@chainlink/ccip-sdk 1.1.1 → 1.2.0

package/src/evm/index.ts

@@ -12,6 +12,7 @@ import {
   JsonRpcProvider,
   WebSocketProvider,
   ZeroAddress,
+  formatUnits,
   getAddress,
   hexlify,
   isBytesLike,
@@ -19,6 +20,7 @@ import {
   isHexString,
   keccak256,
   toBeHex,
+  toBigInt,
   zeroPadValue,
 } from 'ethers'
 import type { TypedContract } from 'ethers-abitype'
@@ -47,6 +49,7 @@ import {
   CCIPHasherVersionUnsupportedError,
   CCIPLogDataInvalidError,
   CCIPSourceChainUnsupportedError,
+  CCIPTokenDecimalsInsufficientError,
   CCIPTokenNotConfiguredError,
   CCIPTokenPoolChainConfigNotFoundError,
   CCIPTransactionNotFoundError,
@@ -692,7 +695,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         offRampABI = OffRamp_1_6_ABI
       // falls through
       case CCIPVersion.V2_0: {
-        offRampABI = OffRamp_2_0_ABI
+        offRampABI ??= OffRamp_2_0_ABI
         const contract = new Contract(
           offRamp,
           offRampABI,
@@ -1003,9 +1006,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /**
-   * {@inheritDoc Chain.generateUnsignedSendMessage}
-   * @returns Array containing 0 or more unsigned token approvals txs (if needed at the time of
-   *   generation), followed by a ccipSend TransactionRequest
+   * Generates unsigned EVM transactions for sending a CCIP message.
+   *
+   * @param opts - Send message options with sender address for populating transaction fields.
+   * @returns Unsigned EVM transaction set containing 0 or more token approval txs
+   *   (if needed at the time of generation), followed by a ccipSend TransactionRequest.
+   *
+   * @remarks
+   * When a token in `tokenAmounts` has `ZeroAddress` as its address, the corresponding
+   * amount is included as native `value` in the `ccipSend` transaction instead of
+   * going through the ERC-20 approve flow.
    */
   async generateUnsignedSendMessage(
     opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
@@ -1138,7 +1148,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   async generateUnsignedExecute(
     opts: Parameters<Chain['generateUnsignedExecute']>[0],
   ): Promise<UnsignedEVMTx> {
-    const { offRamp, input } = await this.resolveExecuteOpts(opts)
+    const { offRamp, input, gasLimit } = await this.resolveExecuteOpts(opts)
     if ('verifications' in input) {
       const contract = new Contract(
         offRamp,
@@ -1166,14 +1176,14 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         messageId,
         input.verifications.map(({ destAddress }) => destAddress),
         input.verifications.map(({ ccvData }) => hexlify(ccvData)),
-        BigInt(opts.gasLimit ?? 0),
+        BigInt(gasLimit ?? 0),
         { from: offRamp }, // internal method
       )
       const execTx = await contract.execute.populateTransaction(
         input.encodedMessage,
         input.verifications.map(({ destAddress }) => destAddress),
         input.verifications.map(({ ccvData }) => hexlify(ccvData)),
-        BigInt(opts.gasLimit ?? 0),
+        BigInt(gasLimit ?? 0),
       )
       execTx.gasLimit = txGasLimit + 40000n // plus `execute`'s overhead
       return { family: ChainFamily.EVM, transactions: [execTx] }
@@ -1190,7 +1200,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           interfaces.EVM2EVMOffRamp_v1_2,
           this.provider,
         ) as unknown as TypedContract<typeof EVM2EVMOffRamp_1_2_ABI>
-        const gasOverride = BigInt(opts.gasLimit ?? 0)
+        const gasOverride = BigInt(gasLimit ?? 0)
         manualExecTx = await contract.manuallyExecute.populateTransaction(
           {
             ...input,
@@ -1217,9 +1227,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           },
           [
             {
-              receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
+              receiverExecutionGasLimit: BigInt(gasLimit ?? 0),
               tokenGasOverrides: input.message.tokenAmounts.map(() =>
-                BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
+                BigInt(opts.tokensGasLimit ?? gasLimit ?? 0),
               ),
             },
           ],
@@ -1272,9 +1282,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           [
             [
               {
-                receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
+                receiverExecutionGasLimit: BigInt(gasLimit ?? 0),
                 tokenGasOverrides: input.message.tokenAmounts.map(() =>
-                  BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
+                  BigInt(opts.tokensGasLimit ?? gasLimit ?? 0),
                 ),
               },
             ],
@@ -1288,27 +1298,27 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
 
     /* 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)
+    let txGasLimit = await this.provider.estimateGas(manualExecTx)
     if (
       'gasLimit' in input.message &&
       input.message.gasLimit &&
-      gasLimit < input.message.gasLimit + 100000n
+      txGasLimit < 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)
+      txGasLimit = BigInt(input.message.gasLimit) + 200000n
+    else if ('gasLimit' in input.message && !input.message.gasLimit && txGasLimit < 240000n)
       // if message didn't request gasLimit, ensure execution gasLimit is above 240k (empiric)
-      gasLimit = 240000n
-    manualExecTx.gasLimit = gasLimit
+      txGasLimit = 240000n
+    manualExecTx.gasLimit = txGasLimit
 
     return { family: ChainFamily.EVM, transactions: [manualExecTx] }
   }
 
   /**
    * {@inheritDoc Chain.execute}
-   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Signer
-   * @throws {@link CCIPExecTxNotConfirmedError} if execution transaction fails to confirm
-   * @throws {@link CCIPExecTxRevertedError} if execution transaction reverts
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Signer.
+   * @throws {@link CCIPExecTxNotConfirmedError} if execution transaction fails to confirm.
+   * @throws {@link CCIPExecTxRevertedError} if execution transaction reverts.
    */
   async execute(opts: Parameters<Chain['execute']>[0]) {
     const wallet = opts.wallet
@@ -1399,7 +1409,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     }
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfig} */
+  /**
+   * Fetches the token pool configuration for an EVM token pool contract.
+   *
+   * @param tokenPool - Token pool contract address.
+   * @returns Token pool config containing token, router, typeAndVersion, and optionally minBlockConfirmations.
+   *
+   * @remarks
+   * For pools with version \>= 2.0, also returns `minBlockConfirmations` for
+   * Faster-Than-Finality (FTF) support. Pre-2.0 pools omit this field.
+   */
   async getTokenPoolConfig(tokenPool: string): Promise<{
     token: string
     router: string
@@ -1444,7 +1463,22 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     )
   }
 
-  /** {@inheritDoc Chain.getTokenPoolRemotes} */
+  /**
+   * Fetches remote chain configurations for an EVM token pool contract.
+   *
+   * @param tokenPool - Token pool address on the current chain.
+   * @param remoteChainSelector - Optional chain selector to filter results to a single destination.
+   * @returns Record mapping chain names to {@link TokenPoolRemote} configs.
+   *
+   * @remarks
+   * Handles 3 pool version branches:
+   * - v1.5: single remote pool via `getRemotePool`, standard rate limiters.
+   * - v1.6: multiple remote pools via `getRemotePools`, standard rate limiters.
+   * - v2.0+: multiple remote pools plus FTF (Faster-Than-Finality) rate limiters
+   *   (`customBlockConfirmationsOutboundRateLimiterState` / `customBlockConfirmationsInboundRateLimiterState`).
+   *
+   * @throws {@link CCIPTokenPoolChainConfigNotFoundError} if remote token is not configured for a chain.
+   */
   async getTokenPoolRemotes(
     tokenPool: string,
     remoteChainSelector?: bigint,
@@ -1729,10 +1763,76 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   override async estimateReceiveExecution(
     opts: Parameters<NonNullable<Chain['estimateReceiveExecution']>>[0],
   ): Promise<number> {
+    const convertAmounts = (
+      tokenAmounts?: readonly ((
+        | { token: string }
+        | { destTokenAddress: string; extraData?: string }
+      ) & {
+        amount: bigint
+      })[],
+    ) =>
+      !tokenAmounts
+        ? undefined
+        : Promise.all(
+            tokenAmounts.map(async (ta) => {
+              if (!('destTokenAddress' in ta)) return ta
+              let amount = ta.amount
+              if (isHexString(ta.extraData, 32)) {
+                // extraData is source token decimals in most pools derived from standard TP contracts;
+                // we can identify for it being exactly 32B and being a small integer; otherwise, assume same decimals
+                const sourceDecimals = toBigInt(ta.extraData)
+                if (0 < sourceDecimals && sourceDecimals <= 36) {
+                  const { decimals: destDecimals } = await this.getTokenInfo(ta.destTokenAddress)
+                  amount =
+                    (amount * BigInt(10) ** BigInt(destDecimals)) /
+                    BigInt(10) ** BigInt(sourceDecimals)
+                  if (amount === 0n)
+                    throw new CCIPTokenDecimalsInsufficientError(
+                      ta.destTokenAddress,
+                      destDecimals,
+                      this.network.name,
+                      formatUnits(amount, sourceDecimals),
+                    )
+                }
+              }
+              return { token: ta.destTokenAddress, amount }
+            }),
+          )
+
+    let opts_
+    if (!('offRamp' in opts)) {
+      const { lane, message, metadata } = await this.getMessageById(opts.messageId)
+
+      const offRamp =
+        ('offRampAddress' in message && message.offRampAddress) ||
+        metadata?.offRamp ||
+        (await this.apiClient!.getExecutionInput(opts.messageId)).offRamp
+
+      opts_ = {
+        offRamp,
+        message: {
+          sourceChainSelector: lane.sourceChainSelector,
+          messageId: message.messageId,
+          receiver: message.receiver,
+          sender: message.sender,
+          data: message.data,
+          destTokenAmounts: await convertAmounts(message.tokenAmounts),
+        },
+      }
+    } else {
+      opts_ = {
+        ...opts,
+        message: {
+          ...opts.message,
+          destTokenAmounts: await convertAmounts(opts.message.destTokenAmounts),
+        },
+      }
+    }
+
     const destRouter = await this.getRouterForOffRamp(
-      opts.offRamp,
-      opts.message.sourceChainSelector,
+      opts_.offRamp,
+      opts_.message.sourceChainSelector,
     )
-    return estimateExecGas({ provider: this.provider, router: destRouter, ...opts })
+    return estimateExecGas({ provider: this.provider, router: destRouter, ...opts_ })
   }
 }

package/src/extra-args.ts

@@ -68,7 +68,7 @@ export type EVMExtraArgsV2 = EVMExtraArgsV1 & {
 export type GenericExtraArgsV3 = {
   /** Gas limit for execution on the destination chain (uint32). */
   gasLimit: bigint
-  /** Number of block confirmations required. */
+  /** Number of source-chain block confirmations to wait before relaying the message. */
   blockConfirmations: number
   /** Cross-chain verifier addresses (EVM addresses). */
   ccvs: string[]
@@ -132,7 +132,17 @@ export type SuiExtraArgsV1 = EVMExtraArgsV2 & {
 }
 
 /**
- * Union type of all supported extra arguments formats.
+ * Union of all supported extra arguments formats for CCIP messages.
+ *
+ * The SDK auto-detects the correct variant based on the fields provided:
+ * - {@link EVMExtraArgsV1} - EVM legacy (gasLimit only)
+ * - {@link EVMExtraArgsV2} - EVM with out-of-order execution support
+ * - {@link GenericExtraArgsV3} - Generic V3 with minimum block confirmations, cross-chain verifiers, custom executor, and per-token receiver/args
+ * - {@link SVMExtraArgsV1} - Solana (compute units, accounts)
+ * - {@link SuiExtraArgsV1} - Sui (gas limit, receiver object IDs)
+ *
+ * @see {@link encodeExtraArgs} - Encode extra arguments for on-chain use.
+ * @see {@link decodeExtraArgs} - Decode extra arguments from bytes.
  */
 export type ExtraArgs =
   | EVMExtraArgsV1
@@ -146,10 +156,10 @@ export type ExtraArgs =
  * The args are *to* a dest network, but are encoded as a message *from* this source chain.
  * E.g. Solana uses Borsh to encode extraArgs in its produced requests, even those targeting EVM.
  *
- * @param args - Extra arguments to encode
- * @param from - Source chain family for encoding format (defaults to EVM)
- * @returns Encoded extra arguments as hex string
- * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported
+ * @param args - Extra arguments to encode.
+ * @param from - Source chain family for encoding format (defaults to EVM).
+ * @returns Encoded extra arguments as hex string.
+ * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported.
  *
  * @example
  * ```typescript
@@ -175,8 +185,8 @@ export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily
  * @param data - Extra arguments bytearray data.
  * @param from - Optional chain family to narrow decoding attempts.
  * @returns Extra arguments object if found, undefined otherwise.
- * @throws {@link CCIPChainFamilyUnsupportedError} if specified chain family not supported
- * @throws {@link CCIPExtraArgsParseError} if data cannot be parsed as valid extra args
+ * @throws {@link CCIPChainFamilyUnsupportedError} if specified chain family not supported.
+ * @throws {@link CCIPExtraArgsParseError} if data cannot be parsed as valid extra args.
  *
  * @example
  * ```typescript

package/src/gas.ts

@@ -28,7 +28,7 @@ export type EstimateMessageInput = {
   data?: BytesLike
   /**
    * optional tokenAmounts; `amount` with either source `token` (as in MessageInput) or
-   * `{ sourceTokenAddress?, sourcePoolAddress, destTokenAddress }` (as in v1.5..v1.7 tokenAmounts)
+   * `{ sourceTokenAddress?, sourcePoolAddress, destTokenAddress }` (as in v1.5..v2.0 tokenAmounts)
    * can be provided
    */
   tokenAmounts?: readonly ({
@@ -122,7 +122,12 @@ export async function estimateReceiveExecution({
       const tokenAmount =
         'destTokenAddress' in ta
           ? ta
-          : await sourceToDestTokenAddresses(source, dest.network.chainSelector, onRamp, ta)
+          : await sourceToDestTokenAddresses({
+              source,
+              onRamp,
+              destChainSelector: dest.network.chainSelector,
+              sourceTokenAmount: ta,
+            })
       const sourceTokenAddress =
         'token' in ta
           ? ta.token
@@ -147,10 +152,10 @@ export async function estimateReceiveExecution({
     }),
   )
   return dest.estimateReceiveExecution({
-    receiver: message.receiver,
     offRamp,
     message: {
       messageId: message.messageId ?? hexlify(randomBytes(32)),
+      receiver: message.receiver,
       sender: message.sender,
       data: message.data,
       sourceChainSelector: source.network.chainSelector,

package/src/index.ts

@@ -12,6 +12,9 @@ export type {
   APIErrorResponse,
   CCIPAPIClientContext,
   LaneLatencyResponse,
+  MessageSearchFilters,
+  MessageSearchPage,
+  MessageSearchResult,
 } from './api/index.ts'
 export {
   CCIPAPIClient,
@@ -41,6 +44,7 @@ export {
   type EVMExtraArgsV1,
   type EVMExtraArgsV2,
   type ExtraArgs,
+  type GenericExtraArgsV3,
   type SVMExtraArgsV1,
   type SuiExtraArgsV1,
   decodeExtraArgs,

package/src/requests.ts

@@ -89,9 +89,9 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     k?.match(/(selector|amount|nonce|number|limit|bitmap|juels)$/i)
       ? BigInt(v as string | number | bigint)
       : k?.match(/(^dest.*address)|(receiver|offramp|accounts)/i)
-        ? decodeAddress(v as BytesLike, destFamily)
+        ? decodeAddress((typeof v === 'bigint' ? v.toString() : v) as BytesLike, destFamily)
         : k?.match(/((source.*address)|sender|issuer|origin|onramp|(feetoken$)|(token.*address$))/i)
-          ? decodeAddress(v as BytesLike, sourceFamily)
+          ? decodeAddress((typeof v === 'bigint' ? v.toString() : v) as BytesLike, sourceFamily)
           : v instanceof Uint8Array ||
               (Array.isArray(v) && v.length >= 4 && v.every((e) => typeof e === 'number'))
             ? hexlify(getDataBytes(v as readonly number[]))
@@ -456,10 +456,7 @@ export async function* getMessagesForSender(
  * Resolves token routing by querying the TokenAdminRegistry and TokenPool
  * to find the corresponding destination chain token.
  *
- * @param source - Source chain instance
- * @param destChainSelector - Destination chain selector
- * @param onRamp - OnRamp contract address
- * @param sourceTokenAmount - Token amount object containing `token` and `amount`
+ * @param opts - options to convert source to dest token addresses
  * @returns Extended token amount with `sourcePoolAddress`, `sourceTokenAddress`, and `destTokenAddress`
  *
  * @throws {@link CCIPTokenNotInRegistryError} if token is not registered in TokenAdminRegistry
@@ -479,12 +476,21 @@ export async function* getMessagesForSender(
  * console.log(`Dest token: ${tokenAmount.destTokenAddress}`)
  * ```
  */
-export async function sourceToDestTokenAddresses<S extends { token: string }>(
-  source: Chain,
-  destChainSelector: bigint,
-  onRamp: string,
-  sourceTokenAmount: S,
-): Promise<
+export async function sourceToDestTokenAddresses<S extends { token: string }>({
+  source,
+  onRamp,
+  destChainSelector,
+  sourceTokenAmount,
+}: {
+  /** Source chain instance */
+  source: Chain
+  /** OnRamp contract address */
+  onRamp: string
+  /** Destination chain selector */
+  destChainSelector: bigint
+  /** Token amount object containing `token` and `amount` */
+  sourceTokenAmount: S
+}): Promise<
   S & {
     sourcePoolAddress: string
     sourceTokenAddress: string

package/src/solana/utils.ts

@@ -27,7 +27,7 @@ import {
   CCIPTransactionNotFinalizedError,
 } from '../errors/index.ts'
 import type { ChainLog, WithLogger } from '../types.ts'
-import { getDataBytes, sleep } from '../utils.ts'
+import { bigIntReplacer, getDataBytes, sleep } from '../utils.ts'
 import type { IDL as BASE_TOKEN_POOL_IDL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import type { UnsignedSolanaTx, Wallet } from './types.ts'
 import type { RateLimiterState } from '../chain.ts'
@@ -347,7 +347,7 @@ export async function simulateTransaction(
     throw new SendTransactionError({
       action: 'simulate',
       signature: '',
-      transactionMessage: JSON.stringify(result.value.err),
+      transactionMessage: JSON.stringify(result.value.err, bigIntReplacer),
       logs: result.value.logs!,
     })
   }

package/src/ton/index.ts

@@ -3,7 +3,18 @@ import { Buffer } from 'buffer'
 import { type Transaction, Address, Cell, beginCell, toNano } from '@ton/core'
 import { TonClient } from '@ton/ton'
 import { type AxiosAdapter, getAdapter } from 'axios'
-import { type BytesLike, hexlify, isBytesLike, isHexString, toBeArray, toBeHex } from 'ethers'
+import {
+  type BytesLike,
+  concat,
+  dataLength,
+  dataSlice,
+  hexlify,
+  isBytesLike,
+  isHexString,
+  toBeArray,
+  toBeHex,
+  toBigInt,
+} from 'ethers'
 import { type Memoized, memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
@@ -45,6 +56,7 @@ import {
   bytesToBuffer,
   createRateLimitedFetch,
   decodeAddress,
+  getDataBytes,
   networkInfo,
   parseTypeAndVersion,
   sleep,
@@ -64,6 +76,16 @@ function isTvmError(error: unknown): error is Error & { exitCode: number } {
   return error instanceof Error && 'exitCode' in error && typeof error.exitCode === 'number'
 }
 
+function bitsToBytes(bits: string): Uint8Array {
+  return Uint8Array.from(bits.match(/.{1,8}/g)!.map((byte) => parseInt(byte.padEnd(8, '0'), 2)))
+}
+
+function bytesToBits(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((B) => B.toString(2).padStart(8, '0'))
+    .join('')
+}
+
 /**
  * TON chain implementation supporting TON networks.
  *
@@ -702,14 +724,14 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    */
   static encodeExtraArgs(args: ExtraArgs): string {
     if ('gasLimit' in args && 'allowOutOfOrderExecution' in args) {
-      const cell = beginCell()
-        .storeUint(Number(EVMExtraArgsV2Tag), 32) // magic tag
-        .storeUint(args.gasLimit, 256) // gasLimit
-        .storeBit(args.allowOutOfOrderExecution) // bool
-        .endCell()
-
-      // Return full BOC including headers
-      return '0x' + cell.toBoc().toString('hex')
+      return concat([
+        EVMExtraArgsV2Tag,
+        bitsToBytes(
+          '1' +
+            bytesToBits(toBeArray(args.gasLimit, 32)) +
+            (args.allowOutOfOrderExecution ? '1' : '0'),
+        ),
+      ])
     }
     return '0x'
   }
@@ -729,25 +751,24 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   static decodeExtraArgs(
     extraArgs: BytesLike,
   ): (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' }) | undefined {
-    const data = bytesToBuffer(extraArgs)
-
-    try {
-      // Parse BOC format to extract cell data
-      const cell = Cell.fromBoc(data)[0]!
-      const slice = cell.beginParse()
+    if (dataSlice(extraArgs, 0, 4) !== EVMExtraArgsV2Tag || dataLength(extraArgs) < 5) return
+    const data = getDataBytes(extraArgs).subarray(4)
+    let bits = bytesToBits(data)
+    let gasLimit = 0n
+    if (bits[0] === '1') {
+      if (bits.length < 1 + 32 * 8) return
+      gasLimit = toBigInt(bitsToBytes(bits.substring(1, 1 + 32 * 8)))
+      bits = bits.substring(1 + 32 * 8)
+    } else {
+      bits = bits.substring(1)
+    }
 
-      // Load and verify magic tag to ensure correct extra args type
-      const magicTag = slice.loadUint(32)
-      if (magicTag !== Number(EVMExtraArgsV2Tag)) return undefined
+    const allowOutOfOrderExecution = bits[0] === '1'
 
-      return {
-        _tag: 'EVMExtraArgsV2',
-        gasLimit: slice.loadUintBig(256),
-        allowOutOfOrderExecution: slice.loadBit(),
-      }
-    } catch {
-      // Return undefined for any parsing errors (invalid BOC, malformed data, etc.)
-      return undefined
+    return {
+      _tag: 'EVMExtraArgsV2',
+      gasLimit,
+      allowOutOfOrderExecution,
     }
   }
 

package/src/utils.ts

@@ -190,10 +190,16 @@ export const networkInfo = memoize(function networkInfo_(
 
 const BLOCK_RANGE = 10_000
 /**
- * Generates exclusive block ranges [fromBlock, toBlock]
- * If startBlock is given, moves forward from there (up to latestBlock),
- * Otherwise, moves backwards down to genesis (you probably want to break/return before that)
- **/
+ * Generates block ranges for paginated log queries.
+ *
+ * @param params - Range parameters:
+ *   - `singleBlock` - yields a single `{ fromBlock, toBlock }` for that block.
+ *   - `endBlock` + optional `startBlock` - if `startBlock` is given, moves forward
+ *     from there up to `endBlock`; otherwise moves backward from `endBlock` to genesis.
+ *   - `page` - step size per range (default 10 000).
+ * @returns Generator of `{ fromBlock, toBlock }` pairs, optionally with a `progress` percentage
+ *   string when iterating forward.
+ */
 export function* blockRangeGenerator(
   params: { page?: number } & ({ endBlock: number; startBlock?: number } | { singleBlock: number }),
 ) {