@chainlink/ccip-sdk 1.0.0 → 1.1.0

package/src/evm/const.ts

@@ -19,6 +19,7 @@ import OnRamp_2_0_ABI from './abi/OnRamp_2_0.ts'
 import PriceRegistry_1_2_ABI from './abi/PriceRegistry_1_2.ts'
 import Router_ABI from './abi/Router.ts'
 import TokenAdminRegistry_ABI from './abi/TokenAdminRegistry_1_5.ts'
+import TokenPool_2_0_ABI from './abi/TokenPool_2_0.ts'
 
 export const defaultAbiCoder = AbiCoder.defaultAbiCoder()
 
@@ -38,6 +39,7 @@ export const interfaces = {
   FeeQuoter: new Interface(FeeQuoter_ABI),
   TokenPool_v1_5_1: new Interface(TokenPool_1_5_1_ABI),
   TokenPool_v1_5: new Interface(TokenPool_1_5_ABI),
+  TokenPool_v2_0: new Interface(TokenPool_2_0_ABI),
   TokenPool_v1_6: new Interface(TokenPool_1_6_ABI),
   CommitStore_v1_5: new Interface(CommitStore_1_5_ABI),
   CommitStore_v1_2: new Interface(CommitStore_1_2_ABI),

package/src/evm/index.ts

@@ -15,6 +15,7 @@ import {
   getAddress,
   hexlify,
   isBytesLike,
+  isError,
   isHexString,
   keccak256,
   toBeHex,
@@ -27,9 +28,12 @@ import type { PickDeep, SetRequired } from 'type-fest'
 import {
   type ChainContext,
   type GetBalanceOpts,
+  type LaneFeatures,
   type LogFilter,
+  type RateLimiterState,
   type TokenPoolRemote,
   Chain,
+  LaneFeature,
 } from '../chain.ts'
 import {
   CCIPAddressInvalidEvmError,
@@ -38,11 +42,11 @@ import {
   CCIPContractNotRouterError,
   CCIPContractTypeInvalidError,
   CCIPDataFormatUnsupportedError,
+  CCIPError,
   CCIPExecTxNotConfirmedError,
   CCIPExecTxRevertedError,
   CCIPHasherVersionUnsupportedError,
   CCIPLogDataInvalidError,
-  CCIPNotImplementedError,
   CCIPSourceChainUnsupportedError,
   CCIPTokenNotConfiguredError,
   CCIPTokenPoolChainConfigNotFoundError,
@@ -95,6 +99,7 @@ import type OnRamp_1_6_ABI from './abi/OnRamp_1_6.ts'
 import type OnRamp_2_0_ABI from './abi/OnRamp_2_0.ts'
 import type Router_ABI from './abi/Router.ts'
 import type TokenAdminRegistry_1_5_ABI from './abi/TokenAdminRegistry_1_5.ts'
+import type TokenPool_2_0_ABI from './abi/TokenPool_2_0.ts'
 import {
   CCV_INDEXER_URL,
   VersionedContractABI,
@@ -111,21 +116,21 @@ import {
 import { estimateExecGas } from './gas.ts'
 import { getV12LeafHasher, getV16LeafHasher } from './hasher.ts'
 import { getEvmLogs } from './logs.ts'
-import {
-  type CCIPMessage_V1_6_EVM,
-  type CCIPMessage_V2_0,
-  type CleanAddressable,
-  type MessageV1,
-  type TokenTransferV1,
-  decodeMessageV1,
-} from './messages.ts'
-export { decodeMessageV1 }
-export type { MessageV1, TokenTransferV1 }
+import type { CCIPMessage_V1_6_EVM, CCIPMessage_V2_0, CleanAddressable } from './messages.ts'
 import { encodeEVMOffchainTokenData } from './offchain.ts'
 import { buildMessageForDest, decodeMessage, getMessagesInBatch } from '../requests.ts'
 import { type UnsignedEVMTx, resultToObject } from './types.ts'
+import { decodeMessageV1 } from '../messages.ts'
 export type { UnsignedEVMTx }
 
+/** Raw on-chain TokenBucket struct returned by TokenPool rate limiter queries. */
+type RateLimiterBucket = { tokens: bigint; isEnabled: boolean; capacity: bigint; rate: bigint }
+
+/** Converts an on-chain bucket to the public RateLimiterState, stripping `isEnabled`. */
+function toRateLimiterState(b: RateLimiterBucket): RateLimiterState {
+  return b.isEnabled ? { tokens: b.tokens, capacity: b.capacity, rate: b.rate } : null
+}
+
 /** typeguard for ethers Signer interface (used for `wallet`s)  */
 function isSigner(wallet: unknown): wallet is Signer {
   return (
@@ -625,6 +630,45 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     }
   }
 
+  /**
+   * {@inheritDoc Chain.getLaneFeatures}
+   */
+  override async getLaneFeatures(opts: {
+    router: string
+    destChainSelector: bigint
+    token?: string
+  }): Promise<Partial<LaneFeatures>> {
+    const onRamp = await this.getOnRampForRouter(opts.router, opts.destChainSelector)
+    const [, version] = await this.typeAndVersion(onRamp)
+
+    const result: Partial<LaneFeatures> = {}
+
+    // default FTF value for V2_0+ lanes if no token/pool or pool doesn't specify
+    if (version >= CCIPVersion.V2_0) result[LaneFeature.MIN_BLOCK_CONFIRMATIONS] = 1
+
+    // MIN_BLOCK_CONFIRMATIONS — V2_0+ only
+    if (opts.token) {
+      const { tokenPool } = await this.getRegistryTokenConfig(
+        await this.getTokenAdminRegistryFor(onRamp),
+        opts.token,
+      )
+      if (tokenPool) {
+        const { minBlockConfirmations } = await this.getTokenPoolConfig(tokenPool)
+        if (minBlockConfirmations != null)
+          result[LaneFeature.MIN_BLOCK_CONFIRMATIONS] = minBlockConfirmations
+
+        const remote = await this.getTokenPoolRemote(tokenPool, opts.destChainSelector)
+        result[LaneFeature.RATE_LIMITS] = remote.outboundRateLimiterState
+        if (minBlockConfirmations && 'customBlockConfirmationsOutboundRateLimiterState' in remote) {
+          result[LaneFeature.CUSTOM_BLOCK_CONFIRMATIONS_RATE_LIMITS] =
+            remote.customBlockConfirmationsOutboundRateLimiterState
+        }
+      }
+    }
+
+    return result
+  }
+
   /**
    * {@inheritDoc Chain.getRouterForOffRamp}
    * @throws {@link CCIPVersionUnsupportedError} if OffRamp version is not supported
@@ -887,11 +931,22 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         ? type.includes('OnRamp')
           ? interfaces.EVM2EVMOnRamp_v1_5
           : interfaces.EVM2EVMOffRamp_v1_5
-        : type.includes('OnRamp')
-          ? interfaces.OnRamp_v1_6
-          : interfaces.OffRamp_v1_6,
+        : version < CCIPVersion.V2_0
+          ? type.includes('OnRamp')
+            ? interfaces.OnRamp_v1_6
+            : interfaces.OffRamp_v1_6
+          : type.includes('OnRamp')
+            ? interfaces.OnRamp_v2_0
+            : interfaces.OffRamp_v2_0,
       this.provider,
-    ) as unknown as TypedContract<typeof OnRamp_1_6_ABI | typeof OffRamp_1_6_ABI>
+    ) as unknown as TypedContract<
+      | typeof EVM2EVMOnRamp_1_5_ABI
+      | typeof EVM2EVMOffRamp_1_5_ABI
+      | typeof OnRamp_1_6_ABI
+      | typeof OffRamp_1_6_ABI
+      | typeof OnRamp_2_0_ABI
+      | typeof OffRamp_2_0_ABI
+    >
     const { tokenAdminRegistry } = await contract.getStaticConfig()
     return tokenAdminRegistry as string
   }
@@ -975,10 +1030,12 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     )
 
     // make sure to approve once per token, for the total amount (including fee, if needed)
-    const amountsToApprove = (message.tokenAmounts ?? []).reduce(
-      (acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }),
-      {} as { [token: string]: bigint },
-    )
+    const amountsToApprove = (message.tokenAmounts ?? [])
+      .filter(({ token }) => token && token !== ZeroAddress)
+      .reduce(
+        (acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }),
+        {} as { [token: string]: bigint },
+      )
     if (feeToken !== ZeroAddress)
       amountsToApprove[feeToken] = (amountsToApprove[feeToken] ?? 0n) + message.fee
 
@@ -992,7 +1049,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           ) as unknown as TypedContract<typeof Token_ABI>
           const allowance = await contract.allowance(sender, router)
           if (allowance >= amount) return
-          const amnt = opts.approveMax ? 2n ** 256n - 1n : amount
+          const amnt = opts.approveMax ? BigInt(2) ** BigInt(256) - BigInt(1) : amount
           return contract.approve.populateTransaction(router, amnt, { from: sender })
         }),
       )
@@ -1003,6 +1060,13 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       interfaces.Router,
       this.provider,
     ) as unknown as TypedContract<typeof Router_ABI>
+
+    // if `token` is ZeroAddress, send its `amount` as `value` to router/EtherSenderReceiver (plus possibly native fee)
+    // if native fee, include it in value; otherwise, it's transferedFrom feeToken
+    const value = (message.tokenAmounts ?? [])
+      .filter(({ token }) => token === ZeroAddress)
+      .reduce((acc, { amount }) => acc + amount, feeToken === ZeroAddress ? message.fee : 0n)
+
     const sendTx = await contract.ccipSend.populateTransaction(
       destChainSelector,
       {
@@ -1012,11 +1076,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         extraArgs,
         feeToken,
       },
-      {
-        from: sender,
-        // if native fee, include it in value; otherwise, it's transferedFrom feeToken
-        ...(feeToken === ZeroAddress && { value: message.fee }),
-      },
+      { from: sender, ...(value > 0n ? { value } : {}) },
     )
     const txRequests = [...approveTxs, sendTx] as SetRequired<typeof sendTx, 'from'>[]
     return {
@@ -1100,6 +1160,13 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       const txGasLimit = await contract.executeSingleMessage.estimateGas(
         {
           ...message,
+          onRampAddress: zeroPadValue(getAddressBytes(message.onRampAddress), 32),
+          sender: zeroPadValue(getAddressBytes(message.sender), 32),
+          tokenTransfer: message.tokenTransfer.map((ta) => ({
+            ...ta,
+            sourcePoolAddress: zeroPadValue(getAddressBytes(ta.sourcePoolAddress), 32),
+            sourceTokenAddress: zeroPadValue(getAddressBytes(ta.sourceTokenAddress), 32),
+          })),
           executionGasLimit: BigInt(message.executionGasLimit),
           ccipReceiveGasLimit: BigInt(message.ccipReceiveGasLimit),
           finality: BigInt(message.finality),
@@ -1226,6 +1293,22 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
       default:
         throw new CCIPVersionUnsupportedError(version)
     }
+
+    /* Executing a message for the first time has some hard try/catches on-chain
+     * so we need to ensure some lower-bounds gasLimits */
+    let gasLimit = await this.provider.estimateGas(manualExecTx)
+    if (
+      'gasLimit' in input.message &&
+      input.message.gasLimit &&
+      gasLimit < input.message.gasLimit + 100000n
+    )
+      // if message requested gasLimit, ensure execution more than 100k above requested, otherwise it's clearly a try/catch fail
+      gasLimit = BigInt(input.message.gasLimit) + 200000n
+    else if ('gasLimit' in input.message && !input.message.gasLimit && gasLimit < 240000n)
+      // if message didn't request gasLimit, ensure execution gasLimit is above 240k (empiric)
+      gasLimit = 240000n
+    manualExecTx.gasLimit = gasLimit
+
     return { family: ChainFamily.EVM, transactions: [manualExecTx] }
   }
 
@@ -1252,7 +1335,8 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     const response = await submitTransaction(wallet, populatedTx, this.provider)
     this.logger.debug('manuallyExecute =>', response.hash)
 
-    const receipt = await response.wait(1, 60_000)
+    let receipt = await response.wait(0)
+    if (!receipt) receipt = await response.wait(1, 240_000)
     if (!receipt?.hash) throw new CCIPExecTxNotConfirmedError(response.hash)
     if (!receipt.status) throw new CCIPExecTxRevertedError(response.hash)
     const tx = await this.getTransaction(receipt)
@@ -1328,24 +1412,44 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     token: string
     router: string
     typeAndVersion: string
+    minBlockConfirmations?: number
   }> {
-    const [_, , typeAndVersion] = await this.typeAndVersion(tokenPool)
-
-    const contract = new Contract(
-      tokenPool,
-      interfaces.TokenPool_v1_6,
-      this.provider,
-    ) as unknown as TypedContract<typeof TokenPool_ABI>
+    const [_, version, typeAndVersion] = await this.typeAndVersion(tokenPool)
 
+    let contract, router, minBlockConfirmations
+    if (version < CCIPVersion.V2_0) {
+      contract = new Contract(
+        tokenPool,
+        interfaces.TokenPool_v1_6,
+        this.provider,
+      ) as unknown as TypedContract<typeof TokenPool_ABI>
+      router = contract.getRouter()
+    } else {
+      contract = new Contract(
+        tokenPool,
+        interfaces.TokenPool_v2_0,
+        this.provider,
+      ) as unknown as TypedContract<typeof TokenPool_2_0_ABI>
+      router = contract.getDynamicConfig().then(([router]) => router)
+      minBlockConfirmations = contract.getMinBlockConfirmations().catch((err) => {
+        if (isError(err, 'CALL_EXCEPTION')) return 0
+        throw CCIPError.from(err)
+      })
+    }
     const token = contract.getToken()
-    const router = contract.getRouter()
-    return Promise.all([token, router]).then(([token, router]) => {
-      return {
-        token: token as string,
-        router: router as string,
-        typeAndVersion,
-      }
-    })
+
+    return Promise.all([token, router, minBlockConfirmations]).then(
+      ([token, router, minBlockConfirmations]) => {
+        return {
+          token: token as CleanAddressable<typeof token>,
+          router: router as CleanAddressable<typeof router>,
+          typeAndVersion,
+          ...(minBlockConfirmations != null && {
+            minBlockConfirmations: Number(minBlockConfirmations),
+          }),
+        }
+      },
+    )
   }
 
   /** {@inheritDoc Chain.getTokenPoolRemotes} */
@@ -1359,53 +1463,93 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     if (remoteChainSelector) supportedChains = Promise.resolve([networkInfo(remoteChainSelector)])
 
     let remotePools: Promise<string[][]>
-    let contract
+    let remoteInfo
     if (version < '1.5.1') {
-      const contract_ = new Contract(
+      const contract = new Contract(
         tokenPool,
         interfaces.TokenPool_v1_5,
         this.provider,
       ) as unknown as TypedContract<typeof TokenPool_1_5_ABI>
-      contract = contract_
       supportedChains ??= contract.getSupportedChains().then((chains) => chains.map(networkInfo))
       remotePools = supportedChains.then((chains) =>
         Promise.all(
           chains.map((chain) =>
-            contract_
+            contract
               .getRemotePool(chain.chainSelector)
               .then((remotePool) => [decodeAddress(remotePool, chain.family)]),
           ),
         ),
       )
-    } else {
-      const contract_ = new Contract(
+      remoteInfo = supportedChains.then((chains) =>
+        Promise.all(
+          chains.map((chain) =>
+            Promise.all([
+              contract.getRemoteToken(chain.chainSelector),
+              resultToObject(contract.getCurrentOutboundRateLimiterState(chain.chainSelector)),
+              resultToObject(contract.getCurrentInboundRateLimiterState(chain.chainSelector)),
+            ] as const),
+          ),
+        ),
+      )
+    } else if (version < CCIPVersion.V2_0) {
+      const contract = new Contract(
         tokenPool,
         interfaces.TokenPool_v1_6,
         this.provider,
       ) as unknown as TypedContract<typeof TokenPool_ABI>
-      contract = contract_
       supportedChains ??= contract.getSupportedChains().then((chains) => chains.map(networkInfo))
       remotePools = supportedChains.then((chains) =>
         Promise.all(
           chains.map((chain) =>
-            contract_
+            contract
               .getRemotePools(chain.chainSelector)
               .then((pools) => pools.map((remotePool) => decodeAddress(remotePool, chain.family))),
           ),
         ),
       )
-    }
-    const remoteInfo = supportedChains.then((chains) =>
-      Promise.all(
-        chains.map((chain) =>
-          Promise.all([
-            contract.getRemoteToken(chain.chainSelector),
-            resultToObject(contract.getCurrentInboundRateLimiterState(chain.chainSelector)),
-            resultToObject(contract.getCurrentOutboundRateLimiterState(chain.chainSelector)),
-          ] as const),
+      remoteInfo = supportedChains.then((chains) =>
+        Promise.all(
+          chains.map((chain) =>
+            Promise.all([
+              contract.getRemoteToken(chain.chainSelector),
+              resultToObject(contract.getCurrentOutboundRateLimiterState(chain.chainSelector)),
+              resultToObject(contract.getCurrentInboundRateLimiterState(chain.chainSelector)),
+            ] as const),
+          ),
         ),
-      ),
-    )
+      )
+    } else {
+      const contract = new Contract(
+        tokenPool,
+        interfaces.TokenPool_v2_0,
+        this.provider,
+      ) as unknown as TypedContract<typeof TokenPool_2_0_ABI>
+      supportedChains ??= contract.getSupportedChains().then((chains) => chains.map(networkInfo))
+      remotePools = supportedChains.then((chains) =>
+        Promise.all(
+          chains.map((chain) =>
+            contract
+              .getRemotePools(chain.chainSelector)
+              .then((pools) => pools.map((remotePool) => decodeAddress(remotePool, chain.family))),
+          ),
+        ),
+      )
+      remoteInfo = supportedChains.then((chains) =>
+        Promise.all(
+          chains.map((chain) =>
+            Promise.all([
+              contract.getRemoteToken(chain.chainSelector),
+              contract.getCurrentRateLimiterState(chain.chainSelector, false),
+              contract.getCurrentRateLimiterState(chain.chainSelector, true),
+            ] as const).then(
+              ([remoteToken, [outbound, inbound], [customOutbound, customInbound]]) => {
+                return [remoteToken, outbound, inbound, customOutbound, customInbound] as const
+              },
+            ),
+          ),
+        ),
+      )
+    }
     return Promise.all([supportedChains, remotePools, remoteInfo]).then(
       ([supportedChains, remotePools, remoteInfo]) =>
         Object.fromEntries(
@@ -1418,8 +1562,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
               {
                 remoteToken: decodeAddress(remoteTokenRaw, chain.family),
                 remotePools: remotePools[i]!.map((pool) => decodeAddress(pool, chain.family)),
-                inboundRateLimiterState: remoteInfo[i]![1].isEnabled ? remoteInfo[i]![1] : null,
-                outboundRateLimiterState: remoteInfo[i]![2].isEnabled ? remoteInfo[i]![2] : null,
+                outboundRateLimiterState: toRateLimiterState(remoteInfo[i]![1]),
+                inboundRateLimiterState: toRateLimiterState(remoteInfo[i]![2]),
+                ...(remoteInfo[i]!.length === 5 && {
+                  customBlockConfirmationsOutboundRateLimiterState: toRateLimiterState(
+                    remoteInfo[i]![3],
+                  ),
+                  customBlockConfirmationsInboundRateLimiterState: toRateLimiterState(
+                    remoteInfo[i]![4],
+                  ),
+                }),
               },
             ] as const
           }),
@@ -1461,7 +1613,8 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         tokens = Array.from(tokens_)
         break
       }
-      case CCIPVersion.V1_6: {
+      case CCIPVersion.V1_6:
+      case CCIPVersion.V2_0: {
         const feeQuoter = await this.getFeeQuoterFor(onRamp)
         const contract = new Contract(
           feeQuoter,
@@ -1489,15 +1642,13 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   ): Promise<CCIPVerifications> {
     const { offRamp, request } = opts
     if (request.lane.version >= CCIPVersion.V2_0) {
-      const message = request.message as CCIPMessage_V2_0
-      if (!message.encodedMessage)
-        throw new CCIPNotImplementedError(`CCIPAPIClient getMessageById v2 encodedMessage`)
+      const { encodedMessage } = request.message as CCIPMessage_V2_0
       const contract = new Contract(
         offRamp,
         interfaces.OffRamp_v2_0,
         this.provider,
       ) as unknown as TypedContract<typeof OffRamp_2_0_ABI>
-      const ccvs = await contract.getCCVsForMessage(message.encodedMessage)
+      const ccvs = await contract.getCCVsForMessage(encodedMessage)
       const [requiredCCVs, optionalCCVs, optionalThreshold] = ccvs.map(
         resultToObject,
       ) as unknown as CleanAddressable<typeof ccvs>
@@ -1511,20 +1662,24 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         const apiRes = await this.apiClient.getMessageById(request.message.messageId)
         if ('verifiers' in apiRes.message) {
           const verifiers = apiRes.message.verifiers as {
-            items: {
+            items?: {
               destAddress: string
               sourceAddress: string
-              verification: { data: string; timestamp: string }
+              verification?: { data: string; timestamp: string }
             }[]
           }
           return {
             verificationPolicy,
-            verifications: verifiers.items.map((item) => ({
-              destAddress: item.destAddress,
-              sourceAddress: item.sourceAddress,
-              ccvData: item.verification.data,
-              timestamp: new Date(item.verification.timestamp).getTime() / 1e3,
-            })),
+            verifications: (verifiers.items ?? [])
+              .filter((item) => item.verification?.data)
+              .map((item) => ({
+                destAddress: item.destAddress,
+                sourceAddress: item.sourceAddress,
+                ccvData: item.verification!.data,
+                ...(!!item.verification?.timestamp && {
+                  timestamp: new Date(item.verification.timestamp).getTime() / 1e3,
+                }),
+              })),
           }
         }
       }