Independent open source · Apache-2.0
Swift and Kotlin SDKs for building self-custody wallets on the Canton Network. Keys are created inside the Secure Enclave or Android StrongBox and can never leave the device. Transactions are verified on the phone before the hardware signs. Payments, the token standard, and dApp connections work out of the box, so you build the product, not the plumbing.
import CantonWalletKit
// Created in the Secure Enclave, never exportable
let driver = try SecureEnclaveSigningDriver()
// A party only this device can act for
let party = try await ExternalPartyClient(client: client)
.allocate(driver: driver, synchronizerId: sync,
partyHint: "alice")
// Prepare on the node → re-verify the hash on device
// → sign in hardware → execute
let submission = InteractiveSubmissionClient(client: client)
let tx = try await submission.prepare(
commands: [pay], actAs: party.partyId,
synchronizerId: sync)
try await submission.signAndExecute(
prepared: tx, driver: driver, partyId: party.partyId,
keyFingerprint: party.publicKeyFingerprint)
import io.github.vsima.canton.wallet.*
// Created in StrongBox (TEE fallback), never exportable
val driver = AndroidKeystoreSigningDriver
.generate(alias = "wallet")
// A party only this device can act for
val party = ExternalPartyClient(channel)
.allocate(driver, synchronizerId, partyHint = "alice")
// Prepare on the node → re-verify the hash on device
// → sign in hardware → execute
val submission = InteractiveSubmissionClient(channel)
val tx = submission.prepare(
listOf(pay), party.partyId, synchronizerId)
submission.signAndExecute(
tx, driver, party.partyId, party.publicKeyFingerprint)
One SDK family, two first-class languages. Every release covers Swift and Kotlin together and passes the same test vectors, so your iOS and Android apps always behave the same.
Why native
The ecosystem's @canton-network
SDKs are excellent for Node and the browser. A mobile wallet needs what only
the platform can give: hardware key storage, biometric approval, and
connections that survive real-world mobile networks. This SDK is that layer,
in the languages your team already ships in.
Signing drivers for the Secure Enclave and the Android Keystore
(StrongBox first, TEE fallback), software drivers for tests, and a
DelegatingSigningDriver hook for custody providers.
Your users truly hold their own assets: no server ever sees a key or can move funds on its own, and every transaction is verified on the device by default before the hardware signs it.
Balances, a payment inbox, and transfers with memos on the CIP-0056 token standard. Instant receiving through preapprovals, including cancel. Full transfer history with counterparties and net amounts.
Plus fee previews, name lookups, test funds, traffic purchase, gap-free state sync, and typed errors with retry hints. The feature set of a production wallet, ready before you write your first screen.
Give dApps the standard way in: wallet sign-in, message signing, and one-tap payments over WalletConnect, LAN, or in-process transports, with every request gated by approval screens you control.
Both sides of the CIP-0103 protocol ship in the box, tested against the published spec, so your wallet speaks the same language as the rest of the Canton ecosystem.
Verified where it counts
Apps inherit the claim "hardware-backed" from their SDK. This one proves it at every security tier, on physical devices.
Beyond the key stores, both SDKs run their full integration suites against a live Canton network: onboarding, signing, token transfers, and preapprovals, end to end. Shared test vectors pin the security-critical behavior, like transaction hashing and message signing, so Swift and Kotlin can never quietly drift apart.
Ecosystem compatibility
Compatibility is demonstrated, not promised. The reference storefront is
built on Digital Asset's official
@canton-network
TypeScript SDKs, and it signs users in and takes one-tap WalletConnect
payments from a wallet built on this SDK, end to end, on both platforms.
Build on this SDK and you plug into the same ecosystem every Canton dApp
targets.
Compatibility
The combinations below are the ones CI and the live suites exercise. Other Canton 3.5 minors are expected to work and are not claimed.
| SDK | 0.7.x on Maven Central (io.github.vsima.canton:*) and Swift Package Manager |
| Canton | 3.5.11 to 3.5.12 over the gRPC Ledger API; stubs generated from the 3.5.12 protobuf definitions and checked fresh on every CI run |
| Token standard | CIP-0056 holdings, transfers, and preapprovals, verified against the Amulet registry on Splice LocalNet 0.7.1 |
| dApp protocol | CIP-0103 as published in OpenRPC 0.5.0, both sides, held to shared golden vectors |
| Apple | iOS 18 and macOS 15 or later; Swift tools 6.0 |
| Android | Android 8.0 (API 26) or later, compileSdk 36; Kotlin 2.4, Java 21 to build |
| WalletConnect | The adapter depends on no client library; the reference wallets drive it through a Reown WalletKit binding |
Security
Self-custody is only as good as the rules around the key. These are the ones the SDK enforces, on by default, with tests you can run.
Created in the Secure Enclave, StrongBox, or the TEE keystore and never exportable, backed up, or synced. The achieved tier is reported truthfully, including "software" in a simulator, so an app cannot claim more than the device delivered.
Every externally signed transaction has its prepared-transaction hash recomputed on the device first; the hardware key only signs a hash the phone derived from what it was shown. Sign-in signatures are domain-separated, so one can never double as a transaction signature. The Ledger API connection can be pinned to your operator's CA.
A dApp can request an actAs party and cannot pick one
outside its grant. Grants are per session, ledger tokens are never
handed out, and ledgerApi is read-only by default. The
wallet, not the agent, sets the spending limits an AI agent lives
under.
Audit status. No third-party audit yet. A scoped audit of the signing drivers, hash verification, and the WalletConnect transport is planned, and its report will be linked here. Found something? Report it privately; the security policy says what is in scope and how fast to expect an answer.
Install
Standard tooling, no exotic setup: add one dependency from Maven Central or Swift Package Manager, start at the layer that matches your app, and each layer includes everything beneath it.
dependencies: [
.package(
url: "https://github.com/vsima/canton-mobile-sdk.git",
from: "0.7.0"),
]
// then import CantonWalletKit, CantonDappKit, …
dependencies {
implementation(
"io.github.vsima.canton:canton-wallet-sdk:0.7.0")
// + canton-wallet-android for StrongBox / TEE keys
}
CantonKitcanton-sdkCantonWalletKitcanton-wallet-sdkCantonDappKitcanton-dappCantonDappWalletKitcanton-dapp-walletRequirements: iOS 18+ / macOS 15+ with Swift 6 · Android 8+ (API 26) or any JVM 17+. Coming from the TypeScript SDK? There's a method-by-method migration guide.
Reference apps
Everything on this page runs in complete reference apps: two wallets and a shop, built only on the SDK's public API and verified against a live Canton network. Clone them, run them, and keep what you need.
Complete self-custody wallets for iOS and Android from stock platform components: portfolio, inbox, scan-to-pay, transfer history, and WalletConnect approvals, all signing on the device key.
Node / TypeScriptA storefront on the official @canton-network SDKs that takes a payment and watches the ledger settle it: wallet sign-in, checkout QR codes, and WalletConnect one-tap pay.
CIP-0103 clientThe least a dApp needs: a minimal client built from the dApp module alone, with no path to keys or the ledger. That boundary keeps third-party dApps out of your users' wallets, and CI enforces it on every run.
Agents
Give your users an assistant that can pay, without ever handing it a key. canton-agent-mcp connects any MCP agent to a wallet built on this SDK, and the agent can only ask: every request lands as an approval sheet on the phone, is verified on the device, and is signed in the Secure Enclave or StrongBox. Shown here as it happened, live on both sides at once.
Nothing to trust but the phone. The agent never holds a key or a session token: it names the request, the wallet prepares it on its own participant, re-verifies the transaction hash on device, and StrongBox signs only what the human approved. The QR is real; scan it for the source.
# Claude Code
claude mcp add canton-agent --env WC_PROJECT_ID=<your-project-id> \
-- npx -y canton-agent-mcp
Works with any MCP client. Ready-made configs for Claude Desktop, Cursor, and Codex CLI are in the install guide; the project id is a free, public WalletConnect client key from dashboard.reown.com.
Project
Pre-1.0. A 0.x minor release may change an API and says so in its release notes; a patch release never does. Every release is built into the reference wallets before it is tagged, so the apps are the stability test.
The roadmap lists what has shipped with where each piece was proven, what is next, and what is being explored. The README's feature matrix sets it against the official TypeScript SDK, capability by capability.
Maintained by Victor Sima. Bugs and proposals go to GitHub issues, security reports to private reporting, and everything else to the Canton forum. Contributions are welcome; the README says how.