@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/marketThree.ts

@@ -1,2861 +0,0 @@
-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,
-    payer,
-    ytOut,
-    maxSyIn,
-    ytTrader: ytTraderParam,
-    ptTrader: ptTraderParam,
-    syTrader: syTraderParam,
-    lnImpliedApyLimit,
-  }: {
-    trader: PublicKey
-    /** Payer for ATA creation instructions. Defaults to trader. */
-    payer?: PublicKey
-    ytOut: bigint
-    maxSyIn: bigint
-    ytTrader?: PublicKey
-    ptTrader?: PublicKey
-    syTrader?: PublicKey
-    lnImpliedApyLimit?: number
-  }) {
-    const ataPayer = payer ?? trader
-    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(ataPayer, syTrader, trader, this.mintSy)
-    const ptTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ptTrader, trader, this.mintPt)
-    const ytTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, 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,
-    payer,
-    ytIn,
-    minSyOut,
-    ytSrc: ytSrcParam,
-    ptSrc: ptSrcParam,
-    syDst: syDstParam,
-    lnImpliedApyLimit,
-  }: {
-    trader: PublicKey
-    /** Payer for ATA creation instructions. Defaults to trader. */
-    payer?: PublicKey
-    ytIn: bigint
-    minSyOut: bigint
-    ytSrc?: PublicKey
-    ptSrc?: PublicKey
-    syDst?: PublicKey
-    lnImpliedApyLimit?: number
-  }) {
-    const ataPayer = payer ?? trader
-    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(ataPayer, syDst, trader, this.mintSy)
-    const ptSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ptSrc, trader, this.mintPt)
-    const ytSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(ataPayer, 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,
-  )
-}