@exponent-labs/exponent-sdk 0.1.7 → 0.1.8

package/build/marketThree.js

@@ -0,0 +1,1415 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketThree = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const exponent_clmm_idl_1 = require("@exponent-labs/exponent-clmm-idl");
+const exponent_clmm_pda_1 = require("@exponent-labs/exponent-clmm-pda");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+const exponent_idl_1 = require("@exponent-labs/exponent-idl");
+const exponent_pda_1 = require("@exponent-labs/exponent-pda");
+const market_three_math_1 = require("@exponent-labs/market-three-math");
+const addressLookupTableUtil_1 = require("./addressLookupTableUtil");
+const flavors_1 = require("./flavors");
+const market_1 = require("./market");
+const syPosition_1 = require("./syPosition");
+const utils_1 = require("./utils");
+const vault_1 = require("./vault");
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+class MarketThree {
+    state;
+    selfAddress;
+    env;
+    connection;
+    clmmProgram;
+    coreProgram;
+    xponPda;
+    pda;
+    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.pda = new exponent_clmm_pda_1.ExponentCLMMPDA();
+        const mockWallet = new market_1.MyWallet(anchor_1.web3.Keypair.generate());
+        this.clmmProgram = new anchor_1.Program(exponent_clmm_idl_1.IDL, new anchor_1.AnchorProvider(connection, mockWallet));
+        this.coreProgram = new anchor_1.Program(exponent_idl_1.IDL, new anchor_1.AnchorProvider(connection, new market_1.MyWallet(anchor_1.web3.Keypair.generate())));
+    }
+    static async load(env, connection, address, vault, ticks, options = {}) {
+        const fetcher = new exponent_fetcher_1.ExponentFetcher({ connection });
+        const fetchedMarket = await fetcher.fetchMarketThree(address);
+        const [alt, loadedVault, loadedTicks] = await Promise.all([
+            (0, addressLookupTableUtil_1.fetchAddressLookupTable)(connection, fetchedMarket.addressLookupTable),
+            vault || vault_1.Vault.load(env, connection, fetchedMarket.vault, options),
+            ticks || fetcher.fetchMarketThreeTicks(fetchedMarket.ticks),
+        ]);
+        const cpiSyAccounts = (0, addressLookupTableUtil_1.makeCpiAccountMetaLists)(alt, fetchedMarket.cpiSyAccounts);
+        const cpiCoreAccounts = (0, addressLookupTableUtil_1.makeMarketCoreCpiAccountMetaLists)(alt, fetchedMarket.cpiCoreAccounts);
+        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, options.syConfig);
+                default:
+                    throw new Error(`Unknown flavor: ${loadedVault.flavor}`);
+            }
+        })();
+        const syPosition = await (0, syPosition_1.makeSyPosition)(fetcher, flavor, fetchedMarket.syProgram, address);
+        //? Assuming that the owner is the same for both accounts feeAccounts
+        const treasuryFeeOwner = await MarketThree.fetchTreasuryFeeOwner(fetchedMarket.tokenFeeTreasuryPt, connection);
+        const state = {
+            ...fetchedMarket,
+            vault: loadedVault,
+            flavor,
+            ticks: loadedTicks,
+            syPosition,
+            cpiSyAccounts,
+            cpiCoreAccounts,
+            ticksAccount: fetchedMarket.ticks,
+            treasuryFeeOwner,
+        };
+        return new MarketThree(state, address, env, connection);
+    }
+    async reload(connection = this.connection) {
+        const market = await MarketThree.load(this.env, connection, this.selfAddress);
+        this.state = market.state;
+        return market;
+    }
+    get vault() {
+        return this.state.vault;
+    }
+    get flavor() {
+        return this.state.flavor;
+    }
+    get lpBalance() {
+        return this.state.financials.liquidityBalance;
+    }
+    get syBalance() {
+        return this.state.financials.syBalance;
+    }
+    get ptBalance() {
+        return this.state.financials.ptBalance;
+    }
+    get mintSy() {
+        return this.state.mintSy;
+    }
+    get mintPt() {
+        return this.state.mintPt;
+    }
+    get statusFlags() {
+        return this.state.statusFlags;
+    }
+    get mintYt() {
+        return this.state.mintYt;
+    }
+    get addressLookupTable() {
+        return this.state.addressLookupTable;
+    }
+    get syProgram() {
+        return this.state.syProgram;
+    }
+    get cpiSyAccounts() {
+        return this.state.cpiSyAccounts;
+    }
+    get cpiCoreAccounts() {
+        return this.state.cpiCoreAccounts;
+    }
+    get marketEmissions() {
+        return this.state.emissions;
+    }
+    get ticksKey() {
+        return this.state.ticksAccount;
+    }
+    get corePda() {
+        return new exponent_pda_1.ExponentPDA();
+    }
+    get coreEventAuthority() {
+        return (0, utils_1.emitEventAuthority)(this.state.exponentCoreProgram);
+    }
+    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;
+    }
+    /** Pass-through YT account owned by the market */
+    get tokenYtEscrow() {
+        return this.state.tokenYtEscrow;
+    }
+    /** SY account that holds treasury SY fees from PT trading */
+    get tokenFeeTreasurySy() {
+        return this.state.tokenFeeTreasurySy;
+    }
+    /** PT account that holds treasury PT fees from PT trading */
+    get tokenFeeTreasuryPt() {
+        return this.state.tokenFeeTreasuryPt;
+    }
+    /** Market liquidity for PT */
+    get tokenPtEscrow() {
+        return this.state.tokenPtEscrow;
+    }
+    get currentSyExchangeRate() {
+        return this.flavor.currentSyExchangeRate;
+    }
+    /** Special account for event emit self-cpi */
+    get eventAuthority() {
+        return (0, utils_1.emitEventAuthority)(this.clmmProgram.programId);
+    }
+    get secondsRemaining() {
+        const timeNow = Date.now() / 1000;
+        return Math.max(0, Math.round(Number(this.state.financials.expirationTs) - timeNow));
+    }
+    /** Annualize a rate given the number of seconds remaining until maturity */
+    static annualize(rate, secondsRemaining) {
+        return (rate * SECONDS_PER_YEAR) / secondsRemaining;
+    }
+    static annualizeApy(rate, secondsRemaining) {
+        return (1 + rate) ** (SECONDS_PER_YEAR / secondsRemaining) - 1;
+    }
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+    get feeTreasuryBps() {
+        return this.state.configurationOptions.treasuryFeeBps;
+    }
+    /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+    get feeTreasuryRate() {
+        return this.feeTreasuryBps / 10_000;
+    }
+    /** Get the owner of the treasury fee accounts: tokenFeeTreasuryPt & tokenFeeTreasurySy */
+    static async fetchTreasuryFeeOwner(tokenFeeTreasury, connection) {
+        const { owner } = await (0, spl_token_1.getAccount)(connection, tokenFeeTreasury);
+        return owner;
+    }
+    /** 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, depositor, lowerTickKey, upperTickKey, ptSrc: ptSrcParam, sySrc: sySrcParam, lpPosition: lpPositionParam, }) {
+        const tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+        const sySrc = sySrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ptSrc = ptSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const lpPosition = lpPositionParam || anchor_1.web3.Keypair.generate();
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const ix = await this.clmmProgram.methods
+            .depositLiquidity(convertApyToApyBp(lowerTickKey), convertApyToApyBp(upperTickKey), new anchor_1.BN(ptInIntent.toString()), new anchor_1.BN(syInIntent.toString()))
+            .accountsStrict({
+            depositor,
+            market: this.selfAddress,
+            tokenPtSrc: ptSrc,
+            tokenSySrc: sySrc,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenProgram,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            lpPosition: lpPosition.publicKey,
+            ticks: this.ticksKey,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return {
+            ix: ix,
+            signers: lpPosition,
+        };
+    }
+    /**
+     * 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, lpPosition, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, }) {
+        const ptDst = ptDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, withdrawer, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const syDst = syDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, 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 remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const ixs = await this.clmmProgram.methods
+            .withdrawLiquidity(new anchor_1.BN(lpIn.toString()), new anchor_1.BN(minPtOut.toString()), new anchor_1.BN(minSyOut.toString()))
+            .accountsStrict({
+            owner: withdrawer,
+            market: this.selfAddress,
+            tokenPtDst: ptDst,
+            tokenSyDst: syDst,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            lpPosition,
+            ticks: this.ticksKey,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx] };
+    }
+    async ixTradePt({ trader, traderAmount, outConstraint, swapDirection, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }) {
+        const tokenPt = tokenPtParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSy = tokenSyParam || (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 = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.withdrawSy,
+        ]);
+        let outConstraintOptional = outConstraint ? new anchor_1.BN(outConstraint.toString()) : null;
+        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .tradePt(new anchor_1.BN(traderAmount.toString()), swapDirection, outConstraintOptional, lnImpliedApyLimitOptional)
+            .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.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] };
+    }
+    async ixTradePtExactOut({ trader, amountOut, swapDirection, amountInConstraint, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }) {
+        const tokenPt = tokenPtParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenSy = tokenSyParam || (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 = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.withdrawSy,
+        ]);
+        const amountInConstraintOptional = amountInConstraint !== undefined ? new anchor_1.BN(amountInConstraint.toString()) : null;
+        const lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .tradePtExactOut(new anchor_1.BN(amountOut.toString()), swapDirection, amountInConstraintOptional, lnImpliedApyLimitOptional)
+            .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.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] };
+    }
+    /** 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, amountSy, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePt({
+            trader,
+            traderAmount: amountSy,
+            outConstraint: outConstraint,
+            swapDirection: { syToPt: {} },
+            tokenPt,
+            tokenSy,
+            lnImpliedApyLimit,
+        });
+    }
+    /**
+     * 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, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePt({
+            trader,
+            traderAmount: amountPt,
+            outConstraint: outConstraint,
+            swapDirection: { ptToSy: {} },
+            tokenPt,
+            tokenSy,
+            lnImpliedApyLimit,
+        });
+    }
+    /**
+     * Buy exact amount of PT with SY
+     *
+     * The trader specifies the exact amount of PT they want to receive
+     * The maxSyIn is the maximum amount of SY the trader is willing to spend
+     */
+    async ixBuyPtExactOut({ trader, amountPt, maxSyIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePtExactOut({
+            trader,
+            amountOut: amountPt,
+            amountInConstraint: maxSyIn,
+            swapDirection: { syToPt: {} },
+            tokenPt,
+            tokenSy,
+            lnImpliedApyLimit,
+        });
+    }
+    /**
+     * Sell PT for exact amount of SY
+     *
+     * The trader specifies the exact amount of SY they want to receive
+     * The maxPtIn is the maximum amount of PT the trader is willing to spend
+     */
+    async ixSellPtExactOut({ trader, amountSy, maxPtIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePtExactOut({
+            trader,
+            amountOut: amountSy,
+            amountInConstraint: maxPtIn,
+            swapDirection: { ptToSy: {} },
+            tokenPt,
+            tokenSy,
+            lnImpliedApyLimit,
+        });
+    }
+    /** 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: ytTraderParam, ptTrader: ptTraderParam, syTrader: syTraderParam, lnImpliedApyLimit, }) {
+        const syTrader = syTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ptTrader = ptTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ytTrader = ytTraderParam || (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.cpiCoreAccounts.stripSy;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.depositSy,
+            ...stripAccounts,
+        ]);
+        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .buyYt(new anchor_1.BN(maxSyIn.toString()), new anchor_1.BN(ytOut.toString()), lnImpliedApyLimitOptional)
+            .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,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            tokenYtEscrow: this.tokenYtEscrow,
+            exponentCoreProgram: this.state.exponentCoreProgram,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] };
+    }
+    /** 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: ytSrcParam, ptSrc: ptSrcParam, syDst: syDstParam, lnImpliedApyLimit, }) {
+        const syDst = syDstParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ptSrc = ptSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, trader, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const ytSrc = ytSrcParam || (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.cpiCoreAccounts.mergeSy;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiSyAccounts.depositSy,
+            ...mergeAccounts,
+        ]);
+        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .sellYt(new anchor_1.BN(ytIn.toString()), new anchor_1.BN(minSyOut.toString()), lnImpliedApyLimitOptional)
+            .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,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            tokenYtEscrow: this.tokenYtEscrow,
+            exponentCoreProgram: this.state.exponentCoreProgram,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] };
+    }
+    async ixModifyMarketSetting({ signer, adminAction }) {
+        return this.clmmProgram.methods
+            .modifyMarketSetting(adminAction)
+            .accountsStrict({
+            market: this.selfAddress,
+            signer,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /**
+     * Add a new farm to the market to distribute rewards to LP holders
+     *
+     * @param signer - The admin address that signs the transaction
+     * @param farmMint - The mint address of the farm reward token
+     * @param farmTokenProgram - The token program for the farm reward token
+     * @param emissionsRate - The rate of emissions per second (in token smallest units)
+     * @param untilTimestamp - Unix timestamp when the farm emissions should end
+     * @param farmTokenSrc - Optional source token account for the farm rewards (derived from signer if not provided)
+     * @param feePayer - Optional fee payer for account reallocation (defaults to signer)
+     */
+    async ixAddFarm({ signer, farmMint, farmTokenProgram, emissionsRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, feePayer: feePayerParam, }) {
+        const feePayer = feePayerParam || signer;
+        const farmTokenEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
+        const farmTokenSrc = farmTokenSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
+        const farmTokenEscrowAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(feePayer, farmTokenEscrow, this.selfAddress, farmMint, farmTokenProgram);
+        const ix = await this.clmmProgram.methods
+            .addFarm(new anchor_1.BN(emissionsRate.toString()), untilTimestamp)
+            .accountsStrict({
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            signer,
+            feePayer,
+            mintNew: farmMint,
+            tokenSource: farmTokenSrc,
+            tokenFarm: farmTokenEscrow,
+            tokenProgram: farmTokenProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+        })
+            .instruction();
+        return {
+            ixs: [ix],
+            setupIxs: [farmTokenEscrowAtaIx],
+        };
+    }
+    /**
+     * Modify an existing farm's emissions rate and/or expiration timestamp
+     *
+     * If the new parameters require more tokens than previously undistributed,
+     * additional tokens will be transferred from the signer's token account.
+     * If fewer tokens are needed, the surplus will be returned to the signer.
+     *
+     * @param signer - The admin address that signs the transaction
+     * @param farmMint - The mint address of the farm reward token
+     * @param farmTokenProgram - The token program for the farm reward token
+     * @param newRate - The new rate of emissions per second (in token smallest units)
+     * @param untilTimestamp - New unix timestamp when the farm emissions should end
+     * @param farmTokenSrc - Optional source/destination token account (derived from signer if not provided)
+     */
+    async ixModifyFarm({ signer, farmMint, farmTokenProgram, newRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, }) {
+        const farmTokenEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
+        const farmTokenSrc = farmTokenSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
+        const ix = await this.clmmProgram.methods
+            .modifyFarm(untilTimestamp, new anchor_1.BN(newRate.toString()))
+            .accountsStrict({
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            signer,
+            mint: farmMint,
+            tokenSource: farmTokenSrc,
+            tokenFarm: farmTokenEscrow,
+            tokenProgram: farmTokenProgram,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+        })
+            .instruction();
+        return {
+            ixs: [ix],
+        };
+    }
+    async ixWrapperBuyPt({ owner, minPtOut, baseIn, tokenSyTrader: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }) {
+        const tokenSyTrader = tokenSyTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtTrader = tokenPtTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseTrader = tokenBaseTraderParam ||
+            (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;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .buyPt(new anchor_1.BN(minPtOut.toString()), new anchor_1.BN(baseIn.toString()), lnImpliedApyLimitOptional, 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.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenFeeTreasuryPt: this.state.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+        })
+            .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: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenBaseTrader: tokenBaseTraderParam, lnImpliedApyLimit, }) {
+        const tokenSyTrader = tokenSyTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtTrader = tokenPtTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseTrader = tokenBaseTraderParam ||
+            (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;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiSyAccounts.withdrawSy,
+        ]);
+        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
+        const ix = await this.clmmProgram.methods
+            .sellPt(new anchor_1.BN(amount.toString()), new anchor_1.BN(minBaseOut.toString()), lnImpliedApyLimitOptional, 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.eventAuthority,
+            program: this.clmmProgram.programId,
+            ticks: this.ticksKey,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        })
+            .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: tokenSyTraderParam, tokenPtTrader: tokenPtTraderParam, tokenYtTrader: tokenYtTraderParam, tokenBaseTrader: tokenBaseTraderParam, }) {
+        const tokenSyTrader = tokenSyTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtTrader = tokenPtTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtTrader = tokenYtTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseTrader = tokenBaseTraderParam ||
+            (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 depositYtAccounts = await this.depositYtAccounts({
+            owner,
+            ytSrc: tokenYtTrader,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiCoreAccounts.stripSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const depositYtAccounts_until = mintSyRemAccounts.length + depositYtAccounts.keys.length;
+        const allRemainingAccounts = mintSyRemAccounts.concat(depositYtAccounts.keys).concat(remainingAccounts);
+        const ix1 = await this.clmmProgram.methods
+            .wrapperBuyYt(new anchor_1.BN(ytOut.toString()), new anchor_1.BN(maxBaseIn.toString()), mintSyRemAccounts.length, depositYtAccounts_until)
+            .accountsStrict({
+            buyer: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenYtTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            exponentCoreProgram: this.state.exponentCoreProgram,
+        })
+            .remainingAccounts(allRemainingAccounts)
+            .instruction();
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+        };
+    }
+    async ixWrapperSellYt({ owner, amount, minBaseOut, tokenBaseTrader: tokenBaseTraderParam, tokenSyTrader: tokenSyTraderParam, tokenYtTrader: tokenYtTraderParam, tokenPtTrader: tokenPtTraderParam, }) {
+        const tokenBaseTrader = tokenBaseTraderParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        const tokenSyTrader = tokenSyTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtTrader = tokenYtTraderParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtTrader = tokenPtTraderParam || (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.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiCoreAccounts.mergeSy,
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.depositSy,
+        ]);
+        const ix1 = await this.clmmProgram.methods
+            .wrapperSellYt(new anchor_1.BN(amount.toString()), new anchor_1.BN(minBaseOut.toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            seller: owner,
+            market: this.selfAddress,
+            tokenYtTrader,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenPtTrader,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenSyTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            exponentCoreProgram: this.state.exponentCoreProgram,
+        })
+            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [ix1, ...(await this.flavor.preIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+    async ixWrapperProvideLiquidity({ depositor, amountBase, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPosition: lpPositionParam, }) {
+        const tokenSyDepositor = tokenSyDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtDepositor = tokenYtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtDepositor = tokenPtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseDepositor = tokenBaseDepositorParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram);
+        const lpPosition = lpPositionParam || anchor_1.web3.Keypair.generate();
+        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 amountBaseBn = new anchor_1.BN(amountBase.toString());
+        const minLpOutBn = new anchor_1.BN(minLpOut.toString());
+        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;
+        const unorderedRemainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiCoreAccounts.stripSy,
+            ...this.cpiSyAccounts.depositSy,
+        ]);
+        const depositYtAccounts = await this.depositYtAccounts({
+            owner: depositor,
+            ytSrc: tokenYtDepositor,
+        });
+        const depositAccountsUntil = mintSyRemAccounts.length + depositYtAccounts.keys.length;
+        const allRemainingAccounts = [...mintSyRemAccounts, ...depositYtAccounts.keys, ...unorderedRemainingAccounts];
+        const ix = await this.clmmProgram.methods
+            .wrapperProvideLiquidity(convertApyToApyBp(lowerTickApy), convertApyToApyBp(upperTickApy), amountBaseBn, minLpOutBn, mintSyRemAccounts.length, depositAccountsUntil)
+            .accountsStrict({
+            depositor,
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyDepositor,
+            tokenYtDepositor,
+            tokenPtDepositor,
+            mintYt: this.vault.mintYt,
+            mintPt: this.vault.mintPt,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            marketAddressLookupTable: this.addressLookupTable,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            lpPosition: lpPosition.publicKey,
+            tokenYtEscrow: this.tokenYtEscrow,
+            ticks: this.ticksKey,
+            exponentCoreProgram: this.state.exponentCoreProgram,
+        })
+            .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 })),
+            ],
+            signers: [lpPosition],
+            setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx],
+        };
+    }
+    async ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, }) {
+        const tokenSyDepositor = tokenSyDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtDepositor = tokenYtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtDepositor = tokenPtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, depositor, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseDepositor = tokenBaseDepositorParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram);
+        const lpPosition = anchor_1.web3.Keypair.generate();
+        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 remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiCoreAccounts.stripSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const mintSyIx = await this.flavor.ixMintSy({
+            amountBase: "0",
+            depositor,
+            depositorBaseTokenAccount: tokenBaseDepositor,
+            depositorSyTokenAccount: tokenSyDepositor,
+        });
+        const mintSyRemAccounts = mintSyIx.keys;
+        const ix = await this.clmmProgram.methods
+            .wrapperProvideLiquidityClassic(convertApyToApyBp(lowerTickApy), convertApyToApyBp(upperTickApy), new anchor_1.BN(amountBase.toString()), new anchor_1.BN(amountPt.toString()), new anchor_1.BN(minLpOut.toString()), mintSyRemAccounts.length)
+            .accountsStrict({
+            depositor,
+            lpPosition: lpPosition.publicKey,
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            syProgram: this.syProgram,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenPtDepositor,
+            tokenSyDepositor,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: this.clmmProgram.programId,
+            ticks: this.ticksKey,
+        })
+            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+            .instruction();
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            signers: [lpPosition],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+        };
+    }
+    async ixWithdrawLiquidityToBase({ owner, amountLp, minBaseOut, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }) {
+        const tokenSyWithdrawer = tokenSyWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtWithdrawer = tokenYtWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtWithdrawer = tokenPtWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseWithdrawer = tokenBaseWithdrawerParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        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 remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.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.clmmProgram.methods
+            .wrapperWithdrawLiquidity(new anchor_1.BN(amountLp.toString()), new anchor_1.BN(minSyOut.toFixed(0).toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            lpPosition,
+            marketAddressLookupTable: this.addressLookupTable,
+            eventAuthority: this.eventAuthority,
+            syProgram: this.syProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenPtWithdrawer,
+            tokenSyWithdrawer,
+            withdrawer: owner,
+            ticks: this.ticksKey,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            program: this.clmmProgram.programId,
+        })
+            .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],
+        };
+    }
+    async ixWithdrawLiquidityClassic({ owner, amountLp, lpPosition, tokenSyWithdrawer: tokenSyWithdrawerParam, tokenYtWithdrawer: tokenYtWithdrawerParam, tokenPtWithdrawer: tokenPtWithdrawerParam, tokenBaseWithdrawer: tokenBaseWithdrawerParam, }) {
+        const tokenSyWithdrawer = tokenSyWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtWithdrawer = tokenYtWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtWithdrawer = tokenPtWithdrawerParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseWithdrawer = tokenBaseWithdrawerParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        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 remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const redeemSyIx = await this.flavor.ixRedeemSy({
+            amountSy: "0",
+            redeemer: owner,
+            redeemerBaseTokenAccount: tokenBaseWithdrawer,
+            redeemerSyTokenAccount: tokenSyWithdrawer,
+        });
+        const redeemSyRemAccounts = redeemSyIx.keys;
+        const ixn = await this.clmmProgram.methods
+            .wrapperWithdrawLiquidityClassic(new anchor_1.BN(amountLp.toString()), redeemSyRemAccounts.length)
+            .accountsStrict({
+            market: this.selfAddress,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            lpPosition,
+            marketAddressLookupTable: this.addressLookupTable,
+            eventAuthority: this.eventAuthority,
+            syProgram: this.syProgram,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            tokenPtWithdrawer,
+            tokenSyWithdrawer,
+            withdrawer: owner,
+            ticks: this.ticksKey,
+            program: this.clmmProgram.programId,
+        })
+            .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],
+        };
+    }
+    async getUserLpPositions(owner, market) {
+        const lpPositions = await (await this.clmmProgram.account.lpPosition.all()).filter((lpPos) => lpPos.account.owner.toString() === owner.toString() && lpPos.account.market.toString() === market.toString());
+        return {
+            lpPositions: [lpPositions],
+        };
+    }
+    // async ixCloseMarket({ owner }: { owner: web3.PublicKey }) {
+    //   const ixn = await this.clmmProgram.methods
+    //     .closeMarket()
+    //     .accountsStrict({
+    //       market: this.selfAddress,
+    //       systemProgram: web3.SystemProgram.programId,
+    //       payer: owner,
+    //       ticks: this.ticksKey,
+    //       program: this.clmmProgram.programId,
+    //       eventAuthority: this.eventAuthority,
+    //       rent: web3.SYSVAR_RENT_PUBKEY,
+    //     })
+    //     .instruction()
+    //   return {
+    //     ixs: [ixn],
+    //   }
+    // }
+    async ixMarketAccureEmissions({ owner, lpPosition }) {
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([...this.cpiSyAccounts.getPositionState]);
+        const ixn = await this.clmmProgram.methods
+            .marketAccrueEmission()
+            .accountsStrict({
+            market: this.selfAddress,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            ticks: this.ticksKey,
+            program: this.clmmProgram.programId,
+            eventAuthority: this.eventAuthority,
+            lpPosition,
+            owner,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return {
+            ixs: [ixn],
+        };
+    }
+    /**
+     * Calculate the current price per unit of liquidity (principal only) for a tick range.
+     * Mirrors the on-chain `liquidity_unit_price_in_asset` helper but performs the
+     * principal aggregation client-side using the fetched ticks account.
+     *
+     * @param lowerTickKey - Inclusive tick key (APY in parts-per-million) for the left boundary
+     * @param upperTickKey - Exclusive tick key for the right boundary
+     * @param ticksOverride - Optional ticks account (defaults to the instance state)
+     * @param syExchangeRateOverride - Optional SY exchange rate (defaults to current flavor rate)
+     * @returns Price per unit of liquidity in underlying asset terms (principal only)
+     */
+    liquidityUnitPriceInAsset({ lowerTickKey, upperTickKey, ticksOverride, syExchangeRateOverride, }) {
+        if (lowerTickKey >= upperTickKey) {
+            throw new Error("lowerTickKey must be less than upperTickKey");
+        }
+        const ticksAccount = ticksOverride ?? this.state.ticks;
+        if (!ticksAccount) {
+            throw new Error("Ticks account data is unavailable");
+        }
+        const relevantIntervals = ticksAccount.ticksTree.filter((tick) => tick.apyBasePoints >= lowerTickKey && tick.apyBasePoints < upperTickKey);
+        if (relevantIntervals.length === 0) {
+            return 0;
+        }
+        let totalPrincipalPt = 0n;
+        let totalPrincipalSy = 0n;
+        let totalShareSupply = 0n;
+        for (const interval of relevantIntervals) {
+            totalPrincipalPt += interval.principalPt;
+            totalPrincipalSy += interval.principalSy;
+            totalShareSupply += interval.principalShareSupply;
+        }
+        if (totalShareSupply === 0n) {
+            return 0;
+        }
+        const timeFactor = this.secondsRemaining / SECONDS_PER_YEAR;
+        const ptAssetValuePerToken = Math.exp(-timeFactor * ticksAccount.currentSpotPrice);
+        const syExchangeRate = syExchangeRateOverride ?? this.currentSyExchangeRate;
+        const principalPtValue = new decimal_js_1.default(totalPrincipalPt.toString()).mul(ptAssetValuePerToken);
+        const principalSyValue = new decimal_js_1.default(totalPrincipalSy.toString()).mul(syExchangeRate);
+        const principalValue = principalPtValue.plus(principalSyValue);
+        return principalValue.div(new decimal_js_1.default(totalShareSupply.toString())).toNumber();
+    }
+    /**
+     * Compute fee growth inside a tick range using Uniswap V3 formula
+     *
+     * @param lowerTick - Lower tick boundary
+     * @param upperTick - Upper tick boundary
+     * @param feeGlobalPt - Optional: Override global PT fees (for historical calculations)
+     * @param feeGlobalSy - Optional: Override global SY fees (for historical calculations)
+     * @returns Object with inside_sy and inside_pt fee growth values
+     */
+    static computeFeeInsideForRange({ currentTickPrice, lowerTickPrice, upperTickPrice, feeGrowthIndexGlobalPt, feeGrowthIndexGlobalSy, lowerTickOutsidePt, lowerTickOutsideSy, upperTickOutsidePt, upperTickOutsideSy, }) {
+        // Uniswap V3 formula for computing fee inside a range
+        let insideSy;
+        let insidePt;
+        if (currentTickPrice < lowerTickPrice) {
+            // Price below range: inside = outside(lower) - outside(upper)
+            insideSy = lowerTickOutsideSy - upperTickOutsideSy;
+            insidePt = lowerTickOutsidePt - upperTickOutsidePt;
+        }
+        else if (currentTickPrice >= upperTickPrice) {
+            // Price above range: inside = outside(upper) - outside(lower)
+            insideSy = upperTickOutsideSy - lowerTickOutsideSy;
+            insidePt = upperTickOutsidePt - lowerTickOutsidePt;
+        }
+        else {
+            // Price in range: inside = global - outside(lower) - outside(upper)
+            insideSy = feeGrowthIndexGlobalSy - lowerTickOutsideSy - upperTickOutsideSy;
+            insidePt = feeGrowthIndexGlobalPt - lowerTickOutsidePt - upperTickOutsidePt;
+        }
+        return { insideSy, insidePt };
+    }
+    /**
+     * Calculate claimable fees for a position
+     * Uses Q64.64 fixed-point math: tokens = floor((L * Δindex) >> 64)
+     *
+     * @param lpBalance - Position's liquidity balance
+     * @param feeInsideLastSy - Last snapshot of inside SY fee growth
+     * @param feeInsideLastPt - Last snapshot of inside PT fee growth
+     * @param currentInsideSy - Current inside SY fee growth
+     * @param currentInsidePt - Current inside PT fee growth
+     * @param tokensOwedSy - Previously owed SY fees
+     * @param tokensOwedPt - Previously owed PT fees
+     * @returns Object with claimable and total fees
+     */
+    static calculateClaimableFees({ lpBalance, feeInsideLastSy, feeInsideLastPt, currentInsideSy, currentInsidePt, tokensOwedSy, tokensOwedPt, }) {
+        // Calculate delta (growth since last snapshot)
+        const deltaSy = currentInsideSy > feeInsideLastSy ? currentInsideSy - feeInsideLastSy : 0n;
+        const deltaPt = currentInsidePt > feeInsideLastPt ? currentInsidePt - feeInsideLastPt : 0n;
+        // Calculate claimable fees using Q64.64 math: tokens = floor((L * Δindex) >> 64)
+        const claimableSy = (lpBalance * deltaSy) >> 64n;
+        const claimablePt = (lpBalance * deltaPt) >> 64n;
+        //? TotalPt and TotalSy don't make sense here because tokensOwedSy and tokensOwedPt are always 0
+        // Calculate totals
+        const totalSy = claimableSy + tokensOwedSy;
+        const totalPt = claimablePt + tokensOwedPt;
+        return {
+            claimableSy,
+            claimablePt,
+            tokensOwedSy,
+            tokensOwedPt,
+            totalSy,
+            totalPt,
+        };
+    }
+    /**
+     * Calculate historical fee APY for a tick range
+     *
+     * @param feeGrowthDeltaSy - Change in global SY fee growth over period
+     * @param feeGrowthDeltaPt - Change in global PT fee growth over period
+     * @param avgLiquidity - Average liquidity in the range during period
+     * @param hoursElapsed - Number of hours in the period
+     * @returns Object with fee APY metrics
+     */
+    static calculateHistoricalFeeApy({ feeGrowthDeltaSy, feeGrowthDeltaPt, avgLiquidity, hoursElapsed, }) {
+        if (avgLiquidity === 0n || hoursElapsed === 0) {
+            return {
+                feeApySy: 0,
+                feeApyPt: 0,
+                feeApyTotal: 0,
+                totalFeesSy: 0n,
+                totalFeesPt: 0n,
+            };
+        }
+        // Calculate total fees earned in the period using Q64.64 math
+        const totalFeesSy = (feeGrowthDeltaSy * avgLiquidity) >> 64n;
+        const totalFeesPt = (feeGrowthDeltaPt * avgLiquidity) >> 64n;
+        // Annualization factor (hours in a year / hours elapsed)
+        const hoursPerYear = 8760;
+        const annualizationFactor = hoursPerYear / hoursElapsed;
+        // Calculate APY as: (fees / avg_liquidity) * annualization_factor * 100
+        const feeApySy = (Number((totalFeesSy * 10000n) / avgLiquidity) / 100) * annualizationFactor;
+        const feeApyPt = (Number((totalFeesPt * 10000n) / avgLiquidity) / 100) * annualizationFactor;
+        const feeApyTotal = feeApySy + feeApyPt;
+        return {
+            feeApySy,
+            feeApyPt,
+            feeApyTotal,
+            totalFeesSy,
+            totalFeesPt,
+        };
+    }
+    async depositYtAccounts({ owner, ytSrc: ytSrcParam, }) {
+        const ytSrc = ytSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const userYieldPosition = this.corePda.yieldPosition({ vault: this.state.vault.selfAddress, owner });
+        const yieldPosition = this.corePda.vaultYieldPosition({ vault: this.state.vault.selfAddress });
+        const escrowYt = this.corePda.escrowYt({ vault: this.state.vault.selfAddress });
+        const mainAccounts = {
+            depositor: owner,
+            ytSrc,
+            vault: this.state.vault.selfAddress,
+            userYieldPosition: userYieldPosition,
+            escrowYt: escrowYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.state.syProgram,
+            addressLookupTable: this.vault.addressLookupTable,
+            yieldPosition,
+            systemProgram: anchor_1.web3.SystemProgram.programId,
+            eventAuthority: this.coreEventAuthority,
+            program: this.state.exponentCoreProgram,
+        };
+        const remainingAccounts = this.cpiSyAccounts.getSyState;
+        const depositIx = await this.coreProgram.methods
+            .depositYt(new anchor_1.BN(0))
+            .accountsStrict(mainAccounts)
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+        return depositIx;
+    }
+    static calcEstimatedYieldForPosition(marketSnapshotDataCurrent, marketSnapshotDataHistory, lowerPricePercentage, upperPricePercentage, baseTokenAmount) {
+        //? Prices in format of 1 + percentage / 100
+        const lowerPrice = 1 + lowerPricePercentage / 100;
+        //? Prices in format of 1 + percentage / 100
+        const upperPrice = 1 + upperPricePercentage / 100;
+        const { syNeeded: userSyProvided, ptNeeded: userPtProvided } = (0, market_three_math_1.calcDepositSyAndPtFromBaseAmount)({
+            expirationTs: Number(marketSnapshotDataCurrent.financials.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix,
+            currentSpotPrice: marketSnapshotDataCurrent.currentSpotPrice,
+            syExchangeRate: marketSnapshotDataCurrent.syExchangeRate,
+            lowerPrice,
+            upperPrice,
+            baseTokenAmount: baseTokenAmount,
+        });
+        const [lowerFeeGrowthOutsidePtHistory, lowerFeeGrowthOutsideSyHistory] = lowerPrice <= marketSnapshotDataHistory.currentSpotPrice
+            ? [marketSnapshotDataHistory.feeGrowthIndexGlobalPt, marketSnapshotDataHistory.feeGrowthIndexGlobalSy]
+            : [0n, 0n];
+        const [upperFeeGrowthOutsidePtHistory, upperFeeGrowthOutsideSyHistory] = upperPrice <= marketSnapshotDataHistory.currentSpotPrice
+            ? [marketSnapshotDataHistory.feeGrowthIndexGlobalPt, marketSnapshotDataHistory.feeGrowthIndexGlobalSy]
+            : [0n, 0n];
+        const { insideSy: insideSyHistory, insidePt: insidePtHistory } = MarketThree.computeFeeInsideForRange({
+            currentTickPrice: marketSnapshotDataHistory.currentSpotPrice,
+            lowerTickPrice: lowerPrice,
+            upperTickPrice: upperPrice,
+            feeGrowthIndexGlobalPt: marketSnapshotDataHistory.feeGrowthIndexGlobalPt,
+            feeGrowthIndexGlobalSy: marketSnapshotDataHistory.feeGrowthIndexGlobalSy,
+            lowerTickOutsidePt: lowerFeeGrowthOutsidePtHistory,
+            lowerTickOutsideSy: lowerFeeGrowthOutsideSyHistory,
+            upperTickOutsidePt: upperFeeGrowthOutsidePtHistory,
+            upperTickOutsideSy: upperFeeGrowthOutsideSyHistory,
+        });
+        const { liquidityTarget: liquidityTargetCurrent, syNeeded, ptNeeded, } = computeLiquidityTargetAndTokenNeedsForSnapshot(marketSnapshotDataCurrent, {
+            lowerPrice,
+            upperPrice,
+            maxSy: userSyProvided,
+            maxPt: userPtProvided,
+        });
+        const { insideSy: insideSyCurrent, insidePt: insidePtCurrent } = MarketThree.computeFeeInsideForRange({
+            currentTickPrice: marketSnapshotDataCurrent.currentSpotPrice,
+            lowerTickPrice: lowerPrice,
+            upperTickPrice: upperPrice,
+            feeGrowthIndexGlobalPt: BigInt(marketSnapshotDataCurrent.feeGrowthIndexGlobalPt),
+            feeGrowthIndexGlobalSy: BigInt(marketSnapshotDataCurrent.feeGrowthIndexGlobalSy),
+            lowerTickOutsidePt: BigInt(lowerFeeGrowthOutsidePtHistory),
+            lowerTickOutsideSy: BigInt(lowerFeeGrowthOutsideSyHistory),
+            upperTickOutsidePt: BigInt(upperFeeGrowthOutsidePtHistory),
+            upperTickOutsideSy: BigInt(upperFeeGrowthOutsideSyHistory),
+        });
+        //? Single invocation
+        const { claimablePt: ptExpectedFees, claimableSy: syExpectedFees } = MarketThree.calculateClaimableFees({
+            lpBalance: BigInt(liquidityTargetCurrent),
+            feeInsideLastSy: insideSyHistory,
+            feeInsideLastPt: insidePtHistory,
+            currentInsideSy: insideSyCurrent,
+            currentInsidePt: insidePtCurrent,
+            tokensOwedSy: 0n,
+            tokensOwedPt: 0n,
+        });
+        //? As we don't have autocompounding, use 1 as annualization factor
+        const ANNUALIZATION_FACTOR = 1;
+        //? Convert SY amounts to baseToken: baseToken = syAmount / syExchangeRate
+        const syNeededBaseToken = syNeeded > 0 ? syNeeded * marketSnapshotDataCurrent.syExchangeRate : 0;
+        const syExpectedFeesBaseToken = syExpectedFees > 0n ? Number(syExpectedFees) * marketSnapshotDataCurrent.syExchangeRate : 0;
+        const ptPriceInBaseToken = (0, market_three_math_1.calcPtPriceInAsset)(marketSnapshotDataCurrent.currentSpotPrice, Number(marketSnapshotDataCurrent.financials.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix);
+        const ptNeededBaseToken = ptNeeded * ptPriceInBaseToken;
+        const ptExpectedFeesBaseToken = Number(ptExpectedFees) * ptPriceInBaseToken;
+        //? Calculate total baseToken value of the position
+        const totalPositionValueBaseToken = syNeededBaseToken + ptNeededBaseToken;
+        //? Calculate total fees earned in baseToken
+        const totalFeesBaseToken = syExpectedFeesBaseToken + ptExpectedFeesBaseToken;
+        //? Calculate unified fee rate: total fees / total position value
+        const totalFeeRate = totalPositionValueBaseToken > 0 ? totalFeesBaseToken / totalPositionValueBaseToken : 0;
+        //? Annualize the fee rate
+        const totalFeeRateAnnualized = totalFeeRate * ANNUALIZATION_FACTOR;
+        return {
+            totalFeeRate: totalFeeRateAnnualized,
+            ptExpectedFees,
+            syExpectedFees,
+            expectedFeesBaseToken: totalFeesBaseToken,
+        };
+    }
+    static calcGlobalFeeRate(marketSnapshotDataCurrent, marketSnapshotDataHistory) {
+        const { financials: financialsCurrent, feeGrowthIndexGlobalPt: feeGrowthIndexGlobalPtCurrent, feeGrowthIndexGlobalSy: feeGrowthIndexGlobalSyCurrent, currentSpotPrice, currentPrefixSum, syExchangeRate, } = marketSnapshotDataCurrent;
+        const { feeGrowthIndexGlobalPt: feeGrowthIndexGlobalPtHistory, feeGrowthIndexGlobalSy: feeGrowthIndexGlobalSyHistory, } = marketSnapshotDataHistory;
+        const ptPriceInBaseToken = (0, market_three_math_1.calcPtPriceInAsset)(currentSpotPrice, Number(financialsCurrent.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix);
+        const feePt = Number(feeGrowthIndexGlobalPtCurrent - feeGrowthIndexGlobalPtHistory) / Number(currentPrefixSum);
+        const feePtInBaseToken = feePt * ptPriceInBaseToken;
+        const feeSy = Number(feeGrowthIndexGlobalSyCurrent - feeGrowthIndexGlobalSyHistory) / Number(currentPrefixSum);
+        const feeSyInBaseToken = feeSy * syExchangeRate;
+        const totalFeesInBaseToken = feePtInBaseToken + feeSyInBaseToken;
+        const ptLiquidityInBaseToken = Number(financialsCurrent.ptBalance) * ptPriceInBaseToken;
+        const syLiquidityInBaseToken = Number(financialsCurrent.syBalance) * syExchangeRate;
+        const tvlInBaseToken = ptLiquidityInBaseToken + syLiquidityInBaseToken;
+        const totalFeeRate = totalFeesInBaseToken / tvlInBaseToken;
+        return {
+            totalFeeRate,
+            totalFeesInBaseToken,
+            tvlInBaseToken,
+        };
+    }
+    /**
+     * Returns PT and SY amounts that will be received on liquidity removal from a position
+     * If liquidityToRemove is not provided, assume that the full position balance will be removed
+     */
+    getPtAndSyOnWithdrawLiquidity(position, liquidityToRemove) {
+        const { ticks, emissions } = this.state;
+        return (0, market_three_math_1.getPtAndSyOnWithdrawLiquidity)(emissions, ticks, position, liquidityToRemove ?? position.lpBalance);
+    }
+}
+exports.MarketThree = MarketThree;
+/**
+ * Convert apy percents to input format
+ */
+function convertApyToApyBp(price) {
+    return price * 1e4;
+}
+/** Wrapper for computeLiquidityTargetAndTokenNeeds that takes a MarketSnapshotData as input */
+function computeLiquidityTargetAndTokenNeedsForSnapshot(marketSnapshotData, params) {
+    const EPSILON_CLAMP = 1e-18;
+    const { lowerPrice, upperPrice, maxSy, maxPt } = params;
+    const { financials, currentSpotPrice, syExchangeRate, snapshotTimeUnix } = marketSnapshotData;
+    const expirationTsNumber = Number(financials.expirationTs);
+    const secondsRemaining = Math.max(0, expirationTsNumber - snapshotTimeUnix);
+    const effSnap = new market_three_math_1.EffSnap((0, market_three_math_1.normalizedTimeRemaining)(secondsRemaining), syExchangeRate);
+    const priceEffLower = effSnap.getEffectivePrice(lowerPrice);
+    const priceEffUpper = effSnap.getEffectivePrice(upperPrice);
+    return (0, market_three_math_1.computeLiquidityTargetAndTokenNeeds)(effSnap, currentSpotPrice, priceEffLower, priceEffUpper, lowerPrice, upperPrice, 0, 0, 0, maxSy, maxPt, EPSILON_CLAMP);
+}
+//# sourceMappingURL=marketThree.js.map