Version: 1.16.0

Class: EVMTokenManager

Defined in: cct/evm/index.ts:235

CCT admin operations for EVM chains, delegating each op to an operation class.

Extends

TokenManager<typeof EVM>

Constructors

Constructor

new EVMTokenManager(chain: EVMChain): EVMTokenManager

Defined in: cct/evm/index.ts:333

Wraps an EVMChain; prefer the static factory methods.

Parameters

Parameter	Type
`chain`	`EVMChain`

Returns

EVMTokenManager

Overrides

TokenManager<typeof ChainFamily.EVM>.constructor

Properties

chain

readonly chain: EVMChain

Defined in: cct/evm/index.ts:236

Chain this manager builds and submits through.

Overrides

TokenManager.chain

Accessors

provider

Get Signature

get provider(): JsonRpcApiProvider

Defined in: cct/evm/index.ts:357

Provider of the underlying chain.

Returns

JsonRpcApiProvider

Methods

acceptAdmin()

acceptAdmin(opts: EVMExecuteParams<AcceptAdminParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:556

Accepts a pending TokenAdminRegistry administrator role, signing + submitting with opts.wallet (the pending administrator). Completes the registerAdmin/transferAdmin → acceptAdmin handshake, after which setPool becomes callable.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`AcceptAdminParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or sender is not the pending administrator

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

// `wallet` must sign as the pending administrator
const { hash } = await cct.acceptAdmin({
  tokenAddress: '0xToken...',
  address: '0xTokenAdminRegistry...',
  wallet,
})

acceptDefaultAdminTransfer()

acceptDefaultAdminTransfer(opts: EVMExecuteParams<AcceptDefaultAdminTransferParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:910

Completes a pending token-admin transfer, signing + submitting with opts.wallet (the proposed admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`AcceptDefaultAdminTransferParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedAcceptDefaultAdminTransfer for version and delay rules. The contract is the final authority on whether v2's schedule has passed and, on v1, on whether the wallet is the proposed owner.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if any param is invalid, sender differs from the wallet, or on v2 no transfer is pending or the wallet is not its pending default admin

Throws

CCIPExecTxRevertedError if the tx reverts on-chain — notably before v2's delay has passed, or when the wallet is not v1's proposed owner

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.acceptDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  wallet, // pending admin
})

acceptPoolOwnership()

acceptPoolOwnership(opts: EVMExecuteParams<AcceptPoolOwnershipParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:694

Completes a pending pool ownership transfer, signing + submitting with opts.wallet — which must be the address transferPoolOwnership proposed. Ownership moves in this tx, and a wallet that is not the proposed owner reverts rather than failing validation, per generateUnsignedAcceptPoolOwnership.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`AcceptPoolOwnershipParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if poolAddress is invalid, or sender is given and is not the wallet's address

Throws

CCTTxFailedError if the tx reverts or fails — notably when the wallet is not the pool's proposed owner

Example

TypeScript

const { hash } = await cct.acceptPoolOwnership({
  poolAddress: '0xPool...',
  wallet, // the proposed owner
})

acceptTokenOwnership()

acceptTokenOwnership(opts: EVMExecuteParams<AcceptDefaultAdminTransferParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:780

Completes a pending token-admin transfer, signing + submitting with opts.wallet — which must be the proposed admin. Admin rights move in this tx.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`AcceptDefaultAdminTransferParams`>

Returns

Promise<TransactionResult>

Deprecated

Use acceptDefaultAdminTransfer.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if tokenAddress is invalid, sender is given and is not the wallet's address, or per acceptDefaultAdminTransfer

Throws

CCTTxFailedError if the tx reverts or fails — notably when the wallet is not the token's proposed admin

Example

TypeScript

const { hash } = await cct.acceptTokenOwnership({
  tokenAddress: '0xToken...',
  wallet, // the proposed owner
})

addRemotePool()

addRemotePool(opts: EVMExecuteParams<RemotePoolParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:4053

Authorizes an additional remote pool on one lane of a v1.5.1+ pool, signing + submitting with opts.wallet. See generateUnsignedAddRemotePool for the version range, the remotePoolAddress encoding and the duplicate pre-check.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RemotePoolParams`>

Returns

Promise<TransactionResult>

Remarks

sender defaults to the signing wallet, which must be the pool owner; passing a different sender is rejected rather than signed — build with generateUnsignedAddRemotePool for externally-signed flows.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address / the pool owner, or remotePoolAddress is already registered on that lane

Throws

CCTOperationUnsupportedError if the pool is v1.5.0

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.addRemotePool({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  remotePoolAddress: '0xNewRemotePool...',
  wallet, // the pool owner
})

applyAllowlistUpdates()

applyAllowlistUpdates(opts: EVMExecuteParams<ApplyAllowlistUpdatesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:4283

Removes and adds entries in the pool's sender allowlist, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must own the allowlist holder: the pool on v1.5.0–v1.6.1, its bound AdvancedPoolHooks on v2.0.0.

removes are applied before adds on-chain, so an address listed in both would end up allowlisted; that is rejected, as are duplicates and the zero address. The holder must have an allowlist enabled (allowlistEnabled is immutable — a holder deployed without one can never gain it), and every entry must change state: the current allowlist is read first, and a removes that is not allowlisted or an adds that already is fails here rather than mining as a no-op.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ApplyAllowlistUpdatesParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool with no hooks bound

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet is not the holder's owner, it has no allowlist enabled, or an entry would be a no-op (see EVMTokenManager.generateUnsignedApplyAllowlistUpdates)

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.applyAllowlistUpdates({
  poolAddress: '0xPool...',
  removes: ['0xRevoked...'],
  adds: ['0xNewSender...'],
  wallet,
})

applyCCVConfigUpdates()

applyCCVConfigUpdates(opts: EVMExecuteParams<ApplyCCVConfigUpdatesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1702

Replaces per-chain CCV requirements, signing + submitting as the hooks owner. Use generateUnsignedApplyCCVConfigUpdates for multisig or offline signing.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ApplyCCVConfigUpdatesParams`>

Returns

Promise<TransactionResult>

Remarks

Base CCVs apply to every transfer; threshold CCVs add requirements only above the hooks' configured threshold. sender defaults to the wallet address and, when supplied, must equal it. address(0) in any list selects the default CCV. The target is probed to confirm it is an AdvancedPoolHooks contract.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, CCVs are duplicated, a threshold list lacks base CCVs, poolAddress has no hooks bound, sender differs from the wallet, or the wallet is not the hooks owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.applyCCVConfigUpdates({
  advancedPoolHooks: '0xHooks...',
  ccvConfigArgs: [{
    remoteChainSelector: 5009297550715157269n,
    outboundCCVs: ['0xCCV...'],
    thresholdOutboundCCVs: [],
    inboundCCVs: [],
    thresholdInboundCCVs: []
  }],
  wallet,
})

applyChainUpdates()

applyChainUpdates(opts: EVMExecuteParams<ApplyChainUpdatesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:4152

Applies the pool's remote-lane configuration, signing + submitting with opts.wallet.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ApplyChainUpdatesParams`>

Returns

Promise<TransactionResult>

Remarks

Same params as generateUnsignedApplyChainUpdates — see there for how a v1.5.0 pool is handled. opts.sender defaults to the wallet's own address (the only address onlyOwner can pass) and is rejected if it differs, so the wallet must be the pool owner.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, a lane lists several remote pools for a v1.5.0 pool, or sender is given and is not the wallet address / pool owner. As with generateUnsignedApplyChainUpdates, an enabled rate limiter on a v1.5.0 or v1.5.1 pool must satisfy the stricter 0 < rate < capacity.

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

// `wallet` must sign as the pool owner
const { hash } = await cct.applyChainUpdates({
  poolAddress: '0xPool...',
  remoteChainSelectorsToRemove: [],
  chainsToAdd: [
    {
      remoteChainSelector: 16015286601757825753n,
      remoteTokenAddress: '0xRemoteToken...',
      remotePoolAddresses: ['0xRemotePool...'],
      inboundRateLimiterConfig: { enabled: false },
      outboundRateLimiterConfig: { enabled: false },
    },
  ],
  wallet,
})

applyTokenTransferFeeConfigUpdates()

applyTokenTransferFeeConfigUpdates(opts: EVMExecuteParams<ApplyTokenTransferFeeConfigUpdatesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1407

Updates or disables token-transfer fees for destination chains on a v2.0.0 pool.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ApplyTokenTransferFeeConfigUpdatesParams`>

Returns

Promise<TransactionResult>

Remarks

Each remote selector appears once across updates and disables. Every update must set isEnabled to true; disables removes its config. The signing wallet must be the pool owner.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, sender differs from the wallet, or the wallet holds neither role

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.applyTokenTransferFeeConfigUpdates({
  poolAddress: '0xPool...',
  updates: [{
    remoteChainSelector: 16015286601757825753n,
    tokenTransferFeeConfig: {
      destGasOverhead: 100_000,
      destBytesOverhead: 32,
      finalityFeeUSDCents: 10,
      fastFinalityFeeUSDCents: 20,
      finalityTransferFeeBps: 25,
      fastFinalityTransferFeeBps: 50,
      isEnabled: true,
    },
  }],
  disables: [5009297550715157269n],
  wallet, // pool owner
})

approveToken()

approveToken(opts: EVMExecuteParams<ApproveTokenParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2154

Grants an ERC-20 allowance, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the allowance comes out of the signing account's balance, so approving on behalf of another address is rejected rather than signed.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ApproveTokenParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or sender is given and is not the wallet's address

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.approveToken({
  tokenAddress: '0xToken...',
  spender: '0xPool...',
  amount: 1_000000000000000000n,
  wallet, // the rebalancer
})

beginDefaultAdminTransfer()

beginDefaultAdminTransfer(opts: EVMExecuteParams<BeginDefaultAdminTransferParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:846

Proposes a new token admin, signing + submitting with opts.wallet (the current admin: v2 default admin, v1 owner).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`BeginDefaultAdminTransferParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedBeginDefaultAdminTransfer for version, delay, and zero-address rules. sender defaults to the wallet address, so the admin gate runs before broadcast.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if any param is invalid, sender differs from the wallet, or per generateUnsignedBeginDefaultAdminTransfer

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.beginDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  newAdmin: '0xNewAdmin...',
  wallet, // current admin
})

cancelDefaultAdminTransfer()

cancelDefaultAdminTransfer(opts: EVMExecuteParams<CancelDefaultAdminTransferParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:971

Cancels a pending token-admin transfer, signing + submitting with opts.wallet (the current admin: v2 default admin, v1 owner).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`CancelDefaultAdminTransferParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedCancelDefaultAdminTransfer for version and pending-transfer rules.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if any param is invalid, sender differs from the wallet, no v2 transfer is pending, the token has no current default admin, or the wallet is not the current admin

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.cancelDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  wallet, // current admin
})

configureSiloedLockboxes()

configureSiloedLockboxes(opts: EVMExecuteParams<ConfigureSiloedLockboxesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2868

Binds lanes of a v2.0.0 siloed pool to their lockboxes, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it: the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ConfigureSiloedLockboxesParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError below v2.0.0

Throws

CCTParamsInvalidError if any param is invalid, a lockbox fails its checks, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.configureSiloedLockboxes({
  poolAddress: '0xPool...',
  lockboxConfigs: [{ remoteChainSelector: 16015286601757825753n, lockbox: '0xLockbox...' }],
  wallet, // the pool owner
})

deployAdvancedPoolHooks()

deployAdvancedPoolHooks(opts: EVMExecuteParams<DeployAdvancedPoolHooksParams>): Promise<DeployResult>

Defined in: cct/evm/index.ts:1554

Deploys an AdvancedPoolHooks contract: the allowlist + CCV + policy-engine layer a v2.0.0 pool delegates to.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`DeployAdvancedPoolHooksParams`>

Returns

Promise<DeployResult>

Remarks

Returns the deployed address plus the verification input (contract name and ABI-encoded constructor args) a block explorer needs to verify the source.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any address is invalid, zero or duplicated, or thresholdAmount is not a uint256

Throws

CCTTxFailedError if the tx reverts, fails, or mines without an address

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
// thresholdAmount and policyEngine default to off
const { hash, contractAddress, verification } = await cct.deployAdvancedPoolHooks({
  allowlist: ['0xSender...'],
  authorizedCallers: ['0xPool...'],
  wallet,
})

deployLockbox()

deployLockbox(opts: EVMExecuteParams<DeployLockboxParams>): Promise<DeployResult>

Defined in: cct/evm/index.ts:3595

Deploys an ERC20LockBox (v2.0.0), signing + submitting with opts.wallet; resolves to the tx hash, the newly deployed lockbox address, and a verification (ExplorerVerificationInput) for verifying the source on a block explorer.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`DeployLockboxParams`>

Returns

Promise<DeployResult>

Remarks

Step two of the lock/release flow: deployToken → deployLockbox → deployTokenPool (passing this lockbox) → updateLockboxAuthorizedCallers (addedCallers: [pool], plus whoever funds it) → setPool → configure lanes → depositToLockbox. The deposit is not optional: a v2.0.0 pool cannot release until its lockbox holds liquidity.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTTxFailedError if the tx reverts, fails, or mines with no, invalid, or unexpected contract address

Example

TypeScript

const { hash, contractAddress, verification } = await cct.deployLockbox({
  token: '0xToken...',
  wallet,
})

deployToken()

deployToken(opts: EVMExecuteParams<DeployTokenParams>): Promise<DeployResult>

Defined in: cct/evm/index.ts:2967

Deploys a CrossChainToken (v2.0.0), signing + submitting with opts.wallet; resolves to the tx hash, the newly deployed token address, and a verification (ExplorerVerificationInput) for verifying the source on a block explorer.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`DeployTokenParams`>

Returns

Promise<DeployResult>

Remarks

Mint/burn are role-gated (MINTER_ROLE/BURNER_ROLE); the token grants neither to any pool at deploy. preMint mints initial supply to preMintRecipient, but before a pool can bridge, burnMintRoleAdmin must grantMintAndBurnRoles(pool).

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTTxFailedError if the tx reverts, fails, or mines with no, invalid, or unexpected contract address

Example

TypeScript

const { hash, contractAddress, verification } = await cct.deployToken({
  name: 'My Token',
  symbol: 'MTK',
  decimals: 18,
  maxSupply: 0n,
  owner: '0xOwner...',
  wallet,
})

deployTokenPool()

deployTokenPool(opts: EVMExecuteParams<DeployTokenPoolParams>): Promise<DeployResult>

Defined in: cct/evm/index.ts:3549

Deploys a token pool, signing + submitting with opts.wallet; resolves to the tx hash, the newly deployed pool address, and a verification (ExplorerVerificationInput) for verifying the source on a block explorer. type selects the pool contract (a DeployableTokenPoolType, v2.0.0).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`DeployTokenPoolParams`>

Returns

Promise<DeployResult>

Remarks

Deploying the pool alone doesn't make it usable: register it with setPool, grant it the token's mint/burn roles (grantMintAndBurnRoles), and configure its remote pools + rate limits before it can bridge. LockReleaseTokenPool also needs a pre-deployed lockbox and the pool authorized on it (DeployLockReleaseTokenPoolParams). The full sequence: deployToken → deployLockbox → deployTokenPool (passing the lockbox) → updateLockboxAuthorizedCallers (addedCallers: [pool], plus whoever funds it) → setPool → configure lanes → depositToLockbox. The deposit is not optional: a v2.0.0 pool cannot release until its lockbox holds liquidity. SiloedLockReleaseTokenPool takes no lockbox; its lockboxes are bound per lane after deploy with configureSiloedLockboxes (see DeploySiloedLockReleaseTokenPoolParams).

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTTxFailedError if the tx reverts, fails, or mines with no, invalid, or unexpected contract address

Example

TypeScript

const { hash, contractAddress, verification } = await cct.deployTokenPool({
  type: 'LockReleaseTokenPool',
  token: '0xToken...',
  localTokenDecimals: 18,
  rmnProxy: '0xRmnProxy...',
  router: '0xRouter...',
  lockbox: '0xLockbox...', // required for LockReleaseTokenPool; must be a non-zero address
  wallet,
})

depositToLockbox()

depositToLockbox(opts: EVMExecuteParams<DepositToLockboxParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3796

Deposits tokens into an ERC20LockBox, signing + submitting with opts.wallet (an authorized caller of the lockbox, which must have approved it for amount).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`DepositToLockboxParams`>

Returns

Promise<TransactionResult>

Remarks

Approve first with approveToken, naming the lockbox as spender.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or the wallet is not an authorized caller of the lockbox

Throws

CCTTxFailedError if the wallet's balance or its allowance to the lockbox is below amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

await cct.approveToken({ tokenAddress: token, spender: lockbox, amount, wallet })
const { hash } = await cct.depositToLockbox({
  lockbox,
  token,
  amount,
  wallet,
})

generateUnsignedAcceptAdmin()

generateUnsignedAcceptAdmin(opts: AcceptAdminParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:533

Builds an unsigned acceptAdminRole tx (for multisig / offline signing). Second half of the two-step admin handshake: a registry module's registerAdmin (fresh registration) or the current admin's transferAdmin (hand-off) proposes opts.sender as pendingAdministrator; acceptAdmin then confirms it on-chain before encoding, after which setPool becomes callable by the new administrator.

Parameters

Parameter	Type
`opts`	`AcceptAdminParams`

Returns

Promise<UnsignedEVMTx>

Throws

CCTParamsInvalidError if any param is invalid, or sender is not the pending administrator

Example

TypeScript

// `sender` must be the pending administrator proposed by registerAdmin/transferAdmin
const unsigned = await cct.generateUnsignedAcceptAdmin({
  tokenAddress: '0xToken...',
  address: '0xTokenAdminRegistry...', // the TAR, or a Router/pool to resolve it from
  sender: '0xPendingAdmin...',
})

generateUnsignedAcceptDefaultAdminTransfer()

generateUnsignedAcceptDefaultAdminTransfer(opts: AcceptDefaultAdminTransferParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:876

Builds an unsigned token-admin acceptance (for multisig / offline signing): acceptDefaultAdminTransfer on a v2.0.0 CrossChainToken, whose contract enforces its mandatory delay when mined, or Ownable2Step acceptOwnership on a v1.x FactoryBurnMintERC20.

Parameters

Parameter	Type
`opts`	`AcceptDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v2's pending admin and schedule are public, so this rejects a missing transfer or a known sender other than the pending admin before signing. It cannot safely reject a schedule that has not passed yet: an offline tx may be executed after it does. v1's pending owner has no getter, so sender only sets tx.from there.

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if no v2 transfer is pending, it schedules renunciation, or sender is not its pending default admin

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedAcceptDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  sender: '0xPendingAdmin...',
})

generateUnsignedAcceptPoolOwnership()

generateUnsignedAcceptPoolOwnership(opts: AcceptPoolOwnershipParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:671

Builds an unsigned pool acceptOwnership tx (for multisig / offline signing), completing a transfer proposed by generateUnsignedTransferPoolOwnership. Probes the pool's on-chain typeAndVersion, which confirms the address is a supported CCT pool — the acceptOwnership() calldata itself is one fixed selector at every version.

Parameters

Parameter	Type
`opts`	`AcceptPoolOwnershipParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Nothing about the caller can be pre-flighted: the pool authorizes this against a private pending-owner slot with no getter, so a tx signed by anyone other than the proposed owner is only rejected on-chain. sender therefore just sets tx.from.

Throws

CCTParamsInvalidError if poolAddress or sender is invalid

Throws

CCTContractTypeInvalidError if poolAddress is not a supported pool type

Example

TypeScript

// signed by the address a previous transferPoolOwnership proposed
const unsigned = await cct.generateUnsignedAcceptPoolOwnership({
  poolAddress: '0xPool...',
  sender: '0xProposedOwner...',
})

generateUnsignedAcceptTokenOwnership()

generateUnsignedAcceptTokenOwnership(opts: AcceptDefaultAdminTransferParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:758

Builds an unsigned acceptance of a pending token-admin transfer (for multisig / offline signing), on either token version.

Parameters

Parameter	Type
`opts`	`AcceptDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Deprecated

Use generateUnsignedAcceptDefaultAdminTransfer; this builds exactly what it does.

Example

TypeScript

const unsigned = await cct.generateUnsignedAcceptTokenOwnership({
  tokenAddress: '0xToken...',
  sender: '0xProposedOwner...',
})

generateUnsignedAddRemotePool()

generateUnsignedAddRemotePool(opts: RemotePoolParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:4024

Builds an unsigned pool addRemotePool tx (for multisig / offline signing), authorizing one more remote pool on a lane.

Parameters

Parameter	Type
`opts`	`RemotePoolParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 and later pools. From v1.5.1 a lane holds a set of remote pools, which is what makes a zero-downtime remote-side pool upgrade possible: add the new pool, drain the old one, then removeRemotePool. A v1.5.0 pool has no additive primitive and throws CCTOperationUnsupportedError — it only supports the wholesale setRemotePool.

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the pool owner, or remotePoolAddress is already registered on that lane

Throws

CCTOperationUnsupportedError if the pool is v1.5.0

Throws

CCTContractTypeInvalidError if poolAddress is not a supported pool type

Example

TypeScript

const unsigned = await cct.generateUnsignedAddRemotePool({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n, // ethereum-testnet-sepolia
  remotePoolAddress: '0xNewRemotePool...',
  sender: '0xPoolOwner...',
})

generateUnsignedApplyAllowlistUpdates()

generateUnsignedApplyAllowlistUpdates(opts: ApplyAllowlistUpdatesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:4249

Builds an unsigned applyAllowListUpdates tx (for multisig / offline signing): removes and adds entries in the pool's sender allowlist in one call. Probes the pool's on-chain typeAndVersion to resolve which contract holds its allowlist.

Parameters

Parameter	Type
`opts`	`ApplyAllowlistUpdatesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The target moved in v2.0.0. On v1.5.0–v1.6.1 the tx goes to the pool, gated on the pool owner. A v2.0.0 pool has no allowlist of its own: the tx goes to its bound AdvancedPoolHooks (see EVMTokenManager.getAdvancedPoolHooks), gated on the hooks owner, and changes the allowlist of every pool bound to those hooks. A v2.0.0 pool with no hooks bound is reported unsupported.

removes are applied before adds on-chain. Either array may be omitted (defaults to []), but at least one address is required across both. They must hold no duplicates and no zero address, and share no address — an address in both would end up allowlisted (removes run first), which no caller can reasonably have meant.

The holder must have been deployed with an allowlist (allowlistEnabled is immutable, and the call reverts AllowListNotEnabled when false), and the update must actually change state: the current allowlist is read first, and an entry the holder would silently ignore — a removes that is not allowlisted, an adds that already is — is rejected here.

Owner-only (applyAllowListUpdates is onlyOwner). When sender is supplied it is checked against the holder's owner() before any calldata is built; omit it and no owner read is made (nothing to compare against).

Throws

CCTOperationUnsupportedError on a v2.0.0 pool with no hooks bound

Throws

CCTParamsInvalidError if any param is invalid, poolAddress is the zero address, both arrays are empty or omitted, an array holds duplicates or the zero address, an address appears in both arrays, the holder has no allowlist enabled, a removes entry is not currently allowlisted, an adds entry already is, or sender is given and is not the holder's owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the holder's owner.
const unsigned = await cct.generateUnsignedApplyAllowlistUpdates({
  poolAddress: '0xPool...',
  removes: ['0xRevoked...'],
  adds: ['0xNewSender...'],
  sender: '0xOwner...',
})

generateUnsignedApplyCCVConfigUpdates()

generateUnsignedApplyCCVConfigUpdates(opts: ApplyCCVConfigUpdatesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1661

Builds an unsigned applyCCVConfigUpdates tx (for multisig / offline signing); use applyCCVConfigUpdates to sign and submit it directly.

Parameters

Parameter	Type
`opts`	`ApplyCCVConfigUpdatesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Each entry replaces one remote chain's complete base and threshold CCV lists. Threshold lists require a non-empty matching base list; CCVs cannot repeat within or across those paired lists. address(0) in any list selects the default CCV. The target is probed to confirm it reports AdvancedPoolHooks before calldata is returned.

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, CCVs are duplicated, a threshold list lacks base CCVs, poolAddress has no hooks bound, or sender is not the hooks owner

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedApplyCCVConfigUpdates({
  advancedPoolHooks: '0xHooks...',
  ccvConfigArgs: [{
    remoteChainSelector: 5009297550715157269n,
    outboundCCVs: ['0xCCV...'],
    thresholdOutboundCCVs: [],
    inboundCCVs: [],
    thresholdInboundCCVs: []
  }],
  sender: '0xOwner...',
})

generateUnsignedApplyChainUpdates()

generateUnsignedApplyChainUpdates(opts: ApplyChainUpdatesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:4204

Builds an unsigned pool applyChainUpdates tx (for multisig / offline signing), configuring, enabling and disabling the pool's remote lanes: remote token, remote pool(s), and both directional rate limits.

Parameters

Parameter	Type
`opts`	`ApplyChainUpdatesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

One parameter shape for every pool version: removals in remoteChainSelectorsToRemove, additions in chainsToAdd, each addition carrying plural remotePoolAddresses — the contract's own signature from v1.5.1 up (v1.6.0, v1.6.1 and v2.0.0 included). A v1.5.0 pool, detected from its on-chain typeAndVersion (a read this op makes anyway), has an older signature, so the params are adapted to its single chains array: each removal becomes an allowed: false lane, each addition an allowed: true lane. A v1.5.0 pool holds a single remote pool per lane, so there each remotePoolAddresses must have exactly one entry.

Rate limits use the SDK's enabled spelling, not the ABI's isEnabled, matching the Solana counterpart; amounts are in the token's smallest unit. Pass opts.sender to pre-flight it against the pool's owner() — applyChainUpdates is onlyOwner.

Throws

CCTParamsInvalidError if any param is invalid, a lane lists several remote pools for a v1.5.0 pool, or sender is not the pool owner. An enabled rate limiter must have rate <= capacity on every version; on a v1.5.0, v1.5.1 or v1.6.0 pool the bound is stricter (0 < rate < capacity), so a rate of 0n or a rate equal to capacity is also rejected there — v1.6.1 and v2.0.0 allow both.

Each lane array must also be dense (no holes) and free of repeated selectors, and a lane being added may not use the 0n selector — the contract would accept it as a permanently unroutable lane rather than reverting. remoteChainSelectorsToRemove still accepts 0n, so a pool already holding such a lane can be repaired; listing one selector in both chainsToAdd and remoteChainSelectorsToRemove remains the wholesale-replace idiom.

Throws

CCTContractTypeInvalidError if poolAddress is not a supported pool type

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

Enabling a lane while retiring an old one — the same call for any pool version:

TypeScript

const unsigned = await cct.generateUnsignedApplyChainUpdates({
  poolAddress: '0xPool...',
  sender: '0xPoolOwner...',
  remoteChainSelectorsToRemove: [3478487238524512106n], // arbitrum-sepolia
  chainsToAdd: [
    {
      remoteChainSelector: 16015286601757825753n, // ethereum-sepolia
      remoteTokenAddress: '0xRemoteToken...',
      remotePoolAddresses: ['0xRemotePool...'],
      inboundRateLimiterConfig: { enabled: true, capacity: 100_000_000n, rate: 167_000n },
      outboundRateLimiterConfig: { enabled: false },
    },
  ],
})

generateUnsignedApplyTokenTransferFeeConfigUpdates()

generateUnsignedApplyTokenTransferFeeConfigUpdates(opts: ApplyTokenTransferFeeConfigUpdatesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1361

Builds an unsigned v2.0.0 pool token-transfer-fee update transaction.

Parameters

Parameter	Type
`opts`	`ApplyTokenTransferFeeConfigUpdatesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Each remote selector appears once across updates and disables. Every update must set isEnabled to true; disables removes its config. The pool owner may submit it, and sender, when supplied, is pre-flighted against that role.

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid or sender is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedApplyTokenTransferFeeConfigUpdates({
  poolAddress: '0xPool...',
  updates: [{
    remoteChainSelector: 16015286601757825753n,
    tokenTransferFeeConfig: {
      destGasOverhead: 100_000,
      destBytesOverhead: 32,
      finalityFeeUSDCents: 10,
      fastFinalityFeeUSDCents: 20,
      finalityTransferFeeBps: 25,
      fastFinalityTransferFeeBps: 50,
      isEnabled: true,
    },
  }],
  disables: [],
  sender: '0xOwner...',
})

generateUnsignedApproveToken()

generateUnsignedApproveToken(opts: ApproveTokenParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2129

Builds an unsigned ERC-20 approve tx (for multisig / offline signing): grants spender an allowance over sender's tokens.

Parameters

Parameter	Type
`opts`	`ApproveTokenParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The prerequisite for generateUnsignedProvideLiquidity — a pool deposits with safeTransferFrom, so a rebalancer must approve the pool for at least the deposit first, or the deposit reverts ERC20InsufficientAllowance. The cross-family counterpart of Solana's approveToken, which delegates SPL spend authority for the same reason.

Throws

CCTParamsInvalidError if tokenAddress or spender is invalid or zero, or amount is not a uint256

Example

TypeScript

// approve a LockRelease pool for a deposit, then deposit
await cct.approveToken({ tokenAddress: token, spender: pool, amount, wallet })
await cct.provideLiquidity({ poolAddress: pool, amount, wallet })

generateUnsignedBeginDefaultAdminTransfer()

generateUnsignedBeginDefaultAdminTransfer(opts: BeginDefaultAdminTransferParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:812

Builds an unsigned token-admin proposal (for multisig / offline signing): beginDefaultAdminTransfer on a v2.0.0 CrossChainToken, whose proposed admin accepts only after the token's mandatory delay, or Ownable2Step transferOwnership on a v1.x FactoryBurnMintERC20. generateUnsignedAcceptDefaultAdminTransfer builds the second tx.

Parameters

Parameter	Type
`opts`	`BeginDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

On v2, newAdmin = 0x0 deliberately schedules default-admin renunciation, completed with renounceRole, not acceptDefaultAdminTransfer. Replacing a pending transfer is valid and cancels the old proposal on-chain. On v1, where a zero proposal would retract, zero is rejected: use generateUnsignedCancelDefaultAdminTransfer.

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if any address is invalid, a v2 token has no current default admin, sender is not the current admin, or a v1 newAdmin is zero or the owner

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedBeginDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  newAdmin: '0xNewAdmin...',
  sender: '0xCurrentAdmin...',
})

generateUnsignedCancelDefaultAdminTransfer()

generateUnsignedCancelDefaultAdminTransfer(opts: CancelDefaultAdminTransferParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:938

Builds an unsigned token-admin cancellation (for multisig / offline signing): cancelDefaultAdminTransfer on a v2.0.0 CrossChainToken, Ownable2Step transferOwnership(0x0) on a v1.x FactoryBurnMintERC20.

Parameters

Parameter	Type
`opts`	`CancelDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

On v2, a cancellation with no pending transfer is rejected even though OpenZeppelin would mine it as a silent no-op. v1's pending owner has no getter, so this is not checked there.

Throws

CCTContractVersionUnsupportedError if a CrossChainToken reports an unknown version

Throws

CCTParamsInvalidError if no v2 transfer is pending, the token has no current default admin, or sender is not the current admin (v2 default admin, v1 owner)

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedCancelDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  sender: '0xCurrentAdmin...',
})

generateUnsignedConfigureSiloedLockboxes()

generateUnsignedConfigureSiloedLockboxes(opts: ConfigureSiloedLockboxesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2841

Builds an unsigned pool configureLockBoxes tx (for multisig / offline signing): binds lanes of a SiloedLockReleaseTokenPool (v2.0.0) to the ERC20LockBoxes their transfers escrow through. Lanes may share a lockbox or each get their own.

Parameters

Parameter	Type
`opts`	`ConfigureSiloedLockboxesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Owner-only. A lane can be re-bound but never unbound, and a lane with no lockbox reverts LockBoxNotConfigured on every transfer. Each lockbox is read before any calldata is built: it must be an ERC20LockBox escrowing the pool's token. A binding already in place is rejected as a no-op.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool, or a lockbox address is some other contract

Throws

CCTOperationUnsupportedError below v2.0.0, where a siloed pool holds its silos itself (see updateSiloDesignations)

Throws

CCTParamsInvalidError if any param is invalid, a lane is zero or listed twice, a lockbox is zero, not a contract, escrows another token or is already bound to that lane, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool or a lockbox reports an unknown version

Example

TypeScript

// build only, sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedConfigureSiloedLockboxes({
  poolAddress: '0xPool...',
  lockboxConfigs: [{ remoteChainSelector: 16015286601757825753n, lockbox: '0xLockbox...' }],
  sender: '0xOwner...',
})

generateUnsignedDeployAdvancedPoolHooks()

generateUnsignedDeployAdvancedPoolHooks(opts: DeployAdvancedPoolHooksParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1521

Builds an unsigned AdvancedPoolHooks deployment tx (for multisig / offline signing).

Parameters

Parameter	Type
`opts`	`DeployAdvancedPoolHooksParams`

Returns

Promise<UnsignedEVMTx>

Remarks

A v2.0.0 pool holds no sender allowlist and no CCV configuration itself — both live on this contract. Deploy it, then bind it with updateAdvancedPoolHooks (or pass its address as deployTokenPool's advancedPoolHooks). The hooks' configuration methods take the hooks' own advancedPoolHooks or a bound pool's poolAddress, so hooks can be configured before binding.

Throws

CCTParamsInvalidError if any address is invalid, zero or duplicated, or thresholdAmount is not a uint256

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
// allowlist, thresholdAmount and policyEngine default to off
const unsigned = await cct.generateUnsignedDeployAdvancedPoolHooks({
  authorizedCallers: ['0xPool...'],
  sender: '0xDeployer...',
})

generateUnsignedDeployLockbox()

generateUnsignedDeployLockbox(opts: DeployLockboxParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3569

Builds an unsigned ERC20LockBox (v2.0.0) deployment tx (for multisig / offline signing). A lockbox escrows a single token for LockReleaseTokenPools. The deployed address is only known once mined, so it is NOT returned here — use deployLockbox to receive { hash, contractAddress, verification }.

Parameters

Parameter	Type
`opts`	`DeployLockboxParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Deploy the lockbox before its pool, then authorize the pool on it with updateLockboxAuthorizedCallers before the pool can lock/release.

Throws

CCTParamsInvalidError if any param is invalid

Example

TypeScript

const unsigned = await cct.generateUnsignedDeployLockbox({
  token: '0xToken...', // must be non-zero; the same token the LockReleaseTokenPool manages
  sender: '0xDeployer...',
})

generateUnsignedDeployToken()

generateUnsignedDeployToken(opts: DeployTokenParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2938

Builds an unsigned CrossChainToken (v2.0.0) deployment tx (for multisig / offline signing). The deployed address is only known once mined, so it is NOT returned here — use deployToken to deploy and receive { hash, contractAddress, verification }.

Parameters

Parameter	Type
`opts`	`DeployTokenParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Same post-deploy roles caveat as deployToken — the pool needs grantMintAndBurnRoles before it can bridge.

Throws

CCTParamsInvalidError if any param is invalid

Example

TypeScript

const unsigned = await cct.generateUnsignedDeployToken({
  name: 'My Token',
  symbol: 'MTK',
  decimals: 18,
  maxSupply: 0n, // 0 = unlimited
  owner: '0xOwner...', // CrossChainToken v2.0.0; ccipAdmin/burnMintRoleAdmin default to owner
  sender: '0xDeployer...',
})

generateUnsignedDeployTokenAndTokenPoolViaFactory()

generateUnsignedDeployTokenAndTokenPoolViaFactory(opts: DeployTokenAndTokenPoolViaFactoryParams): Promise<FactoryDeploy>

Defined in: cct/evm/index.ts:3625

Builds an unsigned TokenPoolFactory (v2.0.0) deployTokenAndTokenPool call — deploying a CrossChainToken and its pool (and, for LockRelease, a lockbox) and configuring the given remote lanes, all in one transaction — and returns it with the locally-predicted token, pool, and (auto-deployed) lockbox addresses, known before signing.

Parameters

Parameter	Type
`opts`	`DeployTokenAndTokenPoolViaFactoryParams`

Returns

Promise<FactoryDeploy>

Remarks

Unsigned-only. The factory salt is keccak256(abi.encodePacked(salt, msg.sender)), so sender (whoever sends this) is baked into the addresses; sign with a wallet whose address equals sender. The predicted pool address depends on the factory's getStaticConfig() (rmnProxy/ccipRouter), read over RPC — pass expectedStaticConfig to pin it to trusted values. Ownership is proposed (Ownable2Step) to futureOwner; batch the accepts separately.

Throws

CCTParamsInvalidError on invalid params, empty init code, salt, static-config mismatch, or an already-occupied predicted address

Throws

CCTContractTypeInvalidError if factory is not a TokenPoolFactory

Throws

CCTContractVersionUnsupportedError if it reports an unsupported version

Example

TypeScript

const { token, pool, transaction } = await cct.generateUnsignedDeployTokenAndTokenPoolViaFactory({
  factory: '0xFactory...',
  sender: '0xSafe...', // baked into the salt/addresses; must sign the tx
  salt: 'my-token-v1',
  type: 'BurnMintTokenPool',
  token: { name: 'My Token', symbol: 'MTK', decimals: 18, maxSupply: 0n },
})

generateUnsignedDeployTokenPool()

generateUnsignedDeployTokenPool(opts: DeployTokenPoolParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3512

Builds an unsigned pool deployment tx (for multisig / offline signing). type selects the pool contract — a DeployableTokenPoolType (BurnMintTokenPool, BurnFromMintTokenPool, BurnWithFromMintTokenPool, LockReleaseTokenPool, or SiloedLockReleaseTokenPool; all v2.0.0). The deployed address is only known once mined, so it is NOT returned here — use deployTokenPool to receive { hash, contractAddress, verification }.

Parameters

Parameter	Type
`opts`	`DeployTokenPoolParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Same post-deploy setup caveat as deployTokenPool — a fresh pool must be registered, role-granted, and lane-configured before it can bridge. LockReleaseTokenPool additionally requires a pre-deployed lockbox (DeployLockReleaseTokenPoolParams) with the pool authorized on it. The full sequence: deployToken → deployLockbox → deployTokenPool (passing the lockbox) → updateLockboxAuthorizedCallers (addedCallers: [pool], plus whoever funds it) → setPool → configure lanes → depositToLockbox. The deposit is not optional: a v2.0.0 pool cannot release until its lockbox holds liquidity. SiloedLockReleaseTokenPool takes no lockbox; its lockboxes are bound per lane after deploy with configureSiloedLockboxes (see DeploySiloedLockReleaseTokenPoolParams).

Throws

CCTParamsInvalidError if any param is invalid

Example

TypeScript

const unsigned = await cct.generateUnsignedDeployTokenPool({
  type: 'BurnMintTokenPool', // burn-* variant; LockReleaseTokenPool additionally requires `lockbox`
  token: '0xToken...',
  localTokenDecimals: 18,
  rmnProxy: '0xRmnProxy...',
  router: '0xRouter...',
  sender: '0xDeployer...',
})

generateUnsignedDeployTokenPoolWithExistingTokenViaFactory()

generateUnsignedDeployTokenPoolWithExistingTokenViaFactory(opts: DeployTokenPoolWithExistingTokenViaFactoryParams): Promise<FactoryDeploy>

Defined in: cct/evm/index.ts:3655

Builds an unsigned TokenPoolFactory (v2.0.0) deployTokenPoolWithExistingToken call for an already-deployed token (any ERC20 — the factory does not require a CrossChainToken), configuring the given remote lanes, and returns it with the locally-predicted pool and (auto-deployed) lockbox addresses, known before signing.

Parameters

Parameter	Type
`opts`	`DeployTokenPoolWithExistingTokenViaFactoryParams`

Returns

Promise<FactoryDeploy>

Remarks

Same unsigned-only, sender-bound-salt, and RPC-trust caveats as generateUnsignedDeployTokenAndTokenPoolViaFactory.

Throws

CCTParamsInvalidError on invalid params, empty init code, salt, static-config mismatch, or an already-occupied predicted address

Throws

CCTContractTypeInvalidError if factory is not a TokenPoolFactory

Throws

CCTContractVersionUnsupportedError if it reports an unsupported version

Example

TypeScript

const { pool, transaction } = await cct.generateUnsignedDeployTokenPoolWithExistingTokenViaFactory({
  factory: '0xFactory...',
  sender: '0xSafe...', // baked into the salt/addresses; must sign the tx
  salt: 'my-pool-v1',
  type: 'BurnMintTokenPool',
  token: '0xExistingToken...',
  localTokenDecimals: 18,
})

generateUnsignedDepositToLockbox()

generateUnsignedDepositToLockbox(opts: DepositToLockboxParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3768

Builds an unsigned ERC20LockBox deposit tx (for multisig / offline signing) that funds the lockbox a v2.0.0 LockRelease pool releases from.

Parameters

Parameter	Type
`opts`	`DepositToLockboxParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The step the deploy sequences stop short of: a v2.0.0 pool cannot release anything until its lockbox holds liquidity. The v2.0.0 replacement for provideLiquidity.

Throws

CCTParamsInvalidError if any param is invalid, if nothing at lockbox answers typeAndVersion(), if the lockbox escrows a different token, or if sender is not an authorized caller

Throws

CCTContractTypeInvalidError if lockbox is a different contract

Throws

CCTContractVersionUnsupportedError if lockbox reports an unsupported version

Throws

CCTTxFailedError if sender holds, or has approved the lockbox for, less than amount

Example

TypeScript

const unsigned = await cct.generateUnsignedDepositToLockbox({
  lockbox: '0xLockbox...',
  token: '0xToken...',
  amount: 1_000000000000000000n,
  sender: '0xAuthorizedCaller...',
})

generateUnsignedGrantBurnRole()

generateUnsignedGrantBurnRole(opts: GrantBurnRoleParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3135

Builds an unsigned grantBurnRole tx (for multisig / offline signing): grants a supported CCT token's burn role to one account. Pair it with generateUnsignedGrantMintRole, or use generateUnsignedGrantMintAndBurnRoles to grant both in one transaction.

Parameters

Parameter	Type
`opts`	`GrantBurnRoleParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 / v1.6.2 tokens encode grantBurnRole and require the token owner; a v2.0.0 CrossChainToken encodes grantRole(BURNER_ROLE, burner) and requires its burn-role admin. A redundant grant is rejected — see generateUnsignedGrantMintRole.

See

deployTokenPool — the primary use case is granting this role to a freshly deployed pool

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender lacks the version's role-admin permission, or burner already holds the burn role

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedGrantBurnRole({
  tokenAddress: '0xToken...',
  burner: '0xBurner...',
  sender: '0xTokenOwner...',
})

generateUnsignedGrantMintAndBurnRoles()

generateUnsignedGrantMintAndBurnRoles(opts: GrantMintAndBurnRolesParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3000

Builds an unsigned grantMintAndBurnRoles tx (for multisig / offline signing): grants a supported CCT token's mint and burn roles to one account, in a single transaction. This is the call that lets a freshly deployed burn/mint pool bridge the token.

Parameters

Parameter	Type
`opts`	`GrantMintAndBurnRolesParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Supported by v1.5.1 / v1.6.2 and v2.0.0 CrossChainToken; v2 enforces the mint/burn role admin through AccessControl. Rejected only when burnAndMinter already holds both roles; holding just one still builds, since this call is what completes the pair.

See

deployTokenPool — the primary use case is granting these roles to a freshly deployed pool

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender lacks the version's role-admin permission, or burnAndMinter already holds both roles

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the v1 owner or v2 role admin.
const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedGrantMintAndBurnRoles({
  tokenAddress: '0xToken...',
  burnAndMinter: '0xPool...', // the token's burn/mint pool
  sender: '0xTokenOwner...',
})

generateUnsignedGrantMintRole()

generateUnsignedGrantMintRole(opts: GrantMintRoleParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3070

Builds an unsigned grantMintRole tx (for multisig / offline signing): grants a supported CCT token's mint role to one account. Pair it with generateUnsignedGrantBurnRole, or use generateUnsignedGrantMintAndBurnRoles to grant both in one transaction.

Parameters

Parameter	Type
`opts`	`GrantMintRoleParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 / v1.6.2 tokens encode grantMintRole and require the token owner; a v2.0.0 CrossChainToken encodes grantRole(MINTER_ROLE, minter) and requires its mint-role admin. A redundant grant is rejected, since the chain would mine it as a silent no-op rather than revert.

See

deployTokenPool — the primary use case is granting this role to a freshly deployed pool

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender lacks the version's role-admin permission, or minter already holds the mint role

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedGrantMintRole({
  tokenAddress: '0xToken...',
  minter: '0xMinter...',
  sender: '0xTokenOwner...',
})

generateUnsignedMint()

generateUnsignedMint(opts: MintParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3320

Builds an unsigned mint tx (for multisig / offline signing): mints new supply of a BurnMintERC677 token to account. The manual mint — seeding liquidity, topping up test supply — not the bridge path, which mints through the pool.

Parameters

Parameter	Type
`opts`	`MintParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 / v1.6.2 tokens only; v2.0.0's CrossChainToken gates minting through AccessControl, which ships separately. sender is checked against the token's isMinter(address), not its owner: mint is onlyMinter, and the owner is the role admin, who need not hold the role. Grant it first with grantMintRole. The full sequence: deployToken → grantMintRole → generateUnsignedMint, checking the grant landed with isMinter (or getMinters for the whole set).

Throws

CCTContractTypeInvalidError if tokenAddress is not a BurnMintERC677 token (a v2.0.0 CrossChainToken included, since it gates mint/burn through AccessControl)

Throws

CCTParamsInvalidError if any param is invalid, or sender is given and does not hold the token's mint role

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must hold the mint role.
const unsigned = await cct.generateUnsignedMint({
  tokenAddress: '0xToken...',
  account: '0xRecipient...',
  amount: 1_000_000000000000000000n, // 1000 tokens at 18 decimals
  sender: '0xMinter...',
})

generateUnsignedProvideLiquidity()

generateUnsignedProvideLiquidity(opts: ProvideLiquidityParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2195

Builds an unsigned pool provideLiquidity tx (for multisig / offline signing): deposits amount of the pool's token into a LockRelease pool (v1.5.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`ProvideLiquidityParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Gated on the pool's rebalancer, not its owner: the pool accepts liquidity calls only from the account appointed with generateUnsignedSetRebalancer, and reverts Unauthorized for everyone else, the owner included. A given sender is checked against getRebalancer() before any calldata is built.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool, which has no liquidity to manage

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which escrows through an external ERC20LockBox instead — see deployLockbox / updateLockboxAuthorizedCallers

Throws

CCTParamsInvalidError if any param is invalid, amount is zero, the pool cannot accept liquidity, or sender is given and is not the pool's rebalancer

Throws

CCTTxFailedError if sender holds less than amount of the pool's token, or has approved the pool for less than amount

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the pool rebalancer.
const unsigned = await cct.generateUnsignedProvideLiquidity({
  poolAddress: '0xPool...',
  amount: 1_000000000000000000n,
  sender: '0xRebalancer...',
})

generateUnsignedProvideSiloedLiquidity()

generateUnsignedProvideSiloedLiquidity(opts: ProvideSiloedLiquidityParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2503

Builds an unsigned pool provideSiloedLiquidity tx (for multisig / offline signing): deposits amount of the pool's token into one lane's silo of a SiloedLockReleaseTokenPool (v1.6.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`ProvideSiloedLiquidityParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Gated on the silo's rebalancer (getChainRebalancer(remoteChainSelector)), not the owner, and not the unsiloed rebalancer generateUnsignedProvideLiquidity takes. The owner appoints it with generateUnsignedUpdateSiloDesignations or generateUnsignedSetSiloRebalancer. The lane must be siloed; that is read whether or not sender is given, and a given sender is checked against the silo rebalancer.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which escrows through a lockbox per lane instead (see configureSiloedLockboxes)

Throws

CCTParamsInvalidError if any param is invalid, remoteChainSelector or amount is zero, the lane is not siloed, or sender is given and is not the silo's rebalancer

Throws

CCTTxFailedError if sender holds less than amount of the pool's token, or has approved the pool for less than amount

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only, sign later (multisig / offline). `sender` must be the silo rebalancer.
const unsigned = await cct.generateUnsignedProvideSiloedLiquidity({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  amount: 1_000000000000000000n,
  sender: '0xSiloRebalancer...',
})

generateUnsignedRegisterAdmin()

generateUnsignedRegisterAdmin(opts: RegisterAdminParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:391

Builds an unsigned registerAdmin tx (for multisig / offline signing): proposes a token's administrator in the TokenAdminRegistry via a RegistryModuleOwnerCustom. Two-step by design — the proposed administrator must then call acceptAdmin.

Parameters

Parameter	Type
`opts`	`RegisterAdminParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The administrator is not a parameter — the module derives it on-chain. owner/ccip-admin read the token's own owner()/getCCIPAdmin(), so the result is independent of who signs; a wrong signer simply reverts (CanOnlySelfRegister).

access-control-default-admin behaves differently and warrants care on this offline path: the module registers msg.sender after checking it holds the token's DEFAULT_ADMIN_ROLE. sender here only drives the local pre-flight probe, so if the built tx is ultimately signed by a different address that also holds that role, the signer becomes the token's administrator — silently, with no revert to catch it. Confirm the signing key before relaying an access-control-default-admin registration. registerAdmin is not exposed to this, since it rejects a sender that differs from its wallet.

Throws

CCTParamsInvalidError if any param is invalid, registryModule is not a registered TAR module, registrationMethod needs a v1.6+ module, sender doesn't match the token's authority for the chosen method, or the token is already registered (or pending acceptance)

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the token's owner (or
// CCIP admin / default admin, matching `registrationMethod`).
const unsigned = await cct.generateUnsignedRegisterAdmin({
  tokenAddress: '0xToken...',
  registryModule: '0xRegistryModuleOwnerCustom...', // not discoverable on-chain
  address: '0xTokenAdminRegistry...', // the TAR, or a Router/OnRamp/OffRamp/pool to resolve it from
  sender: '0xTokenOwner...',
})

generateUnsignedRemoveRemotePool()

generateUnsignedRemoveRemotePool(opts: RemotePoolParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:4086

Builds an unsigned pool removeRemotePool tx (for multisig / offline signing), de-authorizing one remote pool on a lane.

Parameters

Parameter	Type
`opts`	`RemotePoolParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 and later pools — the versions where a lane holds a set of remote pools. The last step of a remote-side pool upgrade started with addRemotePool. A v1.5.0 pool has no removal primitive and throws CCTOperationUnsupportedError; its single remote pool can only be overwritten via setRemotePool.

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the pool owner, or remotePoolAddress is not registered on that lane

Throws

CCTOperationUnsupportedError if the pool is v1.5.0

Throws

CCTContractTypeInvalidError if poolAddress is not a supported pool type

Example

TypeScript

const unsigned = await cct.generateUnsignedRemoveRemotePool({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  remotePoolAddress: '0xDrainedRemotePool...',
  sender: '0xPoolOwner...',
})

generateUnsignedRevokeBurnRole()

generateUnsignedRevokeBurnRole(opts: RevokeBurnRoleParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3259

Builds an unsigned revokeBurnRole tx (for multisig / offline signing): removes a supported CCT token's burn role from one account.

Parameters

Parameter	Type
`opts`	`RevokeBurnRoleParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 / v1.6.2 tokens encode revokeBurnRole; a v2.0.0 CrossChainToken encodes revokeRole(BURNER_ROLE, burner). A missing role is rejected — see generateUnsignedRevokeMintRole.

See

deployTokenPool — the mirror of the grant made to a freshly deployed pool

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender lacks the version's role-admin permission, or burner does not currently hold the burn role

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedRevokeBurnRole({
  tokenAddress: '0xToken...',
  burner: '0xOldPool...', // must currently hold the role
  sender: '0xTokenOwner...',
})

generateUnsignedRevokeMintRole()

generateUnsignedRevokeMintRole(opts: RevokeMintRoleParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3197

Builds an unsigned revokeMintRole tx (for multisig / offline signing): removes a supported CCT token's mint role from one account.

Parameters

Parameter	Type
`opts`	`RevokeMintRoleParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.1 / v1.6.2 tokens encode revokeMintRole; a v2.0.0 CrossChainToken encodes revokeRole(MINTER_ROLE, minter). A missing role is rejected, since the chain would mine a silent no-op.

See

deployTokenPool — the mirror of the grant made to a freshly deployed pool

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender lacks the version's role-admin permission, or minter does not currently hold the mint role

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedRevokeMintRole({
  tokenAddress: '0xToken...',
  minter: '0xOldPool...', // must currently hold the role
  sender: '0xTokenOwner...',
})

generateUnsignedSetAllowedFinalityConfig()

generateUnsignedSetAllowedFinalityConfig(opts: SetAllowedFinalityConfigParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1286

Builds an unsigned pool setAllowedFinalityConfig tx (for multisig / offline signing). Configures the v2.0.0-only FTF minimum block depth and optional FCR/safe-finality mode.

Parameters

Parameter	Type
`opts`	`SetAllowedFinalityConfigParams`

Returns

Promise<UnsignedEVMTx>

Remarks

This replaces the whole finality config: allowedFinality.finalityDepth is an integer in [0, 65535], and 0 disables FTF; omitting allowedFinality.finalitySafe disables FCR. To preserve one setting while changing the other, first call getAllowedFinalityConfig. The pool owner is the only permitted caller; when sender is supplied it is checked against owner() before calldata is returned.

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress is zero, or sender is supplied and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetAllowedFinalityConfig({
  poolAddress: '0xPool...',
  allowedFinality: { finalityDepth: 5, finalitySafe: true },
  sender: '0xOwner...',
})

generateUnsignedSetCCIPAdmin()

generateUnsignedSetCCIPAdmin(opts: SetCCIPAdminParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:998

Builds an unsigned v2.0.0 setCCIPAdmin tx (for multisig / offline signing). The current default admin sets the separate CCIP admin (including zero to clear it), which TokenAdminRegistry can use through registerAdminViaGetCCIPAdmin.

Parameters

Parameter	Type
`opts`	`SetCCIPAdminParams`

Returns

Promise<UnsignedEVMTx>

Throws

CCTContractTypeInvalidError if tokenAddress is not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

CCTParamsInvalidError if an address is invalid or sender is not the current default admin

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetCCIPAdmin({
  tokenAddress: '0xToken...',
  newAdmin: '0xCCIPAdmin...',
  sender: '0xDefaultAdmin...',
})

generateUnsignedSetChainRateLimiterConfigs()

generateUnsignedSetChainRateLimiterConfigs(opts: SetChainRateLimiterConfigsParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1081

Builds an unsigned pool rate-limit tx (for multisig / offline signing): sets the inbound and outbound limits of one or more already-configured lanes, in a single transaction. Probes the pool's on-chain typeAndVersion to resolve its interface + encoder.

Parameters

Parameter	Type
`opts`	`SetChainRateLimiterConfigsParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.0 pools set one lane per transaction. v1.5.1–v1.6.1 encode the batch setChainRateLimiterConfigs(uint64[], Config[], Config[]) and v2.0.0 the reshaped setRateLimitConfig(RateLimitConfigArgs[]), but v1.5.0 ships only the singular setChainRateLimiterConfig(uint64, Config, Config). To keep the one-op-one-transaction contract every CCT write holds, a v1.5.0 pool therefore accepts only a single-element updates; a multi-lane batch is rejected with CCTParamsInvalidError rather than fanned out into N transactions.

fastFinality is v2.0.0-only — the flag does not exist in the earlier ABIs, so setting it (to either value) on an older pool is rejected rather than silently dropped. It defaults to false on v2.0.0.

This op updates limits on lanes that already exist; it does not add one. An unconfigured selector reverts on-chain (NonExistentChain).

The tx must ultimately be signed by the pool owner or its rateLimitAdmin — both are reported by getTokenPoolState. When opts.sender is supplied it is pre-flighted against both roles (two extra eth_calls — the pool's owner() and whichever getter reports rateLimitAdmin on that version), so a sender holding neither fails at build time rather than reverting at signing. Omit sender to build the calldata without any role read, when the eventual signer is not yet known.

Throws

CCTParamsInvalidError if any param is invalid: updates empty, a repeated remoteChainSelector, a non-uint64 selector, a rate above its capacity while enabled, a non-zero amount while disabled, fastFinality set on a pre-2.0.0 pool, or sender given and being neither the pool owner nor its (set) rateLimitAdmin. On a v1.5.1 or v1.6.0 pool the enabled-bucket bound is stricter still (0 < rate < capacity), so a rate of 0n or a rate equal to capacity is also rejected there — v1.6.1 and v2.0.0 allow both. A v1.5.0 pool accepts only a single-element updates.

Example

TypeScript

const unsigned = await cct.generateUnsignedSetChainRateLimiterConfigs({
  poolAddress: '0xPool...',
  updates: [
    {
      remoteChainSelector: 5009297550715157269n, // ethereum-mainnet
      // amounts are in the local token's smallest unit (18 decimals here)
      outboundRateLimiterConfig: { enabled: true, capacity: 10_000n * 10n ** 18n, rate: 100n * 10n ** 18n },
      inboundRateLimiterConfig: { enabled: false }, // capacity/rate default to 0n
    },
  ],
  sender: '0xOwnerOrRateLimitAdmin...',
})

generateUnsignedSetDynamicConfig()

generateUnsignedSetDynamicConfig(opts: SetDynamicConfigParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1222

Builds an unsigned pool setDynamicConfig tx (for multisig / offline signing): replaces a v2.0.0 pool's whole dynamic config — the router it accepts ramp calls from, plus the rateLimitAdmin and feeAdmin delegate roles.

Parameters

Parameter	Type
`opts`	`SetDynamicConfigParams`

Returns

Promise<UnsignedEVMTx>

Remarks

This is where the pre-2.0.0 setRouter / setRateLimitAdmin setters went: 2.0.0 removed them and writes all three fields together. Consequently all three params are required — this op deliberately does not read getDynamicConfig() to fill in what the caller omitted. The calldata has to be deterministic at build time: a multisig or cold wallet may sign it days later, and a hidden read would bake a value that has since moved on-chain, silently reverting an unrelated config change made in the interim.

Read the current triple with getTokenPoolState and pass it back explicitly, so what is signed is exactly what was reviewed. This is also the migration path off setRateLimitAdmin for a 2.0.0 pool.

Owner-only, for the same escalation reason as generateUnsignedSetRateLimitAdmin. Zero rateLimitAdmin / feeAdmin clear those delegations; router must be non-zero, since a zero router detaches the pool from CCIP rather than clearing a privilege.

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool, which has no setDynamicConfig — use generateUnsignedSetRateLimitAdmin there

Throws

CCTParamsInvalidError if any param is invalid, poolAddress or router is the zero address, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedSetDynamicConfig({
  poolAddress: '0xPool...',
  router: '0xRouter...',
  rateLimitAdmin: '0xOpsMultisig...',
  feeAdmin: '0xFeeMultisig...',
  sender: '0xOwner...',
})

generateUnsignedSetPolicyEngine()

generateUnsignedSetPolicyEngine(opts: SetPolicyEngineParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1848

Builds an unsigned setPolicyEngine tx for an AdvancedPoolHooks; use setPolicyEngine to sign and submit it directly.

Parameters

Parameter	Type
`opts`	`SetPolicyEngineParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The zero address disables policy checks. A non-zero engine must have deployed code and implement attach() / detach(); code presence alone cannot verify that interface. The target is probed to confirm it reports AdvancedPoolHooks. When sender is supplied, it must be the current hooks owner.

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, a non-zero engine has no deployed code, or sender is not the hooks owner

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetPolicyEngine({
  advancedPoolHooks: '0xHooks...',
  newPolicyEngine: '0xPolicyEngine...',
  sender: '0xOwner...',
})

generateUnsignedSetPool()

generateUnsignedSetPool(opts: SetPoolParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:440

Builds an unsigned setPool tx (for multisig / offline signing). A zero/empty poolAddress delists the token from the registry.

Parameters

Parameter	Type
`opts`	`SetPoolParams`

Returns

Promise<UnsignedEVMTx>

Throws

CCTParamsInvalidError if any param is invalid

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the token's current admin.
const unsigned = await cct.generateUnsignedSetPool({
  tokenAddress: '0xToken...',
  poolAddress: '0xPool...', // pass the zero address to delist the token
  address: '0xTokenAdminRegistry...', // the TAR, or a Router/pool to resolve it from
  sender: '0xTokenAdmin...',
})

generateUnsignedSetRateLimitAdmin()

generateUnsignedSetRateLimitAdmin(opts: SetRateLimitAdminParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1159

Builds an unsigned pool setRateLimitAdmin tx (for multisig / offline signing): assigns the role allowed to change the pool's rate limits alongside the owner. Probes the pool's on-chain typeAndVersion to resolve its interface + encoder.

Parameters

Parameter	Type
`opts`	`SetRateLimitAdminParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Owner-only, unlike the rate-limit config writes the pool also accepts from the current rateLimitAdmin — this call assigns the role itself, so admitting the incumbent admin would let it reassign or entrench its own privilege. When sender is supplied it is checked against the pool's owner() before any calldata is built; omit it and no owner read is made (nothing to compare against).

A zero newRateLimitAdmin is accepted and clears the delegation, leaving the owner as the only account that can change rate limits.

Throws

CCTOperationUnsupportedError on a v2.0.0 pool — 2.0.0 removed the standalone setRateLimitAdmin(address) selector and folded the role into a three-field dynamic config; use generateUnsignedSetDynamicConfig / setDynamicConfig there

Throws

CCTParamsInvalidError if any param is invalid, poolAddress is the zero address, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedSetRateLimitAdmin({
  poolAddress: '0xPool...',
  newRateLimitAdmin: '0xOpsMultisig...',
  sender: '0xOwner...',
})

generateUnsignedSetRebalancer()

generateUnsignedSetRebalancer(opts: SetRebalancerParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2393

Builds an unsigned pool setRebalancer tx (for multisig / offline signing): appoints the LockRelease pool role allowed to move liquidity (v1.5.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`SetRebalancerParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Owner-only, and the appointee — not the owner — is who generateUnsignedProvideLiquidity and generateUnsignedWithdrawLiquidity then accept. When sender is supplied it is checked against the pool's owner() before any calldata is built; omit it and no owner read is made (nothing to compare against).

A zero rebalancer is accepted and revokes the role, which stops liquidity movement entirely: the pool then accepts those calls from nobody.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which authorizes liquidity on its ERC20LockBox instead — see updateLockboxAuthorizedCallers

Throws

CCTParamsInvalidError if any param is invalid, poolAddress is the zero address, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedSetRebalancer({
  poolAddress: '0xPool...',
  rebalancer: '0xLiquidityOps...',
  sender: '0xOwner...',
})

generateUnsignedSetRemotePool()

generateUnsignedSetRemotePool(opts: RemotePoolParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3962

Builds an unsigned pool setRemotePool tx (for multisig / offline signing), replacing the remote pool a lane accepts.

Parameters

Parameter	Type
`opts`	`RemotePoolParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.5.0 pools only. A v1.5.0 pool holds exactly one remote pool per lane, and this call overwrites it. v1.5.1 replaced it with the additive addRemotePool / removeRemotePool pair and dropped setRemotePool from the ABI, so a v1.5.1, v1.6.1 or v2.0.0 pool throws CCTOperationUnsupportedError — use generateUnsignedAddRemotePool / generateUnsignedRemoveRemotePool there. No emulation is attempted: replacing a set of unknown size is not one transaction.

Throws

CCTParamsInvalidError if any param is invalid, or sender is given and is not the pool owner

Throws

CCTOperationUnsupportedError if the pool is v1.5.1 or newer

Throws

CCTContractTypeInvalidError if poolAddress is not a supported pool type

Example

TypeScript

const unsigned = await cct.generateUnsignedSetRemotePool({
  poolAddress: '0xPool...', // a v1.5.0 pool
  remoteChainSelector: 5009297550715157269n, // ethereum-mainnet
  remotePoolAddress: '0xRemotePool...', // the remote chain's own format, e.g. base58 for Solana
  sender: '0xPoolOwner...',
})

generateUnsignedSetSiloRebalancer()

generateUnsignedSetSiloRebalancer(opts: SetSiloRebalancerParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2644

Builds an unsigned pool setSiloRebalancer tx (for multisig / offline signing): appoints the account allowed to move one lane's silo liquidity on a SiloedLockReleaseTokenPool (v1.6.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`SetSiloRebalancerParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Owner-only, and the lane must already be siloed; silos are created, with a first rebalancer, by generateUnsignedUpdateSiloDesignations. The appointee is who generateUnsignedProvideSiloedLiquidity and generateUnsignedWithdrawSiloedLiquidity then accept for that lane. A given sender is checked against the pool's owner().

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, whose lanes escrow through lockboxes that authorize their own callers (see updateLockboxAuthorizedCallers)

Throws

CCTParamsInvalidError if any param is invalid, remoteChainSelector is zero, rebalancer is zero on a v1.6.0 pool, the lane is not siloed, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only, sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedSetSiloRebalancer({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  rebalancer: '0xSiloRebalancer...',
  sender: '0xOwner...',
})

generateUnsignedSetThresholdAmount()

generateUnsignedSetThresholdAmount(opts: SetThresholdAmountParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1910

Builds an unsigned setThresholdAmount tx for an AdvancedPoolHooks; use setThresholdAmount to sign and submit it directly.

Parameters

Parameter	Type
`opts`	`SetThresholdAmountParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Zero disables threshold CCVs; base CCVs continue to apply. The target is probed to confirm it reports AdvancedPoolHooks; when sender is supplied, it must be the current hooks owner.

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, or sender is not the hooks owner

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetThresholdAmount({
  advancedPoolHooks: '0xHooks...',
  thresholdAmount: 1_000_000n,
  sender: '0xOwner...',
})

generateUnsignedTransferAdmin()

generateUnsignedTransferAdmin(opts: TransferAdminParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:484

Builds an unsigned TokenAdminRegistry transferAdmin tx (for multisig / offline signing). Two-step by design: newAdmin must separately call acceptAdmin to complete the handoff. This is the registry's ADMIN role — distinct from a pool's Ownable2Step owner (see transferPoolOwnership); do not confuse the two.

Parameters

Parameter	Type
`opts`	`TransferAdminParams`

Returns

Promise<UnsignedEVMTx>

Throws

CCTParamsInvalidError if any param is invalid, or if sender is not the token's current registry administrator (including a not-yet-accepted registration)

Example

TypeScript

// `sender` must be the token's current registry administrator
const unsigned = await cct.generateUnsignedTransferAdmin({
  tokenAddress: '0xToken...',
  newAdmin: '0xNewAdmin...', // must separately call acceptAdmin
  address: '0xTokenAdminRegistry...', // the TAR, or a Router/pool to resolve it from
  sender: '0xCurrentAdmin...',
})

generateUnsignedTransferLiquidity()

generateUnsignedTransferLiquidity(opts: TransferLiquidityParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2328

Builds an unsigned pool transferLiquidity tx (for multisig / offline signing): moves liquidity out of an older LockRelease pool (from) into this one (v1.5.0–v1.6.1). The pool-upgrade primitive.

Parameters

Parameter	Type
`opts`	`TransferLiquidityParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Two-step, because the new pool withdraws from the old one as its rebalancer: first point the old pool's rebalancer at the new pool with generateUnsignedSetRebalancer, then call this on the new pool.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool, or a SiloedLockReleaseTokenPool — siloed liquidity is per-lane and has no transferLiquidity

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which escrows through an external ERC20LockBox instead

Throws

CCTParamsInvalidError if any param is invalid, from equals poolAddress, amount is zero or is MaxUint256 from a siloed from, from is a v2.0.0 pool, from escrows a different token or does not have poolAddress as its rebalancer, or sender is given and does not own poolAddress

Throws

CCTTxFailedError if from's withdrawable liquidity is below amount

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

import { MaxUint256 } from 'ethers'

// step 1, on the old pool: let the new pool withdraw from it
await cct.setRebalancer({ poolAddress: oldPool, rebalancer: newPool, wallet })
// step 2, on the new pool: pull everything across (v1.6.1+)
const unsigned = await cct.generateUnsignedTransferLiquidity({
  poolAddress: newPool,
  from: oldPool, // the source pool, not the signer — see `sender`
  amount: MaxUint256, // the source pool's whole balance
  sender: '0xOwner...',
})

generateUnsignedTransferPoolOwnership()

generateUnsignedTransferPoolOwnership(opts: TransferPoolOwnershipParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:622

Builds an unsigned pool transferOwnership tx (for multisig / offline signing). Probes the pool's on-chain typeAndVersion to resolve its interface + encoder; the transferOwnership calldata is stable across pool versions, so the resolved encoding is version/type-independent.

Parameters

Parameter	Type
`opts`	`TransferPoolOwnershipParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Step one of two: nothing changes until newOwner calls acceptPoolOwnership, and until then the current owner keeps every privilege. Re-proposing replaces the pending address, and proposing the zero address cancels the transfer outright.

Throws

CCTParamsInvalidError if any param is invalid, if newOwner equals sender or the pool's current owner (the pool would revert CannotTransferToSelf), or if sender is given and is not the pool owner

Example

TypeScript

const unsigned = await cct.generateUnsignedTransferPoolOwnership({
  poolAddress: '0xPool...',
  newOwner: '0xNewOwner...', // must separately call acceptPoolOwnership
  sender: '0xCurrentOwner...',
})

generateUnsignedTransferTokenOwnership()

generateUnsignedTransferTokenOwnership(opts: TransferTokenOwnershipParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:714

Builds an unsigned token-admin proposal (for multisig / offline signing), or a retraction when newOwner is zero, on either token version.

Parameters

Parameter	Type
`opts`	`TransferTokenOwnershipParams`

Returns

Promise<UnsignedEVMTx>

Deprecated

Use generateUnsignedBeginDefaultAdminTransfer, or generateUnsignedCancelDefaultAdminTransfer to retract; this builds exactly what they do.

Example

TypeScript

const unsigned = await cct.generateUnsignedTransferTokenOwnership({
  tokenAddress: '0xToken...',
  newOwner: '0xNewOwner...', // must separately call acceptTokenOwnership
  sender: '0xCurrentOwner...',
})

generateUnsignedUpdateAdvancedPoolHooks()

generateUnsignedUpdateAdvancedPoolHooks(opts: UpdateAdvancedPoolHooksParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1975

Builds an unsigned pool updateAdvancedPoolHooks tx (for multisig / offline signing): points a v2.0.0 pool at an AdvancedPoolHooks contract, or detaches the current one with the zero address.

Parameters

Parameter	Type
`opts`	`UpdateAdvancedPoolHooksParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Unlike a LockRelease pool's lockBox, which the constructor fixes in an immutable slot with no setter, the hooks binding is a plain storage slot this op overwrites — a mis-bound lockbox needs a new pool, a mis-bound hooks contract needs one transaction. Do not assume the two ctor args behave alike.

Throws

CCTParamsInvalidError if poolAddress is zero/invalid, advancedPoolHooks is invalid, the pool is already bound to it, or sender is not the pool owner

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported, or a non-zero advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedUpdateAdvancedPoolHooks({
  poolAddress: '0xPool...',
  advancedPoolHooks: '0xHooks...',
  sender: '0xOwner...',
})

generateUnsignedUpdateAdvancedPoolHooksAuthorizedCallers()

generateUnsignedUpdateAdvancedPoolHooksAuthorizedCallers(opts: UpdateAdvancedPoolHooksAuthorizedCallersParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1787

Builds an unsigned authorized-caller update for an AdvancedPoolHooks; use updateAdvancedPoolHooksAuthorizedCallers to sign and submit it directly.

Parameters

Parameter	Type
`opts`	`UpdateAdvancedPoolHooksAuthorizedCallersParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Caller arrays reject duplicates (including different address casing). Removes run before adds, so a caller present in both lists remains authorized. The hooks target and supplied owner are pre-flighted before calldata is returned.

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, or sender is not the hooks owner

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedUpdateAdvancedPoolHooksAuthorizedCallers({
  advancedPoolHooks: '0xHooks...',
  addedCallers: ['0xPool...'],
  sender: '0xOwner...',
})

generateUnsignedUpdateLockboxAuthorizedCallers()

generateUnsignedUpdateLockboxAuthorizedCallers(opts: UpdateLockboxAuthorizedCallersParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3686

Builds an unsigned ERC20LockBox applyAuthorizedCallerUpdates tx (for multisig / offline signing) that adds/removes authorized callers. Authorize a LockReleaseTokenPool here so it can lock/release against the lockbox.

Parameters

Parameter	Type
`opts`	`UpdateLockboxAuthorizedCallersParams`

Returns

Promise<UnsignedEVMTx>

Remarks

lockbox is checked on-chain before any calldata is built: a call to an EOA or an undeployed address executes nothing yet mines successfully, so an address that is not a deployed ERC20LockBox is rejected here rather than returning an unsigned tx that silently authorizes nobody. When sender is given it is checked against the lockbox's owner(), since applyAuthorizedCallerUpdates is owner-only.

Throws

CCTParamsInvalidError if any param is invalid, if no caller is supplied, if nothing at lockbox answers typeAndVersion(), or if sender is not the lockbox owner

Throws

CCTContractTypeInvalidError if lockbox is a different contract

Throws

CCTContractVersionUnsupportedError if lockbox reports an unsupported version

Throws

CCIPTypeVersionInvalidError if lockbox answers typeAndVersion() with an unparseable string

Example

TypeScript

// `sender` must be the lockbox owner
const unsigned = await cct.generateUnsignedUpdateLockboxAuthorizedCallers({
  lockbox: '0xLockbox...',
  addedCallers: ['0xPool...'], // the LockReleaseTokenPool to authorize
  sender: '0xLockboxOwner...',
})

generateUnsignedUpdateSiloDesignations()

generateUnsignedUpdateSiloDesignations(opts: UpdateSiloDesignationsParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2703

Builds an unsigned pool updateSiloDesignations tx (for multisig / offline signing): turns lanes of a SiloedLockReleaseTokenPool (v1.6.0–v1.6.1) into silos (adds), or back into shared-bucket lanes (removes). Removes are applied first.

Parameters

Parameter	Type
`opts`	`UpdateSiloDesignationsParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Owner-only. A remove moves the silo's whole balance into the shared unsiloed bucket and revokes its silo rebalancer. An add starts the silo at 0, under the given rebalancer, who funds it with generateUnsignedProvideSiloedLiquidity.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which binds a lockbox per lane instead (see configureSiloedLockboxes)

Throws

CCTParamsInvalidError if any param is invalid, both arrays are empty, a lane is duplicated, zero (in adds) or in both arrays, a rebalancer is zero, a lane fails one of the state checks above, or sender is given and is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only, sign later (multisig / offline). `sender` must be the pool owner.
const unsigned = await cct.generateUnsignedUpdateSiloDesignations({
  poolAddress: '0xPool...',
  removes: [],
  adds: [{ remoteChainSelector: 16015286601757825753n, rebalancer: '0xSiloRebalancer...' }],
  sender: '0xOwner...',
})

generateUnsignedWithdrawFeeTokens()

generateUnsignedWithdrawFeeTokens(opts: WithdrawFeeTokensParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:1436

Builds an unsigned v2.0.0 pool fee-token withdrawal transaction.

Parameters

Parameter	Type
`opts`	`WithdrawFeeTokensParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The pool owner or delegated feeAdmin may transfer the full balances of the selected fee tokens to recipient. On LockRelease pools, bridge liquidity remains in the external lockbox and is not withdrawable here.

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid or sender holds neither role

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedWithdrawFeeTokens({
  poolAddress: '0xPool...',
  feeTokens: ['0xFeeToken...'],
  recipient: '0xRecipient...',
  sender: '0xFeeAdmin...',
})

generateUnsignedWithdrawFromLockbox()

generateUnsignedWithdrawFromLockbox(opts: WithdrawFromLockboxParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:3823

Builds an unsigned ERC20LockBox withdraw tx (for multisig / offline signing) that pulls liquidity back out to an explicit recipient.

Parameters

Parameter	Type
`opts`	`WithdrawFromLockboxParams`

Returns

Promise<UnsignedEVMTx>

Remarks

The v2.0.0 replacement for withdrawLiquidity, with one difference worth noting: the payout address is a parameter, not msg.sender.

Throws

CCTParamsInvalidError if any param is invalid, if nothing at lockbox answers typeAndVersion(), if the lockbox escrows a different token, or if sender is not an authorized caller

Throws

CCTContractTypeInvalidError if lockbox is a different contract

Throws

CCTContractVersionUnsupportedError if lockbox reports an unsupported version

Throws

CCTTxFailedError if the lockbox holds less than amount

Example

TypeScript

const unsigned = await cct.generateUnsignedWithdrawFromLockbox({
  lockbox: '0xLockbox...',
  token: '0xToken...',
  amount: 1_000000000000000000n,
  recipient: '0xTreasury...',
  sender: '0xAuthorizedCaller...',
})

generateUnsignedWithdrawLiquidity()

generateUnsignedWithdrawLiquidity(opts: WithdrawLiquidityParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2257

Builds an unsigned pool withdrawLiquidity tx (for multisig / offline signing): pulls amount of the pool's token back out of a LockRelease pool (v1.5.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`WithdrawLiquidityParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Gated on the pool's rebalancer, not its owner, and the tokens are sent to msg.sender — so they land with the rebalancer, whoever signs. A given sender is checked against getRebalancer() before any calldata is built.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which escrows through an external ERC20LockBox instead

Throws

CCTParamsInvalidError if any param is invalid, amount is zero, or sender is given and is not the pool's rebalancer

Throws

CCTTxFailedError if the pool's withdrawable liquidity is below amount

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only — sign later (multisig / offline). `sender` must be the pool rebalancer.
const unsigned = await cct.generateUnsignedWithdrawLiquidity({
  poolAddress: '0xPool...',
  amount: 1_000000000000000000n,
  sender: '0xRebalancer...',
})

generateUnsignedWithdrawSiloedLiquidity()

generateUnsignedWithdrawSiloedLiquidity(opts: WithdrawSiloedLiquidityParams): Promise<UnsignedEVMTx>

Defined in: cct/evm/index.ts:2578

Builds an unsigned pool withdrawSiloedLiquidity tx (for multisig / offline signing): pulls amount of the pool's token out of one lane's silo of a SiloedLockReleaseTokenPool (v1.6.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`WithdrawSiloedLiquidityParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Gated on the silo's rebalancer, and the tokens are sent to msg.sender, so they land with that rebalancer, whoever signs. The lane must be siloed; a given sender is checked against the silo rebalancer.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which escrows through a lockbox per lane instead (see withdrawFromLockbox)

Throws

CCTParamsInvalidError if any param is invalid, remoteChainSelector or amount is zero, the lane is not siloed, or sender is given and is not the silo's rebalancer

Throws

CCTTxFailedError if the silo holds less than amount

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

// build only, sign later (multisig / offline). `sender` must be the silo rebalancer.
const unsigned = await cct.generateUnsignedWithdrawSiloedLiquidity({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  amount: 1_000000000000000000n,
  sender: '0xSiloRebalancer...',
})

getAdvancedPoolHooks()

getAdvancedPoolHooks(opts: GetAdvancedPoolHooksParams): Promise<string>

Defined in: cct/evm/index.ts:2036

Reads the AdvancedPoolHooks contract a v2.0.0+ pool is bound to.

Parameters

Parameter	Type
`opts`	`GetAdvancedPoolHooksParams`

Returns

Promise<string>

Remarks

The zero address is a normal result: no hooks are bound, so the pool enforces no sender allowlist and no CCV requirements.

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const hooks = await cct.getAdvancedPoolHooks({ poolAddress: '0xPool...' })
if (hooks === ZeroAddress) console.log('pool enforces no allowlist or CCV requirements')

getAllAdvancedPoolHooksAuthorizedCallers()

getAllAdvancedPoolHooksAuthorizedCallers(opts: AdvancedPoolHooksTarget): Promise<GetAllAdvancedPoolHooksAuthorizedCallersResult>

Defined in: cct/evm/index.ts:1723

Lists callers authorized for hooks preflight and postflight checks.

Parameters

Parameter	Type
`opts`	`AdvancedPoolHooksTarget`

Returns

Promise<GetAllAdvancedPoolHooksAuthorizedCallersResult>

Throws

CCTParamsInvalidError if the target is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const callers = await cct.getAllAdvancedPoolHooksAuthorizedCallers({
  advancedPoolHooks: '0xHooks...',
})

getAllCCVConfigs()

getAllCCVConfigs(opts: AdvancedPoolHooksTarget): Promise<GetAllCCVConfigsResult>

Defined in: cct/evm/index.ts:1600

Lists every remote chain with a non-empty base CCV config.

Parameters

Parameter	Type
`opts`	`AdvancedPoolHooksTarget`

Returns

Promise<GetAllCCVConfigsResult>

Remarks

The result follows the contract's enumerable-set order, which is not a stable sort. A config with only threshold CCVs cannot exist; threshold CCVs require a base list.

Throws

CCTParamsInvalidError if the target is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const configs = await cct.getAllCCVConfigs({ advancedPoolHooks: '0xHooks...' })

getAllLockboxAuthorizedCallers()

getAllLockboxAuthorizedCallers(opts: GetAllLockboxAuthorizedCallersParams): Promise<GetAllLockboxAuthorizedCallersResult>

Defined in: cct/evm/index.ts:3736

Lists callers authorized to deposit into or withdraw from an ERC20LockBox.

Parameters

Parameter	Type
`opts`	`GetAllLockboxAuthorizedCallersParams`

Returns

Promise<GetAllLockboxAuthorizedCallersResult>

Throws

CCTParamsInvalidError if lockbox is invalid

Throws

CCTContractTypeInvalidError if lockbox is not ERC20LockBox

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const callers = await cct.getAllLockboxAuthorizedCallers({ lockbox: '0xLockbox...' })

getAllowedFinalityConfig()

getAllowedFinalityConfig(opts: GetAllowedFinalityConfigParams): Promise<FinalityAllowed>

Defined in: cct/evm/index.ts:1488

Reads the finality modes a v2.0.0+ pool accepts.

Parameters

Parameter	Type
`opts`	`GetAllowedFinalityConfigParams`

Returns

Promise<FinalityAllowed>

Remarks

finalityDepth is the FTF minimum block depth (0 when disabled); finalitySafe is true when FCR/safe finality is allowed.

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const allowedFinality = await cct.getAllowedFinalityConfig({ poolAddress: '0xPool...' })

getAllowlist()

getAllowlist(opts: GetAllowlistParams): Promise<GetAllowlistResult>

Defined in: cct/evm/index.ts:4303

Reads the sender allowlist the pool enforces, checksummed: its own on v1.5.0–v1.6.1, its bound AdvancedPoolHooks' on v2.0.0. A v2.0.0 pool with no hooks bound reads [].

Parameters

Parameter	Type
`opts`	`GetAllowlistParams`

Returns

Promise<GetAllowlistResult>

Remarks

[] does not mean "anyone may send": pair with EVMTokenManager.getAllowlistEnabled, since an enabled allowlist with no entries rejects every sender.

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const senders = await cct.getAllowlist({ poolAddress: '0xPool...' })

getAllowlistEnabled()

getAllowlistEnabled(opts: GetAllowlistEnabledParams): Promise<boolean>

Defined in: cct/evm/index.ts:4319

Reads whether the pool enforces a sender allowlist: its own immutable flag on v1.5.0–v1.6.1, its bound AdvancedPoolHooks' on v2.0.0. A v2.0.0 pool with no hooks bound reads false.

Parameters

Parameter	Type
`opts`	`GetAllowlistEnabledParams`

Returns

Promise<boolean>

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

if (!(await cct.getAllowlistEnabled({ poolAddress: '0xPool...' })))
  console.log('any sender may transfer through this pool')

getAllSiloedLockboxConfigs()

getAllSiloedLockboxConfigs(opts: GetAllSiloedLockboxConfigsParams): Promise<GetAllSiloedLockboxConfigsResult>

Defined in: cct/evm/index.ts:2889

Reads every lane → lockbox binding of a SiloedLockReleaseTokenPool (v2.0.0): which lanes are bound, and which share a lockbox (and so share liquidity).

Parameters

Parameter	Type
`opts`	`GetAllSiloedLockboxConfigsParams`

Returns

Promise<GetAllSiloedLockboxConfigsResult>

Every binding in the contract's enumeration order, lockboxes checksummed; [] when none is bound.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool (a non-siloed pool's single lockbox is getLockbox)

Throws

CCTOperationUnsupportedError below v2.0.0 (see isSiloed)

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const bindings = await cct.getAllSiloedLockboxConfigs({ poolAddress: '0xPool...' })

getAvailableTokens()

getAvailableTokens(opts: GetAvailableTokensParams): Promise<bigint>

Defined in: cct/evm/index.ts:2759

Reads the liquidity one lane of a SiloedLockReleaseTokenPool can release (v1.6.0–v1.6.1): the silo's own balance on a siloed lane, and on any other the shared unsiloed bucket (the same value as getUnsiloedLiquidity()).

Parameters

Parameter	Type
`opts`	`GetAvailableTokensParams`

Returns

Promise<bigint>

The lane's liquidity, in the token's smallest unit.

Remarks

Informational, for audit and UX: withdrawSiloedLiquidity makes this same check itself.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, whose lanes escrow through lockboxes (see getSiloedLockbox)

Throws

CCTParamsInvalidError if any param is invalid, or the pool does not support the lane

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const available = await cct.getAvailableTokens({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

getBurners()

getBurners(opts: GetBurnersParams): Promise<GetBurnersResult>

Defined in: cct/evm/index.ts:3384

Lists every account holding a BurnMintERC677 token's burn role, via getBurners().

Parameters

Parameter	Type
`opts`	`GetBurnersParams`

Returns

Promise<GetBurnersResult>

Remarks

Same shape and caveats as getMinters; to check one address, use isBurner.

Throws

CCTParamsInvalidError if tokenAddress is not a valid, non-zero address

Throws

CCTContractTypeInvalidError if tokenAddress is not a BurnMintERC677 token (a v2.0.0 CrossChainToken included, since it gates mint/burn through AccessControl)

Example

TypeScript

const burners = await cct.getBurners({ tokenAddress: '0xToken...' })

getCCIPAdmin()

getCCIPAdmin(opts: GetCCIPAdminParams): Promise<string>

Defined in: cct/evm/index.ts:3457

Reads a token's current getCCIPAdmin(), checksummed — the single-step CCIP admin the ccip-admin registration method authorizes against.

Parameters

Parameter	Type
`opts`	`GetCCIPAdminParams`

Returns

Promise<string>

Remarks

Single-step: there is no pending CCIP admin slot, so this current value is complete (contrast getTokenDefaultAdmin, which is two-step). getCCIPAdmin() is declared identically across every supported token version.

Throws

CCTParamsInvalidError if tokenAddress is not a valid, non-zero address

Example

TypeScript

const ccipAdmin = await cct.getCCIPAdmin({ tokenAddress: '0xToken...' })

getCCVConfig()

getCCVConfig(opts: GetCCVConfigParams): Promise<CCVConfig>

Defined in: cct/evm/index.ts:1580

Reads one remote chain's complete CCV config from AdvancedPoolHooks.

Parameters

Parameter	Type
`opts`	`GetCCVConfigParams`

Returns

Promise<CCVConfig>

Remarks

An all-empty result is normal: the selector has no configured requirements. Base lists apply to every transfer; threshold lists add requirements at or above the hooks' threshold amount. address(0) selects the default CCV.

Throws

CCTParamsInvalidError if the target or remoteChainSelector is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const config = await cct.getCCVConfig({
  advancedPoolHooks: '0xHooks...',
  remoteChainSelector: 5009297550715157269n,
})

getChainRebalancer()

getChainRebalancer(opts: GetChainRebalancerParams): Promise<string>

Defined in: cct/evm/index.ts:2784

Reads the account one lane of a SiloedLockReleaseTokenPool accepts liquidity calls from (v1.6.0–v1.6.1): the silo's rebalancer on a siloed lane, and on any other the unsiloed one (getRebalancer).

Parameters

Parameter	Type
`opts`	`GetChainRebalancerParams`

Returns

Promise<string>

The rebalancer, checksummed. The zero address when none is set, meaning the lane accepts liquidity calls from nobody.

Remarks

Informational, for audit and UX: the per-lane liquidity ops make this same check themselves.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which has no rebalancer

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const rebalancer = await cct.getChainRebalancer({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

getDynamicConfig()

getDynamicConfig(opts: GetDynamicConfigParams): Promise<TokenPoolDynamicConfig>

Defined in: cct/evm/index.ts:2054

Reads a v2.0.0+ pool's router and delegated admin roles.

Parameters

Parameter	Type
`opts`	`GetDynamicConfigParams`

Returns

Promise<TokenPoolDynamicConfig>

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const config = await cct.getDynamicConfig({ poolAddress: '0xPool...' })

getFee()

getFee(opts: GetFeeParams): Promise<TokenPoolFee>

Defined in: cct/evm/index.ts:2078

Reads the fee parameters a v2.0.0+ pool applies to a destination chain and finality.

Parameters

Parameter	Type
`opts`	`GetFeeParams`

Returns

Promise<TokenPoolFee>

Remarks

getFee reports the configured USD-cent and basis-point values, not a fee amount. finality defaults to 'finalized'.

Throws

CCTParamsInvalidError if a parameter is invalid

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const fee = await cct.getFee({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

getLockbox()

getLockbox(opts: GetLockboxParams): Promise<string>

Defined in: cct/evm/index.ts:2465

Reads the ERC20LockBox a v2.0.0 LockRelease pool escrows through — fixed in its constructor and immutable thereafter.

Parameters

Parameter	Type
`opts`	`GetLockboxParams`

Returns

Promise<string>

The lockbox, checksummed.

Remarks

The address depositToLockbox / withdrawFromLockbox need: those ops target the lockbox, not the pool. Also the way to confirm a pool is wired to the lockbox you authorized, which is where a deployLockbox → deployTokenPool sequence goes wrong quietly.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool, or a SiloedLockReleaseTokenPool — a siloed pool escrows per remote chain and declares getLockBox(uint64) instead, so it has no single lockbox; see getSiloedLockbox

Throws

CCTOperationUnsupportedError below v2.0.0, where a LockRelease pool holds its liquidity itself — see getRebalancer and provideLiquidity

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const lockbox = await cct.getLockbox({ poolAddress: '0xPool...' })

getMinters()

getMinters(opts: GetMintersParams): Promise<GetMintersResult>

Defined in: cct/evm/index.ts:3368

Lists every account holding a BurnMintERC677 token's mint role, via getMinters().

Parameters

Parameter	Type
`opts`	`GetMintersParams`

Returns

Promise<GetMintersResult>

Remarks

Informational, for audit and UX. To check one address, use isMinter — one call instead of an unbounded set plus a client-side scan.

Throws

CCTParamsInvalidError if tokenAddress is not a valid, non-zero address

Throws

CCTContractTypeInvalidError if tokenAddress is not a BurnMintERC677 token (a v2.0.0 CrossChainToken included, since it gates mint/burn through AccessControl)

Example

TypeScript

const minters = await cct.getMinters({ tokenAddress: '0xToken...' })
console.log(minters) // ['0xPool...', '0xOpsKey...']

getPolicyEngine()

getPolicyEngine(opts: AdvancedPoolHooksTarget): Promise<string>

Defined in: cct/evm/index.ts:1742

Reads the hooks policy engine; the zero address means policy checks are disabled.

Parameters

Parameter	Type
`opts`	`AdvancedPoolHooksTarget`

Returns

Promise<string>

Throws

CCTParamsInvalidError if the target is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const policyEngine = await cct.getPolicyEngine({ advancedPoolHooks: '0xHooks...' })

getRebalancer()

getRebalancer(opts: GetRebalancerParams): Promise<string>

Defined in: cct/evm/index.ts:2442

Reads a LockRelease pool's rebalancer — the account allowed to move its liquidity (v1.5.0–v1.6.1).

Parameters

Parameter	Type
`opts`	`GetRebalancerParams`

Returns

Promise<string>

The rebalancer, checksummed. The zero address when none is configured, meaning the pool accepts liquidity calls from nobody.

Remarks

Informational, for audit and UX: the liquidity write ops make this same check themselves, so there is no need to call this first.

Throws

CCTContractTypeInvalidError if poolAddress is a BurnMint pool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which has no rebalancer — its ERC20LockBox authorizes its own callers

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const rebalancer = await cct.getRebalancer({ poolAddress: '0xPool...' })

getRequiredCCVs()

getRequiredCCVs(opts: GetRequiredCCVsParams): Promise<GetRequiredCCVsResult>

Defined in: cct/evm/index.ts:1626

Resolves the CCVs required for a proposed inbound or outbound transfer.

Parameters

Parameter	Type
`opts`	`GetRequiredCCVsParams`

Returns

Promise<GetRequiredCCVsResult>

Remarks

This is the hooks contract's current decision for the selector, amount, and direction; it includes threshold CCVs when the amount reaches the configured threshold. The standard AdvancedPoolHooks ignores the interface's token/finality/extra-data arguments, so this query supplies their neutral values internally.

Throws

CCTParamsInvalidError if a param is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const ccvs = await cct.getRequiredCCVs({
  advancedPoolHooks: '0xHooks...',
  remoteChainSelector: 5009297550715157269n,
  amount: 1_000_000n,
  direction: 'outbound',
})

getSiloedLockbox()

getSiloedLockbox(opts: GetSiloedLockboxParams): Promise<string>

Defined in: cct/evm/index.ts:2915

Reads the ERC20LockBox one lane of a SiloedLockReleaseTokenPool (v2.0.0) escrows through: the pool's getLockBox(remoteChainSelector).

Parameters

Parameter	Type
`opts`	`GetSiloedLockboxParams`

Returns

Promise<string>

The lane's lockbox, checksummed.

Remarks

The address depositToLockbox / withdrawFromLockbox need to fund or drain that lane. getAllSiloedLockboxConfigs lists every lane without throwing.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool (a non-siloed pool's single lockbox is getLockbox)

Throws

CCTOperationUnsupportedError below v2.0.0

Throws

CCTParamsInvalidError if any param is invalid, or no lockbox is bound to the lane; bind one with configureSiloedLockboxes

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const lockbox = await cct.getSiloedLockbox({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

getSupportedTokens()

getSupportedTokens(opts: GetSupportedTokensParams): Promise<GetSupportedTokensResult>

Defined in: cct/evm/index.ts:596

Lists every token configured in the TokenAdminRegistry resolved from address.

Parameters

Parameter	Type
`opts`	`GetSupportedTokensParams`

Returns

Promise<GetSupportedTokensResult>

Remarks

The registry paginates via getAllConfiguredTokens — opts.page sets the batch size per call; omit it to read the whole registry in one round trip per 1000 tokens.

Throws

CCTParamsInvalidError if address is not a valid address, or page is given and is not a positive integer

Example

TypeScript

const tokens = await cct.getSupportedTokens({ address: '0xTokenAdminRegistry...' })

getThresholdAmount()

getThresholdAmount(opts: AdvancedPoolHooksTarget): Promise<bigint>

Defined in: cct/evm/index.ts:1759

Reads the amount at which additional CCVs apply; zero means they are disabled.

Parameters

Parameter	Type
`opts`	`AdvancedPoolHooksTarget`

Returns

Promise<bigint>

Throws

CCTParamsInvalidError if the target is invalid, or poolAddress has no hooks bound

Throws

CCTContractTypeInvalidError if the target is not AdvancedPoolHooks

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Example

TypeScript

const thresholdAmount = await cct.getThresholdAmount({ advancedPoolHooks: '0xHooks...' })

getTokenAdminRegistry()

getTokenAdminRegistry(opts: GetTokenAdminRegistryParams): Promise<RegistryTokenConfig>

Defined in: cct/evm/index.ts:581

Reads a token's TokenAdminRegistry entry: its administrator, any pendingAdministrator, and its registered tokenPool.

Parameters

Parameter	Type
`opts`	`GetTokenAdminRegistryParams`

Returns

Promise<RegistryTokenConfig>

Remarks

Deliberately diverges from cct.chain.getRegistryTokenConfig(), which throws when administrator is the zero address — exactly the post-registerAdmin, pre-acceptAdmin state. This op reports { administrator: ZeroAddress, pendingAdministrator } faithfully instead, so a pending registration is observable; see GetTokenAdminRegistry for the full rationale. pendingAdministrator and tokenPool are still omitted when zero.

Throws

CCTParamsInvalidError if any param is invalid

Example

TypeScript

const config = await cct.getTokenAdminRegistry({
  address: '0xTokenAdminRegistry...', // or a Router/OnRamp/OffRamp/pool to resolve it from
  tokenAddress: '0xToken...',
})
if (config.administrator === ZeroAddress) {
  console.log('pending acceptance by', config.pendingAdministrator)
}

getTokenDefaultAdmin()

getTokenDefaultAdmin(opts: GetTokenDefaultAdminParams): Promise<GetTokenDefaultAdminResult>

Defined in: cct/evm/index.ts:3479

Reads a v2.0.0 CrossChainToken's AccessControl default admin: its current defaultAdmin and any scheduled pendingDefaultAdmin ({ newAdmin, schedule }), together.

Parameters

Parameter	Type
`opts`	`GetTokenDefaultAdminParams`

Returns

Promise<GetTokenDefaultAdminResult>

Remarks

pendingDefaultAdmin is omitted when no transfer is scheduled — test with 'pendingDefaultAdmin' in result, not a zero-address compare, mirroring getTokenAdminRegistry's pendingAdministrator. v2.0.0 CrossChainToken only; a v1.x FactoryBurnMintERC20 has no default admin — read its getTokenOwner instead.

Throws

CCTParamsInvalidError if tokenAddress is not a valid, non-zero address

Example

TypeScript

const { defaultAdmin, pendingDefaultAdmin } = await cct.getTokenDefaultAdmin({
  tokenAddress: '0xToken...',
})
if (pendingDefaultAdmin) {
  console.log('pending', pendingDefaultAdmin.newAdmin, 'at', pendingDefaultAdmin.schedule)
}

getTokenOwner()

getTokenOwner(opts: GetTokenOwnerParams): Promise<string>

Defined in: cct/evm/index.ts:3441

Reads a token's current owner() (Ownable2Step), checksummed — the authority that grants and revokes mint/burn roles on a BurnMintERC677 token.

Parameters

Parameter	Type
`opts`	`GetTokenOwnerParams`

Returns

Promise<string>

Remarks

Current owner only. A token's proposed owner is a private slot with no getter, so a pending transfer cannot be read on EVM (same limitation as a v1 acceptDefaultAdminTransfer / acceptPoolOwnership). On a v2.0.0 CrossChainToken, owner() aliases the DEFAULT_ADMIN_ROLE holder — use getTokenDefaultAdmin for its pending transfer.

Throws

CCTParamsInvalidError if tokenAddress is not a valid, non-zero address

Example

TypeScript

const owner = await cct.getTokenOwner({ tokenAddress: '0xToken...' })

getTokenPoolRemotes()

getTokenPoolRemotes(opts: GetTokenPoolRemotesParams): Promise<GetTokenPoolRemotesResult>

Defined in: cct/evm/index.ts:3930

Reads a pool's remote-lane configuration, v1.5.0 through v2.0.0: for each configured remote chain, the remoteToken, the remotePools authorized to mint/release against it, and the inbound/outbound rate-limiter buckets. Keyed by remote network name.

Parameters

Parameter	Type
`opts`	`GetTokenPoolRemotesParams`

Returns

Promise<GetTokenPoolRemotesResult>

Remarks

Omit remoteChainSelector to scan every lane the pool reports through getSupportedChains(); provide it to read one, which is the cheaper call by far on a pool with many lanes. Passing a selector the pool has no config for surfaces as CCIPTokenPoolChainConfigNotFoundError rather than an empty result.

A lane's rate limiter is nullable: inboundRateLimiterState / outboundRateLimiterState are null when that direction is unlimited, so check for null before reading .capacity. Amounts are in the local token's smallest unit. On v2.0.0 pools each entry additionally carries fastInboundRateLimiterState / fastOutboundRateLimiterState, the separate buckets applied to Faster-Than-Finality and safe-finality (FCR) transfers.

Throws

CCTParamsInvalidError if poolAddress is not a valid address, or remoteChainSelector is given and is not a uint64

Throws

CCIPTokenPoolChainConfigNotFoundError if a scanned lane has no remote token configured

Example

TypeScript

// every configured lane
const remotes = await cct.getTokenPoolRemotes({ poolAddress: '0xPool...' })
for (const [network, lane] of Object.entries(remotes)) {
  const inbound = lane.inboundRateLimiterState
  console.log(network, lane.remoteToken, lane.remotePools, inbound?.capacity ?? 'unlimited')
}

// or just one, avoiding a full scan
const one = await cct.getTokenPoolRemotes({
  poolAddress: '0xPool...',
  remoteChainSelector: 5009297550715157269n, // ethereum-mainnet
})

getTokenPoolState()

getTokenPoolState(opts: GetTokenPoolStateParams): Promise<GetTokenPoolStateResult>

Defined in: cct/evm/index.ts:3886

Reads a pool's admin state, v1.5.0 through v2.0.0: the owner every pool write is gated on, the rateLimitAdmin role, its token/router and configured lanes — plus, on v2.0.0 pools, the feeAdmin role, the allowed finality window, and a lock/release pool's lockBox.

Parameters

Parameter	Type
`opts`	`GetTokenPoolStateParams`

Returns

Promise<GetTokenPoolStateResult>

Remarks

The result is a union: state.version === '2.0.0' gates the roles and finality window that version added, and state.type === 'LockReleaseTokenPool' gates its lockBox (see the example) — a SiloedLockReleaseTokenPool reports no lockBox, since it escrows per remote chain (read those with getAllSiloedLockboxConfigs). For a legacy pool's allowList / rebalancer, proxy/USDC pools, or a v1.5.0 *AndProxy pool's previousPool (it reads here as its base type), use cct.chain.getTokenPoolConfig(), the tolerant transfer-flow read. No pool version exposes a pending-owner getter, so a proposed owner is not readable here.

Throws

CCTParamsInvalidError if poolAddress is not a valid address

Throws

CCTContractTypeInvalidError if the pool is not a supported CCT pool type

Throws

CCTContractVersionUnsupportedError if the pool's version is not a known one

Example

TypeScript

const state = await cct.getTokenPoolState({ poolAddress: '0xPool...' })
// state.owner must sign transferPoolOwnership / lane config; state.rateLimitAdmin may set rate limits
if (state.version === '2.0.0') {
  console.log(state.feeAdmin, state.finalityDepth)
  if (state.type === 'LockReleaseTokenPool') console.log(state.lockBox)
}

getTokenTransferFeeConfig()

getTokenTransferFeeConfig(opts: GetTokenTransferFeeConfigParams): Promise<TokenTransferFeeConfig>

Defined in: cct/evm/index.ts:2102

Reads token-transfer fee configuration for a destination chain from a v2.0.0+ pool.

Parameters

Parameter	Type
`opts`	`GetTokenTransferFeeConfigParams`

Returns

Promise<TokenTransferFeeConfig>

Remarks

The pool token is read automatically. finality and tokenArgs default to 'finalized' and '0x', respectively, which are correct for standard pools.

Throws

CCTParamsInvalidError if a parameter is invalid

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const config = await cct.getTokenTransferFeeConfig({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

grantBurnRole()

grantBurnRole(opts: EVMExecuteParams<GrantBurnRoleParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3167

Grants a supported CCT token's burn role to one account, signing + submitting with opts.wallet (the v1 token owner or v2 burn-role admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`GrantBurnRoleParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedGrantBurnRole for the version and redundancy rules.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet lacks the version's role-admin permission, or burner already holds the role

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.grantBurnRole({
  tokenAddress: '0xToken...',
  burner: '0xBurner...',
  wallet, // v1 token owner or v2 burn-role admin
})

grantMintAndBurnRoles()

grantMintAndBurnRoles(opts: EVMExecuteParams<GrantMintAndBurnRolesParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3034

Grants a supported CCT token's mint and burn roles to one account, signing + submitting with opts.wallet (the v1 token owner or v2 mint/burn role admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`GrantMintAndBurnRolesParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedGrantMintAndBurnRoles for the version and redundancy rules. sender defaults to the wallet's address, so the role-admin gate always runs before this submits.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet lacks the version's role-admin permission, or burnAndMinter already holds both roles

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.grantMintAndBurnRoles({
  tokenAddress: '0xToken...',
  burnAndMinter: '0xPool...',
  wallet, // v1 token owner or v2 mint/burn role admin
})

grantMintRole()

grantMintRole(opts: EVMExecuteParams<GrantMintRoleParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3102

Grants a supported CCT token's mint role to one account, signing + submitting with opts.wallet (the v1 token owner or v2 mint-role admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`GrantMintRoleParams`>

Returns

Promise<TransactionResult>

See

generateUnsignedGrantMintRole for the version and redundancy rules.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet lacks the version's role-admin permission, or minter already holds the role

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.grantMintRole({
  tokenAddress: '0xToken...',
  minter: '0xMinter...',
  wallet, // v1 token owner or v2 mint-role admin
})

isBurner()

isBurner(opts: IsBurnerParams): Promise<boolean>

Defined in: cct/evm/index.ts:3424

Reads whether account holds a supported CCT token's burn role.

Parameters

Parameter	Type
`opts`	`IsBurnerParams`

Returns

Promise<boolean>

Remarks

v1 uses isBurner(address); v2 uses AccessControl hasRole. Use this individual membership check rather than getBurners, which is v1-only.

Throws

CCTParamsInvalidError if tokenAddress or account is not a valid, non-zero address

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Example

TypeScript

const poolCanBurn = await cct.isBurner({ tokenAddress: '0xToken...', account: '0xPool...' })

isMinter()

isMinter(opts: IsMinterParams): Promise<boolean>

Defined in: cct/evm/index.ts:3405

Reads whether account holds a supported CCT token's mint role.

Parameters

Parameter	Type
`opts`	`IsMinterParams`

Returns

Promise<boolean>

Remarks

v1 uses isMinter(address); v2 uses AccessControl hasRole. Use this individual membership check rather than getMinters, which is v1-only.

Throws

CCTParamsInvalidError if tokenAddress or account is not a valid, non-zero address

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Example

TypeScript

if (await cct.isMinter({ tokenAddress: '0xToken...', account: '0xOpsKey...' })) {
  await cct.mint({ tokenAddress: '0xToken...', account: '0xRecipient...', amount, wallet })
}

isSiloed()

isSiloed(opts: IsSiloedParams): Promise<boolean>

Defined in: cct/evm/index.ts:2807

Reads whether one lane of a SiloedLockReleaseTokenPool has its own silo (v1.6.0–v1.6.1). A siloed lane is funded with provideSiloedLiquidity; any other shares the unsiloed bucket (provideLiquidity). Silos are set with updateSiloDesignations.

Parameters

Parameter	Type
`opts`	`IsSiloedParams`

Returns

Promise<boolean>

true if the lane is siloed; false for lane 0 and for any unknown lane.

Throws

CCTContractTypeInvalidError if poolAddress is not a SiloedLockReleaseTokenPool

Throws

CCTOperationUnsupportedError on a v2.0.0 pool, which isolates lanes with separate lockboxes instead (see getAllSiloedLockboxConfigs)

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Example

TypeScript

const siloed = await cct.isSiloed({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
})

mint()

mint(opts: EVMExecuteParams<MintParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3349

Mints new supply of a BurnMintERC677 token to account, signing + submitting with opts.wallet (an address holding the token's mint role).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`MintParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedMint for the version and role rules. sender defaults to the wallet's address, so the mint-role check always runs before this submits.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is not a BurnMintERC677 token (a v2.0.0 CrossChainToken included, since it gates mint/burn through AccessControl)

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet does not hold the token's mint role

Throws

CCIPExecTxRevertedError if the tx reverts on-chain — e.g. the mint would exceed the token's maxSupply, which is not pre-flighted

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.mint({
  tokenAddress: '0xToken...',
  account: '0xRecipient...',
  amount: 1_000_000000000000000000n,
  wallet, // must hold the mint role
})

provideLiquidity()

provideLiquidity(opts: EVMExecuteParams<ProvideLiquidityParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2223

Deposits liquidity into a LockRelease pool, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must be the pool's rebalancer, and must have approved amount to the pool with approveToken.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ProvideLiquidityParams`>

Returns

Promise<TransactionResult>

Remarks

On a SiloedLockReleaseTokenPool this funds the unsiloed bucket only.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet is not the pool's rebalancer

Throws

CCTTxFailedError if the wallet's token balance or its approval to the pool is below amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.provideLiquidity({
  poolAddress: '0xPool...',
  amount: 1_000000000000000000n,
  wallet, // the pool rebalancer
})

provideSiloedLiquidity()

provideSiloedLiquidity(opts: EVMExecuteParams<ProvideSiloedLiquidityParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2541

Deposits liquidity into one lane's silo of a siloed pool, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it: the wallet must be the silo's rebalancer, and must have approved amount to the pool with approveToken.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`ProvideSiloedLiquidityParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, the lane is not siloed, sender is given and is not the wallet's address, or the wallet is not the silo's rebalancer

Throws

CCTTxFailedError if the wallet's token balance or its approval to the pool is below amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

// the deposit is a transferFrom: approve the pool first
await cct.approveToken({
  tokenAddress: '0xToken...',
  spender: '0xPool...',
  amount: 1_000000000000000000n,
  wallet,
})
const { hash } = await cct.provideSiloedLiquidity({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  amount: 1_000000000000000000n,
  wallet, // the silo rebalancer
})

registerAdmin()

registerAdmin(opts: EVMExecuteParams<RegisterAdminParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:421

Proposes a token's administrator in the TokenAdminRegistry via a RegistryModuleOwnerCustom, signing + submitting with opts.wallet. Two-step by design — the proposed administrator must then call acceptAdmin.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RegisterAdminParams`>

Returns

Promise<TransactionResult>

Remarks

The administrator is not a parameter — see generateUnsignedRegisterAdmin. sender also defaults to opts.wallet's address here (unlike the unsigned builder, where it's optional for offline/multisig flows), so the token-authority check always runs before this signs and submits.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

// `wallet` must be the token's owner (or CCIP admin / hold DEFAULT_ADMIN_ROLE, matching
// `registrationMethod`) — enforced automatically since `sender` defaults to its address.
const { hash } = await cct.registerAdmin({
  tokenAddress: '0xToken...',
  registryModule: '0xRegistryModuleOwnerCustom...',
  address: '0xTokenAdminRegistry...',
  wallet,
})

removeRemotePool()

removeRemotePool(opts: EVMExecuteParams<RemotePoolParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:4115

De-authorizes a remote pool on one lane of a v1.5.1+ pool, signing + submitting with opts.wallet. See generateUnsignedRemoveRemotePool for the version range, the remotePoolAddress encoding and the membership pre-check.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RemotePoolParams`>

Returns

Promise<TransactionResult>

Remarks

sender defaults to the signing wallet, which must be the pool owner; passing a different sender is rejected rather than signed — build with generateUnsignedRemoveRemotePool for externally-signed flows.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address / the pool owner, or remotePoolAddress is not registered on that lane

Throws

CCTOperationUnsupportedError if the pool is v1.5.0

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.removeRemotePool({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  remotePoolAddress: '0xDrainedRemotePool...',
  wallet, // the pool owner
})

revokeBurnRole()

revokeBurnRole(opts: EVMExecuteParams<RevokeBurnRoleParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3291

Removes a supported CCT token's burn role from one account, signing + submitting with opts.wallet (the v1 token owner or v2 burn-role admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RevokeBurnRoleParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedRevokeBurnRole for the version and role-state rules.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet lacks the version's role-admin permission, or burner does not hold the role

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.revokeBurnRole({
  tokenAddress: '0xToken...',
  burner: '0xOldPool...',
  wallet, // v1 token owner or v2 burn-role admin
})

revokeMintRole()

revokeMintRole(opts: EVMExecuteParams<RevokeMintRoleParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3229

Removes a supported CCT token's mint role from one account, signing + submitting with opts.wallet (the v1 token owner or v2 mint-role admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RevokeMintRoleParams`>

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedRevokeMintRole for the version and role-state rules.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is neither a BurnMintERC677 token nor a supported CrossChainToken

Throws

CCTContractVersionUnsupportedError if CrossChainToken reports an unsupported version

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the wallet lacks the version's role-admin permission, or minter does not hold the role

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.revokeMintRole({
  tokenAddress: '0xToken...',
  minter: '0xOldPool...',
  wallet, // v1 token owner or v2 mint-role admin
})

setAllowedFinalityConfig()

setAllowedFinalityConfig(opts: EVMExecuteParams<SetAllowedFinalityConfigParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1321

Sets the finality modes a v2.0.0 pool accepts, signing + submitting as its owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetAllowedFinalityConfigParams`>

Returns

Promise<TransactionResult>

Remarks

This replaces the whole finality config: allowedFinality.finalityDepth is an integer in [0, 65535], and 0 disables FTF; omitting allowedFinality.finalitySafe disables FCR. To preserve one setting while changing the other, first call getAllowedFinalityConfig. sender defaults to the wallet address and, when supplied, must equal it.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, sender differs from the wallet, or the wallet is not the pool owner

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.setAllowedFinalityConfig({
  poolAddress: '0xPool...',
  allowedFinality: { finalityDepth: 5, finalitySafe: true },
  wallet,
})

setCCIPAdmin()

setCCIPAdmin(opts: EVMExecuteParams<SetCCIPAdminParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1029

Sets a v2.0.0 CrossChainToken CCIP admin, signing + submitting with opts.wallet (the current default admin).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetCCIPAdminParams`>

Returns

Promise<TransactionResult>

Remarks

sender defaults to the wallet address, so the default-admin gate runs before broadcast.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if tokenAddress is not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

CCTParamsInvalidError if any param is invalid, sender differs from the wallet, or the wallet is not the current default admin

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.setCCIPAdmin({
  tokenAddress: '0xToken...',
  newAdmin: '0xCCIPAdmin...',
  wallet, // current default admin
})

setChainRateLimiterConfigs()

setChainRateLimiterConfigs(opts: EVMExecuteParams<SetChainRateLimiterConfigsParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1125

Sets the inbound and outbound rate limits of one or more already-configured lanes in a single transaction, signing + submitting with opts.wallet.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetChainRateLimiterConfigsParams`>

Returns

Promise<TransactionResult>

Remarks

Gated on either the pool owner or its rateLimitAdmin — rate limits are the one pool write that accepts a delegated role, so this check is a disjunction where transferPoolOwnership's is owner-only. Both roles are reported by getTokenPoolState; rateLimitAdmin is the zero address when unset, and an unset role matches nobody.

Same version rules as generateUnsignedSetChainRateLimiterConfigs: v1.5.0 pools set one lane per transaction, and fastFinality is v2.0.0-only.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or if sender is given and is not the wallet's address, or the signer is neither the pool owner nor its (set) rateLimitAdmin. On a v1.5.1 or v1.6.0 pool an enabled rate limiter must additionally satisfy 0 < rate < capacity, so a rate of 0n or a rate equal to capacity is rejected there — v1.6.1 and v2.0.0 allow both. A v1.5.0 pool accepts only a single-element updates.

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.setChainRateLimiterConfigs({
  poolAddress: '0xPool...',
  updates: [
    {
      remoteChainSelector: 16015286601757825753n, // ethereum-testnet-sepolia
      outboundRateLimiterConfig: { enabled: true, capacity: 1_000n * 10n ** 18n, rate: 10n * 10n ** 18n },
      inboundRateLimiterConfig: { enabled: true, capacity: 1_000n * 10n ** 18n, rate: 10n * 10n ** 18n },
      // fastFinality: true, // v2.0.0 pools only — targets the fast-finality buckets
    },
  ],
  wallet, // the pool owner or its rateLimitAdmin
})

setDynamicConfig()

setDynamicConfig(opts: EVMExecuteParams<SetDynamicConfigParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1256

Replaces a v2.0.0 pool's dynamic config, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetDynamicConfigParams`>

Returns

Promise<TransactionResult>

Remarks

Writes all three fields in one call, so all three params are required: read the current triple with getTokenPoolState and pass back whatever you are not changing, as below. A missing field is a validation error, never "leave that one alone" — nothing is backfilled from getDynamicConfig(); see generateUnsignedSetDynamicConfig for why. On a 2.0.0 pool this replaces setRateLimitAdmin.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool — use setRateLimitAdmin

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

// change only rateLimitAdmin: read the current config and pass the rest back unchanged
const state = await cct.getTokenPoolState({ poolAddress: '0xPool...' })
if (state.version !== '2.0.0') throw new Error('pre-2.0.0 pool: use setRateLimitAdmin')
const { hash } = await cct.setDynamicConfig({
  poolAddress: '0xPool...',
  router: state.router,
  rateLimitAdmin: '0xOpsMultisig...',
  feeAdmin: state.feeAdmin,
  wallet,
})

setPolicyEngine()

setPolicyEngine(opts: EVMExecuteParams<SetPolicyEngineParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1882

Attaches a policy engine to an AdvancedPoolHooks, signing + submitting as its owner. Pass the zero address to disable policy checks. Use generateUnsignedSetPolicyEngine for multisig or offline signing.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetPolicyEngineParams`>

Returns

Promise<TransactionResult>

Remarks

The hooks contract detaches the old engine before attaching the new one. A reverting old-engine detach reverts this transaction; use the contract's explicit recovery setter if that is intentional.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, a non-zero engine has no deployed code, sender differs from the wallet, or the wallet is not the hooks owner

Throws

CCIPExecTxRevertedError if the transaction reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.setPolicyEngine({
  advancedPoolHooks: '0xHooks...',
  newPolicyEngine: '0xPolicyEngine...',
  wallet,
})

setPool()

setPool(opts: EVMExecuteParams<SetPoolParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:462

Registers a pool, signing + submitting with opts.wallet (the token admin). A zero/empty poolAddress delists the token from the registry.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetPoolParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

// `wallet` must sign as the token's current administrator
const { hash } = await cct.setPool({
  tokenAddress: '0xToken...',
  poolAddress: '0xPool...', // pass the zero address to delist the token
  address: '0xTokenAdminRegistry...',
  wallet,
})

setRateLimitAdmin()

setRateLimitAdmin(opts: EVMExecuteParams<SetRateLimitAdminParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1183

Assigns the pool's rate-limit admin role, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetRateLimitAdminParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool — use setDynamicConfig

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.setRateLimitAdmin({
  poolAddress: '0xPool...',
  newRateLimitAdmin: '0xOpsMultisig...',
  wallet,
})

setRebalancer()

setRebalancer(opts: EVMExecuteParams<SetRebalancerParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2418

Appoints the pool's rebalancer, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetRebalancerParams`>

Returns

Promise<TransactionResult>

Remarks

On a SiloedLockReleaseTokenPool this sets the unsiloed rebalancer only.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.setRebalancer({
  poolAddress: '0xPool...',
  rebalancer: '0xLiquidityOps...',
  wallet, // the pool owner
})

setRemotePool()

setRemotePool(opts: EVMExecuteParams<RemotePoolParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3991

Replaces the remote pool a v1.5.0 pool accepts on one lane, signing + submitting with opts.wallet. See generateUnsignedSetRemotePool for the version range and the remotePoolAddress encoding.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`RemotePoolParams`>

Returns

Promise<TransactionResult>

Remarks

sender defaults to the signing wallet, which must be the pool owner; passing a different sender is rejected rather than signed — build with generateUnsignedSetRemotePool for externally-signed flows.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or sender is given and is not the wallet's address / the pool owner

Throws

CCTOperationUnsupportedError if the pool is v1.5.1 or newer

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.setRemotePool({
  poolAddress: '0xPool...', // a v1.5.0 pool
  remoteChainSelector: 5009297550715157269n,
  remotePoolAddress: '0xRemotePool...',
  wallet, // the pool owner
})

setSiloRebalancer()

setSiloRebalancer(opts: EVMExecuteParams<SetSiloRebalancerParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2669

Appoints one lane's silo rebalancer, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it: the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetSiloRebalancerParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, the lane is not siloed, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.setSiloRebalancer({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  rebalancer: '0xSiloRebalancer...',
  wallet, // the pool owner
})

setThresholdAmount()

setThresholdAmount(opts: EVMExecuteParams<SetThresholdAmountParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1939

Sets the amount at which an AdvancedPoolHooks requires additional CCVs, signing + submitting as its owner. Pass zero to disable threshold CCVs. Use generateUnsignedSetThresholdAmount for multisig or offline signing.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`SetThresholdAmountParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, sender differs from the wallet, or the wallet is not the hooks owner

Throws

CCIPExecTxRevertedError if the transaction reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.setThresholdAmount({
  advancedPoolHooks: '0xHooks...',
  thresholdAmount: 1_000_000n,
  wallet,
})

transferAdmin()

transferAdmin(opts: EVMExecuteParams<TransferAdminParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:511

Proposes a new TokenAdminRegistry administrator, signing + submitting with opts.wallet (the current registry admin). Two-step: newAdmin must separately call acceptAdmin. This is the registry's ADMIN role — distinct from a pool's Ownable2Step owner (see transferPoolOwnership); do not confuse the two.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`TransferAdminParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, if the signing wallet is not the token's current registry administrator (including a not-yet-accepted registration), or if an explicit opts.sender does not match the wallet's address

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

// `wallet` must sign as the token's current registry administrator; `sender` defaults to its
// address, so pass it only for offline builds via generateUnsignedTransferAdmin.
const { hash } = await cct.transferAdmin({
  tokenAddress: '0xToken...',
  newAdmin: '0xNewAdmin...',
  address: '0xTokenAdminRegistry...',
  wallet,
})

transferLiquidity()

transferLiquidity(opts: EVMExecuteParams<TransferLiquidityParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2360

Migrates liquidity from an older LockRelease pool into this one, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it — the wallet must own the destination pool. See generateUnsignedTransferLiquidity for the two-step rebalancer wiring this depends on.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`TransferLiquidityParams`>

Returns

Promise<TransactionResult>

Remarks

A SiloedLockReleaseTokenPool source gives up only its unsiloed bucket, and MaxUint256 from one is rejected.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, the source pool is not wired to poolAddress, amount is MaxUint256 from a siloed from, or the wallet does not own poolAddress

Throws

CCTTxFailedError if from's withdrawable liquidity is below amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain, e.g. InsufficientLiquidity when the source pool holds less than amount

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.transferLiquidity({
  poolAddress: newPool,
  from: oldPool,
  amount: 1_000000000000000000n,
  wallet, // owner of the new pool
})

transferPoolOwnership()

transferPoolOwnership(opts: EVMExecuteParams<TransferPoolOwnershipParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:646

Proposes a new pool owner, signing + submitting with opts.wallet — which must be the pool's current owner, and is what sender defaults to. Step one of two, per generateUnsignedTransferPoolOwnership: ownership moves only once newOwner calls acceptPoolOwnership.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`TransferPoolOwnershipParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, if newOwner equals the signer, if sender is given and is not the wallet's address, or if the signer is not the pool owner

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

const { hash } = await cct.transferPoolOwnership({
  poolAddress: '0xPool...',
  newOwner: '0xNewOwner...',
  wallet, // the current pool owner
})

transferTokenOwnership()

transferTokenOwnership(opts: EVMExecuteParams<TransferTokenOwnershipParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:739

Proposes a new token admin (or retracts, for a zero newOwner), signing + submitting with opts.wallet — which must be the token's current admin, and is what sender defaults to.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`TransferTokenOwnershipParams`>

Returns

Promise<TransactionResult>

Deprecated

Use beginDefaultAdminTransfer, or cancelDefaultAdminTransfer to retract.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, if sender is given and is not the wallet's address, or per the method it routes to

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

const { hash } = await cct.transferTokenOwnership({
  tokenAddress: '0xToken...',
  newOwner: '0xNewOwner...',
  wallet, // the current token owner
})

updateAdvancedPoolHooks()

updateAdvancedPoolHooks(opts: EVMExecuteParams<UpdateAdvancedPoolHooksParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2012

Points a v2.0.0 pool at an AdvancedPoolHooks contract, or detaches the current one with the zero address. Owner-only.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`UpdateAdvancedPoolHooksParams`>

Returns

Promise<TransactionResult>

Remarks

This moves the pool's entire allowlist and CCV posture in one transaction: the new contract's configuration takes effect for the next transfer, and the old one's stops applying. Detaching leaves the pool enforcing neither.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported, or a non-zero advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if poolAddress is zero/invalid, advancedPoolHooks is invalid, the pool is already bound to it, or sender differs from the wallet

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.updateAdvancedPoolHooks({
  poolAddress: '0xPool...',
  advancedPoolHooks: '0xHooks...',
  wallet,
})

updateAdvancedPoolHooksAuthorizedCallers()

updateAdvancedPoolHooksAuthorizedCallers(opts: EVMExecuteParams<UpdateAdvancedPoolHooksAuthorizedCallersParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1817

Updates callers permitted to invoke hooks checks, signing + submitting as the hooks owner. Use generateUnsignedUpdateAdvancedPoolHooksAuthorizedCallers for multisig or offline signing.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`UpdateAdvancedPoolHooksAuthorizedCallersParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCTContractTypeInvalidError if the target is not an AdvancedPoolHooks contract

Throws

CCTOperationUnsupportedError if poolAddress is a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, poolAddress has no hooks bound, sender differs from the wallet, or the wallet is not the hooks owner

Throws

CCIPExecTxRevertedError if the transaction reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.updateAdvancedPoolHooksAuthorizedCallers({
  advancedPoolHooks: '0xHooks...',
  addedCallers: ['0xPool...'],
  wallet,
})

updateLockboxAuthorizedCallers()

updateLockboxAuthorizedCallers(opts: EVMExecuteParams<UpdateLockboxAuthorizedCallersParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3718

Adds/removes authorized callers on an ERC20LockBox, signing + submitting with opts.wallet (the lockbox owner). Authorize the LockReleaseTokenPool before it can lock/release.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`UpdateLockboxAuthorizedCallersParams`>

Returns

Promise<TransactionResult>

Remarks

Rejects a lockbox that is not a deployed, supported ERC20LockBox, and a wallet that is not its owner, before the wallet is asked to sign; see generateUnsignedUpdateLockboxAuthorizedCallers.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, if no caller is supplied, if nothing at lockbox answers typeAndVersion(), if sender differs from the wallet, or if the wallet is not the lockbox owner

Throws

CCTContractTypeInvalidError if lockbox is a different contract

Throws

CCTContractVersionUnsupportedError if lockbox reports an unsupported version

Throws

CCIPTypeVersionInvalidError if lockbox answers typeAndVersion() with an unparseable string

Throws

CCTTxFailedError if the tx reverts or fails

Example

TypeScript

// `wallet` must sign as the lockbox owner
const { hash } = await cct.updateLockboxAuthorizedCallers({
  lockbox: '0xLockbox...',
  addedCallers: ['0xPool...'],
  wallet,
})

updateSiloDesignations()

updateSiloDesignations(opts: EVMExecuteParams<UpdateSiloDesignationsParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2731

Designates and un-designates silos, signing + submitting with opts.wallet. sender defaults to the wallet's address and must equal it: the wallet must be the pool owner.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`UpdateSiloDesignationsParams`>

Returns

Promise<TransactionResult>

Remarks

A remove moves the silo's balance into the shared unsiloed bucket; an add starts at 0.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, a lane fails a state check, sender is given and is not the wallet's address, or the wallet is not the pool owner

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.updateSiloDesignations({
  poolAddress: '0xPool...',
  removes: [16015286601757825753n],
  adds: [],
  wallet, // the pool owner
})

withdrawFeeTokens()

withdrawFeeTokens(opts: EVMExecuteParams<WithdrawFeeTokensParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:1467

Withdraws the selected fee-token balances from a v2.0.0 pool to recipient.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`WithdrawFeeTokensParams`>

Returns

Promise<TransactionResult>

Remarks

The signing wallet must be the pool owner or delegated feeAdmin.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTContractTypeInvalidError if the pool's reported type is not supported

Throws

CCTOperationUnsupportedError on a pre-v2.0.0 pool

Throws

CCTParamsInvalidError if a param is invalid, sender differs from the wallet, or the wallet holds neither role

Throws

CCTContractVersionUnsupportedError if the pool reports an unknown version

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const cct = EVMTokenManager.fromChain(chain)
const { hash } = await cct.withdrawFeeTokens({
  poolAddress: '0xPool...',
  feeTokens: ['0xFeeToken...'],
  recipient: '0xRecipient...',
  wallet, // pool owner or configured feeAdmin
})

withdrawFromLockbox()

withdrawFromLockbox(opts: EVMExecuteParams<WithdrawFromLockboxParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:3850

Withdraws tokens from an ERC20LockBox to recipient, signing + submitting with opts.wallet (an authorized caller of the lockbox).

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`WithdrawFromLockboxParams`>

Returns

Promise<TransactionResult>

Remarks

The tokens go to recipient, which need not be the wallet.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTParamsInvalidError if any param is invalid, or the wallet is not an authorized caller of the lockbox

Throws

CCTTxFailedError if the lockbox holds less than amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.withdrawFromLockbox({
  lockbox,
  token,
  amount: MaxUint256, // the whole balance
  recipient: '0xTreasury...',
  wallet,
})

withdrawLiquidity()

withdrawLiquidity(opts: EVMExecuteParams<WithdrawLiquidityParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2283

Withdraws liquidity from a LockRelease pool to the signing wallet, which must be the pool's rebalancer. sender defaults to the wallet's address and must equal it.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`WithdrawLiquidityParams`>

Returns

Promise<TransactionResult>

Remarks

On a SiloedLockReleaseTokenPool this draws on the unsiloed bucket only.

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, sender is given and is not the wallet's address, or the wallet is not the pool's rebalancer

Throws

CCIPExecTxRevertedError if the tx reverts on-chain, e.g. InsufficientLiquidity

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.withdrawLiquidity({
  poolAddress: '0xPool...',
  amount: 1_000000000000000000n,
  wallet, // the pool rebalancer, which also receives the tokens
})

withdrawSiloedLiquidity()

withdrawSiloedLiquidity(opts: EVMExecuteParams<WithdrawSiloedLiquidityParams>): Promise<TransactionResult>

Defined in: cct/evm/index.ts:2607

Withdraws liquidity from one lane's silo to the signing wallet, which must be the silo's rebalancer. sender defaults to the wallet's address and must equal it.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`WithdrawSiloedLiquidityParams`>

Returns

Promise<TransactionResult>

Throws

CCIPWalletInvalidError if wallet is not a valid signer

Throws

CCIPWalletChainMismatchError if wallet is connected to a different chain

Throws

CCTOperationUnsupportedError on a v2.0.0 pool

Throws

CCTParamsInvalidError if any param is invalid, the lane is not siloed, sender is given and is not the wallet's address, or the wallet is not the silo's rebalancer

Throws

CCTTxFailedError if the silo holds less than amount

Throws

CCIPExecTxRevertedError if the tx reverts on-chain, e.g. InsufficientLiquidity

Throws

CCTTxFailedError if submission fails before broadcast

Throws

CCTTxNotConfirmedError if it is not confirmed in time

Example

TypeScript

const { hash } = await cct.withdrawSiloedLiquidity({
  poolAddress: '0xPool...',
  remoteChainSelector: 16015286601757825753n,
  amount: 1_000000000000000000n,
  wallet, // the silo rebalancer, which also receives the tokens
})

fromChain()

static fromChain(chain: EVMChain): EVMTokenManager

Defined in: cct/evm/index.ts:339

Wraps an existing EVMChain.

Parameters

Parameter	Type
`chain`	`EVMChain`

Returns

EVMTokenManager

fromProvider()

static fromProvider(provider: JsonRpcApiProvider, ctx?: ChainContext): Promise<EVMTokenManager>

Defined in: cct/evm/index.ts:344

Creates from an ethers provider.

Parameters

Parameter	Type
`provider`	`JsonRpcApiProvider`
`ctx?`	`ChainContext`

Returns

Promise<EVMTokenManager>

fromUrl()

static fromUrl(url: string, ctx?: ChainContext): Promise<EVMTokenManager>

Defined in: cct/evm/index.ts:352

Creates from an RPC URL.

Parameters

Parameter	Type
`url`	`string`
`ctx?`	`ChainContext`

Returns

Promise<EVMTokenManager>

Extends
Constructors
- Constructor
Properties
- chain
  - Overrides
Accessors
- provider
  - Get Signature
Methods

Extends​

Constructors​

Constructor​

Parameters​

Returns​

Overrides​

Properties​

chain​

Overrides​

Accessors​

provider​

Get Signature​

Returns​

Methods​

acceptAdmin()​

Parameters​

Returns​

Throws​

Throws​

Throws​

Throws​

Example​

acceptDefaultAdminTransfer()​

Parameters​

Returns​

Remarks​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Example​

acceptPoolOwnership()​

Parameters​

Returns​

Throws​

Throws​

Throws​

Throws​

Example​

acceptTokenOwnership()​

Parameters​

Returns​

Deprecated​

Throws​

Throws​

Throws​

Throws​

Example​

addRemotePool()​

Parameters​

Returns​

Remarks​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Example​

applyAllowlistUpdates()​

Parameters​

Returns​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Throws​

Example​

applyCCVConfigUpdates()​

Parameters​

Returns​

Remarks​

Throws​

Throws​

Extends

Constructors

Constructor

Parameters

Returns

Overrides

Properties

chain

Overrides

Accessors

provider

Get Signature

Returns

Methods

acceptAdmin()

Parameters

Returns

Throws

Throws

Throws

Throws

Example

acceptDefaultAdminTransfer()

Parameters

Returns

Remarks

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Example

acceptPoolOwnership()

Parameters

Returns

Throws

Throws

Throws

Throws

Example

acceptTokenOwnership()

Parameters

Returns

Deprecated

Throws

Throws

Throws

Throws

Example

addRemotePool()

Parameters

Returns

Remarks

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Example

applyAllowlistUpdates()

Parameters

Returns

Throws

Throws

Throws

Throws

Throws

Throws

Throws

Example

applyCCVConfigUpdates()

Parameters

Returns

Remarks

Throws

Throws