@hawksightco/hawk-sdk 1.3.265 → 1.3.266

package/dist/ixGenerator/IyfMainIxGenerator.js

@@ -0,0 +1,1239 @@
+"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.IyfMainIxGenerator = void 0;
+const web3 = __importStar(require("@solana/web3.js"));
+const anchor_1 = require("../anchor");
+const hawksight_1 = require("../hawksight");
+const functions_1 = require("../functions");
+const addresses_1 = require("../addresses");
+const types_1 = require("../types");
+const bn_js_1 = __importDefault(require("bn.js"));
+const token_1 = require("@coral-xyz/anchor/dist/cjs/utils/token");
+const web3_js_1 = require("@solana/web3.js");
+const util = __importStar(require("../functions"));
+const WSOL_MINT = new web3.PublicKey("So11111111111111111111111111111111111111112");
+/**
+ * Iyf Main IX Generator
+ */
+class IyfMainIxGenerator {
+    /**
+     * Generates a transaction instruction that sets the current blockchain clock
+     * to the user's PDA (Program Derived Address) account.
+     *
+     * @param connection - A Solana web3.js Connection object for interacting with the blockchain.
+     * @param params - AtomicityContextParams containing the context and parameters for setting the transaction slot.
+     * @returns A Promise that resolves to a TransactionInstruction object for setting the current clock in the PDA.
+     */
+    setTransactionSlot(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Get set transaction slot instruction
+            return yield (0, hawksight_1.setTransactionSlot)(params);
+        });
+    }
+    /**
+     * Generates a transaction instruction that verifies whether the current blockchain
+     * clock matches the value that has been previously set in the user's PDA (Program Derived Address) account.
+     *
+     * @param connection - A Solana web3.js Connection object for interacting with the blockchain.
+     * @param params - AtomicityContextParams containing the context and parameters for verifying the transaction slot.
+     * @returns A Promise that resolves to a TransactionInstruction object for verifying the clock in the PDA.
+     */
+    verifyTransactionSlot(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Get verify transaction slot instruction
+            return yield (0, hawksight_1.verifyTransactionSlot)(params);
+        });
+    }
+    /**
+     * Transfers all the pass through token accounts balance into the corresponding storage token account
+     *
+     * @param connection - A Solana web3.js Connection object for interacting with the blockchain.
+     * @param params - StoreTokenContextParams containing the context and parameters.
+     * @returns A Promise that resolves to a TransactionInstruction object for verifying the clock in the PDA.
+     */
+    storeToken(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Get verify transaction slot instruction
+            return yield (0, hawksight_1.storeToken)(connection, params);
+        });
+    }
+    /**
+   * Initialize a storage token account for a given user pda and mints
+   *
+   * @param connection
+   * @param params
+   * @returns
+   */
+    initializeStorageTokenAccounts(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Promise.all(params.mints.map((mint) => __awaiter(this, void 0, void 0, function* () {
+                return yield this.initializeStorageTokenAccount(connection, {
+                    userWallet: params.userWallet,
+                    mint,
+                });
+            })));
+        });
+    }
+    /**
+     * Initialize a storage token account for a given user pda and mint
+     *
+     * @param connection
+     * @param params
+     * @returns
+     */
+    initializeStorageTokenAccount(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            const storageTokenAccount = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.mint);
+            const tokenProgram = yield util.getTokenProgramForMints(connection, [params.mint]);
+            // Create initialize storage token account instruction
+            // @ts-ignore
+            return yield anchor_1.Anchor.instance().iyfMain.methods
+                .initializeStorageTokenAccount()
+                .accounts({
+                userPda,
+                payer: params.userWallet,
+                mint: params.mint,
+                storageTokenAccount,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                tokenProgram,
+                systemProgram: web3_js_1.SystemProgram.programId
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Invoke iyf extension
+     *
+     * @param connection
+     * @param params
+     */
+    iyfExtensionExecute(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, iyfExtensionIx, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user pda
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Validate whether instruction is valid
+            const invalidInstruction = !iyfExtensionIx.programId.equals(addresses_1.IYF_EXTENSION) ||
+                iyfExtensionIx.keys.length < 4 ||
+                iyfExtensionIx.data.length < 8 ||
+                !iyfExtensionIx.keys[0].pubkey.equals(addresses_1.USDC_FARM) ||
+                !iyfExtensionIx.keys[1].pubkey.equals(userPda) ||
+                !iyfExtensionIx.keys[2].pubkey.equals(userWallet) ||
+                !iyfExtensionIx.keys[3].pubkey.equals(addresses_1.IYF_MAIN);
+            if (invalidInstruction) {
+                throw new Error('The given instruction is not a valid iyf extension instruction.');
+            }
+            // Generate iyf extension instruction
+            const ix = yield anchor_1.Anchor.instance().iyfMain
+                .methods
+                .iyfExtensionExecute(iyfExtensionIx.data)
+                .accounts({
+                farm: addresses_1.USDC_FARM,
+                userPda,
+                authority: userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: iyfExtensionIx.programId
+            })
+                .remainingAccounts(iyfExtensionIx.keys.slice(4))
+                .instruction();
+            return ix;
+        });
+    }
+    /**
+     * Invoke iyf extension
+     *
+     * @param connection
+     * @param params
+     */
+    iyfExtensionExecuteV2(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userPda, authority, ix, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Validate whether instruction is valid
+            const invalidInstruction = !ix.programId.equals(addresses_1.IYF_EXTENSION) ||
+                ix.keys.length < 2 ||
+                ix.data.length < 8 ||
+                !ix.keys[0].pubkey.equals(userPda);
+            if (invalidInstruction) {
+                throw new Error('The given instruction is not a valid iyf extension v2 instruction.');
+            }
+            const wrapIx = yield anchor_1.Anchor.instance().iyfMain
+                .methods
+                .iyfExtensionExecuteV2(ix.data)
+                .accounts({
+                userPda,
+                authority,
+                iyfExtensionProgram: ix.programId
+            })
+                .remainingAccounts(ix.keys.slice(2))
+                .instruction();
+            // NOTE: We need iyf execute 2 authority to always be writable now
+            // // Retain the mutable status of the authority
+            // wrapIx.keys[1].isWritable = ix.keys[1].isWritable;
+            // Generate iyf extension instruction
+            return wrapIx;
+        });
+    }
+    jupiterRouteIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, userPda, sourceTokenAccount, destinationTokenAccount, destinationMint, platformFeeAccount, eventAuthority, remainingAccounts, data, slippageOutPct, quotedOutAmount_override, slippageBps, platformFeeBps, isWalletSigner, }) {
+            var _b;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const { routePlan, slippageBps: slippageBps_default, platformFeeBps: platformFeeBps_default, } = (0, functions_1.getJupiterRouteIxParams)(data);
+            const tokenProgramMap = yield util.getTokenProgramMapForMints(connection, [destinationMint]);
+            const tokenProgram = tokenProgramMap[destinationMint.toString()];
+            // Generate user pda from given user wallet
+            userPda = userWallet !== undefined ? (0, functions_1.generateUserPda)(userWallet) : userPda;
+            if (userPda === undefined) {
+                throw new Error("Either one of `userWallet` or `userPda` parameter must be defined!");
+            }
+            // Defaults to false
+            let ataExists = false;
+            // Generate STA and ATA
+            const destATA = (0, functions_1.generateAta)(userPda, destinationMint, tokenProgram);
+            const destSTA = (0, functions_1.generateUserPdaStorageAccount)(userPda, destinationMint);
+            const destLTA = (0, functions_1.generateLimitToken)(userPda, destinationMint);
+            // createAtaIx
+            let createAtaIx;
+            if (destATA.equals(destinationTokenAccount)) {
+                [createAtaIx] = (0, functions_1.createAtaIdempotentIxs)({
+                    accounts: [{
+                            payer: addresses_1.HS_AUTHORITY,
+                            mint: destinationMint,
+                            owner: userPda,
+                            programId: tokenProgram,
+                        }]
+                });
+            }
+            else if (destSTA.equals(destinationTokenAccount)) {
+                createAtaIx = yield anchor_1.Anchor.instance().iyfMain
+                    .methods
+                    .initializeStorageTokenAccount()
+                    .accounts({
+                    userPda,
+                    payer: addresses_1.HS_AUTHORITY,
+                    mint: destinationMint,
+                    storageTokenAccount: destSTA,
+                    rent: web3.SYSVAR_RENT_PUBKEY,
+                    tokenProgram,
+                    systemProgram: web3.SystemProgram.programId,
+                })
+                    .instruction();
+            }
+            else if (destLTA.equals(destinationTokenAccount)) {
+                [createAtaIx] = (0, functions_1.createAtaIdempotentIxs)({
+                    accounts: [{
+                            payer: addresses_1.HS_AUTHORITY,
+                            mint: destinationMint,
+                            owner: userPda,
+                        }]
+                });
+            }
+            else {
+                throw new Error(`destinationTokenAccount: ${destinationTokenAccount} is neither ATA(${destATA}) or STA${destSTA}`);
+            }
+            const info = yield connection.getAccountInfo(destinationTokenAccount);
+            ataExists = !(info === null || info === undefined);
+            const closeAtaIx = yield anchor_1.Anchor.instance().iyfMain
+                .methods
+                .closeAta()
+                .accounts({
+                userPda,
+                hsAuthority: addresses_1.HS_AUTHORITY,
+                userTokenAccount: destinationTokenAccount,
+                tokenProgram,
+            })
+                .instruction();
+            const quotedOutAmount_sim = new bn_js_1.default(0);
+            const p_slippageBps = slippageBps === undefined ? slippageBps_default : slippageBps;
+            const p_platformFeeBps = platformFeeBps === undefined ? platformFeeBps_default : platformFeeBps;
+            const jupiterRouteIx = (quotedOutAmount) => __awaiter(this, void 0, void 0, function* () {
+                // @ts-ignore
+                return yield anchor_1.Anchor.instance().iyfMain
+                    .methods
+                    .jupiterRouteIx(routePlan, quotedOutAmount, p_slippageBps, p_platformFeeBps)
+                    .accounts({
+                    authority: isWalletSigner ? userWallet : addresses_1.HS_AUTHORITY,
+                    tokenProgram: addresses_1.TOKEN_PROGRAM_ID, // token2022 program probably generated in remaining accounts generated by jupiter API.
+                    userPda,
+                    userSourceTokenAccount: sourceTokenAccount,
+                    userDestinationTokenAccount: destinationTokenAccount,
+                    destinationMint,
+                    platformFeeAccount,
+                    eventAuthority,
+                    jupiterProgram: addresses_1.JUPITER_PROGRAM
+                })
+                    .remainingAccounts(remainingAccounts)
+                    .instruction();
+            });
+            // If quotedOutAmountOverride is set, then skip the simulation
+            if (quotedOutAmount_override) {
+                const ix = yield jupiterRouteIx(quotedOutAmount_override);
+                return {
+                    swapIx: ix,
+                    createAtaIx,
+                    closeAtaIx,
+                    ataExists,
+                };
+            }
+            // Create simulation ix (to figure out result value of destination token)
+            const ixSimulate = yield jupiterRouteIx(quotedOutAmount_sim);
+            const instructions = [createAtaIx, ixSimulate]
+                .filter((_, index) => index === 0 && !ataExists ? !ataExists : true);
+            let previousAmount = new bn_js_1.default(0);
+            if (ataExists && info !== null) {
+                const token = (0, functions_1.parseTokenAccountData)(info.data);
+                previousAmount = token.amount;
+            }
+            if (slippageOutPct === undefined) {
+                throw new Error(`slippageOutPct parameter is not set`);
+            }
+            // Simulate the transaction to get expected out token
+            let tokenAmount = previousAmount;
+            if (slippageOutPct < 10000) {
+                const simulation = yield (0, functions_1.simulateTransaction)({
+                    connection,
+                    instructions,
+                    payerKey: isWalletSigner ? userWallet : addresses_1.HS_AUTHORITY,
+                    alts: [],
+                    signers: [],
+                    addresses: [destinationTokenAccount.toString()],
+                });
+                try {
+                    const token = (0, functions_1.parseTokenAccountData)(Buffer.from((_b = simulation.accounts[0]) === null || _b === void 0 ? void 0 : _b.data[0], 'base64'));
+                    tokenAmount = token.amount;
+                }
+                catch (_c) {
+                    console.log(simulation.logs);
+                    throw Error('Transaction simulation failed. See logs above.');
+                }
+            }
+            const delta = tokenAmount.sub(previousAmount);
+            const quotedOutAmount = delta.mul(new bn_js_1.default(10000)
+                .sub(new bn_js_1.default(slippageOutPct))).div(new bn_js_1.default(10000));
+            slippageBps = slippageBps === undefined ? slippageBps_default : slippageBps;
+            platformFeeBps = platformFeeBps === undefined ? platformFeeBps_default : platformFeeBps;
+            // Create actual ix with calculated slippage amount from `slippageOut` input
+            const ix = yield jupiterRouteIx(quotedOutAmount);
+            return {
+                swapIx: ix,
+                createAtaIx,
+                closeAtaIx,
+                ataExists,
+            };
+        });
+    }
+    withdrawLamportsFromPda(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const userPdaLamport = (0, functions_1.generateUserPdaLamport)(userWallet);
+            return yield anchor_1.Anchor.instance().iyfMain.methods
+                .withdrawLamportsFromPda()
+                .accounts({
+                farm: addresses_1.USDC_FARM,
+                payer: userWallet,
+                userPda,
+                userPdaLamport,
+                ownerFeeAccount: addresses_1.SITE_FEE_OWNER,
+                systemProgram: web3.SystemProgram.programId,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accounts
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    depositMultipleToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, deposit }) {
+            return yield (0, hawksight_1.depositMultipleToken)({ connection, payer, deposit });
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accountsz
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    withdrawMultipleToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, withdraw, useSta }) {
+            return yield (0, hawksight_1.withdrawMultipleToken)({ connection, payer, withdraw, useSta });
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accounts
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    depositMultipleTokenV2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, deposit, pdaTokenType }) {
+            return yield (0, hawksight_1.depositMultipleTokenV2)({ connection, payer, deposit, pdaTokenType });
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accountsz
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    withdrawMultipleTokenV2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, withdraw, useSta, pdaTokenType, hasAmount }) {
+            return yield (0, hawksight_1.withdrawMultipleTokenV2)({ connection, payer, withdraw, useSta, pdaTokenType, hasAmount });
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accounts
+     *
+     * @deprecated Will be moving towards labeled instructions. Please use depositMultipleTokenWithToken2022WithLabel
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    depositMultipleTokenWithToken2022(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, deposit, pdaTokenType }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = util.generateUserPda(payer, farm);
+            const amounts = deposit.map((d) => d.amount);
+            const remainingAccounts = [];
+            // Get mint pubkeys
+            const mints = deposit.map((d) => d.mint);
+            // Get and assert one token program for all mints.
+            // Throws an error if there are multiple token programs.
+            const tokenProgramMap = yield util.getTokenProgramMapForMints(connection, mints);
+            let skipIdempotent = false;
+            deposit.map((d) => {
+                const mint = d.mint;
+                const key = mint.toString();
+                const userToken = util.generateAta(payer, d.mint, tokenProgramMap[key]);
+                const ownerFeeToken = util.generateAta(addresses_1.SITE_FEE_OWNER, d.mint, tokenProgramMap[key]);
+                let userPdaToken;
+                if (pdaTokenType === types_1.TokenType.LTA) {
+                    skipIdempotent = true;
+                    userPdaToken = util.generateLimitToken(userPda, d.mint);
+                }
+                else if (pdaTokenType === types_1.TokenType.STA) {
+                    skipIdempotent = true;
+                    userPdaToken = util.generateUserPdaStorageAccount(userPda, d.mint);
+                }
+                else {
+                    userPdaToken = util.generateAta(userPda, d.mint, tokenProgramMap[key]);
+                }
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .depositMultipleTokenWithToken2022(amounts, skipIdempotent)
+                .accounts({
+                farm,
+                userPda,
+                payer,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                tokenProgram2022: addresses_1.TOKEN_2022_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            // IDL marks payer as signer only, but the program CPIs into
+            // CreateIdempotent/transfer which needs payer writable to debit lamports.
+            const payerKey = ix.keys.find(k => k.pubkey.equals(payer));
+            if (payerKey)
+                payerKey.isWritable = true;
+            return ix;
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accounts
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    depositMultipleTokenWithToken2022WithLabel(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, deposit, pdaTokenType }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = util.generateUserPda(payer, farm);
+            const amounts = deposit.map((d) => d.amount);
+            const remainingAccounts = [];
+            // Get mint pubkeys
+            const mints = deposit.map((d) => d.mint);
+            // Get and assert one token program for all mints.
+            // Throws an error if there are multiple token programs.
+            const tokenProgramMap = yield util.getTokenProgramMapForMints(connection, mints);
+            let skipIdempotent = false;
+            deposit.map((d) => {
+                const mint = d.mint;
+                const key = mint.toString();
+                const userToken = util.generateAta(payer, d.mint, tokenProgramMap[key]);
+                const ownerFeeToken = util.generateAta(addresses_1.SITE_FEE_OWNER, d.mint, tokenProgramMap[key]);
+                let userPdaToken;
+                if (pdaTokenType === types_1.TokenType.LTA) {
+                    skipIdempotent = true;
+                    userPdaToken = util.generateLimitToken(userPda, d.mint);
+                }
+                else if (pdaTokenType === types_1.TokenType.STA) {
+                    skipIdempotent = true;
+                    userPdaToken = util.generateUserPdaStorageAccount(userPda, d.mint);
+                }
+                else {
+                    userPdaToken = util.generateAta(userPda, d.mint, tokenProgramMap[key]);
+                }
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .depositMultipleTokenWithToken2022(amounts, skipIdempotent)
+                .accounts({
+                farm,
+                userPda,
+                payer,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                tokenProgram2022: addresses_1.TOKEN_2022_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            // IDL marks payer as signer only, but the program CPIs into
+            // CreateIdempotent/transfer which needs payer writable to debit lamports.
+            const payerKey = ix.keys.find(k => k.pubkey.equals(payer));
+            if (payerKey)
+                payerKey.isWritable = true;
+            return {
+                instruction: ix,
+                label: `Deposit tokens to passthrough token accounts`,
+                class: `depositMultipleTokenWithToken2022WithLabel`
+            };
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accountsz
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    withdrawMultipleTokenWithToken2022(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, withdraw, useSta, pdaTokenType, hasAmount }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = util.generateUserPda(payer, farm);
+            const remainingAccounts = [];
+            const amounts = withdraw.map((d) => d.amount);
+            // Get mint pubkeys
+            const mints = withdraw.map((d) => d.mint);
+            console.log("mints", mints);
+            // Get and assert one token program for all mints.
+            // Throws an error if there are multiple token programs.
+            const tokenProgramMap = yield util.getTokenProgramMapForMints(connection, mints);
+            let skipIdempotent = false;
+            withdraw.map((d) => {
+                const mint = d.mint;
+                const key = mint.toString();
+                const userToken = util.generateAta(payer, d.mint, tokenProgramMap[key]);
+                const ownerFeeToken = util.generateAta(addresses_1.SITE_FEE_OWNER, d.mint, tokenProgramMap[key]);
+                let userPdaToken;
+                if (pdaTokenType === types_1.TokenType.LTA) {
+                    // skipIdempotent = true;
+                    userPdaToken = util.generateLimitToken(userPda, d.mint);
+                }
+                else if (pdaTokenType === types_1.TokenType.STA || useSta) {
+                    // skipIdempotent = true;
+                    userPdaToken = util.generateUserPdaStorageAccount(userPda, d.mint);
+                }
+                else {
+                    userPdaToken = util.generateAta(userPda, d.mint, tokenProgramMap[key]);
+                }
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .withdrawMultipleTokenWithToken2022(skipIdempotent, hasAmount ? amounts : null)
+                .accounts({
+                farm,
+                userPda,
+                payer,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                tokenProgram2022: addresses_1.TOKEN_2022_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return ix;
+        });
+    }
+    /**
+     * Deposit multiple user pda token to passthrough token accountsz
+     *
+     * @returns DepositMultipleToken instruction
+     */
+    withdrawMultipleTokenWithToken2022WithLabel(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, withdraw, useSta, pdaTokenType, hasAmount }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = util.generateUserPda(payer, farm);
+            const remainingAccounts = [];
+            const amounts = withdraw.map((d) => d.amount);
+            // Get mint pubkeys
+            const mints = withdraw.map((d) => d.mint);
+            console.log("mints", mints);
+            // Get and assert one token program for all mints.
+            // Throws an error if there are multiple token programs.
+            const tokenProgramMap = yield util.getTokenProgramMapForMints(connection, mints);
+            let skipIdempotent = false;
+            withdraw.map((d) => {
+                const mint = d.mint;
+                const key = mint.toString();
+                const userToken = util.generateAta(payer, d.mint, tokenProgramMap[key]);
+                const ownerFeeToken = util.generateAta(addresses_1.SITE_FEE_OWNER, d.mint, tokenProgramMap[key]);
+                let userPdaToken;
+                if (pdaTokenType === types_1.TokenType.LTA) {
+                    // skipIdempotent = true;
+                    userPdaToken = util.generateLimitToken(userPda, d.mint);
+                }
+                else if (pdaTokenType === types_1.TokenType.STA || useSta) {
+                    // skipIdempotent = true;
+                    userPdaToken = util.generateUserPdaStorageAccount(userPda, d.mint);
+                }
+                else {
+                    userPdaToken = util.generateAta(userPda, d.mint, tokenProgramMap[key]);
+                }
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .withdrawMultipleTokenWithToken2022(skipIdempotent, hasAmount ? amounts : null)
+                .accounts({
+                farm,
+                userPda,
+                payer,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                tokenProgram2022: addresses_1.TOKEN_2022_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return {
+                instruction: ix,
+                label: `Withdraw tokens from passthrough token accounts`,
+                class: `withdrawMultipleTokenWithToken2022WithLabel`
+            };
+        });
+    }
+    /**
+     * Deposit single token from user pda
+     *
+     * @returns
+     */
+    depositTokenFromUserPda(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, mint, amount, type, }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const tokenProgram = yield util.getTokenProgramForMints(connection, [mint]);
+            const userToken = (0, functions_1.generateAta)(userWallet, mint, tokenProgram);
+            let userPdaToken;
+            if (type === types_1.TokenType.LTA) {
+                userPdaToken = (0, functions_1.generateLimitToken)(userPda, mint);
+            }
+            else if (type === types_1.TokenType.STA) {
+                userPdaToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, mint);
+            }
+            else {
+                userPdaToken = (0, functions_1.generateAta)(userPda, mint, tokenProgram);
+            }
+            const ownerFeeToken = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, mint, tokenProgram);
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .depositTokenToUserPda(amount)
+                .accounts({
+                farm,
+                userPda,
+                payer: userWallet,
+                userToken,
+                userPdaToken,
+                ownerFeeToken,
+                tokenProgram,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    /**
+     * Withdraw single token from user pda
+     *
+     * @returns
+     */
+    withdrawTokenFromUserPda(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, mint, useSta, type, }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const remainingAccounts = [];
+            const tokenProgram = yield util.getTokenProgramForMints(connection, [mint]);
+            const userToken = (0, functions_1.generateAta)(userWallet, mint, tokenProgram);
+            let userPdaToken;
+            if (type === types_1.TokenType.LTA) {
+                userPdaToken = (0, functions_1.generateLimitToken)(userPda, mint);
+            }
+            else if (type === types_1.TokenType.STA || useSta) {
+                userPdaToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, mint);
+            }
+            else {
+                userPdaToken = (0, functions_1.generateAta)(userPda, mint, tokenProgram);
+            }
+            const ownerFeeToken = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, mint, tokenProgram);
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .withdrawTokenFromUserPda()
+                .accounts({
+                farm,
+                userPda,
+                payer: userWallet,
+                userToken,
+                userPdaToken,
+                ownerFeeToken,
+                tokenProgram,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return ix;
+        });
+    }
+    raydiumDynamicCpi(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, raydiumIx, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user pda
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const nftOwner = (0, functions_1.generateUserPdaLamport)(userWallet);
+            if (raydiumIx.programId.equals(addresses_1.RAYDIUM_PROGRAM)) {
+                // Define the whitelisted instructions
+                const whitelist = {
+                    "open_position_with_token22_nft": 1,
+                    "close_position": 0,
+                    "increase_liquidity_v2": 0,
+                };
+                // Find the instruction
+                const key = Object.keys(whitelist).find(discriminator => (0, functions_1.sighashMatch)(raydiumIx.data, discriminator, "global", true));
+                // Key has to return a value. Otherwise, throw error (means we try to execute ix not in the whitelist)
+                if (key === undefined) {
+                    throw new Error('raydiumDynamicCpi: Instruction not in whitelist.');
+                }
+                const index = whitelist[key];
+                // Remove nft owner
+                raydiumIx.keys.splice(index, 1);
+                // Raydium dynamic cpi wrapper
+                const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                    .raydiumDynamicCpi(raydiumIx.data)
+                    .accounts({
+                    raydiumProgram: addresses_1.RAYDIUM_PROGRAM,
+                    userPda,
+                    authority: userWallet,
+                    nftOwner,
+                })
+                    .remainingAccounts([
+                    ...raydiumIx.keys
+                ])
+                    .instruction();
+                return ix;
+            }
+            else if (raydiumIx.programId.equals(addresses_1.IYF_EXTENSION)) {
+                // Raydium dynamic cpi wrapper
+                const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                    .raydiumDynamicCpi(raydiumIx.data)
+                    .accounts({
+                    raydiumProgram: addresses_1.RAYDIUM_PROGRAM,
+                    userPda,
+                    authority: raydiumIx.keys[2].pubkey,
+                    nftOwner,
+                })
+                    .remainingAccounts([
+                    { pubkey: addresses_1.IYF_EXTENSION, isSigner: false, isWritable: false },
+                    ...raydiumIx.keys.slice(4)
+                ])
+                    .instruction();
+                return ix;
+            }
+            else {
+                throw new Error(`raydiumDynamicCpi: Invalid raydiumIx.programId: ${raydiumIx.programId}`);
+            }
+        });
+    }
+    depositMultipleLamportPdaToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userWallet, deposit, skipIdempotent }) {
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const userPdaLamport = (0, functions_1.generateUserPdaLamport)(userWallet);
+            const amounts = deposit.map((d) => d.amount);
+            const remainingAccounts = [];
+            deposit.map((d) => {
+                const mint = d.mint;
+                const userToken = (0, functions_1.generateAta)(userWallet, d.mint);
+                const userPdaToken = (0, functions_1.generateAta)(userPdaLamport, d.mint);
+                const ownerFeeToken = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, d.mint);
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            skipIdempotent = skipIdempotent === undefined ? false : skipIdempotent;
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .depositMultipleLamportPdaToken(amounts, skipIdempotent)
+                .accounts({
+                userPda,
+                userPdaLamport,
+                payer: userWallet,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: token_1.ASSOCIATED_PROGRAM_ID,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return ix;
+        });
+    }
+    withdrawMultipleLamportPdaToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userWallet, withdraw, skipIdempotent }) {
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const userPdaLamport = (0, functions_1.generateUserPdaLamport)(userWallet);
+            const remainingAccounts = [];
+            withdraw.map((d) => {
+                const mint = d.mint;
+                const userToken = (0, functions_1.generateAta)(userWallet, d.mint);
+                const userPdaToken = (0, functions_1.generateAta)(userPdaLamport, d.mint);
+                const ownerFeeToken = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, d.mint);
+                remainingAccounts.push({ pubkey: mint, isSigner: false, isWritable: true });
+                remainingAccounts.push({
+                    pubkey: userToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: userPdaToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+                remainingAccounts.push({
+                    pubkey: ownerFeeToken,
+                    isSigner: false,
+                    isWritable: true,
+                });
+            });
+            skipIdempotent = skipIdempotent === undefined ? false : skipIdempotent;
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .withdrawMultipleLamportPdaToken(skipIdempotent)
+                .accounts({
+                userPda,
+                userPdaLamport,
+                payer: userWallet,
+                hsFeeOwner: addresses_1.SITE_FEE_OWNER,
+                associatedTokenProgram: token_1.ASSOCIATED_PROGRAM_ID,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            return ix;
+        });
+    }
+    createLimitToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, payer, userWallet, mint, }) {
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const tokenProgram = yield util.getTokenProgramForMints(connection, [mint]);
+            const limitToken = (0, functions_1.generateLimitToken)(userPda, mint);
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .createLimitToken()
+                .accounts({
+                userPda,
+                payer,
+                authority: userWallet,
+                limitToken,
+                mint,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                tokenProgram,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    closeLimitToken(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, mint, }) {
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const tokenProgram = yield util.getTokenProgramForMints(connection, [mint]);
+            const limitToken = (0, functions_1.generateLimitToken)(userPda, mint);
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .closeLimitToken()
+                .accounts({
+                userPda,
+                payer: userWallet,
+                authority: userWallet,
+                limitToken,
+                mint,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                tokenProgram,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    fuelDeposit(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userWallet, amount, }) {
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const fuelAccount = (0, functions_1.generateFuelAccount)(userWallet);
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .fuelDeposit(amount)
+                .accounts({
+                userPda,
+                authority: userWallet,
+                fuelAccount,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    fuelWithdraw(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, amount, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const fuelAccount = (0, functions_1.generateFuelAccount)(userWallet);
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .fuelWithdraw(amount)
+                .accounts({
+                userPda,
+                authority: userWallet,
+                fuelAccount,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    wrapFromFuel(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, authority, amount, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const fuelAccount = (0, functions_1.generateFuelAccount)(userWallet);
+            const userWrappedSol = (0, functions_1.generateLimitToken)(userPda, WSOL_MINT);
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .wrapFromFuel(amount || null)
+                .accounts({
+                userPda,
+                authority,
+                fuelAccount,
+                userWrappedSol,
+                wsolMint: WSOL_MINT,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: token_1.ASSOCIATED_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    unwrapToFuel(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, authority, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const fuelAccount = (0, functions_1.generateFuelAccount)(userWallet);
+            // Only supports LTA for now
+            const userWrappedSol = (0, functions_1.generateLimitToken)(userPda, WSOL_MINT);
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .unwrapToFuel()
+                .accounts({
+                userPda,
+                authority,
+                fuelAccount,
+                userWrappedSol,
+                wsolMint: WSOL_MINT,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: token_1.ASSOCIATED_PROGRAM_ID,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    pumpFunCloseUserVolumeAccumulator(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userPda, authority, eventAuthorityPda, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Derive userVolumeAccumulatorAddress using PDA
+            const [userVolumeAccumulatorAddress] = web3.PublicKey.findProgramAddressSync([
+                Buffer.from('user_volume_accumulator'),
+                userPda.toBuffer(),
+            ], addresses_1.PUMP_FUN_AMM_PROGRAM);
+            // Generate the instruction using Anchor pattern
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .pumpFunCloseUserVolumeAccumulator()
+                .accounts({
+                userPda,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                userVolumeAccumulator: userVolumeAccumulatorAddress,
+                eventAuthority: eventAuthorityPda,
+                pumpFunProgram: addresses_1.PUMP_FUN_AMM_PROGRAM,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    meteoraDynamicCpi(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, meteoraIx, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate dynamic cpi for invoking Meteora DLMM program via HawkFi
+            // The meteoraIx.keys are passed as remaining accounts to the CPI
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .meteoraDynamicCpi(meteoraIx.data)
+                .accounts({
+                userPda,
+                authority: userWallet,
+                meteoraProgram: addresses_1.METEORA_DLMM_PROGRAM,
+            })
+                .remainingAccounts(meteoraIx.keys)
+                .instruction();
+            return ix;
+        });
+    }
+    unstakeFromFarm(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ amount, userWallet, farm, strategy, quarry, miner, minerVault, saberFarmRewarder, userPdaLpToken, }) {
+            const user = (0, functions_1.generateUserPda)(userWallet, farm);
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .unstakeFromFarm(amount)
+                .accounts({
+                farm,
+                user,
+                strategy,
+                authority: userWallet,
+                systemProgram: web3.SystemProgram.programId,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                clock: web3.SYSVAR_CLOCK_PUBKEY,
+                saberFarmProgram: addresses_1.QUARRY_MINE_PROGRAM,
+                saberFarm: {
+                    quarry,
+                    miner,
+                    minerVault,
+                },
+                saberFarmRewarder,
+                userPdaLpToken,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    saberUnsupplyLiquidity(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ assetIndex, userWallet, farm, userPda, saberSwap, saberAuthority, lpMint, inputLp, quoteReserves, outputUserToken, outputReserve, outputFees, ownerFee, }) {
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .saberUnsupplyLiquidity(assetIndex)
+                .accounts({
+                saberSwapProgram: addresses_1.SABER_SWAP_PROGRAM,
+                user: {
+                    tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                    swapAuthority: saberAuthority,
+                    userAuthority: userPda,
+                    userWallet,
+                    farm,
+                    swap: saberSwap,
+                },
+                poolMint: lpMint,
+                inputLp,
+                quoteReserves,
+                output: {
+                    userToken: {
+                        user: outputUserToken,
+                        reserve: outputReserve,
+                    },
+                    fees: outputFees,
+                    ownerFee,
+                },
+            })
+                .instruction();
+            return ix;
+        });
+    }
+    harvestFromFarm(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userWallet, farm, strategy, quarry, miner, minerVault, saberFarmRewarder, userPdaLp, userPdaReward, redemptionToken, redemptionVault, redeemer, minterInfo, mintWrapper, minter, claimFeeTokenAccount, ownerFee, }) {
+            const user = (0, functions_1.generateUserPda)(userWallet, farm);
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .harvestFromFarm()
+                .accounts({
+                farm,
+                user,
+                strategy,
+                authority: userWallet,
+                systemProgram: web3.SystemProgram.programId,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                saberFarmProgram: addresses_1.QUARRY_MINE_PROGRAM,
+                redeemerProgram: addresses_1.REDEEMER_PROGRAM,
+                mintProxyProgram: addresses_1.MINT_PROXY_PROGRAM,
+                saberFarm: {
+                    quarry,
+                    miner,
+                    minerVault,
+                },
+                saberFarmRewarder,
+                userPdaLp,
+                userPdaReward,
+                redemptionMint: addresses_1.SABER_MINT,
+                redemptionToken,
+                redemptionVault,
+                redeemer,
+                mintProxyState: addresses_1.SABER_MINT_PROXY_STATE,
+                proxyMintAuthority: addresses_1.PROXY_MINT_AUTHORITY,
+                minterInfo,
+                mintWrapper,
+                mintWrapperProgram: addresses_1.MINT_WRAPPER_PROGRAM,
+                minter,
+                rewardsTokenMint: addresses_1.SABER_IOU_MINT,
+                claimFeeTokenAccount,
+                ownerFee,
+            })
+                .instruction();
+            return ix;
+        });
+    }
+}
+exports.IyfMainIxGenerator = IyfMainIxGenerator;