@across-protocol/contracts 3.0.17 → 3.0.18

package/dist/scripts/svm/utils/helpers.d.ts

@@ -1,2 +1,33 @@
+import { RelayerRefundLeafSolana, RelayerRefundLeafType } from "../../../test/svm/utils";
+import { BigNumber } from "ethers";
+import { PublicKey } from "@solana/web3.js";
+import { MerkleTree } from "@uma/common";
+export declare const requireEnv: (name: string) => string;
+export declare const getSolanaChainId: (cluster: "devnet" | "mainnet") => BigNumber;
+export declare const formatUsdc: (amount: BigNumber) => string;
 export declare const fromBase58ToBytes32: (input: string) => string;
 export declare const fromBytes32ToAddress: (input: string) => string;
+export declare function constructEmptyPoolRebalanceTree(chainId: BigNumber, groupIndex: number): {
+    poolRebalanceLeaf: {
+        chainId: BigNumber;
+        groupIndex: BigNumber;
+        bundleLpFees: never[];
+        netSendAmounts: never[];
+        runningBalances: never[];
+        leafId: BigNumber;
+        l1Tokens: never[];
+    };
+    poolRebalanceTree: MerkleTree<{
+        chainId: BigNumber;
+        groupIndex: BigNumber;
+        bundleLpFees: never[];
+        netSendAmounts: never[];
+        runningBalances: never[];
+        leafId: BigNumber;
+        l1Tokens: never[];
+    }>;
+};
+export declare const constructSimpleRebalanceTreeToHubPool: (netSendAmount: BigNumber, solanaChainId: BigNumber, svmUsdc: PublicKey) => {
+    merkleTree: MerkleTree<RelayerRefundLeafType>;
+    leaves: RelayerRefundLeafSolana[];
+};

package/dist/scripts/svm/utils/helpers.js

@@ -1,7 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromBytes32ToAddress = exports.fromBase58ToBytes32 = void 0;
+exports.constructSimpleRebalanceTreeToHubPool = exports.fromBytes32ToAddress = exports.fromBase58ToBytes32 = exports.formatUsdc = exports.getSolanaChainId = exports.requireEnv = void 0;
+exports.constructEmptyPoolRebalanceTree = constructEmptyPoolRebalanceTree;
 const anchor_1 = require("@coral-xyz/anchor");
+const utils_1 = require("../../../test/svm/utils");
+const ethers_1 = require("ethers");
+const web3_js_1 = require("@solana/web3.js");
+const common_1 = require("@uma/common");
+const requireEnv = (name) => {
+    if (!process.env[name])
+        throw new Error(`Environment variable ${name} is not set`);
+    return process.env[name];
+};
+exports.requireEnv = requireEnv;
+const getSolanaChainId = (cluster) => {
+    return ethers_1.BigNumber.from(BigInt(ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.toUtf8Bytes(`solana-${cluster}`))) & BigInt("0xFFFFFFFFFFFFFFFF"));
+};
+exports.getSolanaChainId = getSolanaChainId;
+const formatUsdc = (amount) => {
+    return ethers_1.ethers.utils.formatUnits(amount, 6);
+};
+exports.formatUsdc = formatUsdc;
 const fromBase58ToBytes32 = (input) => {
     const decodedBytes = anchor_1.utils.bytes.bs58.decode(input);
     return "0x" + Buffer.from(decodedBytes).toString("hex");
@@ -19,3 +38,33 @@ const fromBytes32ToAddress = (input) => {
     return "0x" + address;
 };
 exports.fromBytes32ToAddress = fromBytes32ToAddress;
+function constructEmptyPoolRebalanceTree(chainId, groupIndex) {
+    const poolRebalanceLeaf = {
+        chainId,
+        groupIndex: ethers_1.BigNumber.from(groupIndex),
+        bundleLpFees: [],
+        netSendAmounts: [],
+        runningBalances: [],
+        leafId: ethers_1.BigNumber.from(0),
+        l1Tokens: [],
+    };
+    const rebalanceParamType = "tuple( uint256 chainId, uint256[] bundleLpFees, int256[] netSendAmounts, int256[] runningBalances, uint256 groupIndex, uint8 leafId, address[] l1Tokens )";
+    const rebalanceHashFn = (input) => ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.defaultAbiCoder.encode([rebalanceParamType], [input]));
+    const poolRebalanceTree = new common_1.MerkleTree([poolRebalanceLeaf], rebalanceHashFn);
+    return { poolRebalanceLeaf, poolRebalanceTree };
+}
+const constructSimpleRebalanceTreeToHubPool = (netSendAmount, solanaChainId, svmUsdc) => {
+    const relayerRefundLeaves = [];
+    relayerRefundLeaves.push({
+        isSolana: true,
+        leafId: new anchor_1.BN(0),
+        chainId: new anchor_1.BN(solanaChainId.toString()),
+        amountToReturn: new anchor_1.BN(netSendAmount.toString()),
+        mintPublicKey: new web3_js_1.PublicKey(svmUsdc),
+        refundAddresses: [],
+        refundAmounts: [],
+    });
+    const merkleTree = new common_1.MerkleTree(relayerRefundLeaves, utils_1.relayerRefundHashFn);
+    return { merkleTree, leaves: relayerRefundLeaves };
+};
+exports.constructSimpleRebalanceTreeToHubPool = constructSimpleRebalanceTreeToHubPool;

package/dist/scripts/svm/utils/poolRebalanceTree.d.ts

@@ -0,0 +1,22 @@
+import { MerkleTree } from "@uma/common";
+import { BigNumber } from "ethers";
+export declare function constructSimpleRebalanceTree(l1TokenAddress: string, netSendAmount: BigNumber, chainId: BigNumber): {
+    poolRebalanceLeaf: {
+        chainId: BigNumber;
+        groupIndex: BigNumber;
+        bundleLpFees: BigNumber[];
+        netSendAmounts: BigNumber[];
+        runningBalances: BigNumber[];
+        leafId: BigNumber;
+        l1Tokens: string[];
+    };
+    poolRebalanceTree: MerkleTree<{
+        chainId: BigNumber;
+        groupIndex: BigNumber;
+        bundleLpFees: BigNumber[];
+        netSendAmounts: BigNumber[];
+        runningBalances: BigNumber[];
+        leafId: BigNumber;
+        l1Tokens: string[];
+    }>;
+};

package/dist/scripts/svm/utils/poolRebalanceTree.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructSimpleRebalanceTree = constructSimpleRebalanceTree;
+const common_1 = require("@uma/common");
+const ethers_1 = require("ethers");
+function constructSimpleRebalanceTree(l1TokenAddress, netSendAmount, chainId) {
+    const poolRebalanceLeaf = {
+        chainId,
+        groupIndex: ethers_1.BigNumber.from(1), // Not 0 as this script is not relaying root bundles, only sending tokens to spoke.
+        bundleLpFees: [ethers_1.BigNumber.from(0)],
+        netSendAmounts: [netSendAmount],
+        runningBalances: [netSendAmount],
+        leafId: ethers_1.BigNumber.from(0),
+        l1Tokens: [l1TokenAddress],
+    };
+    const rebalanceParamType = "tuple( uint256 chainId, uint256[] bundleLpFees, int256[] netSendAmounts, int256[] runningBalances, uint256 groupIndex, uint8 leafId, address[] l1Tokens )";
+    const rebalanceHashFn = (input) => ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.defaultAbiCoder.encode([rebalanceParamType], [input]));
+    const poolRebalanceTree = new common_1.MerkleTree([poolRebalanceLeaf], rebalanceHashFn);
+    return { poolRebalanceLeaf, poolRebalanceTree };
+}

package/dist/src/SvmUtils.d.ts

@@ -4,12 +4,32 @@ export declare function findProgramAddress(label: string, program: PublicKey, ex
     publicKey: web3.PublicKey;
     bump: number;
 };
-export declare function readEvents<IDL extends Idl = Idl>(connection: Connection, txSignature: string, programs: Program<IDL>[], commitment?: Finality): Promise<any[]>;
+export declare function readEvents<IDL extends Idl = Idl>(connection: Connection, txSignature: string, programs: Program<IDL>[], commitment?: Finality): Promise<{
+    program: web3.PublicKey;
+    data: any;
+    name: string | undefined;
+}[]>;
+export declare function readEventsUntilFound<IDL extends Idl = Idl>(connection: Connection, txSignature: string, programs: Program<IDL>[]): Promise<{
+    program: web3.PublicKey;
+    data: any;
+    name: string | undefined;
+}[]>;
 export declare function getEvent(events: any[], program: PublicKey, eventName: string): any;
-export declare function readProgramEvents(connection: Connection, program: Program<any>, options?: SignaturesForAddressOptions, finality?: Finality): Promise<any[]>;
+export interface EventType {
+    program: PublicKey;
+    data: any;
+    name: string;
+    slot: number;
+    confirmationStatus: string;
+    blockTime: number;
+    signature: string;
+}
+export declare function readProgramEvents(connection: Connection, program: Program<any>, finality?: Finality, options?: SignaturesForAddressOptions): Promise<EventType[]>;
 export declare function subscribeToCpiEventsForProgram(connection: Connection, program: Program<any>, callback: (events: any[]) => void): Promise<number>;
 export declare const evmAddressToPublicKey: (address: string) => PublicKey;
+export declare const publicKeyToEvmAddress: (publicKey: PublicKey | string) => string;
 export declare function calculateRelayHashUint8Array(relayData: any, chainId: BN): Uint8Array;
+export declare function calculateRelayEventHashUint8Array(relayEventData: any, chainId: BN): Uint8Array;
 export declare const readUInt256BE: (buffer: Buffer) => BigInt;
 export declare class LargeAccountsCoder<A extends string = string> extends BorshAccountsCoder<A> {
     private getAccountLayouts;
@@ -47,4 +67,6 @@ export declare function sendTransactionWithLookupTable(connection: Connection, i
     txSignature: string;
     lookupTableAddress: PublicKey;
 }>;
+export declare function hashNonEmptyMessage(message: Buffer): Uint8Array;
+export declare function strPublicKey(publicKey: PublicKey): string;
 export {};

package/dist/src/SvmUtils.js

@@ -26,14 +26,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcrossPlusMessageCoder = exports.MulticallHandlerCoder = exports.LargeAccountsCoder = exports.readUInt256BE = exports.evmAddressToPublicKey = void 0;
+exports.AcrossPlusMessageCoder = exports.MulticallHandlerCoder = exports.LargeAccountsCoder = exports.readUInt256BE = exports.publicKeyToEvmAddress = exports.evmAddressToPublicKey = void 0;
 exports.findProgramAddress = findProgramAddress;
 exports.readEvents = readEvents;
+exports.readEventsUntilFound = readEventsUntilFound;
 exports.getEvent = getEvent;
 exports.readProgramEvents = readProgramEvents;
 exports.subscribeToCpiEventsForProgram = subscribeToCpiEventsForProgram;
 exports.calculateRelayHashUint8Array = calculateRelayHashUint8Array;
+exports.calculateRelayEventHashUint8Array = calculateRelayEventHashUint8Array;
 exports.sendTransactionWithLookupTable = sendTransactionWithLookupTable;
+exports.hashNonEmptyMessage = hashNonEmptyMessage;
+exports.strPublicKey = strPublicKey;
 //TODO: we will need to move this to a better location and integrate it more directly with other utils & files in time.
 // eslint-disable-next-line node/no-extraneous-import
 const borsh = __importStar(require("@coral-xyz/borsh"));
@@ -64,26 +68,30 @@ function findProgramAddress(label, program, extraSeeds) {
     return { publicKey: res[0], bump: res[1] };
 }
 async function readEvents(connection, txSignature, programs, commitment = "confirmed") {
-    const txResult = await connection.getTransaction(txSignature, {
-        commitment,
-        maxSupportedTransactionVersion: 0,
-    });
-    let eventAuthorities = new Map();
+    const txResult = await connection.getTransaction(txSignature, { commitment, maxSupportedTransactionVersion: 0 });
+    if (txResult === null)
+        return [];
+    return processEventFromTx(txResult, programs);
+}
+function processEventFromTx(txResult, programs) {
+    const eventAuthorities = new Map();
     for (const program of programs) {
-        eventAuthorities.set(program.programId.toString(), findProgramAddress("__event_authority", program.programId).publicKey.toString());
+        eventAuthorities.set(program.programId.toString(), findProgramAddress("__event_authority", program.programId).publicKey);
     }
-    let events = [];
-    // TODO: Add support for version 0 transactions.
-    if (!txResult || txResult.transaction.message.version !== "legacy")
-        return events;
+    const events = [];
+    // Resolve any potential addresses that were passed from address lookup tables.
+    const messageAccountKeys = txResult.transaction.message.getAccountKeys({
+        accountKeysFromLookups: txResult.meta?.loadedAddresses,
+    });
     for (const ixBlock of txResult.meta?.innerInstructions ?? []) {
         for (const ix of ixBlock.instructions) {
             for (const program of programs) {
-                const programStr = program.programId.toString();
-                if (ix.accounts.length === 1 &&
-                    txResult.transaction.message.accountKeys[ix.programIdIndex].toString() === programStr &&
-                    txResult.transaction.message.accountKeys[ix.accounts[0]].toString() ===
-                        eventAuthorities.get(programStr)) {
+                const ixProgramId = messageAccountKeys.get(ix.programIdIndex);
+                const singleIxAccount = ix.accounts.length === 1 ? messageAccountKeys.get(ix.accounts[0]) : undefined;
+                if (ixProgramId !== undefined &&
+                    singleIxAccount !== undefined &&
+                    program.programId.equals(ixProgramId) &&
+                    eventAuthorities.get(ixProgramId.toString())?.equals(singleIxAccount)) {
                     const ixData = anchor_1.utils.bytes.bs58.decode(ix.data);
                     const eventData = anchor_1.utils.bytes.base64.encode(Buffer.from(new Uint8Array(ixData).slice(8)));
                     const event = program.coder.events.decode(eventData);
@@ -98,6 +106,22 @@ async function readEvents(connection, txSignature, programs, commitment = "confi
     }
     return events;
 }
+// Helper function to wait for an event to be emitted. Should only be used in tests where txSignature is known to emit.
+async function readEventsUntilFound(connection, txSignature, programs) {
+    const startTime = Date.now();
+    let txResult = null;
+    while (Date.now() - startTime < 5000) {
+        // 5 seconds timeout to wait to find the event.
+        txResult = await connection.getTransaction(txSignature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0,
+        });
+        if (txResult !== null)
+            return processEventFromTx(txResult, programs);
+        await new Promise((resolve) => setTimeout(resolve, 50)); // 50 ms delay between retries.
+    }
+    throw new Error("No event found within 5 seconds");
+}
 function getEvent(events, program, eventName) {
     for (const event of events) {
         if (event.name === eventName && program.toString() === event.program.toString()) {
@@ -106,13 +130,32 @@ function getEvent(events, program, eventName) {
     }
     throw new Error("Event " + eventName + " not found");
 }
-async function readProgramEvents(connection, program, options, finality = "confirmed") {
-    let events = [];
-    const pastSignatures = await connection.getSignaturesForAddress(program.programId, options, finality);
-    for (const signature of pastSignatures) {
-        events.push(...(await readEvents(connection, signature.signature, [program], finality)));
+async function readProgramEvents(connection, program, finality = "confirmed", options = { limit: 1000 }) {
+    const allSignatures = [];
+    // Fetch all signatures in sequential batches
+    while (true) {
+        const signatures = await connection.getSignaturesForAddress(program.programId, options, finality);
+        allSignatures.push(...signatures);
+        // Update options for the next batch. Set before to the last fetched signature.
+        if (signatures.length > 0) {
+            options = { ...options, before: signatures[signatures.length - 1].signature };
+        }
+        if (options.limit && signatures.length < options.limit)
+            break; // Exit early if the number of signatures < limit
     }
-    return events;
+    // Fetch events for all signatures in parallel
+    const eventsWithSlots = await Promise.all(allSignatures.map(async (signature) => {
+        const events = await readEvents(connection, signature.signature, [program], finality);
+        return events.map((event) => ({
+            ...event,
+            confirmationStatus: signature.confirmationStatus || "Unknown",
+            blockTime: signature.blockTime || 0,
+            signature: signature.signature,
+            slot: signature.slot,
+            name: event.name || "Unknown",
+        }));
+    }));
+    return eventsWithSlots.flat(); // Flatten the array of events & return.
 }
 async function subscribeToCpiEventsForProgram(connection, program, callback) {
     const subscriptionId = connection.onLogs(new web3_js_1.PublicKey(findProgramAddress("__event_authority", program.programId).publicKey.toString()), async (logs) => {
@@ -125,12 +168,19 @@ const evmAddressToPublicKey = (address) => {
     return new web3_js_1.PublicKey(ethers_1.ethers.utils.arrayify(bytes32Address));
 };
 exports.evmAddressToPublicKey = evmAddressToPublicKey;
+const publicKeyToEvmAddress = (publicKey) => {
+    // Convert the input to a PublicKey if it's a string
+    const pubKeyBuffer = typeof publicKey === "string" ? new web3_js_1.PublicKey(publicKey).toBuffer() : publicKey.toBuffer();
+    // Extract the last 20 bytes to get the Ethereum address
+    const addressBuffer = pubKeyBuffer.slice(-20);
+    // Convert the buffer to a hex string and prepend '0x'
+    return `0x${addressBuffer.toString("hex")}`;
+};
+exports.publicKeyToEvmAddress = publicKeyToEvmAddress;
 // TODO: we are inconsistant with where we are placing some utils. we have some stuff here, some stuff that we might
 // want to re-use within the test directory. more over, when moving things into the canonical across repo, we should
 // re-use the test utils there.
 function calculateRelayHashUint8Array(relayData, chainId) {
-    const messageBuffer = Buffer.alloc(4);
-    messageBuffer.writeUInt32LE(relayData.message.length, 0);
     const contentToHash = Buffer.concat([
         relayData.depositor.toBuffer(),
         relayData.recipient.toBuffer(),
@@ -143,8 +193,28 @@ function calculateRelayHashUint8Array(relayData, chainId) {
         Buffer.from(relayData.depositId),
         new anchor_1.BN(relayData.fillDeadline).toArrayLike(Buffer, "le", 4),
         new anchor_1.BN(relayData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
-        messageBuffer,
-        relayData.message,
+        hashNonEmptyMessage(relayData.message), // Replace with hash of message, so that relay hash can be recovered from event.
+        chainId.toArrayLike(Buffer, "le", 8),
+    ]);
+    const relayHash = ethers_1.ethers.utils.keccak256(contentToHash);
+    const relayHashBuffer = Buffer.from(relayHash.slice(2), "hex");
+    return new Uint8Array(relayHashBuffer);
+}
+// Same method as above, but message in the relayData is already hashed, as fetched from fill events.
+function calculateRelayEventHashUint8Array(relayEventData, chainId) {
+    const contentToHash = Buffer.concat([
+        relayEventData.depositor.toBuffer(),
+        relayEventData.recipient.toBuffer(),
+        relayEventData.exclusiveRelayer.toBuffer(),
+        relayEventData.inputToken.toBuffer(),
+        relayEventData.outputToken.toBuffer(),
+        relayEventData.inputAmount.toArrayLike(Buffer, "le", 8),
+        relayEventData.outputAmount.toArrayLike(Buffer, "le", 8),
+        relayEventData.originChainId.toArrayLike(Buffer, "le", 8),
+        Buffer.from(relayEventData.depositId),
+        new anchor_1.BN(relayEventData.fillDeadline).toArrayLike(Buffer, "le", 4),
+        new anchor_1.BN(relayEventData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
+        Buffer.from(relayEventData.messageHash), // Renamed to messageHash in the event data.
         chainId.toArrayLike(Buffer, "le", 8),
     ]);
     const relayHash = ethers_1.ethers.utils.keccak256(contentToHash);
@@ -413,3 +483,14 @@ async function sendTransactionWithLookupTable(connection, instructions, sender)
     const txSignature = await connection.sendTransaction(versionedTx);
     return { txSignature, lookupTableAddress };
 }
+function hashNonEmptyMessage(message) {
+    if (message.length > 0) {
+        const hash = ethers_1.ethers.utils.keccak256(message);
+        return Uint8Array.from(Buffer.from(hash.slice(2), "hex"));
+    }
+    // else return zeroed bytes32
+    return new Uint8Array(32);
+}
+function strPublicKey(publicKey) {
+    return new web3_js_1.PublicKey(publicKey).toString();
+}

package/dist/target/types/svm_spoke.d.ts

@@ -808,11 +808,7 @@ export type SvmSpoke = {
                 "### Required Accounts:",
                 "- signer (Signer): The account that authorizes the closure. Must be the relayer in the fill_status PDA.",
                 "- state (Writable): Spoke state PDA. Seed: [\"state\",state.seed] where seed is 0 on mainnet.",
-                "- fill_status (Writable): The FillStatusAccount PDA to be closed. Seed: [\"fills\",relay_hash].",
-                "",
-                "### Parameters:",
-                "- _relay_hash: The hash identifying the relay for which the fill status account is being closed.",
-                "- relay_data: The data structure containing information about the relay."
+                "- fill_status (Writable): The FillStatusAccount PDA to be closed."
             ];
             "discriminator": [
                 224,
@@ -855,45 +851,9 @@ export type SvmSpoke = {
                 {
                     "name": "fillStatus";
                     "writable": true;
-                    "pda": {
-                        "seeds": [
-                            {
-                                "kind": "const";
-                                "value": [
-                                    102,
-                                    105,
-                                    108,
-                                    108,
-                                    115
-                                ];
-                            },
-                            {
-                                "kind": "arg";
-                                "path": "relayHash";
-                            }
-                        ];
-                    };
-                }
-            ];
-            "args": [
-                {
-                    "name": "relayHash";
-                    "type": {
-                        "array": [
-                            "u8",
-                            32
-                        ];
-                    };
-                },
-                {
-                    "name": "relayData";
-                    "type": {
-                        "defined": {
-                            "name": "v3RelayData";
-                        };
-                    };
                 }
             ];
+            "args": [];
         },
         {
             "name": "closeInstructionParams";
@@ -5041,6 +5001,19 @@ export type SvmSpoke = {
                 66
             ];
         },
+        {
+            "name": "tokensBridged";
+            "discriminator": [
+                200,
+                201,
+                199,
+                39,
+                5,
+                238,
+                214,
+                196
+            ];
+        },
         {
             "name": "v3FundsDeposited";
             "discriminator": [
@@ -5375,6 +5348,10 @@ export type SvmSpoke = {
                     {
                         "name": "relayer";
                         "type": "pubkey";
+                    },
+                    {
+                        "name": "fillDeadline";
+                        "type": "u32";
                     }
                 ];
             };
@@ -5808,6 +5785,34 @@ export type SvmSpoke = {
                 ];
             };
         },
+        {
+            "name": "tokensBridged";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "amountToReturn";
+                        "type": "u64";
+                    },
+                    {
+                        "name": "chainId";
+                        "type": "u64";
+                    },
+                    {
+                        "name": "leafId";
+                        "type": "u32";
+                    },
+                    {
+                        "name": "l2TokenAddress";
+                        "type": "pubkey";
+                    },
+                    {
+                        "name": "caller";
+                        "type": "pubkey";
+                    }
+                ];
+            };
+        },
         {
             "name": "transferLiability";
             "type": {

package/dist/tasks/enableL1TokenAcrossEcosystem.js

@@ -5,38 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = require("hardhat/config");
 const assert_1 = __importDefault(require("assert"));
-const utils_1 = require("./utils");
 const constants_1 = require("../utils/constants");
-/**
- * Given a token symbol, determine whether it is a valid key for the TOKEN_SYMBOLS_MAP object.
- */
-function isTokenSymbol(symbol) {
-    return constants_1.TOKEN_SYMBOLS_MAP[symbol] !== undefined;
-}
-/**
- * Given a token symbol from the HubPool chain and a remote chain ID, resolve the relevant token symbol and address.
- */
-function resolveTokenOnChain(mainnetSymbol, chainId) {
-    (0, assert_1.default)(isTokenSymbol(mainnetSymbol), `Unrecognised token symbol (${mainnetSymbol})`);
-    let symbol = mainnetSymbol;
-    // Handle USDC special case where L1 USDC is mapped to different token symbols on L2s.
-    if (mainnetSymbol === "USDC") {
-        const symbols = ["USDC", "USDC.e", "USDbC", "USDzC"];
-        const tokenSymbol = symbols.find((symbol) => constants_1.TOKEN_SYMBOLS_MAP[symbol]?.addresses[chainId]);
-        if (!isTokenSymbol(tokenSymbol)) {
-            return;
-        }
-        symbol = tokenSymbol;
-    }
-    else if (symbol === "DAI" && chainId === constants_1.CHAIN_IDs.BLAST) {
-        symbol = "USDB";
-    }
-    const address = constants_1.TOKEN_SYMBOLS_MAP[symbol].addresses[chainId];
-    if (!address) {
-        return;
-    }
-    return { symbol, address };
-}
+const utils_1 = require("./utils");
 const { ARBITRUM, OPTIMISM } = constants_1.CHAIN_IDs;
 const NO_SYMBOL = "----";
 const NO_ADDRESS = "------------------------------------------";
@@ -65,7 +35,7 @@ const getChainsFromList = (taskArgInput) => taskArgInput
         throw new Error(`Defaulted to network \`hardhat\`; specify \`--network mainnet\` or \`--network sepolia\``);
     }
     const _matchedSymbol = Object.keys(constants_1.TOKEN_SYMBOLS_MAP).find((_symbol) => _symbol === symbol);
-    (0, assert_1.default)(isTokenSymbol(_matchedSymbol));
+    (0, assert_1.default)((0, utils_1.isTokenSymbol)(_matchedSymbol));
     const matchedSymbol = _matchedSymbol;
     const l1Token = constants_1.TOKEN_SYMBOLS_MAP[matchedSymbol].addresses[hubChainId];
     (0, assert_1.default)(l1Token !== undefined, `Could not find ${symbol} in TOKEN_SYMBOLS_MAP`);
@@ -98,7 +68,7 @@ const getChainsFromList = (taskArgInput) => taskArgInput
     const chainIds = enabledChainIds.filter((chainId) => inputChains.includes(chainId));
     console.log("\nLoading L2 companion token address for provided L1 token.");
     const tokens = Object.fromEntries(chainIds.map((chainId) => {
-        const token = resolveTokenOnChain(matchedSymbol, chainId);
+        const token = (0, utils_1.resolveTokenOnChain)(matchedSymbol, chainId);
         if (token === undefined) {
             return [chainId, { symbol: NO_SYMBOL, address: NO_ADDRESS }];
         }

package/dist/tasks/types.d.ts

@@ -0,0 +1,2 @@
+import { TOKEN_SYMBOLS_MAP } from "../utils/constants";
+export type TokenSymbol = keyof typeof TOKEN_SYMBOLS_MAP;

package/dist/tasks/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tasks/utils.d.ts

@@ -1,3 +1,4 @@
+import { TokenSymbol } from "./types";
 export declare const zeroAddress = "0x0000000000000000000000000000000000000000";
 export declare const minimalSpokePoolInterface: ({
     inputs: ({
@@ -46,3 +47,14 @@ export declare const minimalAdapterInterface: {
     type: string;
 }[];
 export declare function askYesNoQuestion(query: string): Promise<boolean>;
+/**
+ * Given a token symbol from the HubPool chain and a remote chain ID, resolve the relevant token symbol and address.
+ */
+export declare function resolveTokenOnChain(mainnetSymbol: string, chainId: number): {
+    symbol: TokenSymbol;
+    address: string;
+} | undefined;
+/**
+ * Given a token symbol, determine whether it is a valid key for the TOKEN_SYMBOLS_MAP object.
+ */
+export declare function isTokenSymbol(symbol: unknown): symbol is TokenSymbol;

package/dist/tasks/utils.js

@@ -5,8 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.minimalAdapterInterface = exports.minimalSpokePoolInterface = exports.zeroAddress = void 0;
 exports.askYesNoQuestion = askYesNoQuestion;
+exports.resolveTokenOnChain = resolveTokenOnChain;
+exports.isTokenSymbol = isTokenSymbol;
+const assert_1 = __importDefault(require("assert"));
 const ethers_1 = require("ethers");
 const readline_1 = __importDefault(require("readline"));
+const constants_1 = require("../utils/constants");
 exports.zeroAddress = ethers_1.ethers.constants.AddressZero;
 exports.minimalSpokePoolInterface = [
     {
@@ -162,3 +166,33 @@ async function askYesNoQuestion(query) {
         return false;
     return askYesNoQuestion(query);
 }
+/**
+ * Given a token symbol from the HubPool chain and a remote chain ID, resolve the relevant token symbol and address.
+ */
+function resolveTokenOnChain(mainnetSymbol, chainId) {
+    (0, assert_1.default)(isTokenSymbol(mainnetSymbol), `Unrecognised token symbol (${mainnetSymbol})`);
+    let symbol = mainnetSymbol;
+    // Handle USDC special case where L1 USDC is mapped to different token symbols on L2s.
+    if (mainnetSymbol === "USDC") {
+        const symbols = ["USDC", "USDC.e", "USDbC", "USDzC"];
+        const tokenSymbol = symbols.find((symbol) => constants_1.TOKEN_SYMBOLS_MAP[symbol]?.addresses[chainId]);
+        if (!isTokenSymbol(tokenSymbol)) {
+            return;
+        }
+        symbol = tokenSymbol;
+    }
+    else if (symbol === "DAI" && chainId === constants_1.CHAIN_IDs.BLAST) {
+        symbol = "USDB";
+    }
+    const address = constants_1.TOKEN_SYMBOLS_MAP[symbol].addresses[chainId];
+    if (!address) {
+        return;
+    }
+    return { symbol, address };
+}
+/**
+ * Given a token symbol, determine whether it is a valid key for the TOKEN_SYMBOLS_MAP object.
+ */
+function isTokenSymbol(symbol) {
+    return constants_1.TOKEN_SYMBOLS_MAP[symbol] !== undefined;
+}