Class: SolanaTokenManager

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

CCT admin facade for Solana.

Extends

• TokenManager<typeof Solana>

Constructors

Constructor

new SolanaTokenManager(chain: SolanaChain): SolanaTokenManager

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

Creates a Solana CCT manager for an existing chain.

Parameters

Parameter	Type
chain	SolanaChain

Returns

SolanaTokenManager

Overrides

TokenManager<typeof ChainFamily.Solana>.constructor

Properties

chain

readonly chain: SolanaChain

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

Chain this manager builds and submits through.

Overrides

TokenManager.chain

Accessors

provider

Get Signature

get provider(): Connection

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

Provider of the underlying chain.

Returns

Connection

Methods

acceptAdmin()

acceptAdmin(opts: ExecuteAcceptAdminParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteAcceptAdminParams

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

• registerAdmin
• transferAdmin
• setPool

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

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

Parameter	Type
opts	ExecuteAcceptPoolOwnershipParams

Returns

Promise<TransactionResult>

See

• generateUnsignedAcceptPoolOwnership
• transferPoolOwnership

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,
  poolType: 'burn-mint',
  wallet,
})

---

appendRemotePoolAddresses()

appendRemotePoolAddresses(opts: ExecuteAppendRemotePoolAddressesParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteAppendRemotePoolAddressesParams

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

• generateUnsignedAppendRemotePoolAddresses
• editChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
  wallet,
})

---

appendToLookupTable()

appendToLookupTable(opts: ExecuteAppendToLookupTableParams): Promise<ExecuteAppendToLookupTableResult>

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

Extends a Solana lookup table.

Pass tokenAddress with a canonical poolType or custom poolProgramAddress to append the standard CCIP pool addresses.

Parameters

Parameter	Type
opts	ExecuteAppendToLookupTableParams

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

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

Parameters

Parameter	Type
opts	ExecuteApplyChainUpdatesParams

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,
  poolType: 'burn-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:380

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

Parameters

Parameter	Type
opts	ExecuteApproveTokenParams

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

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

Parameter	Type
opts	ExecuteConfigureAllowlistParams

Returns

Promise<TransactionResult>

See

• generateUnsignedConfigureAllowlist
• deployTokenPool
• removeFromAllowlist

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,
  poolType: 'burn-mint',
  add: [],
  enabled: false,
  wallet,
})

---

createLookupTable()

createLookupTable(opts: ExecuteCreateLookupTableParams): Promise<ExecuteCreateLookupTableResult>

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

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

Parameter	Type
opts	ExecuteCreateLookupTableParams

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

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

Parameters

Parameter	Type
opts	ExecuteCreateTokenAccountParams

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

• deployTokenPool
• setPool

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

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

Parameter	Type
opts	ExecuteCreateTokenMultisigParams

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

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

Parameters

Parameter	Type
opts	ExecuteDeleteChainRemoteConfigParams

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

• generateUnsignedDeleteChainRemoteConfig
• initChainRemoteConfig
• editChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  wallet,
})

---

deployToken()

deployToken(opts: ExecuteDeployTokenParams): Promise<ExecuteDeployTokenResult>

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

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

Parameters

Parameter	Type
opts	ExecuteDeployTokenParams

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

Initializes a Solana token pool.

Parameters

Parameter	Type
opts	ExecuteDeployTokenPoolParams

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

• createTokenAccount
• setPool
• mintTokens

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

---

editChainRemoteConfig()

editChainRemoteConfig(opts: ExecuteEditChainRemoteConfigParams): Promise<TransactionResult>

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

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

Parameter	Type
opts	ExecuteEditChainRemoteConfigParams

Returns

Promise<TransactionResult>

See

• generateUnsignedEditChainRemoteConfig
• initChainRemoteConfig
• deleteChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
  remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
  remoteTokenDecimals: 18,
  wallet,
})

---

generateUnsignedAcceptAdmin()

generateUnsignedAcceptAdmin(opts: GenerateAcceptAdminParams): Promise<UnsignedSolanaTx>

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

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

The supplied authority must be the pending token administrator.

Parameters

Parameter	Type
opts	GenerateAcceptAdminParams

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

• generateUnsignedRegisterAdmin
• generateUnsignedTransferAdmin
• generateUnsignedSetPool

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

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

Parameters

Parameter	Type
opts	GenerateAcceptPoolOwnershipParams

Returns

Promise<UnsignedSolanaTx>

See

• acceptPoolOwnership
• generateUnsignedTransferPoolOwnership

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,
  poolType: 'burn-mint',
  payer,
  authority,
})

---

generateUnsignedAppendRemotePoolAddresses()

generateUnsignedAppendRemotePoolAddresses(opts: GenerateAppendRemotePoolAddressesParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateAppendRemotePoolAddressesParams

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

• appendRemotePoolAddresses
• generateUnsignedEditChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
  payer,
  authority,
})

---

generateUnsignedAppendToLookupTable()

generateUnsignedAppendToLookupTable(opts: GenerateAppendToLookupTableParams): Promise<UnsignedSolanaTx>

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

Builds unsigned Solana lookup table extend instructions.

Pass tokenAddress with a canonical poolType or custom poolProgramAddress to append the standard CCIP pool addresses; pass additionalAddresses to append manual addresses. authority defaults to payer.

Parameters

Parameter	Type
opts	GenerateAppendToLookupTableParams

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

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

Parameter	Type
opts	GenerateApplyChainUpdatesParams

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,
  poolType: 'burn-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:345

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

Parameters

Parameter	Type
opts	GenerateApproveTokenParams

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

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 canonical poolType or a compatible poolProgramAddress; authority defaults to payer.

Parameters

Parameter	Type
opts	GenerateConfigureAllowlistParams

Returns

Promise<UnsignedSolanaTx>

See

• configureAllowlist
• generateUnsignedDeployTokenPool
• generateUnsignedRemoveFromAllowlist

Throws

CCTParamsInvalidError If a pool parameter is invalid.

Example

TypeScript

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

---

generateUnsignedCreateLookupTable()

generateUnsignedCreateLookupTable(opts: GenerateCreateLookupTableParams): Promise<GenerateCreateLookupTableResult>

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

Builds unsigned Solana pool lookup table instructions.

Defaults to create+extend. Specify a canonical poolType or custom poolProgramAddress. 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

Parameter	Type
opts	GenerateCreateLookupTableParams

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

Builds an unsigned idempotent associated token account create instruction.

Parameters

Parameter	Type
opts	GenerateCreateTokenAccountParams

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

• generateUnsignedDeployTokenPool
• generateUnsignedSetPool

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

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

Parameters

Parameter	Type
opts	GenerateCreateTokenMultisigParams

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

Builds an unsigned instruction that closes a Solana token pool remote-chain config. Pass canonical poolType or a compatible poolProgramAddress; authority defaults to payer.

Parameters

Parameter	Type
opts	GenerateDeleteChainRemoteConfigParams

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

• deleteChainRemoteConfig
• generateUnsignedInitChainRemoteConfig
• generateUnsignedEditChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  payer,
  authority,
})

---

generateUnsignedDeployToken()

generateUnsignedDeployToken(opts: GenerateDeployTokenParams): Promise<GenerateDeployTokenResult>

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

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

Parameters

Parameter	Type
opts	GenerateDeployTokenParams

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

Builds unsigned Solana token pool initialize instructions.

Parameters

Parameter	Type
opts	GenerateDeployTokenPoolParams

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

• generateUnsignedCreateTokenAccount
• generateUnsignedSetPool
• mintTokens

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

---

generateUnsignedEditChainRemoteConfig()

generateUnsignedEditChainRemoteConfig(opts: GenerateEditChainRemoteConfigParams): Promise<UnsignedSolanaTx>

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

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 canonical poolType or a compatible poolProgramAddress; authority defaults to payer.

Parameters

Parameter	Type
opts	GenerateEditChainRemoteConfigParams

Returns

Promise<UnsignedSolanaTx>

See

• editChainRemoteConfig
• generateUnsignedInitChainRemoteConfig
• generateUnsignedDeleteChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
  remotePoolAddresses: ['0x1234567890abcdef1234567890abcdef12345678'],
  remoteTokenDecimals: 18,
  payer,
  authority,
})

---

generateUnsignedInitChainRemoteConfig()

generateUnsignedInitChainRemoteConfig(opts: GenerateInitChainRemoteConfigParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateInitChainRemoteConfigParams

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

• initChainRemoteConfig
• generateUnsignedEditChainRemoteConfig
• generateUnsignedDeleteChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
  remoteTokenDecimals: 18,
  payer,
  authority,
})

---

generateUnsignedMintTokens()

generateUnsignedMintTokens(opts: GenerateMintTokensParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateMintTokensParams

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

---

generateUnsignedOwnerOverridePendingAdministrator()

generateUnsignedOwnerOverridePendingAdministrator(opts: GenerateOwnerOverridePendingAdministratorParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateOwnerOverridePendingAdministratorParams

Returns

Promise<UnsignedSolanaTx>

Remarks

Only the mint authority may authorize this recovery path, and only while the registry has no accepted administrator. 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

• ownerOverridePendingAdministrator For wallet-based execution.
• generateUnsignedAcceptAdmin The replacement administrator must accept separately.

Throws

CCTParamsInvalidError If an address is invalid or the registry already has an accepted 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.generateUnsignedOwnerOverridePendingAdministrator({
  tokenAddress: mint,
  address: router,
  newAdmin: replacementAdmin,
  payer: mintAuthority,
})

---

generateUnsignedProvideLiquidity()

generateUnsignedProvideLiquidity(opts: GenerateProvideLiquidityParams): Promise<UnsignedSolanaTx>

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

Builds an unsigned instruction to deposit a rebalancer's tokens into a lock-release pool. Pass poolType: 'lock-release' or a compatible poolProgramAddress; 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

Parameter	Type
opts	GenerateProvideLiquidityParams

Returns

Promise<UnsignedSolanaTx>

Remarks

The pool config must have canAcceptLiquidity: true and a rebalancer equal to the transaction authority. 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

• provideLiquidity
• generateUnsignedApproveToken
• setRebalancer
• setCanAcceptLiquidity

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,
  poolType: 'lock-release',
  amount: 1_000_000n,
  includeApproval: true,
})

---

generateUnsignedRegisterAdmin()

generateUnsignedRegisterAdmin(opts: GenerateRegisterAdminParams): Promise<UnsignedSolanaTx>

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

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

Parameter	Type
opts	GenerateRegisterAdminParams

Returns

Promise<UnsignedSolanaTx>

See

• generateUnsignedAcceptAdmin
• generateUnsignedSetPool

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

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

Parameters

Parameter	Type
opts	GenerateRemoveFromAllowlistParams

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

• generateUnsignedConfigureAllowlist
• removeFromAllowlist

Throws

CCTParamsInvalidError If a pool parameter is invalid.

Example

TypeScript

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

---

generateUnsignedSetCanAcceptLiquidity()

generateUnsignedSetCanAcceptLiquidity(opts: GenerateSetCanAcceptLiquidityParams): Promise<UnsignedSolanaTx>

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

Builds an unsigned instruction that sets whether an initialized Solana lock-release token pool accepts provideLiquidity deposits and withdrawLiquidity transfers. Pass canonical poolType: 'lock-release' or a compatible poolProgramAddress; authority defaults to payer.

Parameters

Parameter	Type
opts	GenerateSetCanAcceptLiquidityParams

Returns

Promise<UnsignedSolanaTx>

Remarks

⚠️ 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

• setCanAcceptLiquidity
• generateUnsignedSetRebalancer

Throws

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

Example

TypeScript

const cct = SolanaTokenManager.fromChain(chain)
const unsigned = await cct.generateUnsignedSetCanAcceptLiquidity({
  tokenAddress: mint,
  poolType: 'lock-release',
  allow: true,
  payer,
  authority,
})

---

generateUnsignedSetChainRateLimit()

generateUnsignedSetChainRateLimit(opts: GenerateSetChainRateLimitParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateSetChainRateLimitParams

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

• setChainRateLimit
• generateUnsignedInitChainRemoteConfig

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,
  poolType: 'burn-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,
})

---

generateUnsignedSetPool()

generateUnsignedSetPool(opts: GenerateSetPoolParams): Promise<UnsignedSolanaTx>

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

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

Parameter	Type
opts	GenerateSetPoolParams

Returns

Promise<UnsignedSolanaTx>

See

• generateUnsignedRegisterAdmin
• generateUnsignedAcceptAdmin
• generateUnsignedDeployTokenPool
• generateUnsignedCreateTokenAccount

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

---

generateUnsignedSetRateLimitAdmin()

generateUnsignedSetRateLimitAdmin(opts: GenerateSetRateLimitAdminParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateSetRateLimitAdminParams

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

• setRateLimitAdmin
• generateUnsignedSetChainRateLimit

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,
  poolType: 'burn-mint',
  newRateLimitAdmin,
  payer,
  authority,
})

---

generateUnsignedSetRebalancer()

generateUnsignedSetRebalancer(opts: GenerateSetRebalancerParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateSetRebalancerParams

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

• setRebalancer
• setCanAcceptLiquidity
• generateUnsignedSetCanAcceptLiquidity

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,
  poolType: 'lock-release',
  rebalancer,
  payer,
  authority,
})

---

generateUnsignedSetTokenAuthority()

generateUnsignedSetTokenAuthority(opts: GenerateSetTokenAuthorityParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateSetTokenAuthorityParams

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

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

Parameters

Parameter	Type
opts	GenerateTransferAdminParams

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

Builds an unsigned instruction that proposes a new owner for an initialized Solana token pool. Pass canonical poolType or a compatible poolProgramAddress; 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

Parameter	Type
opts	GenerateTransferPoolOwnershipParams

Returns

Promise<UnsignedSolanaTx>

See

• transferPoolOwnership
• generateUnsignedAcceptPoolOwnership

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,
  poolType: 'burn-mint',
  newOwner,
  payer,
  authority,
})

---

generateUnsignedUpdateMetadataAuthority()

generateUnsignedUpdateMetadataAuthority(opts: GenerateUpdateMetadataAuthorityParams): Promise<UnsignedSolanaTx>

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

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

Parameters

Parameter	Type
opts	GenerateUpdateMetadataAuthorityParams

Returns

Promise<UnsignedSolanaTx>

See

• updateMetadataAuthority For wallet-based execution.
• setTokenAuthority For SPL mint and freeze authority changes.
• deployToken To set the initial metadata update authority.

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

---

generateUnsignedWithdrawLiquidity()

generateUnsignedWithdrawLiquidity(opts: GenerateWithdrawLiquidityParams): Promise<UnsignedSolanaTx>

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

Builds an unsigned instruction to withdraw tokens from a lock-release pool to a rebalancer's associated token account. Pass poolType: 'lock-release' or a compatible poolProgramAddress; 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

Parameter	Type
opts	GenerateWithdrawLiquidityParams

Returns

Promise<UnsignedSolanaTx>

Remarks

The pool config must have canAcceptLiquidity: true and a rebalancer equal to the transaction authority. The rebalancer's associated token account must already exist.

See

• withdrawLiquidity
• generateUnsignedSetRebalancer
• generateUnsignedSetCanAcceptLiquidity

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,
  poolType: 'lock-release',
  amount: 1_000_000n,
})

---

getSupportedTokens()

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

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

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

Parameters

Parameter	Type
opts	GetSupportedTokensParams

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

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

Parameters

Parameter	Type
opts	GetTokenAdminRegistryParams

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

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

Parameters

Parameter	Type
opts	GetTokenInfoParams

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

• setTokenAuthority Sets the mint or freeze authorities returned here.
• updateMetadataAuthority Updates the Metaplex metadata associated with this mint.
• getTokenPoolState Reads pool configuration rather than mint state.
• SolanaChain.getTokenInfo Reads the underlying token metadata.

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

---

getTokenPoolRemotes()

getTokenPoolRemotes(opts: GetTokenPoolRemotesParams): Promise<GetTokenPoolRemotesResult>

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

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

Parameters

Parameter	Type
opts	GetTokenPoolRemotesParams

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
})
console.log(remotes)

---

getTokenPoolState()

Implementation for the overloads above; callers always resolve to one of those.

Call Signature

getTokenPoolState(opts: LockReleasePoolProgramRef & { tokenAddress: string; }): Promise<LockReleaseGetTokenPoolStateResult>

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

Reads a Lock/Release token pool's state account, whose config also reports its liquidity fields (rebalancer, canAcceptLiquidity).

Parameters

Parameter	Type
opts	LockReleasePoolProgramRef & { tokenAddress: string; }

Returns

Promise<LockReleaseGetTokenPoolStateResult>

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({
  poolType: 'lock-release',
  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
console.log(state.config.rebalancer, state.config.canAcceptLiquidity)

Call Signature

getTokenPoolState(opts: BurnMintPoolProgramRef | CustomPoolProgramRef & { tokenAddress: string; }): Promise<BaseGetTokenPoolStateResult>

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

Reads a Burn/Mint or custom token pool's state account; its config carries no liquidity fields. Pass poolProgramAddress instead of poolType for a custom pool program.

Parameters

Parameter	Type
opts	BurnMintPoolProgramRef | CustomPoolProgramRef & { tokenAddress: string; }

Returns

Promise<BaseGetTokenPoolStateResult>

Call Signature

getTokenPoolState(opts: GetTokenPoolStateParams): Promise<GetTokenPoolStateResult>

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

Reads a pool state account whose program is not known statically; narrow the result on the presence of the lock-release-only config fields.

Parameters

Parameter	Type
opts	GetTokenPoolStateParams

Returns

Promise<GetTokenPoolStateResult>

---

initChainRemoteConfig()

initChainRemoteConfig(opts: ExecuteInitChainRemoteConfigParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteInitChainRemoteConfigParams

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

• generateUnsignedInitChainRemoteConfig
• editChainRemoteConfig
• deleteChainRemoteConfig

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,
  poolType: 'burn-mint',
  remoteChainSelector: 5009297550715157269n,
  remoteTokenAddress: '0x1234567890abcdef1234567890abcdef12345678',
  remoteTokenDecimals: 18,
  wallet,
})

---

mintTokens()

mintTokens(opts: ExecuteMintTokensParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteMintTokensParams

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

---

ownerOverridePendingAdministrator()

ownerOverridePendingAdministrator(opts: ExecuteOwnerOverridePendingAdministratorParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteOwnerOverridePendingAdministratorParams

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; use generateUnsignedOwnerOverridePendingAdministrator for Squads/vault flows.

See

• generateUnsignedOwnerOverridePendingAdministrator For externally signed transactions.
• acceptAdmin The replacement administrator must accept the role separately.

Throws

CCIPWalletInvalidError If wallet cannot sign Solana transactions.

Throws

CCTParamsInvalidError If an address is invalid, the registry already has an accepted administrator, or authority differs from the wallet.

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

Deposits tokens from the executing rebalancer wallet into a lock-release pool. Pass poolType: 'lock-release' or a compatible poolProgramAddress; 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

Parameter	Type
opts	ExecuteProvideLiquidityParams

Returns

Promise<TransactionResult>

Remarks

The pool config must have canAcceptLiquidity: true and a rebalancer equal to the transaction authority. 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

• generateUnsignedProvideLiquidity
• approveToken
• setRebalancer
• setCanAcceptLiquidity

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, liquidity is 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,
  poolType: 'lock-release',
  amount: 1_000_000n,
  includeApproval: true,
})

---

registerAdmin()

registerAdmin(opts: ExecuteRegisterAdminParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteRegisterAdminParams

Returns

Promise<TransactionResult>

See

• acceptAdmin
• setPool

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

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

Parameter	Type
opts	ExecuteRemoveFromAllowlistParams

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

• configureAllowlist
• generateUnsignedRemoveFromAllowlist

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,
  poolType: 'burn-mint',
  remove: [sender],
  wallet,
})

---

serializeUnsignedTx()

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

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

Serializes an unsigned Solana CCT tx for external signing.

Parameters

Parameter	Type
unsigned	Pick<UnsignedSolanaTx, "instructions" | "lookupTables">
payer	string
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:1484

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

Parameters

Parameter	Type
opts	ExecuteSetCanAcceptLiquidityParams

Returns

Promise<TransactionResult>

Remarks

⚠️ 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

• generateUnsignedSetCanAcceptLiquidity
• setRebalancer

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

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,
  poolType: 'lock-release',
  allow: true,
  wallet,
})

---

setChainRateLimit()

setChainRateLimit(opts: ExecuteSetChainRateLimitParams): Promise<TransactionResult>

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

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

Parameter	Type
opts	ExecuteSetChainRateLimitParams

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

• generateUnsignedSetChainRateLimit
• initChainRemoteConfig

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,
  poolType: 'burn-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,
})

---

setPool()

setPool(opts: ExecuteSetPoolParams): Promise<TransactionResult>

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

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

Parameter	Type
opts	ExecuteSetPoolParams

Returns

Promise<TransactionResult>

See

• registerAdmin
• acceptAdmin
• deployTokenPool
• createTokenAccount

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

---

setRateLimitAdmin()

setRateLimitAdmin(opts: ExecuteSetRateLimitAdminParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteSetRateLimitAdminParams

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

• generateUnsignedSetRateLimitAdmin
• setChainRateLimit

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,
  poolType: 'burn-mint',
  newRateLimitAdmin,
  wallet,
})

---

setRebalancer()

setRebalancer(opts: ExecuteSetRebalancerParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteSetRebalancerParams

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

• generateUnsignedSetRebalancer
• setCanAcceptLiquidity
• generateUnsignedSetCanAcceptLiquidity

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,
  poolType: 'lock-release',
  rebalancer,
  wallet,
})

Disable rebalancing

TypeScript

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

---

setTokenAuthority()

setTokenAuthority(opts: ExecuteSetTokenAuthorityParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteSetTokenAuthorityParams

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

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

Parameters

Parameter	Type
opts	ExecuteTransferAdminParams

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

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

Parameter	Type
opts	ExecuteTransferPoolOwnershipParams

Returns

Promise<TransactionResult>

See

• generateUnsignedTransferPoolOwnership
• acceptPoolOwnership

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,
  poolType: 'burn-mint',
  newOwner,
  wallet,
})

---

updateMetadataAuthority()

updateMetadataAuthority(opts: ExecuteUpdateMetadataAuthorityParams): Promise<TransactionResult>

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

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

Parameters

Parameter	Type
opts	ExecuteUpdateMetadataAuthorityParams

Returns

Promise<TransactionResult>

See

• generateUnsignedUpdateMetadataAuthority For externally signed transactions.
• setTokenAuthority For SPL mint and freeze authority changes.
• deployToken To set the initial metadata update authority.

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

---

withdrawLiquidity()

withdrawLiquidity(opts: ExecuteWithdrawLiquidityParams): Promise<TransactionResult>

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

Withdraws tokens from a lock-release pool into the executing rebalancer wallet's associated token account. Pass poolType: 'lock-release' or a compatible poolProgramAddress; 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

Parameter	Type
opts	ExecuteWithdrawLiquidityParams

Returns

Promise<TransactionResult>

Remarks

The pool config must have canAcceptLiquidity: true and a rebalancer equal to the transaction authority.

See

• generateUnsignedWithdrawLiquidity
• setRebalancer
• setCanAcceptLiquidity

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, liquidity is disabled, 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,
  poolType: 'lock-release',
  amount: 1_000_000n,
})

---

fromChain()

static fromChain(chain: SolanaChain): SolanaTokenManager

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

Wraps an existing SolanaChain.

Parameters

Parameter	Type
chain	SolanaChain

Returns

SolanaTokenManager

---

fromProvider()

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

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

Creates from a Solana web3.js connection.

Parameters

Parameter	Type
provider	Connection
ctx?	ChainContext

Returns

Promise<SolanaTokenManager>

---

fromUrl()

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

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

Creates from an RPC URL.

Parameters

Parameter	Type
url	string
ctx?	ChainContext

Returns

Promise<SolanaTokenManager>