@across-protocol/contracts 3.0.18 → 3.0.19

package/dist/src/svm/coders.js

@@ -0,0 +1,250 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const idl_1 = require("@coral-xyz/anchor/dist/cjs/coder/borsh/idl");
+const borsh = __importStar(require("@coral-xyz/borsh"));
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+/**
+ * Extended Anchor accounts coder to handle large account data.
+ */
+class LargeAccountsCoder extends anchor_1.BorshAccountsCoder {
+    // Getter to access the private accountLayouts property from base class.
+    getAccountLayouts() {
+        return this.accountLayouts;
+    }
+    async encode(accountName, account) {
+        const buffer = Buffer.alloc(10240); // We don't currently need anything above instruction data account reallocation limit.
+        const layout = this.getAccountLayouts().get(accountName);
+        if (!layout) {
+            throw new Error(`Unknown account: ${accountName}`);
+        }
+        const len = layout.encode(account, buffer);
+        const accountData = buffer.slice(0, len);
+        const discriminator = this.accountDiscriminator(accountName);
+        return Buffer.concat([discriminator, accountData]);
+    }
+}
+exports.LargeAccountsCoder = LargeAccountsCoder;
+/**
+ * Extended version of legacy CompiledKeys to handle compilation of unsigned transactions. Base implementation is here:
+ * https://github.com/solana-labs/solana-web3.js/blob/v1.95.3/src/message/compiled-keys.ts
+ */
+class UnsignedCompiledKeys {
+    constructor(keyModeMap, payer) {
+        this.keyModeMap = keyModeMap;
+        this.payer = payer;
+    }
+    static compileUnsigned(instructions, payer) {
+        const keyModeMap = new Map();
+        const getOrInsertDefault = (pubkey) => {
+            const address = pubkey.toBase58();
+            let keyMode = keyModeMap.get(address);
+            if (keyMode === undefined) {
+                keyMode = {
+                    isWritable: false,
+                };
+                keyModeMap.set(address, keyMode);
+            }
+            return keyMode;
+        };
+        if (payer !== undefined) {
+            const payerKeyMode = getOrInsertDefault(payer);
+            payerKeyMode.isWritable = true;
+        }
+        for (const ix of instructions) {
+            getOrInsertDefault(ix.programId);
+            for (const accountMeta of ix.keys) {
+                const keyMode = getOrInsertDefault(accountMeta.pubkey);
+                keyMode.isWritable ||= accountMeta.isWritable;
+            }
+        }
+        return new UnsignedCompiledKeys(keyModeMap, payer);
+    }
+    getMessageComponents() {
+        const mapEntries = [...this.keyModeMap.entries()];
+        if (mapEntries.length > 256)
+            throw new Error("Max static account keys length exceeded");
+        const writableNonSigners = mapEntries.filter(([, mode]) => mode.isWritable);
+        const readonlyNonSigners = mapEntries.filter(([, mode]) => !mode.isWritable);
+        const header = {
+            numRequiredSignatures: 0,
+            numReadonlySignedAccounts: 0,
+            numReadonlyUnsignedAccounts: readonlyNonSigners.length,
+        };
+        const staticAccountKeys = [
+            ...writableNonSigners.map(([address]) => new web3_js_1.PublicKey(address)),
+            ...readonlyNonSigners.map(([address]) => new web3_js_1.PublicKey(address)),
+        ];
+        return [header, staticAccountKeys];
+    }
+}
+/**
+ * Extended version of legacy Message to handle compilation of unsigned transactions. Base implementation is here:
+ * https://github.com/solana-labs/solana-web3.js/blob/v1.95.3/src/message/legacy.ts
+ */
+class UnsignedMessage extends web3_js_1.Message {
+    static compileUnsigned(instructions, payer) {
+        const compiledKeys = UnsignedCompiledKeys.compileUnsigned(instructions, payer);
+        const [header, staticAccountKeys] = compiledKeys.getMessageComponents();
+        const accountKeys = new web3_js_1.MessageAccountKeys(staticAccountKeys);
+        const compiledInstructions = accountKeys.compileInstructions(instructions).map((ix) => ({
+            programIdIndex: ix.programIdIndex,
+            accounts: ix.accountKeyIndexes,
+            data: bs58_1.default.encode(ix.data),
+        }));
+        return new web3_js_1.Message({
+            header,
+            accountKeys: staticAccountKeys,
+            recentBlockhash: "", // Not used as we are not signing the transaction.
+            instructions: compiledInstructions,
+        });
+    }
+}
+/**
+ * Helper to encode MulticallHandler transactions.
+ */
+class MulticallHandlerCoder {
+    constructor(instructions, payerKey) {
+        // Compile transaction message and keys.
+        this.compiledMessage = UnsignedMessage.compileUnsigned(instructions, payerKey);
+        // Setup the layout for the encoder.
+        const fieldLayouts = [idl_1.IdlCoder.fieldLayout(MulticallHandlerCoder.coderArg, MulticallHandlerCoder.coderTypes)];
+        this.layout = borsh.struct(fieldLayouts);
+    }
+    get readOnlyLen() {
+        return (this.compiledMessage.header.numReadonlySignedAccounts + this.compiledMessage.header.numReadonlyUnsignedAccounts);
+    }
+    get compiledKeyMetas() {
+        return this.compiledMessage.accountKeys.map((key, index) => {
+            return {
+                pubkey: key,
+                isSigner: this.compiledMessage.isAccountSigner(index),
+                isWritable: this.compiledMessage.isAccountWritable(index),
+            };
+        });
+    }
+    encode() {
+        const buffer = Buffer.alloc(1280);
+        const len = this.layout.encode({ compiledIxs: this.compiledMessage.compiledInstructions }, buffer);
+        return buffer.slice(0, len);
+    }
+}
+exports.MulticallHandlerCoder = MulticallHandlerCoder;
+MulticallHandlerCoder.coderArg = {
+    name: "compiledIxs",
+    type: {
+        vec: {
+            defined: {
+                name: "compiledIx",
+            },
+        },
+    },
+};
+MulticallHandlerCoder.coderTypes = [
+    {
+        name: "compiledIx",
+        type: {
+            kind: "struct",
+            fields: [
+                {
+                    name: "programIdIndex",
+                    type: "u8",
+                },
+                {
+                    name: "accountKeyIndexes",
+                    type: {
+                        vec: "u8",
+                    },
+                },
+                {
+                    name: "data",
+                    type: "bytes",
+                },
+            ],
+        },
+    },
+];
+/**
+ * Helper to encode Across+ messages.
+ */
+class AcrossPlusMessageCoder {
+    constructor(acrossPlusMessage) {
+        this.acrossPlusMessage = acrossPlusMessage;
+    }
+    encode() {
+        const fieldLayouts = [idl_1.IdlCoder.fieldLayout(AcrossPlusMessageCoder.coderArg, AcrossPlusMessageCoder.coderTypes)];
+        const layout = borsh.struct(fieldLayouts);
+        const buffer = Buffer.alloc(12800);
+        const len = layout.encode({ message: this.acrossPlusMessage }, buffer);
+        return buffer.slice(0, len);
+    }
+}
+exports.AcrossPlusMessageCoder = AcrossPlusMessageCoder;
+AcrossPlusMessageCoder.coderArg = {
+    name: "message",
+    type: {
+        defined: {
+            name: "acrossPlusMessage",
+        },
+    },
+};
+AcrossPlusMessageCoder.coderTypes = [
+    {
+        name: "acrossPlusMessage",
+        type: {
+            kind: "struct",
+            fields: [
+                {
+                    name: "handler",
+                    type: "pubkey",
+                },
+                {
+                    name: "readOnlyLen",
+                    type: "u8",
+                },
+                {
+                    name: "valueAmount",
+                    type: "u64",
+                },
+                {
+                    name: "accounts",
+                    type: {
+                        vec: "pubkey",
+                    },
+                },
+                {
+                    name: "handlerMessage",
+                    type: "bytes",
+                },
+            ],
+        },
+    },
+];

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

@@ -0,0 +1,22 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Converts an integer to a 32-byte Uint8Array.
+ */
+export declare function intToU8Array32(num: number | BN): number[];
+/**
+ * Converts a 32-byte Uint8Array to a bigint.
+ */
+export declare function u8Array32ToInt(u8Array: Uint8Array | number[]): bigint;
+/**
+ * Converts a string to a PublicKey.
+ */
+export declare function strPublicKey(publicKey: PublicKey): string;
+/**
+ * Converts an EVM address to a Solana PublicKey.
+ */
+export declare const evmAddressToPublicKey: (address: string) => PublicKey;
+/**
+ * Converts a Solana PublicKey to an EVM address.
+ */
+export declare const publicKeyToEvmAddress: (publicKey: PublicKey | string) => string;

package/dist/src/svm/conversionUtils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicKeyToEvmAddress = exports.evmAddressToPublicKey = void 0;
+exports.intToU8Array32 = intToU8Array32;
+exports.u8Array32ToInt = u8Array32ToInt;
+exports.strPublicKey = strPublicKey;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const ethers_1 = require("ethers");
+/**
+ * Converts an integer to a 32-byte Uint8Array.
+ */
+function intToU8Array32(num) {
+    let bigIntValue;
+    if (typeof num === "number") {
+        if (!Number.isInteger(num) || num < 0) {
+            throw new Error("Input must be a non-negative integer");
+        }
+        bigIntValue = BigInt(num);
+    }
+    else if (anchor_1.BN.isBN(num)) {
+        if (num.isNeg()) {
+            throw new Error("Input must be a non-negative BN");
+        }
+        bigIntValue = BigInt(num.toString());
+    }
+    else {
+        throw new Error("Input must be a non-negative integer or BN");
+    }
+    const u8Array = new Array(32).fill(0);
+    let i = 0;
+    while (bigIntValue > 0 && i < 32) {
+        u8Array[i++] = Number(bigIntValue & 0xffn); // Get least significant byte
+        bigIntValue >>= 8n; // Shift right by 8 bits
+    }
+    return u8Array;
+}
+/**
+ * Converts a 32-byte Uint8Array to a bigint.
+ */
+function u8Array32ToInt(u8Array) {
+    const isValidArray = (arr) => Array.isArray(arr) && arr.every(Number.isInteger);
+    if ((u8Array instanceof Uint8Array || isValidArray(u8Array)) && u8Array.length === 32) {
+        return Array.from(u8Array).reduce((num, byte, i) => num | (BigInt(byte) << BigInt(i * 8)), 0n);
+    }
+    throw new Error("Input must be a Uint8Array or an array of 32 numbers.");
+}
+/**
+ * Converts a string to a PublicKey.
+ */
+function strPublicKey(publicKey) {
+    return new web3_js_1.PublicKey(publicKey).toString();
+}
+/**
+ * Converts an EVM address to a Solana PublicKey.
+ */
+const evmAddressToPublicKey = (address) => {
+    const bytes32Address = `0x000000000000000000000000${address.replace("0x", "")}`;
+    return new web3_js_1.PublicKey(ethers_1.ethers.utils.arrayify(bytes32Address));
+};
+exports.evmAddressToPublicKey = evmAddressToPublicKey;
+/**
+ * Converts a Solana PublicKey to an EVM address.
+ */
+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;

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

@@ -0,0 +1,6 @@
+export * from "./relayHashUtils";
+export * from "./instructionParamsUtils";
+export * from "./conversionUtils";
+export * from "./transactionUtils";
+export * from "./solanaProgramUtils";
+export * from "./coders";

package/dist/src/svm/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./relayHashUtils"), exports);
+__exportStar(require("./instructionParamsUtils"), exports);
+__exportStar(require("./conversionUtils"), exports);
+__exportStar(require("./transactionUtils"), exports);
+__exportStar(require("./solanaProgramUtils"), exports);
+__exportStar(require("./coders"), exports);

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

@@ -0,0 +1,31 @@
+import { Keypair, TransactionInstruction, PublicKey } from "@solana/web3.js";
+import { Program, BN } from "@coral-xyz/anchor";
+import { RelayData, SlowFillLeaf, RelayerRefundLeafSolana } from "../types/svm";
+import { SvmSpoke } from "../../target/types/svm_spoke";
+/**
+ * Loads execute relayer refund leaf parameters.
+ */
+export declare function loadExecuteRelayerRefundLeafParams(program: Program<SvmSpoke>, caller: PublicKey, rootBundleId: number, relayerRefundLeaf: RelayerRefundLeafSolana, proof: number[][]): Promise<PublicKey>;
+/**
+ * Closes the instruction parameters account.
+ */
+export declare function closeInstructionParams(program: Program<SvmSpoke>, signer: Keypair): Promise<void>;
+/**
+ * Creates instructions to load fillV3 relay parameters.
+ */
+export declare function createFillV3RelayParamsInstructions(program: Program<SvmSpoke>, signer: PublicKey, relayData: RelayData, repaymentChainId: BN, repaymentAddress: PublicKey): Promise<{
+    loadInstructions: TransactionInstruction[];
+    closeInstruction: TransactionInstruction;
+}>;
+/**
+ * Loads fillV3 relay parameters.
+ */
+export declare function loadFillV3RelayParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData, repaymentChainId: BN, repaymentAddress: PublicKey): Promise<void>;
+/**
+ * Loads requestV3 slow fill parameters.
+ */
+export declare function loadRequestV3SlowFillParams(program: Program<SvmSpoke>, signer: Keypair, relayData: RelayData): Promise<TransactionInstruction[]>;
+/**
+ * Loads executeV3 slow relay leaf parameters.
+ */
+export declare function loadExecuteV3SlowRelayLeafParams(program: Program<SvmSpoke>, signer: Keypair, slowFillLeaf: SlowFillLeaf, rootBundleId: number, proof: number[][]): Promise<TransactionInstruction[]>;

package/dist/src/svm/instructionParamsUtils.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadExecuteRelayerRefundLeafParams = loadExecuteRelayerRefundLeafParams;
+exports.closeInstructionParams = closeInstructionParams;
+exports.createFillV3RelayParamsInstructions = createFillV3RelayParamsInstructions;
+exports.loadFillV3RelayParams = loadFillV3RelayParams;
+exports.loadRequestV3SlowFillParams = loadRequestV3SlowFillParams;
+exports.loadExecuteV3SlowRelayLeafParams = loadExecuteV3SlowRelayLeafParams;
+const web3_js_1 = require("@solana/web3.js");
+const coders_1 = require("./coders");
+/**
+ * Loads execute relayer refund leaf parameters.
+ */
+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 coders_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;
+}
+/**
+ * Closes the instruction parameters account.
+ */
+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]);
+    }
+}
+/**
+ * Creates instructions to load fillV3 relay parameters.
+ */
+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 coders_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 };
+}
+/**
+ * Loads fillV3 relay parameters.
+ */
+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]);
+    }
+}
+/**
+ * Loads requestV3 slow fill parameters.
+ */
+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 coders_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;
+}
+/**
+ * Loads executeV3 slow relay leaf parameters.
+ */
+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 coders_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;
+}

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

@@ -0,0 +1,30 @@
+import { BN } from "@coral-xyz/anchor";
+import { RelayerRefundLeaf, RelayerRefundLeafSolana, SlowFillLeaf } from "../types/svm";
+/**
+ * Calculates the relay hash from relay data and chain ID.
+ */
+export declare function calculateRelayHashUint8Array(relayData: any, chainId: BN): Uint8Array;
+/**
+ * Calculates the relay event hash from relay event data and chain ID.
+ */
+export declare function calculateRelayEventHashUint8Array(relayEventData: any, chainId: BN): Uint8Array;
+/**
+ * Reads a 256-bit unsigned integer from a buffer.
+ */
+export declare const readUInt256BE: (buffer: Buffer) => BigInt;
+/**
+ * Hashes a non-empty message using Keccak256.
+ */
+export declare function hashNonEmptyMessage(message: Buffer): Uint8Array;
+/**
+ * Calculates the relayer refund leaf hash for Solana.
+ */
+export declare function calculateRelayerRefundLeafHashUint8Array(relayData: RelayerRefundLeafSolana): string;
+/**
+ * Hash function for relayer refund leaves.
+ */
+export declare const relayerRefundHashFn: (input: RelayerRefundLeaf | RelayerRefundLeafSolana) => string;
+/**
+ * Hash function for slow fill leaves.
+ */
+export declare function slowFillHashFn(slowFillLeaf: SlowFillLeaf): string;