@chainlink/ccip-sdk 0.91.0 → 0.92.0

package/src/solana/index.ts

@@ -13,7 +13,6 @@ import {
   SYSVAR_CLOCK_PUBKEY,
   SystemProgram,
 } from '@solana/web3.js'
-import type BN from 'bn.js'
 import bs58 from 'bs58'
 import {
   type BytesLike,
@@ -29,13 +28,31 @@ import {
 import { type Memoized, memoize } from 'micro-memoize'
 import type { PickDeep, SetRequired } from 'type-fest'
 
+import { type LogFilter, type TokenInfo, type TokenPoolRemote, Chain } from '../chain.ts'
 import {
-  type LogFilter,
-  type RateLimiterState,
-  type TokenInfo,
-  type TokenPoolRemote,
-  Chain,
-} from '../chain.ts'
+  CCIPBlockTimeNotFoundError,
+  CCIPContractNotRouterError,
+  CCIPDataFormatUnsupportedError,
+  CCIPExecutionReportChainMismatchError,
+  CCIPExecutionStateInvalidError,
+  CCIPExtraArgsInvalidError,
+  CCIPExtraArgsLengthInvalidError,
+  CCIPLogDataMissingError,
+  CCIPLogsAddressRequiredError,
+  CCIPOnRampRequiredError,
+  CCIPSolanaExtraArgsEncodingError,
+  CCIPSolanaOffRampEventsNotFoundError,
+  CCIPSolanaRefAddressesNotFoundError,
+  CCIPSolanaTopicsInvalidError,
+  CCIPSplTokenInvalidError,
+  CCIPTokenDataParseError,
+  CCIPTokenNotConfiguredError,
+  CCIPTokenPoolChainConfigNotFoundError,
+  CCIPTokenPoolInfoNotFoundError,
+  CCIPTokenPoolStateNotFoundError,
+  CCIPTransactionNotFoundError,
+  CCIPWalletInvalidError,
+} from '../errors/index.ts'
 import { type EVMExtraArgsV2, type ExtraArgs, EVMExtraArgsV2Tag } from '../extra-args.ts'
 import type { LeafHasher } from '../hasher/common.ts'
 import SELECTORS from '../selectors.ts'
@@ -61,6 +78,7 @@ import {
   ExecutionState,
 } from '../types.ts'
 import {
+  bytesToBuffer,
   createRateLimitedFetch,
   decodeAddress,
   decodeOnRampAddress,
@@ -79,11 +97,12 @@ import { IDL as BURN_MINT_TOKEN_POOL } from './idl/1.6.0/BURN_MINT_TOKEN_POOL.ts
 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 {
-  bytesToBuffer,
+  convertRateLimiter,
   getErrorFromLogs,
   hexDiscriminator,
   parseSolanaLogs,
@@ -99,18 +118,20 @@ import { patchBorsh } from './patchBorsh.ts'
 
 const routerCoder = new BorshCoder(CCIP_ROUTER_IDL)
 const offrampCoder = new BorshCoder(CCIP_OFFRAMP_IDL)
-const tokenPoolCoder = new BorshCoder({
+const TOKEN_POOL_IDL = {
   ...BURN_MINT_TOKEN_POOL,
   types: BASE_TOKEN_POOL.types,
   events: BASE_TOKEN_POOL.events,
   errors: [...BASE_TOKEN_POOL.errors, ...BURN_MINT_TOKEN_POOL.errors],
-})
-const cctpTokenPoolCoder = new BorshCoder({
+}
+const tokenPoolCoder = new BorshCoder(TOKEN_POOL_IDL)
+const CCTP_TOKEN_POOL_IDL = {
   ...CCIP_CCTP_TOKEN_POOL,
   types: [...BASE_TOKEN_POOL.types, ...CCIP_CCTP_TOKEN_POOL.types],
   events: [...BASE_TOKEN_POOL.events, ...CCIP_CCTP_TOKEN_POOL.events],
   errors: [...BASE_TOKEN_POOL.errors, ...CCIP_CCTP_TOKEN_POOL.errors],
-})
+}
+const cctpTokenPoolCoder = new BorshCoder(CCTP_TOKEN_POOL_IDL)
 // const commonCoder = new BorshCoder(CCIP_COMMON_IDL)
 
 interface ParsedTokenInfo {
@@ -148,6 +169,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
 
   connection: Connection
   commitment: Commitment = 'confirmed'
+  readonly destroy$: Promise<void>
 
   /**
    * Creates a new SolanaChain instance.
@@ -158,6 +180,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     super(network, ctx)
 
     this.connection = connection
+    this.destroy$ = new Promise<void>((resolve) => (this.destroy = resolve))
 
     // Memoize expensive operations
     this.typeAndVersion = memoize(this.typeAndVersion.bind(this), {
@@ -167,7 +190,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     this.getBlockTimestamp = memoize(this.getBlockTimestamp.bind(this), {
       async: true,
       maxSize: 100,
-      forceUpdate: (key) => typeof key[key.length - 1] !== 'number',
+      forceUpdate: ([k]) => typeof k !== 'number' || k <= 0,
     })
     this.getTransaction = memoize(this.getTransaction.bind(this), {
       maxSize: 100,
@@ -220,7 +243,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   static _getConnection(url: string, ctx?: WithLogger): Connection {
     const { logger = console } = ctx ?? {}
     if (!url.startsWith('http') && !url.startsWith('ws')) {
-      throw new Error(
+      throw new CCIPDataFormatUnsupportedError(
         `Invalid Solana RPC URL format (should be https://, http://, wss://, or ws://): ${url}`,
       )
     }
@@ -258,19 +281,21 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
 
   // cached
   /** {@inheritDoc Chain.getBlockTimestamp} */
-  async getBlockTimestamp(block: number | 'finalized'): Promise<number> {
-    if (block === 'finalized') {
-      const slot = await this.connection.getSlot('finalized')
+  async getBlockTimestamp(block: number | 'latest' | 'finalized'): Promise<number> {
+    if (typeof block !== 'number') {
+      const slot = await this.connection.getSlot(block === 'latest' ? 'confirmed' : block)
       const blockTime = await this.connection.getBlockTime(slot)
       if (blockTime === null) {
-        throw new Error(`Could not get block time for finalized slot ${slot}`)
+        throw new CCIPBlockTimeNotFoundError(`finalized slot ${slot}`)
       }
       return blockTime
+    } else if (block <= 0) {
+      block = (await this.connection.getSlot('confirmed')) + block
     }
 
     const blockTime = await this.connection.getBlockTime(block)
     if (blockTime === null) {
-      throw new Error(`Could not get block time for slot ${block}`)
+      throw new CCIPBlockTimeNotFoundError(block)
     }
     return blockTime
   }
@@ -281,7 +306,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       commitment: 'confirmed',
       maxSupportedTransactionVersion: 0,
     })
-    if (!tx) throw new Error(`Transaction not found: ${hash}`)
+    if (!tx) throw new CCIPTransactionNotFoundError(hash)
     if (tx.blockTime) {
       ;(
         this.getBlockTimestamp as Memoized<typeof this.getBlockTimestamp, { async: true }>
@@ -321,69 +346,9 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   async *getTransactionsForAddress(
     opts: Omit<LogFilter, 'topics'>,
   ): AsyncGenerator<SolanaTransaction> {
-    if (!opts.address) throw new Error('Program address is required for Solana log filtering')
-
-    let allSignatures
-    const limit = Math.min(opts?.page || 1000, 1000)
-    if (opts.startBlock || opts.startTime) {
-      // forward collect all matching sigs in array
-      allSignatures = [] as Awaited<ReturnType<typeof this.connection.getSignaturesForAddress>>
-      let batch: typeof allSignatures
-      do {
-        batch = await this.connection.getSignaturesForAddress(
-          new PublicKey(opts.address),
-          { limit, before: allSignatures[allSignatures.length - 1]?.signature },
-          'confirmed',
-        )
-
-        while (
-          batch.length > 0 &&
-          (batch[batch.length - 1].slot < (opts.startBlock || 0) ||
-            (batch[batch.length - 1].blockTime || -1) < (opts.startTime || 0))
-        ) {
-          batch.length-- // truncate tail of txs which are older than requested start
-        }
-
-        allSignatures.push(...batch) // concat in descending order
-      } while (batch.length >= limit)
-
-      allSignatures.reverse()
-
-      while (
-        opts.endBlock &&
-        allSignatures.length > 0 &&
-        allSignatures[allSignatures.length - 1].slot > opts.endBlock
-      ) {
-        allSignatures.length-- // truncate head (after reverse) of txs newer than requested end
-      }
-    } else {
-      allSignatures = async function* (this: SolanaChain) {
-        let batch: Awaited<ReturnType<typeof this.connection.getSignaturesForAddress>> | undefined
-        do {
-          batch = await this.connection.getSignaturesForAddress(
-            new PublicKey(opts.address!),
-            {
-              limit,
-              before: batch?.length
-                ? batch[batch.length - 1].signature
-                : opts.endBefore
-                  ? opts.endBefore
-                  : undefined,
-            },
-            'confirmed',
-          )
-          for (const sig of batch) {
-            if (opts.endBlock && sig.slot > opts.endBlock) continue
-            yield sig
-          }
-        } while (batch.length >= limit)
-      }.call(this) // generate backwards until depleting getSignaturesForAddress
-    }
-
-    // Process signatures
-    for await (const signatureInfo of allSignatures) {
-      yield await this.getTransaction(signatureInfo.signature)
-    }
+    if (opts.watch instanceof Promise)
+      opts = { ...opts, watch: Promise.race([opts.watch, this.destroy$]) }
+    yield* getTransactionsForAddress(opts, this)
   }
 
   /**
@@ -404,45 +369,46 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    *   - `startBlock`: Starting slot number (inclusive)
    *   - `startTime`: Starting Unix timestamp (inclusive)
    *   - `endBlock`: Ending slot number (inclusive)
+   *   - `endBefore`: Fetch signatures before this transaction
    *   - `address`: Program address to filter logs by (required for Solana)
    *   - `topics`: Array of topics to filter logs by (optional); either 0x-8B discriminants or event names
+   *   - `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)
-   *   - `commit`: Special param for fetching ExecutionReceipts, to narrow down the search
    * @returns AsyncIterableIterator of parsed Log_ objects.
    */
   async *getLogs(
-    opts: LogFilter & { sender?: string; programs?: string[] | true; commit?: CommitReport },
+    opts: LogFilter & { programs?: string[] | true },
   ): AsyncGenerator<Log_ & { tx: SolanaTransaction }> {
     let programs: true | string[]
-    if (opts.sender && !opts.address) {
-      // specialization for fetching txs/requests for a given account of interest without a programID
-      opts.address = opts.sender
-      programs = true
-    } else if (!opts.address) {
-      throw new Error('Program address is required for Solana log filtering')
+    if (!opts.address) {
+      throw new CCIPLogsAddressRequiredError()
     } else if (!opts.programs) {
       programs = [opts.address]
     } else {
       programs = opts.programs
     }
+    let topics
     if (opts.topics?.length) {
       if (!opts.topics.every((topic) => typeof topic === 'string'))
-        throw new Error('Topics must be strings')
+        throw new CCIPSolanaTopicsInvalidError()
       // append events discriminants (if not 0x-8B already), but keep OG topics
-      opts.topics.push(
+      topics = [
+        ...opts.topics,
         ...opts.topics.filter((t) => !isHexString(t, 8)).map((t) => hexDiscriminator(t)),
-      )
+      ]
     }
 
     // Process signatures and yield logs
     for await (const tx of this.getTransactionsForAddress(opts)) {
-      for (const log of tx.logs) {
+      let logs = tx.logs
+      if (opts.startBlock == null && opts.startTime == null) logs = logs.toReversed() // backwards
+      for (const log of logs) {
         // Filter and yield logs from the specified program, and which match event discriminant or log prefix
         if (
           (programs !== true && !programs.includes(log.address)) ||
-          (opts.topics?.length &&
-            !(opts.topics as string[]).some(
+          (topics &&
+            !topics.some(
               (t) =>
                 t === log.topics[0] || (typeof log.data === 'string' && log.data.startsWith(t)),
             ))
@@ -464,7 +430,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     onRamp?: string,
     opts?: { page?: number },
   ): Promise<CCIPRequest> {
-    if (!onRamp) throw new Error('onRamp is required')
+    if (!onRamp) throw new CCIPOnRampRequiredError()
     return fetchCCIPRequestById(this, messageId, { address: onRamp, ...opts })
   }
 
@@ -472,7 +438,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   async fetchAllMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
-      'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+      'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
     >,
   >(
     request: R,
@@ -528,8 +494,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       offRamp_,
     )
     const referenceAddressesPda = await this.connection.getAccountInfo(referenceAddressesAddr)
-    if (!referenceAddressesPda)
-      throw new Error(`referenceAddresses account not found for offRamp=${offRamp}`)
+    if (!referenceAddressesPda) throw new CCIPSolanaRefAddressesNotFoundError(offRamp)
 
     // Decode the config account using the program's coder
     const { router }: { router: PublicKey } = program.coder.accounts.decode(
@@ -562,7 +527,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     })) {
       return [log.address] // assume single offramp per router/deployment on Solana
     }
-    throw new Error(`Could not find OffRamp events in feeQuoter=${feeQuoter.toString()} txs`)
+    throw new CCIPSolanaOffRampEventsNotFoundError(feeQuoter.toString())
   }
 
   /** {@inheritDoc Chain.getOnRampForRouter} */
@@ -599,7 +564,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   /** {@inheritDoc Chain.getTokenForTokenPool} */
   async getTokenForTokenPool(tokenPool: string): Promise<string> {
     const tokenPoolInfo = await this.connection.getAccountInfo(new PublicKey(tokenPool))
-    if (!tokenPoolInfo) throw new Error(`TokenPool info not found: ${tokenPool}`)
+    if (!tokenPoolInfo) throw new CCIPTokenPoolInfoNotFoundError(tokenPool)
     const { config }: { config: { mint: PublicKey } } = tokenPoolCoder.accounts.decode(
       'state',
       tokenPoolInfo.data,
@@ -620,7 +585,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
         mintInfo.value.data.program !== 'spl-token' &&
         mintInfo.value.data.program !== 'spl-token-2022')
     ) {
-      throw new Error(`Invalid SPL token or Token-2022: ${token}`)
+      throw new CCIPSplTokenInvalidError(token)
     }
 
     if (typeof mintInfo.value.data === 'object' && 'parsed' in mintInfo.value.data) {
@@ -653,7 +618,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
         decimals: data.decimals,
       }
     } else {
-      throw new Error(`Unable to parse token data for ${token}`)
+      throw new CCIPTokenDataParseError(token)
     }
   }
 
@@ -747,14 +712,13 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     const message = decoded.data.message
 
     // Convert BN/number types to bigints
+    const messageId = hexlify(new Uint8Array(message.header.messageId))
     const sourceChainSelector = BigInt(message.header.sourceChainSelector.toString())
     const destChainSelector = BigInt(message.header.destChainSelector.toString())
     const sequenceNumber = BigInt(message.header.sequenceNumber.toString())
     const nonce = BigInt(message.header.nonce.toString())
     const destNetwork = networkInfo(destChainSelector)
 
-    // Convert message fields to expected format
-    const messageId = hexlify(new Uint8Array(message.header.messageId))
     const sender = message.sender.toString()
     const data_ = getDataBytes(message.data)
     // TODO: extract this into a proper normalize/decode/reencode data utility
@@ -780,17 +744,16 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     // Parse gas limit from extraArgs
     const extraArgs = hexlify(message.extraArgs)
     const parsed = this.decodeExtraArgs(extraArgs)
-    if (!parsed) throw new Error('Invalid extraArgs: ' + extraArgs)
+    if (!parsed) throw new CCIPExtraArgsInvalidError('SVM', extraArgs)
     const { _tag, ...rest } = parsed
 
     return {
-      header: {
-        messageId,
-        sourceChainSelector,
-        destChainSelector: destChainSelector,
-        sequenceNumber: sequenceNumber,
-        nonce,
-      },
+      // merge header fields to message
+      messageId,
+      sourceChainSelector,
+      destChainSelector: destChainSelector,
+      sequenceNumber: sequenceNumber,
+      nonce,
       sender,
       receiver,
       data: msgData,
@@ -823,7 +786,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
             allowOutOfOrderExecution: data[4 + 16] == 1,
           }
         }
-        throw new Error(`Unsupported EVMExtraArgsV2 length: ${dataLength(data)}`)
+        throw new CCIPExtraArgsLengthInvalidError(dataLength(data))
       }
       default:
         return
@@ -836,7 +799,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    * @returns Encoded extra arguments as hex string.
    */
   static encodeExtraArgs(args: ExtraArgs): string {
-    if ('computeUnits' in args) throw new Error('Solana can only encode EVMExtraArgsV2')
+    if ('computeUnits' in args) throw new CCIPSolanaExtraArgsEncodingError()
     const gasLimitUint128Le = toLeArray(args.gasLimit, 16)
     return concat([
       EVMExtraArgsV2Tag,
@@ -857,7 +820,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   ): CommitReport[] | undefined {
     // Check if this is a CommitReportAccepted event by looking at the discriminant
     if (!log.data || typeof log.data !== 'string') {
-      throw new Error('Log data is missing or not a string')
+      throw new CCIPLogDataMissingError()
     }
 
     try {
@@ -908,7 +871,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   static decodeReceipt(log: Pick<Log_, '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 Error('Log data is missing or not a string')
+      throw new CCIPLogDataMissingError()
     }
 
     try {
@@ -935,7 +898,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       state = ExecutionState.Success
     } else if (decoded.data.state.failure) {
       state = ExecutionState.Failed
-    } else throw new Error(`Invalid ExecutionState: ${util.inspect(decoded.data.state)}`)
+    } else throw new CCIPExecutionStateInvalidError(util.inspect(decoded.data.state))
 
     let returnData
     if (log.tx) {
@@ -980,6 +943,19 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     return encodeBase58(getDataBytes(bytes))
   }
 
+  /**
+   * Validates a transaction hash format for Solana
+   */
+  static isTxHash(v: unknown): v is string {
+    if (typeof v !== 'string') return false
+    try {
+      return bs58.decode(v).length === 64
+    } catch (_) {
+      // pass
+    }
+    return false
+  }
+
   /**
    * Gets the leaf hasher for Solana destination chains.
    * @param lane - Lane configuration.
@@ -992,7 +968,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
   async getTokenAdminRegistryFor(address: string): Promise<string> {
     const [type] = await this.typeAndVersion(address)
-    if (!type.includes('Router')) throw new Error(`Not a Router: ${address} is ${type}`)
+    if (!type.includes('Router')) throw new CCIPContractNotRouterError(address, type)
     // Solana implements TokenAdminRegistry in the Router/OnRamp program
     return address
   }
@@ -1040,7 +1016,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     opts: { wallet: unknown; approveMax?: boolean },
   ): Promise<CCIPRequest> {
     const wallet = opts.wallet
-    if (!isWallet(wallet)) throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`)
+    if (!isWallet(wallet)) throw new CCIPWalletInvalidError(util.inspect(wallet))
     const unsigned = await this.generateUnsignedSendMessage(
       wallet.publicKey.toBase58(),
       router,
@@ -1079,7 +1055,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     opts?: { forceBuffer?: boolean; forceLookupTable?: boolean },
   ): Promise<UnsignedSolanaTx> {
     if (!('computeUnits' in execReport_.message))
-      throw new Error("ExecutionReport's message not for Solana")
+      throw new CCIPExecutionReportChainMismatchError('Solana')
     const execReport = execReport_ as ExecutionReport<CCIPMessage_V1_6_Solana>
     const offRamp_ = new PublicKey(offRamp)
     return generateUnsignedExecuteReport(this, new PublicKey(payer), offRamp_, execReport, opts)
@@ -1098,7 +1074,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     },
   ): Promise<ChainTransaction> {
     const wallet = opts.wallet
-    if (!isWallet(wallet)) throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`)
+    if (!isWallet(wallet)) throw new CCIPWalletInvalidError(util.inspect(wallet))
 
     let hash
     do {
@@ -1143,8 +1119,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    */
   async cleanUpBuffers(opts: { wallet: unknown; waitDeactivation?: boolean }): Promise<void> {
     const wallet = opts.wallet
-    if (!isWallet(wallet)) throw new Error(`Expected Wallet, got=${util.inspect(wallet)}`)
-    await cleanUpBuffers(this, wallet, this.getLogs.bind(this), opts)
+    if (!isWallet(wallet)) throw new CCIPWalletInvalidError(util.inspect(wallet))
+    await cleanUpBuffers(this, wallet, opts)
   }
 
   /**
@@ -1181,8 +1157,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
    */
   override async fetchCommitReport(
     commitStore: string,
-    request: PickDeep<CCIPRequest, 'lane' | 'message.header.sequenceNumber' | 'tx.timestamp'>,
-    hints?: { startBlock?: number; page?: number },
+    request: PickDeep<CCIPRequest, 'lane' | 'message.sequenceNumber' | 'tx.timestamp'>,
+    hints?: Pick<LogFilter, 'page' | 'watch'> & { startBlock?: number },
   ): Promise<CCIPCommit> {
     const commitsAroundSeqNum = await this.connection.getProgramAccounts(
       new PublicKey(commitStore),
@@ -1205,7 +1181,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
           {
             memcmp: {
               offset: 8 + 1 + 8 + 32 + 8 + 1,
-              bytes: encodeBase58(toLeArray(request.message.header.sequenceNumber, 8).slice(1)),
+              bytes: encodeBase58(toLeArray(request.message.sequenceNumber, 8).slice(1)),
             },
           },
         ],
@@ -1215,10 +1191,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       // const merkleRoot = acc.account.data.subarray(8 + 1 + 8, 8 + 1 + 8 + 32)
       const minSeqNr = acc.account.data.readBigUInt64LE(8 + 1 + 8 + 32 + 8)
       const maxSeqNr = acc.account.data.readBigUInt64LE(8 + 1 + 8 + 32 + 8 + 8)
-      if (
-        minSeqNr > request.message.header.sequenceNumber ||
-        maxSeqNr < request.message.header.sequenceNumber
-      )
+      if (minSeqNr > request.message.sequenceNumber || maxSeqNr < request.message.sequenceNumber)
         continue
       // we have all the commit report info, but we also need log details (txHash, etc)
       for await (const log of this.getLogs({
@@ -1242,9 +1215,9 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   /** {@inheritDoc Chain.fetchExecutionReceipts} */
   override async *fetchExecutionReceipts(
     offRamp: string,
-    request: PickDeep<CCIPRequest, 'lane' | 'message.header.messageId' | 'tx.timestamp'>,
+    request: PickDeep<CCIPRequest, 'lane' | 'message.messageId' | 'tx.timestamp'>,
     commit?: CCIPCommit,
-    opts?: { page?: number },
+    opts?: Pick<LogFilter, 'page' | 'watch'>,
   ): AsyncIterableIterator<CCIPExecution> {
     let opts_: Parameters<SolanaChain['getLogs']>[0] | undefined = opts
     if (commit) {
@@ -1284,8 +1257,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     )
 
     const tokenAdminRegistry = await this.connection.getAccountInfo(tokenAdminRegistryAddr)
-    if (!tokenAdminRegistry)
-      throw new Error(`Token ${token} is not configured in registry ${registry}`)
+    if (!tokenAdminRegistry) throw new CCIPTokenNotConfiguredError(token, registry)
 
     const config: {
       administrator: string
@@ -1331,10 +1303,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   }> {
     // `tokenPool` is actually a State PDA in the tokenPoolProgram
     const tokenPoolState = await this.connection.getAccountInfo(new PublicKey(tokenPool))
-    if (!tokenPoolState) throw new Error(`TokenPool State PDA not found at ${tokenPool}`)
-
-    const { config }: { config: { mint: PublicKey; router: PublicKey } } =
-      tokenPoolCoder.accounts.decode('state', tokenPoolState.data)
+    if (!tokenPoolState || tokenPoolState.data.length < 266 + 32)
+      throw new CCIPTokenPoolStateNotFoundError(tokenPool)
     const tokenPoolProgram = tokenPoolState.owner.toBase58()
 
     let typeAndVersion
@@ -1344,9 +1314,14 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       // TokenPool may not have a typeAndVersion
     }
 
+    // const { config }: { config: IdlTypes<typeof BASE_TOKEN_POOL>['BaseConfig'] } =
+    //   tokenPoolCoder.accounts.decode('state', tokenPoolState.data)
+    const mint = new PublicKey(tokenPoolState.data.subarray(41, 41 + 32))
+    const router = new PublicKey(tokenPoolState.data.subarray(266, 266 + 32))
+
     return {
-      token: config.mint.toBase58(),
-      router: config.router.toBase58(),
+      token: mint.toBase58(),
+      router: router.toBase58(),
       tokenPoolProgram,
       typeAndVersion,
     }
@@ -1359,7 +1334,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   ): Promise<Record<string, TokenPoolRemote>> {
     // `tokenPool` is actually a State PDA in the tokenPoolProgram
     const tokenPoolState = await this.connection.getAccountInfo(new PublicKey(tokenPool))
-    if (!tokenPoolState) throw new Error(`TokenPool State PDA not found at ${tokenPool}`)
+    if (!tokenPoolState) throw new CCIPTokenPoolStateNotFoundError(tokenPool)
 
     const tokenPoolProgram = tokenPoolState.owner
 
@@ -1385,8 +1360,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
       )
       const chainConfigAcc = await this.connection.getAccountInfo(chainConfigAddr)
       if (!chainConfigAcc)
-        throw new Error(
-          `ChainConfig not found at ${chainConfigAddr.toBase58()} for tokenPool=${tokenPool} and remoteNetwork=${networkInfo(remoteChainSelector).name}`,
+        throw new CCIPTokenPoolChainConfigNotFoundError(
+          chainConfigAddr.toBase58(),
+          tokenPool,
+          networkInfo(remoteChainSelector).name,
         )
       accounts = [
         {
@@ -1408,31 +1385,7 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
 
     for (const acc of accounts) {
       try {
-        let base: {
-          remote: {
-            poolAddresses: { address: Buffer }[]
-            tokenAddress: { address: Buffer }
-            decimals: number
-          }
-          inboundRateLimit: {
-            tokens: BN
-            lastUpdated: BN
-            cfg: {
-              enabled: boolean
-              capacity: BN
-              rate: BN
-            }
-          }
-          outboundRateLimit: {
-            tokens: BN
-            lastUpdated: BN
-            cfg: {
-              enabled: boolean
-              capacity: BN
-              rate: BN
-            }
-          }
-        }
+        let base: IdlTypes<typeof BASE_TOKEN_POOL>['BaseChain']
         try {
           ;({ base } = tokenPoolCoder.accounts.decode('chainConfig', acc.account.data))
         } catch (_) {
@@ -1465,35 +1418,8 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
           decodeAddress(pool.address, remoteNetwork.family),
         )
 
-        let inboundRateLimiterState: RateLimiterState = null
-        if (base.inboundRateLimit.cfg.enabled) {
-          inboundRateLimiterState = {
-            tokens: BigInt(base.inboundRateLimit.tokens.toString()),
-            capacity: BigInt(base.inboundRateLimit.cfg.capacity.toString()),
-            rate: BigInt(base.inboundRateLimit.cfg.rate.toString()),
-          }
-          const cur =
-            inboundRateLimiterState.tokens +
-            inboundRateLimiterState.rate *
-              BigInt(Math.floor(Date.now() / 1000) - base.inboundRateLimit.lastUpdated.toNumber())
-          if (cur < inboundRateLimiterState.capacity) inboundRateLimiterState.tokens = cur
-          else inboundRateLimiterState.tokens = inboundRateLimiterState.capacity
-        }
-
-        let outboundRateLimiterState: RateLimiterState = null
-        if (base.outboundRateLimit.cfg.enabled) {
-          outboundRateLimiterState = {
-            tokens: BigInt(base.outboundRateLimit.tokens.toString()),
-            capacity: BigInt(base.outboundRateLimit.cfg.capacity.toString()),
-            rate: BigInt(base.outboundRateLimit.cfg.rate.toString()),
-          }
-          const cur =
-            outboundRateLimiterState.tokens +
-            outboundRateLimiterState.rate *
-              BigInt(Math.floor(Date.now() / 1000) - base.outboundRateLimit.lastUpdated.toNumber())
-          if (cur < outboundRateLimiterState.capacity) outboundRateLimiterState.tokens = cur
-          else outboundRateLimiterState.tokens = outboundRateLimiterState.capacity
-        }
+        const inboundRateLimiterState = convertRateLimiter(base.inboundRateLimit)
+        const outboundRateLimiterState = convertRateLimiter(base.outboundRateLimit)
 
         remotes[remoteNetwork.name] = {
           remoteToken,