@chainlink/ccip-sdk 0.95.0 → 0.97.0

package/src/solana/index.ts

@@ -73,14 +73,14 @@ import SELECTORS from '../selectors.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
   type AnyMessage,
-  type CCIPCommit,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
+  type CCIPVerifications,
   type ChainTransaction,
   type CommitReport,
+  type ExecutionInput,
   type ExecutionReceipt,
-  type ExecutionReport,
   type Lane,
   type Log_,
   type MergeArrayElements,
@@ -96,6 +96,7 @@ import {
   createRateLimitedFetch,
   decodeAddress,
   decodeOnRampAddress,
+  getAddressBytes,
   getDataBytes,
   leToBigInt,
   networkInfo,
@@ -126,7 +127,7 @@ import {
 } from './utils.ts'
 import { buildMessageForDest, getMessagesInBatch } from '../requests.ts'
 import { patchBorsh } from './patchBorsh.ts'
-import { DEFAULT_GAS_LIMIT } from '../evm/const.ts'
+import { DEFAULT_GAS_LIMIT } from '../shared/constants.ts'
 export type { UnsignedSolanaTx }
 
 const routerCoder = new BorshCoder(CCIP_ROUTER_IDL)
@@ -171,6 +172,29 @@ export type SolanaTransaction = MergeArrayElements<
 
 /**
  * Solana chain implementation supporting Solana networks.
+ *
+ * Provides methods for sending CCIP cross-chain messages, querying message
+ * status, fetching fee quotes, and manually executing pending messages on
+ * Solana networks.
+ *
+ * @remarks
+ * Solana uses CCIP v1.6+ protocol only.
+ *
+ * @example Create from RPC URL
+ * ```typescript
+ * import { SolanaChain } from '@chainlink/ccip-sdk'
+ *
+ * const chain = await SolanaChain.fromUrl('https://api.devnet.solana.com')
+ * console.log(`Connected to: ${chain.network.name}`)
+ * ```
+ *
+ * @example Query messages in a transaction
+ * ```typescript
+ * const requests = await chain.getMessagesInTx('5abc123...')
+ * for (const req of requests) {
+ *   console.log(`Message ID: ${req.message.messageId}`)
+ * }
+ * ```
  */
 export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   static {
@@ -252,6 +276,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @param url - RPC endpoint URL (https://, http://, wss://, or ws://).
    * @param ctx - context containing logger.
    * @returns Solana Connection instance.
+   * @throws {@link CCIPDataFormatUnsupportedError} if URL format is invalid
    */
   static _getConnection(url: string, ctx?: WithLogger): Connection {
     const { logger = console } = ctx ?? {}
@@ -283,9 +308,20 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
 
   /**
    * Creates a SolanaChain instance from an RPC URL.
-   * @param url - RPC endpoint URL.
-   * @param ctx - context containing logger.
-   * @returns A new SolanaChain instance.
+   *
+   * @param url - RPC endpoint URL (https://, http://, wss://, or ws://).
+   * @param ctx - Optional context containing logger and API client configuration.
+   * @returns A new SolanaChain instance connected to the specified network.
+   * @throws {@link CCIPChainNotFoundError} if chain cannot be identified from genesis hash
+   *
+   * @example
+   * ```typescript
+   * // Create from devnet URL
+   * const chain = await SolanaChain.fromUrl('https://api.devnet.solana.com')
+   *
+   * // With custom logger
+   * const chain = await SolanaChain.fromUrl(url, { logger: customLogger })
+   * ```
    */
   static async fromUrl(url: string, ctx?: ChainContext): Promise<SolanaChain> {
     const connection = this._getConnection(url, ctx)
@@ -293,7 +329,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }
 
   // cached
-  /** {@inheritDoc Chain.getBlockTimestamp} */
+  /**
+   * {@inheritDoc Chain.getBlockTimestamp}
+   * @throws {@link CCIPBlockTimeNotFoundError} if block time cannot be retrieved
+   */
   async getBlockTimestamp(block: number | 'latest' | 'finalized'): Promise<number> {
     if (typeof block !== 'number') {
       const slot = await this.connection.getSlot(block === 'latest' ? 'confirmed' : block)
@@ -313,7 +352,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return blockTime
   }
 
-  /** {@inheritDoc Chain.getTransaction} */
+  /**
+   * {@inheritDoc Chain.getTransaction}
+   * @throws {@link CCIPTransactionNotFoundError} if transaction not found
+   */
   async getTransaction(hash: string): Promise<SolanaTransaction> {
     const tx = await this.connection.getTransaction(hash, {
       commitment: 'confirmed',
@@ -389,6 +431,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   - `programs`: Special option to allow querying by address of interest, but yielding matching
    *     logs from specific (string address) program or any (true)
    * @returns AsyncIterableIterator of parsed Log_ objects.
+   * @throws {@link CCIPLogsAddressRequiredError} if address is not provided
+   * @throws {@link CCIPTopicsInvalidError} if topics contain invalid values
    */
   async *getLogs(
     opts: LogFilter & { programs?: string[] | true },
@@ -433,15 +477,15 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }
 
   /** {@inheritDoc Chain.getMessagesInBatch} */
-  async getMessagesInBatch<
+  override async getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
       'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
     >,
   >(
     request: R,
-    commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
-    opts?: { page?: number },
+    range: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    opts?: Pick<LogFilter, 'page'>,
   ): Promise<R['message'][]> {
     const [destChainStatePda] = PublicKey.findProgramAddressSync(
       [Buffer.from('dest_chain_state'), toLeArray(request.lane.destChainSelector, 8)],
@@ -454,7 +498,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       programs: [request.log.address],
       address: destChainStatePda.toBase58(),
     }
-    return getMessagesInBatch(this, request, commit, opts_)
+    return getMessagesInBatch(this, request, range, opts_)
   }
 
   /** {@inheritDoc Chain.typeAndVersion} */
@@ -480,7 +524,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return Promise.resolve(onRamp) // Solana's router is also the onRamp
   }
 
-  /** {@inheritDoc Chain.getRouterForOffRamp} */
+  /**
+   * {@inheritDoc Chain.getRouterForOffRamp}
+   * @throws {@link CCIPSolanaRefAddressesNotFoundError} if reference addresses PDA not found
+   */
   async getRouterForOffRamp(offRamp: string, _sourceChainSelector: bigint): Promise<string> {
     const offRamp_ = new PublicKey(offRamp)
     const program = new Program(CCIP_OFFRAMP_IDL as Idl, offRamp_, {
@@ -507,7 +554,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return Promise.resolve(NATIVE_MINT.toBase58())
   }
 
-  /** {@inheritDoc Chain.getOffRampsForRouter} */
+  /**
+   * {@inheritDoc Chain.getOffRampsForRouter}
+   * @throws {@link CCIPSolanaOffRampEventsNotFoundError} if no OffRamp events found
+   */
   async getOffRampsForRouter(router: string, sourceChainSelector: bigint): Promise<string[]> {
     // feeQuoter is present in router's config, and has a DestChainState account which is updated by
     // the offramps, so we can use it to narrow the search for the offramp
@@ -533,8 +583,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return Promise.resolve(router) // solana's Router is also the OnRamp
   }
 
-  /** {@inheritDoc Chain.getOnRampForOffRamp} */
-  async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
+  /** {@inheritDoc Chain.getOnRampsForOffRamp} */
+  async getOnRampsForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string[]> {
     const program = new Program(CCIP_OFFRAMP_IDL, new PublicKey(offRamp), {
       connection: this.connection,
     })
@@ -548,18 +598,18 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     const {
       config: { onRamp },
     } = await program.account.sourceChain.fetch(statePda)
-    return decodeAddress(
-      new Uint8Array(onRamp.bytes.slice(0, onRamp.len)),
-      networkInfo(sourceChainSelector).family,
-    )
-  }
-
-  /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
-  getCommitStoreForOffRamp(offRamp: string): Promise<string> {
-    return Promise.resolve(offRamp) // Solana supports only CCIP>=1.6, for which OffRamp and CommitStore are the same
+    return [
+      decodeAddress(
+        getAddressBytes(onRamp.bytes).subarray(0, onRamp.len),
+        networkInfo(sourceChainSelector).family,
+      ),
+    ]
   }
 
-  /** {@inheritDoc Chain.getTokenForTokenPool} */
+  /**
+   * {@inheritDoc Chain.getTokenForTokenPool}
+   * @throws {@link CCIPTokenPoolInfoNotFoundError} if token pool info not found
+   */
   async getTokenForTokenPool(tokenPool: string): Promise<string> {
     const tokenPoolInfo = await this.connection.getAccountInfo(new PublicKey(tokenPool))
     if (!tokenPoolInfo) throw new CCIPTokenPoolInfoNotFoundError(tokenPool)
@@ -570,7 +620,11 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return config.mint.toString()
   }
 
-  /** {@inheritDoc Chain.getTokenInfo} */
+  /**
+   * {@inheritDoc Chain.getTokenInfo}
+   * @throws {@link CCIPSplTokenInvalidError} if token is not a valid SPL token
+   * @throws {@link CCIPTokenDataParseError} if token data cannot be parsed
+   */
   async getTokenInfo(token: string): Promise<TokenInfo> {
     const mint = new PublicKey(token)
     const mintInfo = await this.connection.getParsedAccountInfo(mint)
@@ -619,7 +673,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     }
   }
 
-  /** {@inheritDoc Chain.getBalance} */
+  /**
+   * {@inheritDoc Chain.getBalance}
+   * @throws {@link CCIPTokenAccountNotFoundError} if token account not found
+   */
   async getBalance(opts: GetBalanceOpts): Promise<bigint> {
     const { holder, token } = opts
     const holderPubkey = new PublicKey(holder)
@@ -712,6 +769,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * Decodes a CCIP message from a Solana log event.
    * @param log - Log with data field.
    * @returns Decoded CCIPMessage or undefined if not valid.
+   * @throws {@link CCIPExtraArgsInvalidError} if extra args cannot be decoded
    */
   static decodeMessage({ data }: { data: unknown }): CCIPMessage | undefined {
     if (!data || typeof data !== 'string') return undefined
@@ -789,6 +847,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * Decodes extra arguments from Solana CCIP messages.
    * @param extraArgs - Encoded extra arguments bytes.
    * @returns Decoded EVMExtraArgsV2 or undefined if unknown format.
+   * @throws {@link CCIPExtraArgsLengthInvalidError} if extra args length is invalid
    */
   static decodeExtraArgs(
     extraArgs: BytesLike,
@@ -816,6 +875,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * Encodes extra arguments for Solana CCIP messages.
    * @param args - Extra arguments to encode.
    * @returns Encoded extra arguments as hex string.
+   * @throws {@link CCIPSolanaExtraArgsEncodingError} if SVMExtraArgsV1 encoding is attempted
    */
   static encodeExtraArgs(args: ExtraArgs): string {
     if ('computeUnits' in args) throw new CCIPSolanaExtraArgsEncodingError()
@@ -832,6 +892,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @param log - Log with data field.
    * @param lane - Lane info for filtering.
    * @returns Array of CommitReport or undefined if not valid.
+   * @throws {@link CCIPLogDataMissingError} if log data is missing
    */
   static decodeCommits(
     log: Pick<Log_, 'data'>,
@@ -886,6 +947,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * Decodes an execution receipt from a Solana log event.
    * @param log - Log with data, tx, and index fields.
    * @returns ExecutionReceipt or undefined if not valid.
+   * @throws {@link CCIPLogDataMissingError} if log data is missing
+   * @throws {@link CCIPExecutionStateInvalidError} if execution state is invalid
    */
   static decodeReceipt(log: Pick<Log_, 'data' | 'tx' | 'index'>): ExecutionReceipt | undefined {
     // Check if this is a ExecutionStateChanged event by looking at the discriminant
@@ -984,7 +1047,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return getV16SolanaLeafHasher(lane, ctx)
   }
 
-  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
+  /**
+   * {@inheritDoc Chain.getTokenAdminRegistryFor}
+   * @throws {@link CCIPContractNotRouterError} if address is not a Router
+   */
   async getTokenAdminRegistryFor(address: string): Promise<string> {
     const [type] = await this.typeAndVersion(address)
     if (!type.includes('Router')) throw new CCIPContractNotRouterError(address, type)
@@ -1026,7 +1092,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     )
   }
 
-  /** {@inheritDoc Chain.sendMessage} */
+  /**
+   * {@inheritDoc Chain.sendMessage}
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Solana wallet
+   */
   async sendMessage(opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
     if (!isWallet(opts.wallet)) throw new CCIPWalletInvalidError(util.inspect(opts.wallet))
     const unsigned = await this.generateUnsignedSendMessage({
@@ -1044,22 +1113,22 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }
 
   /**
-   * {@inheritDoc Chain.generateUnsignedExecuteReport}
+   * {@inheritDoc Chain.generateUnsignedExecute}
    * @returns instructions - array of instructions to execute the report
    *   lookupTables - array of lookup tables for `manuallyExecute` call
    *   mainIndex - index of the `manuallyExecute` instruction in the array; last unless
    *   forceLookupTable is set, in which case last is ALT deactivation tx, and manuallyExecute is
    *   second to last
+   * @throws {@link CCIPExecutionReportChainMismatchError} if message is not a Solana message
    */
-  async generateUnsignedExecuteReport({
+  async generateUnsignedExecute({
     payer,
-    offRamp,
-    execReport,
     ...opts
-  }: Parameters<Chain['generateUnsignedExecuteReport']>[0]): Promise<UnsignedSolanaTx> {
-    if (!('computeUnits' in execReport.message))
+  }: Parameters<Chain['generateUnsignedExecute']>[0]): Promise<UnsignedSolanaTx> {
+    if (!('input' in opts) || !('message' in opts.input) || !('computeUnits' in opts.input.message))
       throw new CCIPExecutionReportChainMismatchError('Solana')
-    const execReport_ = execReport as ExecutionReport<CCIPMessage_V1_6_Solana>
+    const { offRamp, input } = opts
+    const execReport_ = input as ExecutionInput<CCIPMessage_V1_6_Solana>
     return generateUnsignedExecuteReport(
       this,
       new PublicKey(payer),
@@ -1069,9 +1138,12 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     )
   }
 
-  /** {@inheritDoc Chain.executeReport} */
-  async executeReport(
-    opts: Parameters<Chain['executeReport']>[0] & {
+  /**
+   * {@inheritDoc Chain.execute}
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Solana wallet
+   */
+  async execute(
+    opts: Parameters<Chain['execute']>[0] & {
       // when cleaning leftover LookUp Tables, wait deactivation grace period (~513 slots) then close ALT
       waitDeactivation?: boolean
     },
@@ -1082,7 +1154,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     let hash
     do {
       try {
-        const unsigned = await this.generateUnsignedExecuteReport({
+        const unsigned = await this.generateUnsignedExecute({
           ...opts,
           payer: wallet.publicKey.toBase58(),
         })
@@ -1118,6 +1190,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   - waitDeactivation - Whether to wait for lookup table deactivation cool down period
    *       (513 slots) to pass before closing; by default, we deactivate (if needed) and move on, to
    *       close other ready ALTs
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Solana wallet
    */
   async cleanUpBuffers(opts: { wallet: unknown; waitDeactivation?: boolean }): Promise<void> {
     const wallet = opts.wallet
@@ -1157,39 +1230,36 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   /**
    * Solana specialization: use getProgramAccounts to fetch commit reports from PDAs
    */
-  override async getCommitReport(
-    opts: Parameters<Chain['getCommitReport']>[0],
-  ): Promise<CCIPCommit> {
-    const { commitStore, request } = opts
-    const commitsAroundSeqNum = await this.connection.getProgramAccounts(
-      new PublicKey(commitStore),
-      {
-        filters: [
-          {
-            // commit report account discriminator filter
-            memcmp: {
-              offset: 0,
-              bytes: encodeBase58(BorshAccountsCoder.accountDiscriminator('CommitReport')),
-            },
+  override async getVerifications(
+    opts: Parameters<Chain['getVerifications']>[0],
+  ): Promise<CCIPVerifications> {
+    const { offRamp, request } = opts
+    const commitsAroundSeqNum = await this.connection.getProgramAccounts(new PublicKey(offRamp), {
+      filters: [
+        {
+          // commit report account discriminator filter
+          memcmp: {
+            offset: 0,
+            bytes: encodeBase58(BorshAccountsCoder.accountDiscriminator('CommitReport')),
           },
-          {
-            // sourceChainSelector filter
-            memcmp: {
-              offset: 8 + 1,
-              bytes: encodeBase58(toLeArray(request.lane.sourceChainSelector, 8)),
-            },
+        },
+        {
+          // sourceChainSelector filter
+          memcmp: {
+            offset: 8 + 1,
+            bytes: encodeBase58(toLeArray(request.lane.sourceChainSelector, 8)),
           },
-          // memcmp report.min with msg.sequenceNumber's without least-significant byte;
-          // this should be ~256 around seqNum, i.e. big chance of a match; requires PDAs not to have been closed
-          {
-            memcmp: {
-              offset: 8 + 1 + 8 + 32 + 8 + /*skip byte*/ 1,
-              bytes: encodeBase58(toLeArray(request.message.sequenceNumber, 8).slice(1)),
-            },
+        },
+        // memcmp report.min with msg.sequenceNumber's without least-significant byte;
+        // this should be ~256 around seqNum, i.e. big chance of a match; requires PDAs not to have been closed
+        {
+          memcmp: {
+            offset: 8 + 1 + 8 + 32 + 8 + /*skip byte*/ 1,
+            bytes: encodeBase58(toLeArray(request.message.sequenceNumber, 8).slice(1)),
           },
-        ],
-      },
-    )
+        },
+      ],
+    })
     for (const acc of commitsAroundSeqNum) {
       // const merkleRoot = acc.account.data.subarray(8 + 1 + 8, 8 + 1 + 8 + 32)
       const minSeqNr = acc.account.data.readBigUInt64LE(8 + 1 + 8 + 32 + 8)
@@ -1199,7 +1269,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       // we have all the commit report info, but we also need log details (txHash, etc)
       for await (const log of this.getLogs({
         startTime: 1, // just to force getting the oldest log first
-        programs: [commitStore],
+        programs: [offRamp],
         address: acc.pubkey.toBase58(),
         topics: ['CommitReportAccepted'],
       })) {
@@ -1212,23 +1282,23 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       }
     }
     // in case we can't find it, fallback to generic iterating txs
-    return super.getCommitReport(opts)
+    return super.getVerifications(opts)
   }
 
   /** {@inheritDoc Chain.getExecutionReceipts} */
   override async *getExecutionReceipts(
     opts: Parameters<Chain['getExecutionReceipts']>[0],
   ): AsyncIterableIterator<CCIPExecution> {
-    const { offRamp, sourceChainSelector, commit } = opts
+    const { offRamp, sourceChainSelector, verifications } = opts
     let opts_: Parameters<Chain['getExecutionReceipts']>[0] &
       Parameters<SolanaChain['getLogs']>[0] = opts
-    if (commit && sourceChainSelector) {
+    if (sourceChainSelector && verifications && 'report' in verifications) {
       // if we know of commit, use `commit_report` PDA as more specialized address
       const [commitReportPda] = PublicKey.findProgramAddressSync(
         [
           Buffer.from('commit_report'),
           toLeArray(sourceChainSelector, 8),
-          bytesToBuffer(commit.report.merkleRoot),
+          bytesToBuffer(verifications.report.merkleRoot),
         ],
         new PublicKey(offRamp),
       )
@@ -1241,7 +1311,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     yield* super.getExecutionReceipts(opts_)
   }
 
-  /** {@inheritDoc Chain.getRegistryTokenConfig} */
+  /**
+   * {@inheritDoc Chain.getRegistryTokenConfig}
+   * @throws {@link CCIPTokenNotConfiguredError} if token is not configured in registry
+   */
   async getRegistryTokenConfig(
     registry: string,
     token: string,
@@ -1295,8 +1368,11 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return config
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfigs} */
-  async getTokenPoolConfigs(tokenPool: string): Promise<{
+  /**
+   * {@inheritDoc Chain.getTokenPoolConfig}
+   * @throws {@link CCIPTokenPoolStateNotFoundError} if token pool state not found
+   */
+  async getTokenPoolConfig(tokenPool: string): Promise<{
     token: string
     router: string
     tokenPoolProgram: string
@@ -1328,7 +1404,11 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     }
   }
 
-  /** {@inheritDoc Chain.getTokenPoolRemotes} */
+  /**
+   * {@inheritDoc Chain.getTokenPoolRemotes}
+   * @throws {@link CCIPTokenPoolStateNotFoundError} if token pool state not found
+   * @throws {@link CCIPTokenPoolChainConfigNotFoundError} if chain config not found for specified selector
+   */
   async getTokenPoolRemotes(
     tokenPool: string,
     remoteChainSelector?: bigint,
@@ -1506,7 +1586,14 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return program.account.config.fetch(configPda)
   }
 
-  /** {@inheritDoc ChainStatic.buildMessageForDest} */
+  /**
+   * Returns a copy of a message, populating missing fields like `extraArgs` with defaults.
+   * It's expected to return a message suitable at least for basic token transfers.
+   *
+   * @param message - AnyMessage (from source), containing at least `receiver`
+   * @returns A message suitable for `sendMessage` to this destination chain family
+   * @throws {@link CCIPArgumentInvalidError} if tokenReceiver missing when sending tokens with data
+   */
   static override buildMessageForDest(
     message: Parameters<ChainStatic['buildMessageForDest']>[0],
   ): AnyMessage & { extraArgs: SVMExtraArgsV1 } {
@@ -1544,7 +1631,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     const tokenReceiver =
       message.extraArgs &&
       'tokenReceiver' in message.extraArgs &&
-      message.extraArgs.tokenReceiver != null
+      message.extraArgs.tokenReceiver != null &&
+      typeof message.extraArgs.tokenReceiver === 'string'
         ? message.extraArgs.tokenReceiver
         : message.tokenAmounts?.length
           ? this.getAddress(message.receiver)

package/src/sui/hasher.ts

@@ -1,11 +1,11 @@
 import { concat, id, keccak256, zeroPadValue } from 'ethers'
 
-import { encodeNumber, encodeRawBytes } from '../aptos/utils.ts'
 import { CCIPExtraArgsInvalidError, CCIPSuiHasherVersionUnsupportedError } from '../errors/index.ts'
 import { decodeExtraArgs } from '../extra-args.ts'
 import { type LeafHasher, LEAF_DOMAIN_SEPARATOR } from '../hasher/common.ts'
 import { type CCIPMessage, type CCIPMessage_V1_6, CCIPVersion } from '../types.ts'
 import type { CCIPMessage_V1_6_Sui } from './types.ts'
+import { encodeNumber, encodeRawBytes } from '../shared/bcs-codecs.ts'
 
 /**
  * Creates a leaf hasher for Sui CCIP messages.