@kamino-finance/klend-sdk 2.10.6

package/dist/classes/action.js

@@ -0,0 +1,1505 @@
+"use strict";
+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.KaminoAction = exports.DEPOSITS_LIMIT = exports.BORROWS_LIMIT = exports.POSITION_LIMIT = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const instructions_1 = require("../idl_codegen/instructions");
+const utils_1 = require("../utils");
+const obligation_1 = require("./obligation");
+const types_1 = require("../idl_codegen/types");
+const farms_sdk_1 = require("@hubbleprotocol/farms-sdk");
+const ObligationType_1 = require("../utils/ObligationType");
+const lib_1 = require("../lib");
+exports.POSITION_LIMIT = 10;
+exports.BORROWS_LIMIT = 5;
+exports.DEPOSITS_LIMIT = 8;
+const SOL_PADDING_FOR_INTEREST = new bn_js_1.default('1000000');
+class KaminoAction {
+    constructor(kaminoMarket, owner, obligation, userTokenAccountAddress, userCollateralAccountAddress, mint, positions, amount, depositReserves, borrowReserves, reserveState, currentSlot, hostAta, secondaryMint, additionalTokenAccountAddress, outflowReserveState, outflowAmount, referrer, payer) {
+        this.obligation = null;
+        /**
+         * Null unless the obligation is not passed
+         */
+        this.obligationType = null;
+        if (obligation instanceof obligation_1.KaminoObligation) {
+            this.obligation = obligation;
+        }
+        else if (obligation !== null) {
+            this.obligationType = obligation;
+        }
+        this.kaminoMarket = kaminoMarket;
+        this.owner = owner;
+        this.payer = payer !== null && payer !== void 0 ? payer : owner;
+        this.amount = new bn_js_1.default(amount);
+        this.mint = mint;
+        this.positions = positions;
+        this.hostAta = hostAta;
+        this.userTokenAccountAddress = userTokenAccountAddress;
+        this.userCollateralAccountAddress = userCollateralAccountAddress;
+        this.setupIxs = [];
+        this.setupIxsLabels = [];
+        this.inBetweenIxs = [];
+        this.inBetweenIxsLabels = [];
+        this.lendingIxs = [];
+        this.lendingIxsLabels = [];
+        this.cleanupIxs = [];
+        this.cleanupIxsLabels = [];
+        this.preTxnIxs = [];
+        this.preTxnIxsLabels = [];
+        this.postTxnIxs = [];
+        this.postTxnIxsLabels = [];
+        this.refreshFarmsCleanupTxnIxs = [];
+        this.refreshFarmsCleanupTxnIxsLabels = [];
+        this.depositReserves = depositReserves;
+        this.borrowReserves = borrowReserves;
+        this.additionalTokenAccountAddress = additionalTokenAccountAddress;
+        this.secondaryMint = secondaryMint;
+        this.reserve = reserveState;
+        this.outflowReserve = outflowReserveState;
+        this.outflowAmount = outflowAmount ? new bn_js_1.default(outflowAmount) : undefined;
+        this.preLoadedDepositReservesSameTx = [];
+        this.preLoadedBorrowReservesSameTx = [];
+        this.referrer = referrer ? referrer : web3_js_1.PublicKey.default;
+        this.currentSlot = currentSlot;
+    }
+    static initialize(action, amount, mint, owner, kaminoMarket, obligation, referrer = web3_js_1.PublicKey.default, currentSlot = 0, hostAta, payer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reserve = kaminoMarket.getReserveByMint(mint);
+            if (reserve === undefined) {
+                throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress().toBase58()}`);
+            }
+            const { userTokenAccountAddress, userCollateralAccountAddress } = yield KaminoAction.getUserAccountAddresses(payer !== null && payer !== void 0 ? payer : owner, reserve.state);
+            const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } = yield KaminoAction.loadObligation(action, kaminoMarket, owner, reserve.address, obligation);
+            const [_, userMetadata] = yield kaminoMarket.getUserMetadata(owner);
+            if (userMetadata) {
+                referrer = userMetadata.referrer;
+            }
+            const referrerKey = kaminoObligation ? kaminoObligation.state.referrer : referrer;
+            return new KaminoAction(kaminoMarket, owner, kaminoObligation || obligation, userTokenAccountAddress, userCollateralAccountAddress, mint, distinctReserveCount, amount, depositReserves, borrowReserves, reserve, currentSlot, hostAta, undefined, undefined, undefined, undefined, referrerKey, payer);
+        });
+    }
+    static getUserAccountAddresses(owner, reserve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userTokenAccountAddress = yield spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, reserve.liquidity.mintPubkey, owner, true);
+            const userCollateralAccountAddress = yield spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, reserve.collateral.mintPubkey, owner, true);
+            return { userTokenAccountAddress, userCollateralAccountAddress };
+        });
+    }
+    static loadObligation(action, kaminoMarket, owner, reserve, obligation, outflowReserve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let kaminoObligation;
+            const depositReserves = [];
+            const borrowReserves = [];
+            if (obligation instanceof obligation_1.KaminoObligation) {
+                kaminoObligation = obligation;
+            }
+            else {
+                const obligationAddress = obligation.toPda(kaminoMarket.getAddress(), owner);
+                kaminoObligation = yield obligation_1.KaminoObligation.load(kaminoMarket, obligationAddress);
+            }
+            if (kaminoObligation !== null) {
+                depositReserves.push(...[...kaminoObligation.deposits.keys()]);
+                borrowReserves.push(...[...kaminoObligation.borrows.keys()]);
+            }
+            if (!outflowReserve && action === 'depositAndBorrow') {
+                throw new Error(`Outflow reserve has not been set for depositAndBorrow`);
+            }
+            // Union of addresses
+            const distinctReserveCount = [
+                ...new Set([
+                    ...borrowReserves.map((e) => e.toBase58()),
+                    ...(action === 'borrow' ? [reserve.toBase58()] : []),
+                    ...(action === 'depositAndBorrow' ? [reserve.toBase58()] : []),
+                ]),
+            ].length +
+                [
+                    ...new Set([
+                        ...depositReserves.map((e) => e.toBase58()),
+                        ...(action === 'deposit' ? [reserve.toBase58()] : []),
+                        ...(action === 'depositAndBorrow' ? [outflowReserve.toBase58()] : []),
+                    ]),
+                ].length;
+            if (distinctReserveCount > exports.POSITION_LIMIT) {
+                throw Error(`Obligation already has max number of positions: ${exports.POSITION_LIMIT}`);
+            }
+            return {
+                kaminoObligation,
+                depositReserves,
+                borrowReserves,
+                distinctReserveCount,
+            };
+        });
+    }
+    static buildRefreshObligationTxns(kaminoMarket, payer, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //  placeholder for action initialization
+            const firstReserve = obligation.state.deposits[0].depositReserve;
+            const firstKaminoReserve = kaminoMarket.getReserveByAddress(firstReserve);
+            if (!firstKaminoReserve) {
+                throw new Error(`Reserve ${firstReserve.toBase58()} not found`);
+            }
+            const axn = yield KaminoAction.initialize('refreshObligation', '0', firstKaminoReserve === null || firstKaminoReserve === void 0 ? void 0 : firstKaminoReserve.getLiquidityMint(), obligation.state.owner, kaminoMarket, obligation, kaminoMarket.programId, currentSlot);
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            axn.addRefreshObligation(payer);
+            return axn;
+        });
+    }
+    static buildDepositTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('deposit', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('deposit', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            axn.addDepositIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildBorrowTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0, hostAta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('borrow', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot, hostAta);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('borrow', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            axn.addBorrowIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildDepositReserveLiquidityTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('mint', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('mint', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            axn.addDepositReserveLiquidityIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildRedeemReserveCollateralTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata,
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('redeem', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('redeem', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            axn.addRedeemReserveCollateralIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildDepositObligationCollateralTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('depositCollateral', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('depositCollateral', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            axn.addDepositObligationCollateralIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildDepositAndBorrowTxns(kaminoMarket, depositAmount, depositMint, borrowAmount, borrowMint, payer, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata,
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initializeMultiTokenAction(kaminoMarket, 'depositAndBorrow', depositAmount, depositMint, borrowMint, payer, payer, obligation, borrowAmount, referrer, currentSlot);
+            const addInitObligationForFarmForDeposit = true;
+            const addInitObligationForFarmForBorrow = false;
+            const twoTokenAction = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('deposit', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarmForDeposit, twoTokenAction);
+            yield axn.addDepositAndBorrowIx();
+            yield axn.addInBetweenIxs('depositAndBorrow', includeAtaIxns, requestElevationGroup, addInitObligationForFarmForBorrow);
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildRepayAndWithdrawTxns(kaminoMarket, repayAmount, repayMint, withdrawAmount, withdrawMint, payer, currentSlot, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata,
+    isClosingPosition = false, referrer = web3_js_1.PublicKey.default) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initializeMultiTokenAction(kaminoMarket, 'repayAndWithdraw', repayAmount, repayMint, withdrawMint, payer, payer, obligation, withdrawAmount, referrer, currentSlot);
+            const addInitObligationForFarmForRepay = true;
+            const addInitObligationForFarmForWithdraw = false;
+            const twoTokenAction = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('repay', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarmForRepay, twoTokenAction);
+            yield axn.addRepayAndWithdrawIxs();
+            yield axn.addInBetweenIxs('repayAndWithdraw', includeAtaIxns, requestElevationGroup, addInitObligationForFarmForWithdraw, isClosingPosition);
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildWithdrawTxns(kaminoMarket, amount, mint, owner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('withdraw', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('withdraw', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            yield axn.addWithdrawIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    /**
+     *
+     * @param kaminoMarket
+     * @param amount
+     * @param mint
+     * @param owner
+     * @param obligation - obligation to repay or the PDA seeds
+     * @param currentSlot
+     * @param payer - if not set then owner is used
+     * @param extraComputeBudget - if > 0 then adds the ixn
+     * @param includeAtaIxns - if true it includes create and close wsol and token atas
+     * @param requestElevationGroup
+     * @param includeUserMetadata - if true it includes user metadata
+     * @param referrer
+     */
+    static buildRepayTxns(kaminoMarket, amount, mint, owner, obligation, currentSlot, payer = undefined, extraComputeBudget = 1000000, includeAtaIxns = true, requestElevationGroup = false, includeUserMetadata = true, referrer = web3_js_1.PublicKey.default) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initialize('repay', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot, undefined, payer);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('repay', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            yield axn.addRepayIx();
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildLiquidateTxns(kaminoMarket, amount, minCollateralReceiveAmount, repayTokenMint, withdrawTokenMint, liquidator, obligationOwner, obligation, extraComputeBudget = 1000000, // if > 0 then adds the ixn
+    includeAtaIxns = true, // if true it includes create and close wsol and token atas, and creates all other token atas if they don't exist
+    requestElevationGroup = false, includeUserMetadata = true, // if true it includes user metadata
+    referrer = web3_js_1.PublicKey.default, maxAllowedLtvOverridePercent = 0, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const axn = yield KaminoAction.initializeMultiTokenAction(kaminoMarket, 'liquidate', amount, repayTokenMint, withdrawTokenMint, liquidator, obligationOwner, obligation, minCollateralReceiveAmount, referrer, currentSlot);
+            const addInitObligationForFarm = true;
+            if (extraComputeBudget > 0) {
+                axn.addComputeBudgetIxn(extraComputeBudget);
+            }
+            yield axn.addSupportIxs('liquidate', includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm);
+            yield axn.addLiquidateIx(maxAllowedLtvOverridePercent);
+            axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
+            return axn;
+        });
+    }
+    static buildWithdrawReferrerFeeTxns(owner, tokenMint, kaminoMarket, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { axn, createAtasIxns } = yield KaminoAction.initializeWithdrawReferrerFees(tokenMint, owner, kaminoMarket, currentSlot);
+            axn.preTxnIxs.push(...createAtasIxns);
+            axn.preTxnIxsLabels.push(`createAtasIxs[${axn.userTokenAccountAddress.toString()}]`);
+            axn.addRefreshReserveIxs([axn.reserve.address]);
+            axn.addWithdrawReferrerFeesIxs();
+            return axn;
+        });
+    }
+    getTransactions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txns = {
+                preLendingTxn: null,
+                lendingTxn: null,
+                postLendingTxn: null,
+            };
+            if (this.preTxnIxs.length) {
+                txns.preLendingTxn = new web3_js_1.Transaction({
+                    feePayer: this.owner,
+                    recentBlockhash: (yield this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
+                }).add(...this.preTxnIxs);
+            }
+            if (this.lendingIxs.length === 2) {
+                txns.lendingTxn = new web3_js_1.Transaction({
+                    feePayer: this.owner,
+                    recentBlockhash: (yield this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
+                }).add(...this.setupIxs, ...[this.lendingIxs[0]], ...this.inBetweenIxs, ...[this.lendingIxs[1]], ...this.cleanupIxs);
+            }
+            else {
+                txns.lendingTxn = new web3_js_1.Transaction({
+                    feePayer: this.owner,
+                    recentBlockhash: (yield this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
+                }).add(...this.setupIxs, ...this.lendingIxs, ...this.cleanupIxs);
+            }
+            if (this.postTxnIxs.length) {
+                txns.postLendingTxn = new web3_js_1.Transaction({
+                    feePayer: this.owner,
+                    recentBlockhash: (yield this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
+                }).add(...this.postTxnIxs);
+            }
+            return txns;
+        });
+    }
+    sendTransactions(sendTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txns = yield this.getTransactions();
+            yield this.sendSingleTransaction(txns.preLendingTxn, sendTransaction);
+            const signature = yield this.sendSingleTransaction(txns.lendingTxn, sendTransaction);
+            yield this.sendSingleTransaction(txns.postLendingTxn, sendTransaction);
+            return signature;
+        });
+    }
+    sendSingleTransaction(txn, sendTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!txn)
+                return '';
+            const signature = yield sendTransaction(txn, this.kaminoMarket.getConnection());
+            yield this.kaminoMarket.getConnection().confirmTransaction(signature);
+            return signature;
+        });
+    }
+    simulateTransactions(sendTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const txns = yield this.getTransactions();
+            yield this.simulateSingleTransaction(txns.preLendingTxn, sendTransaction);
+            const signature = yield this.simulateSingleTransaction(txns.lendingTxn, sendTransaction);
+            yield this.simulateSingleTransaction(txns.postLendingTxn, sendTransaction);
+            return signature;
+        });
+    }
+    simulateSingleTransaction(txn, sendTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!txn)
+                return '';
+            return yield sendTransaction(txn, this.kaminoMarket.getConnection());
+        });
+    }
+    addDepositIx() {
+        this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
+        this.lendingIxs.push((0, instructions_1.depositReserveLiquidityAndObligationCollateral)({
+            liquidityAmount: this.amount,
+        }, {
+            owner: this.owner,
+            obligation: this.getObligationPda(),
+            lendingMarket: this.kaminoMarket.getAddress(),
+            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            reserve: this.reserve.address,
+            reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+            reserveCollateralMint: this.reserve.getCTokenMint(),
+            reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault,
+            userSourceLiquidity: this.userTokenAccountAddress,
+            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        }, this.kaminoMarket.programId));
+    }
+    addDepositReserveLiquidityIx() {
+        this.lendingIxsLabels.push(`depositReserveLiquidity`);
+        this.lendingIxs.push((0, instructions_1.depositReserveLiquidity)({
+            liquidityAmount: this.amount,
+        }, {
+            owner: this.owner,
+            lendingMarket: this.kaminoMarket.getAddress(),
+            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            reserve: this.reserve.address,
+            reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+            reserveCollateralMint: this.reserve.getCTokenMint(),
+            userSourceLiquidity: this.userTokenAccountAddress,
+            userDestinationCollateral: this.userCollateralAccountAddress,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        }, this.kaminoMarket.programId));
+    }
+    addRedeemReserveCollateralIx() {
+        this.lendingIxsLabels.push(`redeemReserveCollateral`);
+        this.lendingIxs.push((0, instructions_1.redeemReserveCollateral)({
+            collateralAmount: this.amount,
+        }, {
+            owner: this.owner,
+            lendingMarket: this.kaminoMarket.getAddress(),
+            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            reserve: this.reserve.address,
+            reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+            reserveCollateralMint: this.reserve.getCTokenMint(),
+            userSourceCollateral: this.userCollateralAccountAddress,
+            userDestinationLiquidity: this.userTokenAccountAddress,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        }, this.kaminoMarket.programId));
+    }
+    addDepositObligationCollateralIx() {
+        this.lendingIxsLabels.push(`depositObligationCollateral`);
+        this.lendingIxs.push((0, instructions_1.depositObligationCollateral)({
+            collateralAmount: this.amount,
+        }, {
+            owner: this.owner,
+            obligation: this.getObligationPda(),
+            lendingMarket: this.kaminoMarket.getAddress(),
+            depositReserve: this.reserve.address,
+            reserveDestinationCollateral: this.reserve.state.collateral.supplyVault,
+            userSourceCollateral: this.userCollateralAccountAddress,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        }, this.kaminoMarket.programId));
+    }
+    addBorrowIx() {
+        this.lendingIxsLabels.push(`borrowObligationLiquidity`);
+        this.lendingIxs.push((0, instructions_1.borrowObligationLiquidity)({
+            liquidityAmount: this.amount,
+        }, {
+            owner: this.owner,
+            obligation: this.getObligationPda(),
+            lendingMarket: this.kaminoMarket.getAddress(),
+            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            borrowReserve: this.reserve.address,
+            reserveSourceLiquidity: this.reserve.state.liquidity.supplyVault,
+            userDestinationLiquidity: this.userTokenAccountAddress,
+            borrowReserveLiquidityFeeReceiver: this.reserve.state.liquidity.feeVault,
+            referrerTokenState: (0, utils_1.referrerTokenStatePda)(this.referrer, this.reserve.address, this.kaminoMarket.programId)[0],
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        }, this.kaminoMarket.programId));
+    }
+    addDepositAndBorrowIx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
+            this.lendingIxsLabels.push(`borrowObligationLiquidity`);
+            this.lendingIxs.push((0, instructions_1.depositReserveLiquidityAndObligationCollateral)({
+                liquidityAmount: this.amount,
+            }, {
+                owner: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                reserve: this.reserve.address,
+                reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+                reserveCollateralMint: this.reserve.getCTokenMint(),
+                reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault,
+                userSourceLiquidity: this.userTokenAccountAddress,
+                placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+            if (!this.outflowReserve) {
+                throw new Error(`outflowReserve not set`);
+            }
+            if (!this.additionalTokenAccountAddress) {
+                throw new Error(`additionalTokenAccountAddress not set`);
+            }
+            if (!this.outflowAmount) {
+                throw new Error(`outflowAmount not set`);
+            }
+            this.lendingIxs.push((0, instructions_1.borrowObligationLiquidity)({
+                liquidityAmount: this.outflowAmount,
+            }, {
+                owner: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                borrowReserve: this.outflowReserve.address,
+                reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
+                userDestinationLiquidity: this.additionalTokenAccountAddress,
+                borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
+                referrerTokenState: (0, utils_1.referrerTokenStatePda)(this.referrer, this.outflowReserve.address, this.kaminoMarket.programId)[0],
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+        });
+    }
+    addRepayAndWithdrawIxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lendingIxsLabels.push(`repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`);
+            this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateral`);
+            this.lendingIxs.push((0, instructions_1.repayObligationLiquidity)({
+                liquidityAmount: this.amount,
+            }, {
+                owner: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                repayReserve: this.reserve.address,
+                userSourceLiquidity: this.userTokenAccountAddress,
+                reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+            if (!this.outflowReserve) {
+                throw new Error(`outflowReserve not set`);
+            }
+            if (!this.additionalTokenAccountAddress) {
+                throw new Error(`additionalTokenAccountAddress not set`);
+            }
+            if (!this.outflowAmount) {
+                throw new Error(`outflowAmount not set`);
+            }
+            const collateralExchangeRate = this.outflowReserve.getEstimatedCollateralExchangeRate(this.currentSlot, this.kaminoMarket.state.referralFeeBps);
+            this.lendingIxs.push((0, instructions_1.withdrawObligationCollateralAndRedeemReserveCollateral)({
+                collateralAmount: this.outflowAmount.eq(new bn_js_1.default(utils_1.U64_MAX))
+                    ? this.outflowAmount
+                    : new bn_js_1.default(new decimal_js_1.default(this.outflowAmount.toString()).mul(collateralExchangeRate).ceil().toString()),
+            }, {
+                owner: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                withdrawReserve: this.outflowReserve.address,
+                reserveCollateralMint: this.outflowReserve.getCTokenMint(),
+                reserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
+                reserveSourceCollateral: this.outflowReserve.state.collateral.supplyVault,
+                userDestinationLiquidity: this.additionalTokenAccountAddress,
+                placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+        });
+    }
+    addWithdrawIx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralExchangeRate = this.reserve.getEstimatedCollateralExchangeRate(this.currentSlot, this.kaminoMarket.state.referralFeeBps);
+            const collateralAmount = this.amount.eq(new bn_js_1.default(utils_1.U64_MAX))
+                ? this.amount
+                : new bn_js_1.default(new decimal_js_1.default(this.amount.toString()).mul(collateralExchangeRate).ceil().toString());
+            this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateral`);
+            this.lendingIxs.push((0, instructions_1.withdrawObligationCollateralAndRedeemReserveCollateral)({
+                collateralAmount,
+            }, {
+                owner: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                withdrawReserve: this.reserve.address,
+                reserveCollateralMint: this.reserve.getCTokenMint(),
+                reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+                reserveSourceCollateral: this.reserve.state.collateral.supplyVault,
+                userDestinationLiquidity: this.userTokenAccountAddress,
+                placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+        });
+    }
+    addRepayIx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lendingIxsLabels.push(`repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`);
+            this.lendingIxs.push((0, instructions_1.repayObligationLiquidity)({
+                liquidityAmount: this.amount,
+            }, {
+                owner: this.payer,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                repayReserve: this.reserve.address,
+                userSourceLiquidity: this.userTokenAccountAddress,
+                reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+        });
+    }
+    addLiquidateIx(maxAllowedLtvOverridePercent = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateral`);
+            if (!this.outflowReserve) {
+                throw Error(`Withdraw reserve during liquidation is not defined`);
+            }
+            if (!this.additionalTokenAccountAddress) {
+                throw Error(`Liquidating token account address is not defined`);
+            }
+            this.lendingIxs.push((0, instructions_1.liquidateObligationAndRedeemReserveCollateral)({
+                liquidityAmount: this.amount,
+                // TODO: Configure this when updating liquidator with new interface
+                minAcceptableReceivedCollateralAmount: this.outflowAmount || new bn_js_1.default(0),
+                // TODO: remove this before going live
+                maxAllowedLtvOverridePercent: new bn_js_1.default(maxAllowedLtvOverridePercent),
+            }, {
+                liquidator: this.owner,
+                obligation: this.getObligationPda(),
+                lendingMarket: this.kaminoMarket.getAddress(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                repayReserve: this.reserve.address,
+                repayReserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
+                withdrawReserve: this.outflowReserve.address,
+                withdrawReserveCollateralMint: this.outflowReserve.getCTokenMint(),
+                withdrawReserveCollateralSupply: this.outflowReserve.state.collateral.supplyVault,
+                withdrawReserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
+                userSourceLiquidity: this.additionalTokenAccountAddress,
+                userDestinationCollateral: this.userCollateralAccountAddress,
+                userDestinationLiquidity: this.userTokenAccountAddress,
+                withdrawReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            }, this.kaminoMarket.programId));
+        });
+    }
+    addInBetweenIxs(action, includeAtaIxns, requestElevationGroup, addInitObligationForFarm, isClosingPosition = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addSupportIxsWithoutInitObligation(action, includeAtaIxns, false, requestElevationGroup, addInitObligationForFarm, isClosingPosition);
+        });
+    }
+    addRefreshObligation(crank) {
+        const uniqueReserveAddresses = new utils_1.PublicKeySet(this.depositReserves.concat(this.borrowReserves)).toArray();
+        const addAllToSetupIxns = true;
+        // Union of addresses
+        const allReservesExcludingCurrent = [...uniqueReserveAddresses];
+        this.addRefreshReserveIxs(allReservesExcludingCurrent, addAllToSetupIxns);
+        this.addRefreshFarmsForReserve(this.depositReserves.map((r) => this.kaminoMarket.getReserveByAddress(r)), addAllToSetupIxns, types_1.ReserveFarmKind.Collateral, crank);
+        this.addRefreshFarmsForReserve(this.borrowReserves.map((r) => this.kaminoMarket.getReserveByAddress(r)), addAllToSetupIxns, types_1.ReserveFarmKind.Debt, crank);
+        this.addRefreshObligationIx(addAllToSetupIxns, false);
+    }
+    addSupportIxsWithoutInitObligation(action, includeAtaIxns, addToSetupIxs = true, requestElevationGroup = false, addInitObligationForFarm = false, isClosingPosition = false, twoTokenAction = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: why are we not doing this first?
+            if (includeAtaIxns) {
+                yield this.addAtaIxs(action);
+            }
+            if ([
+                'depositCollateral',
+                'deposit',
+                'withdraw',
+                'borrow',
+                'liquidate',
+                'repay',
+                'depositAndBorrow',
+                'repayAndWithdraw',
+                'refreshObligation',
+            ].includes(action)) {
+                // The support ixns in order are:
+                // 0. Init obligation ixn
+                // 0. Token Ata ixns
+                // 0. Init obligation for farm
+                // 1. Ixns to refresh the reserves of the obligation not related to the current action
+                // 2. Ixn to refresh the reserve of the current action
+                // 3. Ixn to refresh the obligation
+                // 4. Ixn to refresh the `debt` farm of the obligation
+                // 5. Ixn to refresh the `collateral` farm of the obligation
+                // 6. The instruction itself
+                // 7. Ixn to refresh the `debt` farm of the obligation
+                // 8. Ixn to refresh the `collateral` farm of the obligation
+                let currentReserves = [];
+                if (action === 'liquidate' || action === 'depositAndBorrow' || action === 'repayAndWithdraw') {
+                    if (!this.outflowReserve) {
+                        throw new Error('outflowReserve is undefined');
+                    }
+                    if (action === 'depositAndBorrow' || action === 'repayAndWithdraw') {
+                        currentReserves = [this.reserve, this.outflowReserve];
+                        if (this.obligation) {
+                            if (action === 'depositAndBorrow') {
+                                const deposit = this.obligation.state.deposits.find((deposit) => deposit.depositReserve.equals(this.reserve.address));
+                                if (!deposit) {
+                                    this.preLoadedDepositReservesSameTx.push(this.reserve.address);
+                                }
+                            }
+                            else {
+                                const borrow = this.obligation.state.borrows.find((borrow) => borrow.borrowReserve.equals(this.reserve.address));
+                                if (!borrow) {
+                                    throw Error(`Unable to find obligation borrow to repay for ${this.obligation.state.owner.toBase58()}`);
+                                }
+                                const cumulativeBorrowRateObligation = obligation_1.KaminoObligation.getCumulativeBorrowRate(borrow);
+                                const cumulativeBorrowRateReserve = this.reserve.getEstimatedCumulativeBorrowRate(this.currentSlot);
+                                const fullRepay = obligation_1.KaminoObligation.getBorrowAmount(borrow)
+                                    .mul(cumulativeBorrowRateReserve)
+                                    .div(cumulativeBorrowRateObligation);
+                                const amountDecimal = new decimal_js_1.default(this.amount.toString());
+                                if (fullRepay.lte(amountDecimal)) {
+                                    this.preLoadedBorrowReservesSameTx.push(this.reserve.address);
+                                }
+                            }
+                        }
+                        else {
+                            // Obligation doesn't exist yet, so we have to preload the deposit reserve
+                            this.preLoadedDepositReservesSameTx.push(this.reserve.address);
+                        }
+                    }
+                    else if (action === 'liquidate' && !this.outflowReserve.address.equals(this.reserve.address)) {
+                        currentReserves = [this.outflowReserve, this.reserve];
+                    }
+                    else {
+                        currentReserves = [this.reserve];
+                    }
+                }
+                else {
+                    currentReserves = [this.reserve];
+                }
+                const uniqueReserveAddresses = new utils_1.PublicKeySet(this.depositReserves.concat(this.borrowReserves));
+                const currentReserveAddresses = new utils_1.PublicKeySet(currentReserves.map((reserve) => reserve.address));
+                // Union of addresses
+                const allReservesExcludingCurrent = [...uniqueReserveAddresses.toArray()].filter((address) => !currentReserveAddresses.contains(address));
+                this.addRefreshReserveIxs(allReservesExcludingCurrent, addToSetupIxs);
+                if (addInitObligationForFarm) {
+                    if (action === 'liquidate') {
+                        yield this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Debt, addToSetupIxs);
+                        yield this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Collateral, addToSetupIxs);
+                    }
+                    else if (action === 'depositAndBorrow' ||
+                        action === 'depositCollateral' ||
+                        action === 'withdraw' ||
+                        action === 'deposit') {
+                        yield this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Collateral, addToSetupIxs);
+                        if (this.outflowReserve) {
+                            yield this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Debt, addToSetupIxs);
+                        }
+                    }
+                    else if (action === 'repayAndWithdraw' || action === 'borrow' || action === 'repay') {
+                        // todo - probably don't need to add both debt and collateral for everything here
+                        yield this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Debt, addToSetupIxs);
+                        if (this.outflowReserve) {
+                            yield this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Collateral, addToSetupIxs);
+                        }
+                    }
+                    else {
+                        yield this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Collateral, addToSetupIxs);
+                        yield this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Debt, addToSetupIxs);
+                        if (this.outflowReserve) {
+                            yield this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Collateral, addToSetupIxs);
+                            yield this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Debt, addToSetupIxs);
+                        }
+                    }
+                }
+                this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addToSetupIxs);
+                if (action === 'repayAndWithdraw' && !addToSetupIxs && isClosingPosition) {
+                    // addToSetupIxs === addInBetween (same thing)
+                    // If this is a repay and withdraw, and it's not the first action, and it's closing a position
+                    // we don't need to include the repay reserve in the refresh obligation
+                    // I am ashamed of this code, we need to rewrite this entire thing
+                    this.addRefreshObligationIx(addToSetupIxs, true);
+                }
+                else {
+                    this.addRefreshObligationIx(addToSetupIxs, false);
+                }
+                if (addToSetupIxs) {
+                    // If this is an setup ixn (therefore not an in-between), it means it's either a one off action
+                    // or the first of a two-token-action
+                    if (action === 'liquidate') {
+                        this.addRefreshFarmsForReserve([this.outflowReserve], addToSetupIxs, types_1.ReserveFarmKind.Collateral);
+                        this.addRefreshFarmsForReserve([this.reserve], addToSetupIxs, types_1.ReserveFarmKind.Debt);
+                    }
+                    else if (action === 'depositAndBorrow' ||
+                        action === 'depositCollateral' ||
+                        action === 'withdraw' ||
+                        action === 'deposit') {
+                        this.addRefreshFarmsForReserve(currentReserves, addToSetupIxs, types_1.ReserveFarmKind.Collateral, undefined, twoTokenAction);
+                    }
+                    else if (action === 'repayAndWithdraw' || action === 'borrow' || action === 'repay') {
+                        this.addRefreshFarmsForReserve(currentReserves, addToSetupIxs, types_1.ReserveFarmKind.Debt, undefined, twoTokenAction);
+                    }
+                    else {
+                        throw new Error(`Could not decide on refresh farm for action ${action}`);
+                    }
+                }
+                else {
+                    // If this is an inbetween, it means it's part of a two-token-action
+                    // so we skip the refresh farm obligation of the first reserve as that operation already happened
+                    // add added to 'setup' ixns
+                    if (action === 'depositAndBorrow') {
+                        this.addRefreshFarmsForReserve([this.outflowReserve], addToSetupIxs, types_1.ReserveFarmKind.Debt);
+                    }
+                    else if (action === 'repayAndWithdraw') {
+                        this.addRefreshFarmsForReserve([this.outflowReserve], addToSetupIxs, types_1.ReserveFarmKind.Collateral);
+                    }
+                    else {
+                        throw new Error(`Could not decide on refresh farm for action ${action}`);
+                    }
+                }
+                if (action === 'depositAndBorrow' && requestElevationGroup) {
+                    const groupsColl = this.reserve.state.config.elevationGroups;
+                    const groupsDebt = this.outflowReserve.state.config.elevationGroups;
+                    const groups = this.kaminoMarket.state.elevationGroups;
+                    const commonElevationGroups = [...groupsColl].filter((item) => groupsDebt.includes(item) && item !== 0);
+                    console.log('Groups of coll reserve', groupsColl, 'Groups of debt reserve', groupsDebt, 'Common groups', commonElevationGroups);
+                    if (commonElevationGroups.length === 0) {
+                        console.log('No common elevation groups found, staying with default');
+                    }
+                    else {
+                        const eModeGroupWithMaxLtv = commonElevationGroups.reduce((prev, curr) => {
+                            const prevGroup = groups.find((group) => group.id === prev);
+                            const currGroup = groups.find((group) => group.id === curr);
+                            return prevGroup.ltvPct > currGroup.ltvPct ? prev : curr;
+                        });
+                        const eModeGroup = groups.find((group) => group.id === eModeGroupWithMaxLtv).id;
+                        console.log('Setting eModeGroup to', eModeGroup);
+                        if (eModeGroup !== 0 && eModeGroup !== ((_a = this.obligation) === null || _a === void 0 ? void 0 : _a.state.elevationGroup)) {
+                            this.addRequestElevationIx(eModeGroup, false);
+                            this.addRefreshReserveIxs(allReservesExcludingCurrent, addToSetupIxs);
+                            this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addToSetupIxs);
+                            this.addRefreshObligationIx(addToSetupIxs);
+                        }
+                    }
+                }
+            }
+        });
+    }
+    addSupportIxs(action, includeAtaIxns, requestElevationGroup, includeUserMetadata, addInitObligationForFarm, twoTokenAction = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!['mint', 'redeem'].includes(action)) {
+                const [, ownerUserMetadata] = yield this.kaminoMarket.getUserMetadata(this.owner);
+                if (!ownerUserMetadata && includeUserMetadata) {
+                    yield this.addInitUserMetadataIxs();
+                }
+                yield this.addInitReferrerTokenStateIxs();
+                yield this.addInitObligationIxs();
+            }
+            yield this.addSupportIxsWithoutInitObligation(action, includeAtaIxns, true, requestElevationGroup, addInitObligationForFarm, false, twoTokenAction);
+        });
+    }
+    static optionalAccount(pubkey, programId = lib_1.PROGRAM_ID) {
+        if ((0, utils_1.isNotNullPubkey)(pubkey)) {
+            return pubkey;
+        }
+        else {
+            return programId;
+        }
+    }
+    addRefreshReserveIxs(reserves, addToSetupIxs = true) {
+        reserves.forEach((reserveAddress) => {
+            const foundReserve = this.kaminoMarket.getReserveByAddress(reserveAddress);
+            if (!foundReserve) {
+                throw new Error(`Could not find reserve ${reserveAddress} in reserves`);
+            }
+            const { state } = foundReserve;
+            const refreshReserveIx = (0, instructions_1.refreshReserve)({
+                lendingMarket: this.kaminoMarket.getAddress(),
+                reserve: reserveAddress,
+                pythOracle: KaminoAction.optionalAccount(state.config.tokenInfo.pythConfiguration.price, this.kaminoMarket.programId),
+                switchboardPriceOracle: KaminoAction.optionalAccount(state.config.tokenInfo.switchboardConfiguration.priceAggregator, this.kaminoMarket.programId),
+                switchboardTwapOracle: KaminoAction.optionalAccount(state.config.tokenInfo.switchboardConfiguration.twapAggregator, this.kaminoMarket.programId),
+                scopePrices: KaminoAction.optionalAccount(state.config.tokenInfo.scopeConfiguration.priceFeed, this.kaminoMarket.programId),
+            }, this.kaminoMarket.programId);
+            if (addToSetupIxs) {
+                this.setupIxs.push(refreshReserveIx);
+                this.setupIxsLabels.push(`RefreshReserve[${reserveAddress}]`);
+            }
+            else {
+                this.inBetweenIxs.push(refreshReserveIx);
+                this.inBetweenIxsLabels.push(`RefreshReserve[${reserveAddress}]`);
+            }
+        });
+    }
+    static getRefreshAllReserves(kaminoMarket, reserves) {
+        return reserves.map((reserveAddress) => {
+            const foundReserve = kaminoMarket.getReserveByAddress(reserveAddress);
+            if (!foundReserve) {
+                throw new Error(`Could not find reserve ${reserveAddress} in reserves`);
+            }
+            const { state } = foundReserve;
+            return (0, instructions_1.refreshReserve)({
+                reserve: reserveAddress,
+                lendingMarket: state.lendingMarket,
+                pythOracle: this.optionalAccount(state.config.tokenInfo.pythConfiguration.price, kaminoMarket.programId),
+                switchboardPriceOracle: this.optionalAccount(state.config.tokenInfo.switchboardConfiguration.priceAggregator, kaminoMarket.programId),
+                switchboardTwapOracle: this.optionalAccount(state.config.tokenInfo.switchboardConfiguration.twapAggregator, kaminoMarket.programId),
+                scopePrices: this.optionalAccount(state.config.tokenInfo.scopeConfiguration.priceFeed, kaminoMarket.programId),
+            }, kaminoMarket.programId);
+        });
+    }
+    addRefreshObligationIx(addToSetupIxs = true, skipBorrowObligations = false) {
+        const marketAddress = this.kaminoMarket.getAddress();
+        const obligationPda = this.getObligationPda();
+        const refreshObligationIx = (0, instructions_1.refreshObligation)({
+            lendingMarket: marketAddress,
+            obligation: obligationPda,
+        }, this.kaminoMarket.programId);
+        const depositReservesList = this.depositReserves;
+        // check if there's any member in the preloadedDepositReserves that is not in the depositReserves
+        // if so, add it to the depositReserves
+        for (let i = 0; i < this.preLoadedDepositReservesSameTx.length; i++) {
+            const preloadedDepositReserve = this.preLoadedDepositReservesSameTx[i];
+            // Check if the depositReserves array contains the current preloadedDepositReserve
+            const found = this.depositReserves.some((depositReserve) => {
+                return depositReserve.equals(preloadedDepositReserve);
+            });
+            // If not found, push the current preloadedDepositReserve to the depositReserves array
+            if (!found) {
+                depositReservesList.push(this.preLoadedDepositReservesSameTx[i]);
+            }
+        }
+        const depositReserveAccountMetas = depositReservesList.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: true };
+        });
+        const preloadedBorrowReservesString = this.preLoadedBorrowReservesSameTx.map((reserve) => reserve.toString());
+        const borrowReservesList = this.borrowReserves.filter((reserve) => !preloadedBorrowReservesString.includes(reserve.toString()));
+        const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: true };
+        });
+        const borrowReservesReferrerTokenStates = borrowReservesList
+            .map((reserve) => {
+            if (this.referrer.equals(web3_js_1.PublicKey.default)) {
+                return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: true };
+            }
+            const referrerTokenStateAddress = (0, utils_1.referrerTokenStatePda)(this.referrer, reserve, this.kaminoMarket.programId)[0];
+            return { pubkey: referrerTokenStateAddress, isSigner: false, isWritable: true };
+        })
+            .filter((x) => !x.pubkey.equals(this.kaminoMarket.programId));
+        refreshObligationIx.keys = refreshObligationIx.keys.concat([
+            ...depositReserveAccountMetas,
+            ...(skipBorrowObligations ? [] : [...borrowReserveAccountMetas, ...borrowReservesReferrerTokenStates]),
+        ]);
+        if (addToSetupIxs) {
+            this.setupIxs.push(refreshObligationIx);
+            this.setupIxsLabels.push(`RefreshObligation[${obligationPda.toString()}]`);
+        }
+        else {
+            this.inBetweenIxs.push(refreshObligationIx);
+            this.inBetweenIxsLabels.push(`RefreshObligation[${obligationPda.toString()}]`);
+        }
+    }
+    addRequestElevationIx(elevationGroup, addToSetupIxs) {
+        const obligationPda = this.getObligationPda();
+        const args = {
+            elevationGroup,
+        };
+        const accounts = {
+            owner: this.owner,
+            obligation: obligationPda,
+            lendingMarket: this.kaminoMarket.getAddress(),
+        };
+        const requestElevationGroupIx = (0, instructions_1.requestElevationGroup)(args, accounts, this.kaminoMarket.programId);
+        const depositReservesList = this.depositReserves;
+        // check if there's any member in the preloadedDepositReserves that is not in the depositReserves
+        // if so, add it to the depositReserves
+        for (let i = 0; i < this.preLoadedDepositReservesSameTx.length; i++) {
+            const preloadedDepositReserveString = this.preLoadedDepositReservesSameTx[i].toString();
+            // Check if the depositReserves array contains the current preloadedDepositReserve
+            const found = this.depositReserves.some((depositReserve) => {
+                return depositReserve.toString() === preloadedDepositReserveString;
+            });
+            // If not found, push the current preloadedDepositReserve to the depositReserves array
+            if (!found) {
+                depositReservesList.push(this.preLoadedDepositReservesSameTx[i]);
+            }
+        }
+        const depositReserveAccountMetas = depositReservesList.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: true };
+        });
+        const preloadedBorrowReservesString = this.preLoadedBorrowReservesSameTx.map((reserve) => reserve.toString());
+        const borrowReservesList = this.borrowReserves.filter((reserve) => !preloadedBorrowReservesString.includes(reserve.toString()));
+        const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
+            return { pubkey: reserve, isSigner: false, isWritable: true };
+        });
+        const borrowReservesReferrerTokenStates = borrowReservesList
+            .map((reserve) => {
+            if (this.referrer.equals(web3_js_1.PublicKey.default)) {
+                return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: true };
+            }
+            const reserveState = this.kaminoMarket.getReserveByAddress(reserve);
+            const referrerTokenStateAddress = (0, utils_1.referrerTokenStatePda)(this.referrer, reserveState.address, this.kaminoMarket.programId)[0];
+            return { pubkey: referrerTokenStateAddress, isSigner: false, isWritable: true };
+        })
+            .filter((x) => !x.pubkey.equals(this.kaminoMarket.programId));
+        requestElevationGroupIx.keys = requestElevationGroupIx.keys.concat([
+            ...depositReserveAccountMetas,
+            ...borrowReserveAccountMetas,
+            ...borrowReservesReferrerTokenStates,
+        ]);
+        if (addToSetupIxs) {
+            this.setupIxs.push(requestElevationGroupIx);
+            this.setupIxsLabels.push(`RequestElevation[${obligationPda}], elevation_group:${elevationGroup}`);
+        }
+        else {
+            this.inBetweenIxs.push(requestElevationGroupIx);
+            this.inBetweenIxsLabels.push(`RequestElevation[${obligationPda}], elevation_group:${elevationGroup}`);
+        }
+    }
+    addRefreshFarmsForReserve(reserves, addToSetupIxs = true, mode, crank = this.payer, twoTokenAction = false) {
+        const BASE_SEED_USER_STATE = Buffer.from('user');
+        const getPda = (farm) => web3_js_1.PublicKey.findProgramAddressSync([BASE_SEED_USER_STATE, farm.toBytes(), this.getObligationPda().toBytes()], farms_sdk_1.farmsId)[0];
+        const farms = [];
+        for (const kaminoReserve of reserves) {
+            if (mode === types_1.ReserveFarmKind.Collateral && !kaminoReserve.state.farmCollateral.equals(web3_js_1.PublicKey.default)) {
+                farms.push([
+                    types_1.ReserveFarmKind.Collateral,
+                    kaminoReserve.state.farmCollateral,
+                    getPda(kaminoReserve.state.farmCollateral),
+                    kaminoReserve,
+                ]);
+            }
+            if (mode === types_1.ReserveFarmKind.Debt && !kaminoReserve.state.farmDebt.equals(web3_js_1.PublicKey.default)) {
+                farms.push([
+                    types_1.ReserveFarmKind.Debt,
+                    kaminoReserve.state.farmDebt,
+                    getPda(kaminoReserve.state.farmDebt),
+                    kaminoReserve,
+                ]);
+            }
+        }
+        farms.forEach((arg) => {
+            const args = { mode: arg[0].discriminator };
+            const accounts = {
+                crank,
+                obligation: this.getObligationPda(),
+                lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                reserve: arg[3].address,
+                reserveFarmState: arg[1],
+                obligationFarmUserState: arg[2],
+                lendingMarket: this.kaminoMarket.getAddress(),
+                farmsProgram: farms_sdk_1.farmsId,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            };
+            const refreshFarmForObligationix = (0, instructions_1.refreshObligationFarmsForReserve)(args, accounts, this.kaminoMarket.programId);
+            if (addToSetupIxs) {
+                this.setupIxs.push(refreshFarmForObligationix);
+                this.setupIxsLabels.push(`RefreshFarmForObligation[${arg[0].kind}, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`);
+                if (twoTokenAction) {
+                    // If two token action, this refresh needs to be the first inbetween ix
+                    this.inBetweenIxs.push(refreshFarmForObligationix);
+                    this.inBetweenIxsLabels.push(`RefreshFarmForObligation[${arg[0].kind}, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`);
+                }
+                else {
+                    this.refreshFarmsCleanupTxnIxs.push(refreshFarmForObligationix);
+                    this.refreshFarmsCleanupTxnIxsLabels.push(`RefreshFarmForObligation[${arg[0].kind}, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`);
+                }
+            }
+            else {
+                this.inBetweenIxs.push(refreshFarmForObligationix);
+                this.inBetweenIxsLabels.push(`RefreshFarmForObligation[${arg[0].kind}, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`);
+                this.refreshFarmsCleanupTxnIxs.push(refreshFarmForObligationix);
+                this.refreshFarmsCleanupTxnIxsLabels.push(`RefreshFarmForObligation[${arg[0].kind}, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`);
+            }
+        });
+    }
+    addRefreshFarmsCleanupTxnIxsToCleanupIxs() {
+        this.cleanupIxs.splice(this.cleanupIxs.length - 1, 0, ...this.refreshFarmsCleanupTxnIxs);
+        this.cleanupIxsLabels.splice(this.cleanupIxsLabels.length - 1, 0, ...this.refreshFarmsCleanupTxnIxsLabels);
+    }
+    addInitObligationForFarm(reserve, mode, addToSetupIxs = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const BASE_SEED_USER_STATE = Buffer.from('user');
+            const getPda = (farm) => web3_js_1.PublicKey.findProgramAddressSync([BASE_SEED_USER_STATE, farm.toBytes(), this.getObligationPda().toBytes()], farms_sdk_1.farmsId)[0];
+            const farms = [];
+            if (mode === types_1.ReserveFarmKind.Collateral && (0, utils_1.isNotNullPubkey)(reserve.state.farmCollateral)) {
+                const pda = getPda(reserve.state.farmCollateral);
+                const account = yield this.kaminoMarket.getConnection().getAccountInfo(pda);
+                if (!account) {
+                    farms.push([types_1.ReserveFarmKind.Collateral.discriminator, reserve.state.farmCollateral, pda]);
+                }
+            }
+            if (mode === types_1.ReserveFarmKind.Debt && (0, utils_1.isNotNullPubkey)(reserve.state.farmDebt)) {
+                const pda = getPda(reserve.state.farmDebt);
+                const account = yield this.kaminoMarket.getConnection().getAccountInfo(pda);
+                if (!account) {
+                    farms.push([types_1.ReserveFarmKind.Debt.discriminator, reserve.state.farmDebt, getPda(reserve.state.farmDebt)]);
+                }
+            }
+            farms.forEach((arg) => {
+                const args = { mode: arg[0] };
+                const accounts = {
+                    owner: this.obligation ? this.obligation.state.owner : this.owner,
+                    payer: this.owner,
+                    obligation: this.getObligationPda(),
+                    lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+                    reserve: reserve.address,
+                    reserveFarmState: arg[1],
+                    obligationFarm: arg[2],
+                    lendingMarket: this.kaminoMarket.getAddress(),
+                    farmsProgram: farms_sdk_1.farmsId,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                };
+                const initObligationForFarm = (0, instructions_1.initObligationFarmsForReserve)(args, accounts, this.kaminoMarket.programId);
+                if (addToSetupIxs) {
+                    this.setupIxs.push(initObligationForFarm);
+                    this.setupIxsLabels.push(`InitObligationForFarm[${reserve.address.toString()}, ${this.getObligationPda().toString()}]`);
+                }
+                else {
+                    this.inBetweenIxs.push(initObligationForFarm);
+                    this.inBetweenIxsLabels.push(`InitObligationForFarm[${reserve.address.toString()}, ${this.getObligationPda().toString()}]`);
+                }
+            });
+        });
+    }
+    addInitObligationIxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.obligation) {
+                const obligationPda = this.getObligationPda();
+                const [userMetadataAddress, _bump] = (0, utils_1.userMetadataPda)(this.owner, this.kaminoMarket.programId);
+                const initObligationIx = (0, instructions_1.initObligation)({
+                    args: {
+                        tag: this.obligationType.toArgs().tag,
+                        id: this.obligationType.toArgs().id,
+                    },
+                }, {
+                    obligationOwner: this.owner,
+                    feePayer: this.payer,
+                    obligation: obligationPda,
+                    lendingMarket: this.kaminoMarket.getAddress(),
+                    seed1Account: this.obligationType.toArgs().seed1,
+                    seed2Account: this.obligationType.toArgs().seed2,
+                    ownerUserMetadata: userMetadataAddress,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                }, this.kaminoMarket.programId);
+                this.setupIxs.push(initObligationIx);
+                this.setupIxsLabels.push(`InitObligation[${obligationPda.toString()}]`);
+            }
+        });
+    }
+    addInitUserMetadataIxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [createLutIx, lookupTableAddress] = yield (0, utils_1.createLookupTableIx)(this.kaminoMarket.getConnection(), this.owner);
+            this.setupIxs.push(createLutIx);
+            this.setupIxsLabels.push(`createUserLutIx[${lookupTableAddress.toString()}]`);
+            const [userMetadataAddress, _bump] = (0, utils_1.userMetadataPda)(this.owner, this.kaminoMarket.programId);
+            const referrerUserMetadataAddress = this.referrer.equals(web3_js_1.PublicKey.default)
+                ? this.kaminoMarket.programId
+                : (0, utils_1.userMetadataPda)(this.referrer, this.kaminoMarket.programId)[0];
+            const initUserMetadataIx = (0, instructions_1.initUserMetadata)({
+                userLookupTable: lookupTableAddress,
+            }, {
+                owner: this.owner,
+                feePayer: this.payer,
+                userMetadata: userMetadataAddress,
+                referrerUserMetadata: referrerUserMetadataAddress,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }, this.kaminoMarket.programId);
+            this.setupIxs.push(initUserMetadataIx);
+            this.setupIxsLabels.push(`initUserMetadata[${userMetadataAddress.toString()}]`);
+        });
+    }
+    addInitReferrerTokenStateIxs(reservesArr = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.referrer.equals(web3_js_1.PublicKey.default)) {
+                return;
+            }
+            const reserves = reservesArr.length !== 0 ? reservesArr : [...new Set([this.reserve, this.outflowReserve])];
+            const tokenStatesToCreate = [];
+            for (const reserve of reserves) {
+                if (!reserve) {
+                    continue;
+                }
+                const referrerTokenStateAddress = (0, utils_1.referrerTokenStatePda)(this.referrer, reserve.address, this.kaminoMarket.programId)[0];
+                if (!(yield (0, utils_1.checkIfAccountExists)(this.kaminoMarket.getConnection(), referrerTokenStateAddress))) {
+                    tokenStatesToCreate.push([referrerTokenStateAddress, reserve === null || reserve === void 0 ? void 0 : reserve.address]);
+                }
+            }
+            tokenStatesToCreate.forEach(([referrerTokenStateAddress, reserveAddress]) => {
+                const initreferrerTokenStateIx = (0, instructions_1.initReferrerTokenState)({
+                    referrer: this.referrer,
+                }, {
+                    lendingMarket: this.kaminoMarket.getAddress(),
+                    payer: this.owner,
+                    reserve: reserveAddress,
+                    referrerTokenState: referrerTokenStateAddress,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                }, this.kaminoMarket.programId);
+                this.setupIxs.unshift(initreferrerTokenStateIx);
+                this.setupIxsLabels.unshift(`InitReferrerTokenState[${referrerTokenStateAddress.toString()} res=${reserveAddress}]`);
+            });
+        });
+    }
+    addWithdrawReferrerFeesIxs() {
+        const referrerTokenStateAddress = (0, utils_1.referrerTokenStatePda)(this.owner, this.reserve.address, this.kaminoMarket.programId)[0];
+        const withdrawReferrerFeesIx = (0, instructions_1.withdrawReferrerFees)({
+            referrer: this.owner,
+            lendingMarket: this.kaminoMarket.getAddress(),
+            reserve: this.reserve.address,
+            referrerTokenState: referrerTokenStateAddress,
+            reserveSupplyLiquidity: this.reserve.state.liquidity.supplyVault,
+            referrerTokenAccount: this.userTokenAccountAddress,
+            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        }, this.kaminoMarket.programId);
+        this.lendingIxs.push(withdrawReferrerFeesIx);
+        this.lendingIxsLabels.push(`WithdrawReferrerFeesIx[${this.owner.toString()}]`);
+    }
+    addComputeBudgetIxn(units) {
+        this.setupIxs.push((0, utils_1.buildComputeBudgetIx)(units));
+        this.setupIxsLabels.push(`AddComputeBudget[${units}]`);
+    }
+    addAtaIxs(action) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.mint.equals(utils_1.WRAPPED_SOL_MINT) || ((_a = this.secondaryMint) === null || _a === void 0 ? void 0 : _a.equals(utils_1.WRAPPED_SOL_MINT))) {
+                yield this.updateWSOLAccount(action);
+            }
+            if ((action === 'withdraw' || action === 'borrow' || action === 'redeem') && !this.mint.equals(utils_1.WRAPPED_SOL_MINT)) {
+                const userTokenAccountInfo = yield this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
+                if (!userTokenAccountInfo) {
+                    const [, createUserTokenAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, this.reserve.getLiquidityMint(), this.owner, this.userTokenAccountAddress);
+                    if (this.positions === exports.POSITION_LIMIT && this.hostAta) {
+                        this.preTxnIxs.push(createUserTokenAccountIx);
+                        this.preTxnIxsLabels.push(`CreateLiquidityUserAta[${this.owner}]`);
+                    }
+                    else {
+                        this.setupIxs.unshift(createUserTokenAccountIx);
+                        this.setupIxsLabels.unshift(`CreateLiquidityUserAta[${this.owner}]`);
+                    }
+                }
+            }
+            if (action === 'liquidate') {
+                const userTokenAccountInfo = yield this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
+                if (!this.outflowReserve) {
+                    throw new Error(`Outflow reserve state not found ${this.mint}`);
+                }
+                if (!userTokenAccountInfo) {
+                    const [, createUserTokenAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, this.outflowReserve.getLiquidityMint(), this.owner, this.userTokenAccountAddress);
+                    if (this.positions === exports.POSITION_LIMIT && this.mint.equals(utils_1.WRAPPED_SOL_MINT)) {
+                        this.preTxnIxs.push(createUserTokenAccountIx);
+                        this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
+                    }
+                    else {
+                        this.setupIxs.unshift(createUserTokenAccountIx);
+                        this.setupIxsLabels.unshift(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
+                    }
+                }
+                const userCollateralAccountInfo = yield this.kaminoMarket
+                    .getConnection()
+                    .getAccountInfo(this.userCollateralAccountAddress);
+                if (!userCollateralAccountInfo) {
+                    const [, createUserCollateralAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, this.outflowReserve.getCTokenMint(), this.owner, this.userCollateralAccountAddress);
+                    if (this.positions === exports.POSITION_LIMIT && this.mint.equals(utils_1.WRAPPED_SOL_MINT)) {
+                        this.preTxnIxs.push(createUserCollateralAccountIx);
+                        this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+                    }
+                    else {
+                        this.setupIxs.unshift(createUserCollateralAccountIx);
+                        this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+                    }
+                }
+                if (!this.additionalTokenAccountAddress) {
+                    throw new Error(`Additional token account address not found ${this.mint}`);
+                }
+            }
+            if (action === 'depositAndBorrow' ||
+                (action === 'repayAndWithdraw' && !((_b = this.secondaryMint) === null || _b === void 0 ? void 0 : _b.equals(utils_1.WRAPPED_SOL_MINT)))) {
+                if (!this.additionalTokenAccountAddress) {
+                    throw new Error(`Additional token account address not found ${this.secondaryMint}`);
+                }
+                if (!this.outflowReserve) {
+                    throw new Error(`Outflow reserve state not found ${this.mint}`);
+                }
+                const additionalUserTokenAccountInfo = yield this.kaminoMarket
+                    .getConnection()
+                    .getAccountInfo(this.additionalTokenAccountAddress);
+                if (!additionalUserTokenAccountInfo) {
+                    const [, createUserTokenAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, this.outflowReserve.getLiquidityMint(), this.owner, this.additionalTokenAccountAddress);
+                    this.setupIxs.unshift(createUserTokenAccountIx);
+                    this.setupIxsLabels.unshift(`CreateAdditionalUserTokenAta[${this.owner}]`);
+                }
+            }
+            if (action === 'withdraw' || action === 'mint' || action === 'deposit' || action === 'repayAndWithdraw') {
+                const userTokenAccountInfo = yield this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
+                // TODO: Might need to remove this
+                if (!userTokenAccountInfo) {
+                    const [, createUserTokenAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, this.reserve.getLiquidityMint(), this.owner, this.userTokenAccountAddress);
+                    this.preTxnIxs.push(createUserTokenAccountIx);
+                    this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
+                }
+            }
+            if (action === 'mint') {
+                const userCollateralAccountInfo = yield this.kaminoMarket
+                    .getConnection()
+                    .getAccountInfo(this.userCollateralAccountAddress);
+                if (!userCollateralAccountInfo) {
+                    const collateralMintPubkey = this.reserve.getCTokenMint();
+                    const [, createUserCollateralAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, collateralMintPubkey, this.owner, this.userCollateralAccountAddress);
+                    if (this.positions === exports.POSITION_LIMIT && this.mint.equals(utils_1.WRAPPED_SOL_MINT)) {
+                        this.preTxnIxs.push(createUserCollateralAccountIx);
+                        this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+                    }
+                    else {
+                        this.setupIxs.unshift(createUserCollateralAccountIx);
+                        this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+                    }
+                }
+            }
+        });
+    }
+    updateWSOLAccount(action) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const preIxs = [];
+            const postIxs = [];
+            const preIxsLabels = [];
+            const postIxsLabels = [];
+            if (action === 'depositAndBorrow' || action === 'repayAndWithdraw') {
+                return;
+            }
+            let safeRepay = new bn_js_1.default(this.amount);
+            if (this.obligation && action === 'repay' && this.amount.eq(new bn_js_1.default(utils_1.U64_MAX))) {
+                const borrow = this.obligation.state.borrows.find((borrow) => borrow.borrowReserve.toString() === this.reserve.address.toString());
+                if (!borrow) {
+                    throw Error(`Unable to find obligation borrow to repay for ${this.obligation.state.owner.toBase58()}`);
+                }
+                const cumulativeBorrowRateObligation = obligation_1.KaminoObligation.getCumulativeBorrowRate(borrow);
+                const cumulativeBorrowRateReserve = this.reserve.getEstimatedCumulativeBorrowRate(this.currentSlot);
+                // TODO: shouldn't this calc be added to all other stuff as well?
+                safeRepay = new bn_js_1.default(Math.floor(obligation_1.KaminoObligation.getBorrowAmount(borrow)
+                    .mul(cumulativeBorrowRateReserve)
+                    .div(cumulativeBorrowRateObligation)
+                    .add(new decimal_js_1.default(SOL_PADDING_FOR_INTEREST.toString()))
+                    .toNumber()).toString());
+            }
+            let userTokenAccountAddress = this.userTokenAccountAddress;
+            if ((_a = this.secondaryMint) === null || _a === void 0 ? void 0 : _a.equals(utils_1.WRAPPED_SOL_MINT)) {
+                if (!this.additionalTokenAccountAddress) {
+                    throw new Error(`Additional token account address not found ${this.secondaryMint}`);
+                }
+                userTokenAccountAddress = this.additionalTokenAccountAddress;
+            }
+            const userWSOLAccountInfo = yield this.kaminoMarket.getConnection().getAccountInfo(userTokenAccountAddress);
+            const rentExempt = yield spl_token_1.Token.getMinBalanceRentForExemptAccount(this.kaminoMarket.getConnection());
+            // Add rent exemption lamports for WSOL accounts that need to be pre-funded for inflow/send transactions
+            const sendAction = action === 'deposit' ||
+                action === 'repay' ||
+                action === 'mint' ||
+                (action === 'liquidate' && ((_b = this.secondaryMint) === null || _b === void 0 ? void 0 : _b.equals(utils_1.WRAPPED_SOL_MINT))); // only sync WSOL amount if liquidator repays SOL which is secondaryMint
+            const transferLamportsIx = web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.owner,
+                toPubkey: userTokenAccountAddress,
+                lamports: (userWSOLAccountInfo ? 0 : rentExempt) + (sendAction ? parseInt(safeRepay.toString(), 10) : 0),
+            });
+            preIxs.push(transferLamportsIx);
+            preIxsLabels.push(`TransferLamportsToUserAtaSOL[${userTokenAccountAddress}]`);
+            const closeWSOLAccountIx = spl_token_1.Token.createCloseAccountInstruction(spl_token_1.TOKEN_PROGRAM_ID, userTokenAccountAddress, this.owner, this.owner, []);
+            const syncIx = (0, utils_1.syncNative)(userTokenAccountAddress);
+            if (userWSOLAccountInfo) {
+                if (sendAction) {
+                    preIxs.push(syncIx);
+                    preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
+                }
+                else {
+                    postIxs.push(closeWSOLAccountIx);
+                    postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
+                }
+            }
+            else {
+                const [, createUserWSOLAccountIx] = yield (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(this.owner, spl_token_1.NATIVE_MINT, this.owner, userTokenAccountAddress);
+                preIxs.push(createUserWSOLAccountIx);
+                preIxsLabels.push(`CreateUserAtaSOL[${userTokenAccountAddress}]`);
+                preIxs.push(syncIx);
+                preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
+                postIxs.push(closeWSOLAccountIx);
+                postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
+            }
+            // TODO: Consider for liquidations and other types of actions if we have to split up some ixs in 2-3 txs
+            // if (this.positions && this.positions >= POSITION_LIMIT) {
+            //   this.preTxnIxs.push(...preIxs);
+            //   this.preTxnIxsLabels.push(...preIxsLabels);
+            //   this.postTxnIxs.push(...postIxs);
+            //   this.postTxnIxsLabels.push(...postIxsLabels);
+            // } else {
+            // }
+            this.setupIxs.unshift(...preIxs);
+            this.setupIxsLabels.unshift(...preIxsLabels);
+            this.cleanupIxs.push(...postIxs);
+            this.cleanupIxsLabels.push(...postIxsLabels);
+        });
+    }
+    static initializeMultiTokenAction(kaminoMarket, action, inflowAmount, inflowTokenMint, outflowTokenMint, payer, obligationOwner, obligation, outflowAmount, referrer = web3_js_1.PublicKey.default, currentSlot = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inflowReserve = kaminoMarket.getReserveByMint(inflowTokenMint);
+            const outflowReserve = kaminoMarket.getReserveByMint(outflowTokenMint);
+            if (!outflowReserve || !inflowReserve) {
+                throw new Error('reserve states are not fetched');
+            }
+            const { userTokenAccountAddress: userOutflowTokenAccountAddress, userCollateralAccountAddress: userOutflowCollateralAccountAddress, } = yield KaminoAction.getUserAccountAddresses(payer, outflowReserve.state);
+            const { userTokenAccountAddress: userInflowTokenAccountAddress, userCollateralAccountAddress: userInflowCollateralAccountAddress, } = yield KaminoAction.getUserAccountAddresses(payer, inflowReserve.state);
+            const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } = yield KaminoAction.loadObligation(action, kaminoMarket, obligationOwner, inflowReserve.address, obligation, outflowReserve.address);
+            const [_, userMetadata] = yield kaminoMarket.getUserMetadata(payer);
+            if (userMetadata) {
+                referrer = userMetadata.referrer;
+            }
+            const referrerKey = kaminoObligation ? kaminoObligation.state.referrer : referrer;
+            let userTokenAccountAddress;
+            let userCollateralAccountAddress;
+            let additionalUserTokenAccountAddress;
+            let secondaryMint;
+            let primaryMint;
+            if (action === 'liquidate') {
+                userTokenAccountAddress = userOutflowTokenAccountAddress;
+                userCollateralAccountAddress = userOutflowCollateralAccountAddress;
+                additionalUserTokenAccountAddress = userInflowTokenAccountAddress;
+                primaryMint = outflowTokenMint;
+                secondaryMint = inflowTokenMint;
+            }
+            else if (action === 'depositAndBorrow') {
+                userTokenAccountAddress = userInflowTokenAccountAddress;
+                userCollateralAccountAddress = userInflowCollateralAccountAddress;
+                additionalUserTokenAccountAddress = userOutflowTokenAccountAddress;
+                primaryMint = inflowTokenMint;
+                secondaryMint = outflowTokenMint;
+            }
+            else if (action === 'repayAndWithdraw') {
+                primaryMint = inflowTokenMint;
+                secondaryMint = outflowTokenMint;
+                userTokenAccountAddress = userInflowTokenAccountAddress;
+                userCollateralAccountAddress = userOutflowCollateralAccountAddress;
+                additionalUserTokenAccountAddress = userOutflowTokenAccountAddress;
+            }
+            else {
+                throw new Error('Invalid action');
+            }
+            return new KaminoAction(kaminoMarket, payer, kaminoObligation || obligation, userTokenAccountAddress, userCollateralAccountAddress, primaryMint, distinctReserveCount, inflowAmount, depositReserves, borrowReserves, inflowReserve, currentSlot, undefined, secondaryMint, additionalUserTokenAccountAddress, outflowReserve, outflowAmount, referrerKey);
+        });
+    }
+    static initializeWithdrawReferrerFees(mint, owner, kaminoMarket, currentSlot = 0, hostAta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reserve = kaminoMarket.getReserveByMint(mint);
+            if (reserve === undefined) {
+                throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress().toBase58()}`);
+            }
+            const { atas, createAtasIxns } = yield (0, utils_1.getAtasWithCreateIxnsIfMissing)(kaminoMarket.getConnection(), owner, [
+                reserve.getLiquidityMint(),
+            ]);
+            const userTokenAccountAddress = atas[0];
+            return {
+                axn: new KaminoAction(kaminoMarket, owner, new ObligationType_1.VanillaObligation(kaminoMarket.programId), userTokenAccountAddress, web3_js_1.PublicKey.default, mint, 0, new bn_js_1.default(0), [], [], reserve, currentSlot, hostAta, undefined, undefined, undefined, undefined, undefined),
+                createAtasIxns,
+            };
+        });
+    }
+    getObligationPda() {
+        return this.obligation
+            ? this.obligation.obligationAddress
+            : this.obligationType.toPda(this.kaminoMarket.getAddress(), this.owner);
+    }
+}
+exports.KaminoAction = KaminoAction;
+//# sourceMappingURL=action.js.map