@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/src/marketThree.ts

@@ -0,0 +1,2853 @@
+import {
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+} from "@solana/spl-token"
+import bs58 from "bs58"
+import Decimal from "decimal.js"
+
+import { ExponentCLMMPDA } from "@exponent-labs/exponent-clmm-pda"
+import {
+  ExponentFetcher,
+  LiquidityNetBalanceLimits,
+  LpFarm,
+  LpPositionCLMM,
+  MarketConfigurationOptions,
+  MarketThreeFinancials,
+  Ticks,
+} from "@exponent-labs/exponent-fetcher"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import {
+  AnchorizedPNum,
+  CpiAccountsRaw,
+  ExponentCoreCpiAccountsRaw,
+  Flavor,
+  SyPosition,
+} from "@exponent-labs/exponent-types"
+import { LiquidityAdd } from "@exponent-labs/market-math"
+import {
+  EffSnap,
+  calcDepositSyAndPtFromBaseAmount,
+  calcPtPriceInAsset,
+  computeLiquidityTargetAndTokenNeeds,
+  getPtAndSyOnWithdrawLiquidity,
+  normalizedTimeRemaining,
+} from "@exponent-labs/market-three-math"
+
+import {
+  fetchAddressLookupTable,
+  makeCpiAccountMetaLists,
+  makeMarketCoreCpiAccountMetaLists,
+} from "./addressLookupTableUtil"
+import { Environment } from "./environment"
+import {
+  makeFlavorGenericSync,
+  makeFlavorJitoRestakingSync,
+  makeFlavorKaminoSync,
+  makeFlavorMarginfiSync,
+  makeFlavorPerenaSync,
+} from "./flavors"
+import { makeSyPosition } from "./syPosition"
+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 }
+
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
+
+interface Emission {
+  /** Token account that holds emission tokens */
+  escrowAccountAddress: PublicKey
+
+  /** Mint for the emission token */
+  mint: PublicKey
+
+  /** Token program ID for the emission token */
+  tokenProgramAddress: PublicKey
+
+  /** How many emissions have been claimed by SY holders */
+  totalClaimed: bigint
+
+  /** How many emissions have been earned by the SY robot over its lifetime */
+  lastSeenTotalAccruedEmissions: bigint
+
+  /** Global index for sharing out rewards to SY holders */
+  index: AnchorizedPNum
+}
+
+export type MarketAdminAction = exponentClmm.MarketAdminAction
+
+export { SwapDirection } from './client/clmm'
+
+interface MarketThreeLoadOptions {
+  syConfig?: {
+    skipWrap?: boolean
+  }
+}
+
+type MarketThreeArgs = {
+  admin: PublicKey
+  addressLookupTable: PublicKey
+  mintPt: PublicKey
+  mintYt: PublicKey
+  mintSy: PublicKey
+  vault: Vault
+  tokenPtEscrow: PublicKey
+  tokenSyEscrow: PublicKey
+  tokenYtEscrow: PublicKey
+  tokenFeeTreasurySy: PublicKey
+  tokenFeeTreasuryPt: PublicKey
+  syProgram: PublicKey
+  selfAddress: PublicKey
+  statusFlags: number
+  configurationOptions: MarketConfigurationOptions
+  financials: MarketThreeFinancials
+  cpiSyAccounts: CpiAccountsRaw
+  cpiCoreAccounts: ExponentCoreCpiAccountsRaw
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  flavor: Flavor
+  emissions: {
+    trackers: {
+      tokenEscrow: PublicKey
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  ticksAccount: PublicKey
+  ticks: Ticks
+  syPosition: SyPosition
+  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 {
+  xponPda: ExponentPDA
+  pda: ExponentCLMMPDA
+
+  constructor(
+    public state: MarketThreeArgs,
+    public selfAddress: PublicKey,
+    public env: Environment,
+    public connection: Connection,
+  ) {
+    this.xponPda = new ExponentPDA(env.coreProgramId)
+    this.pda = new ExponentCLMMPDA()
+  }
+  /**
+   * Build the modify_market_setting instruction without loading the full market.
+   * Use this when the market's ALT is invalid/unset (e.g. repair flow) to avoid fetching the ALT.
+   */
+  static buildModifyMarketSettingIx(
+    connection: 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: Connection,
+    address: PublicKey,
+    vault?: Vault,
+    ticks?: Ticks,
+    options: MarketThreeLoadOptions = {},
+  ): Promise<MarketThree> {
+    const fetcher = new ExponentFetcher({ connection })
+    const fetchedMarket = await fetcher.fetchMarketThree(address)
+    const [alt, loadedVault, loadedTicks] = await Promise.all([
+      fetchAddressLookupTable(connection, fetchedMarket.addressLookupTable),
+      vault || Vault.load(env, connection, fetchedMarket.vault, options),
+      ticks || fetcher.fetchMarketThreeTicks(fetchedMarket.ticks),
+    ])
+    const cpiSyAccounts = makeCpiAccountMetaLists(alt, fetchedMarket.cpiSyAccounts)
+    const cpiCoreAccounts = makeMarketCoreCpiAccountMetaLists(alt, fetchedMarket.cpiCoreAccounts)
+
+    const flavor = (() => {
+      switch (loadedVault.flavor.flavor) {
+        case "marginfi":
+          return makeFlavorMarginfiSync(loadedVault.flavor)
+        case "kamino":
+          return makeFlavorKaminoSync(loadedVault.flavor)
+        case "jitoRestaking":
+          return makeFlavorJitoRestakingSync(loadedVault.flavor)
+        case "perena":
+          return makeFlavorPerenaSync(loadedVault.flavor)
+        case "generic":
+          return makeFlavorGenericSync(loadedVault.flavor, options.syConfig)
+        default:
+          throw new Error(`Unknown flavor: ${loadedVault.flavor}`)
+      }
+    })()
+
+    const syPosition = await makeSyPosition(fetcher, flavor, fetchedMarket.syProgram, address)
+
+    //? Assuming that the owner is the same for both accounts feeAccounts
+    const treasuryFeeOwner = await MarketThree.fetchTreasuryFeeOwner(fetchedMarket.tokenFeeTreasuryPt, connection)
+
+    const state: MarketThreeArgs = {
+      ...fetchedMarket,
+      vault: loadedVault,
+      flavor,
+      ticks: loadedTicks,
+      syPosition,
+      cpiSyAccounts,
+      cpiCoreAccounts,
+      ticksAccount: fetchedMarket.ticks,
+      treasuryFeeOwner,
+    }
+    return new MarketThree(state, address, env, connection)
+  }
+
+  async reload(connection: Connection = this.connection) {
+    const market = await MarketThree.load(this.env, connection, this.selfAddress)
+    this.state = market.state
+    return market
+  }
+
+  get vault() {
+    return this.state.vault
+  }
+
+  get flavor() {
+    return this.state.flavor
+  }
+
+  get lpBalance() {
+    return this.state.financials.liquidityBalance
+  }
+
+  get syBalance() {
+    return this.state.financials.syBalance
+  }
+
+  get ptBalance() {
+    return this.state.financials.ptBalance
+  }
+
+  get mintSy() {
+    return this.state.mintSy
+  }
+
+  get mintPt() {
+    return this.state.mintPt
+  }
+
+  get statusFlags() {
+    return this.state.statusFlags
+  }
+
+  get mintYt() {
+    return this.state.mintYt
+  }
+
+  get addressLookupTable() {
+    return this.state.addressLookupTable
+  }
+
+  get syProgram() {
+    return this.state.syProgram
+  }
+
+  get cpiSyAccounts() {
+    return this.state.cpiSyAccounts
+  }
+
+  get cpiCoreAccounts() {
+    return this.state.cpiCoreAccounts
+  }
+
+  get marketEmissions() {
+    return this.state.emissions
+  }
+
+  get ticksKey() {
+    return this.state.ticksAccount
+  }
+
+  get corePda() {
+    return new ExponentPDA()
+  }
+
+  get coreEventAuthority() {
+    return emitEventAuthority(exponentCore.EXPONENTCORE_PROGRAM_ID)
+  }
+
+  get emissions(): Emission[] {
+    if (this.flavor.flavor === "marginfi") {
+      return this.flavor.mfiSyState.account.emissions.map((e) => ({
+        escrowAccountAddress: e.escrowAccount,
+        mint: e.mint,
+        tokenProgramAddress: e.tokenProgram,
+        totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+        lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+        index: e.index,
+      }))
+    }
+    if (this.flavor.flavor === "kamino") {
+      return this.flavor.kaminoSyState.account.emissions.map((e) => ({
+        escrowAccountAddress: e.escrowAccount,
+        mint: e.mint,
+        tokenProgramAddress: e.tokenProgram,
+        totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+        lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+        index: e.index,
+      }))
+    }
+    if (this.flavor.flavor === "jitoRestaking") {
+      return this.flavor.jitoSyState.account.emissions.map((e) => ({
+        escrowAccountAddress: e.escrowAccount,
+        mint: e.mint,
+        tokenProgramAddress: e.tokenProgram,
+        totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+        lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+        index: e.index,
+      }))
+    }
+    if (this.flavor.flavor === "perena") {
+      return this.flavor.perenaSyState.account.emissions.map((e) => ({
+        escrowAccountAddress: e.escrowAccount,
+        mint: e.mint,
+        tokenProgramAddress: e.tokenProgram,
+        totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+        lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+        index: e.index,
+      }))
+    }
+    if (this.flavor.flavor === "generic") {
+      return this.flavor.genericSyState.account.emissions.map((e) => ({
+        escrowAccountAddress: e.escrowAccount,
+        mint: e.mint,
+        tokenProgramAddress: e.tokenProgram,
+        totalClaimed: BigInt(e.totalClaimedEmissions.toString()),
+        lastSeenTotalAccruedEmissions: BigInt(e.lastSeenTotalAccruedEmissions.toString()),
+        index: e.index,
+      }))
+    }
+    throw new Error("Unknown flavor")
+  }
+
+  /** Get the escrow token account addresses for the emissions, in order */
+  get emissionTokenAccounts(): PublicKey[] {
+    return this.emissions.map((e) => e.escrowAccountAddress)
+  }
+
+  /** Pass-through SY account owned by the market */
+  get tokenSyEscrow(): PublicKey {
+    return this.state.tokenSyEscrow
+  }
+
+  /** Pass-through YT account owned by the market */
+  get tokenYtEscrow(): PublicKey {
+    return this.state.tokenYtEscrow
+  }
+
+  /** SY account that holds treasury SY fees from PT trading */
+  get tokenFeeTreasurySy(): PublicKey {
+    return this.state.tokenFeeTreasurySy
+  }
+
+  /** PT account that holds treasury PT fees from PT trading */
+  get tokenFeeTreasuryPt(): PublicKey {
+    return this.state.tokenFeeTreasuryPt
+  }
+
+  /** Market liquidity for PT */
+  get tokenPtEscrow(): PublicKey {
+    return this.state.tokenPtEscrow
+  }
+
+  get currentSyExchangeRate(): number {
+    return this.flavor.currentSyExchangeRate
+  }
+
+  /** Special account for event emit self-cpi */
+  get eventAuthority(): PublicKey {
+    return emitEventAuthority(exponentClmm.EXPONENTCLMM_PROGRAM_ID)
+  }
+
+  get secondsRemaining(): number {
+    const timeNow = Date.now() / 1000
+    return Math.max(0, Math.round(Number(this.state.financials.expirationTs) - timeNow))
+  }
+
+  /** Annualize a rate given the number of seconds remaining until maturity */
+  static annualize(rate: number, secondsRemaining: number) {
+    return (rate * SECONDS_PER_YEAR) / secondsRemaining
+  }
+
+  static annualizeApy(rate: number, secondsRemaining: number) {
+    return (1 + rate) ** (SECONDS_PER_YEAR / secondsRemaining) - 1
+  }
+
+  /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+  get feeTreasuryBps(): number {
+    return this.state.configurationOptions.treasuryFeeBps
+  }
+
+  /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+  get feeTreasuryRate(): number {
+    return this.feeTreasuryBps / 10_000
+  }
+
+  /** Get the owner of the treasury fee accounts: tokenFeeTreasuryPt & tokenFeeTreasurySy */
+  static async fetchTreasuryFeeOwner(
+    tokenFeeTreasury: PublicKey,
+    connection: Connection,
+  ): Promise<PublicKey> {
+    const { owner } = await getAccount(connection, tokenFeeTreasury)
+    return owner
+  }
+
+  /** Deposit a pair of tokens as liquidity to the market
+   * Adds PT & SY from the `depositor` to the market
+   *
+   * Due to unforeseeable slippage, the PT & SY amounts intended are effectively the maximum amounts
+   * The minimum LP tokens to receive is specified by `minLpOut`
+   *
+   * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
+   */
+  ixDepositLiquidity({
+    ptInIntent,
+    syInIntent,
+    depositor,
+    lowerTickKey,
+    upperTickKey,
+    ptSrc: ptSrcParam,
+    sySrc: sySrcParam,
+    lpPosition: lpPositionParam,
+  }: {
+    /** Intended (maximum) amount of PT in */
+    ptInIntent: bigint
+    /** Intended (maximum) amount of SY in */
+    syInIntent: bigint
+    /** Lower tick key */
+    lowerTickKey: number
+    /** Upper tick key */
+    upperTickKey: number
+    depositor: PublicKey
+    ptSrc?: PublicKey
+    sySrc?: PublicKey
+    lpPosition?: Keypair
+  }) {
+    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 || Keypair.generate()
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.depositSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const ix = exponentClmm.createDepositLiquidityInstruction(
+      {
+        depositor,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        lpPosition: lpPosition.publicKey,
+        tokenPtSrc: ptSrc,
+        tokenSySrc: sySrc,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        lowerTickKey: convertApyToApyBp(lowerTickKey),
+        upperTickKey: convertApyToApyBp(upperTickKey),
+        maxPtIn: ptInIntent,
+        maxSyIn: syInIntent,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return {
+      ix,
+      signers: lpPosition,
+    }
+  }
+
+  /**
+   * Redeem LP tokens for PT & SY  (liquidity removal)
+   *
+   * The lpIn is exactly the amount of LP tokens to burn
+   * The minimum PT & SY out are specified by minPtOut & minSyOut
+   * The transaction may fail due to unforeseeable slippage on the redemption rate
+   *
+   * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
+   */
+  ixWithdrawLiquidity({
+    lpIn,
+    withdrawer,
+    lpPosition,
+    minPtOut,
+    minSyOut,
+    ptDst: ptDstParam,
+    syDst: syDstParam,
+  }: {
+    lpIn: bigint
+    withdrawer: PublicKey
+    lpPosition: PublicKey
+    minPtOut: bigint
+    minSyOut: bigint
+    ptDst?: PublicKey
+    syDst?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
+    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
+    const ptDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, ptDst, withdrawer, this.mintPt)
+    const syDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, syDst, withdrawer, this.mintSy)
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const ix = exponentClmm.createWithdrawLiquidityInstruction(
+      {
+        owner: withdrawer,
+        market: this.selfAddress,
+        lpPosition,
+        ticks: this.ticksKey,
+        tokenPtDst: ptDst,
+        tokenSyDst: syDst,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        liquidityToRemove: lpIn,
+        minPtOut,
+        minSyOut,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return { ixs: [ix], setupIxs: [ptDstAtaIx, syDstAtaIx] }
+  }
+
+  /**
+   * Swap PT <-> SY on the CLMM.
+   *
+   * Low-level instruction — prefer {@link ixBuyPt} / {@link ixSellPt} for directional trades.
+   *
+   * @param trader - Wallet signing the transaction
+   * @param traderAmount - Amount of the input token
+   * @param outConstraint - Minimum output amount (slippage protection)
+   * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+   * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+   */
+  ixTradePt({
+    trader,
+    traderAmount,
+    outConstraint,
+    swapDirection,
+    tokenPt: tokenPtParam,
+    tokenSy: tokenSyParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    traderAmount: bigint
+    outConstraint: bigint
+    swapDirection: SwapDirection
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const tokenSy = tokenSyParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenSy, trader, this.mintSy)
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenPt, trader, this.mintPt)
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.depositSy,
+      ...this.cpiSyAccounts.withdrawSy,
+    ])
+
+    const ix = exponentClmm.createTradePtInstruction(
+      {
+        trader,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenSyTrader: tokenSy,
+        tokenPtTrader: tokenPt,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        amountIn: traderAmount,
+        swapDirection,
+        amountOutConstraint: outConstraint || null,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] }
+  }
+
+  /**
+   * Swap PT <-> SY specifying the exact output amount.
+   *
+   * Inverse of {@link ixTradePt} — the caller specifies how much they want to *receive*
+   * rather than how much they want to *spend*.
+   *
+   * @param trader - Wallet signing the transaction
+   * @param amountOut - Exact amount of the output token to receive
+   * @param swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+   * @param amountInConstraint - Maximum input amount (slippage protection)
+   * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+   */
+  ixTradePtExactOut({
+    trader,
+    amountOut,
+    swapDirection,
+    amountInConstraint,
+    tokenPt: tokenPtParam,
+    tokenSy: tokenSyParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    amountOut: bigint
+    swapDirection: SwapDirection
+    amountInConstraint?: bigint
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const tokenPt = tokenPtParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const tokenSy = tokenSyParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenSy, trader, this.mintSy)
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, tokenPt, trader, this.mintPt)
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.depositSy,
+      ...this.cpiSyAccounts.withdrawSy,
+    ])
+
+    const ix = exponentClmm.createTradePtExactOutInstruction(
+      {
+        trader,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenSyTrader: tokenSy,
+        tokenPtTrader: tokenPt,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        amountOut,
+        swapDirection,
+        amountInConstraint: amountInConstraint ?? null,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] }
+  }
+
+  /** Buy PT with SY
+   *
+   * The trader is the account that sends the SY
+   * The amountPt is the exact amount of PT the trader intends to buy
+   * The syConstraint is the maximum amount of SY the trader is willing to spend
+   *
+   * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+   */
+  ixBuyPt({
+    trader,
+    amountSy,
+    outConstraint,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    amountSy: bigint
+    outConstraint: bigint
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderAmount: amountSy,
+      outConstraint: outConstraint,
+      swapDirection: SwapDirection.SyToPt,
+      tokenPt,
+      tokenSy,
+      lnImpliedApyLimit,
+    })
+  }
+
+  /**
+   * Sell PT for SY
+   * The trader is the account that sends the PT
+   * The amountPt is the exact amount of PT the trader intends to sell
+   * The minSyReceive is the minimum amount of SY the trader is willing to receive
+   *
+   * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+   */
+  ixSellPt({
+    trader,
+    amountPt,
+    outConstraint,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    amountPt: bigint
+    outConstraint: bigint
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderAmount: amountPt,
+      outConstraint: outConstraint,
+      swapDirection: SwapDirection.PtToSy,
+      tokenPt,
+      tokenSy,
+      lnImpliedApyLimit,
+    })
+  }
+
+  /**
+   * Buy exact amount of PT with SY
+   *
+   * The trader specifies the exact amount of PT they want to receive
+   * The maxSyIn is the maximum amount of SY the trader is willing to spend
+   */
+  ixBuyPtExactOut({
+    trader,
+    amountPt,
+    maxSyIn,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    amountPt: bigint
+    maxSyIn?: bigint
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePtExactOut({
+      trader,
+      amountOut: amountPt,
+      amountInConstraint: maxSyIn,
+      swapDirection: SwapDirection.SyToPt,
+      tokenPt,
+      tokenSy,
+      lnImpliedApyLimit,
+    })
+  }
+
+  /**
+   * Sell PT for exact amount of SY
+   *
+   * The trader specifies the exact amount of SY they want to receive
+   * The maxPtIn is the maximum amount of PT the trader is willing to spend
+   */
+  ixSellPtExactOut({
+    trader,
+    amountSy,
+    maxPtIn,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    amountSy: bigint
+    maxPtIn?: bigint
+    tokenPt?: PublicKey
+    tokenSy?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePtExactOut({
+      trader,
+      amountOut: amountSy,
+      amountInConstraint: maxPtIn,
+      swapDirection: SwapDirection.PtToSy,
+      tokenPt,
+      tokenSy,
+      lnImpliedApyLimit,
+    })
+  }
+
+  /** Buy YT with SY
+   *
+   * The trader is the account that sends the SY
+   *
+   * The ytOut is the exact amount of YT the trader intends to buy
+   *
+   * The maxSyIn is the maximum amount of SY the trader is willing to spend
+   *
+   * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+   */
+  ixBuyYt({
+    trader,
+    ytOut,
+    maxSyIn,
+    ytTrader: ytTraderParam,
+    ptTrader: ptTraderParam,
+    syTrader: syTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    ytOut: bigint
+    maxSyIn: bigint
+    ytTrader?: PublicKey
+    ptTrader?: PublicKey
+    syTrader?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const syTrader = syTraderParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptTrader = ptTraderParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytTrader = ytTraderParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+
+    const syTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, syTrader, trader, this.mintSy)
+    const ptTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, ptTrader, trader, this.mintPt)
+    const ytTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, ytTrader, trader, this.mintYt)
+
+    const stripAccounts = this.cpiCoreAccounts.stripSy
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.depositSy,
+      ...stripAccounts,
+    ])
+
+    const ix = exponentClmm.createBuyYtInstruction(
+      {
+        trader,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenSyTrader: syTrader,
+        tokenYtTrader: ytTrader,
+        tokenPtTrader: ptTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        syIn: maxSyIn,
+        minYtOut: ytOut,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] }
+  }
+
+  /** Sell YT for SY
+   *
+   * The trader is the account that sends the YT
+   *
+   * The amountYt is the exact amount of YT the trader intends to sell
+   *
+   * The minSyOut is the minimum amount of SY the trader is willing to receive
+   *
+   * The token accounts themselves are optional, and will be derived from the trader's wallet if not provided
+   */
+  ixSellYt({
+    trader,
+    ytIn,
+    minSyOut,
+    ytSrc: ytSrcParam,
+    ptSrc: ptSrcParam,
+    syDst: syDstParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: PublicKey
+    ytIn: bigint
+    minSyOut: bigint
+    ytSrc?: PublicKey
+    ptSrc?: PublicKey
+    syDst?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+
+    const syDstAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, syDst, trader, this.mintSy)
+    const ptSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, ptSrc, trader, this.mintPt)
+    const ytSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, ytSrc, trader, this.mintYt)
+
+    const mergeAccounts = this.cpiCoreAccounts.mergeSy
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.depositSy,
+      ...mergeAccounts,
+    ])
+
+    const ix = exponentClmm.createSellYtInstruction(
+      {
+        trader,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenYtTrader: ytSrc,
+        tokenPtTrader: ptSrc,
+        tokenSyTrader: syDst,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        ytIn,
+        minSyOut,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+
+    return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] }
+  }
+
+  /** Apply an admin action to the market (e.g. change status, fees, tick spacing). */
+  ixModifyMarketSetting({ signer, adminAction }: { signer: PublicKey; adminAction: MarketAdminAction }) {
+    return exponentClmm.createModifyMarketSettingInstruction(
+      {
+        market: this.selfAddress,
+        signer,
+        systemProgram: SystemProgram.programId,
+      },
+      { action: adminAction },
+    )
+  }
+
+  /**
+   * Add a new farm to the market to distribute rewards to LP holders
+   *
+   * @param signer - The admin address that signs the transaction
+   * @param farmMint - The mint address of the farm reward token
+   * @param farmTokenProgram - The token program for the farm reward token
+   * @param emissionsRate - The rate of emissions per second (in token smallest units)
+   * @param untilTimestamp - Unix timestamp when the farm emissions should end
+   * @param farmTokenSrc - Optional source token account for the farm rewards (derived from signer if not provided)
+   * @param feePayer - Optional fee payer for account reallocation (defaults to signer)
+   */
+  ixAddFarm({
+    signer,
+    farmMint,
+    farmTokenProgram,
+    emissionsRate,
+    untilTimestamp,
+    farmTokenSrc: farmTokenSrcParam,
+    feePayer: feePayerParam,
+  }: {
+    signer: PublicKey
+    farmMint: PublicKey
+    farmTokenProgram: PublicKey
+    emissionsRate: bigint
+    untilTimestamp: number
+    farmTokenSrc?: PublicKey
+    feePayer?: PublicKey
+  }) {
+    const feePayer = feePayerParam || signer
+    const farmTokenEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
+    const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
+
+    const farmTokenEscrowAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      feePayer,
+      farmTokenEscrow,
+      this.selfAddress,
+      farmMint,
+      farmTokenProgram,
+    )
+
+    const ix = exponentClmm.createAddFarmInstruction(
+      {
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        signer,
+        feePayer,
+        mintNew: farmMint,
+        tokenSource: farmTokenSrc,
+        tokenFarm: farmTokenEscrow,
+        tokenProgram: farmTokenProgram,
+        systemProgram: SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        tokenRate: emissionsRate,
+        untilTimestamp,
+      },
+    )
+
+    return {
+      ixs: [ix],
+      setupIxs: [farmTokenEscrowAtaIx],
+    }
+  }
+
+  /**
+   * Modify an existing farm's emissions rate and/or expiration timestamp
+   *
+   * If the new parameters require more tokens than previously undistributed,
+   * additional tokens will be transferred from the signer's token account.
+   * If fewer tokens are needed, the surplus will be returned to the signer.
+   *
+   * @param signer - The admin address that signs the transaction
+   * @param farmMint - The mint address of the farm reward token
+   * @param farmTokenProgram - The token program for the farm reward token
+   * @param newRate - The new rate of emissions per second (in token smallest units)
+   * @param untilTimestamp - New unix timestamp when the farm emissions should end
+   * @param farmTokenSrc - Optional source/destination token account (derived from signer if not provided)
+   */
+  ixModifyFarm({
+    signer,
+    farmMint,
+    farmTokenProgram,
+    newRate,
+    untilTimestamp,
+    farmTokenSrc: farmTokenSrcParam,
+  }: {
+    signer: PublicKey
+    farmMint: PublicKey
+    farmTokenProgram: PublicKey
+    newRate: bigint
+    untilTimestamp: number
+    farmTokenSrc?: PublicKey
+  }) {
+    const farmTokenEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
+    const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
+
+    const ix = exponentClmm.createModifyFarmInstruction(
+      {
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        signer,
+        mint: farmMint,
+        tokenSource: farmTokenSrc,
+        tokenFarm: farmTokenEscrow,
+        tokenProgram: farmTokenProgram,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        newExpirationTimestamp: untilTimestamp,
+        newRate,
+      },
+    )
+
+    return {
+      ixs: [ix],
+    }
+  }
+
+  /**
+   * Buy PT directly from the base asset (e.g. SOL, USDC).
+   *
+   * Wraps a mint-SY step (via the flavor) with a buy-PT swap in a single instruction.
+   * The program mints SY from the base asset, then swaps SY -> PT on the CLMM.
+   *
+   * @param owner - Wallet signing the transaction
+   * @param baseIn - Amount of base asset to spend
+   * @param minPtOut - Minimum PT to receive (slippage protection)
+   * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+   */
+  async ixWrapperBuyPt({
+    owner,
+    minPtOut,
+    baseIn,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    owner: PublicKey
+    minPtOut: bigint
+    baseIn: bigint
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenSyTrader,
+      owner,
+      this.mintSy,
+    )
+    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenPtTrader,
+      owner,
+      this.mintPt,
+    )
+    const tokenBaseTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseTrader,
+      owner,
+      this.flavor.mintBase,
+    )
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      amountBase: "0",
+      depositor: owner,
+      depositorBaseTokenAccount: tokenBaseTrader,
+      depositorSyTokenAccount: tokenSyTrader,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.depositSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const ix = exponentClmm.createBuyPtInstruction(
+      {
+        buyer: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        ticks: this.ticksKey,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.state.tokenFeeTreasuryPt,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        minPtAmount: minPtOut,
+        baseAmount: baseIn,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+        mintSyRemAccountsUntil: mintSyRemAccounts.length,
+      },
+    )
+    ix.keys.push(...mintSyRemAccounts, ...remainingAccounts)
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  /**
+   * Sell PT and receive the base asset (e.g. SOL, USDC).
+   *
+   * Wraps a PT -> SY swap with a redeem-SY step (via the flavor) in a single instruction.
+   * The program swaps PT -> SY on the CLMM, then redeems SY for the base asset.
+   *
+   * @param owner - Wallet signing the transaction
+   * @param amount - Amount of PT to sell
+   * @param minBaseOut - Minimum base asset to receive (slippage protection)
+   * @param lnImpliedApyLimit - Optional price limit (ln implied APY)
+   */
+  async ixWrapperSellPt({
+    owner,
+    amount,
+    minBaseOut,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    owner: PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenSyTrader,
+      owner,
+      this.mintSy,
+    )
+    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenPtTrader,
+      owner,
+      this.mintPt,
+    )
+    const tokenBaseTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseTrader,
+      owner,
+      this.flavor.mintBase,
+    )
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: tokenBaseTrader,
+      redeemerSyTokenAccount: tokenSyTrader,
+    })
+
+    const redeemSyRemAccounts = redeemSyIx.keys
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.withdrawSy,
+    ])
+
+    const ix = exponentClmm.createSellPtInstruction(
+      {
+        seller: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        amountPt: amount,
+        minBaseAmount: minBaseOut,
+        priceSpotLimit: lnImpliedApyLimit ?? null,
+        redeemSyRemAccountsUntil: redeemSyRemAccounts.length,
+      },
+    )
+    ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts)
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  /**
+   * Buy YT directly from the base asset.
+   *
+   * Wraps a mint-SY step with a buy-YT swap. The program mints SY from the base asset,
+   * then strips SY into PT+YT and executes the trade.
+   *
+   * @param owner - Wallet signing the transaction
+   * @param ytOut - Amount of YT to buy
+   * @param maxBaseIn - Maximum base asset to spend (slippage protection)
+   */
+  async ixWrapperBuyYt({
+    owner,
+    ytOut,
+    maxBaseIn,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    owner: PublicKey
+    ytOut: bigint
+    maxBaseIn: bigint
+    tokenSyTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+    tokenYtTrader?: PublicKey
+    tokenBaseTrader?: PublicKey
+  }) {
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtTrader =
+      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenSyTrader,
+      owner,
+      this.mintSy,
+    )
+    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenPtTrader,
+      owner,
+      this.mintPt,
+    )
+    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenYtTrader,
+      owner,
+      this.mintYt,
+    )
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      amountBase: "0",
+      depositor: owner,
+      depositorBaseTokenAccount: tokenBaseTrader,
+      depositorSyTokenAccount: tokenSyTrader,
+    })
+
+    const depositYtAccounts = this.depositYtAccounts({
+      owner,
+      ytSrc: tokenYtTrader,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiCoreAccounts.stripSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const depositYtAccounts_until = mintSyRemAccounts.length + depositYtAccounts.keys.length
+    const allRemainingAccounts = mintSyRemAccounts.concat(depositYtAccounts.keys).concat(remainingAccounts)
+
+    const ix1 = exponentClmm.createWrapperBuyYtInstruction(
+      {
+        buyer: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenYtTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        systemProgram: SystemProgram.programId,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        ytOut,
+        maxBaseAmount: maxBaseIn,
+        mintSyAccountsLength: mintSyRemAccounts.length,
+        depositYtAccountsUntil: depositYtAccounts_until,
+      },
+    )
+    ix1.keys.push(...allRemainingAccounts)
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+    }
+  }
+
+  /**
+   * Sell YT and receive the base asset.
+   *
+   * Wraps a YT -> SY swap with a redeem-SY step. The program merges YT+PT back into SY,
+   * executes the trade, then redeems SY for the base asset.
+   *
+   * @param owner - Wallet signing the transaction
+   * @param amount - Amount of YT to sell
+   * @param minBaseOut - Minimum base asset to receive (slippage protection)
+   */
+  async ixWrapperSellYt({
+    owner,
+    amount,
+    minBaseOut,
+    tokenBaseTrader: tokenBaseTraderParam,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+  }: {
+    owner: PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenBaseTrader?: PublicKey
+    tokenSyTrader?: PublicKey
+    tokenYtTrader?: PublicKey
+    tokenPtTrader?: PublicKey
+  }) {
+    const tokenBaseTrader =
+      tokenBaseTraderParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    const tokenSyTrader =
+      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtTrader =
+      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtTrader =
+      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+
+    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenSyTrader,
+      owner,
+      this.mintSy,
+    )
+    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenPtTrader,
+      owner,
+      this.mintPt,
+    )
+    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenYtTrader,
+      owner,
+      this.mintYt,
+    )
+    const tokenBaseTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseTrader,
+      owner,
+      this.flavor.mintBase,
+    )
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: tokenBaseTrader,
+      redeemerSyTokenAccount: tokenSyTrader,
+    })
+
+    const redeemSyRemAccounts = redeemSyIx.keys
+
+    const withdrawYtAccounts = this.withdrawYtAccounts({
+      owner,
+      ytDst: tokenYtTrader,
+    })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiCoreAccounts.mergeSy,
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.depositSy,
+    ])
+
+    const withdrawYtAccountsUntil = redeemSyRemAccounts.length + withdrawYtAccounts.keys.length
+
+    const ix1 = exponentClmm.createWrapperSellYtInstruction(
+      {
+        seller: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenYtTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        exponentCoreProgram: exponentCore.EXPONENTCORE_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+      },
+      {
+        ytAmount: amount,
+        minBaseAmount: minBaseOut,
+        redeemSyAccountsUntil: redeemSyRemAccounts.length,
+        withdrawYtAccountsUntil,
+      },
+    )
+    ix1.keys.push(...redeemSyRemAccounts, ...withdrawYtAccounts.keys, ...remainingAccounts)
+
+    return {
+      ixs: [ix1, ...(await this.flavor.preIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  /**
+   * Provide concentrated liquidity from the base asset, receiving LP and YT tokens.
+   *
+   * Wraps a mint-SY step with a deposit-liquidity operation. The program mints SY from the
+   * base asset, strips some into PT, deposits PT+SY as liquidity in the specified tick range,
+   * and returns the leftover YT to the depositor.
+   *
+   * @param depositor - Wallet signing the transaction
+   * @param amountBase - Amount of base asset to deposit
+   * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+   * @param lowerTickApy - Lower APY bound for the liquidity range
+   * @param upperTickApy - Upper APY bound for the liquidity range
+   * @param lpPosition - Optional existing LP position keypair/address (new one generated if omitted)
+   */
+  async ixWrapperProvideLiquidity({
+    depositor,
+    amountBase,
+    minLpOut,
+    lowerTickApy,
+    upperTickApy,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPosition: lpPositionParam,
+  }: {
+    depositor: PublicKey
+    amountBase: bigint
+    minLpOut: bigint
+    lowerTickApy: number
+    upperTickApy: number
+    tokenSyDepositor?: PublicKey
+    tokenYtDepositor?: PublicKey
+    tokenPtDepositor?: PublicKey
+    tokenBaseDepositor?: PublicKey
+    lpPosition?: 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 tokenSyDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenSyDepositor,
+      depositor,
+      this.mintSy,
+    )
+    const tokenYtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenYtDepositor,
+      depositor,
+      this.mintYt,
+    )
+    const tokenPtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenPtDepositor,
+      depositor,
+      this.mintPt,
+    )
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      // argument does not matter - since we are just getting the keys
+      amountBase: "0",
+      depositor,
+      depositorBaseTokenAccount: tokenBaseDepositor,
+      depositorSyTokenAccount: tokenSyDepositor,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+
+    const unorderedRemainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiCoreAccounts.stripSy,
+      ...this.cpiSyAccounts.depositSy,
+    ])
+
+    const depositYtAccounts = this.depositYtAccounts({
+      owner: depositor,
+      ytSrc: tokenYtDepositor,
+    })
+    const depositAccountsUntil = mintSyRemAccounts.length + depositYtAccounts.keys.length
+    const allRemainingAccounts = [...mintSyRemAccounts, ...depositYtAccounts.keys, ...unorderedRemainingAccounts]
+
+    const ix = exponentClmm.createWrapperProvideLiquidityInstruction(
+      {
+        depositor,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenYtEscrow: this.tokenYtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenSyDepositor,
+        tokenYtDepositor,
+        tokenPtDepositor,
+        mintYt: this.vault.mintYt,
+        mintPt: this.vault.mintPt,
+        tokenProgram: 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,
+      },
+      {
+        lowerTick: convertApyToApyBp(lowerTickApy),
+        upperTick: convertApyToApyBp(upperTickApy),
+        amountBase,
+        minLpOut,
+        mintSyRemAccountsUntil: mintSyRemAccounts.length,
+        depositYtAccountsUntil: depositAccountsUntil,
+      },
+    )
+    ix.keys.push(...allRemainingAccounts)
+
+    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: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx],
+    }
+  }
+
+  /**
+   * Provide concentrated liquidity from a base asset plus existing PT tokens ("classic" mode).
+   *
+   * Unlike {@link ixWrapperProvideLiquidity}, this allows the depositor to supply PT they already
+   * hold instead of having the program strip SY into PT+YT. Useful when the depositor has leftover
+   * PT from a previous trade or wants finer control over token composition.
+   *
+   * @param depositor - Wallet signing the transaction
+   * @param amountBase - Amount of base asset to deposit (converted to SY internally)
+   * @param amountPt - Amount of PT to deposit alongside the base asset
+   * @param minLpOut - Minimum LP tokens to receive (slippage protection)
+   * @param lowerTickApy - Lower APY bound for the liquidity range
+   * @param upperTickApy - Upper APY bound for the liquidity range
+   */
+  async ixProvideLiquidityClassic({
+    depositor,
+    amountBase,
+    amountPt,
+    minLpOut,
+    lowerTickApy,
+    upperTickApy,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPositionParam,
+  }: {
+    depositor: PublicKey
+    amountBase: bigint
+    amountPt: 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.createWrapperProvideLiquidityClassicInstruction(
+      {
+        depositor,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenSyDepositor,
+        tokenPtDepositor,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        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: 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,
+        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: [
+        ...(await this.flavor.preIxs({ signer: depositor })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: depositor })),
+      ],
+      signers: lpPosition instanceof Keypair ? [lpPosition] : [],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  async ixWithdrawLiquidityToBase({
+    owner,
+    amountLp,
+    minBaseOut,
+    lpPosition,
+    tokenSyWithdrawer: tokenSyWithdrawerParam,
+    tokenYtWithdrawer: tokenYtWithdrawerParam,
+    tokenPtWithdrawer: tokenPtWithdrawerParam,
+    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
+  }: {
+    owner: PublicKey
+    amountLp: bigint
+    minBaseOut: bigint
+    lpPosition: PublicKey
+    tokenSyWithdrawer?: PublicKey
+    tokenYtWithdrawer?: PublicKey
+    tokenPtWithdrawer?: PublicKey
+    tokenBaseWithdrawer?: PublicKey
+  }) {
+    const tokenSyWithdrawer =
+      tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtWithdrawer =
+      tokenYtWithdrawerParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtWithdrawer =
+      tokenPtWithdrawerParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseWithdrawer =
+      tokenBaseWithdrawerParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenSyWithdrawer, owner, this.mintSy)
+    const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenYtWithdrawer, owner, this.mintYt)
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenPtWithdrawer, owner, this.mintPt)
+    const tokenBaseAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseWithdrawer,
+      owner,
+      this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
+    )
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: tokenBaseWithdrawer,
+      redeemerSyTokenAccount: tokenSyWithdrawer,
+    })
+
+    const redeemSyRemAccounts = redeemSyIx.keys
+
+    const minSyOut = Number(minBaseOut) / this.currentSyExchangeRate
+
+    const ix = exponentClmm.createWrapperWithdrawLiquidityInstruction(
+      {
+        withdrawer: owner,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenSyWithdrawer,
+        tokenPtWithdrawer,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        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 }))],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  async ixWithdrawLiquidityClassic({
+    owner,
+    amountLp,
+    lpPosition,
+    tokenSyWithdrawer: tokenSyWithdrawerParam,
+    tokenYtWithdrawer: tokenYtWithdrawerParam,
+    tokenPtWithdrawer: tokenPtWithdrawerParam,
+    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
+  }: {
+    owner: PublicKey
+    amountLp: bigint
+    lpPosition: PublicKey
+    tokenSyWithdrawer?: PublicKey
+    tokenYtWithdrawer?: PublicKey
+    tokenPtWithdrawer?: PublicKey
+    tokenBaseWithdrawer?: PublicKey
+  }) {
+    const tokenSyWithdrawer =
+      tokenSyWithdrawerParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    const tokenYtWithdrawer =
+      tokenYtWithdrawerParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenPtWithdrawer =
+      tokenPtWithdrawerParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    const tokenBaseWithdrawer =
+      tokenBaseWithdrawerParam ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+
+    const tokenSyAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenSyWithdrawer, owner, this.mintSy)
+    const tokenYtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenYtWithdrawer, owner, this.mintYt)
+    const tokenPtAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenPtWithdrawer, owner, this.mintPt)
+    const tokenBaseAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenBaseWithdrawer,
+      owner,
+      this.flavor.mintBase,
+      this.flavor.baseTokenProgram,
+    )
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: tokenBaseWithdrawer,
+      redeemerSyTokenAccount: tokenSyWithdrawer,
+    })
+
+    const redeemSyRemAccounts = redeemSyIx.keys
+
+    const ixn = exponentClmm.createWrapperWithdrawLiquidityClassicInstruction(
+      {
+        withdrawer: owner,
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenSyWithdrawer,
+        tokenPtWithdrawer,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        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 }))],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  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],
+    }
+  }
+
+  ixMarketAccureEmissions({ owner, lpPosition }: { owner: PublicKey; lpPosition: PublicKey }) {
+    const remainingAccounts = uniqueRemainingAccounts([...this.cpiSyAccounts.getPositionState])
+    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],
+    }
+  }
+
+  /**
+   * Calculate the current price per unit of liquidity (principal only) for a tick range.
+   * Mirrors the on-chain `liquidity_unit_price_in_asset` helper but performs the
+   * principal aggregation client-side using the fetched ticks account.
+   *
+   * @param lowerTickKey - Inclusive tick key (APY in parts-per-million) for the left boundary
+   * @param upperTickKey - Exclusive tick key for the right boundary
+   * @param ticksOverride - Optional ticks account (defaults to the instance state)
+   * @param syExchangeRateOverride - Optional SY exchange rate (defaults to current flavor rate)
+   * @returns Price per unit of liquidity in underlying asset terms (principal only)
+   */
+  liquidityUnitPriceInAsset({
+    lowerTickKey,
+    upperTickKey,
+    ticksOverride,
+    syExchangeRateOverride,
+  }: {
+    lowerTickKey: number
+    upperTickKey: number
+    ticksOverride?: Ticks
+    syExchangeRateOverride?: number
+  }): number {
+    if (lowerTickKey >= upperTickKey) {
+      throw new Error("lowerTickKey must be less than upperTickKey")
+    }
+
+    const ticksAccount = ticksOverride ?? this.state.ticks
+    if (!ticksAccount) {
+      throw new Error("Ticks account data is unavailable")
+    }
+
+    const relevantIntervals = ticksAccount.ticksTree.filter(
+      (tick) => tick.apyBasePoints >= lowerTickKey && tick.apyBasePoints < upperTickKey,
+    )
+
+    if (relevantIntervals.length === 0) {
+      return 0
+    }
+
+    let totalPrincipalPt = 0n
+    let totalPrincipalSy = 0n
+    let totalShareSupply = 0n
+
+    for (const interval of relevantIntervals) {
+      totalPrincipalPt += interval.principalPt
+      totalPrincipalSy += interval.principalSy
+      totalShareSupply += interval.principalShareSupply
+    }
+
+    if (totalShareSupply === 0n) {
+      return 0
+    }
+
+    const timeFactor = this.secondsRemaining / SECONDS_PER_YEAR
+    const ptAssetValuePerToken = Math.exp(-timeFactor * ticksAccount.currentSpotPrice)
+    const syExchangeRate = syExchangeRateOverride ?? this.currentSyExchangeRate
+
+    const principalPtValue = new Decimal(totalPrincipalPt.toString()).mul(ptAssetValuePerToken)
+    const principalSyValue = new Decimal(totalPrincipalSy.toString()).mul(syExchangeRate)
+    const principalValue = principalPtValue.plus(principalSyValue)
+
+    return principalValue.div(new Decimal(totalShareSupply.toString())).toNumber()
+  }
+
+  /**
+   * Compute fee growth inside a tick range using Uniswap V3 formula
+   *
+   * @param lowerTick - Lower tick boundary
+   * @param upperTick - Upper tick boundary
+   * @param feeGlobalPt - Optional: Override global PT fees (for historical calculations)
+   * @param feeGlobalSy - Optional: Override global SY fees (for historical calculations)
+   * @returns Object with inside_sy and inside_pt fee growth values
+   */
+  static computeFeeInsideForRange({
+    currentTickPrice,
+    lowerTickPrice,
+    upperTickPrice,
+    feeGrowthIndexGlobalPt,
+    feeGrowthIndexGlobalSy,
+    lowerTickOutsidePt,
+    lowerTickOutsideSy,
+    upperTickOutsidePt,
+    upperTickOutsideSy,
+  }: {
+    currentTickPrice: number
+    lowerTickPrice: number
+    upperTickPrice: number
+    feeGrowthIndexGlobalPt: bigint
+    feeGrowthIndexGlobalSy: bigint
+    lowerTickOutsidePt: bigint
+    lowerTickOutsideSy: bigint
+    upperTickOutsidePt: bigint
+    upperTickOutsideSy: bigint
+  }): { insideSy: bigint; insidePt: bigint } {
+    // Uniswap V3 formula for computing fee inside a range
+    let insideSy: bigint
+    let insidePt: bigint
+
+    if (currentTickPrice < lowerTickPrice) {
+      // Price below range: inside = outside(lower) - outside(upper)
+      insideSy = lowerTickOutsideSy - upperTickOutsideSy
+      insidePt = lowerTickOutsidePt - upperTickOutsidePt
+    } else if (currentTickPrice >= upperTickPrice) {
+      // Price above range: inside = outside(upper) - outside(lower)
+      insideSy = upperTickOutsideSy - lowerTickOutsideSy
+      insidePt = upperTickOutsidePt - lowerTickOutsidePt
+    } else {
+      // Price in range: inside = global - outside(lower) - outside(upper)
+      insideSy = feeGrowthIndexGlobalSy - lowerTickOutsideSy - upperTickOutsideSy
+      insidePt = feeGrowthIndexGlobalPt - lowerTickOutsidePt - upperTickOutsidePt
+    }
+
+    return { insideSy, insidePt }
+  }
+
+  /**
+   * Calculate claimable fees for a position
+   * Uses Q64.64 fixed-point math: tokens = floor((L * Δindex) >> 64)
+   *
+   * @param lpBalance - Position's liquidity balance
+   * @param feeInsideLastSy - Last snapshot of inside SY fee growth
+   * @param feeInsideLastPt - Last snapshot of inside PT fee growth
+   * @param currentInsideSy - Current inside SY fee growth
+   * @param currentInsidePt - Current inside PT fee growth
+   * @param tokensOwedSy - Previously owed SY fees
+   * @param tokensOwedPt - Previously owed PT fees
+   * @returns Object with claimable and total fees
+   */
+  static calculateClaimableFees({
+    lpBalance,
+    feeInsideLastSy,
+    feeInsideLastPt,
+    currentInsideSy,
+    currentInsidePt,
+    tokensOwedSy,
+    tokensOwedPt,
+  }: {
+    lpBalance: bigint
+    feeInsideLastSy: bigint
+    feeInsideLastPt: bigint
+    currentInsideSy: bigint
+    currentInsidePt: bigint
+    tokensOwedSy: bigint
+    tokensOwedPt: bigint
+  }): {
+    claimableSy: bigint
+    claimablePt: bigint
+    tokensOwedSy: bigint
+    tokensOwedPt: bigint
+    totalSy: bigint
+    totalPt: bigint
+  } {
+    // Calculate delta (growth since last snapshot)
+    const deltaSy = currentInsideSy > feeInsideLastSy ? currentInsideSy - feeInsideLastSy : 0n
+    const deltaPt = currentInsidePt > feeInsideLastPt ? currentInsidePt - feeInsideLastPt : 0n
+
+    // Calculate claimable fees using Q64.64 math: tokens = floor((L * Δindex) >> 64)
+    const claimableSy = (lpBalance * deltaSy) >> 64n
+    const claimablePt = (lpBalance * deltaPt) >> 64n
+
+    //? TotalPt and TotalSy don't make sense here because tokensOwedSy and tokensOwedPt are always 0
+    // Calculate totals
+    const totalSy = claimableSy + tokensOwedSy
+    const totalPt = claimablePt + tokensOwedPt
+
+    return {
+      claimableSy,
+      claimablePt,
+      tokensOwedSy,
+      tokensOwedPt,
+      totalSy,
+      totalPt,
+    }
+  }
+
+  /**
+   * Calculate historical fee APY for a tick range
+   *
+   * @param feeGrowthDeltaSy - Change in global SY fee growth over period
+   * @param feeGrowthDeltaPt - Change in global PT fee growth over period
+   * @param avgLiquidity - Average liquidity in the range during period
+   * @param hoursElapsed - Number of hours in the period
+   * @returns Object with fee APY metrics
+   */
+  static calculateHistoricalFeeApy({
+    feeGrowthDeltaSy,
+    feeGrowthDeltaPt,
+    avgLiquidity,
+    hoursElapsed,
+  }: {
+    feeGrowthDeltaSy: bigint
+    feeGrowthDeltaPt: bigint
+    avgLiquidity: bigint
+    hoursElapsed: number
+  }): {
+    feeApySy: number
+    feeApyPt: number
+    feeApyTotal: number
+    totalFeesSy: bigint
+    totalFeesPt: bigint
+  } {
+    if (avgLiquidity === 0n || hoursElapsed === 0) {
+      return {
+        feeApySy: 0,
+        feeApyPt: 0,
+        feeApyTotal: 0,
+        totalFeesSy: 0n,
+        totalFeesPt: 0n,
+      }
+    }
+
+    // Calculate total fees earned in the period using Q64.64 math
+    const totalFeesSy = (feeGrowthDeltaSy * avgLiquidity) >> 64n
+    const totalFeesPt = (feeGrowthDeltaPt * avgLiquidity) >> 64n
+
+    // Annualization factor (hours in a year / hours elapsed)
+    const hoursPerYear = 8760
+    const annualizationFactor = hoursPerYear / hoursElapsed
+
+    // Calculate APY as: (fees / avg_liquidity) * annualization_factor * 100
+    const feeApySy = (Number((totalFeesSy * 10000n) / avgLiquidity) / 100) * annualizationFactor
+    const feeApyPt = (Number((totalFeesPt * 10000n) / avgLiquidity) / 100) * annualizationFactor
+    const feeApyTotal = feeApySy + feeApyPt
+
+    return {
+      feeApySy,
+      feeApyPt,
+      feeApyTotal,
+      totalFeesSy,
+      totalFeesPt,
+    }
+  }
+
+  depositYtAccounts({
+    owner,
+    ytSrc: ytSrcParam,
+  }: {
+    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 })
+    const escrowYt = this.corePda.escrowYt({ vault: this.state.vault.selfAddress })
+    const mainAccounts = {
+      depositor: owner,
+      ytSrc,
+      vault: this.state.vault.selfAddress,
+      userYieldPosition,
+      escrowYt,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      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 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,
+    lowerPricePercentage: number,
+    upperPricePercentage: number,
+    baseTokenAmount: number,
+  ) {
+    //? Prices in format of 1 + percentage / 100
+    const lowerPrice = 1 + lowerPricePercentage / 100
+    //? Prices in format of 1 + percentage / 100
+    const upperPrice = 1 + upperPricePercentage / 100
+
+    const { syNeeded: userSyProvided, ptNeeded: userPtProvided } = calcDepositSyAndPtFromBaseAmount({
+      expirationTs:
+        Number(marketSnapshotDataCurrent.financials.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix,
+      currentSpotPrice: marketSnapshotDataCurrent.currentSpotPrice,
+      syExchangeRate: marketSnapshotDataCurrent.syExchangeRate,
+      lowerPrice,
+      upperPrice,
+      baseTokenAmount: baseTokenAmount,
+    })
+
+    const [lowerFeeGrowthOutsidePtHistory, lowerFeeGrowthOutsideSyHistory] =
+      lowerPrice <= marketSnapshotDataHistory.currentSpotPrice
+        ? [marketSnapshotDataHistory.feeGrowthIndexGlobalPt, marketSnapshotDataHistory.feeGrowthIndexGlobalSy]
+        : [0n, 0n]
+
+    const [upperFeeGrowthOutsidePtHistory, upperFeeGrowthOutsideSyHistory] =
+      upperPrice <= marketSnapshotDataHistory.currentSpotPrice
+        ? [marketSnapshotDataHistory.feeGrowthIndexGlobalPt, marketSnapshotDataHistory.feeGrowthIndexGlobalSy]
+        : [0n, 0n]
+
+    const { insideSy: insideSyHistory, insidePt: insidePtHistory } = MarketThree.computeFeeInsideForRange({
+      currentTickPrice: marketSnapshotDataHistory.currentSpotPrice,
+      lowerTickPrice: lowerPrice,
+      upperTickPrice: upperPrice,
+      feeGrowthIndexGlobalPt: marketSnapshotDataHistory.feeGrowthIndexGlobalPt,
+      feeGrowthIndexGlobalSy: marketSnapshotDataHistory.feeGrowthIndexGlobalSy,
+      lowerTickOutsidePt: lowerFeeGrowthOutsidePtHistory,
+      lowerTickOutsideSy: lowerFeeGrowthOutsideSyHistory,
+      upperTickOutsidePt: upperFeeGrowthOutsidePtHistory,
+      upperTickOutsideSy: upperFeeGrowthOutsideSyHistory,
+    })
+
+    const {
+      liquidityTarget: liquidityTargetCurrent,
+      syNeeded,
+      ptNeeded,
+    } = computeLiquidityTargetAndTokenNeedsForSnapshot(marketSnapshotDataCurrent, {
+      lowerPrice,
+      upperPrice,
+      maxSy: userSyProvided,
+      maxPt: userPtProvided,
+    })
+
+    const { insideSy: insideSyCurrent, insidePt: insidePtCurrent } = MarketThree.computeFeeInsideForRange({
+      currentTickPrice: marketSnapshotDataCurrent.currentSpotPrice,
+      lowerTickPrice: lowerPrice,
+      upperTickPrice: upperPrice,
+      feeGrowthIndexGlobalPt: BigInt(marketSnapshotDataCurrent.feeGrowthIndexGlobalPt),
+      feeGrowthIndexGlobalSy: BigInt(marketSnapshotDataCurrent.feeGrowthIndexGlobalSy),
+      lowerTickOutsidePt: BigInt(lowerFeeGrowthOutsidePtHistory),
+      lowerTickOutsideSy: BigInt(lowerFeeGrowthOutsideSyHistory),
+      upperTickOutsidePt: BigInt(upperFeeGrowthOutsidePtHistory),
+      upperTickOutsideSy: BigInt(upperFeeGrowthOutsideSyHistory),
+    })
+
+    //? Single invocation
+    const { claimablePt: ptExpectedFees, claimableSy: syExpectedFees } = MarketThree.calculateClaimableFees({
+      lpBalance: BigInt(liquidityTargetCurrent),
+      feeInsideLastSy: insideSyHistory,
+      feeInsideLastPt: insidePtHistory,
+      currentInsideSy: insideSyCurrent,
+      currentInsidePt: insidePtCurrent,
+      tokensOwedSy: 0n,
+      tokensOwedPt: 0n,
+    })
+
+    //? As we don't have autocompounding, use 1 as annualization factor
+    const ANNUALIZATION_FACTOR = 1
+
+    //? Convert SY amounts to baseToken: baseToken = syAmount / syExchangeRate
+    const syNeededBaseToken = syNeeded > 0 ? syNeeded * marketSnapshotDataCurrent.syExchangeRate : 0
+    const syExpectedFeesBaseToken =
+      syExpectedFees > 0n ? Number(syExpectedFees) * marketSnapshotDataCurrent.syExchangeRate : 0
+
+    const ptPriceInBaseToken = calcPtPriceInAsset(
+      marketSnapshotDataCurrent.currentSpotPrice,
+      Number(marketSnapshotDataCurrent.financials.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix,
+    )
+
+    const ptNeededBaseToken = ptNeeded * ptPriceInBaseToken
+    const ptExpectedFeesBaseToken = Number(ptExpectedFees) * ptPriceInBaseToken
+
+    //? Calculate total baseToken value of the position
+    const totalPositionValueBaseToken = syNeededBaseToken + ptNeededBaseToken
+
+    //? Calculate total fees earned in baseToken
+    const totalFeesBaseToken = syExpectedFeesBaseToken + ptExpectedFeesBaseToken
+
+    //? Calculate unified fee rate: total fees / total position value
+    const totalFeeRate = totalPositionValueBaseToken > 0 ? totalFeesBaseToken / totalPositionValueBaseToken : 0
+
+    //? Annualize the fee rate
+    const totalFeeRateAnnualized = totalFeeRate * ANNUALIZATION_FACTOR
+
+    return {
+      totalFeeRate: totalFeeRateAnnualized,
+      ptExpectedFees,
+      syExpectedFees,
+      expectedFeesBaseToken: totalFeesBaseToken,
+    }
+  }
+
+  /**
+   * Calculate TVL (Total Value Locked) in baseToken for a market
+   *
+   * @param currentSpotPrice - Current spot price in format of 1 + percentage / 100
+   * @param financials - Market financials containing balances and expiration timestamp
+   * @param syExchangeRate - SY exchange rate
+   * @param timestampUnix - Timestamp in seconds (defaults to current time)
+   * @returns Object with TVL breakdown: total TVL, PT liquidity, and SY liquidity in baseToken
+   */
+  static calcTvlInBaseToken(params: {
+    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,
+  ) {
+    const {
+      financials: financialsCurrent,
+      feeGrowthIndexGlobalPt: feeGrowthIndexGlobalPtCurrent,
+      feeGrowthIndexGlobalSy: feeGrowthIndexGlobalSyCurrent,
+      currentSpotPrice,
+      currentPrefixSum,
+      syExchangeRate,
+    } = marketSnapshotDataCurrent
+
+    const {
+      feeGrowthIndexGlobalPt: feeGrowthIndexGlobalPtHistory,
+      feeGrowthIndexGlobalSy: feeGrowthIndexGlobalSyHistory,
+    } = marketSnapshotDataHistory
+
+    const ptPriceInBaseToken = calcPtPriceInAsset(
+      currentSpotPrice,
+      Number(financialsCurrent.expirationTs) - marketSnapshotDataCurrent.snapshotTimeUnix,
+    )
+
+    const feePt = Number(feeGrowthIndexGlobalPtCurrent - feeGrowthIndexGlobalPtHistory) / Number(currentPrefixSum)
+    const feePtInBaseToken = feePt * ptPriceInBaseToken
+
+    const feeSy = Number(feeGrowthIndexGlobalSyCurrent - feeGrowthIndexGlobalSyHistory) / Number(currentPrefixSum)
+    const feeSyInBaseToken = feeSy * syExchangeRate
+
+    const totalFeesInBaseToken = feePtInBaseToken + feeSyInBaseToken
+
+    const ptLiquidityInBaseToken = Number(financialsCurrent.ptBalance) * ptPriceInBaseToken
+    const syLiquidityInBaseToken = Number(financialsCurrent.syBalance) * syExchangeRate
+    const tvlInBaseToken = ptLiquidityInBaseToken + syLiquidityInBaseToken
+
+    const totalFeeRate = totalFeesInBaseToken / tvlInBaseToken
+
+    return {
+      totalFeeRate,
+      totalFeesInBaseToken,
+      tvlInBaseToken,
+    }
+  }
+
+  /**
+   * Returns PT and SY amounts that will be received on liquidity removal from a position
+   * If liquidityToRemove is not provided, assume that the full position balance will be removed
+   */
+  getPtAndSyOnWithdrawLiquidity(position: LpPositionCLMM, liquidityToRemove?: bigint) {
+    const { ticks, emissions } = this.state
+
+    return getPtAndSyOnWithdrawLiquidity(emissions, ticks, position, liquidityToRemove ?? position.lpBalance)
+  }
+}
+
+/**
+ * Convert apy percents to input format
+ */
+function convertApyToApyBp(price: number): number {
+  return price * 1e4
+}
+
+/** Market snapshot data for CLMM market */
+export type MarketSnapshotData = {
+  syExchangeRate: number
+  /** Current spot price in format of 1 + percentage / 100 */
+  currentSpotPrice: number
+  financials: MarketThreeFinancials
+  feeGrowthIndexGlobalPt: bigint
+  feeGrowthIndexGlobalSy: bigint
+  currentPrefixSum: bigint
+  snapshotTimeUnix: number
+}
+
+/** Wrapper for computeLiquidityTargetAndTokenNeeds that takes a MarketSnapshotData as input */
+function computeLiquidityTargetAndTokenNeedsForSnapshot(
+  marketSnapshotData: MarketSnapshotData,
+  params: {
+    /** lowerPrice in format of 1 + percentage / 100 */
+    lowerPrice: number
+    /** lowerPrice in format of 1 + percentage / 100 */
+    upperPrice: number
+    maxSy: number
+    maxPt: number
+  },
+) {
+  const EPSILON_CLAMP = 1e-18
+
+  const { lowerPrice, upperPrice, maxSy, maxPt } = params
+  const { financials, currentSpotPrice, syExchangeRate, snapshotTimeUnix } = marketSnapshotData
+
+  const expirationTsNumber = Number(financials.expirationTs)
+
+  const secondsRemaining = Math.max(0, expirationTsNumber - snapshotTimeUnix)
+
+  const effSnap = new EffSnap(normalizedTimeRemaining(secondsRemaining), syExchangeRate)
+
+  const priceEffLower = effSnap.getEffectivePrice(lowerPrice)
+  const priceEffUpper = effSnap.getEffectivePrice(upperPrice)
+
+  return computeLiquidityTargetAndTokenNeeds(
+    effSnap,
+    currentSpotPrice,
+    priceEffLower,
+    priceEffUpper,
+    lowerPrice,
+    upperPrice,
+    0,
+    0,
+    0,
+    maxSy,
+    maxPt,
+    EPSILON_CLAMP,
+  )
+}