@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/dist/evm/index.js

@@ -1,23 +1,24 @@
-import util from 'util';
 import { parseAbi } from 'abitype';
-import { AbstractSigner, BaseWallet, Contract, JsonRpcProvider, Result, SigningKey, WebSocketProvider, ZeroAddress, concat, dataSlice, encodeBase58, getAddress, getBytes, hexlify, isBytesLike, isHexString, toBigInt, zeroPadValue, } from 'ethers';
-import moize, {} from 'moize';
-import { Chain, ChainFamily, } from "../chain.js";
+import { Contract, JsonRpcProvider, Result, WebSocketProvider, ZeroAddress, concat, dataSlice, encodeBase58, getAddress, getBytes, hexlify, isBytesLike, isHexString, toBeHex, toBigInt, zeroPadValue, } from 'ethers';
+import { memoize } from 'micro-memoize';
+import { Chain } from "../chain.js";
 import { EVMExtraArgsV1Tag, EVMExtraArgsV2Tag, SVMExtraArgsV1Tag, SuiExtraArgsV1Tag, } from "../extra-args.js";
 import { supportedChains } from "../supported-chains.js";
-import { CCIPVersion, } from "../types.js";
-import { blockRangeGenerator, decodeAddress, decodeOnRampAddress, getAddressBytes, getDataBytes, getSomeBlockNumberBefore, networkInfo, parseTypeAndVersion, } from "../utils.js";
+import { CCIPVersion, ChainFamily, } from "../types.js";
+import { decodeAddress, decodeOnRampAddress, getAddressBytes, getDataBytes, networkInfo, parseTypeAndVersion, util, } 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 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 { DEFAULT_APPROVE_GAS_LIMIT, DEFAULT_GAS_LIMIT, commitsFragments, defaultAbiCoder, getAllFragmentsMatchingEvents, interfaces, receiptsFragments, requestsFragments, } from "./const.js";
+import { DEFAULT_GAS_LIMIT, commitsFragments, defaultAbiCoder, interfaces, receiptsFragments, requestsFragments, } from "./const.js";
 import { parseData } from "./errors.js";
 import { getV12LeafHasher, getV16LeafHasher } from "./hasher.js";
+import { getEvmLogs } from "./logs.js";
 import { parseSourceTokenData, } from "./messages.js";
 import { encodeEVMOffchainTokenData, fetchEVMOffchainTokenData } from "./offchain.js";
+import { fetchAllMessagesInBatch, fetchCCIPRequestById, fetchCCIPRequestsInTx, } from "../requests.js";
 const VersionedContractABI = parseAbi(['function typeAndVersion() view returns (string)']);
 const EVMExtraArgsV1 = 'tuple(uint256 gasLimit)';
 const EVMExtraArgsV2 = 'tuple(uint256 gasLimit, bool allowOutOfOrderExecution)';
@@ -42,68 +43,58 @@ function resultsToMessage(result) {
         ...(result.header ? { header: result.header.toObject() } : {}),
     };
 }
+/** typeguard for ethers Signer interface (used for `wallet`s)  */
+function isSigner(wallet) {
+    return (typeof wallet === 'object' &&
+        wallet !== null &&
+        'signTransaction' in wallet &&
+        'getAddress' in wallet);
+}
+/**
+ * EVM chain implementation supporting Ethereum-compatible networks.
+ */
 export class EVMChain extends Chain {
+    static {
+        supportedChains[ChainFamily.EVM] = EVMChain;
+    }
     static family = ChainFamily.EVM;
     static decimals = 18;
-    network;
     provider;
-    constructor(provider, network) {
-        if (network.family !== ChainFamily.EVM)
-            throw new Error(`Invalid network family for EVMChain: ${network.family}`);
-        super();
-        this.network = network;
+    destroy$;
+    /**
+     * Creates a new EVMChain instance.
+     * @param provider - JSON-RPC provider for the EVM network.
+     * @param network - Network information for this chain.
+     */
+    constructor(provider, network, ctx) {
+        super(network, ctx);
         this.provider = provider;
-        this.typeAndVersion = moize.default(this.typeAndVersion.bind(this));
-        this.getBlockTimestamp = moize.default(this.getBlockTimestamp.bind(this), {
+        this.destroy$ = new Promise((resolve) => (this.destroy = resolve));
+        void this.destroy$.finally(() => provider.destroy());
+        this.typeAndVersion = memoize(this.typeAndVersion.bind(this));
+        this.provider.getBlock = memoize(provider.getBlock.bind(provider), {
             maxSize: 100,
-            updateCacheForKey: (key) => typeof key[key.length - 1] !== 'number',
+            maxArgs: 1,
+            async: true,
+            forceUpdate: ([block]) => typeof block !== 'number',
         });
-        this.getTransaction = moize.default(this.getTransaction.bind(this), {
+        this.getTransaction = memoize(this.getTransaction.bind(this), {
             maxSize: 100,
-            transformArgs: (args) => typeof args[0] !== 'string'
+            transformKey: (args) => typeof args[0] !== 'string'
                 ? [args[0].hash]
                 : args,
         });
-        this.getTokenForTokenPool = moize.default(this.getTokenForTokenPool.bind(this));
-        this.getNativeTokenForRouter = moize.default(this.getNativeTokenForRouter.bind(this), {
+        this.getTokenForTokenPool = memoize(this.getTokenForTokenPool.bind(this));
+        this.getNativeTokenForRouter = memoize(this.getNativeTokenForRouter.bind(this), {
             maxArgs: 1,
-            isPromise: true,
+            async: true,
         });
-        this.getTokenInfo = moize.default(this.getTokenInfo.bind(this));
-        this.getWallet = moize.default(this.getWallet.bind(this), { maxSize: 1, maxArgs: 0 });
-        this.getTokenAdminRegistryFor = moize.default(this.getTokenAdminRegistryFor.bind(this), {
-            isPromise: true,
+        this.getTokenInfo = memoize(this.getTokenInfo.bind(this));
+        this.getTokenAdminRegistryFor = memoize(this.getTokenAdminRegistryFor.bind(this), {
+            async: true,
             maxArgs: 1,
         });
-    }
-    // overwrite EVMChain.getWallet to implement custom wallet loading
-    // some signers don't like to be `.connect`ed, so pass provider as first param
-    static getWallet(_provider, _opts) {
-        throw new Error('static EVM wallet loading not available');
-    }
-    // cached wallet/signer getter
-    async getWallet(opts = {}) {
-        if (typeof opts.wallet === 'number' ||
-            (typeof opts.wallet === 'string' && opts.wallet.match(/^(\d+|0x[a-fA-F0-9]{40})$/))) {
-            // if given a number, numeric string or address, use ethers `provider.getSigner` (e.g. geth or MM)
-            return this.provider.getSigner(typeof opts.wallet === 'string' && opts.wallet.match(/^0x[a-fA-F0-9]{40}$/)
-                ? opts.wallet
-                : Number(opts.wallet));
-        }
-        else if (typeof opts.wallet === 'string') {
-            // support receiving private key directly (not recommended)
-            try {
-                return Promise.resolve(new BaseWallet(new SigningKey((opts.wallet.startsWith('0x') ? '' : '0x') + opts.wallet), this.provider));
-            }
-            catch (_) {
-                // pass
-            }
-        }
-        else if (opts.wallet instanceof AbstractSigner) {
-            // if given a signer, return/cache it
-            return opts.wallet;
-        }
-        return this.constructor.getWallet(this.provider, opts);
+        this.getFeeTokens = memoize(this.getFeeTokens.bind(this), { async: true, maxArgs: 1 });
     }
     /**
      * Expose ethers provider's `listAccounts`, if provider supports it
@@ -111,9 +102,11 @@ export class EVMChain extends Chain {
     async listAccounts() {
         return (await this.provider.listAccounts()).map(({ address }) => address);
     }
-    async getWalletAddress(opts) {
-        return (await this.getWallet(opts)).getAddress();
-    }
+    /**
+     * Creates a JSON-RPC provider from a URL.
+     * @param url - WebSocket (wss://) or HTTP (https://) endpoint URL.
+     * @returns A ready JSON-RPC provider.
+     */
     static async _getProvider(url) {
         let provider;
         let providerReady;
@@ -137,28 +130,38 @@ export class EVMChain extends Chain {
         }
         return providerReady;
     }
-    static async fromProvider(provider) {
+    /**
+     * Creates an EVMChain instance from an existing provider.
+     * @param provider - JSON-RPC provider instance.
+     * @param ctx - context containing logger.
+     * @returns A new EVMChain instance.
+     */
+    static async fromProvider(provider, ctx) {
         try {
-            return new EVMChain(provider, networkInfo(Number((await provider.getNetwork()).chainId)));
+            return new EVMChain(provider, networkInfo(Number((await provider.getNetwork()).chainId)), ctx);
         }
         catch (err) {
             provider.destroy();
             throw err;
         }
     }
-    static async fromUrl(url) {
-        return this.fromProvider(await this._getProvider(url));
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async destroy() {
-        this.provider.destroy();
+    /**
+     * 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.
+     */
+    static async fromUrl(url, ctx) {
+        return this.fromProvider(await this._getProvider(url), ctx);
     }
+    /** {@inheritDoc Chain.getBlockTimestamp} */
     async getBlockTimestamp(block) {
-        const res = await this.provider.getBlock(block);
+        const res = await this.provider.getBlock(block); // cached
         if (!res)
             throw new Error(`Block not found: ${block}`);
         return res.timestamp;
     }
+    /** {@inheritDoc Chain.getTransaction} */
     async getTransaction(hash) {
         const tx = typeof hash === 'string' ? await this.provider.getTransactionReceipt(hash) : hash;
         if (!tx)
@@ -166,7 +169,6 @@ export class EVMChain extends Chain {
         const timestamp = await this.getBlockTimestamp(tx.blockNumber);
         const chainTx = {
             ...tx,
-            chain: this,
             timestamp,
             logs: [],
         };
@@ -174,39 +176,40 @@ export class EVMChain extends Chain {
         chainTx.logs = logs;
         return chainTx;
     }
+    /** {@inheritDoc Chain.getLogs} */
     async *getLogs(filter) {
-        const endBlock = filter.endBlock ?? (await this.provider.getBlockNumber());
-        if (filter.topics?.length &&
-            filter.topics.every((t) => typeof t === 'string')) {
-            const topics = new Set(filter.topics
-                .filter(isHexString)
-                .concat(Object.keys(getAllFragmentsMatchingEvents(filter.topics)))
-                .flat());
-            if (!topics.size) {
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                throw new Error(`Could not find matching topics: ${filter.topics}`);
-            }
-            filter.topics = [Array.from(topics)];
-        }
-        if (!filter.startBlock && filter.startTime) {
-            filter.startBlock = await getSomeBlockNumberBefore(this.getBlockTimestamp.bind(this), endBlock, filter.startTime);
-        }
-        for (const blockRange of blockRangeGenerator({ ...filter, endBlock })) {
-            console.debug('evm getLogs:', {
-                ...blockRange,
-                ...(filter.address ? { address: filter.address } : {}),
-                ...(filter.topics?.length ? { topics: filter.topics } : {}),
-            });
-            const logs = await this.provider.getLogs({
-                ...blockRange,
-                ...(filter.address ? { address: filter.address } : {}),
-                ...(filter.topics?.length ? { topics: filter.topics } : {}),
-            });
-            if (!filter.startBlock)
-                logs.reverse();
-            yield* logs;
+        yield* getEvmLogs(filter, this);
+    }
+    /** {@inheritDoc Chain.fetchRequestsInTx} */
+    async fetchRequestsInTx(tx) {
+        return fetchCCIPRequestsInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx);
+    }
+    /** {@inheritDoc Chain.fetchRequestById} */
+    fetchRequestById(messageId, onRamp, opts) {
+        return fetchCCIPRequestById(this, messageId, { address: onRamp, ...opts });
+    }
+    /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
+    async fetchAllMessagesInBatch(request, commit, opts) {
+        let opts_;
+        if (request.lane.version >= CCIPVersion.V1_6) {
+            // specialized getLogs filter for v1.6 CCIPMessageSent events, to filter by dest
+            opts_ = {
+                ...opts,
+                topics: [[request.log.topics[0]], [toBeHex(request.lane.destChainSelector, 32)]],
+            };
         }
+        return fetchAllMessagesInBatch(this, request, commit, opts_);
+    }
+    /** {@inheritDoc Chain.typeAndVersion} */
+    async typeAndVersion(address) {
+        const contract = new Contract(address, VersionedContractABI, this.provider);
+        return parseTypeAndVersion(await contract.typeAndVersion());
     }
+    /**
+     * Decodes a CCIP message from a log event.
+     * @param log - Log event with topics and data.
+     * @returns Decoded CCIPMessage or undefined if not a valid CCIP message.
+     */
     static decodeMessage(log) {
         if (!isBytesLike(log.data))
             throw new Error(`invalid data=${util.inspect(log.data)}`);
@@ -259,7 +262,7 @@ export class EVMChain extends Chain {
                     };
                 }
                 catch (_) {
-                    console.debug('legacy sourceTokenData:', i, message.sourceTokenData[i]);
+                    // legacy sourceTokenData
                 }
             }
             if (typeof tokenAmount.destExecData === 'string' && tokenAmount.destGasAmount == null) {
@@ -294,6 +297,12 @@ export class EVMChain extends Chain {
         }
         return message;
     }
+    /**
+     * Decodes commit reports from a log event.
+     * @param log - Log event with topics and data.
+     * @param lane - Lane info (required for CCIP v1.5 and earlier).
+     * @returns Array of CommitReport or undefined if not a valid commit event.
+     */
     static decodeCommits(log, lane) {
         if (!isBytesLike(log.data))
             throw new Error(`invalid data=${util.inspect(log.data)}`);
@@ -348,6 +357,11 @@ export class EVMChain extends Chain {
             }
         }
     }
+    /**
+     * Decodes an execution receipt from a log event.
+     * @param log - Log event with topics and data.
+     * @returns ExecutionReceipt or undefined if not a valid execution event.
+     */
     static decodeReceipt(log) {
         if (!isBytesLike(log.data))
             throw new Error(`invalid data=${util.inspect(log.data)}`);
@@ -373,6 +387,11 @@ export class EVMChain extends Chain {
             }
         }
     }
+    /**
+     * Decodes extra arguments from a CCIP message.
+     * @param extraArgs - Encoded extra arguments bytes.
+     * @returns Decoded extra arguments with tag, or undefined if unknown format.
+     */
     static decodeExtraArgs(extraArgs) {
         const data = getDataBytes(extraArgs), tag = dataSlice(data, 0, 4);
         switch (tag) {
@@ -404,6 +423,11 @@ export class EVMChain extends Chain {
                 return undefined;
         }
     }
+    /**
+     * Encodes extra arguments for a CCIP message.
+     * @param args - Extra arguments to encode.
+     * @returns Encoded extra arguments as hex string.
+     */
     static encodeExtraArgs(args) {
         if (!args)
             return '0x';
@@ -441,6 +465,11 @@ export class EVMChain extends Chain {
         }
         return '0x';
     }
+    /**
+     * Converts bytes to a checksummed EVM address.
+     * @param bytes - Bytes to convert (must be 20 bytes or 32 bytes with leading zeros).
+     * @returns Checksummed EVM address.
+     */
     static getAddress(bytes) {
         bytes = getBytes(bytes);
         if (bytes.length < 20)
@@ -455,10 +484,11 @@ export class EVMChain extends Chain {
         }
         return getAddress(hexlify(bytes));
     }
-    async typeAndVersion(address) {
-        const contract = new Contract(address, VersionedContractABI, this.provider);
-        return parseTypeAndVersion(await contract.typeAndVersion());
-    }
+    /**
+     * Gets lane configuration from an OnRamp contract.
+     * @param onRamp - OnRamp contract address.
+     * @returns Lane configuration.
+     */
     async getLaneForOnRamp(onRamp) {
         const [, version] = await this.typeAndVersion(onRamp);
         const onRampABI = version === CCIPVersion.V1_2 ? EVM2EVMOnRamp_1_2_ABI : EVM2EVMOnRamp_1_5_ABI;
@@ -474,6 +504,7 @@ export class EVMChain extends Chain {
             onRamp,
         };
     }
+    /** {@inheritDoc Chain.getRouterForOnRamp} */
     async getRouterForOnRamp(onRamp, destChainSelector) {
         const [, version] = await this.typeAndVersion(onRamp);
         let onRampABI;
@@ -497,6 +528,7 @@ export class EVMChain extends Chain {
                 throw new Error(`Unsupported version: ${version}`);
         }
     }
+    /** {@inheritDoc Chain.getRouterForOffRamp} */
     async getRouterForOffRamp(offRamp, sourceChainSelector) {
         const [, version] = await this.typeAndVersion(offRamp);
         let offRampABI, router;
@@ -521,10 +553,12 @@ export class EVMChain extends Chain {
         }
         return router;
     }
+    /** {@inheritDoc Chain.getNativeTokenForRouter} */
     async getNativeTokenForRouter(router) {
         const contract = new Contract(router, interfaces.Router, this.provider);
         return contract.getWrappedNative();
     }
+    /** {@inheritDoc Chain.getOffRampsForRouter} */
     async getOffRampsForRouter(router, sourceChainSelector) {
         const contract = new Contract(router, interfaces.Router, this.provider);
         const offRamps = await contract.getOffRamps();
@@ -532,10 +566,12 @@ export class EVMChain extends Chain {
             .filter((offRamp) => offRamp.sourceChainSelector === sourceChainSelector)
             .map(({ offRamp }) => offRamp);
     }
+    /** {@inheritDoc Chain.getOnRampForRouter} */
     async getOnRampForRouter(router, destChainSelector) {
         const contract = new Contract(router, interfaces.Router, this.provider);
         return contract.getOnRamp(destChainSelector);
     }
+    /** {@inheritDoc Chain.getOnRampForOffRamp} */
     async getOnRampForOffRamp(offRamp, sourceChainSelector) {
         const [, version] = await this.typeAndVersion(offRamp);
         let offRampABI;
@@ -559,6 +595,7 @@ export class EVMChain extends Chain {
                 throw new Error(`Unsupported version: ${version}`);
         }
     }
+    /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
     async getCommitStoreForOffRamp(offRamp) {
         const [, version] = await this.typeAndVersion(offRamp);
         let offRampABI;
@@ -579,10 +616,12 @@ export class EVMChain extends Chain {
                 throw new Error(`Unsupported version: ${version}`);
         }
     }
+    /** {@inheritDoc Chain.getTokenForTokenPool} */
     async getTokenForTokenPool(tokenPool) {
         const contract = new Contract(tokenPool, interfaces.TokenPool_v1_6, this.provider);
         return contract.getToken();
     }
+    /** {@inheritDoc Chain.getTokenInfo} */
     async getTokenInfo(token) {
         const contract = new Contract(token, interfaces.Token, this.provider);
         const [symbol, decimals, name] = await Promise.all([
@@ -592,7 +631,13 @@ export class EVMChain extends Chain {
         ]);
         return { symbol, decimals: Number(decimals), name };
     }
-    static getDestLeafHasher({ sourceChainSelector, destChainSelector, onRamp, version, }) {
+    /**
+     * Gets the leaf hasher for computing Merkle proofs on the destination chain.
+     * @param lane - Lane configuration.
+     * @param ctx - Context object containing logger.
+     * @returns Leaf hasher function.
+     */
+    static getDestLeafHasher({ sourceChainSelector, destChainSelector, onRamp, version }, ctx) {
         switch (version) {
             case CCIPVersion.V1_2:
             case CCIPVersion.V1_5:
@@ -600,11 +645,16 @@ export class EVMChain extends Chain {
                     throw new Error(`Unsupported source chain: ${sourceChainSelector}`);
                 return getV12LeafHasher(sourceChainSelector, destChainSelector, onRamp);
             case CCIPVersion.V1_6:
-                return getV16LeafHasher(sourceChainSelector, destChainSelector, onRamp);
+                return getV16LeafHasher(sourceChainSelector, destChainSelector, onRamp, ctx);
             default:
                 throw new Error(`Unsupported hasher version for EVM: ${version}`);
         }
     }
+    /**
+     * Gets any available OnRamp for the given router.
+     * @param router - Router contract address.
+     * @returns OnRamp contract address.
+     */
     async _getSomeOnRampFor(router) {
         // when given a router, we take any onRamp we can find, as usually they all use same registry
         const someOtherNetwork = this.network.isTestnet
@@ -616,6 +666,7 @@ export class EVMChain extends Chain {
                 : 'ethereum-mainnet';
         return this.getOnRampForRouter(router, networkInfo(someOtherNetwork).chainSelector);
     }
+    /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
     async getTokenAdminRegistryFor(address) {
         let [type, version, typeAndVersion] = await this.typeAndVersion(address);
         if (type === 'TokenAdminRegistry') {
@@ -638,6 +689,11 @@ export class EVMChain extends Chain {
         const { tokenAdminRegistry } = await contract.getStaticConfig();
         return tokenAdminRegistry;
     }
+    /**
+     * Gets the FeeQuoter contract address for a given Router or Ramp.
+     * @param address - Router or Ramp contract address.
+     * @returns FeeQuoter contract address.
+     */
     async getFeeQuoterFor(address) {
         let [type, version, typeAndVersion] = await this.typeAndVersion(address);
         if (type === 'FeeQuoter') {
@@ -656,6 +712,7 @@ export class EVMChain extends Chain {
         const { feeQuoter } = await contract.getDynamicConfig();
         return feeQuoter;
     }
+    /** {@inheritDoc Chain.getFee} */
     async getFee(router_, destChainSelector, message) {
         const router = new Contract(router_, interfaces.Router, this.provider);
         return router.getFee(destChainSelector, {
@@ -666,7 +723,19 @@ export class EVMChain extends Chain {
             extraArgs: hexlify(this.constructor.encodeExtraArgs(message.extraArgs)),
         });
     }
-    async sendMessage(router_, destChainSelector, message, opts) {
+    /**
+     * Generate unsigned txs for ccipSend'ing a message
+     * @param sender - sender address
+     * @param router - address of the Router contract
+     * @param destChainSelector - chainSelector of destination chain
+     * @param message - AnyMessage to send; if `fee` is not present, it'll be calculated
+     * @param approveMax - if tokens approvals are needed, opt into approving maximum allowance
+     * @returns Array containing 0 or more unsigned token approvals txs (if needed at the time of
+     *   generation), followed by a ccipSend TransactionRequest
+     */
+    async generateUnsignedSendMessage(sender, router, destChainSelector, message, opts) {
+        if (!message.fee)
+            message.fee = await this.getFee(router, destChainSelector, message);
         const feeToken = message.feeToken ?? ZeroAddress;
         const receiver = zeroPadValue(getAddressBytes(message.receiver), 32);
         const data = hexlify(message.data);
@@ -675,52 +744,85 @@ export class EVMChain extends Chain {
         const amountsToApprove = (message.tokenAmounts ?? []).reduce((acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }), {});
         if (feeToken !== ZeroAddress)
             amountsToApprove[feeToken] = (amountsToApprove[feeToken] ?? 0n) + message.fee;
-        const wallet = await this.getWallet(opts); // moized wallet arg (if called previously)
-        // approve all tokens (including fee token) in parallel
-        let nonce = await this.provider.getTransactionCount(await this.getWalletAddress());
-        await Promise.all(Object.entries(amountsToApprove).map(async ([token, amount]) => {
-            const contract = new Contract(token, interfaces.Token, wallet);
-            const allowance = await contract.allowance(await wallet.getAddress(), router_);
-            if (allowance < amount) {
-                const amnt = opts?.approveMax ? 2n ** 256n - 1n : amount;
-                // optimization: hardcode nonce and gasLimit to send all approvals in parallel without estimating
-                console.info('Approving', amnt, 'of', token, 'tokens for router', router_);
-                const tx = await contract.approve(router_, amnt, {
-                    nonce: nonce++,
-                    gasLimit: DEFAULT_APPROVE_GAS_LIMIT,
-                });
-                console.info('=>', tx.hash);
-                await tx.wait(1, 60_000);
-            }
-        }));
-        const router = new Contract(router_, interfaces.Router, wallet);
-        const tx = await router.ccipSend(destChainSelector, {
+        const approveTxs = (await Promise.all(Object.entries(amountsToApprove).map(async ([token, amount]) => {
+            const contract = new Contract(token, interfaces.Token, this.provider);
+            const allowance = await contract.allowance(sender, router);
+            if (allowance >= amount)
+                return;
+            const amnt = opts?.approveMax ? 2n ** 256n - 1n : amount;
+            return contract.approve.populateTransaction(router, amnt, { from: sender });
+        }))).filter((tx) => tx != null);
+        const contract = new Contract(router, interfaces.Router, this.provider);
+        const sendTx = await contract.ccipSend.populateTransaction(destChainSelector, {
             receiver,
             data,
             tokenAmounts: message.tokenAmounts ?? [],
             extraArgs,
             feeToken,
         }, {
-            nonce: nonce++,
+            from: sender,
             // if native fee, include it in value; otherwise, it's transferedFrom feeToken
-            ...(feeToken === ZeroAddress ? { value: message.fee } : {}),
+            ...(feeToken === ZeroAddress && { value: message.fee }),
         });
-        const receipt = await tx.wait(1);
-        return this.getTransaction(receipt);
+        const txRequests = [...approveTxs, sendTx];
+        return {
+            family: ChainFamily.EVM,
+            transactions: txRequests,
+        };
+    }
+    /** {@inheritDoc Chain.sendMessage} */
+    async sendMessage(router_, destChainSelector, message, opts) {
+        const wallet = opts.wallet;
+        if (!isSigner(wallet))
+            throw new Error(`Wallet must be a Signer, got=${util.inspect(wallet)}`);
+        const sender = await wallet.getAddress();
+        const txs = await this.generateUnsignedSendMessage(sender, router_, destChainSelector, message, opts);
+        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 signed = await wallet.signTransaction(tx);
+            const response = await this.provider.broadcastTransaction(signed);
+            this.logger.debug('approve =>', response.hash);
+            return response;
+        }));
+        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 signed = await wallet.signTransaction(sendTx);
+        const response = await this.provider.broadcastTransaction(signed);
+        this.logger.debug('ccipSend =>', response.hash);
+        await response.wait(1, 60_000);
+        return (await this.fetchRequestsInTx(await this.getTransaction(response.hash)))[0];
     }
+    /** {@inheritDoc Chain.fetchOffchainTokenData} */
     fetchOffchainTokenData(request) {
-        return fetchEVMOffchainTokenData(request);
+        return fetchEVMOffchainTokenData(request, this);
     }
-    async executeReport(offRamp, execReport, opts) {
+    /**
+     * Generate unsigned tx to manuallyExecute a message
+     * @param _payer - not used in EVM
+     * @param offRamp - address of the OffRamp contract
+     * @param execReport - execution report
+     * @param opts - gas limit overrides for ccipReceive and tokenPool calls options
+     * @returns array containing one unsigned `manuallyExecute` TransactionRequest object
+     */
+    async generateUnsignedExecuteReport(_payer, offRamp, execReport, opts) {
         const [_, version] = await this.typeAndVersion(offRamp);
-        const wallet = await this.getWallet(opts);
         let manualExecTx;
         const offchainTokenData = execReport.offchainTokenData.map(encodeEVMOffchainTokenData);
         switch (version) {
             case CCIPVersion.V1_2: {
-                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_2_ABI, wallet);
+                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_2_ABI, this.provider);
                 const gasOverride = BigInt(opts?.gasLimit ?? 0);
-                manualExecTx = await contract.manuallyExecute({
+                manualExecTx = await contract.manuallyExecute.populateTransaction({
                     ...execReport,
                     proofs: execReport.proofs.map((d) => hexlify(d)),
                     messages: [execReport.message],
@@ -729,8 +831,8 @@ export class EVMChain extends Chain {
                 break;
             }
             case CCIPVersion.V1_5: {
-                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_5_ABI, wallet);
-                manualExecTx = await contract.manuallyExecute({
+                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_5_ABI, this.provider);
+                manualExecTx = await contract.manuallyExecute.populateTransaction({
                     ...execReport,
                     proofs: execReport.proofs.map((d) => hexlify(d)),
                     messages: [execReport.message],
@@ -756,8 +858,8 @@ export class EVMChain extends Chain {
                     sender,
                     tokenAmounts,
                 };
-                const contract = new Contract(offRamp, OffRamp_1_6_ABI, wallet);
-                manualExecTx = await contract.manuallyExecute([
+                const contract = new Contract(offRamp, OffRamp_1_6_ABI, this.provider);
+                manualExecTx = await contract.manuallyExecute.populateTransaction([
                     {
                         ...execReport,
                         proofs: execReport.proofs.map((p) => hexlify(p)),
@@ -778,20 +880,38 @@ export class EVMChain extends Chain {
             default:
                 throw new Error(`Unsupported version: ${version}`);
         }
-        const receipt = await this.provider.waitForTransaction(manualExecTx.hash, 1, 60e3);
+        return { family: ChainFamily.EVM, transactions: [manualExecTx] };
+    }
+    /** {@inheritDoc Chain.executeReport} */
+    async executeReport(offRamp, execReport, opts) {
+        const wallet = opts.wallet;
+        if (!isSigner(wallet))
+            throw new Error(`Wallet must be a Signer, got=${util.inspect(wallet)}`);
+        const unsignedTxs = await this.generateUnsignedExecuteReport(await wallet.getAddress(), offRamp, execReport, opts);
+        const unsignedTx = await wallet.populateTransaction(unsignedTxs.transactions[0]);
+        unsignedTx.from = undefined; // some signers don't like receiving pre-populated `from`
+        const signed = await wallet.signTransaction(unsignedTx);
+        const response = await this.provider.broadcastTransaction(signed);
+        this.logger.debug('ccipSend =>', response.hash);
+        const receipt = await response.wait(1, 60_000);
         if (!receipt?.hash)
-            throw new Error(`Could not confirm exec tx: ${manualExecTx.hash}`);
+            throw new Error(`Could not confirm exec tx: ${response.hash}`);
         if (!receipt.status)
-            throw new Error(`Exec transaction reverted: ${manualExecTx.hash}`);
+            throw new Error(`Exec transaction reverted: ${response.hash}`);
         return this.getTransaction(receipt);
     }
+    /**
+     * Parses raw data into typed structures.
+     * @param data - Raw data to parse.
+     * @returns Parsed data.
+     */
     static parse(data) {
         return parseData(data);
     }
     /**
-     * Get the supported tokens for a given contract address
-     *
-     * @param address Router, OnRamp, OffRamp or TokenAdminRegistry contract
+     * Get the supported tokens for a given contract address.
+     * @param registry - Router, OnRamp, OffRamp or TokenAdminRegistry contract address.
+     * @param opts - Optional parameters.
      * @returns An array of supported token addresses.
      */
     async getSupportedTokens(registry, opts) {
@@ -805,6 +925,7 @@ export class EVMChain extends Chain {
         } while (page.length === limit);
         return res;
     }
+    /** {@inheritDoc Chain.getRegistryTokenConfig} */
     async getRegistryTokenConfig(registry, token) {
         const contract = new Contract(registry, interfaces.TokenAdminRegistry, this.provider);
         const config = (await resultToObject(contract.getTokenConfig(token)));
@@ -819,6 +940,7 @@ export class EVMChain extends Chain {
             administrator: config.administrator,
         };
     }
+    /** {@inheritDoc Chain.getTokenPoolConfigs} */
     async getTokenPoolConfigs(tokenPool) {
         const [_, , typeAndVersion] = await this.typeAndVersion(tokenPool);
         const contract = new Contract(tokenPool, interfaces.TokenPool_v1_6, this.provider);
@@ -832,6 +954,7 @@ export class EVMChain extends Chain {
             };
         });
     }
+    /** {@inheritDoc Chain.getTokenPoolRemotes} */
     async getTokenPoolRemotes(tokenPool, remoteChainSelector) {
         const [_, version] = await this.typeAndVersion(tokenPool);
         let supportedChains;
@@ -870,22 +993,30 @@ export class EVMChain extends Chain {
             },
         ])));
     }
-    async listFeeTokens(router) {
+    /** {@inheritDoc Chain.getFeeTokens} */
+    async getFeeTokens(router) {
         const onRamp = await this._getSomeOnRampFor(router);
         const [_, version] = await this.typeAndVersion(onRamp);
         let tokens;
-        let onRampABI;
+        let onRampIface;
         switch (version) {
             case CCIPVersion.V1_2:
-                onRampABI = EVM2EVMOnRamp_1_2_ABI;
+                onRampIface = interfaces.EVM2EVMOnRamp_v1_2;
             // falls through
             case CCIPVersion.V1_5: {
-                onRampABI ??= EVM2EVMOnRamp_1_5_ABI;
-                const contract = new Contract(onRamp, onRampABI, this.provider);
-                tokens = await Promise.all([
-                    this.getNativeTokenForRouter(router),
-                    contract.getStaticConfig().then(({ linkToken }) => linkToken),
-                ]);
+                onRampIface ??= interfaces.EVM2EVMOnRamp_v1_5;
+                const fragment = onRampIface.getEvent('FeeConfigSet');
+                const tokens_ = new Set();
+                for await (const log of this.getLogs({
+                    address: onRamp,
+                    topics: [fragment.topicHash],
+                    startBlock: 1,
+                    onlyFallback: true,
+                })) {
+                    ;
+                    onRampIface.decodeEventLog(fragment, log.data, log.topics).feeConfig.forEach(({ token, enabled }) => enabled ? tokens_.add(token) : tokens_.delete(token));
+                }
+                tokens = Array.from(tokens_);
                 break;
             }
             case CCIPVersion.V1_6: {
@@ -899,6 +1030,33 @@ export class EVMChain extends Chain {
         }
         return Object.fromEntries(await Promise.all(tokens.map(async (token) => [token, await this.getTokenInfo(token)])));
     }
+    /** {@inheritDoc Chain.fetchExecutionReceipts} */
+    async *fetchExecutionReceipts(offRamp, request, commit, opts) {
+        let opts_ = opts;
+        if (request.lane.version < CCIPVersion.V1_6) {
+            opts_ = {
+                ...opts,
+                topics: [
+                    interfaces.EVM2EVMOffRamp_v1_5.getEvent('ExecutionStateChanged').topicHash,
+                    null,
+                    request.message.header.messageId,
+                ],
+                // onlyFallback: false,
+            };
+        }
+        else /* >= V1.6 */ {
+            opts_ = {
+                ...opts,
+                topics: [
+                    interfaces.OffRamp_v1_6.getEvent('ExecutionStateChanged').topicHash,
+                    toBeHex(request.lane.sourceChainSelector, 32),
+                    null,
+                    request.message.header.messageId,
+                ],
+                // onlyFallback: false,
+            };
+        }
+        yield* super.fetchExecutionReceipts(offRamp, request, commit, opts_);
+    }
 }
-supportedChains[ChainFamily.EVM] = EVMChain;
 //# sourceMappingURL=index.js.map