Version: 1.15.0

Class: EVMTokenManager

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

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

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

Chain this manager builds and submits through.

Overrides

TokenManager.chain

Accessors

provider

Get Signature

get provider(): JsonRpcApiProvider

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

Provider of the underlying chain.

Returns

JsonRpcApiProvider

Methods

acceptAdmin()

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

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

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

Accepts a delayed CrossChainToken default-admin transfer, signing + submitting with opts.wallet (the pending default admin).

Parameters

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

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedAcceptDefaultAdminTransfer for pending-transfer and delay rules. The contract is the final authority on whether its schedule has passed.

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, no transfer is pending, or the wallet is not its pending default admin

Throws

CCIPExecTxRevertedError if the mandatory delay has not passed or 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.acceptDefaultAdminTransfer({
  tokenAddress: '0xToken...',
  wallet, // pending default admin
})

acceptPoolOwnership()

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

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

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<AcceptTokenOwnershipParams>): Promise<TransactionResult>

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

Completes a pending token ownership transfer, signing + submitting with opts.wallet — which must be the address transferTokenOwnership proposed. Ownership moves in this tx.

Parameters

Parameter	Type
`opts`	`EVMExecuteParams`<`AcceptTokenOwnershipParams`>

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 tokenAddress 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 token's proposed owner

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

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, CCVs are duplicated, a threshold list lacks base CCVs, 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:3721

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

Parameters

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

Returns

Promise<TransactionResult>

Remarks

Same version-discriminated params as generateUnsignedApplyChainUpdates — see there for the v1.5.0 vs v1.5.1 divergence. 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, version does not match the pool's own generation, 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({
  version: '1.5.1',
  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:1456

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

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

Schedules a CrossChainToken default-admin transfer, signing + submitting with opts.wallet (the current default admin).

Parameters

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

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedBeginDefaultAdminTransfer for version, delay, and renunciation rules. 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, the token has no current default admin, or the wallet is not it

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 default admin
})

cancelDefaultAdminTransfer()

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

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

Cancels a pending CrossChainToken default-admin transfer, signing + submitting with opts.wallet (the current default admin).

Parameters

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

Returns

Promise<TransactionResult>

Remarks

See generateUnsignedCancelDefaultAdminTransfer for pending-transfer 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 not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

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

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 default admin
})

deployAdvancedPoolHooks()

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

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

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

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

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

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.

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

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

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

Builds an unsigned acceptDefaultAdminTransfer tx (for multisig / offline signing), completing a pending CrossChainToken transfer. The contract enforces its mandatory delay when mined.

Parameters

Parameter	Type
`opts`	`AcceptDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

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

Throws

CCTContractTypeInvalidError if tokenAddress is not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

CCTParamsInvalidError if no 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:718

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: AcceptTokenOwnershipParams): Promise<UnsignedEVMTx>

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

Builds an unsigned token acceptOwnership tx (for multisig / offline signing), completing a transfer proposed by generateUnsignedTransferTokenOwnership. v1.x tokens only, and not pre-flightable for the same reason as generateUnsignedAcceptPoolOwnership: the pending owner is a private slot with no getter, so sender only sets tx.from.

Parameters

Parameter	Type
`opts`	`AcceptTokenOwnershipParams`

Returns

Promise<UnsignedEVMTx>

Remarks

Builds without touching the chain: there is neither a version to resolve nor a role to read.

Throws

CCTParamsInvalidError if tokenAddress or sender is invalid

Example

TypeScript

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

generateUnsignedAddRemotePool()

generateUnsignedAddRemotePool(opts: RemotePoolParams): Promise<UnsignedEVMTx>

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

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, CCVs are duplicated, a threshold list lacks base CCVs, 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:3796

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

The parameter shape is version-discriminated, because the contract's own signature changed at v1.5.1 — this is the one CCT pool write where the caller must say which generation it is writing for, via opts.version:

version: '1.5.0' — a single chains array. Each entry carries the enable/disable bit inline (allowed: false removes the lane) and a singular remotePoolAddress.
version: '1.5.1' — removals in remoteChainSelectorsToRemove, additions in chainsToAdd, and each addition carries plural remotePoolAddresses. This is also the shape for v1.6.0, v1.6.1 and v2.0.0 pools, whose calldata is byte-identical to v1.5.1's.

The declaration is checked against the pool's on-chain typeAndVersion, so writing the wrong shape is a parameter error here rather than a tx that reverts on an unknown selector (the two signatures have different selectors: 0xdb6327dc vs 0xe8a1da17).

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, version does not match the pool's own generation, 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

Examples

Enabling a lane on a v1.6.1 pool (the `1.5.1` shape) while retiring an old one:

TypeScript

const unsigned = await cct.generateUnsignedApplyChainUpdates({
  version: '1.5.1',
  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 },
    },
  ],
})

Disabling a lane on a v1.5.0 pool, where removal is `allowed: false`:

TypeScript

const unsigned = await cct.generateUnsignedApplyChainUpdates({
  version: '1.5.0',
  poolAddress: '0xLegacyPool...',
  chains: [
    {
      remoteChainSelector: 16015286601757825753n,
      allowed: false,
      remoteTokenAddress: '0xRemoteToken...',
      remotePoolAddress: '0xRemotePool...', // still required, ignored by the contract
      inboundRateLimiterConfig: { enabled: false },
      outboundRateLimiterConfig: { enabled: false },
    },
  ],
})

generateUnsignedApplyTokenTransferFeeConfigUpdates()

generateUnsignedApplyTokenTransferFeeConfigUpdates(opts: ApplyTokenTransferFeeConfigUpdatesParams): Promise<UnsignedEVMTx>

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

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

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

Builds an unsigned beginDefaultAdminTransfer tx (for multisig / offline signing), scheduling a CrossChainToken default-admin transfer. The proposed admin accepts only after the token's mandatory delay; generateUnsignedAcceptDefaultAdminTransfer builds that second tx.

Parameters

Parameter	Type
`opts`	`BeginDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v2.0.0 and later supported CrossChainToken versions. 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.

Throws

CCTContractTypeInvalidError if tokenAddress is not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

CCTParamsInvalidError if any address is invalid, the token has no current default admin, or sender is not it

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

Builds an unsigned cancelDefaultAdminTransfer tx (for multisig / offline signing), canceling a pending CrossChainToken default-admin transfer.

Parameters

Parameter	Type
`opts`	`CancelDefaultAdminTransferParams`

Returns

Promise<UnsignedEVMTx>

Remarks

A cancellation with no pending transfer is rejected even though OpenZeppelin would mine it as a silent no-op.

Throws

CCTContractTypeInvalidError if tokenAddress is not a CrossChainToken

Throws

CCTContractVersionUnsupportedError if it reports an unknown token version

Throws

CCTParamsInvalidError if no transfer is pending, the token has no current default admin, or sender is not it

Example

TypeScript

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

generateUnsignedDeployAdvancedPoolHooks()

generateUnsignedDeployAdvancedPoolHooks(opts: DeployAdvancedPoolHooksParams): Promise<UnsignedEVMTx>

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

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

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

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

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

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

Builds an unsigned pool deployment tx (for multisig / offline signing). type selects the pool contract — a DeployableTokenPoolType (BurnMintTokenPool, BurnFromMintTokenPool, BurnWithFromMintTokenPool, or LockReleaseTokenPool; 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.

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

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

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

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

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

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

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

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...',
})

generateUnsignedRegisterAdmin()

generateUnsignedRegisterAdmin(opts: RegisterAdminParams): Promise<UnsignedEVMTx>

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

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

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

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

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

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

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

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, 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:487

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

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

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

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...',
})

generateUnsignedSetThresholdAmount()

generateUnsignedSetThresholdAmount(opts: SetThresholdAmountParams): Promise<UnsignedEVMTx>

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid 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:531

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

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

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

Builds an unsigned token transferOwnership tx (for multisig / offline signing), for a v1.x FactoryBurnMintERC20. The token owner grants and revokes mint/burn roles, and is independent of the pool's owner (generateUnsignedTransferPoolOwnership) — moving one leaves the other untouched. Same two-step and zero-address semantics, completed by acceptTokenOwnership, and the same owner() pre-flight of sender.

Parameters

Parameter	Type
`opts`	`TransferTokenOwnershipParams`

Returns

Promise<UnsignedEVMTx>

Remarks

v1.x only: a v2.0.0 CrossChainToken uses generateUnsignedBeginDefaultAdminTransfer instead and is rejected before calldata is built.

Throws

CCTOperationUnsupportedError if tokenAddress is a v2.0.0 CrossChainToken

Throws

CCTParamsInvalidError if any param is invalid, if newOwner equals sender, or if sender is given and is not the token owner

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid 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:3254

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...',
})

generateUnsignedWithdrawFeeTokens()

generateUnsignedWithdrawFeeTokens(opts: WithdrawFeeTokensParams): Promise<UnsignedEVMTx>

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

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

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

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...',
})

getAdvancedPoolHooks()

getAdvancedPoolHooks(opts: GetAdvancedPoolHooksParams): Promise<string>

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

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: GetAllAdvancedPoolHooksAuthorizedCallersParams): Promise<GetAllAdvancedPoolHooksAuthorizedCallersResult>

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

Lists callers authorized for hooks preflight and postflight checks.

Parameters

Parameter	Type
`opts`	`GetAllAdvancedPoolHooksAuthorizedCallersParams`

Returns

Promise<GetAllAdvancedPoolHooksAuthorizedCallersResult>

Throws

CCTParamsInvalidError if advancedPoolHooks is invalid

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

Example

TypeScript

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

getAllCCVConfigs()

getAllCCVConfigs(opts: GetAllCCVConfigsParams): Promise<GetAllCCVConfigsResult>

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

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

Parameters

Parameter	Type
`opts`	`GetAllCCVConfigsParams`

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 advancedPoolHooks is invalid

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

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

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

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

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

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')

getBurners()

getBurners(opts: GetBurnersParams): Promise<GetBurnersResult>

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

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

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

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 advancedPoolHooks or remoteChainSelector is invalid

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

Example

TypeScript

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

getDynamicConfig()

getDynamicConfig(opts: GetDynamicConfigParams): Promise<TokenPoolDynamicConfig>

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

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

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

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

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

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: GetPolicyEngineParams): Promise<string>

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

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

Parameters

Parameter	Type
`opts`	`GetPolicyEngineParams`

Returns

Promise<string>

Throws

CCTParamsInvalidError if advancedPoolHooks is invalid

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

Example

TypeScript

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

getRebalancer()

getRebalancer(opts: GetRebalancerParams): Promise<string>

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

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

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

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

Example

TypeScript

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

getSupportedTokens()

getSupportedTokens(opts: GetSupportedTokensParams): Promise<GetSupportedTokensResult>

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

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: GetThresholdAmountParams): Promise<bigint>

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

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

Parameters

Parameter	Type
`opts`	`GetThresholdAmountParams`

Returns

Promise<bigint>

Throws

CCTParamsInvalidError if advancedPoolHooks is invalid

Throws

CCTContractTypeInvalidError if advancedPoolHooks is not AdvancedPoolHooks

Example

TypeScript

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

getTokenAdminRegistry()

getTokenAdminRegistry(opts: GetTokenAdminRegistryParams): Promise<RegistryTokenConfig>

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

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

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

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 acceptTokenOwnership / 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:3497

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

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. 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:2126

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

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

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

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

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

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 })
}

mint()

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

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

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

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
})

registerAdmin()

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

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

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

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

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

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

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

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

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, 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:509

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

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

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

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
})

setThresholdAmount()

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, 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:558

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

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

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

Proposes a new token owner, signing + submitting with opts.wallet — which must be the token's current owner, and is what sender defaults to. Two-step, and v1.x-only without a version check, per generateUnsignedTransferTokenOwnership.

Parameters

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

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 token owner

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

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

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 advancedPoolHooks is not an AdvancedPoolHooks contract

Throws

CCTParamsInvalidError if a param is invalid, 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:3286

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,
})

withdrawFeeTokens()

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

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

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

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

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
})

fromChain()

static fromChain(chain: EVMChain): EVMTokenManager

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

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

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

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​

Throws​

Example​

acceptPoolOwnership()​

Parameters​

Returns​

Throws​

Throws​

Throws​

Throws​

Example​

acceptTokenOwnership()​

Parameters​

Returns​

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

Throws

Example

acceptPoolOwnership()

Parameters

Returns

Throws

Throws

Throws

Throws

Example

acceptTokenOwnership()

Parameters

Returns

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