@chainlink/ccip-sdk 1.3.1 → 1.4.1

package/src/errors/specialized.ts

@@ -1,7 +1,10 @@
+import type { BytesLike } from 'ethers'
+
 import { type CCIPErrorOptions, CCIPError } from './CCIPError.ts'
 import { CCIPErrorCode } from './codes.ts'
 import { isTransientHttpStatus } from '../http-status.ts'
-import { bigIntReplacer } from '../utils.ts'
+import type { ChainFamily } from '../types.ts'
+import { bigIntReplacer, getAddressBytes, util } from '../utils.ts'
 
 // Chain/Network
 
@@ -987,7 +990,12 @@ export class CCIPUsdcAttestationError extends CCIPError {
  */
 export class CCIPUsdcBurnFeesError extends CCIPError {
   override readonly name = 'CCIPUsdcBurnFeesError'
-  /** Creates a USDC burn fees error. */
+  /**
+   * Creates a USDC burn fees error.
+   * @param sourceDomain - CCTP source domain identifier.
+   * @param destDomain - CCTP destination domain identifier.
+   * @param httpStatus - HTTP status code from the failed request.
+   */
   constructor(sourceDomain: number, destDomain: number, httpStatus: number) {
     super(
       CCIPErrorCode.USDC_BURN_FEES_FAILED,
@@ -1240,7 +1248,11 @@ export class CCIPTimeoutError extends CCIPError {
  */
 export class CCIPAbortError extends CCIPError {
   override readonly name = 'CCIPAbortError'
-  /** Creates an abort error. */
+  /**
+   * Creates an abort error.
+   * @param operation - Name of the operation that was aborted.
+   * @param options - Optional error options.
+   */
   constructor(operation: string, options?: CCIPErrorOptions) {
     super(CCIPErrorCode.ABORT, `Request aborted: ${operation}`, {
       ...options,
@@ -1853,14 +1865,22 @@ export class CCIPMerkleInternalError extends CCIPError {
  * }
  * ```
  */
-export class CCIPAddressInvalidEvmError extends CCIPError {
-  override readonly name = 'CCIPAddressInvalidEvmError'
-  /** Creates an EVM address invalid error. */
-  constructor(address: string, options?: CCIPErrorOptions) {
-    super(CCIPErrorCode.ADDRESS_INVALID_EVM, `Invalid EVM address: ${address}`, {
+export class CCIPAddressInvalidError extends CCIPError {
+  override readonly name = 'CCIPAddressInvalidError'
+  /** Creates an address invalid error for the given chain family. */
+  constructor(address: BytesLike, family: ChainFamily, options?: CCIPErrorOptions) {
+    const len = address.length
+    const type = typeof address === 'object' ? address.constructor.name : typeof address
+    let bytesLen
+    try {
+      bytesLen = getAddressBytes(address).length
+    } catch (err) {
+      bytesLen = (err as Error).message
+    }
+    super(CCIPErrorCode.ADDRESS_INVALID, `Invalid ${family} address: ${util.inspect(address)}`, {
       ...options,
       isTransient: false,
-      context: { ...options?.context, address },
+      context: { ...options?.context, address, family, len, type, bytesLen },
     })
   }
 }
@@ -2556,34 +2576,6 @@ export class CCIPAptosLogInvalidError extends CCIPError {
   }
 }
 
-/**
- * Thrown when Aptos address is invalid.
- *
- * @example
- * ```typescript
- * import { CCIPDataFormatUnsupportedError } from '@chainlink/ccip-sdk'
- *
- * try {
- *   AptosChain.getAddress('invalid-address')
- * } catch (error) {
- *   if (error instanceof CCIPDataFormatUnsupportedError) {
- *     console.log(`Invalid address: ${error.message}`)
- *   }
- * }
- * ```
- */
-export class CCIPAptosAddressInvalidError extends CCIPError {
-  override readonly name = 'CCIPAptosAddressInvalidError'
-  /** Creates an Aptos address invalid error. */
-  constructor(address: string, options?: CCIPErrorOptions) {
-    super(CCIPErrorCode.ADDRESS_INVALID_APTOS, `Invalid aptos address: "${address}"`, {
-      ...options,
-      isTransient: false,
-      context: { ...options?.context, address },
-    })
-  }
-}
-
 /**
  * Thrown when Aptos can only encode specific extra args types.
  *
@@ -3429,7 +3421,12 @@ export class CCIPApiClientNotAvailableError extends CCIPError {
  */
 export class CCIPUnexpectedPaginationError extends CCIPError {
   override readonly name = 'CCIPUnexpectedPaginationError'
-  /** Creates an unexpected pagination error. */
+  /**
+   * Creates an unexpected pagination error.
+   * @param txHash - Source transaction hash.
+   * @param messageCount - Number of messages returned in the first page.
+   * @param options - Optional error options.
+   */
   constructor(txHash: string, messageCount: number, options?: CCIPErrorOptions) {
     super(
       CCIPErrorCode.API_UNEXPECTED_PAGINATION,

package/src/evm/const.ts

@@ -33,6 +33,7 @@ const customErrors = [
   'error NotEnoughGas()',
   'error InvalidChain(uint64 chainSelector)',
   'error InvalidAdapter()',
+  'error BlacklistableBlacklistedAccount(address)',
 ] as const
 
 export const VersionedContractABI = parseAbi(['function typeAndVersion() view returns (string)'])

package/src/evm/errors.ts

@@ -14,6 +14,7 @@ import {
 import { defaultAbiCoder, interfaces } from './const.ts'
 import { decodeExtraArgs } from '../extra-args.ts'
 import { ChainFamily } from '../types.ts'
+import { networkInfo } from '../utils.ts'
 
 /**
  * Get error data from an error object, if possible
@@ -151,6 +152,16 @@ export function recursiveParseError(
     )
   }
   if (!isBytesLike(data) || [0, 20].includes(dataLength(data))) {
+    // include networkName for chainSelectors
+    if (key.match(/sel(ector)?$/i) && typeof data === 'bigint') {
+      let name
+      try {
+        ;({ name } = networkInfo(data))
+      } catch {
+        // ignore
+      }
+      if (name) return [[key, `${data} [${name}]`]]
+    }
     return [[key, data]]
   }
   try {
@@ -166,14 +177,16 @@ export function recursiveParseError(
   if (!parsed) return [[key, data]]
   const [fragment, _, args] = parsed
   const desc = fragment.format('full')
-  key = desc.split(' ')[0]!
-  const res = [[key, desc.substring(key.length + 1)]] as ReturnType<typeof recursiveParseError>
+  const key_ = j(key, desc.split(' ')[0]!)
+  const res = [[key_, desc.substring(desc.indexOf(' ') + 1)]] as ReturnType<
+    typeof recursiveParseError
+  >
   if (!args) return res
   if (['ReceiverError', 'TokenHandlingError'].includes(fragment.name) && args.err === '0x') {
-    res.push([`${key}.err`, '0x [possibly out-of-gas or abi.decode error]'])
+    res.push([`${key_}.err`, '0x [possibly out-of-gas or abi.decode error]'])
     return res
   }
-  res.push(...recursiveParseError('', args))
+  res.push(...recursiveParseError(key, args))
   return res
 }
 
@@ -187,7 +200,11 @@ export function parseData(data: unknown): Record<string, unknown> | undefined {
   if (isHexString(data)) {
     const parsed = recursiveParseError('', data)
     if (parsed.length === 1 && parsed[0]![1] === data) return
-    return Object.fromEntries(parsed)
+    // like Object.fromEntries, but on duplicated keys, add a space to first occurrence, to avoid overwriting and keep all values
+    return parsed.reduceRight(
+      (acc, [k, v]) => ({ ...{ [k && k in acc ? k + ' ' : k]: v }, ...acc }),
+      {},
+    )
   }
   if (typeof data !== 'object') return
   // ethers tx/simulation/call errors

package/src/evm/extra-args.ts

@@ -5,7 +5,7 @@ import {
   encodeBase58,
   getAddress,
   hexlify,
-  toBeHex,
+  toBeArray,
   toBigInt,
   toNumber,
   zeroPadValue,
@@ -25,7 +25,8 @@ import {
   SuiExtraArgsV1Tag,
 } from '../extra-args.ts'
 import { DEFAULT_GAS_LIMIT } from '../shared/constants.ts'
-import { getAddressBytes, getDataBytes } from '../utils.ts'
+import { ChainFamily } from '../types.ts'
+import { decodeAddress, getAddressBytes, getDataBytes } from '../utils.ts'
 import { defaultAbiCoder } from './const.ts'
 import { resultToObject } from './types.ts'
 
@@ -60,16 +61,16 @@ const SuiExtraArgsV1ABI =
  * - tokenArgs (variable)
  */
 function encodeExtraArgsV3(args: GenericExtraArgsV3): string {
-  const parts: Uint8Array[] = []
+  const parts: BytesLike[] = []
 
   // Tag (4 bytes)
-  parts.push(getDataBytes(GenericExtraArgsV3Tag))
+  parts.push(GenericExtraArgsV3Tag)
 
   // gasLimit (4 bytes, uint32 big-endian)
-  parts.push(getDataBytes(toBeHex(args.gasLimit, 4)))
+  parts.push(toBeArray(args.gasLimit, 4))
 
   // blockConfirmations (2 bytes, uint16 big-endian)
-  parts.push(getDataBytes(toBeHex(args.blockConfirmations, 2)))
+  parts.push(toBeArray(args.blockConfirmations, 2))
 
   // ccvsLength (1 byte)
   parts.push(new Uint8Array([args.ccvs.length]))
@@ -83,14 +84,14 @@ function encodeExtraArgsV3(args: GenericExtraArgsV3): string {
       // ccvAddressLength = 20
       parts.push(new Uint8Array([20]))
       // ccvAddress (20 bytes)
-      parts.push(getDataBytes(ccvAddress))
+      parts.push(decodeAddress(ccvAddress, ChainFamily.EVM))
     } else {
       // ccvAddressLength = 0
       parts.push(new Uint8Array([0]))
     }
 
     // ccvArgsLength (2 bytes, uint16 big-endian)
-    parts.push(getDataBytes(toBeHex(ccvArgsBytes.length, 2)))
+    parts.push(toBeArray(ccvArgsBytes.length, 2))
 
     // ccvArgs (variable)
     if (ccvArgsBytes.length > 0) {
@@ -99,26 +100,25 @@ function encodeExtraArgsV3(args: GenericExtraArgsV3): string {
   }
 
   // executorLength (1 byte)
-  if (args.executor && args.executor !== '' && args.executor !== '0x') {
+  if (args.executor && args.executor !== '0x') {
     parts.push(new Uint8Array([20]))
-    parts.push(getDataBytes(args.executor))
+    parts.push(decodeAddress(args.executor, ChainFamily.EVM))
   } else {
     parts.push(new Uint8Array([0]))
   }
 
   // Convert BytesLike fields to Uint8Array
   const executorArgsBytes = getDataBytes(args.executorArgs)
-  const tokenReceiverBytes = getDataBytes(args.tokenReceiver)
-  const tokenArgsBytes = getDataBytes(args.tokenArgs)
 
   // executorArgsLength (2 bytes, uint16 big-endian)
-  parts.push(getDataBytes(toBeHex(executorArgsBytes.length, 2)))
+  parts.push(toBeArray(executorArgsBytes.length, 2))
 
   // executorArgs (variable)
   if (executorArgsBytes.length > 0) {
     parts.push(executorArgsBytes)
   }
 
+  const tokenReceiverBytes = getAddressBytes(args.tokenReceiver)
   // tokenReceiverLength (1 byte)
   parts.push(new Uint8Array([tokenReceiverBytes.length]))
 
@@ -127,8 +127,9 @@ function encodeExtraArgsV3(args: GenericExtraArgsV3): string {
     parts.push(tokenReceiverBytes)
   }
 
+  const tokenArgsBytes = getDataBytes(args.tokenArgs)
   // tokenArgsLength (2 bytes, uint16 big-endian)
-  parts.push(getDataBytes(toBeHex(tokenArgsBytes.length, 2)))
+  parts.push(toBeArray(tokenArgsBytes.length, 2))
 
   // tokenArgs (variable)
   if (tokenArgsBytes.length > 0) {

package/src/evm/index.ts

@@ -34,6 +34,7 @@ import {
   type LogFilter,
   type RateLimiterState,
   type TokenPoolRemote,
+  type TokenPrice,
   type TokenTransferFeeConfig,
   type TokenTransferFeeOpts,
   type TotalFeesEstimate,
@@ -41,7 +42,7 @@ import {
   LaneFeature,
 } from '../chain.ts'
 import {
-  CCIPAddressInvalidEvmError,
+  CCIPAddressInvalidError,
   CCIPBlockNotFoundError,
   CCIPContractNotRouterError,
   CCIPContractTypeInvalidError,
@@ -56,7 +57,6 @@ import {
   CCIPTokenNotConfiguredError,
   CCIPTokenPoolChainConfigNotFoundError,
   CCIPTransactionNotFoundError,
-  CCIPVersionFeatureUnavailableError,
   CCIPVersionRequiresLaneError,
   CCIPVersionUnsupportedError,
   CCIPWalletInvalidError,
@@ -87,6 +87,7 @@ import {
   decodeOnRampAddress,
   getAddressBytes,
   getDataBytes,
+  getSomeBlockNumberBefore,
   networkInfo,
   parseTypeAndVersion,
 } from '../utils.ts'
@@ -250,6 +251,10 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     this.getFeeTokens = memoize(this.getFeeTokens.bind(this), { async: true, maxArgs: 1 })
     this.detectUsdcDomains = memoize(this.detectUsdcDomains.bind(this))
     this.resolveVerifier = memoize(this.resolveVerifier.bind(this))
+    this.getFeeQuoterFor = memoize(this.getFeeQuoterFor.bind(this), {
+      async: true,
+      maxArgs: 1,
+    })
   }
 
   /**
@@ -555,16 +560,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    */
   static getAddress(bytes: BytesLike): string {
     if (isHexString(bytes, 20)) return getAddress(bytes)
-    bytes = getAddressBytes(bytes)
-    if (bytes.length < 20) throw new CCIPAddressInvalidEvmError(hexlify(bytes))
-    else if (bytes.length > 20) {
-      if (bytes.slice(0, bytes.length - 20).every((b) => b === 0)) {
-        bytes = bytes.slice(-20)
+    let bytes_ = getAddressBytes(bytes)
+    if (bytes_.length < 20) throw new CCIPAddressInvalidError(bytes, this.family)
+    else if (bytes_.length > 20) {
+      if (bytes_.slice(0, bytes_.length - 20).every((b) => b === 0)) {
+        bytes_ = bytes_.slice(-20)
       } else {
-        throw new CCIPAddressInvalidEvmError(hexlify(bytes))
+        throw new CCIPAddressInvalidError(hexlify(bytes_), this.family)
       }
     }
-    return getAddress(hexlify(bytes))
+    return getAddress(hexlify(bytes_))
   }
 
   /**
@@ -970,17 +975,26 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * @throws {@link CCIPVersionFeatureUnavailableError} if contract version is below v1.6
    */
   async getFeeQuoterFor(address: string): Promise<string> {
-    let [type, version, typeAndVersion] = await this.typeAndVersion(address)
-    if (type === 'FeeQuoter') {
+    const [type, version, typeAndVersion] = await this.typeAndVersion(address)
+    if (type === 'FeeQuoter' || type === 'PriceRegistry') {
       return address
     } else if (type === 'Router') {
-      address = await this._getSomeOnRampFor(address)
-      ;[type, version, typeAndVersion] = await this.typeAndVersion(address)
+      return this.getFeeQuoterFor(await this._getSomeOnRampFor(address)) // use cache
     } else if (!type.includes('Ramp')) {
       throw new CCIPContractNotRouterError(address, typeAndVersion)
     }
-    if (version < CCIPVersion.V1_6)
-      throw new CCIPVersionFeatureUnavailableError('feeQuoter', version, 'v1.6')
+
+    if (version < CCIPVersion.V1_6) {
+      const contract = new Contract(
+        address,
+        version === CCIPVersion.V1_2
+          ? interfaces.EVM2EVMOnRamp_v1_2
+          : interfaces.EVM2EVMOnRamp_v1_5,
+        this.provider,
+      ) as unknown as TypedContract<typeof EVM2EVMOnRamp_1_2_ABI | typeof EVM2EVMOnRamp_1_5_ABI>
+      const { priceRegistry } = await contract.getDynamicConfig()
+      return priceRegistry as string
+    }
 
     const isOnRamp = type.includes('OnRamp')
     const contract = new Contract(
@@ -1017,7 +1031,10 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       this.provider,
     ) as unknown as TypedContract<typeof Router_ABI>
     return contract.getFee(destChainSelector, {
-      receiver: zeroPadValue(getAddressBytes(populatedMessage.receiver), 32),
+      receiver: (() => {
+        const receiverBytes = getAddressBytes(populatedMessage.receiver)
+        return receiverBytes.length <= 32 ? zeroPadValue(receiverBytes, 32) : hexlify(receiverBytes)
+      })(),
       data: hexlify(populatedMessage.data ?? '0x'),
       tokenAmounts: populatedMessage.tokenAmounts ?? [],
       feeToken: populatedMessage.feeToken ?? ZeroAddress,
@@ -1133,6 +1150,52 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     return undefined
   }
 
+  /** {@inheritDoc Chain.getTokenPrice} */
+  override async getTokenPrice(opts: {
+    router: string
+    token: string
+    timestamp?: number
+  }): Promise<TokenPrice> {
+    let { token } = opts
+
+    // Resolve native token (ZeroAddress) to wrapped native
+    if (token === ZeroAddress) {
+      token = await this.getNativeTokenForRouter(opts.router)
+    }
+
+    const priceContractAddress = await this.getFeeQuoterFor(opts.router)
+
+    // Both PriceRegistry (v1.2/v1.5) and FeeQuoter (v1.6+) expose
+    // getTokenPrice(address) → { value: uint224, timestamp: uint32 }
+    const contract = new Contract(
+      priceContractAddress,
+      interfaces.FeeQuoter,
+      this.provider,
+    ) as unknown as TypedContract<typeof FeeQuoter_ABI>
+
+    // If timestamp provided, resolve to block number for historical query
+    let blockTag: number | undefined
+    if (opts.timestamp != null) {
+      const { number: latestBlock } = (await this.provider.getBlock('latest'))!
+      blockTag = await getSomeBlockNumberBefore(
+        async (block: number) => (await this.provider.getBlock(block))!.timestamp,
+        latestBlock,
+        opts.timestamp,
+        this,
+      )
+    }
+
+    const [result, { decimals }] = await Promise.all([
+      blockTag != null
+        ? contract.getTokenPrice.staticCall(token, { blockTag })
+        : contract.getTokenPrice(token),
+      this.getTokenInfo(token),
+    ])
+
+    const rawPrice = BigInt(result.value)
+    return { price: Number(rawPrice) * 10 ** (decimals - 36) }
+  }
+
   /** {@inheritDoc Chain.getTotalFeesEstimate} */
   override async getTotalFeesEstimate(
     opts: Parameters<Chain['getTotalFeesEstimate']>[0],
@@ -1152,7 +1215,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     let tokenArgs: string = '0x'
     if (extraArgs && 'blockConfirmations' in extraArgs) {
       blockConfirmations = extraArgs.blockConfirmations as number
-      tokenArgs = hexlify(extraArgs.tokenArgs as BytesLike)
+      if (extraArgs.tokenArgs) tokenArgs = hexlify(extraArgs.tokenArgs)
     }
 
     // Skip pool-level fee lookup for pre-v2.0 lanes
@@ -1257,7 +1320,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     }
 
     const feeToken = message.feeToken ?? ZeroAddress
-    const receiver = zeroPadValue(getAddressBytes(message.receiver), 32)
+    const receiverBytes = getAddressBytes(message.receiver)
+    const receiver =
+      receiverBytes.length <= 32 ? zeroPadValue(receiverBytes, 32) : hexlify(receiverBytes)
     const data = hexlify(message.data ?? '0x')
     const extraArgs = hexlify(
       (this.constructor as typeof EVMChain).encodeExtraArgs(message.extraArgs),
@@ -1639,7 +1704,10 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
    * Fetches the token pool configuration for an EVM token pool contract.
    *
    * @param tokenPool - Token pool contract address.
-   * @param feeOpts - Optional parameters to also fetch token transfer fee config.
+   * @param feeOpts - Optional parameters to also fetch token transfer fee config:
+   *   - `destChainSelector` — destination chain selector.
+   *   - `blockConfirmationsRequested` — number of block confirmations (0 = standard, positive = FTF).
+   *   - `tokenArgs` — hex-encoded bytes passed to the pool contract.
    * @returns Token pool config containing token, router, typeAndVersion, and optionally
    *          minBlockConfirmations and tokenTransferFeeConfig.
    *
@@ -1658,7 +1726,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     minBlockConfirmations?: number
     tokenTransferFeeConfig?: TokenTransferFeeConfig
   }> {
-    const [_, version, typeAndVersion] = await this.typeAndVersion(tokenPool)
+    const [type, version, typeAndVersion] = await this.typeAndVersion(tokenPool)
 
     let token, router, minBlockConfirmations, tokenTransferFeeConfig
     if (version < CCIPVersion.V2_0) {
@@ -1670,6 +1738,14 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       token = contract.getToken()
       router = contract.getRouter()
     } else {
+      if (type === 'USDCTokenPoolProxy') {
+        const proxy = new Contract(
+          tokenPool,
+          interfaces.USDCTokenPoolProxy_v2_0,
+          this.provider,
+        ) as unknown as TypedContract<typeof USDCTokenPoolProxy_2_0_ABI>
+        tokenPool = (await proxy.getPools())['cctpV2PoolWithCCV'] as string
+      }
       const contract = new Contract(
         tokenPool,
         interfaces.TokenPool_v2_0,
@@ -1678,6 +1754,11 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       token = contract.getToken()
       router = contract.getDynamicConfig().then(([router]) => router)
       minBlockConfirmations = contract.getMinBlockConfirmations().catch((err) => {
+        this.logger.debug(
+          typeAndVersion,
+          'threw when fetching minBlockConfirmations, defaulting to 0:',
+          err,
+        )
         if (isError(err, 'CALL_EXCEPTION')) return 0
         throw CCIPError.from(err)
       })
@@ -1750,7 +1831,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     tokenPool: string,
     remoteChainSelector?: bigint,
   ): Promise<Record<string, TokenPoolRemote>> {
-    const [_, version] = await this.typeAndVersion(tokenPool)
+    const [type, version] = await this.typeAndVersion(tokenPool)
 
     let supportedChains: Promise<NetworkInfo[]> | undefined
     if (remoteChainSelector) supportedChains = Promise.resolve([networkInfo(remoteChainSelector)])
@@ -1812,6 +1893,14 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         ),
       )
     } else {
+      if (type === 'USDCTokenPoolProxy') {
+        const proxy = new Contract(
+          tokenPool,
+          interfaces.USDCTokenPoolProxy_v2_0,
+          this.provider,
+        ) as unknown as TypedContract<typeof USDCTokenPoolProxy_2_0_ABI>
+        tokenPool = (await proxy.getPools())['cctpV2PoolWithCCV'] as string
+      }
       const contract = new Contract(
         tokenPool,
         interfaces.TokenPool_v2_0,

package/src/gas.ts

@@ -57,11 +57,12 @@ export type EstimateReceiveExecutionOpts = {
  * Estimate CCIP gasLimit needed to execute a request on a contract receiver.
  *
  * @param opts - {@link EstimateReceiveExecutionOpts} for estimation
- * @returns Estimated gasLimit
+ * @returns Estimated execution gas (base transaction cost subtracted)
  *
  * @throws {@link CCIPMethodUnsupportedError} if dest chain doesn't support estimation
  * @throws {@link CCIPContractTypeInvalidError} if routerOrRamp is not a valid contract type
  * @throws {@link CCIPTokenDecimalsInsufficientError} if dest token has insufficient decimals
+ * @throws {@link CCIPOnRampRequiredError} if no OnRamp found for the given OffRamp and source chain
  *
  * @example
  * ```typescript

package/src/index.ts

@@ -37,6 +37,7 @@ export type {
   TokenInfo,
   TokenPoolConfig,
   TokenPoolRemote,
+  TokenPrice,
   TokenTransferFee,
   TokenTransferFeeConfig,
   TokenTransferFeeOpts,

package/src/offchain.ts

@@ -86,6 +86,7 @@ export const CCTP_FINALITY_STANDARD = 2000
  * @param destDomain - CCTP destination domain identifier
  * @param networkType - network type (mainnet or testnet)
  * @returns Array of fee tiers with finality thresholds and BPS fees
+ * @throws {@link CCIPUsdcBurnFeesError} if the HTTP request fails or the response is not a valid array of fee tiers
  */
 export async function getUsdcBurnFees(
   sourceDomain: number,

package/src/requests.ts

@@ -1,7 +1,7 @@
 import { type BytesLike, hexlify, isBytesLike, toBigInt } from 'ethers'
 import type { PickDeep } from 'type-fest'
 
-import { type ChainStatic, Chain } from './chain.ts'
+import type { Chain, ChainStatic } from './chain.ts'
 import {
   CCIPChainFamilyUnsupportedError,
   CCIPMessageBatchIncompleteError,
@@ -196,9 +196,8 @@ export function decodeMessage(data: string | Uint8Array | Record<string, unknown
  * @returns Original message or shallow copy with defaults for required fields
  */
 export function buildMessageForDest(message: MessageInput, dest: ChainFamily): AnyMessage {
-  const chain = supportedChains[dest] ?? Chain
   if (message.extraArgs && '_tag' in message.extraArgs) delete message.extraArgs._tag
-  return chain.buildMessageForDest(message)
+  return supportedChains[dest]!.buildMessageForDest(message)
 }
 
 /**
@@ -310,6 +309,7 @@ const BLOCK_LOG_WINDOW_SIZE = 5000
  * @param range - Object containing minSeqNr and maxSeqNr for the batch range.
  * @param opts - Optional log filtering parameters.
  * @returns Array of messages in the batch.
+ * @throws {@link CCIPMessageBatchIncompleteError} if not all messages in the batch range could be found in source chain logs
  * @see {@link getVerifications} - Get commit report to determine batch range
  */
 export async function getMessagesInBatch<
@@ -409,12 +409,12 @@ export async function getMessagesInBatch<
  * import { sourceToDestTokenAddresses, EVMChain } from '@chainlink/ccip-sdk'
  *
  * const source = await EVMChain.fromUrl('https://rpc.sepolia.org')
- * const tokenAmount = await sourceToDestTokenAddresses(
+ * const tokenAmount = await sourceToDestTokenAddresses({
  *   source,
- *   destChainSelector,
- *   '0xOnRamp...',
- *   { token: '0xLINK...', amount: 1000000000000000000n }
- * )
+ *   onRamp: '0xOnRamp...',
+ *   destChainSelector: 14767482510784806043n,
+ *   sourceTokenAmount: { token: '0xLINK...', amount: 1000000000000000000n },
+ * })
  * console.log(`Pool: ${tokenAmount.sourcePoolAddress}`)
  * console.log(`Dest token: ${tokenAmount.destTokenAddress}`)
  * ```