@chainlink/ccip-sdk 0.96.0 → 0.97.0

package/dist/evm/index.js

@@ -1,44 +1,27 @@
-import { parseAbi } from 'abitype';
-import { Contract, JsonRpcProvider, Result, WebSocketProvider, ZeroAddress, getAddress, hexlify, isBytesLike, isHexString, toBeHex, toBigInt, zeroPadValue, } from 'ethers';
+import { Contract, JsonRpcProvider, WebSocketProvider, ZeroAddress, getAddress, hexlify, isBytesLike, isHexString, keccak256, toBeHex, zeroPadValue, } from 'ethers';
 import { memoize } from 'micro-memoize';
 import { Chain, } from "../chain.js";
-import { CCIPAddressInvalidEvmError, CCIPBlockNotFoundError, CCIPContractNotRouterError, CCIPContractTypeInvalidError, CCIPDataFormatUnsupportedError, CCIPExecTxNotConfirmedError, CCIPExecTxRevertedError, CCIPExtraArgsParseError, CCIPHasherVersionUnsupportedError, CCIPLogDataInvalidError, CCIPMessageDecodeError, CCIPSourceChainUnsupportedError, CCIPTokenNotConfiguredError, CCIPTokenPoolChainConfigNotFoundError, CCIPTransactionNotFoundError, CCIPVersionFeatureUnavailableError, CCIPVersionRequiresLaneError, CCIPVersionUnsupportedError, CCIPWalletInvalidError, } from "../errors/index.js";
+import { CCIPAddressInvalidEvmError, CCIPApiClientNotAvailableError, CCIPBlockNotFoundError, CCIPContractNotRouterError, CCIPContractTypeInvalidError, CCIPDataFormatUnsupportedError, CCIPExecTxNotConfirmedError, CCIPExecTxRevertedError, CCIPHasherVersionUnsupportedError, CCIPLogDataInvalidError, CCIPNotImplementedError, CCIPSourceChainUnsupportedError, CCIPTokenNotConfiguredError, CCIPTokenPoolChainConfigNotFoundError, CCIPTransactionNotFoundError, CCIPVersionFeatureUnavailableError, CCIPVersionRequiresLaneError, CCIPVersionUnsupportedError, CCIPWalletInvalidError, } from "../errors/index.js";
 import { supportedChains } from "../supported-chains.js";
 import { CCIPVersion, ChainFamily, NetworkType, } from "../types.js";
 import { decodeAddress, decodeOnRampAddress, getAddressBytes, getDataBytes, networkInfo, parseTypeAndVersion, } from "../utils.js";
 import EVM2EVMOffRamp_1_2_ABI from "./abi/OffRamp_1_2.js";
 import EVM2EVMOffRamp_1_5_ABI from "./abi/OffRamp_1_5.js";
 import OffRamp_1_6_ABI from "./abi/OffRamp_1_6.js";
+import OffRamp_2_0_ABI from "./abi/OffRamp_2_0.js";
 import EVM2EVMOnRamp_1_2_ABI from "./abi/OnRamp_1_2.js";
 import EVM2EVMOnRamp_1_5_ABI from "./abi/OnRamp_1_5.js";
-import OnRamp_1_6_ABI from "./abi/OnRamp_1_6.js";
-import { commitsFragments, interfaces, receiptsFragments, requestsFragments } from "./const.js";
+import { CCV_INDEXER_URL, VersionedContractABI, commitsFragments, interfaces, receiptsFragments, requestsFragments, } from "./const.js";
 import { parseData } from "./errors.js";
 import { decodeExtraArgs as decodeExtraArgs_, encodeExtraArgs as encodeExtraArgs_, } from "./extra-args.js";
 import { estimateExecGas } from "./gas.js";
 import { getV12LeafHasher, getV16LeafHasher } from "./hasher.js";
 import { getEvmLogs } from "./logs.js";
-import { parseSourceTokenData, } from "./messages.js";
+import { decodeMessageV1, } from "./messages.js";
+export { decodeMessageV1 };
 import { encodeEVMOffchainTokenData, fetchEVMOffchainTokenData } from "./offchain.js";
-import { buildMessageForDest, getMessagesInBatch } from "../requests.js";
-const VersionedContractABI = parseAbi(['function typeAndVersion() view returns (string)']);
-function resultToObject(o) {
-    if (o instanceof Promise)
-        return o.then(resultToObject);
-    if (!(o instanceof Result))
-        return o;
-    if (o.length === 0)
-        return o.toArray();
-    try {
-        const obj = o.toObject();
-        if (!Object.keys(obj).every((k) => /^_+\d*$/.test(k)))
-            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, resultToObject(v)]));
-    }
-    catch (_) {
-        // fallthrough
-    }
-    return o.toArray().map(resultToObject);
-}
+import { buildMessageForDest, decodeMessage, getMessagesInBatch } from "../requests.js";
+import { resultToObject } from "./types.js";
 /** typeguard for ethers Signer interface (used for `wallet`s)  */
 function isSigner(wallet) {
     return (typeof wallet === 'object' &&
@@ -62,6 +45,26 @@ async function submitTransaction(wallet, tx, provider) {
 }
 /**
  * EVM chain implementation supporting Ethereum-compatible networks.
+ *
+ * Provides methods for sending CCIP cross-chain messages, querying message
+ * status, fetching fee quotes, and manually executing pending messages on
+ * Ethereum Virtual Machine compatible chains.
+ *
+ * @example Create from RPC URL
+ * ```typescript
+ * import { EVMChain } from '@chainlink/ccip-sdk'
+ *
+ * const chain = await EVMChain.fromUrl('https://rpc.sepolia.org')
+ * console.log(`Connected to: ${chain.network.name}`)
+ * ```
+ *
+ * @example Query messages in a transaction
+ * ```typescript
+ * const requests = await chain.getMessagesInTx('0xabc123...')
+ * for (const req of requests) {
+ *   console.log(`Message ID: ${req.message.messageId}`)
+ * }
+ * ```
  */
 export class EVMChain extends Chain {
     static {
@@ -71,6 +74,13 @@ export class EVMChain extends Chain {
     static decimals = 18;
     provider;
     destroy$;
+    noncesPromises;
+    /**
+     * Cache of current nonces per wallet address.
+     * Used internally by {@link sendMessage} and {@link execute} to manage transaction ordering.
+     * Can be inspected for debugging or manually adjusted if needed.
+     */
+    nonces;
     /**
      * Creates a new EVMChain instance.
      * @param provider - JSON-RPC provider for the EVM network.
@@ -78,6 +88,8 @@ export class EVMChain extends Chain {
      */
     constructor(provider, network, ctx) {
         super(network, ctx);
+        this.noncesPromises = {};
+        this.nonces = {};
         this.provider = provider;
         this.destroy$ = new Promise((resolve) => (this.destroy = resolve));
         void this.destroy$.finally(() => provider.destroy());
@@ -112,6 +124,21 @@ export class EVMChain extends Chain {
     async listAccounts() {
         return (await this.provider.listAccounts()).map(({ address }) => address);
     }
+    /**
+     * Get the next nonce for a wallet address and increment the internal counter.
+     * Fetches from the network on first call, then uses cached value.
+     * @param address - Wallet address to get nonce for
+     * @returns The next available nonce
+     */
+    async nextNonce(address) {
+        await (this.noncesPromises[address] ??= this.provider
+            .getTransactionCount(address)
+            .then((nonce) => {
+            this.nonces[address] = nonce;
+            return nonce;
+        }));
+        return this.nonces[address]++;
+    }
     /**
      * Creates a JSON-RPC provider from a URL.
      * @param url - WebSocket (wss://) or HTTP (https://) endpoint URL.
@@ -157,9 +184,20 @@ export class EVMChain extends Chain {
     }
     /**
      * Creates an EVMChain instance from an RPC URL.
+     *
      * @param url - WebSocket (wss://) or HTTP (https://) endpoint URL.
-     * @param ctx - context containing logger.
-     * @returns A new EVMChain instance.
+     * @param ctx - Optional context containing logger and API client configuration.
+     * @returns A new EVMChain instance connected to the specified network.
+     * @throws {@link CCIPChainNotFoundError} if chain cannot be identified from chainId
+     *
+     * @example
+     * ```typescript
+     * // HTTP connection
+     * const chain = await EVMChain.fromUrl('https://rpc.sepolia.org')
+     *
+     * // With custom logger
+     * const chain = await EVMChain.fromUrl(url, { logger: customLogger })
+     * ```
      */
     static async fromUrl(url, ctx) {
         return this.fromProvider(await this._getProvider(url), ctx);
@@ -193,7 +231,7 @@ export class EVMChain extends Chain {
         yield* getEvmLogs(filter, this);
     }
     /** {@inheritDoc Chain.getMessagesInBatch} */
-    getMessagesInBatch(request, commit, opts) {
+    getMessagesInBatch(request, range, opts) {
         let opts_;
         if (request.lane.version >= CCIPVersion.V1_6) {
             // specialized getLogs filter for v1.6 CCIPMessageSent events, to filter by dest
@@ -202,12 +240,15 @@ export class EVMChain extends Chain {
                 topics: [[request.log.topics[0]], [toBeHex(request.lane.destChainSelector, 32)]],
             };
         }
-        return getMessagesInBatch(this, request, commit, opts_);
+        return getMessagesInBatch(this, request, range, opts_);
     }
     /** {@inheritDoc Chain.typeAndVersion} */
     async typeAndVersion(address) {
         const contract = new Contract(address, VersionedContractABI, this.provider);
-        return parseTypeAndVersion(await contract.typeAndVersion());
+        const res = parseTypeAndVersion(await contract.typeAndVersion());
+        if (res[1].startsWith('1.7.'))
+            res[1] = CCIPVersion.V2_0;
+        return res;
     }
     /**
      * Decodes a CCIP message from a log event.
@@ -237,6 +278,9 @@ export class EVMChain extends Chain {
                 message = resultToObject(result);
                 if (message.message)
                     message = message.message;
+                else if (message.encodedMessage) {
+                    Object.assign(message, decodeMessageV1(message.encodedMessage));
+                }
                 if (message)
                     break;
             }
@@ -246,63 +290,7 @@ export class EVMChain extends Chain {
         }
         if (!message)
             return;
-        if (!isHexString(message.sender, 20))
-            throw new CCIPMessageDecodeError('invalid sender');
-        if (message.header) {
-            // CCIPMessage_V1_6
-            Object.assign(message, message.header);
-            delete message.header;
-        }
-        const sourceFamily = networkInfo(message.sourceChainSelector).family;
-        let destFamily = ChainFamily.EVM;
-        if (message.destChainSelector) {
-            destFamily = networkInfo(message.destChainSelector).family;
-        }
-        // conversions to make any message version be compatible with latest v1.6
-        message.tokenAmounts = message.tokenAmounts.map((tokenAmount, i) => {
-            if ('sourceTokenData' in message) {
-                // CCIPMessage_V1_2_EVM
-                try {
-                    tokenAmount = {
-                        ...parseSourceTokenData(message.sourceTokenData[i]),
-                        ...tokenAmount,
-                    };
-                }
-                catch (_) {
-                    // legacy sourceTokenData
-                }
-            }
-            if (typeof tokenAmount.destExecData === 'string' && tokenAmount.destGasAmount == null) {
-                // CCIPMessage_V1_6_EVM
-                tokenAmount.destGasAmount = toBigInt(getDataBytes(tokenAmount.destExecData));
-            }
-            // Can be undefined if the message is from before v1.5 and failed to parse sourceTokenData
-            if (tokenAmount.sourcePoolAddress) {
-                tokenAmount.sourcePoolAddress = decodeAddress(tokenAmount.sourcePoolAddress, sourceFamily);
-            }
-            if (tokenAmount.destTokenAddress) {
-                tokenAmount.destTokenAddress = decodeAddress(tokenAmount.destTokenAddress, destFamily);
-            }
-            return tokenAmount;
-        });
-        message.sender = decodeAddress(message.sender, sourceFamily);
-        message.feeToken = decodeAddress(message.feeToken, sourceFamily);
-        message.receiver = decodeAddress(message.receiver, destFamily);
-        if (message.extraArgs) {
-            // v1.6+
-            const parsed = this.decodeExtraArgs(message.extraArgs);
-            if (!parsed)
-                throw new CCIPExtraArgsParseError(message.extraArgs);
-            const { _tag, ...rest } = parsed;
-            // merge parsed extraArgs to any family in message root object
-            Object.assign(message, rest);
-        }
-        else if (message.nonce === 0n) {
-            // v1.2..v1.5 targets EVM only; extraArgs is not explicit, gasLimit is already in
-            // message body, allowOutOfOrderExecution (in v1.5) was present only as nonce=0
-            message.allowOutOfOrderExecution = true;
-        }
-        return message;
+        return decodeMessage(message);
     }
     /**
      * Decodes commit reports from a log event.
@@ -481,11 +469,15 @@ export class EVMChain extends Chain {
                 return router;
             }
             case CCIPVersion.V1_6: {
-                onRampABI = OnRamp_1_6_ABI;
-                const contract = new Contract(onRamp, onRampABI, this.provider);
+                const contract = new Contract(onRamp, interfaces.OnRamp_v1_6, this.provider);
                 const [, , router] = await contract.getDestChainConfig(destChainSelector);
                 return router;
             }
+            case CCIPVersion.V2_0: {
+                const contract = new Contract(onRamp, interfaces.OnRamp_v2_0, this.provider);
+                const { router } = await contract.getDestChainConfig(destChainSelector);
+                return router;
+            }
             default:
                 throw new CCIPVersionUnsupportedError(version);
         }
@@ -507,8 +499,11 @@ export class EVMChain extends Chain {
                 ({ router } = await contract.getDynamicConfig());
                 break;
             }
-            case CCIPVersion.V1_6: {
+            case CCIPVersion.V1_6:
                 offRampABI = OffRamp_1_6_ABI;
+            // falls through
+            case CCIPVersion.V2_0: {
+                offRampABI = OffRamp_2_0_ABI;
                 const contract = new Contract(offRamp, offRampABI, this.provider);
                 ({ router } = await contract.getSourceChainConfig(sourceChainSelector));
                 break;
@@ -537,10 +532,10 @@ export class EVMChain extends Chain {
         return contract.getOnRamp(destChainSelector);
     }
     /**
-     * {@inheritDoc Chain.getOnRampForOffRamp}
+     * {@inheritDoc Chain.getOnRampsForOffRamp}
      * @throws {@link CCIPVersionUnsupportedError} if OffRamp version is not supported
      */
-    async getOnRampForOffRamp(offRamp, sourceChainSelector) {
+    async getOnRampsForOffRamp(offRamp, sourceChainSelector) {
         const [, version] = await this.typeAndVersion(offRamp);
         let offRampABI;
         switch (version) {
@@ -551,21 +546,41 @@ export class EVMChain extends Chain {
                 offRampABI ??= EVM2EVMOffRamp_1_5_ABI;
                 const contract = new Contract(offRamp, offRampABI, this.provider);
                 const { onRamp } = await contract.getStaticConfig();
-                return onRamp;
+                return [onRamp];
             }
             case CCIPVersion.V1_6: {
                 offRampABI = OffRamp_1_6_ABI;
                 const contract = new Contract(offRamp, offRampABI, this.provider);
                 const { onRamp } = await contract.getSourceChainConfig(sourceChainSelector);
-                return decodeOnRampAddress(onRamp, networkInfo(sourceChainSelector).family);
+                if (!onRamp || onRamp.match(/^(0x)?0*$/i))
+                    return [];
+                return [decodeOnRampAddress(onRamp, networkInfo(sourceChainSelector).family)];
+            }
+            case CCIPVersion.V2_0: {
+                offRampABI = OffRamp_2_0_ABI;
+                const contract = new Contract(offRamp, offRampABI, this.provider);
+                const { onRamps } = await contract.getSourceChainConfig(sourceChainSelector);
+                const sourceFamily = networkInfo(sourceChainSelector).family;
+                return onRamps.map((onRamp) => decodeOnRampAddress(onRamp, sourceFamily));
             }
             default:
                 throw new CCIPVersionUnsupportedError(version);
         }
     }
     /**
-     * {@inheritDoc Chain.getCommitStoreForOffRamp}
+     * Fetch the CommitStore set in OffRamp config (CCIP v1.5 and earlier).
+     * For CCIP v1.6 and later, it should return the offRamp address.
+     *
+     * @param offRamp - OffRamp contract address
+     * @returns Promise resolving to CommitStore address
+     *
+     * @example Get commit store
+     * ```typescript
+     * const commitStore = await dest.getCommitStoreForOffRamp(offRampAddress)
+     * // For v1.6+, commitStore === offRampAddress
+     * ```
      * @throws {@link CCIPVersionUnsupportedError} if OffRamp version is not supported
+     * @internal
      */
     async getCommitStoreForOffRamp(offRamp) {
         const [, version] = await this.typeAndVersion(offRamp);
@@ -580,11 +595,8 @@ export class EVMChain extends Chain {
                 const { commitStore } = await contract.getStaticConfig();
                 return commitStore;
             }
-            case CCIPVersion.V1_6: {
-                return offRamp;
-            }
             default:
-                throw new CCIPVersionUnsupportedError(version);
+                return offRamp;
         }
     }
     /** {@inheritDoc Chain.getTokenForTokenPool} */
@@ -771,85 +783,125 @@ export class EVMChain extends Chain {
         const approveTxs = txs.transactions.slice(0, txs.transactions.length - 1);
         let sendTx = txs.transactions[txs.transactions.length - 1];
         // approve all tokens (including feeToken, if needed) in parallel
-        let nonce = await this.provider.getTransactionCount(sender);
         const responses = await Promise.all(approveTxs.map(async (tx) => {
-            tx.nonce = nonce++;
-            tx = await wallet.populateTransaction(tx);
-            tx.from = undefined;
-            const response = await submitTransaction(wallet, tx, this.provider);
-            this.logger.debug('approve =>', response.hash);
-            return response;
+            tx.nonce = await this.nextNonce(sender);
+            try {
+                tx = await wallet.populateTransaction(tx);
+                tx.from = undefined;
+                const response = await submitTransaction(wallet, tx, this.provider);
+                this.logger.debug('approve =>', response.hash);
+                return response;
+            }
+            catch (err) {
+                this.nonces[sender]--;
+                throw err;
+            }
         }));
         if (responses.length)
             await responses[responses.length - 1].wait(1, 60_000); // wait last tx nonce to be mined
-        sendTx.nonce = nonce++;
-        // sendTx.gasLimit = await this.provider.estimateGas(sendTx)
-        sendTx = await wallet.populateTransaction(sendTx);
-        sendTx.from = undefined; // some signers don't like receiving pre-populated `from`
-        const response = await submitTransaction(wallet, sendTx, this.provider);
+        sendTx.nonce = await this.nextNonce(sender);
+        let response;
+        try {
+            // sendTx.gasLimit = await this.provider.estimateGas(sendTx)
+            sendTx = await wallet.populateTransaction(sendTx);
+            sendTx.from = undefined; // some signers don't like receiving pre-populated `from`
+            response = await submitTransaction(wallet, sendTx, this.provider);
+        }
+        catch (err) {
+            this.nonces[sender]--;
+            throw err;
+        }
         this.logger.debug('ccipSend =>', response.hash);
-        await response.wait(1, 60_000);
-        return (await this.getMessagesInTx(await this.getTransaction(response.hash)))[0];
+        const tx = (await response.wait(1, 60_000));
+        return (await this.getMessagesInTx(await this.getTransaction(tx)))[0];
     }
     /** {@inheritDoc Chain.getOffchainTokenData} */
     getOffchainTokenData(request) {
         return fetchEVMOffchainTokenData(request, this);
     }
     /**
-     * {@inheritDoc Chain.generateUnsignedExecuteReport}
+     * {@inheritDoc Chain.generateUnsignedExecute}
      * @returns array containing one unsigned `manuallyExecute` TransactionRequest object
      * @throws {@link CCIPVersionUnsupportedError} if OffRamp version is not supported
      */
-    async generateUnsignedExecuteReport({ offRamp, execReport, ...opts }) {
-        const [_, version] = await this.typeAndVersion(offRamp);
+    async generateUnsignedExecute(opts) {
+        let input, offRamp;
+        if (!('input' in opts)) {
+            if (!this.apiClient)
+                throw new CCIPApiClientNotAvailableError();
+            ({ offRamp, ...input } = await this.apiClient.getExecutionInput(opts.messageId));
+        }
+        else {
+            ;
+            ({ offRamp, input } = opts);
+        }
+        if ('verifications' in input) {
+            const contract = new Contract(offRamp, interfaces.OffRamp_v2_0, this.provider);
+            const message = decodeMessageV1(input.encodedMessage);
+            const messageId = keccak256(input.encodedMessage);
+            // `execute` doesn't revert on failure, so we need to estimate using `executeSingleMessage`
+            const txGasLimit = await contract.executeSingleMessage.estimateGas({
+                ...message,
+                executionGasLimit: BigInt(message.executionGasLimit),
+                ccipReceiveGasLimit: BigInt(message.ccipReceiveGasLimit),
+                finality: BigInt(message.finality),
+            }, messageId, input.verifications.map(({ destAddress }) => destAddress), input.verifications.map(({ ccvData }) => hexlify(ccvData)), BigInt(opts.gasLimit ?? 0), { from: offRamp });
+            const execTx = await contract.execute.populateTransaction(input.encodedMessage, input.verifications.map(({ destAddress }) => destAddress), input.verifications.map(({ ccvData }) => hexlify(ccvData)), BigInt(opts.gasLimit ?? 0));
+            execTx.gasLimit = txGasLimit + 40000n; // plus `execute`'s overhead
+            return { family: ChainFamily.EVM, transactions: [execTx] };
+        }
         let manualExecTx;
-        const offchainTokenData = execReport.offchainTokenData.map(encodeEVMOffchainTokenData);
+        const [_, version] = await this.typeAndVersion(offRamp);
+        const offchainTokenData = input.offchainTokenData.map(encodeEVMOffchainTokenData);
         switch (version) {
             case CCIPVersion.V1_2: {
-                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_2_ABI, this.provider);
+                const contract = new Contract(offRamp, interfaces.EVM2EVMOffRamp_v1_2, this.provider);
                 const gasOverride = BigInt(opts.gasLimit ?? 0);
                 manualExecTx = await contract.manuallyExecute.populateTransaction({
-                    ...execReport,
-                    proofs: execReport.proofs.map((d) => hexlify(d)),
-                    messages: [execReport.message],
+                    ...input,
+                    proofs: input.proofs.map((d) => hexlify(d)),
+                    messages: [input.message],
                     offchainTokenData: [offchainTokenData],
                 }, [gasOverride]);
                 break;
             }
             case CCIPVersion.V1_5: {
-                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_5_ABI, this.provider);
+                const contract = new Contract(offRamp, interfaces.EVM2EVMOffRamp_v1_5, this.provider);
                 manualExecTx = await contract.manuallyExecute.populateTransaction({
-                    ...execReport,
-                    proofs: execReport.proofs.map((d) => hexlify(d)),
-                    messages: [execReport.message],
+                    ...input,
+                    proofs: input.proofs.map((d) => hexlify(d)),
+                    messages: [input.message],
                     offchainTokenData: [offchainTokenData],
                 }, [
                     {
                         receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
-                        tokenGasOverrides: execReport.message.tokenAmounts.map(() => BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0)),
+                        tokenGasOverrides: input.message.tokenAmounts.map(() => BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0)),
                     },
                 ]);
                 break;
             }
             case CCIPVersion.V1_6: {
                 // normalize message
-                const sender = zeroPadValue(getAddressBytes(execReport.message.sender), 32);
-                const tokenAmounts = execReport.message.tokenAmounts.map((ta) => ({
+                const senderBytes = getAddressBytes(input.message.sender);
+                // Addresses ≤32 bytes (EVM 20B, Aptos/Solana/Sui 32B) are zero-padded to 32 bytes;
+                // Addresses >32 bytes (e.g., TON 36B) are used as raw bytes without padding
+                const sender = senderBytes.length <= 32 ? zeroPadValue(senderBytes, 32) : hexlify(senderBytes);
+                const tokenAmounts = input.message.tokenAmounts.map((ta) => ({
                     ...ta,
                     sourcePoolAddress: zeroPadValue(getAddressBytes(ta.sourcePoolAddress), 32),
                     extraData: hexlify(getDataBytes(ta.extraData)),
                 }));
                 const message = {
-                    ...execReport.message,
+                    ...input.message,
                     sender,
                     tokenAmounts,
                 };
-                const contract = new Contract(offRamp, OffRamp_1_6_ABI, this.provider);
+                const contract = new Contract(offRamp, interfaces.OffRamp_v1_6, this.provider);
                 manualExecTx = await contract.manuallyExecute.populateTransaction([
                     {
-                        ...execReport,
-                        proofs: execReport.proofs.map((p) => hexlify(p)),
-                        sourceChainSelector: execReport.message.sourceChainSelector,
+                        ...input,
+                        proofs: input.proofs.map((p) => hexlify(p)),
+                        sourceChainSelector: input.message.sourceChainSelector,
                         messages: [
                             {
                                 ...message,
@@ -868,7 +920,7 @@ export class EVMChain extends Chain {
                     [
                         {
                             receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
-                            tokenGasOverrides: execReport.message.tokenAmounts.map(() => BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0)),
+                            tokenGasOverrides: input.message.tokenAmounts.map(() => BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0)),
                         },
                     ],
                 ]);
@@ -880,22 +932,24 @@ export class EVMChain extends Chain {
         return { family: ChainFamily.EVM, transactions: [manualExecTx] };
     }
     /**
-     * {@inheritDoc Chain.executeReport}
+     * {@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
      */
-    async executeReport(opts) {
+    async execute(opts) {
         const wallet = opts.wallet;
         if (!isSigner(wallet))
             throw new CCIPWalletInvalidError(wallet);
-        const unsignedTxs = await this.generateUnsignedExecuteReport({
+        const unsignedTxs = await this.generateUnsignedExecute({
             ...opts,
             payer: await wallet.getAddress(),
         });
-        const unsignedTx = await wallet.populateTransaction(unsignedTxs.transactions[0]);
-        unsignedTx.from = undefined; // some signers don't like receiving pre-populated `from`
-        const response = await submitTransaction(wallet, unsignedTx, this.provider);
+        const unsignedTx = unsignedTxs.transactions[0];
+        unsignedTx.nonce = await this.nextNonce(await wallet.getAddress());
+        const populatedTx = await wallet.populateTransaction(unsignedTx);
+        populatedTx.from = undefined; // some signers don't like receiving pre-populated `from`
+        const response = await submitTransaction(wallet, populatedTx, this.provider);
         this.logger.debug('manuallyExecute =>', response.hash);
         const receipt = await response.wait(1, 60_000);
         if (!receipt?.hash)
@@ -1046,6 +1100,48 @@ export class EVMChain extends Chain {
         }
         return Object.fromEntries(await Promise.all(tokens.map(async (token) => [token, await this.getTokenInfo(token)])));
     }
+    /** {@inheritDoc Chain.getVerifications} */
+    async getVerifications(opts) {
+        const { offRamp, request } = opts;
+        if (request.lane.version >= CCIPVersion.V2_0) {
+            const message = request.message;
+            if (!message.encodedMessage)
+                throw new CCIPNotImplementedError(`CCIPAPIClient getMessageById v2 encodedMessage`);
+            const contract = new Contract(offRamp, interfaces.OffRamp_v2_0, this.provider);
+            const ccvs = await contract.getCCVsForMessage(message.encodedMessage);
+            const [requiredCCVs, optionalCCVs, optionalThreshold] = ccvs.map(resultToObject);
+            const verificationPolicy = {
+                requiredCCVs,
+                optionalCCVs,
+                optionalThreshold: Number(optionalThreshold),
+            };
+            if (this.apiClient) {
+                const apiRes = await this.apiClient.getMessageById(request.message.messageId);
+                if ('verifiers' in apiRes.message) {
+                    const verifiers = apiRes.message.verifiers;
+                    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,
+                        })),
+                    };
+                }
+            }
+            const url = `${CCV_INDEXER_URL}/v1/verifierresults/${request.message.messageId}`;
+            const res = await fetch(url);
+            const json = await res.json();
+            return json;
+        }
+        else if (request.lane.version < CCIPVersion.V1_6) {
+            // v1.2..v1.5 EVM (only) have separate CommitStore
+            opts.offRamp = await this.getCommitStoreForOffRamp(opts.offRamp);
+        }
+        // fallback <=v1.6
+        return super.getVerifications(opts);
+    }
     /** {@inheritDoc Chain.getExecutionReceipts} */
     async *getExecutionReceipts(opts) {
         const { messageId, sourceChainSelector } = opts;
@@ -1063,10 +1159,13 @@ export class EVMChain extends Chain {
             };
         }
         else /* >= V1.6 */ {
+            const topicHash = version === CCIPVersion.V1_6
+                ? interfaces.OffRamp_v1_6.getEvent('ExecutionStateChanged').topicHash
+                : interfaces.OffRamp_v2_0.getEvent('ExecutionStateChanged').topicHash;
             opts_ = {
                 ...opts,
                 topics: [
-                    interfaces.OffRamp_v1_6.getEvent('ExecutionStateChanged').topicHash,
+                    topicHash,
                     sourceChainSelector ? toBeHex(sourceChainSelector, 32) : null,
                     null,
                     messageId ?? null,