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
| Step | Action | Starter kit | Manual |
|---|---|---|---|
| 1 | Deploy BurnMintTokenPool | cct:deploy-burn-mint | Ledger API CreateCommand |
| 2 | Register on TAR | cct:set-token | TAR choices via Ledger API |
| 3 | Enable lane | cct:enable-lane | Rate limiters + ApplyChainUpdates |
| 4 | Go 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:
npm run cct:deploy-burn-mint -- \
--instanceId acme-eur-bm-pool \
--instrument 'yourParty::1220…::token-id'
Flags:
| Flag | Required | Description |
|---|---|---|
--instanceId | Yes | Unique pool instance ID for your party (e.g. acme-eur-bm-pool) |
--instrument | Yes | Canton instrument ID: party::fingerprint::tokenId |
--poolOwner | No | Defaults to party in canton-config.json (must equal instrument admin) |
--ccipOwner | No | Defaults to ccipParty in canton-config.json |
--decimals | No | Token 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.
Submit a CreateCommand for BurnMintTokenPool via your participant's JSON Ledger API (submit-and-wait-for-transaction-tree).
| Argument | Guidance |
|---|---|
instanceId | Unique string for your party, e.g. acme-eur-bm-pool |
poolOwner | Party that owns the pool. Must be the same as instrumentId.admin. |
ccipOwner | Chainlink CCIP owner party from ops |
instrumentId | Your underlying asset's InstrumentId |
decimals | Standard value: 10 |
rateLimitAdmin | Optional — leave unset unless a separate party manages limits |
remoteChainConfigs | Leave empty — configure via ApplyChainUpdates (Step 3) |
tokenTransferFeeConfigs | Optional per-destination fees — set at deploy or via ApplyTokenTransferFeeConfigUpdates |
poolReceiveContext | Leave empty at creation |
transferTimeout | Indefinite to disable expiry on pending outgoing transfers |
deps | tokenAdminRegistry, rmnRemote, feeQuoter references from ops |
After creation, your pool address is {instanceId}@{poolOwner}.
Transfer-fee fields
When setting tokenTransferFeeConfigs (map keyed by destination chain selector):
| Field | Meaning |
|---|---|
isEnabled | Must be true to apply the config |
feeUSDCents | Flat fee in USD cents (non-negative) |
destGasOverhead | Gas for destination execution (> 0 when set via choice) |
destBytesOverhead | Data-availability bytes overhead (≥ 32) |
feeBps | Proportional fee in basis points (< 10000) |
CCIP hosted addresses
| Field | Testnet | Mainnet |
|---|---|---|
| Token Admin Registry | tokenadminregistry-nbehb@ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551 | Contact the CCIP team for the Token Admin Registry address to register a token pool |
| RMNRemote | rmn_remote-pttst@rmnOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551 | rmn_remote-zqxpl@rmnOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093 |
| FeeQuoter | feequoter-koyox@ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551 | feequoter-dwxyx@ccipOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093 |
| CCIP owner party | ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551 | ccipOwner::122012714685760dc1927c4cfe119ce2126c48756154e95c06f5c181da05a5519093 |
| Global EDS | https://eds.testnet.ccip.chain.link | https://eds.ccip.chain.link |
| Indexer | https://indexer-1.testnet.ccip.chain.link | Primary: https://indexer-1.ccip.chain.link · Backup: https://indexer-2.ccip.chain.link |
| Canton chain selector | 9268731218649498074 | 2308837218439511688 |
| Default CommitteeVerifier | committeeverifier-pttst@ccvOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551 | committeeverifier-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.
npm run cct:set-token -- \
--instrument 'yourParty::1220…::token-id' \
--poolInstanceId acme-eur-bm-pool
Flags:
| Flag | Required | Description |
|---|---|---|
--instrument | Yes | Same instrument ID used in Step 1 |
--poolInstanceId | Yes | instanceId from Step 1 |
--poolOwner | No | Party that owns the pool contract (defaults to party in canton-config.json) |
--poolAdmin | No | TAR admin party (defaults to poolOwner) |
--proposeCaller | No | Party that calls ProposeAdministrator (defaults to instrument admin) |
--tokenConfigCid | No | Resume at AcceptAdminRole if ProposeAdministrator already succeeded |
--skipAccept | No | Resume 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>
Fetch TAR explicit disclosure
Your party is not an observer on TAR. Query the Global EDS batch endpoint:
curl --request POST \
--url https://eds.testnet.ccip.chain.link/ccip/v1/global/disclosure/batch \
--header 'content-type: application/json' \
--data '{
"addresses": [
"tokenadminregistry-nbehb@ccipOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551"
]
}'
Include disclosed contracts in subsequent ledger submissions. OpenAPI: eds-global.yaml.
TAR choices
All three choices take a context argument (Splice.Api.Token.MetadataV1.ChoiceContext) — pass an empty context ({"values": {}}) unless your token's tooling supplies one.
ProposeAdministrator— CCIP owner or instrument admin. PassinstrumentId,newAdmin,context,caller. For new instruments, leavetokenConfigCidasNone. ReturnsTokenConfigCID for next steps.AcceptAdminRole— Proposed admin exercises withtokenConfigCid,instrumentId,context,caller.SetPool— Admin links instrument to pool viaPoolRegistration(poolOwner,poolInstanceIdfrom Step 1), pluscontextandcaller.
Admin role can be transferred with TransferAdminRole → AcceptAdminRole.
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
BurnMintFactorycontract and serve it from their EDS — see Serve the factory from your EDS. The reference implementation isLinkRegistry(#link:Link.Token:LinkRegistry) — a custom-token factory that implements bothTransferFactoryandBurnMintFactoryfor 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):
| Argument | Value |
|---|---|
tokenConfigCid | Current TokenConfig CID (re-read it — it rotates on every TAR write) |
instrumentId | Your instrument's InstrumentId |
burnMintFactory | Some + your factory's ContractId, or None to clear |
context | Empty {"values": {}} unless your tooling supplies one |
caller | The 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]):
| Mode | Config | When to use |
|---|---|---|
address | type = "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. |
url | type = "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.
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:
| Flag | Required | Description |
|---|---|---|
--kind | Yes | Token pool family deployed in Step 1: burnMint or lockRelease |
--poolInstanceId | Yes | Token pool instance ID from Step 1 |
--remotePool | Yes | Remote token pool address (0x-hex) — the pool this lane trusts on the remote chain |
--remoteToken | Yes | Remote token address (0x-hex) — the token this lane bridges on the remote chain |
--poolOwner | No | Party that owns the pool contract (defaults to party in canton-config.json) |
--remoteChainSelector | No | Destination chain selector (defaults to the configured remote chain — Sepolia in the starter kit) |
--ccv | No | CommitteeVerifier 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) |
--finality | No | Allowed finality policy for the lane: finalized (default) or blockDepth |
--blockDepth | No | Block depth (1–65535), required with --finality blockDepth |
--limiterInstanceIdPrefix | No | Prefix for the three rate limiter instance IDs (defaults to <poolInstanceId>-<remoteChainSelector>) |
--enableLimiters | No | Deploy the rate limiters enabled (defaults to disabled with zero capacity/rate for testing) |
--capacity | No | Rate limiter capacity in the pool's decimal representation (with --enableLimiters) |
--rate | No | Rate 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.
1. Deploy three rate limiters
Each lane requires RateLimiter contracts (for testing, deploy disabled with zero capacity/rate):
- Inbound (default finality)
- Inbound (custom finality)
- Outbound
Created by poolOwner with matching poolInstanceId, poolOwner, and remoteChainSelector.
2. Apply the chain update
Call ApplyChainUpdates on the pool:
The choice argument is not the pool's remoteChainConfigs map — it takes remoteChainSelectorsToRemove (a list) and chainsToAdd (a list of ChainUpdate records, each carrying its own remoteChainSelector):
{
"commands": [
{
"ExerciseCommand": {
"templateId": "#ccip-burn-mint-token-pool-v2:CCIP.BurnMintTokenPoolV2:BurnMintTokenPool",
"contractId": "<POOL_CONTRACT_ID>",
"choice": "ApplyChainUpdates",
"choiceArgument": {
"remoteChainSelectorsToRemove": [],
"chainsToAdd": [
{
"remoteChainSelector": "16015286601757825753",
"remotePools": ["<REMOTE_POOL_ADDRESS_32_BYTES>"],
"remoteTokenAddress": "<REMOTE_TOKEN_ADDRESS_32_BYTES>",
"inboundCCVs": [
{
"unpack": "committeeverifier-pttst@ccvOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551"
}
],
"outboundCCVs": [
{
"unpack": "committeeverifier-pttst@ccvOwner::1220e382f4e57b0815e6be737006e381e6b7de448e06bd033ece6df498017879f551"
}
],
"finalityConfig": { "tag": "WaitForFinality", "value": {} },
"inboundRateLimiter": { "unpack": "<INBOUND_LIMITER>@<POOL_OWNER>" },
"inboundCustomBlockConfirmationsRateLimiter": { "unpack": "<INBOUND_CUSTOM_LIMITER>@<POOL_OWNER>" },
"outboundRateLimiter": { "unpack": "<OUTBOUND_LIMITER>@<POOL_OWNER>" }
}
]
}
}
}
],
"commandId": "apply-chain-updates",
"actAs": ["<POOL_OWNER_PARTY>"]
}
| ChainUpdate field | Guidance |
|---|---|
remoteChainSelector | Destination chain selector — see CCIP Directory |
remotePools | Remote token pool address(es). Padded to 32 bytes in the case of EVM addresses. |
remoteTokenAddress | Remote token address. Padded to 32 bytes in the case of EVM addresses. |
inboundCCVs / outboundCCVs | Required — the lane has no defaults, so the pool must specify CCVs explicitly. Use the default CommitteeVerifier (testnet address above) unless you run your own. Both directions are required: sending forwards the message to the verifier to generate the verification, and executing verifies it. |
finalityConfig | WaitForFinality for default finalized source tx |
inboundRateLimiter | Inbound default limiter address |
inboundCustomBlockConfirmationsRateLimiter | Inbound custom limiter address |
outboundRateLimiter | Outbound limiter address |
Once applied, the on-ledger lane is complete.
Step 4 — Go live
Verification checklist
InstrumentId.adminequals pool owner.- TAR maps your instrument to your pool with your party as admin.
- Pool exists at
{instanceId}@{poolOwner}with matchingInstrumentId. - 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.