Grofty Labs LogoGrofty

Transfer Flow

How Canton transactions are prepared, signed locally, and executed.

Prepare → Sign → Execute

All Grofty transactions use a three-step non-custodial flow to ensure your private key never leaves your device:

1. Prepare (Backend)

The backend prepares the Canton transaction — handling Party ID validation, preapproval checks, UTXO selection, fee calculation, and transaction construction. Returns a transaction hash for local signing.

2. Sign (Extension)

The extension decrypts your recovery phrase with your PIN, derives the private key in memory, signs the transaction hash with Ed25519, then immediately discards the private key.

3. Execute (Backend)

The backend submits the signed transaction to Canton Network and tracks confirmation state.

Normal CC Transfer Flow
  1. User enters receiver Party ID, CC amount, and PIN
  2. Extension validates input and unlocks wallet
  3. Extension calls backend: prepare transfer
  4. Backend checks receiver preapproval state
  5. Backend selects UTXO from Canton wallet (UTXO model)
  6. Backend builds fee-aware transfer command via DAML
  7. Backend calls Canton Ledger API to prepare transaction
  8. Backend returns: prepareId, transactionHash, fee details
  9. Extension shows transaction review screen to user
  10. User reviews: receiver Party ID, CC amount, receiver amount, fee
  11. User clicks "Approve & Send"
  12. Extension decrypts recovery phrase from local storage
  13. Extension derives private key in memory (Ed25519)
  14. Extension signs transaction hash
  15. Extension sends signature to backend
  16. Private key is immediately discarded from memory
  17. Backend submits signed transaction to Canton Network
  18. Transaction confirmed on Canton ledger

Transfer Fee Example

Sender enters:      12 CC
Grofty fee:          6 CC
Receiver receives:   6 CC

The amount must be greater than the fee so the receiver receives a positive amount.

In-Wallet Swap Flow (CC ↔ USDCx)
  1. User selects source asset (CC or USDCx) and destination
  2. User enters swap amount
  3. Backend prepares swap order and returns quote with swap fee
  4. User reviews: source amount, destination amount, swap fee
  5. User confirms swap
  6. Extension signs locally (same Prepare → Sign → Execute flow)
  7. Backend executes swap order on Canton
  8. Settled assets appear in wallet balance

Swap fees are separate from normal CC transfer fees.

Demo: Swap CC to USDCx
Bridge Flow

Grofty provides bridge access for moving supported liquidity into Canton from external networks.

  1. User selects source network and asset
  2. User selects Canton as destination
  3. Backend prepares bridge order and returns bridge fee details
  4. User reviews: bridge amount, bridge fee, destination Party ID
  5. User confirms the transaction
  6. Extension signs locally
  7. Backend manages bridge order and cross-chain settlement
  8. Assets appear in Canton wallet after bridge settlement

Bridge fees are separate from swap fees and normal CC transfer fees.

Demo: Bridge Flow
Backend Capabilities
  • Wallet ownership and unlock checks
  • Transaction preparation (CC transfer, swap, bridge)
  • Local signing support through the extension
  • Transaction execution and state tracking
  • Bridge order management
  • Swap order management
  • Fee-aware normal CC transfer handling via DAML
  • Audit-style operational tracking
Security Properties
  • Private key exists in memory for milliseconds only during signing
  • Backend cannot modify transaction after it is prepared and signed
  • Prepared transactions expire — cannot be replayed indefinitely
  • Signature cannot be reused (replay protection)
  • User reviews full transaction details before signing

Import Wallet Flow

Wallet import and credential encryption

Canton Network

Party ID, preapproval, and fee types