@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/marketThree.js

@@ -0,0 +1,1749 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketThree = exports.SwapDirection = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const bs58_1 = __importDefault(require("bs58"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const exponent_clmm_pda_1 = require("@exponent-labs/exponent-clmm-pda");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+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 syPosition_1 = require("./syPosition");
+const utils_1 = require("./utils");
+const vault_1 = require("./vault");
+const web3_js_1 = require("@solana/web3.js");
+const exponentClmm = __importStar(require("./client/clmm"));
+const clmm_1 = require("./client/clmm");
+const exponentCore = __importStar(require("./client/core"));
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+var clmm_2 = require("./client/clmm");
+Object.defineProperty(exports, "SwapDirection", { enumerable: true, get: function () { return clmm_2.SwapDirection; } });
+/**
+ * CLMM (Concentrated Liquidity Market Maker) market client for the Exponent protocol.
+ *
+ * Provides instruction builders for trading PT/YT tokens, managing concentrated liquidity positions,
+ * and administering market settings. Each `ix*` method returns one or more Solana `TransactionInstruction`s
+ * ready to be included in a transaction.
+ *
+ * "Wrapper" methods (e.g. `ixWrapperBuyPt`) combine a base-asset mint/redeem step with the
+ * underlying trade so the caller can operate directly with the base asset rather than SY.
+ */
+class MarketThree {
+    state;
+    selfAddress;
+    env;
+    connection;
+    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();
+    }
+    /**
+     * Build the modify_market_setting instruction without loading the full market.
+     * Use this when the market's ALT is invalid/unset (e.g. repair flow) to avoid fetching the ALT.
+     */
+    static buildModifyMarketSettingIx(connection, marketAddress, { signer, adminAction }) {
+        return exponentClmm
+            .createModifyMarketSettingInstruction({
+            market: marketAddress,
+            signer,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { 'action': adminAction });
+    }
+    /**
+     * Load a MarketThree instance from on-chain state.
+     *
+     * Fetches the market account, its address lookup table, vault, and ticks data in parallel.
+     * Pre-loaded vault/ticks can be passed to avoid redundant fetches.
+     *
+     * @param env - Environment configuration (program IDs, cluster)
+     * @param connection - Solana RPC connection
+     * @param address - On-chain address of the market account
+     * @param vault - Optional pre-loaded vault (fetched automatically if omitted)
+     * @param ticks - Optional pre-loaded ticks data (fetched automatically if omitted)
+     * @param options - Optional load options (e.g. SY config overrides)
+     */
+    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)(exponentCore.EXPONENTCORE_PROGRAM_ID);
+    }
+    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)(exponentClmm.EXPONENTCLMM_PROGRAM_ID);
+    }
+    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
+     */
+    ixDepositLiquidity({ ptInIntent, syInIntent, depositor, lowerTickKey, upperTickKey, ptSrc: ptSrcParam, sySrc: sySrcParam, lpPosition: lpPositionParam, }) {
+        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 || web3_js_1.Keypair.generate();
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.depositSy,
+            ...this.cpiSyAccounts.getPositionState,
+        ]);
+        const ix = exponentClmm.createDepositLiquidityInstruction({
+            depositor,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            lpPosition: lpPosition.publicKey,
+            tokenPtSrc: ptSrc,
+            tokenSySrc: sySrc,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            lowerTickKey: convertApyToApyBp(lowerTickKey),
+            upperTickKey: convertApyToApyBp(upperTickKey),
+            maxPtIn: ptInIntent,
+            maxSyIn: syInIntent,
+        });
+        ix.keys.push(...remainingAccounts);
+        return {
+            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
+     */
+    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 ix = exponentClmm.createWithdrawLiquidityInstruction({
+            owner: withdrawer,
+            market: this.selfAddress,
+            lpPosition,
+            ticks: this.ticksKey,
+            tokenPtDst: ptDst,
+            tokenSyDst: syDst,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            liquidityToRemove: lpIn,
+            minPtOut,
+            minSyOut,
+        });
+        ix.keys.push(...remainingAccounts);
+        return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx] };
+    }
+    /**
+     * Swap PT <-> SY on the CLMM.
+     *
+     * Low-level instruction — prefer {@link ixBuyPt} / {@link ixSellPt} for directional trades.
+     *
+     * @param trader - Wallet signing the transaction
+     * @param traderAmount - Amount of the input token
+     * @param outConstraint - Minimum output amount (slippage protection)
+     * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    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,
+        ]);
+        const ix = exponentClmm.createTradePtInstruction({
+            trader,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenSyTrader: tokenSy,
+            tokenPtTrader: tokenPt,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            amountIn: traderAmount,
+            swapDirection,
+            amountOutConstraint: outConstraint || null,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+        });
+        ix.keys.push(...remainingAccounts);
+        return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] };
+    }
+    /**
+     * Swap PT <-> SY specifying the exact output amount.
+     *
+     * Inverse of {@link ixTradePt} — the caller specifies how much they want to *receive*
+     * rather than how much they want to *spend*.
+     *
+     * @param trader - Wallet signing the transaction
+     * @param amountOut - Exact amount of the output token to receive
+     * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+     * @param amountInConstraint - Maximum input amount (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    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 ix = exponentClmm.createTradePtExactOutInstruction({
+            trader,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenSyTrader: tokenSy,
+            tokenPtTrader: tokenPt,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            amountOut,
+            swapDirection,
+            amountInConstraint: amountInConstraint ?? null,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+        });
+        ix.keys.push(...remainingAccounts);
+        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
+     */
+    ixBuyPt({ trader, amountSy, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePt({
+            trader,
+            traderAmount: amountSy,
+            outConstraint: outConstraint,
+            swapDirection: clmm_1.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
+     */
+    ixSellPt({ trader, amountPt, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePt({
+            trader,
+            traderAmount: amountPt,
+            outConstraint: outConstraint,
+            swapDirection: clmm_1.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
+     */
+    ixBuyPtExactOut({ trader, amountPt, maxSyIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePtExactOut({
+            trader,
+            amountOut: amountPt,
+            amountInConstraint: maxSyIn,
+            swapDirection: clmm_1.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
+     */
+    ixSellPtExactOut({ trader, amountSy, maxPtIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+        return this.ixTradePtExactOut({
+            trader,
+            amountOut: amountSy,
+            amountInConstraint: maxPtIn,
+            swapDirection: clmm_1.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
+     */
+    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,
+        ]);
+        const ix = exponentClmm.createBuyYtInstruction({
+            trader,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenSyTrader: syTrader,
+            tokenYtTrader: ytTrader,
+            tokenPtTrader: ptTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            syIn: maxSyIn,
+            minYtOut: ytOut,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+        });
+        ix.keys.push(...remainingAccounts);
+        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
+     */
+    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,
+        ]);
+        const ix = exponentClmm.createSellYtInstruction({
+            trader,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenYtTrader: ytSrc,
+            tokenPtTrader: ptSrc,
+            tokenSyTrader: syDst,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            ytIn,
+            minSyOut,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+        });
+        ix.keys.push(...remainingAccounts);
+        return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] };
+    }
+    /** Apply an admin action to the market (e.g. change status, fees, tick spacing). */
+    ixModifyMarketSetting({ signer, adminAction }) {
+        return exponentClmm.createModifyMarketSettingInstruction({
+            market: this.selfAddress,
+            signer,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { action: adminAction });
+    }
+    /**
+     * 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)
+     */
+    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 = exponentClmm.createAddFarmInstruction({
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            signer,
+            feePayer,
+            mintNew: farmMint,
+            tokenSource: farmTokenSrc,
+            tokenFarm: farmTokenEscrow,
+            tokenProgram: farmTokenProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            tokenRate: emissionsRate,
+            untilTimestamp,
+        });
+        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)
+     */
+    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 = exponentClmm.createModifyFarmInstruction({
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            signer,
+            mint: farmMint,
+            tokenSource: farmTokenSrc,
+            tokenFarm: farmTokenEscrow,
+            tokenProgram: farmTokenProgram,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            newExpirationTimestamp: untilTimestamp,
+            newRate,
+        });
+        return {
+            ixs: [ix],
+        };
+    }
+    /**
+     * Buy PT directly from the base asset (e.g. SOL, USDC).
+     *
+     * Wraps a mint-SY step (via the flavor) with a buy-PT swap in a single instruction.
+     * The program mints SY from the base asset, then swaps SY -> PT on the CLMM.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param baseIn - Amount of base asset to spend
+     * @param minPtOut - Minimum PT to receive (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    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,
+        ]);
+        const ix = exponentClmm.createBuyPtInstruction({
+            buyer: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            ticks: this.ticksKey,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.state.tokenFeeTreasuryPt,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            minPtAmount: minPtOut,
+            baseAmount: baseIn,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+            mintSyRemAccountsUntil: mintSyRemAccounts.length,
+        });
+        ix.keys.push(...mintSyRemAccounts, ...remainingAccounts);
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    /**
+     * Sell PT and receive the base asset (e.g. SOL, USDC).
+     *
+     * Wraps a PT -> SY swap with a redeem-SY step (via the flavor) in a single instruction.
+     * The program swaps PT -> SY on the CLMM, then redeems SY for the base asset.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param amount - Amount of PT to sell
+     * @param minBaseOut - Minimum base asset to receive (slippage protection)
+     * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    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,
+        ]);
+        const ix = exponentClmm.createSellPtInstruction({
+            seller: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            amountPt: amount,
+            minBaseAmount: minBaseOut,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+            redeemSyRemAccountsUntil: redeemSyRemAccounts.length,
+        });
+        ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts);
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    /**
+     * Buy YT directly from the base asset.
+     *
+     * Wraps a mint-SY step with a buy-YT swap. The program mints SY from the base asset,
+     * then strips SY into PT+YT and executes the trade.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param ytOut - Amount of YT to buy
+     * @param maxBaseIn - Maximum base asset to spend (slippage protection)
+     */
+    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 = 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 = exponentClmm.createWrapperBuyYtInstruction({
+            buyer: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenYtTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            ytOut,
+            maxBaseAmount: maxBaseIn,
+            mintSyAccountsLength: mintSyRemAccounts.length,
+            depositYtAccountsUntil: depositYtAccounts_until,
+        });
+        ix1.keys.push(...allRemainingAccounts);
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+        };
+    }
+    /**
+     * Sell YT and receive the base asset.
+     *
+     * Wraps a YT -> SY swap with a redeem-SY step. The program merges YT+PT back into SY,
+     * executes the trade, then redeems SY for the base asset.
+     *
+     * @param owner - Wallet signing the transaction
+     * @param amount - Amount of YT to sell
+     * @param minBaseOut - Minimum base asset to receive (slippage protection)
+     */
+    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 withdrawYtAccounts = this.withdrawYtAccounts({
+            owner,
+            ytDst: tokenYtTrader,
+        });
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+            ...this.cpiSyAccounts.getSyState,
+            ...this.cpiSyAccounts.getPositionState,
+            ...this.cpiCoreAccounts.mergeSy,
+            ...this.cpiSyAccounts.withdrawSy,
+            ...this.cpiSyAccounts.depositSy,
+        ]);
+        const withdrawYtAccountsUntil = redeemSyRemAccounts.length + withdrawYtAccounts.keys.length;
+        const ix1 = exponentClmm.createWrapperSellYtInstruction({
+            seller: owner,
+            market: this.selfAddress,
+            tokenSyTrader,
+            tokenYtTrader,
+            tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenPtEscrow: this.tokenPtEscrow,
+            marketAddressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            ticks: this.ticksKey,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            ytAmount: amount,
+            minBaseAmount: minBaseOut,
+            redeemSyAccountsUntil: redeemSyRemAccounts.length,
+            withdrawYtAccountsUntil,
+        });
+        ix1.keys.push(...redeemSyRemAccounts, ...withdrawYtAccounts.keys, ...remainingAccounts);
+        return {
+            ixs: [ix1, ...(await this.flavor.preIxs({ signer: owner }))],
+            setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+        };
+    }
+    /**
+     * Provide concentrated liquidity from the base asset, receiving LP and YT tokens.
+     *
+     * Wraps a mint-SY step with a deposit-liquidity operation. The program mints SY from the
+     * base asset, strips some into PT, deposits PT+SY as liquidity in the specified tick range,
+     * and returns the leftover YT to the depositor.
+     *
+     * @param depositor - Wallet signing the transaction
+     * @param amountBase - Amount of base asset to deposit
+     * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+     * @param lowerTickApy - Lower APY bound for the liquidity range
+     * @param upperTickApy - Upper APY bound for the liquidity range
+     * @param lpPosition - Optional existing LP position keypair/address (new one generated if omitted)
+     */
+    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 || web3_js_1.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 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 = this.depositYtAccounts({
+            owner: depositor,
+            ytSrc: tokenYtDepositor,
+        });
+        const depositAccountsUntil = mintSyRemAccounts.length + depositYtAccounts.keys.length;
+        const allRemainingAccounts = [...mintSyRemAccounts, ...depositYtAccounts.keys, ...unorderedRemainingAccounts];
+        const ix = exponentClmm.createWrapperProvideLiquidityInstruction({
+            depositor,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyDepositor,
+            tokenYtDepositor,
+            tokenPtDepositor,
+            mintYt: this.vault.mintYt,
+            mintPt: this.vault.mintPt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            lpPosition: lpPosition instanceof web3_js_1.Keypair ? lpPosition.publicKey : lpPosition,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            lowerTick: convertApyToApyBp(lowerTickApy),
+            upperTick: convertApyToApyBp(upperTickApy),
+            amountBase,
+            minLpOut,
+            mintSyRemAccountsUntil: mintSyRemAccounts.length,
+            depositYtAccountsUntil: depositAccountsUntil,
+        });
+        ix.keys.push(...allRemainingAccounts);
+        if (lpPosition instanceof web3_js_1.Keypair) {
+            ix.keys.find((k) => k.pubkey.equals(lpPosition.publicKey)).isSigner = true;
+        }
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [lpPosition] : [],
+            setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx],
+        };
+    }
+    /**
+     * Provide concentrated liquidity from a base asset plus existing PT tokens ("classic" mode).
+     *
+     * Unlike {@link ixWrapperProvideLiquidity}, this allows the depositor to supply PT they already
+     * hold instead of having the program strip SY into PT+YT. Useful when the depositor has leftover
+     * PT from a previous trade or wants finer control over token composition.
+     *
+     * @param depositor - Wallet signing the transaction
+     * @param amountBase - Amount of base asset to deposit (converted to SY internally)
+     * @param amountPt - Amount of PT to deposit alongside the base asset
+     * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+     * @param lowerTickApy - Lower APY bound for the liquidity range
+     * @param upperTickApy - Upper APY bound for the liquidity range
+     */
+    async ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, 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 || web3_js_1.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 = exponentClmm.createWrapperProvideLiquidityClassicInstruction({
+            depositor,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyDepositor,
+            tokenPtDepositor,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            lpPosition: lpPosition instanceof web3_js_1.Keypair ? lpPosition.publicKey : lpPosition,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            lowerTick: convertApyToApyBp(lowerTickApy),
+            upperTick: convertApyToApyBp(upperTickApy),
+            amountBase,
+            amountPt,
+            minLpOut,
+            mintSyAccountsUntil: mintSyRemAccounts.length,
+        });
+        ix.keys.push(...mintSyRemAccounts, ...remainingAccounts);
+        if (lpPosition instanceof web3_js_1.Keypair) {
+            ix.keys.find((k) => k.pubkey.equals(lpPosition.publicKey)).isSigner = true;
+        }
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [lpPosition] : [],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+        };
+    }
+    async ixProvideLiquidityBase({ depositor, externalPtToBuy, externalSyConstraint, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, 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 || web3_js_1.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 = exponentClmm.createWrapperProvideLiquidityBaseInstruction({
+            depositor,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyDepositor,
+            tokenPtDepositor,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            mintPt: this.mintPt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+            lpPosition: lpPosition instanceof web3_js_1.Keypair ? lpPosition.publicKey : lpPosition,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            lowerTickKey: convertApyToApyBp(lowerTickApy),
+            upperTickKey: convertApyToApyBp(upperTickApy),
+            minLpOut,
+            mintSyAccountsUntil: mintSyRemAccounts.length,
+            externalPtToBuy,
+            externalSyConstraint,
+        });
+        ix.keys.push(...mintSyRemAccounts, ...remainingAccounts);
+        if (lpPosition instanceof web3_js_1.Keypair) {
+            ix.keys.find((k) => k.pubkey.equals(lpPosition.publicKey)).isSigner = true;
+        }
+        return {
+            ixs: [
+                ...(await this.flavor.preIxs({ signer: depositor })),
+                ix,
+                ...(await this.flavor.postIxs({ signer: depositor })),
+            ],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [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 = exponentClmm.createWrapperWithdrawLiquidityInstruction({
+            withdrawer: owner,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyWithdrawer,
+            tokenPtWithdrawer,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+            lpPosition,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            amountLp,
+            syConstraint: BigInt(minSyOut.toFixed(0)),
+            redeemSyAccountsLength: redeemSyRemAccounts.length,
+        });
+        ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts);
+        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 = exponentClmm.createWrapperWithdrawLiquidityClassicInstruction({
+            withdrawer: owner,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenSyWithdrawer,
+            tokenPtWithdrawer,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            marketAddressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            lpPosition,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            amountLp,
+            redeemSyAccountsLength: redeemSyRemAccounts.length,
+        });
+        ixn.keys.push(...redeemSyRemAccounts, ...remainingAccounts);
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ixn, ...(await this.flavor.postIxs({ signer: owner }))],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+        };
+    }
+    async ixAddLiquidity({ owner, ptInIntent, syInIntent, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, lpPosition, }) {
+        const tokenSyDepositor = tokenSyDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenYtDepositor = tokenYtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenPtDepositor = tokenPtDepositorParam || (0, spl_token_1.getAssociatedTokenAddressSync)(this.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+        const tokenBaseDepositor = tokenBaseDepositorParam ||
+            (0, spl_token_1.getAssociatedTokenAddressSync)(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram);
+        const tokenSyAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenSyDepositor, owner, this.mintSy);
+        const tokenYtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenYtDepositor, owner, this.mintYt);
+        const tokenPtAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenPtDepositor, owner, this.mintPt);
+        const tokenBaseAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenBaseDepositor, owner, 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 ix = exponentClmm.createAddLiquidityInstruction({
+            owner,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            lpPosition: lpPosition instanceof web3_js_1.Keypair ? lpPosition.publicKey : lpPosition,
+            tokenPtSrc: tokenPtDepositor,
+            tokenSySrc: tokenSyDepositor,
+            tokenPtEscrow: this.tokenPtEscrow,
+            tokenSyEscrow: this.tokenSyEscrow,
+            addressLookupTable: this.addressLookupTable,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            maxSyInToAdd: syInIntent,
+            maxPtInToAdd: ptInIntent,
+            lowerTickKeyOptional: null,
+            upperTickKeyOptional: null,
+        });
+        ix.keys.push(...remainingAccounts);
+        return {
+            ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [lpPosition] : [],
+            setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+        };
+    }
+    async getUserLpPositions(owner, market) {
+        const LP_POSITION_DISCRIMINATOR = Buffer.from([105, 241, 37, 200, 224, 2, 252, 90]);
+        const accounts = await this.connection.getProgramAccounts(exponentClmm.EXPONENTCLMM_PROGRAM_ID, {
+            filters: [
+                { memcmp: { offset: 0, bytes: bs58_1.default.encode(LP_POSITION_DISCRIMINATOR) } },
+                { memcmp: { offset: 8, bytes: owner.toBase58() } },
+                { memcmp: { offset: 40, bytes: market.toBase58() } },
+            ],
+        });
+        const lpPositions = accounts.map(({ pubkey, account }) => ({
+            publicKey: pubkey,
+            account: exponentClmm.deserializeLpPositionAccount(account.data),
+        }));
+        return {
+            lpPositions: [lpPositions],
+        };
+    }
+    ixMarketAccureEmissions({ owner, lpPosition }) {
+        const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([...this.cpiSyAccounts.getPositionState]);
+        const ixn = exponentClmm.createMarketAccrueEmissionInstruction({
+            owner,
+            market: this.selfAddress,
+            ticks: this.ticksKey,
+            lpPosition,
+            addressLookupTable: this.addressLookupTable,
+            syProgram: this.syProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        });
+        ixn.keys.push(...remainingAccounts);
+        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,
+        };
+    }
+    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,
+            escrowYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.state.syProgram,
+            addressLookupTable: this.vault.addressLookupTable,
+            yieldPosition,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.coreEventAuthority,
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        };
+        const remainingAccounts = this.cpiSyAccounts.getSyState;
+        const depositIx = exponentCore.createDepositYtInstruction(mainAccounts, { amount: 0n });
+        depositIx.keys.push(...remainingAccounts);
+        return depositIx;
+    }
+    withdrawYtAccounts({ owner, ytDst: ytDstParam, }) {
+        const ytDst = ytDstParam || (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 = {
+            owner,
+            vault: this.state.vault.selfAddress,
+            userYieldPosition,
+            ytDst,
+            escrowYt,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            authority: this.vault.authority,
+            syProgram: this.state.syProgram,
+            addressLookupTable: this.vault.addressLookupTable,
+            yieldPosition,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.coreEventAuthority,
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        };
+        const remainingAccounts = this.cpiSyAccounts.getSyState;
+        const withdrawIx = exponentCore.createWithdrawYtInstruction(mainAccounts, { amount: 0n });
+        withdrawIx.keys.push(...remainingAccounts);
+        return withdrawIx;
+    }
+    /**
+     * Estimate the yield (fees + emissions) a hypothetical LP position would have earned
+     * between two market snapshots.
+     *
+     * @param marketSnapshotDataCurrent - The more recent market snapshot
+     * @param marketSnapshotDataHistory - The older market snapshot (defines the look-back window)
+     * @param lowerPricePercentage - Lower price bound as a percentage (e.g. 5 for 5%)
+     * @param upperPricePercentage - Upper price bound as a percentage
+     * @param baseTokenAmount - Amount of base tokens in the hypothetical position
+     */
+    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,
+        };
+    }
+    /**
+     * Calculate TVL (Total Value Locked) in baseToken for a market
+     *
+     * @param currentSpotPrice - Current spot price in format of 1 + percentage / 100
+     * @param financials - Market financials containing balances and expiration timestamp
+     * @param syExchangeRate - SY exchange rate
+     * @param timestampUnix - Timestamp in seconds (defaults to current time)
+     * @returns Object with TVL breakdown: total TVL, PT liquidity, and SY liquidity in baseToken
+     */
+    static calcTvlInBaseToken(params) {
+        const { financials, currentSpotPrice, syExchangeRate, timestampUnix = Date.now() / 1000 } = params;
+        const secondsRemaining = Math.max(0, Number(financials.expirationTs) - timestampUnix);
+        const ptPriceInBaseToken = (0, market_three_math_1.calcPtPriceInAsset)(currentSpotPrice, secondsRemaining);
+        const ptLiquidityInBaseToken = Number(financials.ptBalance) * ptPriceInBaseToken;
+        const syLiquidityInBaseToken = Number(financials.syBalance) * syExchangeRate;
+        const tvlInBaseToken = ptLiquidityInBaseToken + syLiquidityInBaseToken;
+        return {
+            tvlInBaseToken: Math.round(tvlInBaseToken),
+            ptLiquidityInBaseToken: Math.round(ptLiquidityInBaseToken),
+            syLiquidityInBaseToken: Math.round(syLiquidityInBaseToken),
+        };
+    }
+    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