Skip to main content
Version: 1.18.0

Class: SolanaTokenManager

Defined in: cct/solana/index.ts:237

CCT admin facade for Solana.

Extends​

Constructors​

Constructor​

new SolanaTokenManager(chain: SolanaChain): SolanaTokenManager

Defined in: cct/solana/index.ts:293

Creates a Solana CCT manager for an existing chain.

Parameters​

ParameterType
chainSolanaChain

Returns​

SolanaTokenManager

Overrides​

TokenManager<typeof ChainFamily.Solana>.constructor

Properties​

chain​

readonly chain: SolanaChain

Defined in: cct/solana/index.ts:238

Chain this manager builds and submits through.

Overrides​

TokenManager.chain

Accessors​

provider​

Get Signature​

get provider(): Connection

Defined in: cct/solana/index.ts:316

Provider of the underlying chain.

Returns​

Connection

Methods​

acceptAdmin()​

acceptAdmin(opts: ExecuteAcceptAdminParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2428

Accepts a pending token administrator role using the pending administrator wallet.

Parameters​

ParameterType
optsExecuteAcceptAdminParams

Returns​

Promise<TransactionResult>

Remarks​

Call this after registerAdmin or transferAdmin and before setPool. authority defaults to wallet; Squads/vault flows should use generateUnsignedAcceptAdmin instead.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address is invalid or authority does not match the executing wallet/pending token administrator.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Throws​

CCTTxFailedError If simulation or the Router rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.acceptAdmin({ tokenAddress: mint, address: router, wallet: pendingAdminWallet })

acceptPoolOwnership()​

acceptPoolOwnership(opts: ExecuteAcceptPoolOwnershipParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1736

Accepts pending ownership of an initialized Solana token pool using the proposed owner wallet. It verifies the wallet is the proposed owner before submitting.

Parameters​

ParameterType
optsExecuteAcceptPoolOwnershipParams

Returns​

Promise<TransactionResult>

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool account does not exist.

Throws​

CCTTxFailedError If the wallet is not the proposed owner or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.acceptPoolOwnership({
tokenAddress: mint,
wallet,
})

appendRemotePoolAddresses()​

appendRemotePoolAddresses(opts: ExecuteAppendRemotePoolAddressesParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1118

Appends remote pool addresses to an initialized Solana token pool remote-chain config with the pool owner wallet.

Parameters​

ParameterType
optsExecuteAppendRemotePoolAddressesParams

Returns​

Promise<TransactionResult>

Remarks​

remotePoolAddresses must be non-empty and contain no duplicates. Existing addresses are retained. The remote-chain config must already exist; addresses already on-chain cause the transaction to fail. To clear all pools, use editChainRemoteConfig with remotePoolAddresses: [].

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter or remote pool address is invalid, or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the chain config does not exist, the wallet is not the pool owner, an address already exists, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.appendRemotePoolAddresses({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
wallet,
})

appendToLookupTable()​

appendToLookupTable(opts: ExecuteAppendToLookupTableParams): Promise<ExecuteAppendToLookupTableResult>

Defined in: cct/solana/index.ts:2364

Extends a Solana lookup table.

Pass tokenAddress (plus poolProgramAddress for a non-canonical pool program) to append the standard CCIP pool addresses.

Parameters​

ParameterType
optsExecuteAppendToLookupTableParams

Returns​

Promise<ExecuteAppendToLookupTableResult>

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address or lookup table parameter is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.appendToLookupTable({
lookupTableAddress,
wallet,
tokenAddress: mint,
poolProgramAddress: poolProgram,
additionalAddresses: [extraAccount],
})

applyChainUpdates()​

applyChainUpdates(opts: ExecuteApplyChainUpdatesParams): Promise<ExecuteApplyChainUpdatesResult>

Defined in: cct/solana/index.ts:1052

Applies EVM-equivalent remote-chain configuration changes with the pool owner wallet.

Parameters​

ParameterType
optsExecuteApplyChainUpdatesParams

Returns​

Promise<ExecuteApplyChainUpdatesResult>

Remarks​

Removals run before additions. Each added chain is initialized, configured, and rate-limited as one transaction group. Groups are submitted sequentially and are not atomic; if a later transaction fails, earlier groups may already be committed. The result contains every transaction hash. To replace a chain, include its selector in both remoteChainSelectorsToRemove and chainsToAdd. wallet must be the pool owner and is the fee payer and default authority.

See​

generateUnsignedApplyChainUpdates

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter or chain update is invalid, or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If a chain config already exists or is missing, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.applyChainUpdates({
tokenAddress: mint,
remoteChainSelectorsToRemove: [],
chainsToAdd: [{
remoteChainSelector: selector,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
inboundRateLimiterConfig: { enabled: false },
outboundRateLimiterConfig: { enabled: false },
}],
wallet,
})

approveToken()​

approveToken(opts: ExecuteApproveTokenParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:439

Approves a delegate to transfer SPL tokens from the selected token account using the executing authority wallet.

Parameters​

ParameterType
optsExecuteApproveTokenParams

Returns​

Promise<TransactionResult>

See​

generateUnsignedApproveToken For externally signed transactions.

Remarks​

This is a prerequisite for pool liquidity operations: approve the pool signer PDA as delegate with the maximum allowance it may transfer during provideLiquidity. Approval grants a trusted delegate spend authority and replaces the account's existing delegate and allowance; set amount to 0n to clear the allowance. tokenAccount defaults to the authority's existing associated token account. An explicitly supplied tokenAccount must belong to tokenAddress. SPL Token multisig authorities require multisigSigners.

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address, allowance, or multisig signer is invalid, or authority does not match the executing wallet.

Throws​

CCIPTokenAccountNotFoundError If the token account does not exist.

Throws​

CCTTokenAccountMintMismatchError If an explicit token account belongs to another mint.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If simulation or the SPL Token program rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.approveToken({ wallet, tokenAddress: mint, delegate, amount: 1_000_000n })

configureAllowlist()​

configureAllowlist(opts: ExecuteConfigureAllowlistParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:873

Appends addresses to and configures an initialized Solana token pool allowlist using the pool owner wallet. Every call overwrites enforcement; pass add: [] to toggle it without appending an address. Addresses in add must be unique; existing allowlist entries are rejected by the program.

Parameters​

ParameterType
optsExecuteConfigureAllowlistParams

Returns​

Promise<TransactionResult>

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.configureAllowlist({
tokenAddress: mint,
add: [],
enabled: false,
wallet,
})

createLookupTable()​

createLookupTable(opts: ExecuteCreateLookupTableParams): Promise<ExecuteCreateLookupTableResult>

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

Creates a Solana pool lookup table. Defaults to create+extend; pass mode: 'createEmpty' to create an empty ALT owned by authority and paid by wallet. If authority is omitted, it defaults to the wallet public key.

Parameters​

ParameterType
optsExecuteCreateLookupTableParams

Returns​

Promise<ExecuteCreateLookupTableResult>

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address or lookup table parameter is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const { hash, lookupTableAddress } = await cct.createLookupTable({
mode: 'createEmpty',
authority: squadsVault,
wallet,
})

createTokenAccount()​

createTokenAccount(opts: ExecuteCreateTokenAccountParams): Promise<ExecuteCreateTokenAccountResult>

Defined in: cct/solana/index.ts:496

Creates an associated token account for a wallet or PDA owner.

Parameters​

ParameterType
optsExecuteCreateTokenAccountParams

Returns​

Promise<ExecuteCreateTokenAccountResult>

Remarks​

This operation is idempotent and safe to re-run. For the canonical pool setup flow, pass the poolSignerAddress returned by deployTokenPool as ownerAddress, then call setPool.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.createTokenAccount({ wallet, tokenAddress: mint, ownerAddress: owner })

createTokenMultisig()​

createTokenMultisig(opts: ExecuteCreateTokenMultisigParams): Promise<ExecuteCreateTokenMultisigResult>

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

Creates an SPL Token multisig account. The pool signer PDA occupies threshold slots; non-pool signers must meet the threshold independently. Wallet pays fees and must match the mint authority.

Parameters​

ParameterType
optsExecuteCreateTokenMultisigParams

Returns​

Promise<ExecuteCreateTokenMultisigResult>

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If multisig parameters are invalid or the wallet is not the mint authority.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const { hash, multisigAddress } = await cct.createTokenMultisig({
wallet,
tokenAddress: mint,
poolType: 'burn-mint',
threshold: 2,
additionalSigners: [admin],
})

deleteChainRemoteConfig()​

deleteChainRemoteConfig(opts: ExecuteDeleteChainRemoteConfigParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1252

Closes an initialized Solana token pool remote-chain config with the pool owner wallet.

Parameters​

ParameterType
optsExecuteDeleteChainRemoteConfigParams

Returns​

Promise<TransactionResult>

Remarks​

Destructive: this closes the remote-chain config account and returns its rent to the wallet. CCIP transfers for remoteChainSelector fail until the config is recreated with initChainRemoteConfig.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the chain config does not exist, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.deleteChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
wallet,
})

deleteFastFinalityRateLimit()​

deleteFastFinalityRateLimit(opts: ExecuteDeleteFastFinalityRateLimitParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2177

Deletes a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain with the pool owner wallet.

Parameters​

ParameterType
optsExecuteDeleteFastFinalityRateLimitParams

Returns​

Promise<TransactionResult>

See​

generateUnsignedDeleteFastFinalityRateLimit

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If the FTF rate limits do not exist, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.deleteFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
wallet,
})

deployToken()​

deployToken(opts: ExecuteDeployTokenParams): Promise<ExecuteDeployTokenResult>

Defined in: cct/solana/index.ts:369

Creates a Solana mint, optionally with initial supply. The wallet public key defaults as mint, freeze, and metadata update authority.

Parameters​

ParameterType
optsExecuteDeployTokenParams

Returns​

Promise<ExecuteDeployTokenResult>

See​

updateMetadataAuthority To transfer the initial metadata update authority.

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If token parameters are invalid.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.deployToken({
wallet,
decimals: 9,
tokenProgram: 'spl-token',
withMetaplex: false,
})

deployTokenPool()​

deployTokenPool(opts: ExecuteDeployTokenPoolParams): Promise<ExecuteDeployTokenPoolResult>

Defined in: cct/solana/index.ts:969

Initializes a Solana token pool.

Parameters​

ParameterType
optsExecuteDeployTokenPoolParams

Returns​

Promise<ExecuteDeployTokenPoolResult>

Remarks​

This only sends the pool initialize instruction for the canonical burn-mint and lock-release programs selected by poolType; custom pool deployment is unsupported. Pass poolProgramAddress where that program is deployed at a non-canonical address. The signer must be allowed to initialize the pool.

Important: The pool requires a pool_token_account (the pool signer PDA's associated token account) to lock/release or mint on transfers. Set createPoolSignerATA: true to create it idempotently in this transaction. If omitted (defaults to false), create it separately with the returned poolSignerAddress via createTokenAccount before setPool, or transfers fail with AccountNotInitialized (3012).

When to use createPoolSignerATA: true vs. the separate generateUnsignedCreateTokenAccount op:

  • Use this option when deploying a pool that will immediately receive transfers (simplest, one tx)
  • Use the separate op for vault-owned pools or when decoupling pool initialization from ATA setup

This option is Solana-only (no EVM equivalent). It is analogous to createRecipientATA on mintTokens, the same idiomatic pattern for atomicity.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.deployTokenPool({
tokenAddress: mint,
poolType: 'burn-mint',
createPoolSignerATA: true,
wallet,
})

editChainConfigV2()​

editChainConfigV2(opts: ExecuteEditChainConfigV2Params): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1949

Edits a CCIP 2.0 token pool's ChainConfigV2 for a remote chain with the pool owner wallet.

Parameters​

ParameterType
optsExecuteEditChainConfigV2Params

Returns​

Promise<TransactionResult>

Remarks​

Each of allowedFinality, tokenTransferFeeConfig and ccvConfig replaces that part of the config in full when passed, and keeps its current value when omitted (ccvConfig: {} clears the CCVs). The config must exist.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCIPTokenPoolChainConfigNotFoundError If a config field is omitted and the lane has no ChainConfigV2.

Throws​

CCTDataDecodeError If a config field is omitted and the lane's ChainConfigV2 cannot be decoded.

Throws​

CCTTxFailedError If the config does not exist, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.editChainConfigV2({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
allowedFinality: { finalityDepth: 10, finalitySafe: true },
wallet,
})

editChainRemoteConfig()​

editChainRemoteConfig(opts: ExecuteEditChainRemoteConfigParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2304

Replaces an initialized Solana token pool remote-chain config with the pool owner wallet. Initialize the config first with initChainRemoteConfig. Each call replaces the remote token address, pool addresses, and decimals.

Parameters​

ParameterType
optsExecuteEditChainRemoteConfigParams

Returns​

Promise<TransactionResult>

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If simulation or the pool rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.editChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
wallet,
})

generateUnsignedAcceptAdmin()​

generateUnsignedAcceptAdmin(opts: GenerateAcceptAdminParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2399

Builds an unsigned Solana instruction that accepts a pending token administrator role.

The supplied authority must be the pending token administrator.

Parameters​

ParameterType
optsGenerateAcceptAdminParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

Call this after generateUnsignedRegisterAdmin or generateUnsignedTransferAdmin and before generateUnsignedSetPool. authority defaults to payer; Squads/vault flows should use this method with their fee payer and signing authority explicitly.

See​

Throws​

CCTParamsInvalidError If an address is invalid or the authority is not the pending token administrator.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedAcceptAdmin({
tokenAddress: mint,
address: router,
payer: pendingAdmin,
})

generateUnsignedAcceptPoolOwnership()​

generateUnsignedAcceptPoolOwnership(opts: GenerateAcceptPoolOwnershipParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1707

Builds an unsigned instruction that accepts pending ownership of an initialized Solana token pool. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer. The operation reads pool state and requires it to be the proposed owner.

Parameters​

ParameterType
optsGenerateAcceptPoolOwnershipParams

Returns​

Promise<UnsignedSolanaTx>

See​

Throws​

CCTParamsInvalidError If a pool parameter or public key is invalid.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool account does not exist.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedAcceptPoolOwnership({
tokenAddress: mint,
payer,
authority,
})

generateUnsignedAppendRemotePoolAddresses()​

generateUnsignedAppendRemotePoolAddresses(opts: GenerateAppendRemotePoolAddressesParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1083

Builds an unsigned instruction that appends remote pool addresses to an initialized Solana token pool remote-chain config. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateAppendRemotePoolAddressesParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

remotePoolAddresses must be non-empty and contain no duplicates. Existing addresses are retained. On-chain execution rejects addresses already present. To clear all pools, use generateUnsignedEditChainRemoteConfig with remotePoolAddresses: []. The remote-chain config must already exist.

See​

Throws​

CCTParamsInvalidError If a pool parameter, selector, or remote pool address is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedAppendRemotePoolAddresses({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
payer,
authority,
})

generateUnsignedAppendToLookupTable()​

generateUnsignedAppendToLookupTable(opts: GenerateAppendToLookupTableParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2334

Builds unsigned Solana lookup table extend instructions.

Pass tokenAddress (plus poolProgramAddress for a non-canonical pool program) to append the standard CCIP pool addresses; pass additionalAddresses to append manual addresses. authority defaults to payer.

Parameters​

ParameterType
optsGenerateAppendToLookupTableParams

Returns​

Promise<UnsignedSolanaTx>

Throws​

CCTParamsInvalidError If an address or lookup table parameter is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedAppendToLookupTable({
lookupTableAddress,
payer: squadsVault,
authority: squadsVault,
tokenAddress: mint,
poolProgramAddress: poolProgram,
additionalAddresses: [extraAccount],
})

generateUnsignedApplyChainUpdates()​

generateUnsignedApplyChainUpdates(opts: GenerateApplyChainUpdatesParams): Promise<GenerateApplyChainUpdatesResult>

Defined in: cct/solana/index.ts:1010

Builds ordered unsigned transactions that remove remote-chain configs and add new configs with their remote pools and rate limits. This accepts the same remoteChainSelectorsToRemove and chainsToAdd parameters as EVM applyChainUpdates.

Parameters​

ParameterType
optsGenerateApplyChainUpdatesParams

Returns​

Promise<GenerateApplyChainUpdatesResult>

Remarks​

Removals run before additions. Each added chain is initialized, configured, and rate-limited as one transaction group; returns one or more packed transactions. To replace a chain, include its selector in both remoteChainSelectorsToRemove and chainsToAdd. Solana requires remoteTokenDecimals. authority must be the pool owner and defaults to payer.

See​

applyChainUpdates

Throws​

CCTParamsInvalidError If a pool parameter or chain update is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsignedTxs = await cct.generateUnsignedApplyChainUpdates({
tokenAddress: mint,
remoteChainSelectorsToRemove: [oldSelector],
chainsToAdd: [{
remoteChainSelector: newSelector,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
inboundRateLimiterConfig: { enabled: false },
outboundRateLimiterConfig: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
}],
payer,
authority,
})

for (const unsignedTx of unsignedTxs) {
// Sign and submit each transaction in order.
}

generateUnsignedApproveToken()​

generateUnsignedApproveToken(opts: GenerateApproveTokenParams): Promise<UnsignedSolanaTx>

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

Builds unsigned instructions to approve a delegate to transfer SPL tokens.

Parameters​

ParameterType
optsGenerateApproveTokenParams

Returns​

Promise<UnsignedSolanaTx>

See​

approveToken For wallet-based execution.

Remarks​

This is a prerequisite for pool liquidity operations: approve the pool signer PDA as delegate with the maximum allowance it may transfer during provideLiquidity. Approval grants a trusted delegate spend authority and replaces the account's existing delegate and allowance; set amount to 0n to clear the allowance. tokenAccount defaults to the authority's existing associated token account. An explicitly supplied tokenAccount must belong to tokenAddress. For an SPL Token multisig authority, provide multisigSigners and collect member signatures externally.

Throws​

CCTParamsInvalidError If an address, allowance, or multisig signer is invalid.

Throws​

CCIPTokenAccountNotFoundError If the token account does not exist.

Throws​

CCTTokenAccountMintMismatchError If an explicit token account belongs to another mint.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedApproveToken({
payer: owner,
tokenAddress: mint,
delegate,
amount: 1_000_000n,
})

generateUnsignedConfigureAllowlist()​

generateUnsignedConfigureAllowlist(opts: GenerateConfigureAllowlistParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:841

Builds an unsigned instruction to append addresses to a token pool allowlist and toggle enforcement. Every call overwrites enforcement; pass add: [] to toggle it without appending an address. Addresses in add must be unique; existing allowlist entries are rejected by the program. The pool must be initialized first. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateConfigureAllowlistParams

Returns​

Promise<UnsignedSolanaTx>

See​

Throws​

CCTParamsInvalidError If a pool parameter is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedConfigureAllowlist({
tokenAddress: mint,
add: [allowedSender],
enabled: true,
payer,
authority,
})

generateUnsignedCreateLookupTable()​

generateUnsignedCreateLookupTable(opts: GenerateCreateLookupTableParams): Promise<GenerateCreateLookupTableResult>

Defined in: cct/solana/index.ts:785

Builds unsigned Solana pool lookup table instructions.

Defaults to create+extend. Pass poolProgramAddress for a non-canonical pool program. Use mode: 'createEmpty' to create an empty ALT, e.g. with an EOA payer and vault authority, then populate it later through the authority. If authority is omitted, it defaults to payer.

Parameters​

ParameterType
optsGenerateCreateLookupTableParams

Returns​

Promise<GenerateCreateLookupTableResult>

Throws​

CCTParamsInvalidError If an address or lookup table parameter is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedCreateLookupTable({
mode: 'createEmpty',
payer: eoa,
authority: squadsVault,
})

generateUnsignedCreateTokenAccount()​

generateUnsignedCreateTokenAccount(opts: GenerateCreateTokenAccountParams): Promise<GenerateCreateTokenAccountResult>

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

Builds an unsigned idempotent associated token account create instruction.

Parameters​

ParameterType
optsGenerateCreateTokenAccountParams

Returns​

Promise<GenerateCreateTokenAccountResult>

Remarks​

This operation is idempotent and safe to re-run. For the canonical pool setup flow, pass the poolSignerAddress returned by generateUnsignedDeployTokenPool as ownerAddress, then call generateUnsignedSetPool.

See​

Throws​

CCTParamsInvalidError If an address is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedCreateTokenAccount({
payer,
tokenAddress: mint,
ownerAddress: owner,
})

generateUnsignedCreateTokenMultisig()​

generateUnsignedCreateTokenMultisig(opts: GenerateCreateTokenMultisigParams): Promise<GenerateCreateTokenMultisigResult>

Defined in: cct/solana/index.ts:729

Builds unsigned SPL Token multisig creation instructions. The pool signer PDA occupies threshold slots; non-pool signers must meet the threshold independently.

Parameters​

ParameterType
optsGenerateCreateTokenMultisigParams

Returns​

Promise<GenerateCreateTokenMultisigResult>

Remarks​

When payer differs from the mint authority, both must sign: the mint authority is the createAccountWithSeed base account.

Throws​

CCTParamsInvalidError If multisig parameters are invalid or the mint has no authority.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedCreateTokenMultisig({
payer,
tokenAddress: mint,
poolType: 'burn-mint',
threshold: 2,
additionalSigners: [admin],
})

generateUnsignedDeleteChainRemoteConfig()​

generateUnsignedDeleteChainRemoteConfig(opts: GenerateDeleteChainRemoteConfigParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1218

Builds an unsigned instruction that closes a Solana token pool remote-chain config. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateDeleteChainRemoteConfigParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

Destructive: this closes the remote-chain config account and returns its rent to authority. CCIP transfers for remoteChainSelector fail until the config is recreated with generateUnsignedInitChainRemoteConfig. On-chain execution requires authority to be the token pool owner and the chain config to exist.

See​

Throws​

CCTParamsInvalidError If a pool parameter or remote chain selector is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedDeleteChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
payer,
authority,
})

generateUnsignedDeleteFastFinalityRateLimit()​

generateUnsignedDeleteFastFinalityRateLimit(opts: GenerateDeleteFastFinalityRateLimitParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2148

Builds an unsigned instruction that deletes a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain, closing its FTF ChainConfigOverride. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateDeleteFastFinalityRateLimitParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner, who receives the rent.

See​

Throws​

CCTParamsInvalidError If a pool parameter or selector is invalid.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedDeleteFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
payer,
authority,
})

generateUnsignedDeployToken()​

generateUnsignedDeployToken(opts: GenerateDeployTokenParams): Promise<GenerateDeployTokenResult>

Defined in: cct/solana/index.ts:341

Builds unsigned Solana mint creation instructions, optionally with initial supply. The payer defaults as mint, freeze, and metadata update authority.

Parameters​

ParameterType
optsGenerateDeployTokenParams

Returns​

Promise<GenerateDeployTokenResult>

See​

updateMetadataAuthority To transfer the initial metadata update authority.

Throws​

CCTParamsInvalidError If token parameters are invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedDeployToken({
payer,
decimals: 9,
tokenProgram: 'spl-token',
withMetaplex: true,
name: 'My Token',
symbol: 'MTK',
})

generateUnsignedDeployTokenPool()​

generateUnsignedDeployTokenPool(opts: GenerateDeployTokenPoolParams): Promise<GenerateDeployTokenPoolResult>

Defined in: cct/solana/index.ts:921

Builds unsigned Solana token pool initialize instructions.

Parameters​

ParameterType
optsGenerateDeployTokenPoolParams

Returns​

Promise<GenerateDeployTokenPoolResult>

Remarks​

This only builds the pool initialize instruction for the canonical burn-mint and lock-release programs selected by poolType; custom pool deployment is unsupported. Pass poolProgramAddress where that program is deployed at a non-canonical address. authority must be allowed to initialize the pool.

Important: The pool requires a pool_token_account (the pool signer PDA's associated token account) to lock/release or mint on transfers. Set createPoolSignerATA: true to create it idempotently in this transaction. If omitted (defaults to false), create it separately with the returned poolSignerAddress via generateUnsignedCreateTokenAccount before generateUnsignedSetPool, or transfers fail with AccountNotInitialized (3012).

When to use createPoolSignerATA: true vs. the separate generateUnsignedCreateTokenAccount op:

  • Use this option when deploying a pool that will immediately receive transfers (simplest, one tx)
  • Use the separate op for vault-owned pools or when decoupling pool initialization from ATA setup

This option is Solana-only (no EVM equivalent). It is analogous to createRecipientATA on mintTokens, the same idiomatic pattern for atomicity.

See​

Throws​

CCTParamsInvalidError If a pool parameter is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedDeployTokenPool({
tokenAddress: mint,
poolType: 'burn-mint',
payer,
authority,
allowlist: [allowedSender],
createPoolSignerATA: true,
})

generateUnsignedEditChainConfigV2()​

generateUnsignedEditChainConfigV2(opts: GenerateEditChainConfigV2Params): Promise<UnsignedSolanaTx>

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

Builds an unsigned instruction that edits a CCIP 2.0 token pool's ChainConfigV2 for a remote chain. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateEditChainConfigV2Params

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner. Each of allowedFinality, tokenTransferFeeConfig and ccvConfig replaces that part of the config in full when passed, and keeps its current value when omitted (ccvConfig: {} clears the CCVs). Kept values are read when the instruction is built, so build it close to execution if the config may change meanwhile. Read them with chain.getTokenPoolConfig (finality and fees) and getCCVConfig. The config must exist.

See​

Throws​

CCTParamsInvalidError If a parameter is malformed or the pool program would reject the config.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCIPTokenPoolChainConfigNotFoundError If a config field is omitted and the lane has no ChainConfigV2.

Throws​

CCTDataDecodeError If a config field is omitted and the lane's ChainConfigV2 cannot be decoded.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedEditChainConfigV2({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
allowedFinality: { finalityDepth: 10, finalitySafe: true },
payer,
authority,
})

generateUnsignedEditChainRemoteConfig()​

generateUnsignedEditChainRemoteConfig(opts: GenerateEditChainRemoteConfigParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2271

Builds an unsigned instruction that replaces an initialized Solana token pool remote-chain config. Initialize the config first with generateUnsignedInitChainRemoteConfig. Each call replaces the remote token address, pool addresses, and decimals. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateEditChainRemoteConfigParams

Returns​

Promise<UnsignedSolanaTx>

See​

Throws​

CCTParamsInvalidError If a pool parameter or remote config value is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedEditChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
payer,
authority,
})

generateUnsignedInitChainConfigV2()​

generateUnsignedInitChainConfigV2(opts: GenerateInitChainConfigV2Params): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1837

Builds an unsigned instruction that creates a CCIP 2.0 token pool's ChainConfigV2 for a remote chain: the lane's allowed finality, token transfer fees, and CCVs. It also creates, if missing, the fee vault token account where the lane's in-token BPS fee accrues. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateInitChainConfigV2Params

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner, who pays the rent. The config must not exist yet. Omitted fields default to full finality only, no token transfer fees, and no pool CCVs.

See​

Throws​

CCTParamsInvalidError If a parameter is malformed, the pool program would reject the config, or the pool is a CCTP or Lombard pool, which keeps no fee vault.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedInitChainConfigV2({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
allowedFinality: { finalityDepth: 10 }, // FTF from 10 blocks deep
ccvConfig: { outboundCCVs: [committeeVerifier], inboundCCVs: [committeeVerifier] },
payer,
authority,
})

generateUnsignedInitChainRemoteConfig()​

generateUnsignedInitChainRemoteConfig(opts: GenerateInitChainRemoteConfigParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1151

Builds an unsigned instruction that initializes a Solana token pool remote-chain config for a previously unconfigured selector. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateInitChainRemoteConfigParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

This creates the chain-config PDA once and fails if it already exists. Configure remote pools and rate limits separately before using the lane.

See​

Throws​

CCTParamsInvalidError If a pool parameter or remote config value is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedInitChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remoteTokenDecimals: 18,
payer,
authority,
})

generateUnsignedInitFastFinalityRateLimit()​

generateUnsignedInitFastFinalityRateLimit(opts: GenerateInitFastFinalityRateLimitParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2016

Builds an unsigned instruction that creates a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain, held in its FTF ChainConfigOverride. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateInitFastFinalityRateLimitParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner, who pays the rent. The FTF rate limits must not exist yet. Enabled limits require rate <= capacity; disabled limits default omitted values to zero and reject nonzero values.

See​

Throws​

CCTParamsInvalidError If a pool parameter, rate limit, or selector is invalid.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedInitFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
inbound: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
outbound: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
payer,
authority,
})

generateUnsignedMintTokens()​

generateUnsignedMintTokens(opts: GenerateMintTokensParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:527

Builds unsigned instructions to mint SPL tokens to a recipient's associated token account.

Parameters​

ParameterType
optsGenerateMintTokensParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

amount is in base units. Set createRecipientATA to create the recipient ATA idempotently before minting; otherwise it must already exist. authority defaults to payer. For an SPL Token multisig authority, provide multisigSigners and collect member signatures externally.

Throws​

CCTParamsInvalidError If an address, amount, or multisig signer is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCIPTokenAccountNotFoundError If the recipient ATA is missing and createRecipientATA is not set.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedMintTokens({
payer: mintAuthority,
tokenAddress: mint,
recipient,
amount: 1_000_000n, // One token for a mint with six decimals
})

generateUnsignedOnboardToken()​

generateUnsignedOnboardToken(opts: GenerateOnboardTokenParams): Promise<GenerateOnboardTokenResult>

Defined in: cct/solana/index.ts:2966

Builds the unsigned transactions of the next CCIP 2.0 onboarding step, for an external signer such as a Squads vault. Land every returned transaction in order, then call again with the same params, until step is undefined. See onboardToken for the steps.

Parameters​

ParameterType
optsGenerateOnboardTokenParams

Returns​

Promise<GenerateOnboardTokenResult>

Remarks​

Each call plans from on-chain state, so it returns the step after the last one that landed; one step at a time, since each operation validates the state the previous ones leave. authority (defaulting to payer) must be the token's mint authority: it deploys and registers the pool and becomes its owner and token administrator. A lookup table is created from a recent slot that Solana accepts for about 3 minutes, so for a vault awaiting approvals, pass a hot wallet as lookupTablePayer: it creates the table in a createLookupTable step it signs alone (the result's payer), and the vault fills and sets it in setPool. Whenever a result has a lookupTableAddress, pass it as poolLookupTableAddress from then on.

See​

Throws​

CCTParamsInvalidError If a parameter is invalid, a precondition fails, or the next step's operation rejects the current state.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const onboarding: GenerateOnboardTokenParams = {
tokenAddress: mint,
poolType: 'burn-mint',
remoteChains: [{
remoteChainSelector: 16015286601757825753n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
inboundRateLimiterConfig: { enabled: false },
outboundRateLimiterConfig: { enabled: false },
ccvConfig: { outboundCCVs: [committeeVerifier], inboundCCVs: [committeeVerifier] },
}],
payer: vault, // the Squads vault: mint authority, payer, and future pool owner
lookupTablePayer: hotWallet, // creates the pool lookup table, without the vault's delay
}
for (;;) {
const { step, transactions, payer, lookupTableAddress } =
await cct.generateUnsignedOnboardToken(onboarding)
if (!step) break
for (const tx of transactions) {
const serialized = await cct.serializeUnsignedTx(tx, payer)
// createLookupTable: sign with the hot wallet and send it now;
// otherwise: propose `serialized` to Squads and wait until it executes
}
if (lookupTableAddress) onboarding.poolLookupTableAddress = lookupTableAddress
}

generateUnsignedOwnerOverridePendingAdministrator()​

generateUnsignedOwnerOverridePendingAdministrator(opts: GenerateOwnerOverridePendingAdministratorParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2463

Builds an unsigned instruction that replaces an initial pending registry administrator.

Parameters​

ParameterType
optsGenerateOwnerOverridePendingAdministratorParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

Only the mint authority may authorize this recovery path, and only while the registry has no accepted administrator. When the mint authority is a 1-of-N SPL multisig, authority is one of its signers, and the Router's multisig instruction is used. It replaces the initial pending administrator; the replacement must still call generateUnsignedAcceptAdmin. authority defaults to payer; use this unsigned method for Squads/vault signatures.

See​

Throws​

CCTParamsInvalidError If an address is invalid, the registry already has an accepted administrator, or the mint authority is a multisig whose threshold is not 1 or that authority does not sign for.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedOwnerOverridePendingAdministrator({
tokenAddress: mint,
address: router,
newAdmin: replacementAdmin,
payer: mintAuthority,
})

generateUnsignedProvideLiquidity()​

generateUnsignedProvideLiquidity(opts: GenerateProvideLiquidityParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1353

Builds an unsigned instruction to deposit a rebalancer's tokens into a lock-release pool. Pass poolProgramAddress only for a custom program; a custom program must have the canonical lock-release provideLiquidity instruction and account layout. authority defaults to payer. amount is a positive u64 in base units.

Parameters​

ParameterType
optsGenerateProvideLiquidityParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

The pool config must have a rebalancer equal to the transaction authority, and on pools before CCIP 2.0 also canAcceptLiquidity: true. The authority's ATA for tokenAddress must exist, hold at least amount, and delegate at least amount to the pool signer PDA. Set includeApproval: true to bundle that approval before the liquidity instruction in this transaction.

See​

Throws​

CCTParamsInvalidError If a pool parameter, address, or amount is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool state is missing.

Throws​

CCIPTokenAccountNotFoundError If the rebalancer or pool vault ATA is missing; create it first.

Example​

Generate bundled approval and liquidity instructions

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const liquidity = await cct.generateUnsignedProvideLiquidity({
payer: rebalancer,
tokenAddress: mint,
amount: 1_000_000n,
includeApproval: true,
})

generateUnsignedRegisterAdmin()​

generateUnsignedRegisterAdmin(opts: GenerateRegisterAdminParams): Promise<UnsignedSolanaTx>

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

Builds an unsigned Solana token registration instruction.

This proposes the registry administrator. The proposed admin must accept the role using generateUnsignedAcceptAdmin before calling generateUnsignedSetPool. The administrator defaults to the mint authority and the method to owner; choose ccip-admin when the Router CCIP admin signs. Provide administrator to nominate a different admin or register a mint with no mint authority.

Parameters​

ParameterType
optsGenerateRegisterAdminParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

When the mint authority is a 1-of-N SPL multisig, the owner method takes one of its signers as authority and uses the Router's multisig instruction. The administrator then defaults to authority, as the multisig cannot accept the role; ccip-admin requires an explicit administrator.

See​

Throws​

CCTParamsInvalidError If an address or registrationMethod is invalid, the authority does not match the selected registration method, administrator is required, or a registry entry already exists for the token.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedRegisterAdmin({
tokenAddress: mint,
address: router,
payer: mintAuthority,
})

generateUnsignedRemoveFromAllowlist()​

generateUnsignedRemoveFromAllowlist(opts: GenerateRemoveFromAllowlistParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2605

Builds an unsigned instruction to remove addresses from a token pool allowlist. The pool must be initialized first. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer. Every removed address must already be allowlisted or the transaction reverts.

Parameters​

ParameterType
optsGenerateRemoveFromAllowlistParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

Removal does not change enforcement; removing the last allowed sender while the allowlist is enabled blocks all senders — use configureAllowlist to toggle.

See​

Throws​

CCTParamsInvalidError If a pool parameter is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedRemoveFromAllowlist({
tokenAddress: mint,
remove: [sender],
payer,
authority,
})

generateUnsignedSetCanAcceptLiquidity()​

generateUnsignedSetCanAcceptLiquidity(opts: GenerateSetCanAcceptLiquidityParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1502

Builds an unsigned instruction that sets whether an initialized Solana lock-release token pool accepts provideLiquidity deposits and withdrawLiquidity transfers. Pass poolProgramAddress only for a custom program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateSetCanAcceptLiquidityParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

CCIP 2.0 lock-release pools removed this setting: they always accept liquidity, and this operation throws CCTOperationUnsupportedError for them. To stop rebalancing on a 2.0 pool, set the rebalancer to the default address with setRebalancer.

⚠️ Consequence: Setting allow to true lets the rebalancer both provideLiquidity and withdrawLiquidity. Setting allow to false disables both — liquidity already in the pool cannot be withdrawn until allow is re-enabled. Verify the current liquidity balance before flipping to false.

See​

Throws​

CCTParamsInvalidError If allow, a pool parameter, or public key is invalid.

Throws​

CCTOperationUnsupportedError If the pool is CCIP 2.0 or later.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetCanAcceptLiquidity({
tokenAddress: mint,
allow: true,
payer,
authority,
})

generateUnsignedSetChainRateLimit()​

generateUnsignedSetChainRateLimit(opts: GenerateSetChainRateLimitParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1769

Builds an unsigned instruction that sets inbound and outbound rate limits for an initialized Solana token pool remote-chain config. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateSetChainRateLimitParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner or rate-limit admin. The remote-chain config must already exist. Enabled limits require rate <= capacity; disabled limits default omitted values to zero and reject nonzero values.

See​

Throws​

CCTParamsInvalidError If a pool parameter, rate limit, or selector is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetChainRateLimit({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
inbound: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
outbound: { enabled: false }, // Disabled limits default capacity and rate to zero.
payer,
authority,
})

generateUnsignedSetFastFinalityRateLimit()​

generateUnsignedSetFastFinalityRateLimit(opts: GenerateSetFastFinalityRateLimitParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2084

Builds an unsigned instruction that sets a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateSetFastFinalityRateLimitParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner or rate-limit admin. The FTF rate limits must already exist. Enabled limits require rate <= capacity; disabled limits default omitted values to zero and reject nonzero values.

See​

Throws​

CCTParamsInvalidError If a pool parameter, rate limit, or selector is invalid.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
inbound: { enabled: true, capacity: 2_000_000n, rate: 2_000n },
outbound: { enabled: false },
payer,
authority,
})

generateUnsignedSetPool()​

generateUnsignedSetPool(opts: GenerateSetPoolParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2670

Builds unsigned Solana setPool instructions.

The token must first be registered and its proposed administrator accepted. The payer pays transaction fees; authority defaults to payer, while Squads/multisig flows should pass the token admin/vault authority explicitly. For a newly deployed canonical pool, create the pool signer's ATA before calling this operation.

Parameters​

ParameterType
optsGenerateSetPoolParams

Returns​

Promise<UnsignedSolanaTx>

See​

Throws​

CCTParamsInvalidError If an address or writableIndexes is invalid.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetPool({
tokenAddress: mint,
address: router,
poolLookupTableAddress: lookupTable,
payer: squadsVault,
authority: tokenAdmin,
})

generateUnsignedSetPoolInterfaceImplementation()​

generateUnsignedSetPoolInterfaceImplementation(opts: GenerateSetPoolInterfaceImplementationParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2797

Builds an unsigned instruction that records in a token's CCIP 2.0 TokenAdminRegistry which pool interface its pool implements, and how the Router resolves the pool's accounts. authority defaults to payer.

Parameters​

ParameterType
optsGenerateSetPoolInterfaceImplementationParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the token administrator, and the registry to be at the Router's latest layout; migrate an older one with generateUnsignedUpgradeTokenAdminRegistry. The Router accepts one account resolution per interface version, which accountResolution defaults to: NoResolution for 1, WithoutExtendedLookupTable for 2.

See​

Throws​

CCTParamsInvalidError If a public key, the interface version, or the account resolution is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetPoolInterfaceImplementation({
tokenAddress: mint,
address: router,
interfaceVersion: 2,
accountResolution: 'WithoutExtendedLookupTable',
payer,
authority,
})

generateUnsignedSetRateLimitAdmin()​

generateUnsignedSetRateLimitAdmin(opts: GenerateSetRateLimitAdminParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1283

Builds an unsigned instruction that assigns the rate-limit admin for an initialized Solana token pool. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateSetRateLimitAdminParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner. This assignment takes effect immediately; unlike ownership transfer, it has no acceptance step. The new rate-limit admin may configure chain rate limits but cannot change this role.

See​

Throws​

CCTParamsInvalidError If a pool parameter or public key is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetRateLimitAdmin({
tokenAddress: mint,
newRateLimitAdmin,
payer,
authority,
})

generateUnsignedSetRebalancer()​

generateUnsignedSetRebalancer(opts: GenerateSetRebalancerParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1576

Builds an unsigned instruction that sets the address authorized to provide or withdraw liquidity for an initialized Solana lock-release token pool. Pass poolProgramAddress only for a custom program; authority defaults to payer. The default/zero public key (11111111111111111111111111111111) disables rebalancing.

Parameters​

ParameterType
optsGenerateSetRebalancerParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

⚠️ Consequence: Rebalancer is the address allowed to provide or withdraw liquidity. Setting the zero address (11111111111111111111111111111111) removes the rebalancer; until a new one is set, no account can provide or withdraw liquidity, even liquidity already in the pool. This does not affect whether the pool accepts liquidity — see setCanAcceptLiquidity.

See​

Throws​

CCTParamsInvalidError If a pool parameter or public key is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetRebalancer({
tokenAddress: mint,
rebalancer,
payer,
authority,
})

generateUnsignedSetTokenAuthority()​

generateUnsignedSetTokenAuthority(opts: GenerateSetTokenAuthorityParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:604

Builds unsigned instructions for an immediate SPL Token mint and/or freeze authority update.

Parameters​

ParameterType
optsGenerateSetTokenAuthorityParams

Returns​

Promise<UnsignedSolanaTx>

See​

setTokenAuthority For wallet-based execution.

Remarks​

⚠️ IRREVERSIBLE: Setting newAuthority to null permanently revokes the selected authority roles for the SPL Token. Once revoked, the authority cannot be recovered or transferred. Example: revoked mint authority prevents anyone from minting tokens. Use with extreme caution.

Once confirmed, the current authority loses the selected roles. Set authorityTypes to ['mint'], ['freeze'], or both. All selected roles must have the same current authority. The instructions are atomic: no role changes if any selected update fails. authority defaults to payer. For an SPL Token multisig authority, provide multisigSigners and collect member signatures externally.

Throws​

CCTParamsInvalidError If an address or authority role selection is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Examples​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetTokenAuthority({
payer: currentAuthority,
tokenAddress: mint,
newAuthority,
authorityTypes: ['mint'],
})

Permanently revoke mint authority

TypeScript
const revokeUnsigned = await cct.generateUnsignedSetTokenAuthority({
payer: currentAuthority,
tokenAddress: mint,
newAuthority: null, // ⚠️ PERMANENT
authorityTypes: ['mint'],
})

generateUnsignedTransferAdmin()​

generateUnsignedTransferAdmin(opts: GenerateTransferAdminParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2730

Builds an unsigned Solana instruction that transfers a token administrator role.

Parameters​

ParameterType
optsGenerateTransferAdminParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

This transfers an already accepted administrator role; it does not register a token. The proposed administrator must call generateUnsignedAcceptAdmin before becoming the current administrator.

See​

generateUnsignedAcceptAdmin

Throws​

CCTParamsInvalidError If an address is invalid or the authority is not the current token administrator.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedTransferAdmin({
tokenAddress: mint,
address: router,
newAdmin,
payer: currentAdmin,
})

generateUnsignedTransferPoolOwnership()​

generateUnsignedTransferPoolOwnership(opts: GenerateTransferPoolOwnershipParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1650

Builds an unsigned instruction that proposes a new owner for an initialized Solana token pool. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer. The operation reads pool state and rejects the current owner or default public key. The proposed owner must accept ownership separately before the transfer takes effect.

Parameters​

ParameterType
optsGenerateTransferPoolOwnershipParams

Returns​

Promise<UnsignedSolanaTx>

See​

Throws​

CCTParamsInvalidError If a pool parameter or public key is invalid.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool account does not exist.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedTransferPoolOwnership({
tokenAddress: mint,
newOwner,
payer,
authority,
})

generateUnsignedUpdateMetadataAuthority()​

generateUnsignedUpdateMetadataAuthority(opts: GenerateUpdateMetadataAuthorityParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:669

Builds unsigned instructions to transfer a token's Metaplex metadata update authority.

Parameters​

ParameterType
optsGenerateUpdateMetadataAuthorityParams

Returns​

Promise<UnsignedSolanaTx>

See​

Remarks​

The mint must have mutable Metaplex Token Metadata and authority must match its current update authority. authority defaults to payer; both the payer and authority must sign if they differ. Use this to hand metadata control to a multisig or DAO after deployment.

Throws​

CCTParamsInvalidError If an address is invalid, the mint has no Metaplex metadata, or authority is not its current metadata update authority.

Throws​

CCTTxFailedError If the metadata is immutable.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedUpdateMetadataAuthority({
payer: currentAuthority,
tokenAddress: mint,
newAuthority,
})

generateUnsignedUpgradeTokenAdminRegistry()​

generateUnsignedUpgradeTokenAdminRegistry(opts: GenerateUpgradeTokenAdminRegistryParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2859

Builds an unsigned instruction that migrates a token's TokenAdminRegistry from an older layout to the CCIP 2.0 Router's latest, keeping its administrator, pool, and account resolution. authority defaults to payer.

Parameters​

ParameterType
optsGenerateUpgradeTokenAdminRegistryParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

Permissionless: authority only pays for the account's growth. The Router rejects a registry already at the latest layout.

See​

Throws​

CCTParamsInvalidError If a public key is invalid.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedUpgradeTokenAdminRegistry({
tokenAddress: mint,
address: router,
payer,
})

generateUnsignedWithdrawFeeTokens()​

generateUnsignedWithdrawFeeTokens(opts: GenerateWithdrawFeeTokensParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:2209

Builds unsigned instructions that withdraw the fees a CCIP 2.0 token pool accrued in one fee token, into the recipient's associated token account, which is created first if missing. Pass poolProgramAddress for a non-canonical pool program; authority defaults to payer.

Parameters​

ParameterType
optsGenerateWithdrawFeeTokensParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

On-chain execution requires authority to be the pool owner. The pool's balance in the fee token must be positive and at least amount, which defaults to the whole balance.

See​

withdrawFeeTokens

Throws​

CCTParamsInvalidError If a public key or the amount is invalid, or the pool is a CCTP or Lombard pool, which withdraws fees with its own instruction.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedWithdrawFeeTokens({
tokenAddress: mint,
feeTokenAddress: linkMint,
recipient: treasury,
payer,
authority,
})

generateUnsignedWithdrawLiquidity()​

generateUnsignedWithdrawLiquidity(opts: GenerateWithdrawLiquidityParams): Promise<UnsignedSolanaTx>

Defined in: cct/solana/index.ts:1429

Builds an unsigned instruction to withdraw tokens from a lock-release pool to a rebalancer's associated token account. Pass poolProgramAddress only for a custom program; a custom program must have the canonical lock-release withdrawLiquidity instruction and account layout. authority defaults to payer. amount is a positive u64 in base units.

Parameters​

ParameterType
optsGenerateWithdrawLiquidityParams

Returns​

Promise<UnsignedSolanaTx>

Remarks​

The pool config must have a rebalancer equal to the transaction authority, and on pools before CCIP 2.0 also canAcceptLiquidity: true. The rebalancer's associated token account must already exist.

See​

Throws​

CCTParamsInvalidError If a pool parameter, address, or amount is invalid.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Example​

Generate a liquidity withdrawal instruction

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const withdrawal = await cct.generateUnsignedWithdrawLiquidity({
payer: rebalancer,
tokenAddress: mint,
amount: 1_000_000n,
})

getCCVConfig()​

getCCVConfig(opts: GetCCVConfigParams): Promise<Required<TokenPoolCCVConfig>>

Defined in: cct/solana/index.ts:1983

Reads the CCVs a CCIP 2.0 token pool requires on a remote chain's lane, from its ChainConfigV2. Pass poolProgramAddress for a non-canonical pool program.

Parameters​

ParameterType
optsGetCCVConfigParams

Returns​

Promise<Required<TokenPoolCCVConfig>>

Remarks​

The result has the shape of the ccvConfig param of editChainConfigV2 and initChainConfigV2, so it can be modified and passed back; edit keeps the lane's finality and fees when they are omitted. A lane without a ChainConfigV2 returns empty lists and a 0n thresholdAmount: the pool requires no CCVs of its own on it. Base lists apply to every transfer; threshold lists add CCVs from thresholdAmount (local mint base units) when it is positive. These are the pool's own CCVs, required on top of the lane's.

See​

generateUnsignedEditChainConfigV2

Throws​

CCTParamsInvalidError If the token or pool program address or remote selector is invalid.

Throws​

CCIPTokenPoolStateNotFoundError If the pool state account does not exist.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTDataDecodeError If the lane's ChainConfigV2 cannot be decoded.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const { inboundCCVs, outboundCCVs, thresholdAmount } = await cct.getCCVConfig({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
})
console.log({ inboundCCVs, outboundCCVs, thresholdAmount })

getSupportedTokens()​

getSupportedTokens(opts: GetSupportedTokensParams): Promise<string[]>

Defined in: cct/solana/index.ts:3144

Lists all SPL token mints configured in a Router's TokenAdminRegistry in a single scan; pagination is not supported.

Parameters​

ParameterType
optsGetSupportedTokensParams

Returns​

Promise<string[]>

Throws​

CCTParamsInvalidError If address is not a valid Solana public key.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const tokens = await cct.getSupportedTokens({ address: router })

getTokenAdminRegistry()​

getTokenAdminRegistry(opts: GetTokenAdminRegistryParams): Promise<GetTokenAdminRegistryResult>

Defined in: cct/solana/index.ts:3127

Reads a token's TokenAdminRegistry administrator, pending administrator, and pool lookup table.

Parameters​

ParameterType
optsGetTokenAdminRegistryParams

Returns​

Promise<GetTokenAdminRegistryResult>

Throws​

CCTParamsInvalidError If address or tokenAddress is not a valid Solana public key.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const config = await cct.getTokenAdminRegistry({
address: router,
tokenAddress: mint,
})

getTokenInfo()​

getTokenInfo(opts: GetTokenInfoParams): Promise<GetTokenInfoResult>

Defined in: cct/solana/index.ts:3050

Reads an SPL token mint's metadata, program, supply, initialization state, and mint/freeze authorities.

Parameters​

ParameterType
optsGetTokenInfoParams

Returns​

Promise<GetTokenInfoResult>

Remarks​

Metadata comes from SolanaChain.getTokenInfo; mint state comes directly from the SPL Token or Token-2022 mint account. Supply is in base units. Solana-only; no EVM CCT equivalent exists.

See​

Throws​

CCTParamsInvalidError If tokenAddress is not a valid Solana public key.

Throws​

CCIPSplTokenInvalidError If the token metadata is not a valid SPL token.

Throws​

CCIPTokenMintNotFoundError If the mint account does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCIPTokenDataParseError If the mint data cannot be parsed.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const info = await cct.getTokenInfo({ tokenAddress: mint })
console.log(`${info.symbol}: ${info.decimals} decimals`)

getTokenOnboardingPlan()​

getTokenOnboardingPlan(opts: GenerateOnboardTokenParams): Promise<TokenOnboardingPlan>

Defined in: cct/solana/index.ts:2910

Plans the CCIP 2.0 onboarding steps a token still needs, from on-chain state, without building any transaction. See onboardToken for the steps.

Parameters​

ParameterType
optsGenerateOnboardTokenParams

Returns​

Promise<TokenOnboardingPlan>

Remarks​

Before the pool is deployed, the plan reads the token's registry under the Router the pool program assigns new pools.

See​

generateUnsignedOnboardToken

Throws​

CCTParamsInvalidError If a parameter is invalid, or authority is not the mint authority, pool owner, token administrator, or (for a pool program without self-served pools) the program's upgrade authority where a remaining step needs it.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const { steps } = await cct.getTokenOnboardingPlan({ ...onboarding, payer: vault })
console.log(steps.map(({ name }) => name)) // e.g. ['applyChainUpdates', 'initChainConfigV2', …]

getTokenPoolRemotes()​

getTokenPoolRemotes(opts: GetTokenPoolRemotesParams): Promise<GetTokenPoolRemotesResult>

Defined in: cct/solana/index.ts:3075

Reads all, or one selected, Solana token pool remote-chain configurations.

Parameters​

ParameterType
optsGetTokenPoolRemotesParams

Returns​

Promise<GetTokenPoolRemotesResult>

Remarks​

Results are keyed by remote network name. Omit remoteChainSelector to scan all configured remotes; provide it to query one. Rate-limit amounts use the local mint's smallest unit.

Throws​

CCTParamsInvalidError If the token or pool program address or remote selector is invalid.

Throws​

CCIPTokenPoolStateNotFoundError If the pool state account does not exist.

Throws​

CCIPTokenPoolChainConfigNotFoundError If the selected remote-chain config does not exist.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const remotes = await cct.getTokenPoolRemotes({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
})
console.log(remotes)

getTokenPoolState()​

getTokenPoolState(opts: GetTokenPoolStateParams): Promise<GetTokenPoolStateResult>

Defined in: cct/solana/index.ts:3107

Reads a token pool's state account. A lock-release pool's config also reports its liquidity fields (rebalancer, canAcceptLiquidity); narrow on their presence.

Parameters​

ParameterType
optsGetTokenPoolStateParams

Returns​

Promise<GetTokenPoolStateResult>

Remarks​

The EVM counterpart, EVMTokenManager.getTokenPoolState, returns a different shape: its fields are flat where these nest under state.config, it spells config.mint / config.decimals / config.rmnRemote as token / tokenDecimals / rmnProxy, and its version is the pool's protocol semver ('2.0.0'), not the account-layout number returned here. owner, rateLimitAdmin and router are named alike on both.

Throws​

CCTParamsInvalidError If the token or pool program address is invalid.

Throws​

CCIPTokenPoolStateNotFoundError If the pool state account does not exist.

Throws​

CCTDataDecodeError If the pool state account cannot be decoded.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const state = await cct.getTokenPoolState({
tokenAddress: mint,
})
// config.owner must sign pool writes; config.rateLimitAdmin may set rate limits
console.log(state.config.owner, state.config.mint, state.config.decimals)
// lock-release only: who rebalances the pool, and whether it accepts liquidity
if ('rebalancer' in state.config) {
console.log(state.config.rebalancer, state.config.canAcceptLiquidity)
}

initChainConfigV2()​

initChainConfigV2(opts: ExecuteInitChainConfigV2Params): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1870

Creates a CCIP 2.0 token pool's ChainConfigV2 for a remote chain with the pool owner wallet.

Parameters​

ParameterType
optsExecuteInitChainConfigV2Params

Returns​

Promise<TransactionResult>

Remarks​

The config must not exist yet. Omitted fields default to full finality only, no token transfer fees, and no pool CCVs.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a parameter is invalid, the pool is a CCTP or Lombard pool, or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If the config already exists, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.initChainConfigV2({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
allowedFinality: { finalityDepth: 10 },
wallet,
})

initChainRemoteConfig()​

initChainRemoteConfig(opts: ExecuteInitChainRemoteConfigParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1185

Initializes a Solana token pool remote-chain config for a previously unconfigured selector with the pool owner wallet.

Parameters​

ParameterType
optsExecuteInitChainRemoteConfigParams

Returns​

Promise<TransactionResult>

Remarks​

This creates the chain-config PDA once and fails if it already exists. Configure remote pools and rate limits separately before using the lane.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If simulation or the pool rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.initChainRemoteConfig({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remoteTokenDecimals: 18,
wallet,
})

initFastFinalityRateLimit()​

initFastFinalityRateLimit(opts: ExecuteInitFastFinalityRateLimitParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2050

Creates a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain with the pool owner wallet.

Parameters​

ParameterType
optsExecuteInitFastFinalityRateLimitParams

Returns​

Promise<TransactionResult>

Remarks​

The FTF rate limits must not exist yet.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter or rate limit is invalid, or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If the FTF rate limits already exist, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.initFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
inbound: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
outbound: { enabled: false },
wallet,
})

mintTokens()​

mintTokens(opts: ExecuteMintTokensParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:559

Mints SPL tokens to a recipient's associated token account using the executing wallet.

Parameters​

ParameterType
optsExecuteMintTokensParams

Returns​

Promise<TransactionResult>

Remarks​

amount is in base units. Set createRecipientATA to create the recipient ATA idempotently before minting; otherwise it must already exist. SPL Token multisig authorities require multisigSigners and external member signatures; use generateUnsignedMintTokens.

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address, amount, or multisig signer is invalid, or authority does not match the executing wallet.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCIPTokenAccountNotFoundError If the recipient ATA is missing and createRecipientATA is not set.

Throws​

CCTTxFailedError If simulation or the SPL Token program rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.mintTokens({
wallet,
tokenAddress: mint,
recipient,
amount: 1_000_000n, // One token for a mint with six decimals
})

onboardToken()​

onboardToken(opts: ExecuteOnboardTokenParams): Promise<ExecuteOnboardTokenResult>

Defined in: cct/solana/index.ts:3020

Onboards a token on CCIP 2.0 with its mint authority's wallet, running every remaining step:

  1. deployTokenPool, with the pool signer's token account (and allowlist, if any)
  2. registerAdmin and acceptAdmin, making the wallet the token administrator, with upgradeTokenAdminRegistry first for a registry an older Router created
  3. setPool, after creating the pool's lookup table; it also replaces another pool the registry points at
  4. applyChainUpdates, connecting each remote chain with its pools and rate limits
  5. initChainConfigV2 per remote chain: allowed finality, fees and CCVs
  6. initFastFinalityRateLimit per remote chain with fastFinalityRateLimits
  7. setPoolInterfaceImplementation to the 2.0 interface, with WithoutExtendedLookupTable
  8. createTokenMultisig and setTokenAuthority (burn-mint only), making the mint authority a 1-of-2 SPL multisig of the pool signer, which mints through it alone, and the wallet, which keeps its own path to mint or move the mint authority

Parameters​

ParameterType
optsExecuteOnboardTokenParams

Returns​

Promise<ExecuteOnboardTokenResult>

Remarks​

Plans from on-chain state before every step, so a re-run after a failure resumes where it stopped. Steps already done are skipped; remote chains the pool already has are left as they are. The wallet must be the token's mint authority, and stays the pool owner and token administrator.

See​

generateUnsignedOnboardToken

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a parameter is invalid or a precondition fails.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If a step fails. Once the steps start, every error carries the steps that landed before it in context.executedSteps, and a failed setPool the lookup table it created in context.lookupTableAddress: pass it as poolLookupTableAddress to resume with it.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const { steps, poolAddress } = await cct.onboardToken({
tokenAddress: mint,
poolType: 'lock-release',
remoteChains: [{
remoteChainSelector: 16015286601757825753n,
remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
remoteTokenDecimals: 18,
inboundRateLimiterConfig: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
outboundRateLimiterConfig: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
}],
wallet,
})

ownerOverridePendingAdministrator()​

ownerOverridePendingAdministrator(opts: ExecuteOwnerOverridePendingAdministratorParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2501

Replaces an initial pending registry administrator using the mint authority wallet.

Parameters​

ParameterType
optsExecuteOwnerOverridePendingAdministratorParams

Returns​

Promise<TransactionResult>

Remarks​

This recovery path only works while the registry has no accepted administrator. It replaces the initial pending administrator; it does not make the replacement an administrator. The replacement must call acceptAdmin separately. authority defaults to wallet, which may also be a signer of a 1-of-N SPL multisig mint authority; use generateUnsignedOwnerOverridePendingAdministrator for Squads/vault flows.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address is invalid, the registry already has an accepted administrator, authority differs from the wallet, or the mint authority is a multisig whose threshold is not 1 or that authority does not sign for.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Throws​

CCTTxFailedError If the Router rejects a non-mint authority or the registry changes.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.ownerOverridePendingAdministrator({
tokenAddress: mint,
address: router,
newAdmin: replacementAdmin,
wallet: mintAuthorityWallet,
})

provideLiquidity()​

provideLiquidity(opts: ExecuteProvideLiquidityParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1397

Deposits tokens from the executing rebalancer wallet into a lock-release pool. Pass poolProgramAddress only for a custom program; a custom program must have the canonical lock-release provideLiquidity instruction and account layout. The wallet's associated token account must exist and hold the positive u64 amount in base units.

Parameters​

ParameterType
optsExecuteProvideLiquidityParams

Returns​

Promise<TransactionResult>

Remarks​

The pool config must have a rebalancer equal to the transaction authority, and on pools before CCIP 2.0 also canAcceptLiquidity: true. Before this operation, the rebalancer ATA must delegate at least amount to the pool signer PDA, unless includeApproval: true bundles that approval in this transaction.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter, address, or amount is invalid, or the authority differs from the executing wallet.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool state is missing.

Throws​

CCIPTokenAccountNotFoundError If the rebalancer or pool vault ATA is missing; create it first.

Throws​

CCTTxFailedError If the source ATA does not delegate enough tokens to the pool signer and includeApproval is false, the pool rejects the rebalancer, a pre-2.0 pool has liquidity disabled, the token account lacks funds, or simulation/submission fails.

Example​

Approve and provide liquidity in one transaction

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.provideLiquidity({
wallet,
tokenAddress: mint,
amount: 1_000_000n,
includeApproval: true,
})

registerAdmin()​

registerAdmin(opts: ExecuteRegisterAdminParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2576

Proposes a token registry administrator using the executing wallet as registration authority and fee payer. The proposed admin must acceptAdmin before calling setPool.

Parameters​

ParameterType
optsExecuteRegisterAdminParams

Returns​

Promise<TransactionResult>

Remarks​

With a 1-of-N SPL multisig mint authority, the wallet registers as one of its signers and is the default administrator; see generateUnsignedRegisterAdmin.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address or registrationMethod is invalid, the authority does not match the selected registration method or executing wallet, administrator is required, or a registry entry already exists for the token.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If simulation or the Router rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.registerAdmin({
tokenAddress: mint,
address: router,
wallet,
})

removeFromAllowlist()​

removeFromAllowlist(opts: ExecuteRemoveFromAllowlistParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2636

Removes addresses from an initialized Solana token pool allowlist using the pool owner wallet. Every removed address must already be allowlisted or the transaction reverts.

Parameters​

ParameterType
optsExecuteRemoveFromAllowlistParams

Returns​

Promise<TransactionResult>

Remarks​

Removal does not change enforcement; removing the last allowed sender while the allowlist is enabled blocks all senders — use configureAllowlist to toggle.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If transaction simulation or submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.removeFromAllowlist({
tokenAddress: mint,
remove: [sender],
wallet,
})

serializeUnsignedTx()​

serializeUnsignedTx(unsigned: Pick<UnsignedSolanaTx, "instructions" | "lookupTables">, payer: string, encoding?: SerializedSolanaTxEncoding): Promise<string>

Defined in: cct/solana/index.ts:3162

Serializes an unsigned Solana CCT tx for external signing.

Parameters​

ParameterType
unsignedPick<UnsignedSolanaTx, "instructions" | "lookupTables">
payerstring
encoding?SerializedSolanaTxEncoding

Returns​

Promise<string>

Throws​

CCTParamsInvalidError If encoding is unsupported or the transaction uses address lookup tables, which legacy-message serialization cannot represent.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetPool({ ...params, payer })
const base58 = await cct.serializeUnsignedTx(unsigned, payer)
const base64 = await cct.serializeUnsignedTx(unsigned, payer, 'base64')

setCanAcceptLiquidity()​

setCanAcceptLiquidity(opts: ExecuteSetCanAcceptLiquidityParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1540

Sets whether an initialized Solana lock-release token pool accepts provideLiquidity deposits and withdrawLiquidity transfers using the pool owner wallet.

Parameters​

ParameterType
optsExecuteSetCanAcceptLiquidityParams

Returns​

Promise<TransactionResult>

Remarks​

CCIP 2.0 lock-release pools removed this setting: they always accept liquidity, and this operation throws CCTOperationUnsupportedError for them. To stop rebalancing on a 2.0 pool, set the rebalancer to the default address with setRebalancer.

⚠️ Consequence: Setting allow to true lets the rebalancer both provideLiquidity and withdrawLiquidity. Setting allow to false disables both — liquidity already in the pool cannot be withdrawn until allow is re-enabled. Verify the current liquidity balance before flipping to false.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If allow or a pool parameter is invalid, or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool is CCIP 2.0 or later.

Throws​

CCTTxFailedError If the wallet is not the pool owner or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setCanAcceptLiquidity({
tokenAddress: mint,
allow: true,
wallet,
})

setChainRateLimit()​

setChainRateLimit(opts: ExecuteSetChainRateLimitParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1803

Sets inbound and outbound rate limits for an initialized Solana token pool remote-chain config with the pool owner or rate-limit admin wallet.

Parameters​

ParameterType
optsExecuteSetChainRateLimitParams

Returns​

Promise<TransactionResult>

Remarks​

The remote-chain config must already exist. Enabled limits require rate <= capacity; disabled limits default omitted values to zero and reject nonzero values.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter or rate limit is invalid, or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the chain config does not exist, the wallet is neither the pool owner nor rate-limit admin, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setChainRateLimit({
tokenAddress: mint,
remoteChainSelector: 5009297550715157269n,
inbound: { enabled: true, capacity: 1_000_000n, rate: 1_000n },
outbound: { enabled: false }, // Disabled limits default capacity and rate to zero.
wallet,
})

setFastFinalityRateLimit()​

setFastFinalityRateLimit(opts: ExecuteSetFastFinalityRateLimitParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2118

Sets a CCIP 2.0 token pool's faster-than-finality (FTF) rate limits for a remote chain with the pool owner or rate-limit admin wallet.

Parameters​

ParameterType
optsExecuteSetFastFinalityRateLimitParams

Returns​

Promise<TransactionResult>

Remarks​

The FTF rate limits must already exist.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter or rate limit is invalid, or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If the FTF rate limits do not exist, the wallet is neither the pool owner nor rate-limit admin, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setFastFinalityRateLimit({
tokenAddress: mint,
remoteChainSelector: 16015286601757825753n,
inbound: { enabled: true, capacity: 2_000_000n, rate: 2_000n },
outbound: { enabled: false },
wallet,
})

setPool()​

setPool(opts: ExecuteSetPoolParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2700

Registers a token pool. The token must first be registered and its proposed administrator accepted; the wallet must be the token admin authority. For a newly deployed canonical pool, create the pool signer's ATA before calling this operation.

Parameters​

ParameterType
optsExecuteSetPoolParams

Returns​

Promise<TransactionResult>

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address or writableIndexes is invalid.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCTTxFailedError If simulation or the Router rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setPool({
tokenAddress: mint,
address: router,
poolLookupTableAddress: lookupTable,
wallet,
})

setPoolInterfaceImplementation()​

setPoolInterfaceImplementation(opts: ExecuteSetPoolInterfaceImplementationParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2830

Records in a token's CCIP 2.0 TokenAdminRegistry which pool interface its pool implements, and how the Router resolves the pool's accounts, with the token administrator wallet.

Parameters​

ParameterType
optsExecuteSetPoolInterfaceImplementationParams

Returns​

Promise<TransactionResult>

Remarks​

The registry must be at the Router's latest layout; migrate an older one with upgradeTokenAdminRegistry.

See​

generateUnsignedSetPoolInterfaceImplementation

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the wallet is not the token administrator, the registry is not at the latest layout, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setPoolInterfaceImplementation({
tokenAddress: mint,
address: router,
interfaceVersion: 2,
accountResolution: 'WithoutExtendedLookupTable',
wallet,
})

setRateLimitAdmin()​

setRateLimitAdmin(opts: ExecuteSetRateLimitAdminParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1315

Assigns the rate-limit admin for an initialized Solana token pool with the pool owner wallet.

Parameters​

ParameterType
optsExecuteSetRateLimitAdminParams

Returns​

Promise<TransactionResult>

Remarks​

This assignment takes effect immediately; unlike ownership transfer, it has no acceptance step. The new rate-limit admin may configure chain rate limits but cannot change this role.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the pool does not exist, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setRateLimitAdmin({
tokenAddress: mint,
newRateLimitAdmin,
wallet,
})

setRebalancer()​

setRebalancer(opts: ExecuteSetRebalancerParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1623

Sets the address authorized to provide or withdraw liquidity for an initialized Solana lock-release token pool using the pool owner wallet. Pass poolProgramAddress only for a custom program; set rebalancer to the default/zero public key (11111111111111111111111111111111) to disable rebalancing.

Parameters​

ParameterType
optsExecuteSetRebalancerParams

Returns​

Promise<TransactionResult>

Remarks​

⚠️ Consequence: Rebalancer is the address allowed to provide or withdraw liquidity. Setting the zero address (11111111111111111111111111111111) removes the rebalancer; until a new one is set, no account can provide or withdraw liquidity, even liquidity already in the pool. This does not affect whether the pool accepts liquidity — see setCanAcceptLiquidity.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the wallet is not the pool owner or simulation/submission fails.

Examples​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setRebalancer({
tokenAddress: mint,
rebalancer,
wallet,
})

Disable rebalancing

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setRebalancer({
tokenAddress: mint,
rebalancer: PublicKey.default.toBase58(), // disable
wallet,
})

setTokenAuthority()​

setTokenAuthority(opts: ExecuteSetTokenAuthorityParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:639

Immediately sets SPL Token mint and/or freeze authority using the executing wallet.

Parameters​

ParameterType
optsExecuteSetTokenAuthorityParams

Returns​

Promise<TransactionResult>

See​

generateUnsignedSetTokenAuthority For externally signed transactions.

Remarks​

⚠️ IRREVERSIBLE: Setting newAuthority to null permanently revokes the selected authority roles for the SPL Token. Once revoked, the authority cannot be recovered or transferred. Example: revoked mint authority prevents anyone from minting tokens. Use with extreme caution.

Once confirmed, the current authority loses the selected roles. Set authorityTypes to ['mint'], ['freeze'], or both. All selected roles must have the same current authority. The transaction is atomic: no role changes if any selected update fails. SPL Token multisig authorities require multisigSigners and external member signatures; use generateUnsignedSetTokenAuthority.

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address or authority role selection is invalid, or authority does not match the executing wallet.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If simulation or the SPL Token program rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.setTokenAuthority({ wallet, tokenAddress: mint, newAuthority, authorityTypes: ['mint'] })

transferAdmin()​

transferAdmin(opts: ExecuteTransferAdminParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2763

Transfers a token administrator role using the executing wallet as the current administrator.

Parameters​

ParameterType
optsExecuteTransferAdminParams

Returns​

Promise<TransactionResult>

Remarks​

This transfers an already accepted administrator role; it does not register a token. The proposed administrator must call acceptAdmin before becoming the current administrator.

See​

acceptAdmin

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address is invalid or authority does not match the executing wallet/current token administrator.

Throws​

CCIPContractNotRouterError If address does not resolve to a Router.

Throws​

CCIPTokenNotConfiguredError If the token is not registered.

Throws​

CCTTxFailedError If simulation or the Router rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.transferAdmin({
tokenAddress: mint,
address: router,
newAdmin,
wallet: currentAdminWallet,
})

transferPoolOwnership()​

transferPoolOwnership(opts: ExecuteTransferPoolOwnershipParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:1680

Proposes a new owner for an initialized Solana token pool using the current owner wallet. It rejects the current owner or default public key. The proposed owner must accept ownership separately before the transfer takes effect.

Parameters​

ParameterType
optsExecuteTransferPoolOwnershipParams

Returns​

Promise<TransactionResult>

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter is invalid or the authority differs from the executing wallet.

Throws​

CCIPTokenPoolStateNotFoundError If the token pool account does not exist.

Throws​

CCTTxFailedError If the wallet is not the pool owner or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.transferPoolOwnership({
tokenAddress: mint,
newOwner,
wallet,
})

updateMetadataAuthority()​

updateMetadataAuthority(opts: ExecuteUpdateMetadataAuthorityParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:700

Transfers a token's Metaplex metadata update authority using the executing wallet.

Parameters​

ParameterType
optsExecuteUpdateMetadataAuthorityParams

Returns​

Promise<TransactionResult>

See​

Remarks​

The mint must have mutable Metaplex Token Metadata and the executing wallet must be its current update authority. Use this to hand metadata control to a multisig or DAO after deployment. Use generateUnsignedUpdateMetadataAuthority when payer and authority differ or external signatures are required.

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If an address is invalid, the mint has no Metaplex metadata, or authority does not match the metadata or executing wallet.

Throws​

CCTTxFailedError If the metadata is immutable, simulation fails, or the Metaplex program rejects the transaction.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.updateMetadataAuthority({ wallet, tokenAddress: mint, newAuthority })

upgradeTokenAdminRegistry()​

upgradeTokenAdminRegistry(opts: ExecuteUpgradeTokenAdminRegistryParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2883

Migrates a token's TokenAdminRegistry to the CCIP 2.0 Router's latest layout, paid by the wallet.

Parameters​

ParameterType
optsExecuteUpgradeTokenAdminRegistryParams

Returns​

Promise<TransactionResult>

See​

generateUnsignedUpgradeTokenAdminRegistry

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a public key is invalid or the authority differs from the executing wallet.

Throws​

CCTTxFailedError If the registry is already at the latest layout, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.upgradeTokenAdminRegistry({ tokenAddress: mint, address: router, wallet })

withdrawFeeTokens()​

withdrawFeeTokens(opts: ExecuteWithdrawFeeTokensParams): Promise<TransactionResult>

Defined in: cct/solana/index.ts:2241

Withdraws the fees a CCIP 2.0 token pool accrued in one fee token with the pool owner wallet.

Parameters​

ParameterType
optsExecuteWithdrawFeeTokensParams

Returns​

Promise<TransactionResult>

Remarks​

The pool's balance in the fee token must be positive and at least amount, which defaults to the whole balance.

See​

generateUnsignedWithdrawFeeTokens

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a public key or the amount is invalid, the pool is a CCTP or Lombard pool, or the authority differs from the executing wallet.

Throws​

CCTOperationUnsupportedError If the pool program predates CCIP 2.0.

Throws​

CCTTxFailedError If there are no fees to withdraw, the wallet is not the pool owner, or simulation/submission fails.

Example​

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.withdrawFeeTokens({
tokenAddress: mint,
feeTokenAddress: linkMint,
recipient: treasury,
wallet,
})

withdrawLiquidity()​

withdrawLiquidity(opts: ExecuteWithdrawLiquidityParams): Promise<TransactionResult>

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

Withdraws tokens from a lock-release pool into the executing rebalancer wallet's associated token account. Pass poolProgramAddress only for a custom program; a custom program must have the canonical lock-release withdrawLiquidity instruction and account layout. The wallet's associated token account must exist. amount is a positive u64 in base units.

Parameters​

ParameterType
optsExecuteWithdrawLiquidityParams

Returns​

Promise<TransactionResult>

Remarks​

The pool config must have a rebalancer equal to the transaction authority, and on pools before CCIP 2.0 also canAcceptLiquidity: true.

See​

Throws​

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws​

CCTParamsInvalidError If a pool parameter, address, or amount is invalid, or the authority differs from the executing wallet.

Throws​

CCIPTokenMintNotFoundError If the mint does not exist.

Throws​

CCIPTokenMintInvalidError If the mint is not owned by an SPL Token program.

Throws​

CCTTxFailedError If the pool rejects the rebalancer, a pre-2.0 pool has liquidity disabled, the pool lacks liquidity, the token account does not exist, or simulation/submission fails.

Example​

Withdraw liquidity

TypeScript
const cct = SolanaTokenManager.fromChain(chain)
await cct.withdrawLiquidity({
wallet,
tokenAddress: mint,
amount: 1_000_000n,
})

fromChain()​

static fromChain(chain: SolanaChain): SolanaTokenManager

Defined in: cct/solana/index.ts:299

Wraps an existing SolanaChain.

Parameters​

ParameterType
chainSolanaChain

Returns​

SolanaTokenManager


fromProvider()​

static fromProvider(provider: Connection, ctx?: ChainContext): Promise<SolanaTokenManager>

Defined in: cct/solana/index.ts:304

Creates from a Solana web3.js connection.

Parameters​

ParameterType
providerConnection
ctx?ChainContext

Returns​

Promise<SolanaTokenManager>


fromUrl()​

static fromUrl(url: string, ctx?: ChainContext): Promise<SolanaTokenManager>

Defined in: cct/solana/index.ts:310

Creates from an RPC URL.

Parameters​

ParameterType
urlstring
ctx?ChainContext

Returns​

Promise<SolanaTokenManager>