@hawksightco/hawk-sdk 1.3.265 → 1.3.267

package/dist/functions.js

@@ -0,0 +1,1636 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmark = exports.METEORA_API_URL = void 0;
+exports.createTxMetadata = createTxMetadata;
+exports.createTxMetadataWithActions = createTxMetadataWithActions;
+exports.createTxMetadata2 = createTxMetadata2;
+exports.resultOrError = resultOrError;
+exports.getFeeEstimate = getFeeEstimate;
+exports.getMeteoraPool = getMeteoraPool;
+exports.createTransactionMeta = createTransactionMeta;
+exports.createTransactionMeta2 = createTransactionMeta2;
+exports.legacyTxMetadata = legacyTxMetadata;
+exports.generateUserPda = generateUserPda;
+exports.generateUserPdaLamport = generateUserPdaLamport;
+exports.generateAta = generateAta;
+exports.generateLimitToken = generateLimitToken;
+exports.generateFuelAccount = generateFuelAccount;
+exports.generateAta2022 = generateAta2022;
+exports.generateOrcaPositionPDA = generateOrcaPositionPDA;
+exports.generateUserPdaStorageAccount = generateUserPdaStorageAccount;
+exports.getIxs = getIxs;
+exports.sighashMatch = sighashMatch;
+exports.sighash = sighash;
+exports.tokenAccountExists = tokenAccountExists;
+exports.parseTokenAccountData = parseTokenAccountData;
+exports.createAtaIdempotentIxs = createAtaIdempotentIxs;
+exports.getMintsFromInstruction = getMintsFromInstruction;
+exports.wrapSolIfMintIsWsol = wrapSolIfMintIsWsol;
+exports.wrapSolIfMintIsWsolLabeled = wrapSolIfMintIsWsolLabeled;
+exports.createSourceAtasIdempotent = createSourceAtasIdempotent;
+exports.createSourceAtasIdempotentLabeled = createSourceAtasIdempotentLabeled;
+exports.wrapSolToWsol = wrapSolToWsol;
+exports.wrapSolToWsolLabeled = wrapSolToWsolLabeled;
+exports.unwrapSolIfMintIsWsol = unwrapSolIfMintIsWsol;
+exports.unwrapWsolToSol = unwrapWsolToSol;
+exports.unwrapSolIfMintIsWsolLabeled = unwrapSolIfMintIsWsolLabeled;
+exports.unwrapWsolToSolLabeled = unwrapWsolToSolLabeled;
+exports.inputTokenExists = inputTokenExists;
+exports.getJupiterRouteIxParams = getJupiterRouteIxParams;
+exports.toVersionedTransaction = toVersionedTransaction;
+exports.ixStrToWeb3Ix = ixStrToWeb3Ix;
+exports.stringToAlt = stringToAlt;
+exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
+exports.getPriorityFeeEstimate2 = getPriorityFeeEstimate2;
+exports.mid = mid;
+exports.generateNonceAddressFromIndex = generateNonceAddressFromIndex;
+exports.generateNonceAddressesOwnedBy = generateNonceAddressesOwnedBy;
+exports.findNonceOwnedBy = findNonceOwnedBy;
+exports.tokenizer = tokenizer;
+exports.deserializeParametersFromIDL = deserializeParametersFromIDL;
+exports.extractValue = extractValue;
+exports.resolveStruct = resolveStruct;
+exports.resolveEnum = resolveEnum;
+exports.resolveOption = resolveOption;
+exports.resolveVec = resolveVec;
+exports.resolveArray = resolveArray;
+exports.resolveDefined = resolveDefined;
+exports.extractPrimitives = extractPrimitives;
+exports.simulateTransaction = simulateTransaction;
+exports.createAssociatedTokenAccountIdempotentInstruction = createAssociatedTokenAccountIdempotentInstruction;
+exports.raydiumStartTickIndex = raydiumStartTickIndex;
+exports.i32ToBeBuffer = i32ToBeBuffer;
+exports.findUserAlts = findUserAlts;
+exports.pubkeysInAlt = pubkeysInAlt;
+exports.getBatchedMultipleAccountsInfo = getBatchedMultipleAccountsInfo;
+exports.getTokenProgramForMints = getTokenProgramForMints;
+exports.getTokenProgramMapForMints = getTokenProgramMapForMints;
+exports.getMeteoraStrategyType = getMeteoraStrategyType;
+exports.generateHawksightFeeAccounts = generateHawksightFeeAccounts;
+exports.fetchRemainingAccountsInfo = fetchRemainingAccountsInfo;
+exports.fetchRemainingAccountsInfoForReward = fetchRemainingAccountsInfoForReward;
+const client = __importStar(require("@hawksightco/swagger-client"));
+const web3 = __importStar(require("@solana/web3.js"));
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("./types");
+const CreateTxMetadata_1 = require("./classes/CreateTxMetadata");
+const addresses_1 = require("./addresses");
+const errors_1 = require("./errors");
+const lodash_1 = require("lodash");
+const js_sha256_1 = require("js-sha256");
+const bn_js_1 = __importDefault(require("bn.js"));
+const spl_token_1 = require("@solana/spl-token");
+const bs58_1 = __importDefault(require("bs58"));
+const Logging_1 = require("./classes/Logging");
+const jupiter_idl_1 = require("./idl/jupiter-idl");
+const MintCache_1 = require("./classes/account-cache/MintCache");
+exports.METEORA_API_URL = "https://dlmm.datapi.meteora.ag";
+/**
+ * Asynchronously creates transaction metadata based on the provided transaction parameters and network state.
+ * This includes constructing a transaction with given instructions, calculating fees, and optionally handling priority fees.
+ *
+ * @param connection The active Solana blockchain connection used to fetch state and simulate the transaction.
+ * @param payer The public key (as a string) of the payer for the transaction, responsible for fees.
+ * @param data An object containing necessary information to construct the transaction, such as:
+ *        - addressLookupTableAddresses: Array of addresses for lookup tables.
+ *        - computeBudgetInstructions: Array of instructions for setting compute budget.
+ *        - description: Description of the transaction.
+ *        - estimatedFeeInSOL: Estimated fee in SOL units.
+ * @returns A promise resolving to an object containing the transaction metadata including the description,
+ *          estimated fee, and the transaction object itself.
+ * @throws Error if there is an issue in constructing the transaction or during simulation which includes logs of errors.
+ */
+function createTxMetadata(generalUtility, connection, payer, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield CreateTxMetadata_1.CreateTxMetadata.instance().createTxMetadata(generalUtility, connection, payer, data);
+    });
+}
+function createTxMetadataWithActions(generalUtility, connection, payer, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield CreateTxMetadata_1.CreateTxMetadata.instance().createTxMetadataWithActions(generalUtility, connection, payer, data);
+    });
+}
+/**
+ * Designed for splitting transactions into multiple transactions dynamically
+ * based on the size of the transaction by measuring each raw instructions.
+ *
+ * @param generalUtility
+ * @param connection
+ * @param payer
+ * @param data
+ * @returns
+ */
+function createTxMetadata2(generalUtility, connection, payer, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield CreateTxMetadata_1.CreateTxMetadata.instance().createTxMetadata2(generalUtility, connection, payer, data);
+    });
+}
+/**
+ * Wraps the result of an API call or operation in an object containing status information.
+ * If the result status is 200, applies a success function to the data.
+ * @param result The result object containing the HTTP status code and response data.
+ * @param successFn A function to be applied to the response data in case of success.
+ * @returns A promise that resolves to an object containing status information and the transformed or original response data.
+ * The response data may be of type Out if the success function is applied, or type Response if not.
+ */
+function resultOrError(result, successFn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (result.status === 200) {
+            // If the status is 200, apply the success function to the data
+            return {
+                status: result.status,
+                data: yield successFn(result.data),
+            };
+        }
+        else {
+            console.error(`Error:`);
+            console.error(result.data);
+            throw new Error();
+        }
+    });
+}
+/**
+ * Retrieves an estimate of the priority fee for a transaction using the provided connection.
+ *
+ * @param connection The web3 connection object used for interacting with the blockchain.
+ * @param priorityLevel The priority level of the transaction.
+ * @param versionedTransaction The versioned transaction object for which the fee estimate is needed.
+ * @returns A Promise resolving to the estimated priority fee for the transaction.
+ */
+function getFeeEstimate(generalUtility, priority, transaction) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield generalUtility.getPriorityFeeEstimate({
+            priority,
+            transaction,
+        });
+        return (yield resultOrError(response, (result) => __awaiter(this, void 0, void 0, function* () {
+            let priorityFee;
+            if (priority === client.PriorityLevel.Default || priority === client.PriorityLevel.Medium) {
+                priorityFee = result.feeLevels._default;
+            }
+            else if (priority === client.PriorityLevel.High) {
+                priorityFee = result.feeLevels.high;
+            }
+            else if (priority === client.PriorityLevel.VeryHigh) {
+                priorityFee = result.feeLevels.high;
+            }
+            else {
+                const max = result.feeLevels._default;
+                const min = result.feeLevels.low;
+                priorityFee = min + ((max - min) / 2);
+            }
+            return result.priorityFeeEstimate;
+        }))).data;
+    });
+}
+/**
+ * Returns a meteora pool
+ *
+ * @param poolAddress Address of the meteora pool
+ * @returns {Promise<MeteoraPoolInfo>}A promise that resolves to an object of Meteora pool information.
+ */
+function getMeteoraPool(poolAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield axios_1.default.get(`${exports.METEORA_API_URL}/pools/${poolAddress}`);
+            const poolInfo = response.data;
+            return poolInfo;
+        }
+        catch (error) {
+            console.error(`Failed to fetch Meteora pool info for address ${poolAddress}:`, error);
+            throw new Error('Could not retrieve Meteora pool information.');
+        }
+    });
+}
+/**
+ * Generate transaction meta object
+ *
+ * @param params
+ * @returns
+ */
+function createTransactionMeta(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressLookupTableAddresses = [];
+        const pubkeys = [];
+        const mainInstructions = params.mainInstructions.map((ix) => {
+            return {
+                accounts: ix.keys.map((account) => {
+                    const pubkey = account.pubkey.toString();
+                    pubkeys.push(pubkey);
+                    return {
+                        isSigner: account.isSigner,
+                        isWritable: account.isWritable,
+                        pubkey,
+                    };
+                }),
+                data: ix.data.toString("base64"),
+                programId: ix.programId.toString(),
+            };
+        });
+        addressLookupTableAddresses.push(...params.addressLookupTableAddresses);
+        const signature = "";
+        return {
+            description: params.description,
+            estimatedFeeInSOL: "",
+            addressLookupTableAddresses,
+            computeBudgetInstructions: [],
+            mainInstructions,
+            payer: params.payer.toString(),
+            signature,
+        };
+    });
+}
+/**
+ * Generate transaction with labels per instruction
+ *
+ * @param params
+ * @returns
+ */
+function createTransactionMeta2(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressLookupTableAddresses = [];
+        const pubkeys = [];
+        const mainInstructions = params.mainInstructions.map((ix) => {
+            return {
+                accounts: ix.instruction.keys.map((account) => {
+                    const pubkey = account.pubkey.toString();
+                    pubkeys.push(pubkey);
+                    return {
+                        isSigner: account.isSigner,
+                        isWritable: account.isWritable,
+                        pubkey,
+                    };
+                }),
+                data: ix.instruction.data.toString("base64"),
+                programId: ix.instruction.programId.toString(),
+            };
+        });
+        const actions = params.mainInstructions.map(ix => ix.label);
+        addressLookupTableAddresses.push(...params.addressLookupTableAddresses);
+        return {
+            actions,
+            addressLookupTableAddresses,
+            computeBudgetInstructions: [],
+            mainInstructions,
+            payer: params.payer.toString(),
+        };
+    });
+}
+function legacyTxMetadata(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ connection, generalUtility, payer, description, ixs, additionalAlt, }) {
+        // Create transaction meta
+        const result = yield createTransactionMeta({
+            payer,
+            description,
+            addressLookupTableAddresses: [...addresses_1.GLOBAL_ALT, ...(additionalAlt || [])],
+            mainInstructions: ixs,
+        });
+        return {
+            status: 200,
+            data: yield createTxMetadata(generalUtility, connection, payer.toString(), result),
+        };
+    });
+}
+/**
+ * Generate UserPDA
+ *
+ * @param userWallet
+ * @param farm
+ * @returns
+ */
+function generateUserPda(userWallet, farm = new web3.PublicKey("7jLQhREMxXjKdpwVuN6gwsWt3BNfAg9WqbepffPbi4ww")) {
+    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from("multi-user"), farm.toBuffer(), userWallet.toBuffer()], new web3.PublicKey("FqGg2Y1FNxMiGd51Q6UETixQWkF5fB92MysbYogRJb3P"));
+    return pda;
+}
+/**
+ * Generate UserPDA Lamport Account
+ *
+ * @param userWallet
+ * @param farm
+ * @returns
+ */
+function generateUserPdaLamport(userWallet, farm = new web3.PublicKey("7jLQhREMxXjKdpwVuN6gwsWt3BNfAg9WqbepffPbi4ww")) {
+    const userPda = generateUserPda(userWallet, farm);
+    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from("user-pda-lamport"), userPda.toBuffer()], new web3.PublicKey("FqGg2Y1FNxMiGd51Q6UETixQWkF5fB92MysbYogRJb3P"));
+    return pda;
+}
+/**
+ * Generate ATA
+ *
+ * @param owner Owner of the ATA
+ * @param mint Mint of the ATA
+ * @param programId Defaults to Token Program. Program ID is used to support token 2022
+ * @returns ATA address
+ */
+function generateAta(owner, mint, programId = addresses_1.TOKEN_PROGRAM_ID) {
+    const [pda] = web3.PublicKey.findProgramAddressSync([
+        owner.toBuffer(),
+        programId.toBuffer(),
+        mint.toBuffer(),
+    ], new web3.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"));
+    return pda;
+}
+function generateLimitToken(userPda, mint) {
+    const [pda] = web3.PublicKey.findProgramAddressSync([
+        Buffer.from("limit-token", "utf-8"),
+        mint.toBuffer(),
+        userPda.toBuffer(),
+    ], new web3.PublicKey("FqGg2Y1FNxMiGd51Q6UETixQWkF5fB92MysbYogRJb3P"));
+    return pda;
+}
+function generateFuelAccount(userWallet) {
+    const [pda] = web3.PublicKey.findProgramAddressSync([
+        Buffer.from("fuel", "utf-8"),
+        userWallet.toBuffer(),
+    ], new web3.PublicKey("FqGg2Y1FNxMiGd51Q6UETixQWkF5fB92MysbYogRJb3P"));
+    return pda;
+}
+function generateAta2022(owner, mint) {
+    return generateAta(owner, mint, addresses_1.TOKEN_2022);
+}
+/**
+ * Generate Orca Position PDA
+ *
+ * @param userWallet
+ * @param farm
+ * @returns
+ */
+function generateOrcaPositionPDA(positionMint) {
+    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from("position", "utf-8"), positionMint.toBuffer()], addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+    return pda;
+}
+/**
+ * Generate the PDA for the userPda's storage account
+ *
+ * @param userPda
+ * @param mint
+ * @returns Storage Account owned by the user pda
+ */
+function generateUserPdaStorageAccount(userPda, mint) {
+    const [storageAccount] = web3.PublicKey.findProgramAddressSync([Buffer.from("storage-token"), mint.toBuffer(), userPda.toBuffer()], addresses_1.IYF_MAIN);
+    return storageAccount;
+}
+/**
+ * Convert transaction to instructions
+ *
+ * @param txns
+ * @returns
+ */
+function getIxs(txns) {
+    const ixs = [];
+    if (typeof txns.length === "number") {
+        const txs = txns;
+        for (const tx of txs) {
+            ixs.push(...tx.instructions);
+        }
+    }
+    else {
+        const txs = txns;
+        ixs.push(...txs.instructions);
+    }
+    return ixs;
+}
+/**
+ * Check if anchor instruction matches
+ *
+ * @param data
+ * @param compareTo
+ */
+function sighashMatch(data, compareTo, prefix, noSnakeCase, skipDataLengthCheck) {
+    if (typeof compareTo === "string") {
+        compareTo = sighash(compareTo, prefix, noSnakeCase);
+    }
+    if (data.length < 8) {
+        if (skipDataLengthCheck) {
+            return false;
+        }
+        throw new errors_1.AppError(`Data is not an anchor instruction`, `sighashMatch`);
+    }
+    if (compareTo.length < 8) {
+        throw new errors_1.AppError(`compareTo is not a valid sighash`, `sighashMatch`);
+    }
+    for (let i = 0; i < 8; i++) {
+        if (data[i] !== compareTo[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Anchor sighash function
+ *
+ * @param ixName
+ * @returns
+ */
+function sighash(ixName, prefix = "global", noSnakeCase = false) {
+    const name = noSnakeCase ? ixName : (0, lodash_1.snakeCase)(ixName);
+    const preimage = `${prefix}:${name}`;
+    return Buffer.from(js_sha256_1.sha256.digest(preimage)).subarray(0, 8);
+}
+/**
+ * Determine whether given token account exists
+ * @param publicKeys
+ */
+function tokenAccountExists(connection, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tokenKeys = params.map((p) => {
+            if (p.tokenType === types_1.TokenType.STA || p.isSta) {
+                return generateUserPdaStorageAccount(p.owner, p.mint);
+            }
+            else if (p.tokenType === types_1.TokenType.LTA) {
+                return generateLimitToken(p.owner, p.mint);
+            }
+            else {
+                return generateAta(p.owner, p.mint, p.tokenProgram);
+            }
+        });
+        const accountInfos = yield connection.getMultipleAccountsInfo(tokenKeys);
+        const result = accountInfos.map((accountInfo, index) => {
+            if (accountInfo === null || accountInfo.data.length !== 165) {
+                return { mint: params[index].mint, tokenKey: tokenKeys[index], exists: false };
+            }
+            // Get the expected token program for this specific account
+            const expectedTokenProgram = params[index].tokenProgram || addresses_1.TOKEN_PROGRAM_ID;
+            return {
+                mint: params[index].mint,
+                tokenKey: tokenKeys[index],
+                exists: accountInfo.owner.equals(expectedTokenProgram),
+            };
+        });
+        return result;
+    });
+}
+/**
+ * Decodes a buffer into an object describing the token account.
+ * @param data - The buffer containing raw account data.
+ * @returns An object with mint, owner, and amount properties.
+ */
+function parseTokenAccountData(data) {
+    return {
+        mint: new web3.PublicKey(data.subarray(0, 32)),
+        owner: new web3.PublicKey(data.subarray(32, 64)),
+        amount: new bn_js_1.default(data.subarray(64, 72), "le"),
+    };
+}
+/**
+ * Creates an array of idempotent associated token account creation instructions.
+ *
+ * This function generates instructions to create associated token accounts (ATAs) for the provided accounts.
+ * The instructions are idempotent, meaning they can be safely executed multiple times without changing the result beyond the initial application.
+ *
+ * @param {CreateAtaIdempotentParams} params - The parameters for creating ATA instructions.
+ * @param {Array<{ payer: web3.PublicKey, owner: web3.PublicKey, mint: web3.PublicKey }>} params.accounts - An array of objects containing:
+ *    - `payer`: The public key of the account paying for the transaction.
+ *    - `owner`: The public key of the account owner.
+ *    - `mint`: The public key of the mint (token) for which the ATA is being created.
+ *
+ * @returns {web3.TransactionInstruction[]} An array of transaction instructions for creating the associated token accounts.
+ *
+ * @example
+ * const accounts = [
+ *   { payer: payerPublicKey, owner: ownerPublicKey, mint: mintPublicKey },
+ *   { payer: anotherPayerPublicKey, owner: anotherOwnerPublicKey, mint: anotherMintPublicKey }
+ * ];
+ * const instructions = createAtaIdempotent({ accounts });
+ * Log(instructions); // Logs an array of TransactionInstruction objects.
+ */
+function createAtaIdempotentIxs({ accounts, }) {
+    const result = [];
+    for (const account of accounts) {
+        const { payer, owner, mint, programId } = account;
+        const ata = generateAta(owner, mint, programId);
+        const ataIx = createAssociatedTokenAccountIdempotentInstruction(payer, ata, owner, mint, programId);
+        result.push(ataIx);
+    }
+    return result;
+}
+/**
+ * Extracts unique mint addresses from a list of Solana instructions based on specific criteria.
+ *
+ * @param {GetMintsFromInstructionParams} params - The parameters for extracting mint addresses.
+ * @param {web3.TransactionInstruction[]} params.instructions - An array of Solana instructions to search through.
+ * @param {Record<string, { programId: string, mintIndices: number[] }>} params.find - A record where each key is a string identifier and the value is an object containing:
+ *    - programId: The program ID to match against the instruction's program ID.
+ *    - mintIndices: An array of indices that point to the mint addresses within the instruction's keys.
+ *
+ * @returns {web3.PublicKey[]} An array of unique mint addresses (as PublicKey objects) found in the provided instructions.
+ *
+ * @example
+ * const instructions = [/* array of web3.TransactionInstruction objects * /];
+ * const findCriteria = {
+ *   "exampleProgram": {
+ *     programId: "ExampleProgramId123456789",
+ *     mintIndices: [0, 2]
+ *   }
+ * };
+ * const mints = getMintsFromInstruction({ instructions, find: findCriteria });
+ * Log(mints); // Logs an array of unique PublicKey objects.
+ */
+function getMintsFromInstruction({ instructions, find, }) {
+    const mints = {};
+    // Iterate through each instruction
+    for (const ix of instructions) {
+        // Iterate through each key in the find record
+        for (const id in find) {
+            // Check if the instruction data matches the sighash and the program ID matches
+            try {
+                const _sighash = sighash(id, undefined, find[id].manualSnakeCase);
+                if (sighashMatch(ix.data, _sighash) &&
+                    ix.programId.toBase58() == find[id].programId) {
+                    // Iterate through each mint index specified in the find record
+                    for (const index of find[id].mintIndices) {
+                        const address = ix.keys[index].pubkey.toString();
+                        mints[address] = true; // Mark the address as found
+                    }
+                }
+            }
+            catch (_a) { }
+        }
+    }
+    // Convert the unique mint addresses to web3.PublicKey objects
+    const result = [];
+    for (const mint in mints) {
+        result.push(new web3.PublicKey(mint));
+    }
+    return result;
+}
+/**
+ * Creates instructions to wrap SOL to wSOL if the provided mint matches the wrapped SOL mint.
+ *
+ * This function takes a user's wallet public key and an array of mint-amount pairs. It filters the pairs to find those
+ * where the mint is the wrapped SOL mint (`So11111111111111111111111111111111111111112`). For each of these pairs, it
+ * generates instructions to wrap SOL to wSOL, owned by the target wallet.
+ *
+ * If no pairs match the wrapped SOL mint, the function will return an empty array.
+ *
+ * @param {web3.PublicKey} userWallet - The public key of the user's wallet.
+ * @param {web3.PublicKey} payer - The public key of transaction payer.
+ * @param {Array<{mint: web3.PublicKey, amount: BN}>} params - An array of objects, each containing:
+ *    - `mint`: The public key of the mint.
+ *    - `amount`: The amount of the token to be wrapped.
+ *
+ * @returns {Array<web3.TransactionInstruction>} - An array of transaction instructions to wrap SOL to wSOL.
+ *    If no mint matches the wrapped SOL mint, the function returns an empty array.
+ */
+function wrapSolIfMintIsWsol(userWallet, payer, params) {
+    return params
+        .filter((v) => v.mint.toBase58() === "So11111111111111111111111111111111111111112")
+        .map((v) => wrapSolToWsol({ payer, owner: userWallet, amount: v.amount }))
+        .flat();
+}
+/**
+ * Creates instructions to wrap SOL to wSOL if the provided mint matches the wrapped SOL mint. (Labeled version)
+ *
+ * This function takes a user's wallet public key and an array of mint-amount pairs. It filters the pairs to find those
+ * where the mint is the wrapped SOL mint (`So11111111111111111111111111111111111111112`). For each of these pairs, it
+ * generates instructions to wrap SOL to wSOL, owned by the target wallet.
+ *
+ * If no pairs match the wrapped SOL mint, the function will return an empty array.
+ *
+ * @param {web3.PublicKey} userWallet - The public key of the user's wallet.
+ * @param {web3.PublicKey} payer - The public key of transaction payer.
+ * @param {Array<{mint: web3.PublicKey, amount: BN}>} params - An array of objects, each containing:
+ *    - `mint`: The public key of the mint.
+ *    - `amount`: The amount of the token to be wrapped.
+ *
+ * @returns {Array<LabeledInstruction>} - An array of labeled transaction instructions to wrap SOL to wSOL.
+ *    If no mint matches the wrapped SOL mint, the function returns an empty array.
+ */
+function wrapSolIfMintIsWsolLabeled(userWallet, payer, params) {
+    return params
+        .filter((v) => v.mint.toBase58() === "So11111111111111111111111111111111111111112")
+        .map((v) => wrapSolToWsolLabeled({ payer, owner: userWallet, amount: v.amount }))
+        .flat();
+}
+/**
+ * H-2106: Ensure the user-wallet associated token accounts for every non-wSOL mint
+ * referenced by a deposit-multi-token flow exist on chain. Symmetric to
+ * `wrapSolIfMintIsWsol` -- that helper guarantees the wSOL ATA via wrap, this
+ * one guarantees every other source ATA via createIdempotent. Without this,
+ * `depositMultipleTokenWithToken2022` references a non-existent user-wallet ATA
+ * as the Token Program transfer source and the on-chain handler fails with
+ * `InvalidAccountData`. Token program is resolved per-mint via the cached
+ * MintCache so both legacy SPL Token and Token-2022 mints derive correctly.
+ */
+function createSourceAtasIdempotent(connection, userWallet, payer, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nonWsol = params.filter((v) => v.mint.toBase58() !== "So11111111111111111111111111111111111111112");
+        if (nonWsol.length === 0)
+            return [];
+        const tokenProgramMap = yield getTokenProgramMapForMints(connection, nonWsol.map((v) => v.mint));
+        return nonWsol.map((v) => {
+            const tokenProgram = tokenProgramMap[v.mint.toString()];
+            const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(v.mint, userWallet, false, tokenProgram);
+            return createAssociatedTokenAccountIdempotentInstruction(payer, ata, userWallet, v.mint, tokenProgram);
+        });
+    });
+}
+/** Labeled variant of `createSourceAtasIdempotent`. */
+function createSourceAtasIdempotentLabeled(connection, userWallet, payer, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ixs = yield createSourceAtasIdempotent(connection, userWallet, payer, params);
+        return ixs.map((instruction) => ({
+            instruction,
+            label: `Create source token account in user wallet`,
+            class: `createSourceAtasIdempotentLabeled`,
+        }));
+    });
+}
+function wrapSolToWsol({ payer, owner, amount, }) {
+    const wSolAccount = generateAta(owner, addresses_1.WSOL_MINT);
+    // Step 1: Create ATA account IX
+    const ataIx = createAssociatedTokenAccountIdempotentInstruction(payer, wSolAccount, owner, addresses_1.WSOL_MINT);
+    if (amount !== undefined) {
+        console.log(`Amount is not undefined. Transferring ${amount.toString()} lamports from ${payer.toBase58()} to ${wSolAccount.toBase58()} and wrapping to wSOL.`);
+        // Step 1: Transfer lamports from authority to wSolAccount
+        const transferIx = web3.SystemProgram.transfer({
+            /** Account that will transfer lamports */
+            fromPubkey: payer,
+            /** Account that will receive transferred lamports */
+            toPubkey: wSolAccount,
+            /** Amount of lamports to transfer */
+            lamports: BigInt(amount.toString()),
+        });
+        // Step 2: Convert wSolAccount into wrapped sol account
+        const wrapSolIx = (0, spl_token_1.createSyncNativeInstruction)(wSolAccount);
+        // Return instructions
+        return [ataIx, transferIx, wrapSolIx];
+    }
+    // Just return ATA creation
+    return [ataIx];
+}
+/**
+ * Generate a labeled version of wrapSolToWsol instructions, which includes descriptive
+ * labels for each instruction to enhance readability and debugging.
+ *
+ * @param param0
+ * @returns
+ */
+function wrapSolToWsolLabeled({ payer, owner, amount, }) {
+    const wSolAccount = generateAta(owner, addresses_1.WSOL_MINT);
+    // Step 1: Create ATA account IX
+    const ataIx = {
+        label: `Create ATA for wSOL`,
+        class: `wrapSolToWsolLabeled`,
+        instruction: createAssociatedTokenAccountIdempotentInstruction(payer, wSolAccount, owner, addresses_1.WSOL_MINT),
+    };
+    if (amount !== undefined) {
+        console.log(`Amount is not undefined. Transferring ${amount.toString()} lamports from ${payer.toBase58()} to ${wSolAccount.toBase58()} and wrapping to wSOL.`);
+        // Step 1: Transfer lamports from authority to wSolAccount
+        const transferIx = {
+            label: `Transfer lamports to wSOL account`,
+            class: `wrapSolToWsolLabeled`,
+            instruction: web3.SystemProgram.transfer({
+                /** Account that will transfer lamports */
+                fromPubkey: payer,
+                /** Account that will receive transferred lamports */
+                toPubkey: wSolAccount,
+                /** Amount of lamports to transfer */
+                lamports: BigInt(amount.toString()),
+            })
+        };
+        // Step 2: Convert wSolAccount into wrapped sol account
+        const wrapSolIx = {
+            label: `Sync native to wrap SOL`,
+            class: `wrapSolToWsolLabeled`,
+            instruction: (0, spl_token_1.createSyncNativeInstruction)(wSolAccount),
+        };
+        // Return instructions
+        return [ataIx, transferIx, wrapSolIx];
+    }
+    // Just return ATA creation
+    return [ataIx];
+}
+/**
+ * Creates instructions to unwrap wSOL to SOL if the provided mint matches the wrapped SOL mint.
+ *
+ * This function takes a user's wallet public key and an array of mint public keys. It filters the array to find mints
+ * that match the wrapped SOL mint (`So11111111111111111111111111111111111111112`). For each of these mints, it
+ * generates instructions to unwrap wSOL to SOL, with the user's wallet as the authority.
+ *
+ * If no mints match the wrapped SOL mint, the function will return an empty array.
+ *
+ * @param {web3.PublicKey} userWallet - The public key of the user's wallet.
+ * @param {web3.PublicKey[]} mints - An array of public keys representing the mints.
+ *
+ * @returns {web3.TransactionInstruction[]} - An array of transaction instructions to unwrap wSOL to SOL.
+ *    If no mint matches the wrapped SOL mint, the function returns an empty array.
+ */
+function unwrapSolIfMintIsWsol(userWallet, mints) {
+    return mints
+        .filter((mint) => mint.toBase58() === "So11111111111111111111111111111111111111112")
+        .map(() => unwrapWsolToSol({ authority: userWallet }))
+        .flat();
+}
+function unwrapWsolToSol({ authority, }) {
+    const wSolAccount = generateAta(authority, addresses_1.WSOL_MINT);
+    // account: PublicKey,
+    // destination: PublicKey,
+    // authority: PublicKey,
+    // multiSigners: (Signer | PublicKey)[] = [],
+    // programId = TOKEN_PROGRAM_ID
+    // Create close account instruction (transfers native SOL to authority)
+    const closeIx = (0, spl_token_1.createCloseAccountInstruction)(wSolAccount, authority, authority);
+    // Return instructions
+    return closeIx;
+}
+/**
+ * Creates instructions to unwrap wSOL to SOL if the provided mint matches the wrapped SOL mint. (Labeled version)
+ *
+ * This function takes a user's wallet public key and an array of mint public keys. It filters the array to find mints
+ * that match the wrapped SOL mint (`So11111111111111111111111111111111111111112`). For each of these mints, it
+ * generates instructions to unwrap wSOL to SOL, with the user's wallet as the authority.
+ *
+ * If no mints match the wrapped SOL mint, the function will return an empty array.
+ *
+ * @param {web3.PublicKey} userWallet - The public key of the user's wallet.
+ * @param {web3.PublicKey[]} mints - An array of public keys representing the mints.
+ *
+ * @returns {web3.TransactionInstruction[]} - An array of transaction instructions to unwrap wSOL to SOL.
+ *    If no mint matches the wrapped SOL mint, the function returns an empty array.
+ */
+function unwrapSolIfMintIsWsolLabeled(userWallet, mints) {
+    return mints
+        .filter((mint) => mint.toBase58() === "So11111111111111111111111111111111111111112")
+        .map(() => unwrapWsolToSolLabeled({ authority: userWallet }))
+        .flat();
+}
+function unwrapWsolToSolLabeled({ authority, }) {
+    const wSolAccount = generateAta(authority, addresses_1.WSOL_MINT);
+    // account: PublicKey,
+    // destination: PublicKey,
+    // authority: PublicKey,
+    // multiSigners: (Signer | PublicKey)[] = [],
+    // programId = TOKEN_PROGRAM_ID
+    // Create close account instruction (transfers native SOL to authority)
+    const closeIx = (0, spl_token_1.createCloseAccountInstruction)(wSolAccount, authority, authority);
+    // Return instructions
+    return {
+        label: `Unwrap wSOL to SOL`,
+        class: `unwrapWsolToSolLabeled`,
+        instruction: closeIx,
+    };
+}
+/**
+ * Checks if token accounts for specified mints exist for a given user wallet.
+ *
+ * This function takes a user's wallet public key and an array of mint public keys. It maps these mints to token seeds
+ * (objects containing mint and owner information) and checks if the token accounts exist using the `tokenAccountExists` function.
+ *
+ * If a mint corresponds to wrapped SOL (`So11111111111111111111111111111111111111112`) and the token account does not exist,
+ * it will not throw an error. For other mints, if the token account does not exist, the function will throw an error.
+ *
+ * @param {web3.PublicKey} userWallet - The public key of the user's wallet.
+ * @param {web3.PublicKey[]} mints - An array of public keys representing the mints.
+ *
+ * @returns {Promise<void>} - A promise that resolves if all non-wrapped SOL token accounts exist, otherwise it throws an error.
+ *
+ * @throws {Error} - Throws an error if a token account for a mint (other than wrapped SOL) does not exist.
+ */
+function inputTokenExists(connection, userWallet, mints) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tokenSeeds = mints.map((mint) => {
+            return { mint, owner: userWallet };
+        });
+        const resultMap = yield tokenAccountExists(connection, tokenSeeds);
+        resultMap.map((result, index) => {
+            const tokenKey = result.tokenKey;
+            const token = tokenSeeds[index];
+            const tokenIsWsol = token.mint.toString() === "So11111111111111111111111111111111111111112";
+            if (tokenIsWsol && !result.exists) {
+            }
+            else if (!result.exists) {
+                throw new Error(`Token: ${tokenKey} owned by ${token.owner} does not exist. Mint: ${token.mint}`);
+            }
+        });
+    });
+}
+/**
+ * Get Jupiter route ix parameters
+ *
+ * @param data
+ */
+function getJupiterRouteIxParams(data) {
+    const result = deserializeParametersFromIDL(jupiter_idl_1.IDL, 'route', data);
+    const routePlan = result.params['route_plan'];
+    const quotedOutAmount = new bn_js_1.default(result.params['quoted_out_amount']);
+    const slippageBps = result.params['slippage_bps'].readUInt16LE();
+    const platformFeeBps = result.params['platform_fee_bps'].readUInt8();
+    return {
+        routePlan,
+        quotedOutAmount,
+        slippageBps,
+        platformFeeBps,
+    };
+}
+/**
+ * Converts tx metadata to versioned transaction
+ *
+ * @param txMessage
+ */
+function toVersionedTransaction(connection, txMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const alts = yield stringToAlt(connection, txMessage.addressLookupTableAddresses);
+        const result = new web3.VersionedTransaction(new web3.TransactionMessage({
+            instructions: txMessage.mainInstructions.map((ix) => ixStrToWeb3Ix(ix)),
+            payerKey: new web3.PublicKey(txMessage.payer),
+            recentBlockhash: web3.PublicKey.default.toString(),
+        }).compileToV0Message(alts));
+        return result;
+    });
+}
+function ixStrToWeb3Ix(ix) {
+    return {
+        keys: ix.accounts.map((account) => {
+            return {
+                isSigner: account.isSigner,
+                isWritable: account.isWritable,
+                pubkey: new web3.PublicKey(account.pubkey),
+            };
+        }),
+        data: Buffer.from(ix.data, "base64"),
+        programId: new web3.PublicKey(ix.programId),
+    };
+}
+function stringToAlt(connection, alts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const c = CreateTxMetadata_1.CreateTxMetadata.instance();
+        c.setConnection(connection);
+        return yield c.stringToAlt(alts);
+    });
+}
+let previousHeliusFeeLevels = {
+    priorityFeeLevels: {
+        high: 9327508,
+        low: 500000,
+        medium: 2675228,
+        min: 500000,
+        unsafeMax: 2368000000,
+        veryHigh: 28631588,
+    }
+};
+function getPriorityFeeEstimate(priorityLevel, transaction, rpcUrl) {
+    const tx = bs58_1.default.encode(transaction.serialize());
+    const heliusFeeLevels = getPriorityFeeEstimate2(tx, { includeAllPriorityFeeLevels: true }, rpcUrl);
+    heliusFeeLevels.then(feeLevels => {
+        previousHeliusFeeLevels = feeLevels;
+    });
+    const m = {
+        Min: "min",
+        Low: "low",
+        Default: "medium",
+        Medium: "medium",
+        High: "high",
+        VeryHigh: "veryHigh",
+        UnsafeMax: "unsafeMax",
+    };
+    const feeLevels = {
+        low: previousHeliusFeeLevels.priorityFeeLevels.medium * 2,
+        default: mid(previousHeliusFeeLevels.priorityFeeLevels.medium, previousHeliusFeeLevels.priorityFeeLevels.high),
+        high: previousHeliusFeeLevels.priorityFeeLevels.high,
+        veryHigh: previousHeliusFeeLevels.priorityFeeLevels.veryHigh * 3,
+    };
+    return {
+        priorityFeeEstimate: previousHeliusFeeLevels.priorityFeeLevels[m[priorityLevel]],
+        feeLevels,
+    };
+}
+function getPriorityFeeEstimate2(transaction, options, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "1",
+                method: "getPriorityFeeEstimate",
+                params: [
+                    {
+                        transaction,
+                        options,
+                    },
+                ],
+            }),
+        });
+        const data = yield response.json();
+        return data.result;
+    });
+}
+function mid(min, max) {
+    return min + (max - min) / 2;
+}
+/**
+ * Find all nonce pubkey owned by given owner and index
+ *
+ * @param owner
+ */
+function generateNonceAddressFromIndex(owner, index) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield web3.PublicKey.createWithSeed(owner, `hs-nonce-${index}`, web3.SystemProgram.programId);
+    });
+}
+/**
+ * Find all nonce pubkey owned by given owner
+ *
+ * @param owner
+ */
+function generateNonceAddressesOwnedBy(owner, count) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nonceAddresses = [];
+        for (let i = 0; i < count; i++) {
+            nonceAddresses.push(yield generateNonceAddressFromIndex(owner, i));
+        }
+        return nonceAddresses;
+    });
+}
+/**
+ * Find all nonce pubkey owned by given owner
+ *
+ * TODO: Put this into a class and the class must serve as cache of nonce accounts (so that we don't query nonce account multiple times)
+ *
+ * @param owner
+ */
+function findNonceOwnedBy(connection, owner, count) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nonceAddresses = yield generateNonceAddressesOwnedBy(owner, count);
+        const infos = yield connection.getMultipleAccountsInfo(nonceAddresses);
+        const result = infos.filter(info => info !== null).map(info => {
+            const result = {
+                /** `true` if this account's data contains a loaded program */
+                executable: info.executable,
+                /** Identifier of the program that owns the account */
+                owner: info.owner,
+                /** Number of lamports assigned to the account */
+                lamports: info.lamports,
+                /** Optional data assigned to the account */
+                data: web3.NonceAccount.fromAccountData(info.data),
+                /** Optional rent epoch info for account */
+                rentEpoch: info.rentEpoch,
+            };
+            return result;
+        });
+        return result;
+    });
+}
+exports.benchmark = (() => {
+    let startTime;
+    return ({ end, name, msg }) => {
+        if (end) {
+            (0, Logging_1.Log)(`${name}: ${msg} elapsed time: ${new Date().getTime() / 1000 - startTime}`);
+        }
+        else {
+            startTime = new Date().getTime() / 1000;
+            (0, Logging_1.Log)(`${name}: Benchmarking ${msg}`);
+        }
+    };
+})();
+function tokenizer(buffer) {
+    let clone = buffer.map(v => v);
+    let currentIndex = 0;
+    return {
+        readBuffer: (length) => {
+            currentIndex += length;
+            const result = clone.subarray(0, length);
+            clone = clone.subarray(length);
+            return Buffer.from(result);
+        },
+        currentIndex: () => {
+            return currentIndex;
+        },
+        remainingBytes: () => {
+            return clone;
+        },
+        debug: () => {
+            const hexValues = Buffer.from(clone).toString('hex');
+            return `currentIndex: ${currentIndex}, remainingBytes: ${hexValues}`;
+        }
+    };
+}
+function deserializeParametersFromIDL(idl, instruction, data) {
+    const tokens = tokenizer(data);
+    const discriminator = tokens.readBuffer(8);
+    const params = {};
+    const ixDefinition = idl.instructions.find((ix) => ix.name === instruction);
+    if (!discriminator.equals(Uint8Array.from(ixDefinition.discriminator))) {
+        throw new Error(`deserializeParametersFromIDL: Discriminator mismatch.`);
+    }
+    for (const arg of ixDefinition.args) {
+        const value = extractValue(idl, arg.type, tokens);
+        params[arg.name] = value;
+    }
+    return {
+        discriminator,
+        params,
+    };
+}
+function extractValue(idl, type, tokens) {
+    if (typeof type === 'object') {
+        if (typeof type.option !== 'undefined') {
+            return resolveOption(idl, type.option, tokens);
+        }
+        else if (typeof type.vec !== 'undefined') {
+            return resolveVec(idl, type.vec, tokens);
+        }
+        else if (typeof type.array !== 'undefined') {
+            return resolveArray(idl, type.array, tokens);
+        }
+        else if (typeof type.defined !== 'undefined') {
+            return resolveDefined(idl, type.defined.name, tokens);
+        }
+        else {
+            const k = Object.keys(type);
+            throw new Error(`extractValue: Unexpected error: Unexpected type key: ${k[0]}, debug: ${tokens.debug()}`);
+        }
+    }
+    else if (typeof type === 'string') {
+        const value = extractPrimitives(type, tokens);
+        if (value === undefined) {
+            throw new Error(`extractValue: Unexpected error: Unable to extract value from type: ${type}, debug: ${tokens.debug()}`);
+        }
+        return value;
+    }
+    else {
+        throw new Error(`extractValue: Unexpected error: Unexpected type: ${type}, debug: ${tokens.debug()}`);
+    }
+}
+function resolveStruct(idl, fields, tokens) {
+    const values = [];
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const value = extractValue(idl, field.type, tokens);
+        values.push(new Uint8Array(value));
+    }
+    return Buffer.concat(values);
+}
+function resolveEnum(idl, variants, tokens) {
+    let index;
+    const values = [];
+    if (variants.length <= 256) {
+        const buffer = tokens.readBuffer(1);
+        index = buffer.readUint8();
+        values.push(new Uint8Array(buffer));
+    }
+    else if (variants.length <= 65536) {
+        const buffer = tokens.readBuffer(2);
+        index = buffer.readUint16LE();
+        values.push(new Uint8Array(buffer));
+    }
+    else {
+        throw new Error(`resolveEnum: Unsupported enum. Debug: ${tokens.debug()}`);
+    }
+    if (typeof variants[index].fields !== 'undefined') {
+        for (let i = 0; i < variants[index].fields.length; i++) {
+            const field = variants[index].fields[i];
+            const value = extractValue(idl, field.type, tokens);
+            values.push(new Uint8Array(value));
+        }
+    }
+    return Buffer.concat(values);
+}
+function resolveOption(idl, type, tokens) {
+    const isSet = tokens.readBuffer(1);
+    if (isSet[0] === 0) {
+        return Buffer.from([0]);
+    }
+    else if (isSet[0] === 1) {
+        return Buffer.concat([isSet, extractValue(idl, type, tokens)]);
+    }
+    else {
+        throw new Error(`resolveOption: Value can only be 1 or 0. Actual value: ${isSet[0]}, debug: ${tokens.debug()}`);
+    }
+}
+function resolveVec(idl, type, tokens) {
+    const vectorSize = tokens.readBuffer(4);
+    const size = vectorSize.readUint32LE();
+    const values = [];
+    values.push(new Uint8Array(vectorSize));
+    for (let i = 0; i < size; i++) {
+        values.push(new Uint8Array(extractValue(idl, type, tokens)));
+    }
+    return Buffer.concat(values);
+}
+function resolveArray(idl, type, tokens) {
+    const _type = type[0];
+    const count = type[1];
+    const values = [];
+    if (typeof _type === 'object' && typeof _type.defined === 'object' && typeof _type.defined.name === 'string') {
+        for (let i = 0; i < count; i++) {
+            values.push(new Uint8Array(resolveDefined(idl, _type.defined.name, tokens)));
+        }
+    }
+    else if (typeof _type === 'string') {
+        for (let i = 0; i < count; i++) {
+            const value = extractPrimitives(_type, tokens);
+            if (value === undefined) {
+                throw new Error(`resolveArray: Unexpected error: Unresolvable value ${_type}, debug: ${tokens.debug()}`);
+            }
+            values.push(new Uint8Array(value));
+        }
+    }
+    else {
+        throw new Error(`resolveArray: Unexpected error: Unresolvable type: ${_type}, debug: ${tokens.debug()}`);
+    }
+    return Buffer.concat(values);
+}
+function resolveDefined(idl, typeName, tokens) {
+    const type = idl.types.find((t) => t.name === typeName);
+    if (type === undefined) {
+        throw new Error(`resolveDefined: Unexpected error: Cannot find type: ${typeName}`);
+    }
+    if (type.type.kind === 'struct') {
+        return resolveStruct(idl, type.type.fields, tokens);
+    }
+    else if (type.type.kind === 'enum') {
+        return resolveEnum(idl, type.type.variants, tokens);
+    }
+    else {
+        throw new Error(`resolveDefined: Unexpected error: Unexpected type: ${type.type.kind}, debug: ${tokens.debug()}`);
+    }
+}
+function extractPrimitives(type, tokens) {
+    if (type === 'u8' || type === 'i8' || type === 'bool') {
+        return tokens.readBuffer(1);
+    }
+    else if (type === 'u16' || type === 'i16') {
+        return tokens.readBuffer(2);
+    }
+    else if (type === 'u32' || type === 'i32') {
+        return tokens.readBuffer(4);
+    }
+    else if (type === 'u64' || type === '164') {
+        return tokens.readBuffer(8);
+    }
+    else if (type === 'u128' || type === 'i128') {
+        return tokens.readBuffer(16);
+    }
+}
+function simulateTransaction(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ connection, instructions, payerKey, alts, signers, addresses, }) {
+        const testVersionedTxn = new web3.VersionedTransaction(new web3.TransactionMessage({
+            instructions,
+            payerKey,
+            recentBlockhash: web3.PublicKey.default.toString(),
+        }).compileToV0Message(alts));
+        if (signers.length > 0) {
+            testVersionedTxn.sign(signers);
+        }
+        const simulation = yield connection.simulateTransaction(testVersionedTxn, {
+            replaceRecentBlockhash: true,
+            sigVerify: false,
+            accounts: {
+                encoding: 'base64',
+                addresses,
+            }
+        });
+        if (simulation.value.unitsConsumed === undefined) {
+            throw new Error("Unable to calculate compute budget.");
+        }
+        return {
+            err: simulation.value.err,
+            logs: simulation.value.logs,
+            accounts: simulation.value.accounts,
+            unitsConsumed: simulation.value.unitsConsumed,
+            returnData: simulation.value.returnData,
+        };
+    });
+}
+/**
+ * Construct a CreateAssociatedTokenAccountIdempotent instruction
+ *
+ * @param payer                    Payer of the initialization fees
+ * @param associatedToken          New associated token account
+ * @param owner                    Owner of the new account
+ * @param mint                     Token mint account
+ * @param programId                SPL Token program account
+ * @param associatedTokenProgramId SPL Associated Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+function createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, programId = addresses_1.TOKEN_PROGRAM_ID, associatedTokenProgramId = addresses_1.ASSOCIATED_TOKEN_PROGRAM) {
+    return buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, Buffer.from([1]), programId, associatedTokenProgramId);
+}
+function buildAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, instructionData, programId = addresses_1.TOKEN_PROGRAM_ID, associatedTokenProgramId = addresses_1.ASSOCIATED_TOKEN_PROGRAM) {
+    const keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: associatedToken, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: web3.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false },
+    ];
+    return new web3.TransactionInstruction({
+        keys,
+        programId: associatedTokenProgramId,
+        data: instructionData,
+    });
+}
+// pub fn check_tick_array_start_index(
+//   tick_array_start_index: i32,
+//   tick_index: i32,
+//   tick_spacing: u16,
+// ) -> Result<()> {
+//   require!(
+//       tick_index >= tick_math::MIN_TICK,
+//       ErrorCode::TickLowerOverflow
+//   );
+//   require!(
+//       tick_index <= tick_math::MAX_TICK,
+//       ErrorCode::TickUpperOverflow
+//   );
+//   require_eq!(0, tick_index % i32::from(tick_spacing));
+//   let expect_start_index = TickArrayState::get_array_start_index(tick_index, tick_spacing);
+//   require_eq!(tick_array_start_index, expect_start_index);
+//   Ok(())
+// }
+function raydiumStartTickIndex(tick_index, tick_spacing) {
+    const TICK_ARRAY_SIZE = 60;
+    const tick_count = TICK_ARRAY_SIZE * tick_spacing;
+    const start_index = tick_index / tick_count;
+    if (tick_index < 0 && tick_index % tick_count != 0) {
+        return (Math.ceil(start_index) - 1) * tick_count;
+    }
+    else {
+        return Math.floor(start_index) * tick_count;
+    }
+}
+function i32ToBeBuffer(value) {
+    // Let's manually convert a number to a buffer (4-bytes)
+    // Input is signed 32-bit integer
+    // Output is 4-bytes buffer in big-endian order
+    const buffer = Buffer.alloc(4);
+    buffer.writeInt32BE(value, 0);
+    return buffer;
+}
+function findUserAlts(userWallet_1, connection_1) {
+    return __awaiter(this, arguments, void 0, function* (userWallet, connection, filterDeactivated = true) {
+        const alts = yield connection.getProgramAccounts(web3.AddressLookupTableProgram.programId, {
+            filters: [{
+                    memcmp: {
+                        offset: 4 + 8 + 8 + 1 + 1,
+                        bytes: userWallet.toString(),
+                    }
+                }]
+        });
+        const _alts = alts.map((alt) => {
+            return new web3.AddressLookupTableAccount({
+                key: alt.pubkey,
+                state: web3.AddressLookupTableAccount.deserialize(new Uint8Array(alt.account.data))
+            });
+        });
+        return filterDeactivated ? _alts.filter(alt => alt.isActive()) : _alts;
+    });
+}
+/**
+ * Filters the list of pubkeys to only include pubkeys that are in the alt.
+ *
+ * @param pubkeys - List of pubkeys to filter
+ * @param alt - Alt to filter pubkeys by
+ * @returns List of pubkeys that are in the alt
+ */
+function pubkeysInAlt(pubkeys, alt) {
+    const pubkeysInAlt = pubkeys.filter(pubkey => {
+        const address = alt.state.addresses.find(address => {
+            if (address.toString() === pubkey) {
+                return address;
+            }
+        });
+        if (address) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    });
+    return pubkeysInAlt;
+}
+/**
+ * The goal of this function is to batch 100 accounts at a time as it is the max number of accounts that can be fetched at once.
+ * @param pubkeys - The accounts to fetch.
+ * @returns - A promise that resolves to an array of TokenAccountInfo objects.
+ */
+function getBatchedMultipleAccountsInfo(connection_1, pubkeys_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, pubkeys, commitment = "confirmed") {
+        const batchSize = 100;
+        const batches = [];
+        for (let i = 0; i < pubkeys.length; i += batchSize) {
+            batches.push(pubkeys.slice(i, i + batchSize));
+        }
+        const batch = yield Promise.all(batches.map(batch => connection.getMultipleAccountsInfo(batch, commitment)));
+        return batch.flat();
+    });
+}
+function getTokenProgramForMints(connection, mints) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mintCache = yield MintCache_1.MintCache
+            .instance(connection)
+            .getBatchedMultipleAccountsInfo(mints)
+            .waitForResult();
+        let tokenProgram = null;
+        for (let i = 0; i < mints.length; i++) {
+            const pubkey = mints[i];
+            const mintAccount = mintCache[pubkey.toString()].info;
+            const _tokenProgram = mintAccount.owner;
+            // Make sure that all tokens are owned by the same program.
+            if (tokenProgram === null) {
+                tokenProgram = _tokenProgram;
+            }
+            else {
+                // Make sure that all tokens are owned by the same program.
+                if (_tokenProgram.toString() !== tokenProgram.toString()) {
+                    throw new Error(`Token program mismatch for mint: ${pubkey}. It should be owned by program: ${tokenProgram}`);
+                }
+            }
+        }
+        if (tokenProgram === null) {
+            throw new Error(`No mints were passed in the parameter.`);
+        }
+        return tokenProgram;
+    });
+}
+function getTokenProgramMapForMints(connection, mints) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (mints.length === 0) {
+            throw new Error(`No mints were passed in the parameter.`);
+        }
+        const mintCache = yield MintCache_1.MintCache
+            .instance(connection)
+            .getBatchedMultipleAccountsInfo(mints)
+            .waitForResult();
+        let tokenProgramMap = {};
+        for (let i = 0; i < mints.length; i++) {
+            const pubkey = mints[i];
+            const mintAccount = mintCache[pubkey.toString()].info;
+            const _tokenProgram = mintAccount.owner;
+            tokenProgramMap[pubkey.toString()] = _tokenProgram;
+        }
+        return tokenProgramMap;
+    });
+}
+function getMeteoraStrategyType(strategyType, totalXAmount, totalYAmount) {
+    let singleSidedX;
+    const [_strategyType, oneSide] = types_1.StrategyTypeMap2[strategyType];
+    if (oneSide) {
+        if (totalXAmount.gt(new bn_js_1.default(0)) && totalYAmount.eq(new bn_js_1.default(0))) {
+            singleSidedX = true;
+        }
+        else if (totalXAmount.eq(new bn_js_1.default(0)) && totalYAmount.gt(new bn_js_1.default(0))) {
+            singleSidedX = false;
+        }
+        else {
+            throw new errors_1.AppError("Total X or Y amount must be greater than 0 when adding liquidity one-sided", `getMeteoraStrategyType`);
+        }
+    }
+    return [_strategyType, singleSidedX];
+}
+/**
+ * Generate Hawksight fee accounts for X and Y tokens
+ */
+function generateHawksightFeeAccounts(tokenXMint, tokenYMint, tokenXProgram, tokenYProgram) {
+    return {
+        ownerFeeX: generateAta(addresses_1.SITE_FEE_OWNER, tokenXMint, tokenXProgram),
+        ownerFeeY: generateAta(addresses_1.SITE_FEE_OWNER, tokenYMint, tokenYProgram),
+    };
+}
+/**
+ * Fetch RemainingAccountsInfo for Token2022 tokens with transfer hooks.
+ *
+ * This function checks if the provided token mints have transfer hook extensions
+ * and fetches the required extra account metas if they do.
+ *
+ * For standard SPL tokens or Token2022 tokens without transfer hooks, returns
+ * empty slices and accounts (which is the default/no-op case).
+ *
+ * @param connection - Solana connection
+ * @param tokenXMint - Token X mint address
+ * @param tokenYMint - Token Y mint address
+ * @param tokenXProgram - Token X program (TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID)
+ * @param tokenYProgram - Token Y program (TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID)
+ * @returns RemainingAccountsInfo with slices and accounts for transfer hooks
+ */
+/**
+ * Gets the transfer hook program ID from a Token2022 mint.
+ * Parses TLV extensions to find the TransferHook extension (type 14).
+ *
+ * @param connection - Solana connection
+ * @param mint - The mint to check for transfer hook
+ * @returns The transfer hook program ID, or null if none exists
+ */
+function getTransferHookProgramId(connection, mint) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const mintInfo = yield connection.getAccountInfo(mint);
+            if (!mintInfo || mintInfo.data.length < 165) {
+                return null; // Not a valid mint or no extensions
+            }
+            // Token2022 mint structure:
+            // - Base mint data: 82 bytes
+            // - Account type: 1 byte (should be 1 for mint)
+            // - Extensions follow after base data
+            //
+            // TransferHook extension has type 14 and contains:
+            // - authority: 32 bytes
+            // - programId: 32 bytes (the transfer hook program)
+            const data = mintInfo.data;
+            // Check if this is a Token2022 mint with extensions
+            // The extension data starts at offset 165 (after base mint + account type)
+            if (data.length <= 165) {
+                return null;
+            }
+            // Parse TLV (Type-Length-Value) extensions
+            let offset = 165; // Start of extensions
+            while (offset + 4 <= data.length) {
+                const extensionType = data.readUInt16LE(offset);
+                const extensionLength = data.readUInt16LE(offset + 2);
+                // TransferHook extension type is 14
+                if (extensionType === 14 && extensionLength >= 64) {
+                    // Skip authority (32 bytes), read programId (32 bytes)
+                    const programIdBytes = data.subarray(offset + 4 + 32, offset + 4 + 64);
+                    const programId = new web3.PublicKey(programIdBytes);
+                    // Check if programId is not default (all zeros)
+                    if (!programId.equals(web3.PublicKey.default)) {
+                        return programId;
+                    }
+                }
+                offset += 4 + extensionLength;
+            }
+            return null;
+        }
+        catch (error) {
+            (0, Logging_1.Log)(`Error fetching transfer hook for mint ${mint.toString()}: ${error}`);
+            return null;
+        }
+    });
+}
+/**
+ * Gets extra account metas for a transfer hook program.
+ * Parses the ExtraAccountMetas PDA to extract required accounts.
+ *
+ * @param connection - Solana connection
+ * @param mint - The mint with the transfer hook
+ * @param transferHookProgramId - The transfer hook program ID
+ * @returns Array of AccountMeta for the transfer hook
+ */
+function getTransferHookExtraAccountMetas(connection, mint, transferHookProgramId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Derive the extra account metas PDA
+            const [extraAccountMetasPda] = web3.PublicKey.findProgramAddressSync([Buffer.from('extra-account-metas'), mint.toBuffer()], transferHookProgramId);
+            const accountInfo = yield connection.getAccountInfo(extraAccountMetasPda);
+            if (!accountInfo) {
+                return [];
+            }
+            // Parse the extra account metas
+            // Format: u64 instruction_discriminator + u32 length + ExtraAccountMeta[]
+            // Each ExtraAccountMeta: u8 discriminator + 32 bytes addressConfig + bool isSigner + bool isWritable
+            const data = accountInfo.data;
+            if (data.length < 12) {
+                return [];
+            }
+            const count = data.readUInt32LE(8); // Length is at offset 8 (after u64 discriminator)
+            const extraMetas = [];
+            let offset = 12; // Start of extra accounts array
+            for (let i = 0; i < count && offset + 35 <= data.length; i++) {
+                const discriminator = data.readUInt8(offset);
+                const addressConfig = data.subarray(offset + 1, offset + 33);
+                const isSigner = data.readUInt8(offset + 33) === 1;
+                const isWritable = data.readUInt8(offset + 34) === 1;
+                // Discriminator 0 means literal address
+                if (discriminator === 0) {
+                    extraMetas.push({
+                        pubkey: new web3.PublicKey(addressConfig),
+                        isSigner,
+                        isWritable,
+                    });
+                }
+                // Other discriminators require more complex resolution (seeds, etc.)
+                // For now, we only support literal addresses
+                offset += 35;
+            }
+            return extraMetas;
+        }
+        catch (error) {
+            (0, Logging_1.Log)(`Error fetching extra account metas: ${error}`);
+            return [];
+        }
+    });
+}
+function fetchRemainingAccountsInfo(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const slices = [];
+        const accounts = [];
+        // Only Token2022 tokens can have transfer hooks
+        // Standard SPL tokens (TOKEN_PROGRAM_ID) never have transfer hooks
+        const hasToken2022X = tokenXProgram.equals(addresses_1.TOKEN_2022);
+        const hasToken2022Y = tokenYProgram.equals(addresses_1.TOKEN_2022);
+        // If neither token is Token2022, return empty (no transfer hooks possible)
+        if (!hasToken2022X && !hasToken2022Y) {
+            return { slices, accounts };
+        }
+        // Check token X for transfer hook
+        if (hasToken2022X) {
+            const hookProgramIdX = yield getTransferHookProgramId(connection, tokenXMint);
+            if (hookProgramIdX) {
+                const extraAccountsX = yield getTransferHookExtraAccountMetas(connection, tokenXMint, hookProgramIdX);
+                if (extraAccountsX.length > 0) {
+                    slices.push({
+                        accountsType: types_1.RemainingAccountsType.TransferHookX,
+                        length: extraAccountsX.length,
+                    });
+                    accounts.push(...extraAccountsX);
+                }
+            }
+        }
+        // Check token Y for transfer hook
+        if (hasToken2022Y) {
+            const hookProgramIdY = yield getTransferHookProgramId(connection, tokenYMint);
+            if (hookProgramIdY) {
+                const extraAccountsY = yield getTransferHookExtraAccountMetas(connection, tokenYMint, hookProgramIdY);
+                if (extraAccountsY.length > 0) {
+                    slices.push({
+                        accountsType: types_1.RemainingAccountsType.TransferHookY,
+                        length: extraAccountsY.length,
+                    });
+                    accounts.push(...extraAccountsY);
+                }
+            }
+        }
+        return { slices, accounts };
+    });
+}
+/**
+ * Fetches remainingAccountsInfo for a reward mint's transfer hook (Token2022).
+ * Used for claim_reward2 instructions where we only need transfer hooks for the reward token.
+ *
+ * @param connection - Solana connection
+ * @param rewardMint - The reward token mint
+ * @param rewardTokenProgram - The token program for the reward mint
+ * @returns RemainingAccountsInfo with transfer hook accounts for the reward token
+ */
+function fetchRemainingAccountsInfoForReward(connection, rewardMint, rewardTokenProgram) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const slices = [];
+        const accounts = [];
+        // Only Token2022 tokens can have transfer hooks
+        if (!rewardTokenProgram.equals(addresses_1.TOKEN_2022)) {
+            return { slices, accounts };
+        }
+        // Check reward mint for transfer hook
+        const hookProgramId = yield getTransferHookProgramId(connection, rewardMint);
+        if (hookProgramId) {
+            const extraAccounts = yield getTransferHookExtraAccountMetas(connection, rewardMint, hookProgramId);
+            if (extraAccounts.length > 0) {
+                slices.push({
+                    accountsType: types_1.RemainingAccountsType.TransferHookReward,
+                    length: extraAccounts.length,
+                });
+                accounts.push(...extraAccounts);
+            }
+        }
+        return { slices, accounts };
+    });
+}