@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/build/marketThree.js

@@ -1,32 +1,66 @@
 "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 = void 0;
-const anchor_1 = require("@coral-xyz/anchor");
+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_idl_1 = require("@exponent-labs/exponent-clmm-idl");
 const exponent_clmm_pda_1 = require("@exponent-labs/exponent-clmm-pda");
 const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
-const exponent_idl_1 = require("@exponent-labs/exponent-idl");
 const exponent_pda_1 = require("@exponent-labs/exponent-pda");
 const market_three_math_1 = require("@exponent-labs/market-three-math");
 const addressLookupTableUtil_1 = require("./addressLookupTableUtil");
 const flavors_1 = require("./flavors");
-const market_1 = require("./market");
 const syPosition_1 = require("./syPosition");
 const utils_1 = require("./utils");
 const vault_1 = require("./vault");
+const 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;
-    clmmProgram;
-    coreProgram;
     xponPda;
     pda;
     constructor(state, selfAddress, env, connection) {
@@ -36,10 +70,32 @@ class MarketThree {
         this.connection = connection;
         this.xponPda = new exponent_pda_1.ExponentPDA(env.coreProgramId);
         this.pda = new exponent_clmm_pda_1.ExponentCLMMPDA();
-        const mockWallet = new market_1.MyWallet(anchor_1.web3.Keypair.generate());
-        this.clmmProgram = new anchor_1.Program(exponent_clmm_idl_1.IDL, new anchor_1.AnchorProvider(connection, mockWallet));
-        this.coreProgram = new anchor_1.Program(exponent_idl_1.IDL, new anchor_1.AnchorProvider(connection, new market_1.MyWallet(anchor_1.web3.Keypair.generate())));
     }
+    /**
+     * 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);
@@ -136,7 +192,7 @@ class MarketThree {
         return new exponent_pda_1.ExponentPDA();
     }
     get coreEventAuthority() {
-        return (0, utils_1.emitEventAuthority)(this.state.exponentCoreProgram);
+        return (0, utils_1.emitEventAuthority)(exponentCore.EXPONENTCORE_PROGRAM_ID);
     }
     get emissions() {
         if (this.flavor.flavor === "marginfi") {
@@ -220,7 +276,7 @@ class MarketThree {
     }
     /** Special account for event emit self-cpi */
     get eventAuthority() {
-        return (0, utils_1.emitEventAuthority)(this.clmmProgram.programId);
+        return (0, utils_1.emitEventAuthority)(exponentClmm.EXPONENTCLMM_PROGRAM_ID);
     }
     get secondsRemaining() {
         const timeNow = Date.now() / 1000;
@@ -254,37 +310,39 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
      */
-    async ixDepositLiquidity({ ptInIntent, syInIntent, depositor, lowerTickKey, upperTickKey, ptSrc: ptSrcParam, sySrc: sySrcParam, lpPosition: lpPositionParam, }) {
-        const tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+    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 || anchor_1.web3.Keypair.generate();
+        const lpPosition = lpPositionParam || web3_js_1.Keypair.generate();
         const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
             ...this.cpiSyAccounts.depositSy,
             ...this.cpiSyAccounts.getPositionState,
         ]);
-        const ix = await this.clmmProgram.methods
-            .depositLiquidity(convertApyToApyBp(lowerTickKey), convertApyToApyBp(upperTickKey), new anchor_1.BN(ptInIntent.toString()), new anchor_1.BN(syInIntent.toString()))
-            .accountsStrict({
+        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,
-            tokenProgram,
+            instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+            systemProgram: web3_js_1.SystemProgram.programId,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            lpPosition: lpPosition.publicKey,
-            ticks: this.ticksKey,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            lowerTickKey: convertApyToApyBp(lowerTickKey),
+            upperTickKey: convertApyToApyBp(upperTickKey),
+            maxPtIn: ptInIntent,
+            maxSyIn: syInIntent,
+        });
+        ix.keys.push(...remainingAccounts);
         return {
-            ix: ix,
+            ix,
             signers: lpPosition,
         };
     }
@@ -297,7 +355,7 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
      */
-    async ixWithdrawLiquidity({ lpIn, withdrawer, lpPosition, minPtOut, minSyOut, ptDst: ptDstParam, syDst: syDstParam, }) {
+    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);
@@ -306,29 +364,41 @@ class MarketThree {
             ...this.cpiSyAccounts.withdrawSy,
             ...this.cpiSyAccounts.getPositionState,
         ]);
-        const ixs = await this.clmmProgram.methods
-            .withdrawLiquidity(new anchor_1.BN(lpIn.toString()), new anchor_1.BN(minPtOut.toString()), new anchor_1.BN(minSyOut.toString()))
-            .accountsStrict({
+        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,
-            syProgram: this.syProgram,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            syProgram: this.syProgram,
+            systemProgram: web3_js_1.SystemProgram.programId,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-            lpPosition,
-            ticks: this.ticksKey,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
-        return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx] };
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            liquidityToRemove: lpIn,
+            minPtOut,
+            minSyOut,
+        });
+        ix.keys.push(...remainingAccounts);
+        return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx] };
     }
-    async ixTradePt({ trader, traderAmount, outConstraint, swapDirection, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }) {
+    /**
+     * 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);
@@ -339,31 +409,43 @@ class MarketThree {
             ...this.cpiSyAccounts.depositSy,
             ...this.cpiSyAccounts.withdrawSy,
         ]);
-        let outConstraintOptional = outConstraint ? new anchor_1.BN(outConstraint.toString()) : null;
-        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .tradePt(new anchor_1.BN(traderAmount.toString()), swapDirection, outConstraintOptional, lnImpliedApyLimitOptional)
-            .accountsStrict({
+        const ix = exponentClmm.createTradePtInstruction({
             trader,
             market: this.selfAddress,
-            tokenPtTrader: tokenPt,
+            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,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-            ticks: this.ticksKey,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            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] };
     }
-    async ixTradePtExactOut({ trader, amountOut, swapDirection, amountInConstraint, tokenPt: tokenPtParam, tokenSy: tokenSyParam, lnImpliedApyLimit, }) {
+    /**
+     * 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);
@@ -374,28 +456,28 @@ class MarketThree {
             ...this.cpiSyAccounts.depositSy,
             ...this.cpiSyAccounts.withdrawSy,
         ]);
-        const amountInConstraintOptional = amountInConstraint !== undefined ? new anchor_1.BN(amountInConstraint.toString()) : null;
-        const lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .tradePtExactOut(new anchor_1.BN(amountOut.toString()), swapDirection, amountInConstraintOptional, lnImpliedApyLimitOptional)
-            .accountsStrict({
+        const ix = exponentClmm.createTradePtExactOutInstruction({
             trader,
             market: this.selfAddress,
-            tokenPtTrader: tokenPt,
+            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,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-            ticks: this.ticksKey,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            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
@@ -406,12 +488,12 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixBuyPt({ trader, amountSy, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+    ixBuyPt({ trader, amountSy, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
         return this.ixTradePt({
             trader,
             traderAmount: amountSy,
             outConstraint: outConstraint,
-            swapDirection: { syToPt: {} },
+            swapDirection: clmm_1.SwapDirection.SyToPt,
             tokenPt,
             tokenSy,
             lnImpliedApyLimit,
@@ -425,12 +507,12 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixSellPt({ trader, amountPt, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+    ixSellPt({ trader, amountPt, outConstraint, tokenPt, tokenSy, lnImpliedApyLimit, }) {
         return this.ixTradePt({
             trader,
             traderAmount: amountPt,
             outConstraint: outConstraint,
-            swapDirection: { ptToSy: {} },
+            swapDirection: clmm_1.SwapDirection.PtToSy,
             tokenPt,
             tokenSy,
             lnImpliedApyLimit,
@@ -442,12 +524,12 @@ class MarketThree {
      * The trader specifies the exact amount of PT they want to receive
      * The maxSyIn is the maximum amount of SY the trader is willing to spend
      */
-    async ixBuyPtExactOut({ trader, amountPt, maxSyIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+    ixBuyPtExactOut({ trader, amountPt, maxSyIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
         return this.ixTradePtExactOut({
             trader,
             amountOut: amountPt,
             amountInConstraint: maxSyIn,
-            swapDirection: { syToPt: {} },
+            swapDirection: clmm_1.SwapDirection.SyToPt,
             tokenPt,
             tokenSy,
             lnImpliedApyLimit,
@@ -459,12 +541,12 @@ class MarketThree {
      * The trader specifies the exact amount of SY they want to receive
      * The maxPtIn is the maximum amount of PT the trader is willing to spend
      */
-    async ixSellPtExactOut({ trader, amountSy, maxPtIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
+    ixSellPtExactOut({ trader, amountSy, maxPtIn, tokenPt, tokenSy, lnImpliedApyLimit, }) {
         return this.ixTradePtExactOut({
             trader,
             amountOut: amountSy,
             amountInConstraint: maxPtIn,
-            swapDirection: { ptToSy: {} },
+            swapDirection: clmm_1.SwapDirection.PtToSy,
             tokenPt,
             tokenSy,
             lnImpliedApyLimit,
@@ -480,7 +562,7 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixBuyYt({ trader, ytOut, maxSyIn, ytTrader: ytTraderParam, ptTrader: ptTraderParam, syTrader: syTraderParam, lnImpliedApyLimit, }) {
+    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);
@@ -494,30 +576,30 @@ class MarketThree {
             ...this.cpiSyAccounts.depositSy,
             ...stripAccounts,
         ]);
-        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .buyYt(new anchor_1.BN(maxSyIn.toString()), new anchor_1.BN(ytOut.toString()), lnImpliedApyLimitOptional)
-            .accountsStrict({
+        const ix = exponentClmm.createBuyYtInstruction({
             trader,
             market: this.selfAddress,
+            ticks: this.ticksKey,
+            tokenSyTrader: syTrader,
             tokenYtTrader: ytTrader,
             tokenPtTrader: ptTrader,
-            tokenSyTrader: syTrader,
             tokenSyEscrow: this.tokenSyEscrow,
             tokenPtEscrow: this.tokenPtEscrow,
-            addressLookupTable: this.addressLookupTable,
+            tokenYtEscrow: this.tokenYtEscrow,
+            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            addressLookupTable: this.addressLookupTable,
             syProgram: this.syProgram,
-            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-            ticks: this.ticksKey,
-            tokenYtEscrow: this.tokenYtEscrow,
-            exponentCoreProgram: this.state.exponentCoreProgram,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            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
@@ -530,7 +612,7 @@ class MarketThree {
      *
      * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
      */
-    async ixSellYt({ trader, ytIn, minSyOut, ytSrc: ytSrcParam, ptSrc: ptSrcParam, syDst: syDstParam, lnImpliedApyLimit, }) {
+    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);
@@ -544,41 +626,39 @@ class MarketThree {
             ...this.cpiSyAccounts.depositSy,
             ...mergeAccounts,
         ]);
-        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .sellYt(new anchor_1.BN(ytIn.toString()), new anchor_1.BN(minSyOut.toString()), lnImpliedApyLimitOptional)
-            .accountsStrict({
+        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,
-            tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+            exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-            ticks: this.ticksKey,
-            tokenYtEscrow: this.tokenYtEscrow,
-            exponentCoreProgram: this.state.exponentCoreProgram,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            ytIn,
+            minSyOut,
+            priceSpotLimit: lnImpliedApyLimit ?? null,
+        });
+        ix.keys.push(...remainingAccounts);
         return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] };
     }
-    async ixModifyMarketSetting({ signer, adminAction }) {
-        return this.clmmProgram.methods
-            .modifyMarketSetting(adminAction)
-            .accountsStrict({
+    /** 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: anchor_1.web3.SystemProgram.programId,
-        })
-            .instruction();
+            systemProgram: web3_js_1.SystemProgram.programId,
+        }, { action: adminAction });
     }
     /**
      * Add a new farm to the market to distribute rewards to LP holders
@@ -591,14 +671,12 @@ class MarketThree {
      * @param farmTokenSrc - Optional source token account for the farm rewards (derived from signer if not provided)
      * @param feePayer - Optional fee payer for account reallocation (defaults to signer)
      */
-    async ixAddFarm({ signer, farmMint, farmTokenProgram, emissionsRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, feePayer: feePayerParam, }) {
+    ixAddFarm({ signer, farmMint, farmTokenProgram, emissionsRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, feePayer: feePayerParam, }) {
         const feePayer = feePayerParam || signer;
         const farmTokenEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
         const farmTokenSrc = farmTokenSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
         const farmTokenEscrowAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(feePayer, farmTokenEscrow, this.selfAddress, farmMint, farmTokenProgram);
-        const ix = await this.clmmProgram.methods
-            .addFarm(new anchor_1.BN(emissionsRate.toString()), untilTimestamp)
-            .accountsStrict({
+        const ix = exponentClmm.createAddFarmInstruction({
             market: this.selfAddress,
             ticks: this.ticksKey,
             signer,
@@ -607,11 +685,13 @@ class MarketThree {
             tokenSource: farmTokenSrc,
             tokenFarm: farmTokenEscrow,
             tokenProgram: farmTokenProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-        })
-            .instruction();
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        }, {
+            tokenRate: emissionsRate,
+            untilTimestamp,
+        });
         return {
             ixs: [ix],
             setupIxs: [farmTokenEscrowAtaIx],
@@ -631,12 +711,10 @@ class MarketThree {
      * @param untilTimestamp - New unix timestamp when the farm emissions should end
      * @param farmTokenSrc - Optional source/destination token account (derived from signer if not provided)
      */
-    async ixModifyFarm({ signer, farmMint, farmTokenProgram, newRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, }) {
+    ixModifyFarm({ signer, farmMint, farmTokenProgram, newRate, untilTimestamp, farmTokenSrc: farmTokenSrcParam, }) {
         const farmTokenEscrow = (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, this.selfAddress, true, farmTokenProgram);
         const farmTokenSrc = farmTokenSrcParam || (0, spl_token_1.getAssociatedTokenAddressSync)(farmMint, signer, true, farmTokenProgram);
-        const ix = await this.clmmProgram.methods
-            .modifyFarm(untilTimestamp, new anchor_1.BN(newRate.toString()))
-            .accountsStrict({
+        const ix = exponentClmm.createModifyFarmInstruction({
             market: this.selfAddress,
             ticks: this.ticksKey,
             signer,
@@ -645,13 +723,26 @@ class MarketThree {
             tokenFarm: farmTokenEscrow,
             tokenProgram: farmTokenProgram,
             eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-        })
-            .instruction();
+            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);
@@ -672,32 +763,44 @@ class MarketThree {
             ...this.cpiSyAccounts.depositSy,
             ...this.cpiSyAccounts.getPositionState,
         ]);
-        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .buyPt(new anchor_1.BN(minPtOut.toString()), new anchor_1.BN(baseIn.toString()), lnImpliedApyLimitOptional, mintSyRemAccounts.length)
-            .accountsStrict({
-            addressLookupTable: this.addressLookupTable,
+        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,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
             tokenFeeTreasuryPt: this.state.tokenFeeTreasuryPt,
-            ticks: this.ticksKey,
-        })
-            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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);
@@ -718,32 +821,43 @@ class MarketThree {
             ...this.cpiSyAccounts.getPositionState,
             ...this.cpiSyAccounts.withdrawSy,
         ]);
-        let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null;
-        const ix = await this.clmmProgram.methods
-            .sellPt(new anchor_1.BN(amount.toString()), new anchor_1.BN(minBaseOut.toString()), lnImpliedApyLimitOptional, redeemSyRemAccounts.length)
-            .accountsStrict({
+        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,
-            tokenSyTrader,
-            tokenPtEscrow: this.tokenPtEscrow,
-            tokenSyEscrow: this.tokenSyEscrow,
             tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            ticks: this.ticksKey,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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);
@@ -759,7 +873,7 @@ class MarketThree {
             depositorBaseTokenAccount: tokenBaseTrader,
             depositorSyTokenAccount: tokenSyTrader,
         });
-        const depositYtAccounts = await this.depositYtAccounts({
+        const depositYtAccounts = this.depositYtAccounts({
             owner,
             ytSrc: tokenYtTrader,
         });
@@ -773,9 +887,7 @@ class MarketThree {
         ]);
         const depositYtAccounts_until = mintSyRemAccounts.length + depositYtAccounts.keys.length;
         const allRemainingAccounts = mintSyRemAccounts.concat(depositYtAccounts.keys).concat(remainingAccounts);
-        const ix1 = await this.clmmProgram.methods
-            .wrapperBuyYt(new anchor_1.BN(ytOut.toString()), new anchor_1.BN(maxBaseIn.toString()), mintSyRemAccounts.length, depositYtAccounts_until)
-            .accountsStrict({
+        const ix1 = exponentClmm.createWrapperBuyYtInstruction({
             buyer: owner,
             market: this.selfAddress,
             tokenSyTrader,
@@ -783,25 +895,39 @@ class MarketThree {
             tokenPtTrader,
             tokenSyEscrow: this.tokenSyEscrow,
             tokenPtEscrow: this.tokenPtEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
             marketAddressLookupTable: this.addressLookupTable,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             syProgram: this.syProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
             tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            tokenYtEscrow: this.tokenYtEscrow,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
             ticks: this.ticksKey,
-            exponentCoreProgram: this.state.exponentCoreProgram,
-        })
-            .remainingAccounts(allRemainingAccounts)
-            .instruction();
+            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);
@@ -819,6 +945,10 @@ class MarketThree {
             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,
@@ -826,47 +956,61 @@ class MarketThree {
             ...this.cpiSyAccounts.withdrawSy,
             ...this.cpiSyAccounts.depositSy,
         ]);
-        const ix1 = await this.clmmProgram.methods
-            .wrapperSellYt(new anchor_1.BN(amount.toString()), new anchor_1.BN(minBaseOut.toString()), redeemSyRemAccounts.length)
-            .accountsStrict({
+        const withdrawYtAccountsUntil = redeemSyRemAccounts.length + withdrawYtAccounts.keys.length;
+        const ix1 = exponentClmm.createWrapperSellYtInstruction({
             seller: owner,
             market: this.selfAddress,
+            tokenSyTrader,
             tokenYtTrader,
-            marketAddressLookupTable: this.addressLookupTable,
             tokenPtTrader,
+            tokenSyEscrow: this.tokenSyEscrow,
+            tokenYtEscrow: this.tokenYtEscrow,
             tokenPtEscrow: this.tokenPtEscrow,
+            marketAddressLookupTable: this.addressLookupTable,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             syProgram: this.syProgram,
-            tokenSyTrader,
-            tokenSyEscrow: this.tokenSyEscrow,
             tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-            eventAuthority: this.eventAuthority,
-            program: this.clmmProgram.programId,
-            tokenYtEscrow: this.tokenYtEscrow,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
             ticks: this.ticksKey,
-            exponentCoreProgram: this.state.exponentCoreProgram,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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 liquidity from a base asset - and receive YT and LP tokens in return */
+    /**
+     * 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 || anchor_1.web3.Keypair.generate();
+        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 amountBaseBn = new anchor_1.BN(amountBase.toString());
-        const minLpOutBn = new anchor_1.BN(minLpOut.toString());
         const mintSyIx = await this.flavor.ixMintSy({
             // argument does not matter - since we are just getting the keys
             amountBase: "0",
@@ -881,55 +1025,77 @@ class MarketThree {
             ...this.cpiCoreAccounts.stripSy,
             ...this.cpiSyAccounts.depositSy,
         ]);
-        const depositYtAccounts = await this.depositYtAccounts({
+        const depositYtAccounts = this.depositYtAccounts({
             owner: depositor,
             ytSrc: tokenYtDepositor,
         });
         const depositAccountsUntil = mintSyRemAccounts.length + depositYtAccounts.keys.length;
         const allRemainingAccounts = [...mintSyRemAccounts, ...depositYtAccounts.keys, ...unorderedRemainingAccounts];
-        const ix = await this.clmmProgram.methods
-            .wrapperProvideLiquidity(convertApyToApyBp(lowerTickApy), convertApyToApyBp(upperTickApy), amountBaseBn, minLpOutBn, mintSyRemAccounts.length, depositAccountsUntil)
-            .accountsStrict({
+        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,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            syProgram: this.syProgram,
             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: this.clmmProgram.programId,
-            lpPosition: lpPosition.publicKey,
-            tokenYtEscrow: this.tokenYtEscrow,
-            ticks: this.ticksKey,
-            exponentCoreProgram: this.state.exponentCoreProgram,
-        })
-            .remainingAccounts(allRemainingAccounts)
-            .instruction();
-        // console.log("ix accounts length", ix.keys.length)
+            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],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [lpPosition] : [],
             setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx],
         };
     }
-    async ixProvideLiquidityClassic({ depositor, amountBase, amountPt, minLpOut, lowerTickApy, upperTickApy, tokenSyDepositor: tokenSyDepositorParam, tokenYtDepositor: tokenYtDepositorParam, tokenPtDepositor: tokenPtDepositorParam, tokenBaseDepositor: tokenBaseDepositorParam, }) {
+    /**
+     * 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 = anchor_1.web3.Keypair.generate();
+        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);
@@ -947,33 +1113,109 @@ class MarketThree {
             depositorSyTokenAccount: tokenSyDepositor,
         });
         const mintSyRemAccounts = mintSyIx.keys;
-        const ix = await this.clmmProgram.methods
-            .wrapperProvideLiquidityClassic(convertApyToApyBp(lowerTickApy), convertApyToApyBp(upperTickApy), new anchor_1.BN(amountBase.toString()), new anchor_1.BN(amountPt.toString()), new anchor_1.BN(minLpOut.toString()), mintSyRemAccounts.length)
-            .accountsStrict({
+        const ix = exponentClmm.createWrapperProvideLiquidityClassicInstruction({
             depositor,
-            lpPosition: lpPosition.publicKey,
             market: this.selfAddress,
+            ticks: this.ticksKey,
             tokenPtEscrow: this.tokenPtEscrow,
             tokenSyEscrow: this.tokenSyEscrow,
-            syProgram: this.syProgram,
+            tokenSyDepositor,
+            tokenPtDepositor,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            tokenPtDepositor,
-            tokenSyDepositor,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            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: this.clmmProgram.programId,
+            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,
-        })
-            .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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],
+            signers: lpPosition instanceof web3_js_1.Keypair ? [lpPosition] : [],
             setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
         };
     }
@@ -999,28 +1241,29 @@ class MarketThree {
         });
         const redeemSyRemAccounts = redeemSyIx.keys;
         const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate;
-        const ix = await this.clmmProgram.methods
-            .wrapperWithdrawLiquidity(new anchor_1.BN(amountLp.toString()), new anchor_1.BN(minSyOut.toFixed(0).toString()), redeemSyRemAccounts.length)
-            .accountsStrict({
+        const ix = exponentClmm.createWrapperWithdrawLiquidityInstruction({
+            withdrawer: owner,
             market: this.selfAddress,
+            ticks: this.ticksKey,
             tokenPtEscrow: this.tokenPtEscrow,
             tokenSyEscrow: this.tokenSyEscrow,
-            lpPosition,
+            tokenSyWithdrawer,
+            tokenPtWithdrawer,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            eventAuthority: this.eventAuthority,
             syProgram: this.syProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
             tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            tokenPtWithdrawer,
-            tokenSyWithdrawer,
-            withdrawer: owner,
-            ticks: this.ticksKey,
             tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-            program: this.clmmProgram.programId,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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],
@@ -1047,71 +1290,108 @@ class MarketThree {
             redeemerSyTokenAccount: tokenSyWithdrawer,
         });
         const redeemSyRemAccounts = redeemSyIx.keys;
-        const ixn = await this.clmmProgram.methods
-            .wrapperWithdrawLiquidityClassic(new anchor_1.BN(amountLp.toString()), redeemSyRemAccounts.length)
-            .accountsStrict({
+        const ixn = exponentClmm.createWrapperWithdrawLiquidityClassicInstruction({
+            withdrawer: owner,
             market: this.selfAddress,
+            ticks: this.ticksKey,
             tokenPtEscrow: this.tokenPtEscrow,
             tokenSyEscrow: this.tokenSyEscrow,
-            lpPosition,
+            tokenSyWithdrawer,
+            tokenPtWithdrawer,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             marketAddressLookupTable: this.addressLookupTable,
-            eventAuthority: this.eventAuthority,
             syProgram: this.syProgram,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
-            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            tokenPtWithdrawer,
-            tokenSyWithdrawer,
-            withdrawer: owner,
-            ticks: this.ticksKey,
-            program: this.clmmProgram.programId,
-        })
-            .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-            .instruction();
+            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 lpPositions = await (await this.clmmProgram.account.lpPosition.all()).filter((lpPos) => lpPos.account.owner.toString() === owner.toString() && lpPos.account.market.toString() === market.toString());
+        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],
         };
     }
-    // async ixCloseMarket({ owner }: { owner: web3.PublicKey }) {
-    //   const ixn = await this.clmmProgram.methods
-    //     .closeMarket()
-    //     .accountsStrict({
-    //       market: this.selfAddress,
-    //       systemProgram: web3.SystemProgram.programId,
-    //       payer: owner,
-    //       ticks: this.ticksKey,
-    //       program: this.clmmProgram.programId,
-    //       eventAuthority: this.eventAuthority,
-    //       rent: web3.SYSVAR_RENT_PUBKEY,
-    //     })
-    //     .instruction()
-    //   return {
-    //     ixs: [ixn],
-    //   }
-    // }
-    async ixMarketAccureEmissions({ owner, lpPosition }) {
+    ixMarketAccureEmissions({ owner, lpPosition }) {
         const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([...this.cpiSyAccounts.getPositionState]);
-        const ixn = await this.clmmProgram.methods
-            .marketAccrueEmission()
-            .accountsStrict({
+        const ixn = exponentClmm.createMarketAccrueEmissionInstruction({
+            owner,
             market: this.selfAddress,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
             ticks: this.ticksKey,
-            program: this.clmmProgram.programId,
-            eventAuthority: this.eventAuthority,
             lpPosition,
-            owner,
             addressLookupTable: this.addressLookupTable,
             syProgram: this.syProgram,
-        })
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+            systemProgram: web3_js_1.SystemProgram.programId,
+            eventAuthority: this.eventAuthority,
+            program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+        });
+        ixn.keys.push(...remainingAccounts);
         return {
             ixs: [ixn],
         };
@@ -1258,7 +1538,7 @@ class MarketThree {
             totalFeesPt,
         };
     }
-    async depositYtAccounts({ owner, ytSrc: ytSrcParam, }) {
+    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 });
@@ -1267,24 +1547,56 @@ class MarketThree {
             depositor: owner,
             ytSrc,
             vault: this.state.vault.selfAddress,
-            userYieldPosition: userYieldPosition,
-            escrowYt: escrowYt,
+            userYieldPosition,
+            escrowYt,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             syProgram: this.state.syProgram,
             addressLookupTable: this.vault.addressLookupTable,
             yieldPosition,
-            systemProgram: anchor_1.web3.SystemProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
             eventAuthority: this.coreEventAuthority,
-            program: this.state.exponentCoreProgram,
+            program: exponentCore.EXPONENTCORE_PROGRAM_ID,
         };
         const remainingAccounts = this.cpiSyAccounts.getSyState;
-        const depositIx = await this.coreProgram.methods
-            .depositYt(new anchor_1.BN(0))
-            .accountsStrict(mainAccounts)
-            .remainingAccounts(remainingAccounts)
-            .instruction();
+        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;
@@ -1365,6 +1677,28 @@ class MarketThree {
             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;