@across-protocol/contracts 3.0.18 → 3.0.19

package/dist/src/SvmUtils.js

@@ -1,496 +0,0 @@
-"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 = 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"));
-const bs58_1 = __importDefault(require("bs58"));
-const anchor_1 = require("@coral-xyz/anchor");
-const idl_1 = require("@coral-xyz/anchor/dist/cjs/coder/borsh/idl");
-const ethers_1 = require("ethers");
-const web3_js_1 = require("@solana/web3.js");
-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] };
-}
-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);
-}
-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");
-}
-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");
-}
-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.
-}
-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;
-}
-const evmAddressToPublicKey = (address) => {
-    const bytes32Address = `0x000000000000000000000000${address.replace("0x", "")}`;
-    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 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);
-}
-// 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);
-    const relayHashBuffer = Buffer.from(relayHash.slice(2), "hex");
-    return new Uint8Array(relayHashBuffer);
-}
-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;
-// This is extended Anchor accounts coder to handle large account data that is required when passing instruction
-// parameters from prefilled data account. Base implementation restricts the buffer to only 1000 bytes.
-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;
-// Modified version of CompiledKeys to handle compilation of unsigned transactions. Original 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 message compiled transactions for Across+ multicall handler.
-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",
-                },
-            ],
-        },
-    },
-];
-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",
-                },
-            ],
-        },
-    },
-];
-// Helper to send instructions using Address Lookup Table (ALT) for large number 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 };
-}
-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();
-}