@across-protocol/contracts 3.0.18 → 3.0.19

package/dist/src/svm/relayHashUtils.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayerRefundHashFn = exports.readUInt256BE = void 0;
+exports.calculateRelayHashUint8Array = calculateRelayHashUint8Array;
+exports.calculateRelayEventHashUint8Array = calculateRelayEventHashUint8Array;
+exports.hashNonEmptyMessage = hashNonEmptyMessage;
+exports.calculateRelayerRefundLeafHashUint8Array = calculateRelayerRefundLeafHashUint8Array;
+exports.slowFillHashFn = slowFillHashFn;
+const anchor_1 = require("@coral-xyz/anchor");
+const ethers_1 = require("ethers");
+const borsh_1 = require("borsh");
+/**
+ * Calculates the relay hash from relay data and chain ID.
+ */
+function calculateRelayHashUint8Array(relayData, chainId) {
+    const contentToHash = Buffer.concat([
+        relayData.depositor.toBuffer(),
+        relayData.recipient.toBuffer(),
+        relayData.exclusiveRelayer.toBuffer(),
+        relayData.inputToken.toBuffer(),
+        relayData.outputToken.toBuffer(),
+        relayData.inputAmount.toArrayLike(Buffer, "le", 8),
+        relayData.outputAmount.toArrayLike(Buffer, "le", 8),
+        relayData.originChainId.toArrayLike(Buffer, "le", 8),
+        Buffer.from(relayData.depositId),
+        new anchor_1.BN(relayData.fillDeadline).toArrayLike(Buffer, "le", 4),
+        new anchor_1.BN(relayData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
+        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);
+}
+/**
+ * Calculates the relay event hash from relay event data and chain ID.
+ */
+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);
+    const relayHashBuffer = Buffer.from(relayHash.slice(2), "hex");
+    return new Uint8Array(relayHashBuffer);
+}
+/**
+ * Reads a 256-bit unsigned integer from a buffer.
+ */
+const readUInt256BE = (buffer) => {
+    let result = BigInt(0);
+    for (let i = 0; i < buffer.length; i++) {
+        result = (result << BigInt(8)) + BigInt(buffer[i]);
+    }
+    return result;
+};
+exports.readUInt256BE = readUInt256BE;
+/**
+ * Hashes a non-empty message using Keccak256.
+ */
+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);
+}
+/**
+ * Class for relay data.
+ */
+class RelayData {
+    constructor(properties) {
+        Object.assign(this, properties);
+    }
+}
+/**
+ * Schema for relay data.
+ */
+const relayDataSchema = new Map([
+    [
+        RelayData,
+        {
+            kind: "struct",
+            fields: [
+                ["amountToReturn", "u64"],
+                ["chainId", "u64"],
+                ["refundAmounts", ["u64"]],
+                ["leafId", "u32"],
+                ["mintPublicKey", [32]],
+                ["refundAddresses", [[32]]],
+            ],
+        },
+    ],
+]);
+/**
+ * Calculates the relayer refund leaf hash for Solana.
+ */
+function calculateRelayerRefundLeafHashUint8Array(relayData) {
+    const refundAddresses = relayData.refundAddresses.map((address) => address.toBuffer());
+    const data = new RelayData({
+        amountToReturn: relayData.amountToReturn,
+        chainId: relayData.chainId,
+        refundAmounts: relayData.refundAmounts,
+        leafId: relayData.leafId,
+        mintPublicKey: relayData.mintPublicKey.toBuffer(),
+        refundAddresses: refundAddresses,
+    });
+    const serializedData = (0, borsh_1.serialize)(relayDataSchema, data);
+    // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves can never be played on SVM and vice versa.
+    const contentToHash = Buffer.concat([Buffer.alloc(64, 0), serializedData]);
+    return ethers_1.ethers.utils.keccak256(contentToHash);
+}
+/**
+ * Hash function for relayer refund leaves.
+ */
+const relayerRefundHashFn = (input) => {
+    if (!input.isSolana) {
+        const abiCoder = new ethers_1.ethers.utils.AbiCoder();
+        const encodedData = abiCoder.encode([
+            "tuple( uint256 amountToReturn, uint256 chainId, uint256[] refundAmounts, uint256 leafId, address l2TokenAddress, address[] refundAddresses)",
+        ], [
+            {
+                leafId: input.leafId,
+                chainId: input.chainId,
+                amountToReturn: input.amountToReturn,
+                l2TokenAddress: input.l2TokenAddress, // Type assertion
+                refundAddresses: input.refundAddresses, // Type assertion
+                refundAmounts: input.refundAmounts, // Type assertion
+            },
+        ]);
+        return ethers_1.ethers.utils.keccak256(encodedData);
+    }
+    else {
+        return calculateRelayerRefundLeafHashUint8Array(input);
+    }
+};
+exports.relayerRefundHashFn = relayerRefundHashFn;
+/**
+ * Class for slow fill data.
+ */
+class SlowFillData {
+    constructor(properties) {
+        Object.assign(this, properties);
+    }
+}
+/**
+ * Schema for slow fill data.
+ */
+const slowFillDataSchema = new Map([
+    [
+        SlowFillData,
+        {
+            kind: "struct",
+            fields: [
+                ["depositor", [32]],
+                ["recipient", [32]],
+                ["exclusiveRelayer", [32]],
+                ["inputToken", [32]],
+                ["outputToken", [32]],
+                ["inputAmount", "u64"],
+                ["outputAmount", "u64"],
+                ["originChainId", "u64"],
+                ["depositId", [32]],
+                ["fillDeadline", "u32"],
+                ["exclusivityDeadline", "u32"],
+                ["message", ["u8"]],
+                ["chainId", "u64"],
+                ["updatedOutputAmount", "u64"],
+            ],
+        },
+    ],
+]);
+/**
+ * Hash function for slow fill leaves.
+ */
+function slowFillHashFn(slowFillLeaf) {
+    const data = new SlowFillData({
+        depositor: Uint8Array.from(slowFillLeaf.relayData.depositor.toBuffer()),
+        recipient: Uint8Array.from(slowFillLeaf.relayData.recipient.toBuffer()),
+        exclusiveRelayer: Uint8Array.from(slowFillLeaf.relayData.exclusiveRelayer.toBuffer()),
+        inputToken: Uint8Array.from(slowFillLeaf.relayData.inputToken.toBuffer()),
+        outputToken: Uint8Array.from(slowFillLeaf.relayData.outputToken.toBuffer()),
+        inputAmount: slowFillLeaf.relayData.inputAmount,
+        outputAmount: slowFillLeaf.relayData.outputAmount,
+        originChainId: slowFillLeaf.relayData.originChainId,
+        depositId: Uint8Array.from(Buffer.from(slowFillLeaf.relayData.depositId)),
+        fillDeadline: slowFillLeaf.relayData.fillDeadline,
+        exclusivityDeadline: slowFillLeaf.relayData.exclusivityDeadline,
+        message: Uint8Array.from(slowFillLeaf.relayData.message),
+        chainId: slowFillLeaf.chainId,
+        updatedOutputAmount: slowFillLeaf.updatedOutputAmount,
+    });
+    const serializedData = (0, borsh_1.serialize)(slowFillDataSchema, data);
+    // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves cannot be played on SVM and vice versa
+    const contentToHash = Buffer.concat([Buffer.alloc(64, 0), serializedData]);
+    return ethers_1.ethers.utils.keccak256(contentToHash);
+}

package/dist/src/svm/solanaProgramUtils.d.ts

@@ -0,0 +1,38 @@
+import { Idl, Program, web3 } from "@coral-xyz/anchor";
+import { Connection, Finality, PublicKey, SignaturesForAddressOptions } from "@solana/web3.js";
+import { EventType } from "../types/svm";
+/**
+ * Finds a program address with a given label and optional extra seeds.
+ */
+export declare function findProgramAddress(label: string, program: PublicKey, extraSeeds?: string[]): {
+    publicKey: web3.PublicKey;
+    bump: number;
+};
+/**
+ * Reads events from a transaction.
+ */
+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;
+}[]>;
+/**
+ * Helper function to wait for an event to be emitted. Should only be used in tests where txSignature is known to emit.
+ */
+export declare function readEventsUntilFound<IDL extends Idl = Idl>(connection: Connection, txSignature: string, programs: Program<IDL>[]): Promise<{
+    program: web3.PublicKey;
+    data: any;
+    name: string | undefined;
+}[]>;
+/**
+ * Retrieves a specific event by name from a list of events.
+ */
+export declare function getEvent(events: any[], program: PublicKey, eventName: string): any;
+/**
+ * Reads all events for a specific program.
+ */
+export declare function readProgramEvents(connection: Connection, program: Program<any>, finality?: Finality, options?: SignaturesForAddressOptions): Promise<EventType[]>;
+/**
+ * Subscribes to CPI events for a program.
+ */
+export declare function subscribeToCpiEventsForProgram(connection: Connection, program: Program<any>, callback: (events: any[]) => void): Promise<number>;

package/dist/src/svm/solanaProgramUtils.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProgramAddress = findProgramAddress;
+exports.readEvents = readEvents;
+exports.readEventsUntilFound = readEventsUntilFound;
+exports.getEvent = getEvent;
+exports.readProgramEvents = readProgramEvents;
+exports.subscribeToCpiEventsForProgram = subscribeToCpiEventsForProgram;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * Finds a program address with a given label and optional extra seeds.
+ */
+function findProgramAddress(label, program, extraSeeds) {
+    const seeds = [Buffer.from(anchor_1.utils.bytes.utf8.encode(label))];
+    if (extraSeeds) {
+        for (const extraSeed of extraSeeds) {
+            if (typeof extraSeed === "string") {
+                seeds.push(Buffer.from(anchor_1.utils.bytes.utf8.encode(extraSeed)));
+            }
+            else if (Array.isArray(extraSeed)) {
+                seeds.push(Buffer.from(extraSeed));
+            }
+            else if (Buffer.isBuffer(extraSeed)) {
+                seeds.push(extraSeed);
+            }
+            else {
+                seeds.push(extraSeed.toBuffer());
+            }
+        }
+    }
+    const res = web3_js_1.PublicKey.findProgramAddressSync(seeds, program);
+    return { publicKey: res[0], bump: res[1] };
+}
+/**
+ * Reads events from a transaction.
+ */
+async function readEvents(connection, txSignature, programs, commitment = "confirmed") {
+    const txResult = await connection.getTransaction(txSignature, { commitment, maxSupportedTransactionVersion: 0 });
+    if (txResult === null)
+        return [];
+    return processEventFromTx(txResult, programs);
+}
+/**
+ * Processes events from a transaction.
+ */
+function processEventFromTx(txResult, programs) {
+    const eventAuthorities = new Map();
+    for (const program of programs) {
+        eventAuthorities.set(program.programId.toString(), findProgramAddress("__event_authority", program.programId).publicKey);
+    }
+    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 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);
+                    events.push({
+                        program: program.programId,
+                        data: event?.data,
+                        name: event?.name,
+                    });
+                }
+            }
+        }
+    }
+    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");
+}
+/**
+ * Retrieves a specific event by name from a list of events.
+ */
+function getEvent(events, program, eventName) {
+    for (const event of events) {
+        if (event.name === eventName && program.toString() === event.program.toString()) {
+            return event.data;
+        }
+    }
+    throw new Error("Event " + eventName + " not found");
+}
+/**
+ * Reads all events for a specific program.
+ */
+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
+    }
+    // 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.
+}
+/**
+ * Subscribes to CPI events for a program.
+ */
+async function subscribeToCpiEventsForProgram(connection, program, callback) {
+    const subscriptionId = connection.onLogs(new web3_js_1.PublicKey(findProgramAddress("__event_authority", program.programId).publicKey.toString()), async (logs) => {
+        callback(await readEvents(connection, logs.signature, [program], "confirmed"));
+    }, "confirmed");
+    return subscriptionId;
+}

package/dist/src/svm/transactionUtils.d.ts

@@ -0,0 +1,8 @@
+import { Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Sends a transaction using an Address Lookup Table for large numbers of accounts.
+ */
+export declare function sendTransactionWithLookupTable(connection: Connection, instructions: TransactionInstruction[], sender: Keypair): Promise<{
+    txSignature: string;
+    lookupTableAddress: PublicKey;
+}>;

package/dist/src/svm/transactionUtils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTransactionWithLookupTable = sendTransactionWithLookupTable;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * Sends a transaction using an Address Lookup Table for large numbers of accounts.
+ */
+async function sendTransactionWithLookupTable(connection, instructions, sender) {
+    // Maximum number of accounts that can be added to Address Lookup Table (ALT) in a single transaction.
+    const maxExtendedAccounts = 30;
+    // Consolidate addresses from all instructions into a single array for the ALT.
+    const lookupAddresses = Array.from(new Set(instructions.flatMap((instruction) => [
+        instruction.programId,
+        ...instruction.keys.map((accountMeta) => accountMeta.pubkey),
+    ])));
+    // Create instructions for creating and extending the ALT.
+    const [lookupTableInstruction, lookupTableAddress] = await web3_js_1.AddressLookupTableProgram.createLookupTable({
+        authority: sender.publicKey,
+        payer: sender.publicKey,
+        recentSlot: await connection.getSlot(),
+    });
+    // Submit the ALT creation transaction
+    await anchor_1.web3.sendAndConfirmTransaction(connection, new anchor_1.web3.Transaction().add(lookupTableInstruction), [sender], {
+        skipPreflight: true, // Avoids recent slot mismatch in simulation.
+    });
+    // Extend the ALT with all accounts making sure not to exceed the maximum number of accounts per transaction.
+    for (let i = 0; i < lookupAddresses.length; i += maxExtendedAccounts) {
+        const extendInstruction = web3_js_1.AddressLookupTableProgram.extendLookupTable({
+            lookupTable: lookupTableAddress,
+            authority: sender.publicKey,
+            payer: sender.publicKey,
+            addresses: lookupAddresses.slice(i, i + maxExtendedAccounts),
+        });
+        await anchor_1.web3.sendAndConfirmTransaction(connection, new anchor_1.web3.Transaction().add(extendInstruction), [sender], {
+            skipPreflight: true, // Avoids recent slot mismatch in simulation.
+        });
+    }
+    // Avoids invalid ALT index as ALT might not be active yet on the following tx.
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    // Fetch the AddressLookupTableAccount
+    const lookupTableAccount = (await connection.getAddressLookupTable(lookupTableAddress)).value;
+    if (lookupTableAccount === null)
+        throw new Error("AddressLookupTableAccount not fetched");
+    // Create the versioned transaction
+    const versionedTx = new web3_js_1.VersionedTransaction(new web3_js_1.TransactionMessage({
+        payerKey: sender.publicKey,
+        recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
+        instructions,
+    }).compileToV0Message([lookupTableAccount]));
+    // Sign and submit the versioned transaction.
+    versionedTx.sign([sender]);
+    const txSignature = await connection.sendTransaction(versionedTx);
+    return { txSignature, lookupTableAddress };
+}

package/dist/src/types/svm.d.ts

@@ -0,0 +1,118 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { BigNumber } from "ethers";
+/**
+ * Relayer Refund Interfaces
+ */
+export interface RelayerRefundLeaf {
+    isSolana: boolean;
+    amountToReturn: BigNumber;
+    chainId: BigNumber;
+    refundAmounts: BigNumber[];
+    leafId: BigNumber;
+    l2TokenAddress: string;
+    refundAddresses: string[];
+}
+export interface RelayerRefundLeafSolana {
+    isSolana: boolean;
+    amountToReturn: BN;
+    chainId: BN;
+    refundAmounts: BN[];
+    leafId: BN;
+    mintPublicKey: PublicKey;
+    refundAddresses: PublicKey[];
+}
+export type RelayerRefundLeafType = RelayerRefundLeaf | RelayerRefundLeafSolana;
+/**
+ * Slow Fill Leaf Interface
+ */
+export interface SlowFillLeaf {
+    relayData: RelayData;
+    chainId: BN;
+    updatedOutputAmount: BN;
+}
+/**
+ * Relay Data Interface
+ */
+export type RelayData = {
+    depositor: PublicKey;
+    recipient: PublicKey;
+    exclusiveRelayer: PublicKey;
+    inputToken: PublicKey;
+    outputToken: PublicKey;
+    inputAmount: BN;
+    outputAmount: BN;
+    originChainId: BN;
+    depositId: number[];
+    fillDeadline: number;
+    exclusivityDeadline: number;
+    message: Buffer;
+};
+/**
+ * Deposit Data Interfaces
+ */
+export interface DepositData {
+    depositor: PublicKey | null;
+    recipient: PublicKey;
+    inputToken: PublicKey | null;
+    outputToken: PublicKey;
+    inputAmount: BN;
+    outputAmount: BN;
+    destinationChainId: BN;
+    exclusiveRelayer: PublicKey;
+    quoteTimestamp: BN;
+    fillDeadline: BN;
+    exclusivityParameter: BN;
+    message: Buffer;
+}
+export type DepositDataValues = [
+    PublicKey,
+    PublicKey,
+    PublicKey,
+    PublicKey,
+    BN,
+    BN,
+    BN,
+    PublicKey,
+    number,
+    number,
+    number,
+    Buffer
+];
+/**
+ * Fill Data Interfaces
+ */
+export type FillDataValues = [number[], RelayData, BN, PublicKey];
+export type FillDataParams = [number[], RelayData | null, BN | null, PublicKey | null];
+/**
+ * Request V3 Slow Fill Data Interfaces
+ */
+export type RequestV3SlowFillDataValues = [number[], RelayData];
+export type RequestV3SlowFillDataParams = [number[], RelayData | null];
+/**
+ * Execute V3 Slow Relay Leaf Data Interfaces
+ */
+export type ExecuteV3SlowRelayLeafDataValues = [number[], SlowFillLeaf, number, number[][]];
+export type ExecuteV3SlowRelayLeafDataParams = [number[], SlowFillLeaf | null, number | null, number[][] | null];
+/**
+ * Across+ Message Interface
+ */
+export type AcrossPlusMessage = {
+    handler: PublicKey;
+    readOnlyLen: number;
+    valueAmount: BN;
+    accounts: PublicKey[];
+    handlerMessage: Buffer;
+};
+/**
+ * Event Type Interface
+ */
+export interface EventType {
+    program: PublicKey;
+    data: any;
+    name: string;
+    slot: number;
+    confirmationStatus: string;
+    blockTime: number;
+    signature: string;
+}

package/dist/src/types/svm.js

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

package/dist/test/svm/MulticallHandler.js

@@ -27,7 +27,7 @@ const anchor = __importStar(require("@coral-xyz/anchor"));
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
-const SvmUtils_1 = require("../../src/SvmUtils");
+const svm_1 = require("../../src/svm");
 const SvmSpoke_common_1 = require("./SvmSpoke.common");
 const { provider, owner, connection, assertSE } = SvmSpoke_common_1.common;
 describe("multicall_handler", () => {
@@ -47,7 +47,7 @@ describe("multicall_handler", () => {
         const recipient = web3_js_1.Keypair.generate().publicKey;
         const recipientATA = (await (0, spl_token_1.getOrCreateAssociatedTokenAccount)(connection, payer, mint, recipient)).address;
         const transferIx = (0, spl_token_1.createTransferCheckedInstruction)(handlerATA, mint, recipientATA, handlerSigner, tokenAmount, mintDecimals);
-        const multicallHandlerCoder = new SvmUtils_1.MulticallHandlerCoder([transferIx]);
+        const multicallHandlerCoder = new svm_1.MulticallHandlerCoder([transferIx]);
         const handlerMessage = multicallHandlerCoder.encode();
         await program.methods
             .handleV3AcrossMessage(handlerMessage)