@chainlink/ccip-sdk 1.3.1 → 1.4.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,
@@ -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,
+    })
   }
 
   /**
@@ -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

@@ -310,6 +310,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 +410,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}`)
  * ```