@exponent-labs/exponent-sdk 0.0.3

package/build/market.js

@@ -0,0 +1,1445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Market = exports.MyWallet = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+const exponent_ix_1 = require("@exponent-labs/exponent-ix");
+const spl_token_1 = require("@solana/spl-token");
+const addressLookupTableUtil_1 = require("./addressLookupTableUtil");
+const tokenUtil_1 = require("./tokenUtil");
+const flavors_1 = require("./flavors");
+const exponent_idl_1 = require("@exponent-labs/exponent-idl");
+const anchor_2 = require("@coral-xyz/anchor");
+const exponent_pda_1 = require("@exponent-labs/exponent-pda");
+const vault_1 = require("./vault");
+const market_math_1 = require("@exponent-labs/market-math");
+const utils_1 = require("./utils");
+const precise_number_1 = require("@exponent-labs/precise-number");
+const altUtil_1 = require("./utils/altUtil");
+const syPosition_1 = require("./syPosition");
+const exponent_ix_2 = require("@exponent-labs/exponent-ix");
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+class MyWallet {
+    payer;
+    constructor(payer) {
+        this.payer = payer;
+        this.payer = payer;
+    }
+    async signTransaction(tx) {
+        if (tx instanceof anchor_1.web3.Transaction) {
+            tx.partialSign(this.payer);
+        }
+        else {
+            tx.sign([this.payer]);
+        }
+        return tx;
+    }
+    async signAllTransactions(txs) {
+        return txs.map((t) => {
+            if (t instanceof anchor_1.web3.Transaction) {
+                t.partialSign(this.payer);
+            }
+            else if (t instanceof anchor_1.web3.VersionedTransaction) {
+                t.sign([this.payer]);
+            }
+            return t;
+        });
+    }
+    get publicKey() {
+        return this.payer.publicKey;
+    }
+}
+exports.MyWallet = MyWallet;
+class Market {
+    state;
+    selfAddress;
+    env;
+    connection;
+    coreProgram;
+    xponIx;
+    xponPda;
+    constructor(state, selfAddress, env, connection) {
+        this.state = state;
+        this.selfAddress = selfAddress;
+        this.env = env;
+        this.connection = connection;
+        this.xponPda = new exponent_pda_1.ExponentPDA(env.coreProgramId);
+        this.xponIx = new exponent_ix_1.ExponentIx(env.coreProgramId);
+        const mockWallet = new MyWallet(anchor_1.web3.Keypair.generate());
+        this.coreProgram = new anchor_1.Program(exponent_idl_1.IDL, new anchor_1.AnchorProvider(connection, mockWallet));
+    }
+    static async load(env, connection, address, vault) {
+        const fetcher = new exponent_fetcher_1.ExponentFetcher({ connection });
+        const m = await fetcher.fetchMarket(address);
+        const [[lpSupply, sySupply], alt, loadedVault] = await Promise.all([
+            (0, tokenUtil_1.getMultipleMintSupply)(connection, [m.mintLp, m.mintSy]),
+            (0, addressLookupTableUtil_1.fetchAddressLookupTable)(connection, m.addressLookupTable),
+            vault || vault_1.Vault.load(env, connection, m.vault),
+        ]);
+        const cpiAccounts = (0, addressLookupTableUtil_1.makeCpiAccountMetaLists)(alt, m.cpiAccounts);
+        const flavor = (() => {
+            switch (loadedVault.flavor.flavor) {
+                case "marginfi":
+                    return (0, flavors_1.makeFlavorMarginfiSync)(loadedVault.flavor);
+                case "kamino":
+                    return (0, flavors_1.makeFlavorKaminoSync)(loadedVault.flavor);
+                case "jitoRestaking":
+                    return (0, flavors_1.makeFlavorJitoRestakingSync)(loadedVault.flavor);
+                case "perena":
+                    return (0, flavors_1.makeFlavorPerenaSync)(loadedVault.flavor);
+                case "generic":
+                    return (0, flavors_1.makeFlavorGenericSync)(loadedVault.flavor);
+                default:
+                    throw new Error(`Unknown flavor: ${loadedVault.flavor}`);
+            }
+        })();
+        const syPosition = await (0, syPosition_1.makeSyPosition)(fetcher, flavor, m.syProgram, address);
+        const state = {
+            ...m,
+            vault: loadedVault,
+            cpiAccounts,
+            lpSupply,
+            sySupply,
+            flavor,
+            syPosition,
+        };
+        return new Market(state, address, env, connection);
+    }
+    async reload(conn = this.connection) {
+        const m = await Market.load(this.env, conn, this.selfAddress);
+        this.state = m.state;
+        return m;
+    }
+    /** Convert to a JSON representation */
+    toJson() {
+        return toJson(this);
+    }
+    get vault() {
+        return this.state.vault;
+    }
+    get flavor() {
+        return this.state.flavor;
+    }
+    get lpSupply() {
+        return this.state.lpSupply;
+    }
+    get syBalance() {
+        return this.state.syBalance;
+    }
+    get ptBalance() {
+        return this.state.ptBalance;
+    }
+    get mintSy() {
+        return this.state.mintSy;
+    }
+    get mintPt() {
+        return this.state.mintPt;
+    }
+    get statusFlags() {
+        return this.state.statusFlags;
+    }
+    get mintYt() {
+        return this.vault.mintYt;
+    }
+    get mintLp() {
+        return this.state.mintLp;
+    }
+    get addressLookupTable() {
+        return this.state.addressLookupTable;
+    }
+    get syProgram() {
+        return this.state.syProgram;
+    }
+    get cpiAccounts() {
+        return this.state.cpiAccounts;
+    }
+    get marketEmissions() {
+        return this.state.emissions;
+    }
+    get emissions() {
+        if (this.flavor.flavor === "marginfi") {
+            return this.flavor.mfiSyState.account.emissions.map((e) => ({
+                escrowAccountAddress: e.escrowAccount,
+                mint: e.mint,
+                tokenProgramAddress: e.tokenProgram,
+                totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+                lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+                index: e.index,
+            }));
+        }
+        if (this.flavor.flavor === "kamino") {
+            return this.flavor.kaminoSyState.account.emissions.map((e) => ({
+                escrowAccountAddress: e.escrowAccount,
+                mint: e.mint,
+                tokenProgramAddress: e.tokenProgram,
+                totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+                lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+                index: e.index,
+            }));
+        }
+        if (this.flavor.flavor === "jitoRestaking") {
+            return this.flavor.jitoSyState.account.emissions.map((e) => ({
+                escrowAccountAddress: e.escrowAccount,
+                mint: e.mint,
+                tokenProgramAddress: e.tokenProgram,
+                totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+                lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+                index: e.index,
+            }));
+        }
+        if (this.flavor.flavor === "perena") {
+            return this.flavor.perenaSyState.account.emissions.map((e) => ({
+                escrowAccountAddress: e.escrowAccount,
+                mint: e.mint,
+                tokenProgramAddress: e.tokenProgram,
+                totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+                lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+                index: e.index,
+            }));
+        }
+        if (this.flavor.flavor === "generic") {
+            return this.flavor.genericSyState.account.emissions.map((e) => ({
+                escrowAccountAddress: e.escrowAccount,
+                mint: e.mint,
+                tokenProgramAddress: e.tokenProgram,
+                totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+                lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+                index: e.index,
+            }));
+        }
+        throw new Error("Unknown flavor");
+    }
+    /** Get the escrow token account addresses for the emissions, in order */
+    get emissionTokenAccounts() {
+        return this.emissions.map((e) => e.escrowAccountAddress);
+    }
+    /** Pass-through SY account owned by the market */
+    get tokenSyEscrow() {
+        return this.state.tokenSyEscrow;
+    }
+    /** SY account that holds treasury SY fees from PT trading */
+    get tokenFeeTreasurySy() {
+        return this.state.tokenFeeTreasurySy;
+    }
+    /** Market liquidity for PT */
+    get tokenPtEscrow() {
+        return this.state.tokenPtEscrow;
+    }
+    get tokenLpEscrow() {
+        return this.state.tokenLpEscrow;
+    }
+    get currentSyExchangeRate() {
+        return this.flavor.currentSyExchangeRate;
+    }
+    /** Special account for event emit self-cpi */
+    get eventAuthority() {
+        return (0, utils_1.emitEventAuthority)(this.env.coreProgramId);
+    }
+    get currentPtPriceInSy() {
+        return this.currentPtPriceInAsset / this.currentSyExchangeRate;
+    }
+    get currentPtPriceInAsset() {
+        const c = this.marketCalculator();
+        return c.exchangeRate;
+    }
+    get ptDiscount() {
+        return 1 / this.currentPtPriceInAsset;
+    }
+    get lpPriceInAsset() {
+        // Calculate total value of liquidity in asset units
+        const liquidityPoolTvl = Number(this.syBalance) * this.flavor.currentSyExchangeRate + Number(this.ptBalance) / this.currentPtPriceInAsset;
+        // Return LP price in asset units (0 if no supply to avoid division by zero)
+        return Number(this.lpSupply) === 0 ? 0 : liquidityPoolTvl / Number(this.lpSupply);
+    }
+    get secondsRemaining() {
+        const now = Date.now() / 1000;
+        return Math.max(0, Math.round(this.state.expirationTs - now));
+    }
+    get absolutePtYield() {
+        const ptAssetExchangeRate = this.ptDiscount;
+        return (1 - ptAssetExchangeRate) / ptAssetExchangeRate;
+    }
+    /** Annualize a rate given the number of seconds remaining until maturity */
+    static annualize(r, secondsRemaining) {
+        return (r * SECONDS_PER_YEAR) / secondsRemaining;
+    }
+    /** Annualized PT fixed rate */
+    get ptApr() {
+        return Market.annualize(this.absolutePtYield, this.secondsRemaining);
+    }
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+    get feeTreasuryBps() {
+        return this.state.feeTreasurySyBps;
+    }
+    /** The fee rate on assets when trading PT
+     * Expressed as a rational number
+     * eg 0.01 = 1%
+     */
+    get feeRatePtTrade() {
+        return 1 - this.marketCalculator().feeRate;
+    }
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+    get feeTreasuryRate() {
+        return this.feeTreasuryBps / 10_000;
+    }
+    /** Calculate amonut of LP tokens to expect for tokens in */
+    lpOutForTokensIn(syInIntent, ptInIntent) {
+        return (0, market_math_1.lpOutForTokensIn)({
+            syIntent: Number(syInIntent),
+            ptIntent: Number(ptInIntent),
+            lpSupply: Number(this.lpSupply),
+            syLiquidity: Number(this.syBalance),
+            ptLiquidity: Number(this.ptBalance),
+        });
+    }
+    marketCalculator() {
+        const secondsRemaining = Math.max(0, Math.round(this.state.expirationTs - Date.now() / 1000));
+        return new market_math_1.MarketCalculator({
+            liquiditySy: parseInt(this.syBalance.toString()),
+            liquidityPt: parseInt(this.ptBalance.toString()),
+            currentSyExchangeRate: this.currentSyExchangeRate,
+            lnFeeRateRoot: this.state.lnFeeRateRoot,
+            secondsRemaining,
+            lpTokenSupply: this.lpSupply,
+            rateScalarRoot: this.state.rateScalarRoot,
+            lastLnImpliedRate: this.state.lastLnImpliedRate,
+            maxNetBalanceChangeNegativePercentage: this.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+            maxNetBalanceChangePositivePercentage: this.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+            windowStartTimestamp: this.state.liquidityNetBalanceLimits.windowStartTimestamp,
+            windowStartNetBalance: this.state.liquidityNetBalanceLimits.windowStartNetBalance.toNumber(),
+            windowDurationSeconds: this.state.liquidityNetBalanceLimits.windowDurationSeconds,
+        });
+    }
+    /** Deposit a pair of tokens as liquidity to the market
+     * Adds PT & SY from the `depositor` to the market
+     *
+     * Due to unforeseeable slippage, the PT & SY amounts intended are effectively the maximum amounts
+     * The minimum LP tokens to receive is specified by `minLpOut`
+     *
+     * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
+     */
+    async ixDepositLiquidity({ ptInIntent, syInIntent, minLpOut, depositor, ptSrc, sySrc, lpDst, }) {
+        const tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+        sySrc = sySrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        ptSrc = ptSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        lpDst = lpDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const syRemAccounts = this.cpiAccounts.depositSy;
+        return this.coreProgram.methods
+            .marketTwoDepositLiquidity(new anchor_2.BN(ptInIntent.toString()), new anchor_2.BN(syInIntent.toString()), new anchor_2.BN(minLpOut.toString()))
+            .accountsStrict({
+            depositor,
+            market: this.selfAddress,
+            mintLp: this.mintLp,
+            tokenPtSrc: ptSrc,
+            tokenSySrc: sySrc,
+            tokenLpDst: lpDst,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenProgram,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(syRemAccounts)
+            .instruction();
+    }
+    async ixModifyMarketSetting({ signer, adminAction }) {
+        return this.coreProgram.methods
+            .modifyMarketSetting(adminAction)
+            .accountsStrict({
+            market: this.selfAddress,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            signer,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async ixModifyFarm({ newRate, untilTimestamp, signer, farmMint, farmTokenProgram, farmTokenSrc, }) {
+        farmTokenSrc = farmTokenSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
+        const tokenFarm = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
+        return this.coreProgram.methods
+            .modifyFarm(untilTimestamp, new anchor_2.BN(newRate.toString()))
+            .accountsStrict({
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            market: this.selfAddress,
+            mint: farmMint,
+            tokenFarm: tokenFarm,
+            signer,
+            tokenProgram: farmTokenProgram,
+            tokenSource: farmTokenSrc,
+        })
+            .instruction();
+    }
+    /**
+     * Redeem LP tokens for PT & SY  (liquidity removal)
+     *
+     * The lpIn is exactly the amount of LP tokens to burn
+     * The minimum PT & SY out are specified by minPtOut & minSyOut
+     * The transaction may fail due to unforeseeable slippage on the redemption rate
+     *
+     * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
+     */
+    async ixWithdrawLiquidity({ lpIn, withdrawer, minPtOut, minSyOut, ptDst, syDst, lpSrc, }) {
+        ptDst = ptDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
+        syDst = syDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
+        lpSrc = lpSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ptDstAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(withdrawer, ptDst, withdrawer, this.mintPt);
+        const syDstAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(withdrawer, syDst, withdrawer, this.mintSy);
+        const lpSrcAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(withdrawer, lpSrc, withdrawer, this.mintLp);
+        const syRemAccounts = this.cpiAccounts.withdrawSy;
+        const ixs = await this.coreProgram.methods
+            .marketTwoWithdrawLiquidity(new anchor_2.BN(lpIn.toString()), new anchor_2.BN(minPtOut.toString()), new anchor_2.BN(minSyOut.toString()))
+            .accountsStrict({
+            withdrawer,
+            market: this.selfAddress,
+            mintLp: this.mintLp,
+            tokenPtDst: ptDst,
+            tokenSyDst: syDst,
+            tokenLpSrc: lpSrc,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(syRemAccounts)
+            .instruction();
+        return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] };
+    }
+    /** Buy PT with SY
+     *
+     * The trader is the account that sends the SY
+     * The amountPt is the exact amount of PT the trader intends to buy
+     * The syConstraint is the maximum amount of SY the trader is willing to spend
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    async ixBuyPt({ trader, amountPt, maxSySpend, tokenPt, tokenSy, }) {
+        return this.ixTradePt({
+            trader,
+            traderPt: amountPt,
+            syConstraint: maxSySpend,
+            isBuy: true,
+            tokenPt,
+            tokenSy,
+        });
+    }
+    /**
+     * Sell PT for SY
+     * The trader is the account that sends the PT
+     * The amountPt is the exact amount of PT the trader intends to sell
+     * The minSyReceive is the minimum amount of SY the trader is willing to receive
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    async ixSellPt({ trader, amountPt, minSyReceive, tokenPt, tokenSy, }) {
+        return this.ixTradePt({
+            trader,
+            traderPt: amountPt,
+            syConstraint: minSyReceive,
+            isBuy: false,
+            tokenPt,
+            tokenSy,
+        });
+    }
+    async ixTradePt({ trader, traderPt, syConstraint, isBuy, tokenPt, tokenSy, }) {
+        tokenPt = tokenPt || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenSy = tokenSy || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, tokenSy, trader, this.mintSy);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, tokenPt, trader, this.mintPt);
+        const remainingAccounts = [
+            ...this.cpiAccounts.getSyState,
+            ...this.cpiAccounts.depositSy,
+            ...this.cpiAccounts.withdrawSy,
+        ];
+        const netTradePtBN = new anchor_2.BN(traderPt.toString()).mul(isBuy ? new anchor_2.BN(1) : new anchor_2.BN(-1));
+        const syConstraintBN = new anchor_2.BN(syConstraint.toString()).mul(isBuy ? new anchor_2.BN(-1) : new anchor_2.BN(1));
+        const ix = await this.coreProgram.methods
+            .tradePt(netTradePtBN, syConstraintBN)
+            .accountsStrict({
+            trader,
+            market: this.selfAddress,
+            tokenPtTrader: tokenPt,
+            tokenSyTrader: tokenSy,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] };
+    }
+    /** Sell YT for SY
+     *
+     * The trader is the account that sends the YT
+     *
+     * The amountYt is the exact amount of YT the trader intends to sell
+     *
+     * The minSyOut is the minimum amount of SY the trader is willing to receive
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    async ixSellYt({ trader, ytIn, minSyOut, ytSrc, ptSrc, syDst, }) {
+        syDst = syDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        ptSrc = ptSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        ytSrc = ytSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const syDstAtaIxs = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, syDst, trader, this.mintSy);
+        const ptSrcAtaIxs = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, ptSrc, trader, this.mintPt);
+        const ytSrcAtaIxs = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, ytSrc, trader, this.mintYt);
+        const mergeAccounts = this.vault.mergeAccounts({ owner: trader, ytSrc, ptSrc, syDst });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.getSyState,
+            ...this.cpiAccounts.depositSy,
+            ...mergeAccounts.remainingAccounts,
+        ]);
+        remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false });
+        const ix = await this.coreProgram.methods
+            .sellYt(new anchor_2.BN(ytIn.toString()), new anchor_2.BN(minSyOut.toString()))
+            .accountsStrict({
+            trader,
+            market: this.selfAddress,
+            tokenYtTrader: ytSrc,
+            tokenPtTrader: ptSrc,
+            tokenSyTrader: syDst,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            vault: mergeAccounts.mainAccounts.vault,
+            authorityVault: mergeAccounts.mainAccounts.authority,
+            tokenSyEscrowVault: mergeAccounts.mainAccounts.escrowSy,
+            mintYt: this.mintYt,
+            mintPt: this.mintPt,
+            addressLookupTableVault: mergeAccounts.mainAccounts.addressLookupTable,
+            yieldPositionVault: mergeAccounts.mainAccounts.yieldPosition,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] };
+    }
+    /** Buy YT with SY
+     *
+     * The trader is the account that sends the SY
+     *
+     * The ytOut is the exact amount of YT the trader intends to buy
+     *
+     * The maxSyIn is the maximum amount of SY the trader is willing to spend
+     *
+     * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+     */
+    async ixBuyYt({ trader, ytOut, maxSyIn, ytTrader, ptTrader, syTrader, }) {
+        syTrader = syTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        ptTrader = ptTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        ytTrader = ytTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const syTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, syTrader, trader, this.mintSy);
+        const ptTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, ptTrader, trader, this.mintPt);
+        const ytTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(trader, ytTrader, trader, this.mintYt);
+        const stripAccounts = this.vault.stripAccounts({
+            depositor: trader,
+            ytDst: ytTrader,
+            ptDst: ptTrader,
+            sySrc: syTrader,
+        });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.getSyState,
+            ...this.cpiAccounts.withdrawSy,
+            ...this.cpiAccounts.depositSy,
+            ...stripAccounts.remainingAccounts,
+        ]);
+        remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false });
+        const ix = await this.coreProgram.methods
+            .buyYt(new anchor_2.BN(maxSyIn.toString()), new anchor_2.BN(ytOut.toString()))
+            .accountsStrict({
+            trader,
+            market: this.selfAddress,
+            tokenYtTrader: ytTrader,
+            tokenPtTrader: ptTrader,
+            tokenSyTrader: syTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            vault: stripAccounts.mainAccounts.vault,
+            vaultAuthority: stripAccounts.mainAccounts.authority,
+            tokenSyEscrowVault: stripAccounts.mainAccounts.escrowSy,
+            mintYt: this.mintYt,
+            mintPt: this.mintPt,
+            addressLookupTableVault: stripAccounts.mainAccounts.addressLookupTable,
+            yieldPosition: stripAccounts.mainAccounts.yieldPosition,
+            tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] };
+    }
+    async ixInitLpPosition({ owner, feePayer }) {
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        return this.coreProgram.methods
+            .initLpPosition()
+            .accountsStrict({
+            owner,
+            feePayer: feePayer || owner,
+            lpPosition,
+            market: this.selfAddress,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .instruction();
+    }
+    /** Deposit LP tokens into the farming module to earn rewards */
+    async ixDepositLp({ owner, amount, lpSrc }) {
+        lpSrc = lpSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        return this.coreProgram.methods
+            .marketDepositLp(new anchor_2.BN(amount.toString()))
+            .accountsStrict({
+            owner,
+            lpPosition,
+            tokenLpSrc: lpSrc,
+            tokenLpEscrow: this.tokenLpEscrow,
+            market: this.selfAddress,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            mintLp: this.mintLp,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(this.cpiAccounts.getPositionState)
+            .instruction();
+    }
+    /** Withdraw LP tokens from the farming module */
+    async ixWithdrawLp({ owner, amount, lpDst }) {
+        lpDst = lpDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        return this.coreProgram.methods
+            .marketWithdrawLp(new anchor_2.BN(amount.toString()))
+            .accountsStrict({
+            owner,
+            lpPosition,
+            tokenLpDst: lpDst,
+            tokenLpEscrow: this.tokenLpEscrow,
+            market: this.selfAddress,
+            addressLookupTable: this.addressLookupTable,
+            mintLp: this.mintLp,
+            syProgram: this.syProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(this.cpiAccounts.getPositionState)
+            .instruction();
+    }
+    async ixWrapperCollectInterest({ claimer, tokenSyDst }) {
+        const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress });
+        tokenSyDst = tokenSyDst || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, claimer, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseClaimer = (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, claimer, true, this.flavor.baseTokenProgram);
+        const tokenBaseClaimerAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(claimer, tokenBaseClaimer, claimer, this.flavor.mintBase);
+        const tokenSyClaimer = (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, claimer, true);
+        const tokenSyClaimerAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(claimer, tokenSyClaimer, claimer, this.mintSy);
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.vault.cpiAccounts.getSyState,
+            ...this.vault.cpiAccounts.withdrawSy,
+        ]);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: claimer,
+            redeemerBaseTokenAccount: tokenBaseClaimer,
+            redeemerSyTokenAccount: tokenSyDst,
+        });
+        const ix = await this.coreProgram.methods
+            .wrapperCollectInterest(redeemSyIx.keys.length)
+            .accountsStrict({
+            addressLookupTable: this.vault.addressLookupTable,
+            authority: this.vault.state.authority,
+            claimer,
+            escrowSy: this.vault.escrowSy,
+            syProgram: this.syProgram,
+            vault: this.vault.selfAddress,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
+            yieldPosition: yieldPosition,
+            tokenSyDst,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(redeemSyIx.keys.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: claimer })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: claimer })),
+            ],
+            setupIxs: [tokenBaseClaimerAtaIx, tokenSyClaimerAtaIx],
+        };
+    }
+    async ixWrapperBuyPt({ owner, ptOut, maxBaseIn, tokenSyTrader, tokenPtTrader, tokenBaseTrader, }) {
+        tokenSyTrader = tokenSyTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtTrader = tokenPtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseTrader =
+            tokenBaseTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        const tokenSyTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyTrader, owner, this.mintSy);
+        const tokenPtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtTrader, owner, this.mintPt);
+        const tokenBaseTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseTrader, owner, this.flavor.mintBase);
+        const mintSyIx = await this.flavor.ixMintSy({
+            amountBase: "0",
+            depositor: owner,
+            depositorBaseTokenAccount: tokenBaseTrader,
+            depositorSyTokenAccount: tokenSyTrader,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        console.log("mintSyRemAccounts", mintSyRemAccounts);
+        mintSyRemAccounts.push({
+            pubkey: this.coreProgram.programId,
+            isWritable: false,
+            isSigner: false,
+        });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.getSyState,
+            ...this.cpiAccounts.depositSy,
+            // ...this.cpiAccounts.withdrawSy,
+        ]);
+        const ix = await this.coreProgram.methods
+            .wrapperBuyPt(new anchor_2.BN(ptOut.toString()), new anchor_2.BN(maxBaseIn.toString()), mintSyRemAccounts.length)
+            .accountsStrict({
+            addressLookupTable: this.addressLookupTable,
+            buyer: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    async ixWrapperSellPt({ owner, amount, minBaseOut, tokenSyTrader, tokenPtTrader, tokenBaseTrader, }) {
+        tokenSyTrader = tokenSyTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtTrader = tokenPtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseTrader =
+            tokenBaseTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        const tokenSyTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyTrader, owner, this.mintSy);
+        const tokenPtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtTrader, owner, this.mintPt);
+        const tokenBaseTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseTrader, owner, this.flavor.mintBase);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: owner,
+            redeemerBaseTokenAccount: tokenBaseTrader,
+            redeemerSyTokenAccount: tokenSyTrader,
+        });
+        const redeemSyRemAccounts = redeemSyIx.keys;
+        redeemSyRemAccounts.push({
+            pubkey: this.coreProgram.programId,
+            isWritable: false,
+            isSigner: false,
+        });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([...this.cpiAccounts.getSyState, ...this.cpiAccounts.withdrawSy]);
+        const ix = await this.coreProgram.methods
+            .wrapperSellPt(new anchor_2.BN(amount.toString()), new anchor_2.BN(minBaseOut.toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            seller: owner,
+            market: this.selfAddress,
+            tokenPtTrader,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenSyTrader,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    async ixWrapperBuyYt({ owner, ytOut, maxBaseIn, tokenSyTrader, tokenPtTrader, tokenYtTrader, tokenBaseTrader, }) {
+        tokenSyTrader = tokenSyTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtTrader = tokenPtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtTrader = tokenYtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseTrader =
+            tokenBaseTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        const tokenSyTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyTrader, owner, this.mintSy);
+        const tokenPtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtTrader, owner, this.mintPt);
+        const tokenYtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenYtTrader, owner, this.mintYt);
+        const mintSyIx = await this.flavor.ixMintSy({
+            amountBase: "0",
+            depositor: owner,
+            depositorBaseTokenAccount: tokenBaseTrader,
+            depositorSyTokenAccount: tokenSyTrader,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.getSyState,
+            ...this.vault.cpiAccounts.depositSy,
+            ...this.vault.cpiAccounts.getSyState,
+            ...this.cpiAccounts.withdrawSy,
+            ...this.cpiAccounts.getPositionState,
+        ]);
+        const allRemainingAccounts = mintSyRemAccounts.concat(remainingAccounts);
+        const ix1 = await this.coreProgram.methods
+            .wrapperBuyYt(new anchor_2.BN(ytOut.toString()), new anchor_2.BN(maxBaseIn.toString()), mintSyRemAccounts.length)
+            .accountsStrict({
+            buyer: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenYtTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            marketAddressLookupTable: this.addressLookupTable,
+            vault: this.vault.selfAddress,
+            vaultAuthority: this.vault.authority,
+            tokenSyEscrowVault: this.vault.escrowSy,
+            vaultAddressLookupTable: this.vault.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            mintPt: this.vault.mintPt,
+            yieldPosition: this.vault.state.yieldPositonAddress,
+            mintYt: this.vault.mintYt,
+            escrowYt: this.vault.escrowYt,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(allRemainingAccounts)
+            .instruction();
+        const ix2 = await this.coreProgram.methods
+            .depositYt(new anchor_2.BN(ytOut.toString()))
+            .accountsStrict({
+            depositor: owner,
+            vault: this.vault.selfAddress,
+            userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+            ytSrc: tokenYtTrader,
+            escrowYt: this.vault.escrowYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            addressLookupTable: this.vault.addressLookupTable,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+            yieldPosition: this.vault.state.yieldPositonAddress,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: owner })),
+                ix1,
+                ...(await this.flavor.postIxs({ signer: owner })),
+                ix2,
+            ],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+        };
+    }
+    async ixWrapperSellYt({ owner, amount, minBaseOut, tokenBaseTrader, tokenSyTrader, tokenYtTrader, tokenPtTrader, }) {
+        tokenBaseTrader =
+            tokenBaseTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        tokenSyTrader = tokenSyTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtTrader = tokenYtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtTrader = tokenPtTrader || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyTrader, owner, this.mintSy);
+        const tokenPtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtTrader, owner, this.mintPt);
+        const tokenYtTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenYtTrader, owner, this.mintYt);
+        const tokenBaseTraderAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseTrader, owner, this.flavor.mintBase);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: owner,
+            redeemerBaseTokenAccount: tokenBaseTrader,
+            redeemerSyTokenAccount: tokenSyTrader,
+        });
+        const redeemSyRemAccounts = redeemSyIx.keys;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.getSyState,
+            ...this.cpiAccounts.withdrawSy,
+            ...this.vault.cpiAccounts.depositSy,
+        ]);
+        console.log(" remaining accounts length", remainingAccounts.length);
+        // remainingAccounts.push({
+        //   pubkey: this.coreProgram.programId,
+        //   isWritable: false,
+        //   isSigner: false,
+        // })
+        const ix1 = await this.coreProgram.methods
+            .withdrawYt(new anchor_2.BN(amount.toString()))
+            .accountsStrict({
+            ytDst: tokenYtTrader,
+            escrowYt: this.vault.escrowYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            addressLookupTable: this.vault.addressLookupTable,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+            yieldPosition: this.vault.state.yieldPositonAddress,
+            userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+            authority: this.vault.authority,
+            owner,
+            vault: this.vault.selfAddress,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        const ix2 = await this.coreProgram.methods
+            .wrapperSellYt(new anchor_2.BN(amount.toString()), new anchor_2.BN(minBaseOut.toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            seller: owner,
+            market: this.selfAddress,
+            tokenYtTrader,
+            marketAddressLookupTable: this.addressLookupTable,
+            vault: this.vault.selfAddress,
+            vaultAuthority: this.vault.authority,
+            tokenPtTrader,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrowVault: this.vault.escrowSy,
+            vaultAddressLookupTable: this.vault.addressLookupTable,
+            yieldPosition: this.vault.state.yieldPositonAddress,
+            mintPt: this.vault.mintPt,
+            mintYt: this.vault.mintYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenSyTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [
+                ix1,
+                ...(await this.flavor.preIxs({ signer: owner })),
+                ix2,
+                ...(await this.flavor.postIxs({ signer: owner })),
+            ],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    async ixCollectMarketEmission({ owner, emissionIndex, emissionDst, }) {
+        const emission = this.emissions[emissionIndex];
+        const tokenEmissionDst = emissionDst || (0, spl_token_1.getAssociatedTokenAddressSync)(emission.mint, owner, true, emission.tokenProgramAddress);
+        const tokenEmissionDstIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenEmissionDst, owner, emission.mint);
+        const ix = await this.coreProgram.methods
+            .marketCollectEmission(emissionIndex)
+            .accountsStrict({
+            addressLookupTable: this.addressLookupTable,
+            lpPosition: this.xponPda.marketLpPosition({ market: this.selfAddress, owner }),
+            market: this.selfAddress,
+            owner,
+            syProgram: this.syProgram,
+            tokenEmissionDst,
+            tokenEmissionEscrow: this.marketEmissions.trackers[emissionIndex].tokenEscrow,
+            tokenProgram: emission.tokenProgramAddress,
+            program: this.coreProgram.programId,
+            eventAuthority: this.eventAuthority,
+        })
+            .remainingAccounts(this.cpiAccounts.claimEmission[emissionIndex])
+            .instruction();
+        return {
+            ixs: [ix],
+            setupIxs: [tokenEmissionDstIx],
+        };
+    }
+    /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+    async ixProvideLiquidityNoPriceImpact({ depositor, amountBase, minLpOut, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }) {
+        tokenSyDepositor = tokenSyDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtDepositor = tokenYtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtDepositor = tokenPtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseDepositor =
+            tokenBaseDepositor ||
+                (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram);
+        tokenLpDepositor = tokenLpDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenSyDepositor, depositor, this.mintSy);
+        const tokenYtDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenYtDepositor, depositor, this.mintYt);
+        const tokenPtDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenPtDepositor, depositor, this.mintPt);
+        const tokenLpDepositorAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenLpDepositor, depositor, this.mintLp);
+        const amountBaseBn = new anchor_2.BN(amountBase.toString());
+        const minLpOutBn = new anchor_2.BN(minLpOut.toString());
+        // TODO - fix this
+        const mintSyIx = await this.flavor.ixMintSy({
+            // argument does not matter - since we are just getting the keys
+            amountBase: "0",
+            depositor,
+            depositorBaseTokenAccount: tokenBaseDepositor,
+            depositorSyTokenAccount: tokenSyDepositor,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        // Log vault accounts before filtering
+        const beforeVaultAccounts = [...this.vault.cpiAccounts.getSyState, ...this.vault.cpiAccounts.depositSy];
+        console.log("Before filtering vault accounts:", beforeVaultAccounts.length, "accounts");
+        // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from vault remaining accounts
+        const vaultCpiRemainingAccounts = beforeVaultAccounts.filter((account) => account.pubkey.toBase58() !== spl_token_1.TOKEN_PROGRAM_ID.toBase58());
+        // Log vault accounts after filtering
+        console.log("After filtering vault accounts:", vaultCpiRemainingAccounts.length, "accounts");
+        // Log market accounts before filtering
+        const beforeMarketAccounts = [...this.cpiAccounts.depositSy];
+        console.log("Before filtering market accounts:", beforeMarketAccounts.length, "accounts");
+        // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from market remaining accounts
+        const marketCpiRemainingAccounts = beforeMarketAccounts.filter((account) => account.pubkey.toBase58() !== spl_token_1.TOKEN_PROGRAM_ID.toBase58() &&
+            account.pubkey.toBase58() !== anchor_1.web3.SystemProgram.programId.toBase58() &&
+            account.pubkey.toBase58() !== this.selfAddress.toBase58());
+        // Log market accounts after filtering
+        console.log("After filtering market accounts:", marketCpiRemainingAccounts.length, "accounts");
+        // These remaining accounts can be in any order, and they can be unique-ified
+        const unorderedRemainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...vaultCpiRemainingAccounts,
+            ...marketCpiRemainingAccounts,
+        ]);
+        const allRemainingAccounts = [...mintSyRemAccounts, ...unorderedRemainingAccounts];
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor });
+        const ix = await this.coreProgram.methods
+            .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length)
+            .accountsStrict({
+            depositor,
+            authority: this.vault.authority,
+            vault: this.vault.selfAddress,
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenLpDst: tokenLpDepositor,
+            mintLp: this.mintLp,
+            escrowSy: this.vault.escrowSy,
+            escrowYt: this.vault.escrowYt,
+            tokenSyDepositor,
+            tokenYtDepositor,
+            tokenPtDepositor,
+            mintYt: this.vault.mintYt,
+            mintPt: this.vault.mintPt,
+            userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner: depositor }),
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            marketAddressLookupTable: this.addressLookupTable,
+            vaultAddressLookupTable: this.vault.addressLookupTable,
+            vaultRobotYieldPosition: this.vault.state.yieldPositonAddress,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+            lpPosition,
+            tokenLpEscrow: this.tokenLpEscrow,
+        })
+            .remainingAccounts(allRemainingAccounts)
+            .instruction();
+        console.log("ix accounts length", ix.keys.length);
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx, tokenLpDepositorAtaIx],
+        };
+    }
+    async ixProvideLiquidityBase({ depositor, amountBase, minLpOut, externalPtToBuy, externalSyConstraint, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }) {
+        tokenSyDepositor = tokenSyDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtDepositor = tokenYtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtDepositor = tokenPtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseDepositor =
+            tokenBaseDepositor ||
+                (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram);
+        tokenLpDepositor = tokenLpDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenSyDepositor, depositor, this.mintSy);
+        const tokenYtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenYtDepositor, depositor, this.mintYt);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenPtDepositor, depositor, this.mintPt);
+        const tokenBaseAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenBaseDepositor, depositor, this.flavor.mintBase, this.flavor.baseTokenProgram);
+        const tokenLpAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenLpDepositor, depositor, this.mintLp);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.depositSy,
+            ...this.cpiAccounts.getPositionState,
+        ]);
+        const mintSyIx = await this.flavor.ixMintSy({
+            amountBase: "0",
+            depositor,
+            depositorBaseTokenAccount: tokenBaseDepositor,
+            depositorSyTokenAccount: tokenSyDepositor,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        const ix = await this.coreProgram.methods
+            .wrapperProvideLiquidityBase(new anchor_2.BN(amountBase.toString()), new anchor_2.BN(minLpOut.toString()), mintSyRemAccounts.length, new anchor_2.BN(externalPtToBuy.toString()), new anchor_2.BN(externalSyConstraint.toString()))
+            .accountsStrict({
+            depositor,
+            lpPosition,
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenLpDst: tokenLpDepositor,
+            mintLp: this.mintLp,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenLpEscrow: this.tokenLpEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenPtDepositor,
+            tokenSyDepositor,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
+        };
+    }
+    async ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, tokenSyDepositor, tokenYtDepositor, tokenPtDepositor, tokenBaseDepositor, tokenLpDepositor, }) {
+        tokenSyDepositor = tokenSyDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtDepositor = tokenYtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtDepositor = tokenPtDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseDepositor =
+            tokenBaseDepositor ||
+                (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram);
+        tokenLpDepositor = tokenLpDepositor || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenSyDepositor, depositor, this.mintSy);
+        const tokenYtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenYtDepositor, depositor, this.mintYt);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenPtDepositor, depositor, this.mintPt);
+        const tokenLpAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(depositor, tokenLpDepositor, depositor, this.mintLp);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.depositSy,
+            ...this.cpiAccounts.getPositionState,
+        ]);
+        const mintSyIx = await this.flavor.ixMintSy({
+            amountBase: "0",
+            depositor,
+            depositorBaseTokenAccount: tokenBaseDepositor,
+            depositorSyTokenAccount: tokenSyDepositor,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        const ix = await this.coreProgram.methods
+            .wrapperProvideLiquidityClassic(new anchor_2.BN(amountBase.toString()), new anchor_2.BN(amountPt.toString()), new anchor_2.BN(minLpOut.toString()), mintSyRemAccounts.length)
+            .accountsStrict({
+            depositor,
+            lpPosition,
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenLpDst: tokenLpDepositor,
+            mintLp: this.mintLp,
+            syProgram: this.syProgram,
+            tokenLpEscrow: this.tokenLpEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenPtDepositor,
+            tokenSyDepositor,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenLpAtaIx],
+        };
+    }
+    async ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, tokenSyWithdrawer, tokenYtWithdrawer, tokenPtWithdrawer, tokenBaseWithdrawer, tokenLpWithdrawer, }) {
+        tokenSyWithdrawer = tokenSyWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtWithdrawer = tokenYtWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtWithdrawer = tokenPtWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseWithdrawer =
+            tokenBaseWithdrawer ||
+                (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        tokenLpWithdrawer = tokenLpWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyWithdrawer, owner, this.mintSy);
+        const tokenYtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenYtWithdrawer, owner, this.mintYt);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtWithdrawer, owner, this.mintPt);
+        const tokenBaseAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseWithdrawer, owner, this.flavor.mintBase, this.flavor.baseTokenProgram);
+        const tokenLpAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenLpWithdrawer, owner, this.mintLp);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.withdrawSy,
+            ...this.cpiAccounts.getPositionState,
+        ]);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: owner,
+            redeemerBaseTokenAccount: tokenBaseWithdrawer,
+            redeemerSyTokenAccount: tokenSyWithdrawer,
+        });
+        const redeemSyRemAccounts = redeemSyIx.keys;
+        const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate;
+        const ix = await this.coreProgram.methods
+            .wrapperWithdrawLiquidity(new anchor_2.BN(amountLp.toString()), new anchor_2.BN(minSyOut.toFixed(0).toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenLpSrc: tokenLpWithdrawer,
+            lpPosition,
+            marketAddressLookupTable: this.addressLookupTable,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+            syProgram: this.syProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenLpEscrow: this.tokenLpEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenPtWithdrawer,
+            tokenSyWithdrawer,
+            mintLp: this.mintLp,
+            withdrawer: owner,
+        })
+            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
+        };
+    }
+    async ixWithdrawLiquidityClassic({ owner, amountLp, minBaseOut, tokenSyWithdrawer, tokenYtWithdrawer, tokenPtWithdrawer, tokenBaseWithdrawer, tokenLpWithdrawer, }) {
+        tokenSyWithdrawer = tokenSyWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenYtWithdrawer = tokenYtWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenPtWithdrawer = tokenPtWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        tokenBaseWithdrawer =
+            tokenBaseWithdrawer ||
+                (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        tokenLpWithdrawer = tokenLpWithdrawer || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintLp, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyWithdrawer, owner, this.mintSy);
+        const tokenYtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenYtWithdrawer, owner, this.mintYt);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtWithdrawer, owner, this.mintPt);
+        const tokenBaseAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseWithdrawer, owner, this.flavor.mintBase, this.flavor.baseTokenProgram);
+        const tokenLpAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenLpWithdrawer, owner, this.mintLp);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiAccounts.withdrawSy,
+            ...this.cpiAccounts.getPositionState,
+        ]);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: owner,
+            redeemerBaseTokenAccount: tokenBaseWithdrawer,
+            redeemerSyTokenAccount: tokenSyWithdrawer,
+        });
+        const redeemSyRemAccounts = redeemSyIx.keys;
+        const ixn = await this.coreProgram.methods
+            .wrapperWithdrawLiquidityClassic(new anchor_2.BN(amountLp.toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenLpSrc: tokenLpWithdrawer,
+            lpPosition,
+            marketAddressLookupTable: this.addressLookupTable,
+            eventAuthority: this.vault.eventAuthority,
+            program: this.coreProgram.programId,
+            syProgram: this.syProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenLpEscrow: this.tokenLpEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenPtWithdrawer,
+            tokenSyWithdrawer,
+            mintLp: this.mintLp,
+            withdrawer: owner,
+        })
+            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ixn, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
+        };
+    }
+    async claimFarmEmissions({ owner, mint, tokenProgram, tokenDst, }) {
+        tokenDst = tokenDst || (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, true, tokenProgram);
+        const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner });
+        const tokenFarm = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, this.selfAddress, true, tokenProgram);
+        const tokenAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenDst, owner, mint);
+        const ix = await this.coreProgram.methods
+            .claimFarmEmissions({ all: {} })
+            .accountsStrict({
+            market: this.selfAddress,
+            lpPosition,
+            mint,
+            tokenFarm,
+            owner,
+            tokenDst,
+            tokenProgram,
+            eventAuthority: this.eventAuthority,
+            program: this.coreProgram.programId,
+        })
+            .instruction();
+        return {
+            ixs: [ix],
+            setupIxs: [tokenAtaIx],
+        };
+    }
+    async ixAddStandaloneEmission({ signer, emissionMint, emissionTokenProgram = spl_token_1.TOKEN_PROGRAM_ID, altAddresses, cpiAccounts, }) {
+        const altUtil = (0, altUtil_1.extendAddressLookupTable)(altAddresses, cpiAccounts);
+        const tokenEmission = (0, spl_token_1.getAssociatedTokenAddressSync)(emissionMint, this.selfAddress, true, emissionTokenProgram);
+        const ix = await this.coreProgram.methods
+            .addMarketEmission(altUtil.cpiAccountIndexes)
+            .accountsStrict({
+            market: this.selfAddress,
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            feePayer: signer,
+            mintNew: emissionMint,
+            signer,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenEmission,
+            tokenProgram: emissionTokenProgram,
+        })
+            .instruction();
+        return {
+            extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
+            addMarketEmissionIx: ix,
+        };
+    }
+    async addFarm({ signer, farmMint, farmRewardTokenProgram, emissionsRate, untilTimestamp, farmRewardSrc, feePayer, }) {
+        feePayer = feePayer || signer;
+        const farmRewardEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmRewardTokenProgram);
+        farmRewardSrc = farmRewardSrc || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmRewardTokenProgram);
+        const ix = await this.coreProgram.methods
+            .addFarm(new anchor_2.BN(emissionsRate), untilTimestamp)
+            .accountsStrict({
+            adminState: (0, utils_1.getExponentAdminStatePda)(),
+            market: this.selfAddress,
+            feePayer,
+            signer,
+            mintNew: farmMint,
+            tokenFarm: farmRewardEscrow,
+            tokenProgram: farmRewardTokenProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenSource: farmRewardSrc,
+        })
+            .instruction();
+        return {
+            ixs: [ix],
+        };
+    }
+    /** Calculate available liquidity for PT trades
+     * @param is_buy - true if buying PT with SY, false if selling PT for SY
+     * @param size_pt - amount of PT to trade (in PT decimals)
+     * @returns amount of PT that can be traded given current liquidity
+     */
+    liquidityAvailable(is_buy, size_pt) {
+        const calc = this.marketCalculator();
+        if (is_buy) {
+            // When buying PT, we're limited by SY liquidity
+            // Convert PT amount to SY using current price
+            const syNeeded = Number(size_pt) * calc.exchangeRate;
+            // Available SY in the market
+            const syAvailable = Number(this.syBalance);
+            if (syNeeded <= syAvailable) {
+                return size_pt;
+            }
+            else {
+                // Calculate max PT that can be bought with available SY
+                return BigInt(Math.floor(syAvailable / calc.exchangeRate));
+            }
+        }
+        else {
+            // When selling PT, we're limited by PT liquidity in the market
+            const ptAvailable = this.ptBalance;
+            if (size_pt <= ptAvailable) {
+                return size_pt;
+            }
+            else {
+                return ptAvailable;
+            }
+        }
+    }
+}
+exports.Market = Market;
+function toJson(m) {
+    const c = m.marketCalculator();
+    return {
+        treasurySyTokenAccount: m.state.tokenFeeTreasurySy.toBase58(),
+        address: m.selfAddress.toBase58(),
+        addressLookupTable: m.addressLookupTable.toBase58(),
+        tokenSyEscrow: m.tokenSyEscrow.toBase58(),
+        tokenPtEscrow: m.tokenPtEscrow.toBase58(),
+        tokenLpEscrow: m.tokenLpEscrow.toBase58(),
+        lpSupply: m.state.lpSupply.toString(),
+        syProgram: m.state.syProgram.toBase58(),
+        mintPt: m.state.mintPt.toBase58(),
+        mintSy: m.state.mintSy.toBase58(),
+        mintLp: m.state.mintLp.toBase58(),
+        feeTreasurySyBps: m.state.feeTreasurySyBps,
+        ptBalance: m.state.ptBalance.toString(),
+        syBalance: m.state.syBalance.toString(),
+        currentSyRate: m.flavor.currentSyExchangeRate,
+        expirationTs: m.state.expirationTs,
+        expirationDate: new Date(m.state.expirationTs * 1000).toISOString(),
+        lnFeeRateRoot: m.state.lnFeeRateRoot,
+        rateScalarRoot: m.state.rateScalarRoot,
+        lastLnImpliedRate: m.state.lastLnImpliedRate,
+        currentPtPriceInSy: m.currentPtPriceInSy,
+        currentPtPriceInAsset: m.currentPtPriceInAsset,
+        secondsRemaining: m.secondsRemaining,
+        proportionPtInAsset: c.proportionPtInAsset,
+        proportionPtInSy: c.proportionPtInSy,
+        currentFeeRate: c.feeRate,
+        currentRateScalar: c.rateScalar,
+        currentRateAnchor: c.findRateAnchor(),
+        cpiAccounts: (0, exponent_ix_2.serializeCpiAccountsRaw)(m.cpiAccounts),
+        emissions: {
+            trackers: m.marketEmissions.trackers.map((e) => ({
+                tokenEscrow: e.tokenEscrow.toBase58(),
+                lpShareIndex: e.lpShareIndex,
+                lastSeenStaged: e.lastSeenStaged,
+            })),
+        },
+        ptApr: m.ptApr,
+        lpEscrowAmount: m.state.lpEscrowAmount.toString(),
+        maxLpSupply: m.state.maxLpSupply.toString(),
+        liquidityNetBalanceLimits: {
+            windowStartTimestamp: m.state.liquidityNetBalanceLimits.windowStartTimestamp,
+            windowStartNetBalance: m.state.liquidityNetBalanceLimits.windowStartNetBalance.toString(),
+            maxNetBalanceChangeNegativePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+            maxNetBalanceChangePositivePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+            windowDurationSeconds: m.state.liquidityNetBalanceLimits.windowDurationSeconds,
+        },
+        lpFarm: {
+            lastSeenTimestamp: m.state.lpFarm.lastSeenTimestamp,
+            farmEmissions: m.state.lpFarm.farmEmissions.map((e) => ({
+                mint: e.mint.toBase58(),
+                tokenRate: e.tokenRate.toString(),
+                expiryTimestamp: e.expiryTimestamp,
+                index: precise_number_1.PreciseNumber.fromRaw(e.index[0]).valueString,
+            })),
+        },
+    };
+}
+//# sourceMappingURL=market.js.map