BurnMint Token Pool Deployment (Canton)

Deploy a BurnMint token pool on Canton, register it on the Token Admin Registry (TAR), and enable a cross-chain lane. Use the ccip-starter-kit-canton for pool deployment and TAR registration, or submit Ledger API commands directly.

This guide assumes you already have a token instrument live on Canton — for example a Registry instrument from Digital Asset's Registry utility, or any instrument supporting CIP-56 with the BurnMintFactory interface.

Scope: On-ledger pool connection — deploy, TAR registration (including the BurnMintFactory setup for custom tokens), and lane enablement. Does not cover end-to-end transfer tests.

Prerequisites

  • Instrument (token managed on Canton Ledger) with known InstrumentId = { admin, id }. The admin party must be the same party that will own the token pool.
  • Burn/mint authority — instrumentId.admin == poolOwner (enforced by the BurnMint template and by the starter kit).
  • DARs uploaded and vetted on your participant — the pool DAR, plus ccip-runtime-v2 (required for the pool operator) and the CommitteeVerifier DAR (required for users sending or executing transfers). See Prerequisites (all CCT guides).
  • CCIP contract references from Chainlink ops: CCIP owner party, Token Admin Registry, RMNRemote, FeeQuoter.
  • Starter kit setup (if using cct:* scripts) — complete Canton as Source prerequisites and the CCT overview.

Deployment overview

StepActionStarter kitManual
1Deploy BurnMintTokenPoolcct:deploy-burn-mintLedger API CreateCommand
2Register on TARcct:set-tokenTAR choices via Ledger API
3Enable lanecct:enable-laneRate limiters + ApplyChainUpdates
4Go live—EDS + verification

Step 1 — Deploy the BurnMint Token Pool

Create one BurnMintTokenPool. poolOwner + instanceId uniquely identifies the pool. Signatory: poolOwner.

From the starter kit root:

Terminal
npm run cct:deploy-burn-mint -- \
  --instanceId acme-eur-bm-pool \
  --instrument 'yourParty::1220…::token-id'

Flags:

FlagRequiredDescription
--instanceIdYesUnique pool instance ID for your party (e.g. acme-eur-bm-pool)
--instrumentYesCanton instrument ID: party::fingerprint::tokenId
--poolOwnerNoDefaults to party in canton-config.json (must equal instrument admin)
--ccipOwnerNoDefaults to ccipParty in canton-config.json
--decimalsNoToken decimals on Canton (default 10)

Expected output:

Deploying BurnMint token pool on Canton
   instanceId: acme-eur-bm-pool
   instrument: yourParty::1220…::token-id
   poolOwner:  yourParty::1220…
Canton bearer token obtained via OIDC client credentials.
✅ BurnMintTokenPool contract ID: 00abc…
   Pool address: acme-eur-bm-pool@yourParty::1220…
   Update: https://lighthouse.testnet.cantonloop.com/transactions/…

Next step: register the pool on the Token Admin Registry:
   npm run cct:set-token -- --instrument "yourParty::1220…::token-id" --poolInstanceId "acme-eur-bm-pool" --poolOwner "yourParty::1220…"

Save the pool address ({instanceId}@{poolOwner}) and contract ID for verification.

Transfer-fee fields

When setting tokenTransferFeeConfigs (map keyed by destination chain selector):

FieldMeaning
isEnabledMust be true to apply the config
feeUSDCentsFlat fee in USD cents (non-negative)
destGasOverheadGas for destination execution (> 0 when set via choice)
destBytesOverheadData-availability bytes overhead (≥ 32)
feeBpsProportional fee in basis points (< 10000)

CCIP hosted addresses

FieldTestnetMainnet
Token Admin Registrytokenadminregistry-nbehb@ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551Contact the CCIP team for the Token Admin Registry address to register a token pool
RMNRemotermn_remote-pttst@rmnOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551rmn_remote-zqxpl@rmnOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093
FeeQuoterfeequoter-koyox@ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551feequoter-dwxyx@ccipOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093
CCIP owner partyccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551ccipOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093
Global EDShttps://eds.testnet.ccip.chain.linkhttps://eds.ccip.chain.link
Indexerhttps://indexer-1.testnet.ccip.chain.linkPrimary: https://indexer-1.ccip.chain.link · Backup: https://indexer-2.ccip.chain.link
Canton chain selector92687312186494980742308837218439511688
Default CommitteeVerifiercommitteeverifier-pttst@ccvOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551committeeverifier-vnmkd@ccvOwner::122096accf0a84fc7d80d5fce5ea3135317a03eb22e62e0d8cdd7548865f984f11ff

Step 2 — Register on the Token Admin Registry

TAR maps each instrument to a single token pool. Registration: propose → accept → set pool.

Terminal
npm run cct:set-token -- \
  --instrument 'yourParty::1220…::token-id' \
  --poolInstanceId acme-eur-bm-pool

Flags:

FlagRequiredDescription
--instrumentYesSame instrument ID used in Step 1
--poolInstanceIdYesinstanceId from Step 1
--poolOwnerNoParty that owns the pool contract (defaults to party in canton-config.json)
--poolAdminNoTAR admin party (defaults to poolOwner)
--proposeCallerNoParty that calls ProposeAdministrator (defaults to instrument admin)
--tokenConfigCidNoResume at AcceptAdminRole if ProposeAdministrator already succeeded
--skipAcceptNoResume at SetPool only (skip propose and accept)

The script fetches TAR disclosures from Global EDS, then submits all three TAR choices in sequence.

Expected output:

Registering token pool on the Token Admin Registry (TAR)
   instrument:     yourParty::1220…::token-id
   poolInstanceId: acme-eur-bm-pool
   pool address:   acme-eur-bm-pool@yourParty::1220…
Step 1/3 — ProposeAdministrator on Token Admin Registry
   tokenConfigCid: 00def…
Step 2/3 — AcceptAdminRole on Token Admin Registry
Step 3/3 — SetPool on Token Admin Registry
✅ Token pool registered for yourParty::1220…::token-id
   tokenConfigCid: 00ghi…

Next step: enable a cross-chain lane (remote pool + token are required):
   npm run cct:enable-lane -- --kind <burnMint|lockRelease> --poolInstanceId "acme-eur-bm-pool" \
      --poolOwner "yourParty::1220…" --remotePool <0xREMOTE_POOL> --remoteToken <0xREMOTE_TOKEN>

Configure the BurnMintFactory

BurnMint pools do not burn or mint instrument supply themselves — they call a BurnMintFactory (Splice.Api.Token.BurnMintV1.BurnMintFactory). The factory contract implements the actual burn (send) and mint (execute) operations against your token, and its contract ID is supplied by the user in the choice context at transfer time.

  • Registry instruments (created via Digital Asset's Registry utility) already have a factory — the registry resolves it automatically. No action needed.
  • Custom tokens (any instrument not created via the Registry utility) must deploy their own BurnMintFactory contract and serve it from their EDS — see Serve the factory from your EDS. The reference implementation is LinkRegistry (#link:Link.Token:LinkRegistry) — a custom-token factory that implements both TransferFactory and BurnMintFactory for the LINK instrument on Canton.

Pin the factory on the TAR (optional, advanced)

By default, the factory's contract ID is not pinned on the TAR: the pool calls into whatever BurnMintFactory the user supplies in the choice context, using the pool owner's authority. As long as only trusted DARs are vetted on the pool owner's participant — specifically DARs containing a BurnMintFactory implementation — this is not a concern.

If the pool owner does not fully trust the participant their party is hosted on, they can hard-code the factory's contract ID on the TAR via the SetBurnMintFactory choice. The pool then aborts any transfer where the user-supplied factory does not match the pinned one.

SetBurnMintFactory is exercised by the token admin on the TAR (same disclosure flow as the other TAR choices):

ArgumentValue
tokenConfigCidCurrent TokenConfig CID (re-read it — it rotates on every TAR write)
instrumentIdYour instrument's InstrumentId
burnMintFactorySome + your factory's ContractId, or None to clear
contextEmpty {"values": {}} unless your tooling supplies one
callerThe token admin party

Serve the factory from your EDS

Senders and executors cannot see your factory contract — your pool operator's EDS must supply it in the token pool API response. The reference EDS supports two factory modes per pool ([token_pool_api.token_pools.<address>.factory]):

ModeConfigWhen to use
addresstype = "address", template_id (#package-name:Module:Entity), party, instance_address (0x… hashed form)Your factory is visible to the EDS's participant — EDS reads it directly from the Active Contract Set.
urltype = "url", token_standard_url — on testnet, the DA token-standard backend: https://api.utilities.digitalasset-staging.com (not a validator scan-proxy URL)EDS calls the DA registry backend's getBurnMintFactory endpoint at serve time — no ledger visibility into the factory needed on the EDS's participant.

See the reference configs: eds-token-pools.toml (URL mode) and the EDS config tests (address mode).

Step 3 — Enable a lane

Lane enablement wires your pool to a remote chain: three RateLimiter contracts plus an ApplyChainUpdates exercise on the pool. Use the starter kit or submit the Ledger API commands directly.

Terminal
npm run cct:enable-lane -- \
  --kind burnMint \
  --poolInstanceId acme-eur-bm-pool \
  --remotePool 0x… \
  --remoteToken 0x…

--remotePool and --remoteToken are the token pool and token addresses deployed on the remote chain. EVM addresses are automatically left-padded to the 32-byte form the pool expects.

Flags:

FlagRequiredDescription
--kindYesToken pool family deployed in Step 1: burnMint or lockRelease
--poolInstanceIdYesToken pool instance ID from Step 1
--remotePoolYesRemote token pool address (0x-hex) — the pool this lane trusts on the remote chain
--remoteTokenYesRemote token address (0x-hex) — the token this lane bridges on the remote chain
--poolOwnerNoParty that owns the pool contract (defaults to party in canton-config.json)
--remoteChainSelectorNoDestination chain selector (defaults to the configured remote chain — Sepolia in the starter kit)
--ccvNoCommitteeVerifier raw instance address(es) for both directions (defaults to the CCIP-hosted testnet CCV — the lane itself has no defaults, so manual ApplyChainUpdates must always set inboundCCVs and outboundCCVs explicitly)
--finalityNoAllowed finality policy for the lane: finalized (default) or blockDepth
--blockDepthNoBlock depth (1–65535), required with --finality blockDepth
--limiterInstanceIdPrefixNoPrefix for the three rate limiter instance IDs (defaults to <poolInstanceId>-<remoteChainSelector>)
--enableLimitersNoDeploy the rate limiters enabled (defaults to disabled with zero capacity/rate for testing)
--capacityNoRate limiter capacity in the pool's decimal representation (with --enableLimiters)
--rateNoRate limiter refill per second in the pool's decimal representation (with --enableLimiters)

The script deploys the three rate limiters and exercises ApplyChainUpdates on the pool in one run.

Expected output:

Canton bearer token obtained via OIDC client credentials.
Enabling a cross-chain lane on the token pool
   pool kind:          burnMint
   poolInstanceId:     acme-eur-bm-pool
   poolOwner:          yourParty::1220…
   remoteChainSelector: 16015286601757825753
   remotePools:        0000…1234
   remoteTokenAddress: 0000…5678
   CCVs:               committeeverifier-pttst@ccvOwner::1220e382…
   finalityConfig:     finalized
   limiters:           disabled (zero capacity/rate)
Step 1/2 — Deploy three RateLimiter contracts
   inbound: acme-eur-bm-pool-16015286601757825753-in (isEnabled=false, capacity=0, rate=0)
   inbound contract ID: 00def…
   inbound-custom: acme-eur-bm-pool-16015286601757825753-in-custom (isEnabled=false, capacity=0, rate=0)
   inbound-custom contract ID: 00ghi…
   outbound: acme-eur-bm-pool-16015286601757825753-out (isEnabled=false, capacity=0, rate=0)
   outbound contract ID: 00jkl…
Step 2/2 — ApplyChainUpdates on the token pool
✅ Lane enabled for remote chain 16015286601757825753
   poolContractId: 00abc…
   inbound limiter: acme-eur-bm-pool-16015286601757825753-in@yourParty::1220…
   inbound-custom limiter: acme-eur-bm-pool-16015286601757825753-in-custom@yourParty::1220…
   outbound limiter: acme-eur-bm-pool-16015286601757825753-out@yourParty::1220…
   Update: https://lighthouse.testnet.cantonloop.com/transactions/…

Next step: stand up EDS for your pool and run end-to-end transfer tests.

Step 4 — Go live

Verification checklist

  1. InstrumentId.admin equals pool owner.
  2. TAR maps your instrument to your pool with your party as admin.
  3. Pool exists at {instanceId}@{poolOwner} with matching InstrumentId.
  4. Lane rate limiters are in place.

Stand up EDS for your pool

Users need explicit disclosures for your pool to send and execute transfers. The reference EDS Docker image supports BurnMint out of the box.

Test transactions

See CCIP on Canton — Overview for user flows. Track messages in CCIP Explorer.

What's next

Get the latest Chainlink content straight to your inbox.