@chainlink/ccip-sdk 0.96.0 → 1.0.0

package/src/solana/index.ts

@@ -73,19 +73,18 @@ 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 ChainLog,
   type ChainTransaction,
   type CommitReport,
+  type ExecutionInput,
   type ExecutionReceipt,
-  type ExecutionReport,
   type Lane,
-  type Log_,
   type MergeArrayElements,
   type NetworkInfo,
-  type OffchainTokenData,
   type WithLogger,
   CCIPVersion,
   ChainFamily,
@@ -96,6 +95,7 @@ import {
   createRateLimitedFetch,
   decodeAddress,
   decodeOnRampAddress,
+  getAddressBytes,
   getDataBytes,
   leToBigInt,
   networkInfo,
@@ -112,7 +112,6 @@ import { IDL as CCIP_CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts
 import { IDL as CCIP_OFFRAMP_IDL } from './idl/1.6.0/CCIP_OFFRAMP.ts'
 import { IDL as CCIP_ROUTER_IDL } from './idl/1.6.0/CCIP_ROUTER.ts'
 import { getTransactionsForAddress } from './logs.ts'
-import { fetchSolanaOffchainTokenData } from './offchain.ts'
 import { generateUnsignedCcipSend, getFee } from './send.ts'
 import { type CCIPMessage_V1_6_Solana, type UnsignedSolanaTx, isWallet } from './types.ts'
 import {
@@ -126,7 +125,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)
@@ -159,7 +158,7 @@ const unknownTokens: { [mint: string]: string } = {
 }
 
 /** Solana-specific log structure with transaction reference and log level. */
-export type SolanaLog = Log_ & { tx: SolanaTransaction; data: string; level: number }
+export type SolanaLog = ChainLog & { tx: SolanaTransaction; data: string; level: number }
 /** Solana-specific transaction structure with versioned transaction response. */
 export type SolanaTransaction = MergeArrayElements<
   ChainTransaction,
@@ -171,6 +170,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 {
@@ -284,9 +306,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)
@@ -395,13 +428,13 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   - `watch`: Watch for new logs
    *   - `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.
+   * @returns AsyncIterableIterator of parsed ChainLog objects.
    * @throws {@link CCIPLogsAddressRequiredError} if address is not provided
    * @throws {@link CCIPTopicsInvalidError} if topics contain invalid values
    */
   async *getLogs(
     opts: LogFilter & { programs?: string[] | true },
-  ): AsyncGenerator<Log_ & { tx: SolanaTransaction }> {
+  ): AsyncGenerator<ChainLog & { tx: SolanaTransaction }> {
     let programs: true | string[]
     if (!opts.address) {
       throw new CCIPLogsAddressRequiredError()
@@ -442,15 +475,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)],
@@ -463,7 +496,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} */
@@ -548,8 +581,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,
     })
@@ -563,15 +596,12 @@ 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,
+      ),
+    ]
   }
 
   /**
@@ -863,7 +893,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @throws {@link CCIPLogDataMissingError} if log data is missing
    */
   static decodeCommits(
-    log: Pick<Log_, 'data'>,
+    log: Pick<ChainLog, 'data'>,
     lane?: Omit<Lane, 'destChainSelector'>,
   ): CommitReport[] | undefined {
     // Check if this is a CommitReportAccepted event by looking at the discriminant
@@ -918,7 +948,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @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 {
+  static decodeReceipt(log: Pick<ChainLog, 'data' | 'tx' | 'index'>): ExecutionReceipt | undefined {
     // Check if this is a ExecutionStateChanged event by looking at the discriminant
     if (!log.data || typeof log.data !== 'string') {
       throw new CCIPLogDataMissingError()
@@ -951,7 +981,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     } else throw new CCIPExecutionStateInvalidError(util.inspect(decoded.data.state))
 
     let returnData
-    if (log.tx) {
+    if (log.tx?.logs) {
       // use only last receipt per tx+message (i.e. skip intermediary InProgress=1 states for Solana)
       const laterReceiptLog = log.tx.logs
         .filter((l) => l.index > log.index)
@@ -1075,13 +1105,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return (await this.getMessagesInTx(await this.getTransaction(hash)))[0]!
   }
 
-  /** {@inheritDoc Chain.getOffchainTokenData} */
-  async getOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
-    return fetchSolanaOffchainTokenData(request, this)
-  }
-
   /**
-   * {@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
@@ -1089,15 +1114,14 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   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),
@@ -1108,11 +1132,11 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }
 
   /**
-   * {@inheritDoc Chain.executeReport}
+   * {@inheritDoc Chain.execute}
    * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Solana wallet
    */
-  async executeReport(
-    opts: Parameters<Chain['executeReport']>[0] & {
+  async execute(
+    opts: Parameters<Chain['execute']>[0] & {
       // when cleaning leftover LookUp Tables, wait deactivation grace period (~513 slots) then close ALT
       waitDeactivation?: boolean
     },
@@ -1123,7 +1147,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(),
         })
@@ -1178,13 +1202,13 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       if (Array.isArray(data)) {
         if (data.every((e) => typeof e === 'string')) return getErrorFromLogs(data)
         else if (data.every((e) => typeof e === 'object' && 'data' in e && 'address' in e))
-          return getErrorFromLogs(data as Log_[])
+          return getErrorFromLogs(data as ChainLog[])
       } else if (typeof data === 'object') {
         if ('transactionLogs' in data && 'transactionMessage' in data) {
-          const parsed = getErrorFromLogs(data.transactionLogs as Log_[] | string[])
+          const parsed = getErrorFromLogs(data.transactionLogs as ChainLog[] | string[])
           if (parsed) return { message: data.transactionMessage, ...parsed }
         }
-        if ('logs' in data) return getErrorFromLogs(data.logs as Log_[] | string[])
+        if ('logs' in data) return getErrorFromLogs(data.logs as ChainLog[] | string[])
       } else if (typeof data === 'string') {
         const parsedExtraArgs = this.decodeExtraArgs(getDataBytes(data))
         if (parsedExtraArgs) return parsedExtraArgs
@@ -1199,39 +1223,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)
@@ -1241,7 +1262,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'],
       })) {
@@ -1254,23 +1275,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),
       )
@@ -1559,7 +1580,11 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }
 
   /**
-   * {@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(

package/src/solana/offchain.ts

@@ -1,29 +1,10 @@
-import { type BN, BorshCoder } from '@coral-xyz/anchor'
-import type { PublicKey } from '@solana/web3.js'
+import { BorshCoder } from '@coral-xyz/anchor'
 import { hexlify } from 'ethers'
 
-import {
-  CCIPCctpDecodeError,
-  CCIPCctpMultipleEventsError,
-  CCIPDataFormatUnsupportedError,
-} from '../errors/index.ts'
-import { getUsdcAttestation } from '../offchain.ts'
-import type { CCIPMessage, CCIPRequest, OffchainTokenData, WithLogger } from '../types.ts'
-import { bytesToBuffer, networkInfo, util } from '../utils.ts'
+import type { OffchainTokenData } from '../types.ts'
+import { bytesToBuffer } from '../utils.ts'
 import { IDL as BASE_TOKEN_POOL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import { IDL as CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts'
-import type { SolanaLog, SolanaTransaction } from './index.ts'
-import { hexDiscriminator } from './utils.ts'
-
-interface CcipCctpMessageSentEvent {
-  originalSender: PublicKey
-  remoteChainSelector: BN
-  msgTotalNonce: BN
-  eventAddress: PublicKey
-  sourceDomain: number
-  cctpNonce: BN
-  messageSentBytes: Uint8Array
-}
 
 interface CcipCctpMessageAndAttestation {
   message: {
@@ -38,84 +19,6 @@ const cctpTokenPoolCoder = new BorshCoder({
   errors: [...BASE_TOKEN_POOL.errors, ...CCTP_TOKEN_POOL.errors],
 })
 
-/**
- * Analyzes a Solana transaction to extract CcipCctpMessageSentEvent, fetch Circle attestation,
- * and encode the data in the format required by the destination chain.
- * @param request - CCIP request containing transaction data and chain routing info.
- * @param logger - Logger instance for logging messages.
- * @returns Array of encoded offchain token data (only one supported for Solana right now).
- * @throws Error if transaction hash is missing or CcipCctpMessageSentEvent parsing fails.
- */
-export async function fetchSolanaOffchainTokenData(
-  request: Pick<CCIPRequest, 'tx' | 'lane'> & {
-    message: CCIPMessage
-    log: Pick<CCIPRequest['log'], 'topics' | 'index' | 'transactionHash' | 'address'>
-  },
-  { logger = console }: WithLogger = {},
-): Promise<OffchainTokenData[]> {
-  if (!request.message.tokenAmounts.length) {
-    return []
-  }
-
-  if (request.message.tokenAmounts.length > 1) {
-    throw new CCIPDataFormatUnsupportedError(
-      `Expected at most 1 token transfer, found ${request.message.tokenAmounts.length}`,
-    )
-  }
-
-  const { networkType } = networkInfo(request.lane.sourceChainSelector)
-  const txSignature = request.log.transactionHash
-
-  // Parse Solana transaction to find CCTP event
-  const tx = request.tx as SolanaTransaction
-  const log = request.log as SolanaLog
-  const logMessages = tx.tx.meta!.logMessages!
-  // there may have multiple ccipSend calls in same tx;
-  // use `invoke [level]` to filter only logs inside this call
-  const requestInvokeIdx = logMessages.findLastIndex(
-    (l, i) => i < log.index && l === `Program ${request.log.address} invoke [${log.level}]`,
-  )
-  const cctpEvents = []
-  for (const l of tx.logs) {
-    if (requestInvokeIdx >= l.index || l.index >= log.index) continue
-    if (l.topics[0] !== hexDiscriminator('CcipCctpMessageSentEvent')) continue
-    const decoded = cctpTokenPoolCoder.events.decode(l.data)
-    if (!decoded) throw new CCIPCctpDecodeError(util.inspect(l))
-    cctpEvents.push(decoded.data as unknown as CcipCctpMessageSentEvent)
-  }
-  const offchainTokenData: OffchainTokenData[] = request.message.tokenAmounts.map(() => undefined)
-
-  // If no CcipCctpMessageSentEvent found, return defaults so we don't block execution
-  if (cctpEvents.length === 0) {
-    logger.debug('No USDC/CCTP events found')
-    return offchainTokenData
-  }
-
-  // Currently, we only support ONE token per transfer
-  if (cctpEvents.length > 1) {
-    throw new CCIPCctpMultipleEventsError(cctpEvents.length, txSignature)
-  }
-
-  // NOTE: assuming USDC token is the first (and only) token in the CCIP message, we will process the CCTP event.
-  // If later multi-token transfers support is added, we need to add more info in order to match each token with it's event and offchainTokenData.
-  const cctpEvent = cctpEvents[0]
-  if (cctpEvent) {
-    const message = hexlify(cctpEvent.messageSentBytes)
-    try {
-      // Extract message bytes to fetch circle's attestation and then encode offchainTokenData.
-      const attestation = await getUsdcAttestation(message, networkType)
-
-      offchainTokenData[0] = { _tag: 'usdc', message, attestation }
-    } catch (error) {
-      logger.warn(`❌ Solana CCTP: Failed to fetch attestation for ${txSignature}:`, message, error)
-    }
-  }
-
-  logger.debug('Got Solana offchain token data', offchainTokenData)
-
-  return offchainTokenData
-}
-
 /**
  * Encodes CCTP message and attestation
  *

package/src/solana/utils.ts

@@ -26,7 +26,7 @@ import {
   CCIPTokenMintNotFoundError,
   CCIPTransactionNotFinalizedError,
 } from '../errors/index.ts'
-import type { Log_, WithLogger } from '../types.ts'
+import type { ChainLog, WithLogger } from '../types.ts'
 import { getDataBytes, sleep } from '../utils.ts'
 import type { IDL as BASE_TOKEN_POOL_IDL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import type { UnsignedSolanaTx, Wallet } from './types.ts'
@@ -143,7 +143,7 @@ export function camelToSnakeCase(str: string): string {
     .replace(/^_/, '')
 }
 
-type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & {
+type ParsedLog = Pick<ChainLog, 'topics' | 'index' | 'address' | 'data'> & {
   data: string
   level: number
 }
@@ -160,7 +160,7 @@ type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & {
  * This function:
  * 1. Tracks the program call stack to determine which program emitted each log
  * 2. Extracts the first 8 bytes from base64 "Program data:" logs as topics (event discriminants)
- * 3. Converts logs to EVM-compatible Log_ format for CCIP compatibility
+ * 3. Converts logs to EVM-compatible ChainLog format for CCIP compatibility
  * 4. Returns ALL logs from the transaction - filtering should be done by the caller
  *
  * @param logs - Array of logMessages from Solana transaction
@@ -215,7 +215,10 @@ export function parseSolanaLogs(logs: readonly string[]): ParsedLog[] {
  * @returns Parsed error info with program and error details.
  */
 export function getErrorFromLogs(
-  logs_: readonly string[] | readonly Pick<Log_, 'address' | 'index' | 'data' | 'topics'>[] | null,
+  logs_:
+    | readonly string[]
+    | readonly Pick<ChainLog, 'address' | 'index' | 'data' | 'topics'>[]
+    | null,
 ): { program: string; [k: string]: string } | undefined {
   if (!logs_?.length) return
   let logs
@@ -229,7 +232,7 @@ export function getErrorFromLogs(
       (acc, l) =>
         // if acc is empty (i.e. on last log), or it is emitted by the same program and not a Program data:
         !acc.length || (l.address === acc[0]!.address && !l.topics.length) ? [l, ...acc] : acc,
-      [] as Pick<Log_, 'address' | 'index' | 'data'>[],
+      [] as Pick<ChainLog, 'address' | 'index' | 'data'>[],
     )
     .map(({ data }) => data as string)
     .reduceRight(

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.