@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/marketThree.ts

@@ -1,13 +1,12 @@
-import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
 import {
   TOKEN_PROGRAM_ID,
   createAssociatedTokenAccountIdempotentInstruction,
   getAccount,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token"
+import bs58 from "bs58"
 import Decimal from "decimal.js"
 
-import { ExponentClmm, IDL } from "@exponent-labs/exponent-clmm-idl"
 import { ExponentCLMMPDA } from "@exponent-labs/exponent-clmm-pda"
 import {
   ExponentFetcher,
@@ -18,12 +17,10 @@ import {
   MarketThreeFinancials,
   Ticks,
 } from "@exponent-labs/exponent-fetcher"
-import { IDL as EXPONENT_CORE_IDL, ExponentCore } from "@exponent-labs/exponent-idl"
 import { ExponentPDA } from "@exponent-labs/exponent-pda"
 import {
   AnchorizedPNum,
   CpiAccountsRaw,
-  CpiAccountsRawJson,
   ExponentCoreCpiAccountsRaw,
   Flavor,
   SyPosition,
@@ -51,10 +48,13 @@ import {
   makeFlavorMarginfiSync,
   makeFlavorPerenaSync,
 } from "./flavors"
-import { MyWallet } from "./market"
 import { makeSyPosition } from "./syPosition"
-import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
+import { emitEventAuthority, uniqueRemainingAccounts } from "./utils"
 import { Vault } from "./vault"
+import { Connection, Keypair, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from "@solana/web3.js"
+import * as exponentClmm from './client/clmm'
+import { SwapDirection } from './client/clmm'
+import * as exponentCore from './client/core'
 
 export { LiquidityAdd }
 
@@ -62,13 +62,13 @@ const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
 
 interface Emission {
   /** Token account that holds emission tokens */
-  escrowAccountAddress: web3.PublicKey
+  escrowAccountAddress: PublicKey
 
   /** Mint for the emission token */
-  mint: web3.PublicKey
+  mint: PublicKey
 
   /** Token program ID for the emission token */
-  tokenProgramAddress: web3.PublicKey
+  tokenProgramAddress: PublicKey
 
   /** How many emissions have been claimed by SY holders */
   totalClaimed: bigint
@@ -80,24 +80,9 @@ interface Emission {
   index: AnchorizedPNum
 }
 
-export type MarketAdminAction =
-  | { setStatus: [number] }
-  | { setMaxLpSupply: [BN] }
-  | { changeTreasuryTradeSyBpsFee: [number] }
-  | { changeLnFeeRateRoot: [number] }
-  | {
-      changeLiquidityNetBalanceLimits: {
-        maxNetBalanceChangeNegativePercentage: number
-        maxNetBalanceChangePositivePercentage: number
-        windowDurationSeconds: number
-      }
-    }
-  | { changeEpsilonClamp: [number] }
-  | { changeMinLpTickAmount: [BN] }
-  | { changeTickSpace: [number] }
+export type MarketAdminAction = exponentClmm.MarketAdminAction
 
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export type SwapDirection = { ptToSy: {} } | { syToPt: {} }
+export { SwapDirection } from './client/clmm'
 
 interface MarketThreeLoadOptions {
   syConfig?: {
@@ -106,20 +91,19 @@ interface MarketThreeLoadOptions {
 }
 
 type MarketThreeArgs = {
-  admin: web3.PublicKey
-  addressLookupTable: web3.PublicKey
-  mintPt: web3.PublicKey
-  mintYt: web3.PublicKey
-  mintSy: web3.PublicKey
+  admin: PublicKey
+  addressLookupTable: PublicKey
+  mintPt: PublicKey
+  mintYt: PublicKey
+  mintSy: PublicKey
   vault: Vault
-  tokenPtEscrow: web3.PublicKey
-  tokenSyEscrow: web3.PublicKey
-  tokenYtEscrow: web3.PublicKey
-  tokenFeeTreasurySy: web3.PublicKey
-  tokenFeeTreasuryPt: web3.PublicKey
-  syProgram: web3.PublicKey
-  exponentCoreProgram: web3.PublicKey
-  selfAddress: web3.PublicKey
+  tokenPtEscrow: PublicKey
+  tokenSyEscrow: PublicKey
+  tokenYtEscrow: PublicKey
+  tokenFeeTreasurySy: PublicKey
+  tokenFeeTreasuryPt: PublicKey
+  syProgram: PublicKey
+  selfAddress: PublicKey
   statusFlags: number
   configurationOptions: MarketConfigurationOptions
   financials: MarketThreeFinancials
@@ -130,44 +114,77 @@ type MarketThreeArgs = {
   flavor: Flavor
   emissions: {
     trackers: {
-      tokenEscrow: web3.PublicKey
+      tokenEscrow: PublicKey
       lpShareIndex: number
       lastSeenStaged: number
     }[]
   }
   liquidityNetBalanceLimits: LiquidityNetBalanceLimits
-  ticksAccount: web3.PublicKey
+  ticksAccount: PublicKey
   ticks: Ticks
   syPosition: SyPosition
-  treasuryFeeOwner: web3.PublicKey
+  treasuryFeeOwner: PublicKey
 }
 
+/**
+ * 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.
+ */
 export class MarketThree {
-  clmmProgram: Program<ExponentClmm>
-  coreProgram: Program<ExponentCore>
   xponPda: ExponentPDA
   pda: ExponentCLMMPDA
 
   constructor(
     public state: MarketThreeArgs,
-    public selfAddress: web3.PublicKey,
+    public selfAddress: PublicKey,
     public env: Environment,
-    public connection: web3.Connection,
+    public connection: Connection,
   ) {
     this.xponPda = new ExponentPDA(env.coreProgramId)
     this.pda = new ExponentCLMMPDA()
-    const mockWallet = new MyWallet(web3.Keypair.generate())
-    this.clmmProgram = new Program<ExponentClmm>(IDL as ExponentClmm, new AnchorProvider(connection, mockWallet))
-    this.coreProgram = new Program(
-      EXPONENT_CORE_IDL as ExponentCore,
-      new AnchorProvider(connection, new MyWallet(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: Connection,
+    marketAddress: PublicKey,
+    { signer, adminAction }: { signer: PublicKey; adminAction: MarketAdminAction },
+  ): TransactionInstruction {
+    return exponentClmm
+      .createModifyMarketSettingInstruction(
+        { 
+          market: marketAddress,
+          signer,
+          systemProgram: 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: Environment,
-    connection: web3.Connection,
-    address: web3.PublicKey,
+    connection: Connection,
+    address: PublicKey,
     vault?: Vault,
     ticks?: Ticks,
     options: MarketThreeLoadOptions = {},
@@ -218,7 +235,7 @@ export class MarketThree {
     return new MarketThree(state, address, env, connection)
   }
 
-  async reload(connection: web3.Connection = this.connection) {
+  async reload(connection: Connection = this.connection) {
     const market = await MarketThree.load(this.env, connection, this.selfAddress)
     this.state = market.state
     return market
@@ -289,7 +306,7 @@ export class MarketThree {
   }
 
   get coreEventAuthority() {
-    return emitEventAuthority(this.state.exponentCoreProgram)
+    return emitEventAuthority(exponentCore.EXPONENTCORE_PROGRAM_ID)
   }
 
   get emissions(): Emission[] {
@@ -347,32 +364,32 @@ export class MarketThree {
   }
 
   /** Get the escrow token account addresses for the emissions, in order */
-  get emissionTokenAccounts(): web3.PublicKey[] {
+  get emissionTokenAccounts(): PublicKey[] {
     return this.emissions.map((e) => e.escrowAccountAddress)
   }
 
   /** Pass-through SY account owned by the market */
-  get tokenSyEscrow(): web3.PublicKey {
+  get tokenSyEscrow(): PublicKey {
     return this.state.tokenSyEscrow
   }
 
   /** Pass-through YT account owned by the market */
-  get tokenYtEscrow(): web3.PublicKey {
+  get tokenYtEscrow(): PublicKey {
     return this.state.tokenYtEscrow
   }
 
   /** SY account that holds treasury SY fees from PT trading */
-  get tokenFeeTreasurySy(): web3.PublicKey {
+  get tokenFeeTreasurySy(): PublicKey {
     return this.state.tokenFeeTreasurySy
   }
 
   /** PT account that holds treasury PT fees from PT trading */
-  get tokenFeeTreasuryPt(): web3.PublicKey {
+  get tokenFeeTreasuryPt(): PublicKey {
     return this.state.tokenFeeTreasuryPt
   }
 
   /** Market liquidity for PT */
-  get tokenPtEscrow(): web3.PublicKey {
+  get tokenPtEscrow(): PublicKey {
     return this.state.tokenPtEscrow
   }
 
@@ -381,8 +398,8 @@ export class MarketThree {
   }
 
   /** Special account for event emit self-cpi */
-  get eventAuthority(): web3.PublicKey {
-    return emitEventAuthority(this.clmmProgram.programId)
+  get eventAuthority(): PublicKey {
+    return emitEventAuthority(exponentClmm.EXPONENTCLMM_PROGRAM_ID)
   }
 
   get secondsRemaining(): number {
@@ -411,9 +428,9 @@ export class MarketThree {
 
   /** Get the owner of the treasury fee accounts: tokenFeeTreasuryPt & tokenFeeTreasurySy */
   static async fetchTreasuryFeeOwner(
-    tokenFeeTreasury: web3.PublicKey,
-    connection: web3.Connection,
-  ): Promise<web3.PublicKey> {
+    tokenFeeTreasury: PublicKey,
+    connection: Connection,
+  ): Promise<PublicKey> {
     const { owner } = await getAccount(connection, tokenFeeTreasury)
     return owner
   }
@@ -426,7 +443,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
    */
-  async ixDepositLiquidity({
+  ixDepositLiquidity({
     ptInIntent,
     syInIntent,
     depositor,
@@ -444,50 +461,49 @@ export class MarketThree {
     lowerTickKey: number
     /** Upper tick key */
     upperTickKey: number
-    depositor: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    lpPosition?: web3.Keypair
+    depositor: PublicKey
+    ptSrc?: PublicKey
+    sySrc?: PublicKey
+    lpPosition?: Keypair
   }) {
-    const tokenProgram = TOKEN_PROGRAM_ID
-
     const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
     const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
 
-    const lpPosition = lpPositionParam || web3.Keypair.generate()
+    const lpPosition = lpPositionParam || Keypair.generate()
     const remainingAccounts = uniqueRemainingAccounts([
       ...this.cpiSyAccounts.depositSy,
       ...this.cpiSyAccounts.getPositionState,
     ])
 
-    const ix = await this.clmmProgram.methods
-      .depositLiquidity(
-        convertApyToApyBp(lowerTickKey),
-        convertApyToApyBp(upperTickKey),
-        new BN(ptInIntent.toString()),
-        new 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: TOKEN_PROGRAM_ID,
         syProgram: this.syProgram,
-        tokenProgram,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.eventAuthority,
-        program: this.clmmProgram.programId,
-        lpPosition: lpPosition.publicKey,
-        ticks: this.ticksKey,
-        systemProgram: 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,
     }
   }
@@ -501,7 +517,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
    */
-  async ixWithdrawLiquidity({
+  ixWithdrawLiquidity({
     lpIn,
     withdrawer,
     lpPosition,
@@ -511,12 +527,12 @@ export class MarketThree {
     syDst: syDstParam,
   }: {
     lpIn: bigint
-    withdrawer: web3.PublicKey
-    lpPosition: web3.PublicKey
+    withdrawer: PublicKey
+    lpPosition: PublicKey
     minPtOut: bigint
     minSyOut: bigint
-    ptDst?: web3.PublicKey
-    syDst?: web3.PublicKey
+    ptDst?: PublicKey
+    syDst?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
@@ -528,31 +544,46 @@ export class MarketThree {
       ...this.cpiSyAccounts.getPositionState,
     ])
 
-    const ixs = await this.clmmProgram.methods
-      .withdrawLiquidity(new BN(lpIn.toString()), new BN(minPtOut.toString()), new 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: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.eventAuthority,
-        program: this.clmmProgram.programId,
-        systemProgram: web3.SystemProgram.programId,
-        lpPosition,
-        ticks: this.ticksKey,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        liquidityToRemove: lpIn,
+        minPtOut,
+        minSyOut,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
 
-    return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx] }
+    return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx] }
   }
 
-  async ixTradePt({
+  /**
+   * 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,
@@ -561,12 +592,12 @@ export class MarketThree {
     tokenSy: tokenSyParam,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     traderAmount: bigint
     outConstraint: bigint
     swapDirection: SwapDirection
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
@@ -582,34 +613,48 @@ export class MarketThree {
       ...this.cpiSyAccounts.withdrawSy,
     ])
 
-    let outConstraintOptional = outConstraint ? new BN(outConstraint.toString()) : null
-    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-
-    const ix = await this.clmmProgram.methods
-      .tradePt(new 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: 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({
+  /**
+   * 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,
@@ -618,12 +663,12 @@ export class MarketThree {
     tokenSy: tokenSyParam,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountOut: bigint
     swapDirection: SwapDirection
     amountInConstraint?: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
@@ -639,34 +684,31 @@ export class MarketThree {
       ...this.cpiSyAccounts.withdrawSy,
     ])
 
-    const amountInConstraintOptional = amountInConstraint !== undefined ? new BN(amountInConstraint.toString()) : null
-    const lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-
-    const ix = await this.clmmProgram.methods
-      .tradePtExactOut(
-        new 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: 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] }
   }
@@ -679,7 +721,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixBuyPt({
+  ixBuyPt({
     trader,
     amountSy,
     outConstraint,
@@ -687,18 +729,18 @@ export class MarketThree {
     tokenSy,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountSy: bigint
     outConstraint: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     return this.ixTradePt({
       trader,
       traderAmount: amountSy,
       outConstraint: outConstraint,
-      swapDirection: { syToPt: {} },
+      swapDirection: SwapDirection.SyToPt,
       tokenPt,
       tokenSy,
       lnImpliedApyLimit,
@@ -713,7 +755,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixSellPt({
+  ixSellPt({
     trader,
     amountPt,
     outConstraint,
@@ -721,18 +763,18 @@ export class MarketThree {
     tokenSy,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountPt: bigint
     outConstraint: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     return this.ixTradePt({
       trader,
       traderAmount: amountPt,
       outConstraint: outConstraint,
-      swapDirection: { ptToSy: {} },
+      swapDirection: SwapDirection.PtToSy,
       tokenPt,
       tokenSy,
       lnImpliedApyLimit,
@@ -745,7 +787,7 @@ export 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({
+  ixBuyPtExactOut({
     trader,
     amountPt,
     maxSyIn,
@@ -753,18 +795,18 @@ export class MarketThree {
     tokenSy,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountPt: bigint
     maxSyIn?: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     return this.ixTradePtExactOut({
       trader,
       amountOut: amountPt,
       amountInConstraint: maxSyIn,
-      swapDirection: { syToPt: {} },
+      swapDirection: SwapDirection.SyToPt,
       tokenPt,
       tokenSy,
       lnImpliedApyLimit,
@@ -777,7 +819,7 @@ export 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({
+  ixSellPtExactOut({
     trader,
     amountSy,
     maxPtIn,
@@ -785,18 +827,18 @@ export class MarketThree {
     tokenSy,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     amountSy: bigint
     maxPtIn?: bigint
-    tokenPt?: web3.PublicKey
-    tokenSy?: web3.PublicKey
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     return this.ixTradePtExactOut({
       trader,
       amountOut: amountSy,
       amountInConstraint: maxPtIn,
-      swapDirection: { ptToSy: {} },
+      swapDirection: SwapDirection.PtToSy,
       tokenPt,
       tokenSy,
       lnImpliedApyLimit,
@@ -813,7 +855,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixBuyYt({
+  ixBuyYt({
     trader,
     ytOut,
     maxSyIn,
@@ -822,12 +864,12 @@ export class MarketThree {
     syTrader: syTraderParam,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     ytOut: bigint
     maxSyIn: bigint
-    ytTrader?: web3.PublicKey
-    ptTrader?: web3.PublicKey
-    syTrader?: web3.PublicKey
+    ytTrader?: PublicKey
+    ptTrader?: PublicKey
+    syTrader?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const syTrader = syTraderParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
@@ -847,30 +889,33 @@ export class MarketThree {
       ...stripAccounts,
     ])
 
-    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-    const ix = await this.clmmProgram.methods
-      .buyYt(new BN(maxSyIn.toString()), new 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: 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] }
   }
@@ -885,7 +930,7 @@ export class MarketThree {
    *
    * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
    */
-  async ixSellYt({
+  ixSellYt({
     trader,
     ytIn,
     minSyOut,
@@ -894,12 +939,12 @@ export class MarketThree {
     syDst: syDstParam,
     lnImpliedApyLimit,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     ytIn: bigint
     minSyOut: bigint
-    ytSrc?: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    syDst?: web3.PublicKey
+    ytSrc?: PublicKey
+    ptSrc?: PublicKey
+    syDst?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
@@ -918,43 +963,47 @@ export class MarketThree {
       ...mergeAccounts,
     ])
 
-    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-    const ix = await this.clmmProgram.methods
-      .sellYt(new BN(ytIn.toString()), new 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: 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 }: { signer: web3.PublicKey; adminAction: MarketAdminAction }) {
-    return this.clmmProgram.methods
-      .modifyMarketSetting(adminAction)
-      .accountsStrict({
+  /** Apply an admin action to the market (e.g. change status, fees, tick spacing). */
+  ixModifyMarketSetting({ signer, adminAction }: { signer: PublicKey; adminAction: MarketAdminAction }) {
+    return exponentClmm.createModifyMarketSettingInstruction(
+      {
         market: this.selfAddress,
         signer,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction()
+        systemProgram: SystemProgram.programId,
+      },
+      { action: adminAction },
+    )
   }
 
   /**
@@ -968,7 +1017,7 @@ export 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({
+  ixAddFarm({
     signer,
     farmMint,
     farmTokenProgram,
@@ -977,13 +1026,13 @@ export class MarketThree {
     farmTokenSrc: farmTokenSrcParam,
     feePayer: feePayerParam,
   }: {
-    signer: web3.PublicKey
-    farmMint: web3.PublicKey
-    farmTokenProgram: web3.PublicKey
+    signer: PublicKey
+    farmMint: PublicKey
+    farmTokenProgram: PublicKey
     emissionsRate: bigint
     untilTimestamp: number
-    farmTokenSrc?: web3.PublicKey
-    feePayer?: web3.PublicKey
+    farmTokenSrc?: PublicKey
+    feePayer?: PublicKey
   }) {
     const feePayer = feePayerParam || signer
     const farmTokenEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
@@ -997,9 +1046,8 @@ export class MarketThree {
       farmTokenProgram,
     )
 
-    const ix = await this.clmmProgram.methods
-      .addFarm(new BN(emissionsRate.toString()), untilTimestamp)
-      .accountsStrict({
+    const ix = exponentClmm.createAddFarmInstruction(
+      {
         market: this.selfAddress,
         ticks: this.ticksKey,
         signer,
@@ -1008,11 +1056,15 @@ export class MarketThree {
         tokenSource: farmTokenSrc,
         tokenFarm: farmTokenEscrow,
         tokenProgram: farmTokenProgram,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: SystemProgram.programId,
         eventAuthority: this.eventAuthority,
-        program: this.clmmProgram.programId,
-      })
-      .instruction()
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        tokenRate: emissionsRate,
+        untilTimestamp,
+      },
+    )
 
     return {
       ixs: [ix],
@@ -1034,7 +1086,7 @@ export 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({
+  ixModifyFarm({
     signer,
     farmMint,
     farmTokenProgram,
@@ -1042,19 +1094,18 @@ export class MarketThree {
     untilTimestamp,
     farmTokenSrc: farmTokenSrcParam,
   }: {
-    signer: web3.PublicKey
-    farmMint: web3.PublicKey
-    farmTokenProgram: web3.PublicKey
+    signer: PublicKey
+    farmMint: PublicKey
+    farmTokenProgram: PublicKey
     newRate: bigint
     untilTimestamp: number
-    farmTokenSrc?: web3.PublicKey
+    farmTokenSrc?: PublicKey
   }) {
     const farmTokenEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
     const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
 
-    const ix = await this.clmmProgram.methods
-      .modifyFarm(untilTimestamp, new BN(newRate.toString()))
-      .accountsStrict({
+    const ix = exponentClmm.createModifyFarmInstruction(
+      {
         market: this.selfAddress,
         ticks: this.ticksKey,
         signer,
@@ -1063,15 +1114,30 @@ export 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,
@@ -1081,12 +1147,12 @@ export class MarketThree {
     tokenBaseTrader: tokenBaseTraderParam,
     lnImpliedApyLimit,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     minPtOut: bigint
     baseIn: bigint
-    tokenSyTrader?: web3.PublicKey
-    tokenPtTrader?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const tokenSyTrader =
@@ -1131,33 +1197,31 @@ export class MarketThree {
       ...this.cpiSyAccounts.getPositionState,
     ])
 
-    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-
-    const ix = await this.clmmProgram.methods
-      .buyPt(
-        new BN(minPtOut.toString()),
-        new 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: 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 }))],
@@ -1165,6 +1229,17 @@ export class MarketThree {
     }
   }
 
+  /**
+   * 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,
@@ -1174,12 +1249,12 @@ export class MarketThree {
     tokenBaseTrader: tokenBaseTraderParam,
     lnImpliedApyLimit,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amount: bigint
     minBaseOut: bigint
-    tokenSyTrader?: web3.PublicKey
-    tokenPtTrader?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
     lnImpliedApyLimit?: number
   }) {
     const tokenSyTrader =
@@ -1224,33 +1299,31 @@ export class MarketThree {
       ...this.cpiSyAccounts.withdrawSy,
     ])
 
-    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
-
-    const ix = await this.clmmProgram.methods
-      .sellPt(
-        new BN(amount.toString()),
-        new 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: 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 }))],
@@ -1258,6 +1331,16 @@ export class MarketThree {
     }
   }
 
+  /**
+   * 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,
@@ -1267,13 +1350,13 @@ export class MarketThree {
     tokenYtTrader: tokenYtTraderParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     ytOut: bigint
     maxBaseIn: bigint
-    tokenSyTrader?: web3.PublicKey
-    tokenPtTrader?: web3.PublicKey
-    tokenYtTrader?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenYtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
   }) {
     const tokenSyTrader =
       tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1311,7 +1394,7 @@ export class MarketThree {
       depositorSyTokenAccount: tokenSyTrader,
     })
 
-    const depositYtAccounts = await this.depositYtAccounts({
+    const depositYtAccounts = this.depositYtAccounts({
       owner,
       ytSrc: tokenYtTrader,
     })
@@ -1329,14 +1412,8 @@ export 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 BN(ytOut.toString()),
-        new BN(maxBaseIn.toString()),
-        mintSyRemAccounts.length,
-        depositYtAccounts_until,
-      )
-      .accountsStrict({
+    const ix1 = exponentClmm.createWrapperBuyYtInstruction(
+      {
         buyer: owner,
         market: this.selfAddress,
         tokenSyTrader,
@@ -1344,20 +1421,26 @@ export class MarketThree {
         tokenPtTrader,
         tokenSyEscrow: this.tokenSyEscrow,
         tokenPtEscrow: this.tokenPtEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
         marketAddressLookupTable: this.addressLookupTable,
         tokenProgram: TOKEN_PROGRAM_ID,
         syProgram: this.syProgram,
-        systemProgram: web3.SystemProgram.programId,
+        systemProgram: 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],
@@ -1365,6 +1448,16 @@ export class MarketThree {
     }
   }
 
+  /**
+   * 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,
@@ -1374,13 +1467,13 @@ export class MarketThree {
     tokenYtTrader: tokenYtTraderParam,
     tokenPtTrader: tokenPtTraderParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amount: bigint
     minBaseOut: bigint
-    tokenBaseTrader?: web3.PublicKey
-    tokenSyTrader?: web3.PublicKey
-    tokenYtTrader?: web3.PublicKey
-    tokenPtTrader?: web3.PublicKey
+    tokenBaseTrader?: PublicKey
+    tokenSyTrader?: PublicKey
+    tokenYtTrader?: PublicKey
+    tokenPtTrader?: PublicKey
   }) {
     const tokenBaseTrader =
       tokenBaseTraderParam ||
@@ -1426,6 +1519,11 @@ export class MarketThree {
 
     const redeemSyRemAccounts = redeemSyIx.keys
 
+    const withdrawYtAccounts = this.withdrawYtAccounts({
+      owner,
+      ytDst: tokenYtTrader,
+    })
+
     const remainingAccounts = uniqueRemainingAccounts([
       ...this.cpiSyAccounts.getSyState,
       ...this.cpiSyAccounts.getPositionState,
@@ -1434,29 +1532,36 @@ export class MarketThree {
       ...this.cpiSyAccounts.depositSy,
     ])
 
-    const ix1 = await this.clmmProgram.methods
-      .wrapperSellYt(new BN(amount.toString()), new 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: 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 }))],
@@ -1464,7 +1569,20 @@ export class MarketThree {
     }
   }
 
-  /** 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,
@@ -1477,16 +1595,16 @@ export class MarketThree {
     tokenBaseDepositor: tokenBaseDepositorParam,
     lpPosition: lpPositionParam,
   }: {
-    depositor: web3.PublicKey
+    depositor: PublicKey
     amountBase: bigint
     minLpOut: bigint
     lowerTickApy: number
     upperTickApy: number
-    tokenSyDepositor?: web3.PublicKey
-    tokenYtDepositor?: web3.PublicKey
-    tokenPtDepositor?: web3.PublicKey
-    tokenBaseDepositor?: web3.PublicKey
-    lpPosition?: web3.Keypair
+    tokenSyDepositor?: PublicKey
+    tokenYtDepositor?: PublicKey
+    tokenPtDepositor?: PublicKey
+    tokenBaseDepositor?: PublicKey
+    lpPosition?: Keypair | PublicKey
   }) {
     const tokenSyDepositor =
       tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
@@ -1498,7 +1616,7 @@ export class MarketThree {
       tokenBaseDepositorParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
 
-    const lpPosition = lpPositionParam || web3.Keypair.generate()
+    const lpPosition = lpPositionParam || Keypair.generate()
 
     const tokenSyDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       depositor,
@@ -1519,9 +1637,6 @@ export class MarketThree {
       this.mintPt,
     )
 
-    const amountBaseBn = new BN(amountBase.toString())
-    const minLpOutBn = new BN(minLpOut.toString())
-
     const mintSyIx = await this.flavor.ixMintSy({
       // argument does not matter - since we are just getting the keys
       amountBase: "0",
@@ -1539,47 +1654,51 @@ export class MarketThree {
       ...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: web3.SystemProgram.programId,
         tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
         marketAddressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        lpPosition: lpPosition instanceof Keypair ? lpPosition.publicKey : lpPosition,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
+        rent: 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()
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        lowerTick: convertApyToApyBp(lowerTickApy),
+        upperTick: convertApyToApyBp(upperTickApy),
+        amountBase,
+        minLpOut,
+        mintSyRemAccountsUntil: mintSyRemAccounts.length,
+        depositYtAccountsUntil: depositAccountsUntil,
+      },
+    )
+    ix.keys.push(...allRemainingAccounts)
 
-    // console.log("ix accounts length", ix.keys.length)
+    if (lpPosition instanceof Keypair) {
+      ix.keys.find((k) => k.pubkey.equals(lpPosition.publicKey))!.isSigner = true
+    }
 
     return {
       ixs: [
@@ -1587,11 +1706,25 @@ export class MarketThree {
         ix,
         ...(await this.flavor.postIxs({ signer: depositor })),
       ],
-      signers: [lpPosition],
+      signers: lpPosition instanceof 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,
@@ -1603,17 +1736,19 @@ export class MarketThree {
     tokenYtDepositor: tokenYtDepositorParam,
     tokenPtDepositor: tokenPtDepositorParam,
     tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPositionParam,
   }: {
-    depositor: web3.PublicKey
+    depositor: PublicKey
     amountBase: bigint
     amountPt: bigint
     minLpOut: bigint
     lowerTickApy: number
     upperTickApy: number
-    tokenSyDepositor?: web3.PublicKey
-    tokenYtDepositor?: web3.PublicKey
-    tokenPtDepositor?: web3.PublicKey
-    tokenBaseDepositor?: web3.PublicKey
+    tokenSyDepositor?: PublicKey
+    tokenYtDepositor?: PublicKey
+    tokenPtDepositor?: PublicKey
+    tokenBaseDepositor?: PublicKey
+    lpPositionParam?: Keypair | PublicKey
   }) {
     const tokenSyDepositor =
       tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
@@ -1625,7 +1760,7 @@ export class MarketThree {
       tokenBaseDepositorParam ||
       getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
 
-    const lpPosition = web3.Keypair.generate()
+    const lpPosition = lpPositionParam || Keypair.generate()
 
     const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(
       depositor,
@@ -1669,33 +1804,167 @@ export class MarketThree {
 
     const mintSyRemAccounts = mintSyIx.keys
 
-    const ix = await this.clmmProgram.methods
-      .wrapperProvideLiquidityClassic(
-        convertApyToApyBp(lowerTickApy),
-        convertApyToApyBp(upperTickApy),
-        new BN(amountBase.toString()),
-        new BN(amountPt.toString()),
-        new 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: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        tokenPtDepositor,
-        tokenSyDepositor,
-        systemProgram: web3.SystemProgram.programId,
+        syProgram: this.syProgram,
+        lpPosition: lpPosition instanceof Keypair ? lpPosition.publicKey : lpPosition,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
+        rent: 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 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 Keypair ? [lpPosition] : [],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  async ixProvideLiquidityBase({
+    depositor,
+    externalPtToBuy,
+    externalSyConstraint,
+    minLpOut,
+    lowerTickApy,
+    upperTickApy,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPositionParam,
+  }: {
+    depositor: PublicKey
+    externalPtToBuy: bigint
+    externalSyConstraint: bigint
+    minLpOut: bigint
+    lowerTickApy: number
+    upperTickApy: number
+    tokenSyDepositor?: PublicKey
+    tokenYtDepositor?: PublicKey
+    tokenPtDepositor?: PublicKey
+    tokenBaseDepositor?: PublicKey
+    lpPositionParam?: Keypair | PublicKey
+  }) {
+    const tokenSyDepositor =
+      tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenYtDepositor =
+      tokenYtDepositorParam || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenPtDepositor =
+      tokenPtDepositorParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    const tokenBaseDepositor =
+      tokenBaseDepositorParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
+
+    const lpPosition = lpPositionParam || Keypair.generate()
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenSyDepositor,
+      depositor,
+      this.mintSy,
+    )
+    const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenYtDepositor,
+      depositor,
+      this.mintYt,
+    )
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenPtDepositor,
+      depositor,
+      this.mintPt,
+    )
+    const tokenBaseAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenBaseDepositor,
+      depositor,
+      this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
+    )
+
+    const remainingAccounts = 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: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        lpPosition: lpPosition instanceof Keypair ? lpPosition.publicKey : lpPosition,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
+        rent: 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 Keypair) {
+      ix.keys.find((k) => k.pubkey.equals(lpPosition.publicKey))!.isSigner = true
+    }
 
     return {
       ixs: [
@@ -1703,7 +1972,7 @@ export class MarketThree {
         ix,
         ...(await this.flavor.postIxs({ signer: depositor })),
       ],
-      signers: [lpPosition],
+      signers: lpPosition instanceof Keypair ? [lpPosition] : [],
       setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
     }
   }
@@ -1718,14 +1987,14 @@ export class MarketThree {
     tokenPtWithdrawer: tokenPtWithdrawerParam,
     tokenBaseWithdrawer: tokenBaseWithdrawerParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amountLp: bigint
     minBaseOut: bigint
-    lpPosition: web3.PublicKey
-    tokenSyWithdrawer?: web3.PublicKey
-    tokenYtWithdrawer?: web3.PublicKey
-    tokenPtWithdrawer?: web3.PublicKey
-    tokenBaseWithdrawer?: web3.PublicKey
+    lpPosition: PublicKey
+    tokenSyWithdrawer?: PublicKey
+    tokenYtWithdrawer?: PublicKey
+    tokenPtWithdrawer?: PublicKey
+    tokenBaseWithdrawer?: PublicKey
   }) {
     const tokenSyWithdrawer =
       tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1764,32 +2033,32 @@ export class MarketThree {
 
     const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate
 
-    const ix = await this.clmmProgram.methods
-      .wrapperWithdrawLiquidity(
-        new BN(amountLp.toString()),
-        new 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: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        eventAuthority: this.eventAuthority,
         syProgram: this.syProgram,
-        systemProgram: web3.SystemProgram.programId,
         tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        tokenPtWithdrawer,
-        tokenSyWithdrawer,
-        withdrawer: owner,
-        ticks: this.ticksKey,
         tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
-        program: this.clmmProgram.programId,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        lpPosition,
+        systemProgram: 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 }))],
@@ -1806,13 +2075,13 @@ export class MarketThree {
     tokenPtWithdrawer: tokenPtWithdrawerParam,
     tokenBaseWithdrawer: tokenBaseWithdrawerParam,
   }: {
-    owner: web3.PublicKey
+    owner: PublicKey
     amountLp: bigint
-    lpPosition: web3.PublicKey
-    tokenSyWithdrawer?: web3.PublicKey
-    tokenYtWithdrawer?: web3.PublicKey
-    tokenPtWithdrawer?: web3.PublicKey
-    tokenBaseWithdrawer?: web3.PublicKey
+    lpPosition: PublicKey
+    tokenSyWithdrawer?: PublicKey
+    tokenYtWithdrawer?: PublicKey
+    tokenPtWithdrawer?: PublicKey
+    tokenBaseWithdrawer?: PublicKey
   }) {
     const tokenSyWithdrawer =
       tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
@@ -1849,26 +2118,29 @@ export class MarketThree {
 
     const redeemSyRemAccounts = redeemSyIx.keys
 
-    const ixn = await this.clmmProgram.methods
-      .wrapperWithdrawLiquidityClassic(new 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: TOKEN_PROGRAM_ID,
         marketAddressLookupTable: this.addressLookupTable,
-        eventAuthority: this.eventAuthority,
         syProgram: this.syProgram,
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        tokenPtWithdrawer,
-        tokenSyWithdrawer,
-        withdrawer: owner,
-        ticks: this.ticksKey,
-        program: this.clmmProgram.programId,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        lpPosition,
+        systemProgram: 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 }))],
@@ -1876,54 +2148,128 @@ export class MarketThree {
     }
   }
 
-async getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey) {
-    const lpPositions = await (
-      await this.clmmProgram.account.lpPosition.all()
-    ).filter(
-      (lpPos) =>
-        lpPos.account.owner.toString() === owner.toString() && lpPos.account.market.toString() === market.toString(),
+  async ixAddLiquidity({
+    owner,
+    ptInIntent,
+    syInIntent,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPosition,
+  }: {
+    owner: PublicKey
+    /** Intended (maximum) amount of PT in */
+    ptInIntent: bigint
+    /** Intended (maximum) amount of SY in */
+    syInIntent: bigint
+    tokenSyDepositor?: PublicKey
+    tokenYtDepositor?: PublicKey
+    tokenPtDepositor?: PublicKey
+    tokenBaseDepositor?: PublicKey
+    lpPosition: PublicKey
+  }) {
+    const tokenSyDepositor =
+      tokenSyDepositorParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtDepositor =
+      tokenYtDepositorParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtDepositor =
+      tokenPtDepositorParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseDepositor =
+      tokenBaseDepositorParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenSyDepositor, owner, this.mintSy)
+    const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenYtDepositor, owner, this.mintYt)
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenPtDepositor, owner, this.mintPt)
+    const tokenBaseAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseDepositor,
+      owner,
+      this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
+    )
+
+    const remainingAccounts = 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 Keypair ? lpPosition.publicKey : lpPosition,
+        tokenPtSrc: tokenPtDepositor,
+        tokenSySrc: tokenSyDepositor,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
+        rent: 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 Keypair ? [lpPosition] : [],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  async getUserLpPositions(owner: PublicKey, market: PublicKey) {
+    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.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 }: { owner: web3.PublicKey; lpPosition: web3.PublicKey }) {
+
+  ixMarketAccureEmissions({ owner, lpPosition }: { owner: PublicKey; lpPosition: PublicKey }) {
     const remainingAccounts = uniqueRemainingAccounts([...this.cpiSyAccounts.getPositionState])
-    const ixn = await this.clmmProgram.methods
-      .marketAccrueEmission()
-      .accountsStrict({
-        market: this.selfAddress,
-        systemProgram: web3.SystemProgram.programId,
-        ticks: this.ticksKey,
-        program: this.clmmProgram.programId,
-        eventAuthority: this.eventAuthority,
-        lpPosition,
-        owner,
-        addressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    const ixn = exponentClmm.createMarketAccrueEmissionInstruction({
+      owner,
+      market: this.selfAddress,
+      ticks: this.ticksKey,
+      lpPosition,
+      addressLookupTable: this.addressLookupTable,
+      syProgram: this.syProgram,
+      systemProgram: SystemProgram.programId,
+      eventAuthority: this.eventAuthority,
+      program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+    })
+    ixn.keys.push(...remainingAccounts)
 
     return {
       ixs: [ixn],
@@ -2163,13 +2509,13 @@ async getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey) {
     }
   }
 
-  async depositYtAccounts({
+  depositYtAccounts({
     owner,
     ytSrc: ytSrcParam,
   }: {
-    owner: web3.PublicKey
-    ytSrc?: web3.PublicKey
-  }): Promise<web3.TransactionInstruction> {
+    owner: PublicKey
+    ytSrc?: PublicKey
+  }): TransactionInstruction {
     const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
     const userYieldPosition = this.corePda.yieldPosition({ vault: this.state.vault.selfAddress, owner })
     const yieldPosition = this.corePda.vaultYieldPosition({ vault: this.state.vault.selfAddress })
@@ -2178,27 +2524,68 @@ async getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey) {
       depositor: owner,
       ytSrc,
       vault: this.state.vault.selfAddress,
-      userYieldPosition: userYieldPosition,
-      escrowYt: escrowYt,
+      userYieldPosition,
+      escrowYt,
       tokenProgram: TOKEN_PROGRAM_ID,
       syProgram: this.state.syProgram,
       addressLookupTable: this.vault.addressLookupTable,
       yieldPosition,
-      systemProgram: web3.SystemProgram.programId,
+      systemProgram: 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 BN(0))
-      .accountsStrict(mainAccounts)
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    const depositIx = exponentCore.createDepositYtInstruction(mainAccounts, { amount: 0n })
+    depositIx.keys.push(...remainingAccounts)
 
     return depositIx
   }
 
+  withdrawYtAccounts({
+    owner,
+    ytDst: ytDstParam,
+  }: {
+    owner: PublicKey
+    ytDst?: PublicKey
+  }): TransactionInstruction {
+    const ytDst = ytDstParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, 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: TOKEN_PROGRAM_ID,
+      authority: this.vault.authority,
+      syProgram: this.state.syProgram,
+      addressLookupTable: this.vault.addressLookupTable,
+      yieldPosition,
+      systemProgram: 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: MarketSnapshotData,
     marketSnapshotDataHistory: MarketSnapshotData,
@@ -2313,6 +2700,42 @@ async getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey) {
     }
   }
 
+  /**
+   * 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: {
+    financials: MarketThreeFinancials
+    currentSpotPrice: number
+    syExchangeRate: number
+    timestampUnix?: number
+  }): {
+    tvlInBaseToken: number
+    ptLiquidityInBaseToken: number
+    syLiquidityInBaseToken: number
+  } {
+    const { financials, currentSpotPrice, syExchangeRate, timestampUnix = Date.now() / 1000 } = params
+
+    const secondsRemaining = Math.max(0, Number(financials.expirationTs) - timestampUnix)
+
+    const ptPriceInBaseToken = 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: MarketSnapshotData,
     marketSnapshotDataHistory: MarketSnapshotData,