Independent open source · Apache-2.0

The native wallet stack for Canton.

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.

API reference See the reference apps
v0.7.0 Canton 3.5.11 – 3.5.12 Maven Central + Swift PM gRPC Ledger API
2platforms, one API: Swift and Kotlin, the same type names on both
397unit tests (Swift 197, Kotlin 200) plus shared golden vectors both must satisfy
4hardware tiers verified on named devices: Secure Enclave, StrongBox, TEE, macOS enclave
11 + 3CIP-0103 methods and events, the whole OpenRPC 0.5.0 surface, dApp and wallet sides
3.5.12Canton, with both integration suites run live against Splice LocalNet 0.7.1
swift CI kotlin CI ios sample app CI android sample app CI generated stubs CI
SwiftSecure Enclave
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)
KotlinStrongBox / TEE
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 official SDKs are TypeScript. Phones are not.

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.

Keys live in silicon

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.

The whole wallet surface

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.

dApps connect natively

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

Hardware claims, tested on hardware.

Apps inherit the claim "hardware-backed" from their SDK. This one proves it at every security tier, on physical devices.

Secure Enclave Apple's dedicated security coprocessor iPhone, on device VERIFIED
StrongBox Dedicated secure element, Android Pixel 11 Pro, on device VERIFIED
Hardware TEE Android Keystore trusted execution environment OnePlus Open, on device VERIFIED
Secure Enclave, macOS Apple silicon Macs, the real enclave Every CI run VERIFIED

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

Works with Canton's official stack. Proven live.

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.

See the working integration →

Compatibility

What it runs against, and on.

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.

SDK0.7.x on Maven Central (io.github.vsima.canton:*) and Swift Package Manager
Canton3.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 standardCIP-0056 holdings, transfers, and preapprovals, verified against the Amulet registry on Splice LocalNet 0.7.1
dApp protocolCIP-0103 as published in OpenRPC 0.5.0, both sides, held to shared golden vectors
AppleiOS 18 and macOS 15 or later; Swift tools 6.0
AndroidAndroid 8.0 (API 26) or later, compileSdk 36; Kotlin 2.4, Java 21 to build
WalletConnectThe adapter depends on no client library; the reference wallets drive it through a Reown WalletKit binding

Security

What the phone will sign, and what it never will.

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.

Keys never leave hardware

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.

Verified before signing

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 may ask, never choose

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

One dependency. Take the layer you need.

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.

Swift Package Manager
dependencies: [
  .package(
    url: "https://github.com/vsima/canton-mobile-sdk.git",
    from: "0.7.0"),
]
// then import CantonWalletKit, CantonDappKit, …
Gradle
dependencies {
    implementation(
        "io.github.vsima.canton:canton-wallet-sdk:0.7.0")
    // + canton-wallet-android for StrongBox / TEE keys
}
I am building…SwiftKotlin
A read-only or backend integrationCantonKitcanton-sdk
A wallet with device-held keysCantonWalletKitcanton-wallet-sdk
A dApp that talks to someone's walletCantonDappKitcanton-dapp
A wallet that accepts dApp connectionsCantonDappWalletKitcanton-dapp-wallet

Requirements: 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

Start from working apps, not a blank page.

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.

SwiftUI · Jetpack Compose

The wallets

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 / TypeScript

The dApp shop

A 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 client

The dApp app

The 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

The agent asks. The human approves. The secure element signs.

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.

agent session canton-agent-mcp · MCP over stdio

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.

Add it to your agenton npm · npx, nothing to clone
# 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

Built in the open, versioned honestly.

Versioning

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.

Releases and notes on GitHub.

Where things stand

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.

Maintainer and contact

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.