@chainlink/ccip-sdk 0.91.1 → 0.92.1

package/src/evm/types.ts

@@ -0,0 +1,11 @@
+import type { TransactionRequest } from 'ethers'
+
+import type { ChainFamily } from '../types.ts'
+
+/**
+ * Type representing a set of unsigned EVM transactions
+ */
+export type UnsignedEVMTx = {
+  family: typeof ChainFamily.EVM
+  transactions: Pick<TransactionRequest, 'from' | 'to' | 'data'>[]
+}

package/src/execution.ts

@@ -1,6 +1,11 @@
 import { memoize } from 'micro-memoize'
 
 import type { Chain, ChainStatic } from './chain.ts'
+import {
+  CCIPMerkleRootMismatchError,
+  CCIPMessageNotInBatchError,
+  CCIPOffRampNotFoundError,
+} from './errors/index.ts'
 import { Tree, getLeafHasher, proofFlagsToBits } from './hasher/index.ts'
 import {
   type CCIPCommit,
@@ -33,11 +38,12 @@ export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
 ): Omit<ExecutionReport, 'offchainTokenData' | 'message'> {
   const hasher = getLeafHasher(lane, ctx)
 
-  const msgIdx = messagesInBatch.findIndex((message) => message.header.messageId === messageId)
+  const msgIdx = messagesInBatch.findIndex((message) => message.messageId === messageId)
   if (msgIdx < 0) {
-    throw new Error(
-      `Could not find ${messageId} in batch seqNums=[${Number(messagesInBatch[0].header.sequenceNumber)}..${Number(messagesInBatch[messagesInBatch.length - 1].header.sequenceNumber)}]`,
-    )
+    throw new CCIPMessageNotInBatchError(messageId, {
+      min: messagesInBatch[0].sequenceNumber,
+      max: messagesInBatch[messagesInBatch.length - 1].sequenceNumber,
+    })
   }
 
   const leaves = messagesInBatch.map((message) => hasher(message))
@@ -45,9 +51,7 @@ export function calculateManualExecProof<V extends CCIPVersion = CCIPVersion>(
   // Create multi-merkle tree
   const tree = new Tree(leaves)
   if (merkleRoot && tree.root() !== merkleRoot) {
-    throw new Error(
-      `Merkle root created from send events doesn't match ReportAccepted merkle root: expected=${merkleRoot}, got=${tree.root()}`,
-    )
+    throw new CCIPMerkleRootMismatchError(merkleRoot, tree.root())
   }
 
   // Generate proof from multi-merkle tree
@@ -89,7 +93,7 @@ export const discoverOffRamp = memoize(
         }
       }
     }
-    throw new Error(`No matching offRamp found for "${onRamp}" on "${dest.network.name}"`)
+    throw new CCIPOffRampNotFoundError(onRamp, dest.network.name)
   },
   {
     transformKey: ([source, dest, onRamp]) =>
@@ -130,7 +134,7 @@ export async function* fetchExecutionReceipts(
     ...hints,
   })) {
     const receipt = (dest.constructor as ChainStatic).decodeReceipt(log)
-    if (!receipt || receipt.messageId !== request.message.header.messageId) continue
+    if (!receipt || receipt.messageId !== request.message.messageId) continue
 
     const timestamp = log.tx?.timestamp ?? (await dest.getBlockTimestamp(log.blockNumber))
     yield { receipt, log, timestamp }

package/src/extra-args.ts

@@ -1,5 +1,6 @@
 import { type BytesLike, id } from 'ethers'
 
+import { CCIPChainFamilyUnsupportedError, CCIPExtraArgsParseError } from './errors/index.ts'
 import { supportedChains } from './supported-chains.ts'
 import { ChainFamily } from './types.ts'
 
@@ -67,7 +68,7 @@ export type ExtraArgs = EVMExtraArgsV1 | EVMExtraArgsV2 | SVMExtraArgsV1 | SuiEx
  **/
 export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily.EVM): string {
   const chain = supportedChains[from]
-  if (!chain) throw new Error(`Unsupported chain family: ${from}`)
+  if (!chain) throw new CCIPChainFamilyUnsupportedError(from)
   return chain.encodeExtraArgs(args)
 }
 
@@ -90,7 +91,7 @@ export function decodeExtraArgs(
   let chains
   if (from) {
     const chain = supportedChains[from]
-    if (!chain) throw new Error(`Unsupported chain family: ${from}`)
+    if (!chain) throw new CCIPChainFamilyUnsupportedError(from)
     chains = [chain]
   } else {
     chains = Object.values(supportedChains)
@@ -99,5 +100,5 @@ export function decodeExtraArgs(
     const decoded = chain.decodeExtraArgs(data)
     if (decoded) return decoded
   }
-  throw new Error(`Could not parse extraArgs from "${from}"`)
+  throw new CCIPExtraArgsParseError(String(from ?? data))
 }

package/src/gas.ts

@@ -14,6 +14,10 @@ import {
 import type { TypedContract } from 'ethers-abitype'
 
 import type { Chain } from './chain.ts'
+import {
+  CCIPLegacyTokenPoolsUnsupportedError,
+  CCIPTokenDecimalsInsufficientError,
+} from './errors/index.ts'
 import TokenABI from './evm/abi/BurnMintERC677Token.ts'
 import RouterABI from './evm/abi/Router.ts'
 import { defaultAbiCoder } from './evm/const.ts'
@@ -63,7 +67,7 @@ export async function estimateExecGasForRequest(
 
   const destTokenAmounts = await Promise.all(
     request.message.tokenAmounts.map(async (ta) => {
-      if (!('destTokenAddress' in ta)) throw new Error('legacy <1.5 tokenPools not supported')
+      if (!('destTokenAddress' in ta)) throw new CCIPLegacyTokenPoolsUnsupportedError()
       const [{ decimals: sourceDecimals }, { decimals: destDecimals }] = await Promise.all([
         source
           .getTokenForTokenPool(ta.sourcePoolAddress)
@@ -73,8 +77,11 @@ export async function estimateExecGasForRequest(
       const destAmount =
         (ta.amount * 10n ** BigInt(destDecimals - sourceDecimals + 36)) / 10n ** 36n
       if (destAmount === 0n)
-        throw new Error(
-          `not enough decimals=${destDecimals} for token=${ta.destTokenAddress} on dest=${dest.network.name} to express ${formatUnits(ta.amount, sourceDecimals)}`,
+        throw new CCIPTokenDecimalsInsufficientError(
+          ta.destTokenAddress,
+          destDecimals,
+          dest.network.name,
+          formatUnits(ta.amount, sourceDecimals),
         )
       return { token: ta.destTokenAddress, amount: destAmount }
     }),

package/src/hasher/hasher.ts

@@ -1,3 +1,4 @@
+import { CCIPChainFamilyUnsupportedError } from '../errors/index.ts'
 import { supportedChains } from '../supported-chains.ts'
 import type { CCIPVersion, Lane, WithLogger } from '../types.ts'
 import { networkInfo } from '../utils.ts'
@@ -15,6 +16,6 @@ export function getLeafHasher<V extends CCIPVersion = CCIPVersion>(
 ): LeafHasher<V> {
   const destFamily = networkInfo(lane.destChainSelector).family
   const chain = supportedChains[destFamily]
-  if (!chain) throw new Error(`Unsupported chain family: ${destFamily}`)
+  if (!chain) throw new CCIPChainFamilyUnsupportedError(destFamily)
   return chain.getDestLeafHasher(lane, ctx) as LeafHasher<V>
 }

package/src/hasher/merklemulti.ts

@@ -1,5 +1,15 @@
 // For reference implementation, see https://github.com/smartcontractkit/ccip/blob/ccip-develop/core/services/ocr2/plugins/ccip/merklemulti/merkle_multi.go
 import { ZERO_HASH, hashInternal } from './common.ts'
+import {
+  CCIPMerkleFlagsMismatchError,
+  CCIPMerkleHashesTooLargeError,
+  CCIPMerkleInternalError,
+  CCIPMerkleProofEmptyError,
+  CCIPMerkleProofFlagsMismatchError,
+  CCIPMerkleProofIncompleteError,
+  CCIPMerkleProofTooLargeError,
+  CCIPMerkleTreeEmptyError,
+} from '../errors/index.ts'
 
 export const MAX_NUMBER_TREE_LEAVES = 256
 
@@ -146,7 +156,7 @@ export class Tree {
    */
   constructor(leafHashes: Hash[]) {
     if (leafHashes.length === 0) {
-      throw new Error('Cannot construct a tree without leaves')
+      throw new CCIPMerkleTreeEmptyError()
     }
 
     // Initialize the first layer with leaf hashes.
@@ -227,21 +237,21 @@ export function verifyComputeRoot(leafHashes: Hash[], proof: Proof): Hash {
   const proofsLength = proof.hashes.length
 
   if (leavesLength === 0 && proofsLength === 0) {
-    throw new Error('leaves and proofs are empty')
+    throw new CCIPMerkleProofEmptyError()
   }
 
   if (leavesLength > MAX_NUMBER_TREE_LEAVES + 1 || proofsLength > MAX_NUMBER_TREE_LEAVES + 1) {
-    throw new Error(`leaves or proofs length beyond the limit of ${MAX_NUMBER_TREE_LEAVES}`)
+    throw new CCIPMerkleProofTooLargeError(MAX_NUMBER_TREE_LEAVES)
   }
 
   const totalHashes = leavesLength + proofsLength - 1
 
   if (totalHashes > MAX_NUMBER_TREE_LEAVES) {
-    throw new Error(`total hashes length cannot be larger than ${MAX_NUMBER_TREE_LEAVES}`)
+    throw new CCIPMerkleHashesTooLargeError(totalHashes, MAX_NUMBER_TREE_LEAVES)
   }
 
   if (totalHashes !== proof.sourceFlags.length) {
-    throw new Error(`hashes ${totalHashes} != sourceFlags ${proof.sourceFlags.length}`)
+    throw new CCIPMerkleFlagsMismatchError(totalHashes, proof.sourceFlags.length)
   }
 
   // If there are no hashes, return the first leaf hash.
@@ -253,7 +263,7 @@ export function verifyComputeRoot(leafHashes: Hash[], proof: Proof): Hash {
   const sourceProofCount = proof.countSourceFlags(false)
 
   if (sourceProofCount !== proofsLength) {
-    throw new Error(`proof source flags ${sourceProofCount} != proof hashes ${proofsLength}`)
+    throw new CCIPMerkleProofFlagsMismatchError(sourceProofCount, proofsLength)
   }
 
   const hashes: Hash[] = new Array<Hash>(totalHashes)
@@ -293,7 +303,7 @@ export function verifyComputeRoot(leafHashes: Hash[], proof: Proof): Hash {
     }
 
     if (a === undefined || b === undefined) {
-      throw new Error('a or b is undefined')
+      throw new CCIPMerkleInternalError('Hash operand is undefined')
     }
 
     // Compute the hash of a and b and store it in the hashes array.
@@ -302,7 +312,7 @@ export function verifyComputeRoot(leafHashes: Hash[], proof: Proof): Hash {
 
   // Check if all proofs were used during processing.
   if (hashPos !== totalHashes - 1 || leafPos !== leavesLength || proofPos !== proofsLength) {
-    throw new Error('not all proofs used during processing')
+    throw new CCIPMerkleProofIncompleteError()
   }
 
   // Return the computed Merkle root hash.

package/src/index.ts

@@ -37,15 +37,27 @@ export {
   CCIPVersion,
   ExecutionState,
 } from './types.ts'
-export { bigIntReplacer, bigIntReviver, decodeAddress, getDataBytes, networkInfo } from './utils.ts'
+export {
+  bigIntReplacer,
+  bigIntReviver,
+  bytesToBuffer,
+  decodeAddress,
+  getDataBytes,
+  isSupportedTxHash,
+  networkInfo,
+} from './utils.ts'
+
+// errors
+export * from './errors/index.ts'
 
 // chains
 import { AptosChain } from './aptos/index.ts'
 import { EVMChain } from './evm/index.ts'
 import { SolanaChain } from './solana/index.ts'
 import { SuiChain } from './sui/index.ts'
+import { TONChain } from './ton/index.ts'
 import { ChainFamily } from './types.ts'
-export { AptosChain, ChainFamily, EVMChain, SolanaChain, SuiChain }
+export { AptosChain, ChainFamily, EVMChain, SolanaChain, SuiChain, TONChain }
 // use `supportedChains` to override/register derived classes, if needed
 export { supportedChains } from './supported-chains.ts'
 // import `allSupportedChains` to get them all registered, in tree-shaken environments
@@ -54,4 +66,5 @@ export const allSupportedChains = {
   [ChainFamily.Solana]: SolanaChain,
   [ChainFamily.Aptos]: AptosChain,
   [ChainFamily.Sui]: SuiChain,
+  [ChainFamily.TON]: TONChain,
 }

package/src/offchain.ts

@@ -1,5 +1,11 @@
 import { keccak256 } from 'ethers'
 
+import {
+  CCIPLbtcAttestationNotApprovedError,
+  CCIPLbtcAttestationNotFoundError,
+  CCIPUsdcAttestationError,
+} from './errors/index.ts'
+
 const CIRCLE_API_URL = {
   mainnet: 'https://iris-api.circle.com/v1',
   testnet: 'https://iris-api-sandbox.circle.com/v1',
@@ -35,7 +41,7 @@ export async function getUsdcAttestation(message: string, isTestnet: boolean): P
   const res = await fetch(`${circleApiBaseUrl}/attestations/${msgHash}`)
   const json = (await res.json()) as CctpAttestationResponse
   if (!('status' in json) || json.status !== 'complete' || !json.attestation) {
-    throw new Error('Could not fetch USDC attestation. Response: ' + JSON.stringify(json, null, 2))
+    throw new CCIPUsdcAttestationError(msgHash, json)
   }
   return json.attestation
 }
@@ -60,27 +66,17 @@ export async function getLbtcAttestation(
   })
   const response = (await res.json()) as LombardAttestationsResponse
   if (response == null || !('attestations' in response)) {
-    throw new Error(
-      'Error while fetching LBTC attestation. Response: ' + JSON.stringify(response, null, 2),
-    )
+    throw new CCIPLbtcAttestationNotFoundError(payloadHash, response)
   }
   const attestation = response.attestations.find((att) => att.message_hash === payloadHash)
   if (attestation == null) {
-    throw new Error(
-      'Could not find requested LBTC attestation with hash:' +
-        payloadHash +
-        ' in response: ' +
-        JSON.stringify(response, null, 2),
-    )
+    throw new CCIPLbtcAttestationNotFoundError(payloadHash, response)
   }
   if (
     attestation.status !== 'NOTARIZATION_STATUS_SESSION_APPROVED' ||
     !('attestation' in attestation)
   ) {
-    throw new Error(
-      'LBTC attestation is not approved or invalid. Response: ' +
-        JSON.stringify(attestation, null, 2),
-    )
+    throw new CCIPLbtcAttestationNotApprovedError(payloadHash, attestation)
   }
   return attestation
 }

package/src/requests.ts

@@ -3,6 +3,15 @@ import type { PickDeep } from 'type-fest'
 import yaml from 'yaml'
 
 import type { Chain, ChainStatic, LogFilter } from './chain.ts'
+import {
+  CCIPMessageBatchIncompleteError,
+  CCIPMessageDecodeError,
+  CCIPMessageIdNotFoundError,
+  CCIPMessageInvalidError,
+  CCIPMessageNotFoundInTxError,
+  CCIPNetworkFamilyUnsupportedError,
+  CCIPTokenNotInRegistryError,
+} from './errors/index.ts'
 import type { EVMChain } from './evm/index.ts'
 import { decodeExtraArgs } from './extra-args.ts'
 import { supportedChains } from './supported-chains.ts'
@@ -14,18 +23,19 @@ import {
   type Log_,
   ChainFamily,
 } from './types.ts'
-import { convertKeysToCamelCase, decodeAddress, leToBigInt, networkInfo, util } from './utils.ts'
+import { convertKeysToCamelCase, decodeAddress, leToBigInt, networkInfo } from './utils.ts'
 
 function decodeJsonMessage(data: Record<string, unknown>) {
-  if (!data || typeof data != 'object') throw new Error(`invalid msg: ${util.inspect(data)}`)
+  if (!data || typeof data != 'object') throw new CCIPMessageInvalidError(data)
   if (data.message) data = data.message as Record<string, unknown>
+  if (data.header) {
+    Object.assign(data, data.header)
+    delete data.header
+  }
   let data_ = data as Record<string, unknown> & {
-    header: {
-      dest_chain_selector?: string
-      destChainSelector?: string
-      sourceChainSelector?: string
-      source_chain_selector?: string
-    }
+    dest_chain_selector?: string
+    destChainSelector?: string
+    source_chain_selector?: string
     sourceChainSelector?: string
     extraArgs?: string
     tokenAmounts: {
@@ -33,29 +43,17 @@ function decodeJsonMessage(data: Record<string, unknown>) {
       destGasAmount?: bigint
     }[]
   }
-  const sourceChainSelector =
-    data_.header?.sourceChainSelector ??
-    data_.header?.source_chain_selector ??
-    data_.sourceChainSelector
-  if (!sourceChainSelector) throw new Error(`invalid msg: ${util.inspect(data)}`)
+  const sourceChainSelector = data_.source_chain_selector ?? data_.sourceChainSelector
+  if (!sourceChainSelector) throw new CCIPMessageInvalidError(data)
   const sourceNetwork = networkInfo(sourceChainSelector)
-  if (!data_.header) {
-    const header = {
-      sourceChainSelector: data_.sourceChainSelector,
-      messageId: data_.messageId,
-      nonce: data_.nonce,
-      sequenceNumber: data_.sequenceNumber,
-    }
-    data_.header = header
-  }
 
-  const destChainSelector = data_.header.dest_chain_selector ?? data_.header.destChainSelector
+  const destChainSelector = data_.dest_chain_selector ?? data_.destChainSelector
   if (destChainSelector) {
     const destFamily = networkInfo(destChainSelector).family
     data_ = convertKeysToCamelCase(data_, (v, k) =>
       typeof v === 'string' && v.match(/^\d+$/)
         ? BigInt(v)
-        : k === 'receiver' || k === 'destTokenAddress'
+        : k === 'receiver' || k === 'destTokenAddress' || k === 'tokenReceiver'
           ? decodeAddress(v as string, destFamily)
           : v,
     ) as typeof data_
@@ -108,7 +106,7 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
       // continue
     }
   }
-  throw new Error('Failed to decode message')
+  throw new CCIPMessageDecodeError()
 }
 
 /**
@@ -128,23 +126,23 @@ export async function fetchCCIPRequestsInTx(
     let lane
     const message = (source.constructor as ChainStatic).decodeMessage(log)
     if (!message) continue
-    if ('destChainSelector' in message.header) {
+    if ('destChainSelector' in message) {
       const [_, version] = await source.typeAndVersion(log.address)
       lane = {
-        sourceChainSelector: message.header.sourceChainSelector,
-        destChainSelector: message.header.destChainSelector,
+        sourceChainSelector: message.sourceChainSelector,
+        destChainSelector: message.destChainSelector,
         onRamp: log.address,
         version: version as CCIPVersion,
       }
     } else if (source.network.family !== ChainFamily.EVM) {
-      throw new Error(`Unsupported network family: ${source.network.family}`)
+      throw new CCIPNetworkFamilyUnsupportedError(source.network.family)
     } else {
       lane = await (source as EVMChain).getLaneForOnRamp(log.address)
     }
     requests.push({ lane, message, log, tx })
   }
   if (!requests.length) {
-    throw new Error(`Could not find any CCIPSendRequested message in tx: ${txHash}`)
+    throw new CCIPMessageNotFoundInTxError(txHash)
   }
 
   return requests
@@ -168,10 +166,10 @@ export async function fetchCCIPRequestById(
     ...hints,
   })) {
     const message = (source.constructor as ChainStatic).decodeMessage(log)
-    if (message?.header.messageId !== messageId) continue
+    if (message?.messageId !== messageId) continue
     let destChainSelector, version
-    if ('destChainSelector' in message.header) {
-      destChainSelector = message.header.destChainSelector
+    if ('destChainSelector' in message) {
+      destChainSelector = message.destChainSelector
       ;[, version] = await source.typeAndVersion(log.address)
     } else {
       ;({ destChainSelector, version } = await (source as EVMChain).getLaneForOnRamp(log.address))
@@ -179,7 +177,7 @@ export async function fetchCCIPRequestById(
     const tx = log.tx ?? (await source.getTransaction(log.transactionHash))
     return {
       lane: {
-        sourceChainSelector: source.network.chainSelector,
+        sourceChainSelector: message.sourceChainSelector,
         destChainSelector,
         onRamp: log.address,
         version: version as CCIPVersion,
@@ -189,7 +187,7 @@ export async function fetchCCIPRequestById(
       tx,
     }
   }
-  throw new Error('Could not find a CCIPSendRequested message with messageId: ' + messageId)
+  throw new CCIPMessageIdNotFoundError(messageId)
 }
 
 // Number of blocks to expand the search window for logs
@@ -207,7 +205,7 @@ export async function fetchAllMessagesInBatch<
   C extends Chain,
   R extends PickDeep<
     CCIPRequest,
-    'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+    'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
   >,
 >(
   source: C,
@@ -223,13 +221,13 @@ export async function fetchAllMessagesInBatch<
     address: request.log.address,
     ...opts,
   }
-  if (request.message.header.sequenceNumber === maxSeqNr) filter.endBlock = request.log.blockNumber
+  if (request.message.sequenceNumber === maxSeqNr) filter.endBlock = request.log.blockNumber
   else
     // start proportionally before send request block, including case when seqNum==min => startBlock
     filter.startBlock =
       request.log.blockNumber -
       Math.ceil(
-        (Number(request.message.header.sequenceNumber - minSeqNr) / Number(maxSeqNr - minSeqNr)) *
+        (Number(request.message.sequenceNumber - minSeqNr) / Number(maxSeqNr - minSeqNr)) *
           filter.page,
       )
 
@@ -243,15 +241,15 @@ export async function fetchAllMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
-        ('destChainSelector' in message.header &&
-          message.header.destChainSelector !== request.lane.destChainSelector)
+        ('destChainSelector' in message &&
+          message.destChainSelector !== request.lane.destChainSelector)
       )
         continue
-      if (message.header.sequenceNumber < minSeqNr) continue
+      if (message.sequenceNumber < minSeqNr) continue
       messages.push(message)
-      if (message.header.sequenceNumber >= maxSeqNr) break
+      if (message.sequenceNumber >= maxSeqNr) break
     }
-    if (messages.length && messages[0].header.sequenceNumber > minSeqNr) {
+    if (messages.length && messages[0].sequenceNumber > minSeqNr) {
       // still work to be done backwards
       delete filter['startBlock']
       filter['endBlock'] = backwardsEndBlock
@@ -264,18 +262,19 @@ export async function fetchAllMessagesInBatch<
       const message = (source.constructor as ChainStatic).decodeMessage(log)
       if (
         !message ||
-        ('destChainSelector' in message.header &&
-          message.header.destChainSelector !== request.lane.destChainSelector)
+        ('destChainSelector' in message &&
+          message.destChainSelector !== request.lane.destChainSelector)
       )
         continue
       messages.unshift(message)
-      if (message.header.sequenceNumber <= minSeqNr) break
+      if (message.sequenceNumber <= minSeqNr) break
     }
   }
 
   if (messages.length != Number(maxSeqNr - minSeqNr) + 1) {
-    throw new Error(
-      `Could not find all expected request events: from=${request.log.blockNumber}, wanted=[${Number(minSeqNr)}..${Number(maxSeqNr)}:${Number(maxSeqNr - minSeqNr) + 1}], got=[${messages.map((e) => Number(e.header.sequenceNumber)).join(',')}]`,
+    throw new CCIPMessageBatchIncompleteError(
+      { min: minSeqNr, max: maxSeqNr },
+      messages.map((e) => e.sequenceNumber),
     )
   }
   return messages
@@ -302,13 +301,13 @@ export async function* fetchRequestsForSender(
     const message = (source.constructor as ChainStatic).decodeMessage(log)
     if (message?.sender !== sender) continue
     let destChainSelector, version
-    if ('destChainSelector' in message.header) {
-      destChainSelector = message.header.destChainSelector
+    if ('destChainSelector' in message) {
+      destChainSelector = message.destChainSelector
       ;[, version] = await source.typeAndVersion(log.address)
     } else if (source.network.family === ChainFamily.EVM) {
       ;({ destChainSelector, version } = await (source as EVMChain).getLaneForOnRamp(log.address))
     } else {
-      throw new Error(`Unsupported network family: ${source.network.family}`)
+      throw new CCIPNetworkFamilyUnsupportedError(source.network.family)
     }
     yield {
       lane: {
@@ -344,8 +343,7 @@ export async function sourceToDestTokenAmounts<S extends { token: string }>(
         tokenAdminRegistry,
         token,
       )
-      if (!sourcePoolAddress)
-        throw new Error(`Token=${token} not found in registry=${tokenAdminRegistry}`)
+      if (!sourcePoolAddress) throw new CCIPTokenNotInRegistryError(token, tokenAdminRegistry)
       const remotes = await source.getTokenPoolRemotes(sourcePoolAddress, destChainSelector)
       return {
         ...rest,

package/src/selectors.ts

@@ -1335,6 +1335,29 @@ const selectors: Selectors = {
     family: 'sui',
   },
   // end:generate
+
+  // generate:
+  // fetch('https://github.com/smartcontractkit/chain-selectors/raw/main/selectors_ton.yml')
+  //   .then((res) => res.text())
+  //   .then((body) => require('yaml').parse(body, { intAsBigInt: true }).selectors)
+  //   .then((obj) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, { ...v, family: 'ton' }])))
+  //   .then((obj) => [...require('util').inspect(obj).split('\n').slice(1, -1), ','])
+  '-239': {
+    name: 'ton-mainnet',
+    selector: 16448340667252469081n,
+    family: 'ton',
+  },
+  '-3': {
+    name: 'ton-testnet',
+    selector: 1399300952838017768n,
+    family: 'ton',
+  },
+  '-217': {
+    name: 'ton-localnet',
+    selector: 13879075125137744094n,
+    family: 'ton',
+  },
+  // end:generate
 }
 
 export default selectors

package/src/solana/cleanup.ts

@@ -21,15 +21,13 @@ import type { WithLogger } from '../types.ts'
  * Clean up and recycle buffers and Address Lookup Tables owned by wallet.
  * @param ctx - Context object containing the Solana connection instance and logger.
  * @param wallet - Wallet instance to sign txs.
- * @param getLogs - SolanaChain-compatible getLogs function (to scan for Buffers and ALTs).
  * @param opts - Optional parameters. Set `waitDeactivation` to wait for lookup table deactivation
  *   cool down period (513 slots) to pass before closing; by default, we deactivate (if needed)
  *   and leave close to be done in the future.
  */
 export async function cleanUpBuffers(
-  ctx: { connection: Connection } & WithLogger,
+  ctx: { connection: Connection; getLogs: SolanaChain['getLogs'] } & WithLogger,
   wallet: Wallet,
-  getLogs: SolanaChain['getLogs'],
   opts?: { waitDeactivation?: boolean },
 ): Promise<void> {
   const { connection, logger = console } = ctx
@@ -103,7 +101,7 @@ export async function cleanUpBuffers(
   }
 
   let alreadyClosed = 0
-  for await (const log of getLogs({
+  for await (const log of ctx.getLogs({
     address: wallet.publicKey.toBase58(),
     topics: [
       'Instruction: BufferExecutionReport',