@across-protocol/contracts 3.0.17 → 3.0.19

package/dist/test/svm/utils.d.ts

@@ -1,42 +1,13 @@
-import { BN, Program } from "@coral-xyz/anchor";
-import { AccountMeta, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { AccountMeta, PublicKey } from "@solana/web3.js";
 import { BigNumber } from "ethers";
-import { SvmSpoke } from "../../target/types/svm_spoke";
-import { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress } from "../../src/SvmUtils";
+import { calculateRelayHashUint8Array, findProgramAddress, readEvents, readProgramEvents } from "../../src/svm";
 import { MerkleTree } from "@uma/common";
-import { RelayData } from "./SvmSpoke.common";
-export { readEvents, readProgramEvents, calculateRelayHashUint8Array, findProgramAddress };
+import { RelayerRefundLeafType } from "../../src/types/svm";
+export { calculateRelayHashUint8Array, findProgramAddress, readEvents, readProgramEvents };
 export declare function printLogs(connection: any, program: any, tx: any): Promise<void>;
 export declare function randomAddress(): string;
 export declare function randomBigInt(bytes?: number, signed?: boolean): bigint;
-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;
-export declare function convertLeafIdToNumber(leaf: RelayerRefundLeafSolana): {
-    leafId: number;
-    isSolana: boolean;
-    amountToReturn: BN;
-    chainId: BN;
-    refundAmounts: BN[];
-    mintPublicKey: PublicKey;
-    refundAddresses: PublicKey[];
-};
 export declare function buildRelayerRefundMerkleTree({ totalEvmDistributions, totalSolanaDistributions, mixLeaves, chainId, mint, svmRelayers, evmRelayers, evmTokenAddress, evmRefundAmounts, svmRefundAmounts, }: {
     totalEvmDistributions: number;
     totalSolanaDistributions: number;
@@ -52,40 +23,7 @@ export declare function buildRelayerRefundMerkleTree({ totalEvmDistributions, to
     relayerRefundLeaves: RelayerRefundLeafType[];
     merkleTree: MerkleTree<RelayerRefundLeafType>;
 };
-export declare function calculateRelayerRefundLeafHashUint8Array(relayData: RelayerRefundLeafSolana): string;
-export declare const relayerRefundHashFn: (input: RelayerRefundLeaf | RelayerRefundLeafSolana) => string;
-export interface SlowFillLeaf {
-    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;
-    };
-    chainId: BN;
-    updatedOutputAmount: BN;
-}
-export declare function slowFillHashFn(slowFillLeaf: SlowFillLeaf): string;
-export declare function loadExecuteRelayerRefundLeafParams(program: Program<SvmSpoke>, caller: PublicKey, rootBundleId: number, relayerRefundLeaf: RelayerRefundLeafSolana, proof: number[][]): Promise<PublicKey>;
-export declare function closeInstructionParams(program: Program<SvmSpoke>, signer: Keypair): Promise<void>;
-export declare function createFillV3RelayParamsInstructions(program: Program<SvmSpoke>, signer: PublicKey, relayData: RelayData, repaymentChainId: BN, repaymentAddress: PublicKey): Promise<{
-    loadInstructions: TransactionInstruction[];
-    closeInstruction: TransactionInstruction;
-}>;
-export declare function loadFillV3RelayParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData, repaymentChainId: BN, repaymentAddress: PublicKey): Promise<void>;
-export declare function loadRequestV3SlowFillParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData): Promise<TransactionInstruction[]>;
-export declare function loadExecuteV3SlowRelayLeafParams(program: Program<SvmSpoke>, signer: Keypair, slowFillLeaf: SlowFillLeaf, rootBundleId: number, proof: number[][]): Promise<TransactionInstruction[]>;
-export declare function intToU8Array32(num: number): number[];
-export declare function u8Array32ToInt(u8Array: Uint8Array): bigint;
 export declare function testAcrossPlusMessage(): {
     encodedMessage: Buffer;
     fillRemainingAccounts: AccountMeta[];
 };
-export declare function hashNonEmptyMessage(message: Buffer): Uint8Array;

package/dist/test/svm/utils.js

@@ -23,33 +23,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayerRefundHashFn = exports.findProgramAddress = exports.calculateRelayHashUint8Array = exports.readProgramEvents = exports.readEvents = void 0;
+exports.readProgramEvents = exports.readEvents = exports.findProgramAddress = exports.calculateRelayHashUint8Array = void 0;
 exports.printLogs = printLogs;
 exports.randomAddress = randomAddress;
 exports.randomBigInt = randomBigInt;
-exports.convertLeafIdToNumber = convertLeafIdToNumber;
 exports.buildRelayerRefundMerkleTree = buildRelayerRefundMerkleTree;
-exports.calculateRelayerRefundLeafHashUint8Array = calculateRelayerRefundLeafHashUint8Array;
-exports.slowFillHashFn = slowFillHashFn;
-exports.loadExecuteRelayerRefundLeafParams = loadExecuteRelayerRefundLeafParams;
-exports.closeInstructionParams = closeInstructionParams;
-exports.createFillV3RelayParamsInstructions = createFillV3RelayParamsInstructions;
-exports.loadFillV3RelayParams = loadFillV3RelayParams;
-exports.loadRequestV3SlowFillParams = loadRequestV3SlowFillParams;
-exports.loadExecuteV3SlowRelayLeafParams = loadExecuteV3SlowRelayLeafParams;
-exports.intToU8Array32 = intToU8Array32;
-exports.u8Array32ToInt = u8Array32ToInt;
 exports.testAcrossPlusMessage = testAcrossPlusMessage;
-exports.hashNonEmptyMessage = hashNonEmptyMessage;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
-const ethers_1 = require("ethers");
 const crypto = __importStar(require("crypto"));
-const SvmUtils_1 = require("../../src/SvmUtils");
-Object.defineProperty(exports, "readEvents", { enumerable: true, get: function () { return SvmUtils_1.readEvents; } });
-Object.defineProperty(exports, "readProgramEvents", { enumerable: true, get: function () { return SvmUtils_1.readProgramEvents; } });
-Object.defineProperty(exports, "calculateRelayHashUint8Array", { enumerable: true, get: function () { return SvmUtils_1.calculateRelayHashUint8Array; } });
-Object.defineProperty(exports, "findProgramAddress", { enumerable: true, get: function () { return SvmUtils_1.findProgramAddress; } });
+const ethers_1 = require("ethers");
+const svm_1 = require("../../src/svm");
+Object.defineProperty(exports, "calculateRelayHashUint8Array", { enumerable: true, get: function () { return svm_1.calculateRelayHashUint8Array; } });
+Object.defineProperty(exports, "findProgramAddress", { enumerable: true, get: function () { return svm_1.findProgramAddress; } });
+Object.defineProperty(exports, "readEvents", { enumerable: true, get: function () { return svm_1.readEvents; } });
+Object.defineProperty(exports, "readProgramEvents", { enumerable: true, get: function () { return svm_1.readProgramEvents; } });
 const common_1 = require("@uma/common");
 async function printLogs(connection, program, tx) {
     const latestBlockHash = await connection.getLatestBlockhash();
@@ -76,9 +64,6 @@ function randomBigInt(bytes = 8, signed = false) {
     const byteString = "0x" + Buffer.from(crypto.randomBytes(bytes)).toString("hex");
     return BigInt(sign + byteString);
 }
-function convertLeafIdToNumber(leaf) {
-    return { ...leaf, leafId: leaf.leafId.toNumber() };
-}
 function buildRelayerRefundMerkleTree({ totalEvmDistributions, totalSolanaDistributions, mixLeaves, chainId, mint, svmRelayers, evmRelayers, evmTokenAddress, evmRefundAmounts, svmRefundAmounts, }) {
     const relayerRefundLeaves = [];
     const createSolanaLeaf = (index) => ({
@@ -122,202 +107,15 @@ function buildRelayerRefundMerkleTree({ totalEvmDistributions, totalSolanaDistri
             relayerRefundLeaves.push(createEvmLeaf(i + totalSolanaDistributions));
         }
     }
-    const merkleTree = new common_1.MerkleTree(relayerRefundLeaves, exports.relayerRefundHashFn);
+    const merkleTree = new common_1.MerkleTree(relayerRefundLeaves, svm_1.relayerRefundHashFn);
     return { relayerRefundLeaves, merkleTree };
 }
-function calculateRelayerRefundLeafHashUint8Array(relayData) {
-    const refundAmountsBuffer = Buffer.concat(relayData.refundAmounts.map((amount) => {
-        const buf = Buffer.alloc(8);
-        amount.toArrayLike(Buffer, "le", 8).copy(buf);
-        return buf;
-    }));
-    const refundAddressesBuffer = Buffer.concat(relayData.refundAddresses.map((address) => address.toBuffer()));
-    // TODO: We better consider reusing Borch serializer in production.
-    const contentToHash = Buffer.concat([
-        // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves can never be played on SVM and vice versa.
-        Buffer.alloc(64, 0),
-        relayData.amountToReturn.toArrayLike(Buffer, "le", 8),
-        relayData.chainId.toArrayLike(Buffer, "le", 8),
-        new anchor_1.BN(relayData.refundAmounts.length).toArrayLike(Buffer, "le", 4),
-        refundAmountsBuffer,
-        relayData.leafId.toArrayLike(Buffer, "le", 4),
-        relayData.mintPublicKey.toBuffer(),
-        new anchor_1.BN(relayData.refundAddresses.length).toArrayLike(Buffer, "le", 4),
-        refundAddressesBuffer,
-    ]);
-    const relayHash = ethers_1.ethers.utils.keccak256(contentToHash);
-    return relayHash;
-}
-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;
-// TODO: We better consider reusing Borch serializer in production.
-function slowFillHashFn(slowFillLeaf) {
-    const contentToHash = Buffer.concat([
-        // SVM leaves require the first 64 bytes to be 0 to ensure EVM leaves can never be played on SVM and vice versa.
-        Buffer.alloc(64, 0),
-        slowFillLeaf.relayData.depositor.toBuffer(),
-        slowFillLeaf.relayData.recipient.toBuffer(),
-        slowFillLeaf.relayData.exclusiveRelayer.toBuffer(),
-        slowFillLeaf.relayData.inputToken.toBuffer(),
-        slowFillLeaf.relayData.outputToken.toBuffer(),
-        slowFillLeaf.relayData.inputAmount.toArrayLike(Buffer, "le", 8),
-        slowFillLeaf.relayData.outputAmount.toArrayLike(Buffer, "le", 8),
-        slowFillLeaf.relayData.originChainId.toArrayLike(Buffer, "le", 8),
-        Buffer.from(slowFillLeaf.relayData.depositId),
-        new anchor_1.BN(slowFillLeaf.relayData.fillDeadline).toArrayLike(Buffer, "le", 4),
-        new anchor_1.BN(slowFillLeaf.relayData.exclusivityDeadline).toArrayLike(Buffer, "le", 4),
-        new anchor_1.BN(slowFillLeaf.relayData.message.length).toArrayLike(Buffer, "le", 4),
-        slowFillLeaf.relayData.message,
-        slowFillLeaf.chainId.toArrayLike(Buffer, "le", 8),
-        slowFillLeaf.updatedOutputAmount.toArrayLike(Buffer, "le", 8),
-    ]);
-    const slowFillHash = ethers_1.ethers.utils.keccak256(contentToHash);
-    return slowFillHash;
-}
-async function loadExecuteRelayerRefundLeafParams(program, caller, rootBundleId, relayerRefundLeaf, proof) {
-    const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-    // Close the instruction params account if the caller has used it before.
-    const [instructionParams] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("instruction_params"), caller.toBuffer()], program.programId);
-    const accountInfo = await program.provider.connection.getAccountInfo(instructionParams);
-    if (accountInfo !== null)
-        await program.methods.closeInstructionParams().rpc();
-    const accountCoder = new SvmUtils_1.LargeAccountsCoder(program.idl);
-    const instructionParamsBytes = await accountCoder.encode("executeRelayerRefundLeafParams", {
-        rootBundleId,
-        relayerRefundLeaf,
-        proof,
-    });
-    await program.methods.initializeInstructionParams(instructionParamsBytes.length).rpc();
-    for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-        const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-        await program.methods.writeInstructionParamsFragment(i, fragment).rpc();
-    }
-    return instructionParams;
-}
-async function closeInstructionParams(program, signer) {
-    const [instructionParams] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("instruction_params"), signer.publicKey.toBuffer()], program.programId);
-    const accountInfo = await program.provider.connection.getAccountInfo(instructionParams);
-    if (accountInfo !== null) {
-        const closeIx = await program.methods.closeInstructionParams().accounts({ signer: signer.publicKey }).instruction();
-        await (0, web3_js_1.sendAndConfirmTransaction)(program.provider.connection, new web3_js_1.Transaction().add(closeIx), [signer]);
-    }
-}
-async function createFillV3RelayParamsInstructions(program, signer, relayData, repaymentChainId, repaymentAddress) {
-    const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-    const accountCoder = new SvmUtils_1.LargeAccountsCoder(program.idl);
-    const instructionParamsBytes = await accountCoder.encode("fillV3RelayParams", {
-        relayData,
-        repaymentChainId,
-        repaymentAddress,
-    });
-    const loadInstructions = [];
-    loadInstructions.push(await program.methods.initializeInstructionParams(instructionParamsBytes.length).accounts({ signer }).instruction());
-    for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-        const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-        loadInstructions.push(await program.methods.writeInstructionParamsFragment(i, fragment).accounts({ signer }).instruction());
-    }
-    const closeInstruction = await program.methods.closeInstructionParams().accounts({ signer }).instruction();
-    return { loadInstructions, closeInstruction };
-}
-async function loadFillV3RelayParams(program, signer, relayData, repaymentChainId, repaymentAddress) {
-    // Close the instruction params account if the caller has used it before.
-    await closeInstructionParams(program, signer);
-    // Execute load instructions sequentially.
-    const { loadInstructions } = await createFillV3RelayParamsInstructions(program, signer.publicKey, relayData, repaymentChainId, repaymentAddress);
-    for (let i = 0; i < loadInstructions.length; i += 1) {
-        await (0, web3_js_1.sendAndConfirmTransaction)(program.provider.connection, new web3_js_1.Transaction().add(loadInstructions[i]), [signer]);
-    }
-}
-async function loadRequestV3SlowFillParams(program, signer, relayData) {
-    // Close the instruction params account if the caller has used it before.
-    await closeInstructionParams(program, signer);
-    // Execute load instructions sequentially.
-    const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-    const accountCoder = new SvmUtils_1.LargeAccountsCoder(program.idl);
-    const instructionParamsBytes = await accountCoder.encode("requestV3SlowFillParams", { relayData });
-    const loadInstructions = [];
-    loadInstructions.push(await program.methods
-        .initializeInstructionParams(instructionParamsBytes.length)
-        .accounts({ signer: signer.publicKey })
-        .instruction());
-    for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-        const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-        loadInstructions.push(await program.methods
-            .writeInstructionParamsFragment(i, fragment)
-            .accounts({ signer: signer.publicKey })
-            .instruction());
-    }
-    return loadInstructions;
-}
-async function loadExecuteV3SlowRelayLeafParams(program, signer, slowFillLeaf, rootBundleId, proof) {
-    // Close the instruction params account if the caller has used it before.
-    await closeInstructionParams(program, signer);
-    // Execute load instructions sequentially.
-    const maxInstructionParamsFragment = 900; // Should not exceed message size limit when writing to the data account.
-    const accountCoder = new SvmUtils_1.LargeAccountsCoder(program.idl);
-    const instructionParamsBytes = await accountCoder.encode("executeV3SlowRelayLeafParams", {
-        slowFillLeaf,
-        rootBundleId,
-        proof,
-    });
-    const loadInstructions = [];
-    loadInstructions.push(await program.methods
-        .initializeInstructionParams(instructionParamsBytes.length)
-        .accounts({ signer: signer.publicKey })
-        .instruction());
-    for (let i = 0; i < instructionParamsBytes.length; i += maxInstructionParamsFragment) {
-        const fragment = instructionParamsBytes.slice(i, i + maxInstructionParamsFragment);
-        loadInstructions.push(await program.methods
-            .writeInstructionParamsFragment(i, fragment)
-            .accounts({ signer: signer.publicKey })
-            .instruction());
-    }
-    return loadInstructions;
-}
-function intToU8Array32(num) {
-    if (!Number.isInteger(num) || num < 0) {
-        throw new Error("Input must be a non-negative integer");
-    }
-    const u8Array = new Array(32).fill(0);
-    let i = 0;
-    while (num > 0 && i < 32) {
-        u8Array[i++] = num & 0xff; // Get least significant byte
-        num >>= 8; // Shift right by 8 bits
-    }
-    return u8Array;
-}
-function u8Array32ToInt(u8Array) {
-    if (!(u8Array instanceof Uint8Array) || u8Array.length !== 32) {
-        throw new Error("Input must be a Uint8Array of length 32");
-    }
-    return u8Array.reduce((num, byte, i) => num | (BigInt(byte) << BigInt(i * 8)), 0n);
-}
 // Encodes empty list of multicall handler instructions to be used as a test message field for fills.
 function testAcrossPlusMessage() {
     const handlerProgram = anchor_1.workspace.MulticallHandler;
-    const multicallHandlerCoder = new SvmUtils_1.MulticallHandlerCoder([]);
+    const multicallHandlerCoder = new svm_1.MulticallHandlerCoder([]);
     const handlerMessage = multicallHandlerCoder.encode();
-    const message = new SvmUtils_1.AcrossPlusMessageCoder({
+    const message = new svm_1.AcrossPlusMessageCoder({
         handler: handlerProgram.programId,
         readOnlyLen: multicallHandlerCoder.readOnlyLen,
         valueAmount: new anchor_1.BN(0),
@@ -331,11 +129,3 @@ function testAcrossPlusMessage() {
     ];
     return { encodedMessage, fillRemainingAccounts };
 }
-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);
-}