# BurnMint Token Pool Deployment (Canton)
Source: https://docs.chain.link/ccip/canton/tutorials/cross-chain-tokens/burn-mint-token-pool
Last Updated: 2026-11-10

> For the complete documentation index, see [llms.txt](/llms.txt).

> **CAUTION**
>
> Addresses shown may change due to upgrades since Canton contracts are immutable. Confirm party IDs and contract addresses with [Chainlink CCIP](https://chain.link/ccip-contact).

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`](https://github.com/smartcontractkit/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](https://docs.digitalasset.com/registry/overview), 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.

> **NOTE: Testnet only**
>
> Starter kit `cct:*` scripts target **Canton testnet** only.

## 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/canton/tutorials/cross-chain-tokens#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](/ccip/canton/tutorials/source/prerequisites) and the [CCT overview](/ccip/canton/tutorials/cross-chain-tokens#starter-kit-cct-scripts).

> **CAUTION: Pool owner trust**
>
> CCIP fully trusts the pool owner party. Whoever owns the pool controls remote-chain configuration, rate limits, fees, and token handling. We strongly recommend pool owner and instrument admin be the same party, decentralized across multiple nodes.

## 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`](https://github.com/smartcontractkit/chainlink-canton/blob/main/contracts/ccip/pools/burn-mint-token-pool/daml/CCIP/BurnMintTokenPoolV2.daml). `poolOwner` + `instanceId` uniquely identifies the pool. Signatory: `poolOwner`.

### Starter kit

From the starter kit root:

```bash filename="Terminal"
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:**

```text
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.

### Manual

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](https://chain.link/ccip-contact) 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**.

### Starter kit

```bash filename="Terminal"
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:**

```text
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>
```

### Manual

### Fetch TAR explicit disclosure

Your party is not an observer on TAR. Query the Global EDS batch endpoint:

```shell
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`](https://github.com/smartcontractkit/chainlink-canton/blob/main/openapi/src/eds/global/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.

1. **`ProposeAdministrator`** — CCIP owner or instrument admin. Pass `instrumentId`, `newAdmin`, `context`, `caller`. For new instruments, leave `tokenConfigCid` as `None`. Returns `TokenConfig` CID for next steps.
2. **`AcceptAdminRole`** — Proposed admin exercises with `tokenConfigCid`, `instrumentId`, `context`, `caller`.
3. **`SetPool`** — Admin links instrument to pool via `PoolRegistration` (`poolOwner`, `poolInstanceId` from Step 1), plus `context` and `caller`.

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](https://docs.digitalasset.com/registry/overview)) 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](#serve-the-factory-from-your-eds). The reference implementation is [`LinkRegistry`](https://github.com/smartcontractkit/chainlink-canton/blob/main/contracts/link/daml/Link/Token.daml) (`#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.

> **CAUTION: Only pin long-lived factories**
>
> Pinning only works if the factory's contract ID will never (or very rarely) change — the same restriction as hard-coding preapprovals in `poolReceiveContext` (see [LockRelease preapprovals](/ccip/canton/tutorials/cross-chain-tokens/lock-release-token-pool#set-pool-receive-preapproval)). If the factory is re-created with a new contract ID, every pinned pool must be updated via `SetBurnMintFactory` before transfers can proceed. Only enable this when you know the factory is long-lived and the trust situation calls for it.

`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                                                  |

> **NOTE: Factory contract shape (address mode)**
>
> If you serve the factory in `address` mode (see below), your factory template must expose a top-level `instanceId : Text` create argument (no `@`) — the EDS Active Contract Set indexer keys contracts by `instanceId@signatory`, so a template without it cannot be disclosed. `LinkRegistry` shows the expected shape: `registryAdmin`, `registryInstrumentId`, `instanceId`, `registryMeta`. This requirement is specific to the reference EDS in `address` mode — in `url` mode the factory is resolved from the DA registry backend instead, and if you bring your own EDS, its factory-serving requirements apply.

### 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. |

> **CAUTION: URL mode resolves registry instruments only**
>
> `url` mode calls the DA registry's `getBurnMintFactory` endpoint, which only resolves factories for **Registry utility instruments**. Custom (non-registry) tokens must use `address` mode with their own factory contract.

See the reference configs: [`eds-token-pools.toml`](https://github.com/smartcontractkit/chainlink-canton/blob/main/eds/testdata/eds-token-pools.toml) (URL mode) and the EDS [config tests](https://github.com/smartcontractkit/chainlink-canton/blob/main/eds/config/config_test.go) (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.

### Starter kit

```bash filename="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:**

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

```text
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.
```

### Manual

### 1. Deploy three rate limiters

Each lane requires [`RateLimiter`](https://github.com/smartcontractkit/chainlink-canton/blob/main/contracts/ccip/rate-limiter/daml/CCIP/RateLimiterV2.daml) 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`](https://github.com/smartcontractkit/chainlink-canton/blob/main/contracts/ccip/pools/burn-mint-token-pool/daml/CCIP/BurnMintTokenPoolV2.daml) 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`):

```json
{
  "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](/ccip/directory/testnet)                                                                                                                                                                                                                            |
| `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

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](/ccip/canton/concepts/explicit-disclosure) for your pool to send and execute transfers. The [reference EDS Docker image](https://github.com/smartcontractkit/chainlink-canton/blob/main/eds/eds.Dockerfile) supports BurnMint out of the box.

### Test transactions

See [CCIP on Canton — Overview](/ccip/canton/concepts/overview) for user flows. Track messages in [CCIP Explorer](/ccip/tools-resources/ccip-explorer).

> **CAUTION: Educational Example Disclaimer**
>
> Please note, this page contains community examples only — these are not Chainlink products or services and are not
> supported or maintained by Chainlink. This code represents an example of using a Chainlink product or service, and is
> intended for demonstration and educational purposes only. It is provided "AS IS" and "AS AVAILABLE" without warranties
> of any kind, may not have been audited, and may omit checks or error handling. Each party intending to use this
> example code does so entirely at their own risk and must perform its own audits, security and code review, key
> management, and testing before any production deployment and ensure the operation and performance of such code matches
> expectations. Neither Chainlink Labs nor the Chainlink Foundation deploys, operates, monitors, maintains or endorses
> any deployment of this code. Note that this is not a Chainlink product, feature or service, and there are no
> commitments made with respect to the code, including compatibility with future Chainlink releases. You should not rely
> on this code without first conducting your own technical, engineering, and security review. This code is also outside
> the scope of any Chainlink bug bounty programs. Neither Chainlink Labs, the Chainlink Foundation, nor Chainlink node
> operators are responsible for outcomes due to errors in this example or how it is deployed or operated, or liable for
> any resulting claims or damages. Use of the Chainlink Network is subject to the Chainlink Foundation [Terms of
> Service](https://chain.link/terms), which provides important information and disclosures. By using this code, you
> acknowledge and agree to these terms.