@chainlink/ccip-sdk 0.0.0 → 0.90.0

package/dist/evm/index.js

@@ -0,0 +1,904 @@
+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 { 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 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 { parseData } from "./errors.js";
+import { getV12LeafHasher, getV16LeafHasher } from "./hasher.js";
+import { parseSourceTokenData, } from "./messages.js";
+import { encodeEVMOffchainTokenData, fetchEVMOffchainTokenData } from "./offchain.js";
+const VersionedContractABI = parseAbi(['function typeAndVersion() view returns (string)']);
+const EVMExtraArgsV1 = 'tuple(uint256 gasLimit)';
+const EVMExtraArgsV2 = 'tuple(uint256 gasLimit, bool allowOutOfOrderExecution)';
+const SVMExtraArgsV1 = 'tuple(uint32 computeUnits, uint64 accountIsWritableBitmap, bool allowOutOfOrderExecution, bytes32 tokenReceiver, bytes32[] accounts)';
+const SuiExtraArgsV1 = 'tuple(uint256 gasLimit, bool allowOutOfOrderExecution, bytes32 tokenReceiver, bytes32[] receiverObjectIds)';
+function resultToObject(o) {
+    return o instanceof Promise
+        ? o.then(resultToObject)
+        : o instanceof Result
+            ? o.toObject()
+            : o;
+}
+function resultsToMessage(result) {
+    if (result.message)
+        result = result.message;
+    return {
+        ...result.toObject(),
+        tokenAmounts: result.tokenAmounts.map((ta) => ta.toObject()),
+        ...(result.sourceTokenData
+            ? { sourceTokenData: result.sourceTokenData.toArray() }
+            : {}),
+        ...(result.header ? { header: result.header.toObject() } : {}),
+    };
+}
+export class EVMChain extends Chain {
+    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;
+        this.provider = provider;
+        this.typeAndVersion = moize.default(this.typeAndVersion.bind(this));
+        this.getBlockTimestamp = moize.default(this.getBlockTimestamp.bind(this), {
+            maxSize: 100,
+            updateCacheForKey: (key) => typeof key[key.length - 1] !== 'number',
+        });
+        this.getTransaction = moize.default(this.getTransaction.bind(this), {
+            maxSize: 100,
+            transformArgs: (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), {
+            maxArgs: 1,
+            isPromise: 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,
+            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);
+    }
+    /**
+     * Expose ethers provider's `listAccounts`, if provider supports it
+     */
+    async listAccounts() {
+        return (await this.provider.listAccounts()).map(({ address }) => address);
+    }
+    async getWalletAddress(opts) {
+        return (await this.getWallet(opts)).getAddress();
+    }
+    static async _getProvider(url) {
+        let provider;
+        let providerReady;
+        if (url.startsWith('ws')) {
+            const provider_ = new WebSocketProvider(url);
+            providerReady = new Promise((resolve, reject) => {
+                provider_.websocket.onerror = reject;
+                provider_
+                    ._waitUntilReady()
+                    .then(() => resolve(provider_))
+                    .catch(reject);
+            });
+            provider = provider_;
+        }
+        else if (url.startsWith('http')) {
+            provider = new JsonRpcProvider(url);
+            providerReady = Promise.resolve(provider);
+        }
+        else {
+            throw new Error(`Unknown JSON RPC protocol in endpoint (should be wss?:// or https?://): ${url}`);
+        }
+        return providerReady;
+    }
+    static async fromProvider(provider) {
+        try {
+            return new EVMChain(provider, networkInfo(Number((await provider.getNetwork()).chainId)));
+        }
+        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();
+    }
+    async getBlockTimestamp(block) {
+        const res = await this.provider.getBlock(block);
+        if (!res)
+            throw new Error(`Block not found: ${block}`);
+        return res.timestamp;
+    }
+    async getTransaction(hash) {
+        const tx = typeof hash === 'string' ? await this.provider.getTransactionReceipt(hash) : hash;
+        if (!tx)
+            throw new Error(`Transaction not found: ${hash}`);
+        const timestamp = await this.getBlockTimestamp(tx.blockNumber);
+        const chainTx = {
+            ...tx,
+            chain: this,
+            timestamp,
+            logs: [],
+        };
+        const logs = tx.logs.map((l) => Object.assign(l, { tx: chainTx }));
+        chainTx.logs = logs;
+        return chainTx;
+    }
+    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;
+        }
+    }
+    static decodeMessage(log) {
+        if (!isBytesLike(log.data))
+            throw new Error(`invalid data=${util.inspect(log.data)}`);
+        let fragments;
+        if (log.topics?.[0]) {
+            fragments = [requestsFragments[log.topics[0]]];
+            if (!fragments[0])
+                return;
+        }
+        else {
+            fragments = Object.values(requestsFragments);
+        }
+        let message;
+        for (const fragment of fragments) {
+            try {
+                // we don't actually use Interface instance here, `decodeEventLog` is mostly static when given a fragment
+                const result = interfaces.OnRamp_v1_6.decodeEventLog(fragment, log.data, log.topics);
+                message = resultsToMessage(result);
+            }
+            catch (_) {
+                // try next fragment
+            }
+        }
+        if (!message)
+            return;
+        if (!isHexString(message.sender, 20))
+            throw new Error('could not decode CCIPMessage');
+        if (!message.header) {
+            // CCIPMessage_V1_2_EVM
+            message.header = {
+                messageId: message.messageId,
+                sequenceNumber: message.sequenceNumber,
+                nonce: message.nonce,
+                sourceChainSelector: message.sourceChainSelector,
+            };
+        }
+        const sourceFamily = networkInfo(message.header.sourceChainSelector).family;
+        let destFamily = ChainFamily.EVM;
+        if (message.header?.destChainSelector) {
+            destFamily = networkInfo(message.header.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 (_) {
+                    console.debug('legacy sourceTokenData:', i, message.sourceTokenData[i]);
+                }
+            }
+            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 Error(`Unknown extraArgs: ${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;
+    }
+    static decodeCommits(log, lane) {
+        if (!isBytesLike(log.data))
+            throw new Error(`invalid data=${util.inspect(log.data)}`);
+        let fragments;
+        if (log.topics?.[0]) {
+            const fragment = commitsFragments[log.topics[0]];
+            if (!fragment)
+                return;
+            const isCcipV15 = fragment.name === 'ReportAccepted';
+            // CCIP<=1.5 doesn't have lane info in event, so we need lane to be provided (e.g. from CommitStore's configs)
+            if (isCcipV15 && !lane)
+                throw new Error('decoding commits from CCIP<=v1.5 requires lane');
+            fragments = [fragment];
+        }
+        else
+            fragments = Object.values(commitsFragments);
+        for (const fragment of fragments) {
+            let result;
+            try {
+                result = interfaces.OffRamp_v1_6.decodeEventLog(fragment, log.data, log.topics);
+            }
+            catch (_) {
+                continue;
+            }
+            if (result.length === 1)
+                result = result[0];
+            const isCcipV15 = fragment.name === 'ReportAccepted';
+            if (isCcipV15) {
+                return [
+                    {
+                        merkleRoot: result.merkleRoot,
+                        minSeqNr: result.interval.min,
+                        maxSeqNr: result.interval.max,
+                        sourceChainSelector: lane.sourceChainSelector,
+                        onRampAddress: lane.onRamp,
+                    },
+                ];
+            }
+            else {
+                const reports = [];
+                for (const c of [...result[0], ...result[1]]) {
+                    // if ccip>=v1.6 and lane is provided, use it to filter reports; otherwise, include all
+                    if (lane && c.sourceChainSelector !== lane.sourceChainSelector)
+                        continue;
+                    const onRampAddress = decodeOnRampAddress(c.onRampAddress, networkInfo(c.sourceChainSelector).family);
+                    if (lane && onRampAddress !== lane.onRamp)
+                        continue;
+                    reports.push({ ...c.toObject(), onRampAddress });
+                }
+                if (reports.length)
+                    return reports;
+            }
+        }
+    }
+    static decodeReceipt(log) {
+        if (!isBytesLike(log.data))
+            throw new Error(`invalid data=${util.inspect(log.data)}`);
+        let fragments;
+        if (log.topics?.[0]) {
+            fragments = [receiptsFragments[log.topics[0]]];
+            if (!fragments[0])
+                return;
+        }
+        else
+            fragments = Object.values(receiptsFragments);
+        for (const fragment of fragments) {
+            try {
+                const result = interfaces.OffRamp_v1_6.decodeEventLog(fragment, log.data, log.topics);
+                return {
+                    ...result.toObject(),
+                    // ...(fragment.inputs.filter((p) => p.indexed).map((p, i) => [p.name, log.topics[i+1]] as const)).
+                    state: Number(result.state),
+                };
+            }
+            catch (_) {
+                // continue
+            }
+        }
+    }
+    static decodeExtraArgs(extraArgs) {
+        const data = getDataBytes(extraArgs), tag = dataSlice(data, 0, 4);
+        switch (tag) {
+            case EVMExtraArgsV1Tag: {
+                const args = defaultAbiCoder.decode([EVMExtraArgsV1], dataSlice(data, 4));
+                return { ...args[0].toObject(), _tag: 'EVMExtraArgsV1' };
+            }
+            case EVMExtraArgsV2Tag: {
+                const args = defaultAbiCoder.decode([EVMExtraArgsV2], dataSlice(data, 4));
+                return { ...args[0].toObject(), _tag: 'EVMExtraArgsV2' };
+            }
+            case SVMExtraArgsV1Tag: {
+                const args = defaultAbiCoder.decode([SVMExtraArgsV1], dataSlice(data, 4));
+                const parsed = args[0].toObject();
+                parsed.tokenReceiver = encodeBase58(parsed.tokenReceiver);
+                parsed.accounts = parsed.accounts.map((a) => encodeBase58(a));
+                return { ...parsed, _tag: 'SVMExtraArgsV1' };
+            }
+            case SuiExtraArgsV1Tag: {
+                const args = defaultAbiCoder.decode([SuiExtraArgsV1], dataSlice(data, 4));
+                const parsed = args[0].toObject();
+                return {
+                    ...parsed,
+                    receiverObjectIds: Array.from(parsed.receiverObjectIds),
+                    _tag: 'SuiExtraArgsV1',
+                };
+            }
+            default:
+                return undefined;
+        }
+    }
+    static encodeExtraArgs(args) {
+        if (!args)
+            return '0x';
+        if ('computeUnits' in args) {
+            return concat([
+                SVMExtraArgsV1Tag,
+                defaultAbiCoder.encode([SVMExtraArgsV1], [
+                    {
+                        ...args,
+                        tokenReceiver: getAddressBytes(args.tokenReceiver),
+                        accounts: args.accounts.map((a) => getAddressBytes(a)),
+                    },
+                ]),
+            ]);
+        }
+        else if ('receiverObjectIds' in args) {
+            return concat([
+                SuiExtraArgsV1Tag,
+                defaultAbiCoder.encode([SuiExtraArgsV1], [
+                    {
+                        ...args,
+                        tokenReceiver: zeroPadValue(getAddressBytes(args.tokenReceiver), 32),
+                        receiverObjectIds: args.receiverObjectIds.map((a) => getDataBytes(a)),
+                    },
+                ]),
+            ]);
+        }
+        else if ('allowOutOfOrderExecution' in args) {
+            if (args.gasLimit == null)
+                args.gasLimit = DEFAULT_GAS_LIMIT;
+            return concat([EVMExtraArgsV2Tag, defaultAbiCoder.encode([EVMExtraArgsV2], [args])]);
+        }
+        else if (args.gasLimit != null) {
+            return concat([EVMExtraArgsV1Tag, defaultAbiCoder.encode([EVMExtraArgsV1], [args])]);
+        }
+        return '0x';
+    }
+    static getAddress(bytes) {
+        bytes = getBytes(bytes);
+        if (bytes.length < 20)
+            throw new Error(`Invalid address: ${hexlify(bytes)}`);
+        else if (bytes.length > 20) {
+            if (bytes.slice(0, bytes.length - 20).every((b) => b === 0)) {
+                bytes = bytes.slice(-20);
+            }
+            else {
+                throw new Error(`Invalid address: ${hexlify(bytes)}`);
+            }
+        }
+        return getAddress(hexlify(bytes));
+    }
+    async typeAndVersion(address) {
+        const contract = new Contract(address, VersionedContractABI, this.provider);
+        return parseTypeAndVersion(await contract.typeAndVersion());
+    }
+    async getLaneForOnRamp(onRamp) {
+        const [, version] = await this.typeAndVersion(onRamp);
+        const onRampABI = version === CCIPVersion.V1_2 ? EVM2EVMOnRamp_1_2_ABI : EVM2EVMOnRamp_1_5_ABI;
+        const contract = new Contract(onRamp, onRampABI, this.provider);
+        // TODO: memo this call
+        const staticConfig = await contract.getStaticConfig();
+        if (!staticConfig.destChainSelector)
+            throw new Error(`No destChainSelector in OnRamp.staticConfig: ${JSON.stringify(staticConfig)}`);
+        return {
+            sourceChainSelector: this.network.chainSelector,
+            destChainSelector: staticConfig.destChainSelector,
+            version: version,
+            onRamp,
+        };
+    }
+    async getRouterForOnRamp(onRamp, destChainSelector) {
+        const [, version] = await this.typeAndVersion(onRamp);
+        let onRampABI;
+        switch (version) {
+            case CCIPVersion.V1_2:
+                onRampABI = EVM2EVMOnRamp_1_2_ABI;
+            // falls through
+            case CCIPVersion.V1_5: {
+                onRampABI ??= EVM2EVMOnRamp_1_5_ABI;
+                const contract = new Contract(onRamp, onRampABI, this.provider);
+                const { router } = await contract.getDynamicConfig();
+                return router;
+            }
+            case CCIPVersion.V1_6: {
+                onRampABI = OnRamp_1_6_ABI;
+                const contract = new Contract(onRamp, onRampABI, this.provider);
+                const [, , router] = await contract.getDestChainConfig(destChainSelector);
+                return router;
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+    }
+    async getRouterForOffRamp(offRamp, sourceChainSelector) {
+        const [, version] = await this.typeAndVersion(offRamp);
+        let offRampABI, router;
+        switch (version) {
+            case CCIPVersion.V1_2:
+                offRampABI = EVM2EVMOffRamp_1_2_ABI;
+            // falls through
+            case CCIPVersion.V1_5: {
+                offRampABI ??= EVM2EVMOffRamp_1_5_ABI;
+                const contract = new Contract(offRamp, offRampABI, this.provider);
+                ({ router } = await contract.getDynamicConfig());
+                break;
+            }
+            case CCIPVersion.V1_6: {
+                offRampABI = OffRamp_1_6_ABI;
+                const contract = new Contract(offRamp, offRampABI, this.provider);
+                ({ router } = await contract.getSourceChainConfig(sourceChainSelector));
+                break;
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+        return router;
+    }
+    async getNativeTokenForRouter(router) {
+        const contract = new Contract(router, interfaces.Router, this.provider);
+        return contract.getWrappedNative();
+    }
+    async getOffRampsForRouter(router, sourceChainSelector) {
+        const contract = new Contract(router, interfaces.Router, this.provider);
+        const offRamps = await contract.getOffRamps();
+        return offRamps
+            .filter((offRamp) => offRamp.sourceChainSelector === sourceChainSelector)
+            .map(({ offRamp }) => offRamp);
+    }
+    async getOnRampForRouter(router, destChainSelector) {
+        const contract = new Contract(router, interfaces.Router, this.provider);
+        return contract.getOnRamp(destChainSelector);
+    }
+    async getOnRampForOffRamp(offRamp, sourceChainSelector) {
+        const [, version] = await this.typeAndVersion(offRamp);
+        let offRampABI;
+        switch (version) {
+            case CCIPVersion.V1_2:
+                offRampABI = EVM2EVMOffRamp_1_2_ABI;
+            // falls through
+            case CCIPVersion.V1_5: {
+                offRampABI ??= EVM2EVMOffRamp_1_5_ABI;
+                const contract = new Contract(offRamp, offRampABI, this.provider);
+                const { onRamp } = await contract.getStaticConfig();
+                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);
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+    }
+    async getCommitStoreForOffRamp(offRamp) {
+        const [, version] = await this.typeAndVersion(offRamp);
+        let offRampABI;
+        switch (version) {
+            case CCIPVersion.V1_2:
+                offRampABI = EVM2EVMOffRamp_1_2_ABI;
+            // falls through
+            case CCIPVersion.V1_5: {
+                offRampABI ??= EVM2EVMOffRamp_1_5_ABI;
+                const contract = new Contract(offRamp, offRampABI, this.provider);
+                const { commitStore } = await contract.getStaticConfig();
+                return commitStore;
+            }
+            case CCIPVersion.V1_6: {
+                return offRamp;
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+    }
+    async getTokenForTokenPool(tokenPool) {
+        const contract = new Contract(tokenPool, interfaces.TokenPool_v1_6, this.provider);
+        return contract.getToken();
+    }
+    async getTokenInfo(token) {
+        const contract = new Contract(token, interfaces.Token, this.provider);
+        const [symbol, decimals, name] = await Promise.all([
+            contract.symbol(),
+            contract.decimals(),
+            contract.name(),
+        ]);
+        return { symbol, decimals: Number(decimals), name };
+    }
+    static getDestLeafHasher({ sourceChainSelector, destChainSelector, onRamp, version, }) {
+        switch (version) {
+            case CCIPVersion.V1_2:
+            case CCIPVersion.V1_5:
+                if (networkInfo(sourceChainSelector).family !== ChainFamily.EVM)
+                    throw new Error(`Unsupported source chain: ${sourceChainSelector}`);
+                return getV12LeafHasher(sourceChainSelector, destChainSelector, onRamp);
+            case CCIPVersion.V1_6:
+                return getV16LeafHasher(sourceChainSelector, destChainSelector, onRamp);
+            default:
+                throw new Error(`Unsupported hasher version for EVM: ${version}`);
+        }
+    }
+    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
+            ? this.network.name === 'ethereum-testnet-sepolia'
+                ? 'avalanche-testnet-fuji'
+                : 'ethereum-testnet-sepolia'
+            : this.network.name === 'ethereum-mainnet'
+                ? 'avalanche-mainnet'
+                : 'ethereum-mainnet';
+        return this.getOnRampForRouter(router, networkInfo(someOtherNetwork).chainSelector);
+    }
+    async getTokenAdminRegistryFor(address) {
+        let [type, version, typeAndVersion] = await this.typeAndVersion(address);
+        if (type === 'TokenAdminRegistry') {
+            return address;
+        }
+        else if (type === 'Router') {
+            address = await this._getSomeOnRampFor(address);
+            [type, version, typeAndVersion] = await this.typeAndVersion(address);
+        }
+        else if (!type.includes('Ramp')) {
+            throw new Error(`Not a Router, Ramp or TokenAdminRegistry: ${address} is "${typeAndVersion}"`);
+        }
+        const contract = new Contract(address, version < CCIPVersion.V1_6
+            ? type.includes('OnRamp')
+                ? interfaces.EVM2EVMOnRamp_v1_5
+                : interfaces.EVM2EVMOffRamp_v1_5
+            : type.includes('OnRamp')
+                ? interfaces.OnRamp_v1_6
+                : interfaces.OffRamp_v1_6, this.provider);
+        const { tokenAdminRegistry } = await contract.getStaticConfig();
+        return tokenAdminRegistry;
+    }
+    async getFeeQuoterFor(address) {
+        let [type, version, typeAndVersion] = await this.typeAndVersion(address);
+        if (type === 'FeeQuoter') {
+            return address;
+        }
+        else if (type === 'Router') {
+            address = await this._getSomeOnRampFor(address);
+            [type, version, typeAndVersion] = await this.typeAndVersion(address);
+        }
+        else if (!type.includes('Ramp')) {
+            throw new Error(`Not a Router, Ramp or FeeQuoter: ${address} is "${typeAndVersion}"`);
+        }
+        if (version < CCIPVersion.V1_6)
+            throw new Error(`Version < v1.6 doesn't have feeQuoter: got=${version}`);
+        const contract = new Contract(address, type.includes('OnRamp') ? interfaces.OnRamp_v1_6 : interfaces.OffRamp_v1_6, this.provider);
+        const { feeQuoter } = await contract.getDynamicConfig();
+        return feeQuoter;
+    }
+    async getFee(router_, destChainSelector, message) {
+        const router = new Contract(router_, interfaces.Router, this.provider);
+        return router.getFee(destChainSelector, {
+            receiver: zeroPadValue(getAddressBytes(message.receiver), 32),
+            data: hexlify(message.data),
+            tokenAmounts: message.tokenAmounts ?? [],
+            feeToken: message.feeToken ?? ZeroAddress,
+            extraArgs: hexlify(this.constructor.encodeExtraArgs(message.extraArgs)),
+        });
+    }
+    async sendMessage(router_, destChainSelector, message, opts) {
+        const feeToken = message.feeToken ?? ZeroAddress;
+        const receiver = zeroPadValue(getAddressBytes(message.receiver), 32);
+        const data = hexlify(message.data);
+        const extraArgs = hexlify(this.constructor.encodeExtraArgs(message.extraArgs));
+        // make sure to approve once per token, for the total amount (including fee, if needed)
+        const amountsToApprove = (message.tokenAmounts ?? []).reduce((acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }), {});
+        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, {
+            receiver,
+            data,
+            tokenAmounts: message.tokenAmounts ?? [],
+            extraArgs,
+            feeToken,
+        }, {
+            nonce: nonce++,
+            // if native fee, include it in value; otherwise, it's transferedFrom feeToken
+            ...(feeToken === ZeroAddress ? { value: message.fee } : {}),
+        });
+        const receipt = await tx.wait(1);
+        return this.getTransaction(receipt);
+    }
+    fetchOffchainTokenData(request) {
+        return fetchEVMOffchainTokenData(request);
+    }
+    async executeReport(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 gasOverride = BigInt(opts?.gasLimit ?? 0);
+                manualExecTx = await contract.manuallyExecute({
+                    ...execReport,
+                    proofs: execReport.proofs.map((d) => hexlify(d)),
+                    messages: [execReport.message],
+                    offchainTokenData: [offchainTokenData],
+                }, [gasOverride]);
+                break;
+            }
+            case CCIPVersion.V1_5: {
+                const contract = new Contract(offRamp, EVM2EVMOffRamp_1_5_ABI, wallet);
+                manualExecTx = await contract.manuallyExecute({
+                    ...execReport,
+                    proofs: execReport.proofs.map((d) => hexlify(d)),
+                    messages: [execReport.message],
+                    offchainTokenData: [offchainTokenData],
+                }, [
+                    {
+                        receiverExecutionGasLimit: BigInt(opts?.gasLimit ?? 0),
+                        tokenGasOverrides: execReport.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) => ({
+                    ...ta,
+                    sourcePoolAddress: zeroPadValue(getAddressBytes(ta.sourcePoolAddress), 32),
+                    extraData: hexlify(getDataBytes(ta.extraData)),
+                }));
+                const message = {
+                    ...execReport.message,
+                    sender,
+                    tokenAmounts,
+                };
+                const contract = new Contract(offRamp, OffRamp_1_6_ABI, wallet);
+                manualExecTx = await contract.manuallyExecute([
+                    {
+                        ...execReport,
+                        proofs: execReport.proofs.map((p) => hexlify(p)),
+                        sourceChainSelector: execReport.message.header.sourceChainSelector,
+                        messages: [message],
+                        offchainTokenData: [offchainTokenData],
+                    },
+                ], [
+                    [
+                        {
+                            receiverExecutionGasLimit: BigInt(opts?.gasLimit ?? 0),
+                            tokenGasOverrides: execReport.message.tokenAmounts.map(() => BigInt(opts?.tokensGasLimit ?? opts?.gasLimit ?? 0)),
+                        },
+                    ],
+                ]);
+                break;
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+        const receipt = await this.provider.waitForTransaction(manualExecTx.hash, 1, 60e3);
+        if (!receipt?.hash)
+            throw new Error(`Could not confirm exec tx: ${manualExecTx.hash}`);
+        if (!receipt.status)
+            throw new Error(`Exec transaction reverted: ${manualExecTx.hash}`);
+        return this.getTransaction(receipt);
+    }
+    static parse(data) {
+        return parseData(data);
+    }
+    /**
+     * Get the supported tokens for a given contract address
+     *
+     * @param address Router, OnRamp, OffRamp or TokenAdminRegistry contract
+     * @returns An array of supported token addresses.
+     */
+    async getSupportedTokens(registry, opts) {
+        const contract = new Contract(registry, interfaces.TokenAdminRegistry, this.provider);
+        const limit = (opts?.page ?? 1000) || Number.MAX_SAFE_INTEGER;
+        const res = [];
+        let page;
+        do {
+            page = await contract.getAllConfiguredTokens(BigInt(res.length), BigInt(limit));
+            res.push(...page);
+        } while (page.length === limit);
+        return res;
+    }
+    async getRegistryTokenConfig(registry, token) {
+        const contract = new Contract(registry, interfaces.TokenAdminRegistry, this.provider);
+        const config = (await resultToObject(contract.getTokenConfig(token)));
+        if (!config.administrator || config.administrator === ZeroAddress)
+            throw new Error(`Token ${token} is not configured in registry ${registry}`);
+        if (!config.pendingAdministrator || config.pendingAdministrator === ZeroAddress)
+            delete config.pendingAdministrator;
+        if (!config.tokenPool || config.tokenPool === ZeroAddress)
+            delete config.tokenPool;
+        return {
+            ...config,
+            administrator: config.administrator,
+        };
+    }
+    async getTokenPoolConfigs(tokenPool) {
+        const [_, , typeAndVersion] = await this.typeAndVersion(tokenPool);
+        const contract = new Contract(tokenPool, interfaces.TokenPool_v1_6, this.provider);
+        const token = contract.getToken();
+        const router = contract.getRouter();
+        return Promise.all([token, router]).then(([token, router]) => {
+            return {
+                token: token,
+                router: router,
+                typeAndVersion,
+            };
+        });
+    }
+    async getTokenPoolRemotes(tokenPool, remoteChainSelector) {
+        const [_, version] = await this.typeAndVersion(tokenPool);
+        let supportedChains;
+        if (remoteChainSelector)
+            supportedChains = Promise.resolve([networkInfo(remoteChainSelector)]);
+        let remotePools;
+        let contract;
+        if (version < '1.5.1') {
+            const contract_ = new Contract(tokenPool, interfaces.TokenPool_v1_5, this.provider);
+            contract = contract_;
+            supportedChains ??= contract.getSupportedChains().then((chains) => chains.map(networkInfo));
+            remotePools = supportedChains.then((chains) => Promise.all(chains.map((chain) => contract_
+                .getRemotePool(chain.chainSelector)
+                .then((remotePool) => [decodeAddress(remotePool, chain.family)]))));
+        }
+        else {
+            const contract_ = new Contract(tokenPool, interfaces.TokenPool_v1_6, this.provider);
+            contract = contract_;
+            supportedChains ??= contract.getSupportedChains().then((chains) => chains.map(networkInfo));
+            remotePools = supportedChains.then((chains) => Promise.all(chains.map((chain) => contract_
+                .getRemotePools(chain.chainSelector)
+                .then((pools) => pools.map((remotePool) => decodeAddress(remotePool, chain.family))))));
+        }
+        const remoteInfo = supportedChains.then((chains) => Promise.all(chains.map((chain) => Promise.all([
+            contract.getRemoteToken(chain.chainSelector),
+            resultToObject(contract.getCurrentInboundRateLimiterState(chain.chainSelector)),
+            resultToObject(contract.getCurrentOutboundRateLimiterState(chain.chainSelector)),
+        ]))));
+        return Promise.all([supportedChains, remotePools, remoteInfo]).then(([supportedChains, remotePools, remoteInfo]) => Object.fromEntries(supportedChains.map((chain, i) => [
+            chain.name,
+            {
+                remoteToken: decodeAddress(remoteInfo[i][0], chain.family),
+                remotePools: remotePools[i].map((pool) => decodeAddress(pool, chain.family)),
+                inboundRateLimiterState: remoteInfo[i][1].isEnabled ? remoteInfo[i][1] : null,
+                outboundRateLimiterState: remoteInfo[i][2].isEnabled ? remoteInfo[i][2] : null,
+            },
+        ])));
+    }
+    async listFeeTokens(router) {
+        const onRamp = await this._getSomeOnRampFor(router);
+        const [_, version] = await this.typeAndVersion(onRamp);
+        let tokens;
+        let onRampABI;
+        switch (version) {
+            case CCIPVersion.V1_2:
+                onRampABI = EVM2EVMOnRamp_1_2_ABI;
+            // 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),
+                ]);
+                break;
+            }
+            case CCIPVersion.V1_6: {
+                const feeQuoter = await this.getFeeQuoterFor(onRamp);
+                const contract = new Contract(feeQuoter, interfaces.FeeQuoter, this.provider);
+                tokens = await contract.getFeeTokens();
+                break;
+            }
+            default:
+                throw new Error(`Unsupported version: ${version}`);
+        }
+        return Object.fromEntries(await Promise.all(tokens.map(async (token) => [token, await this.getTokenInfo(token)])));
+    }
+}
+supportedChains[ChainFamily.EVM] = EVMChain;
+//# sourceMappingURL=index.js.map