@exponent-labs/exponent-sdk 0.1.7 → 0.1.8

package/src/marketThree.ts

@@ -0,0 +1,2430 @@
+import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
+import {
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+} from "@solana/spl-token"
+import Decimal from "decimal.js"
+
+import { ExponentClmm, IDL } from "@exponent-labs/exponent-clmm-idl"
+import { ExponentCLMMPDA } from "@exponent-labs/exponent-clmm-pda"
+import {
+  ExponentFetcher,
+  LiquidityNetBalanceLimits,
+  LpFarm,
+  LpPositionCLMM,
+  MarketConfigurationOptions,
+  MarketThreeFinancials,
+  Ticks,
+} from "@exponent-labs/exponent-fetcher"
+import { IDL as EXPONENT_CORE_IDL, ExponentCore } from "@exponent-labs/exponent-idl"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import {
+  AnchorizedPNum,
+  CpiAccountsRaw,
+  CpiAccountsRawJson,
+  ExponentCoreCpiAccountsRaw,
+  Flavor,
+  SyPosition,
+} 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 { MyWallet } from "./market"
+import { makeSyPosition } from "./syPosition"
+import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
+import { Vault } from "./vault"
+
+export { LiquidityAdd }
+
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
+
+interface Emission {
+  /** Token account that holds emission tokens */
+  escrowAccountAddress: web3.PublicKey
+
+  /** Mint for the emission token */
+  mint: web3.PublicKey
+
+  /** Token program ID for the emission token */
+  tokenProgramAddress: web3.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 =
+  | { setStatus: [number] }
+  | { setMaxLpSupply: [BN] }
+  | { changeTreasuryTradeSyBpsFee: [number] }
+  | { changeLnFeeRateRoot: [number] }
+  | {
+      changeLiquidityNetBalanceLimits: {
+        maxNetBalanceChangeNegativePercentage: number
+        maxNetBalanceChangePositivePercentage: number
+        windowDurationSeconds: number
+      }
+    }
+  | { changeEpsilonClamp: [number] }
+  | { changeMinLpTickAmount: [BN] }
+  | { changeTickSpace: [number] }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type SwapDirection = { ptToSy: {} } | { syToPt: {} }
+
+interface MarketThreeLoadOptions {
+  syConfig?: {
+    skipWrap?: boolean
+  }
+}
+
+type MarketThreeArgs = {
+  admin: web3.PublicKey
+  addressLookupTable: web3.PublicKey
+  mintPt: web3.PublicKey
+  mintYt: web3.PublicKey
+  mintSy: web3.PublicKey
+  vault: Vault
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenYtEscrow: web3.PublicKey
+  tokenFeeTreasurySy: web3.PublicKey
+  tokenFeeTreasuryPt: web3.PublicKey
+  syProgram: web3.PublicKey
+  exponentCoreProgram: web3.PublicKey
+  selfAddress: web3.PublicKey
+  statusFlags: number
+  configurationOptions: MarketConfigurationOptions
+  financials: MarketThreeFinancials
+  cpiSyAccounts: CpiAccountsRaw
+  cpiCoreAccounts: ExponentCoreCpiAccountsRaw
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  flavor: Flavor
+  emissions: {
+    trackers: {
+      tokenEscrow: web3.PublicKey
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  ticksAccount: web3.PublicKey
+  ticks: Ticks
+  syPosition: SyPosition
+  treasuryFeeOwner: web3.PublicKey
+}
+
+export class MarketThree {
+  clmmProgram: Program<ExponentClmm>
+  coreProgram: Program<ExponentCore>
+  xponPda: ExponentPDA
+  pda: ExponentCLMMPDA
+
+  constructor(
+    public state: MarketThreeArgs,
+    public selfAddress: web3.PublicKey,
+    public env: Environment,
+    public connection: web3.Connection,
+  ) {
+    this.xponPda = new ExponentPDA(env.coreProgramId)
+    this.pda = new ExponentCLMMPDA()
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    this.clmmProgram = new Program<ExponentClmm>(IDL as ExponentClmm, new AnchorProvider(connection, mockWallet))
+    this.coreProgram = new Program(
+      EXPONENT_CORE_IDL as ExponentCore,
+      new AnchorProvider(connection, new MyWallet(web3.Keypair.generate())),
+    )
+  }
+
+  static async load(
+    env: Environment,
+    connection: web3.Connection,
+    address: web3.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: web3.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(this.state.exponentCoreProgram)
+  }
+
+  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(): web3.PublicKey[] {
+    return this.emissions.map((e) => e.escrowAccountAddress)
+  }
+
+  /** Pass-through SY account owned by the market */
+  get tokenSyEscrow(): web3.PublicKey {
+    return this.state.tokenSyEscrow
+  }
+
+  /** Pass-through YT account owned by the market */
+  get tokenYtEscrow(): web3.PublicKey {
+    return this.state.tokenYtEscrow
+  }
+
+  /** SY account that holds treasury SY fees from PT trading */
+  get tokenFeeTreasurySy(): web3.PublicKey {
+    return this.state.tokenFeeTreasurySy
+  }
+
+  /** PT account that holds treasury PT fees from PT trading */
+  get tokenFeeTreasuryPt(): web3.PublicKey {
+    return this.state.tokenFeeTreasuryPt
+  }
+
+  /** Market liquidity for PT */
+  get tokenPtEscrow(): web3.PublicKey {
+    return this.state.tokenPtEscrow
+  }
+
+  get currentSyExchangeRate(): number {
+    return this.flavor.currentSyExchangeRate
+  }
+
+  /** Special account for event emit self-cpi */
+  get eventAuthority(): web3.PublicKey {
+    return emitEventAuthority(this.clmmProgram.programId)
+  }
+
+  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: web3.PublicKey,
+    connection: web3.Connection,
+  ): Promise<web3.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
+   */
+  async 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: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    lpPosition?: web3.Keypair
+  }) {
+    const tokenProgram = TOKEN_PROGRAM_ID
+
+    const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+
+    const lpPosition = lpPositionParam || web3.Keypair.generate()
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.depositSy,
+      ...this.cpiSyAccounts.getPositionState,
+    ])
+
+    const ix = await this.clmmProgram.methods
+      .depositLiquidity(
+        convertApyToApyBp(lowerTickKey),
+        convertApyToApyBp(upperTickKey),
+        new BN(ptInIntent.toString()),
+        new BN(syInIntent.toString()),
+      )
+      .accountsStrict({
+        depositor,
+        market: this.selfAddress,
+        tokenPtSrc: ptSrc,
+        tokenSySrc: sySrc,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenProgram,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        lpPosition: lpPosition.publicKey,
+        ticks: this.ticksKey,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return {
+      ix: 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
+   */
+  async ixWithdrawLiquidity({
+    lpIn,
+    withdrawer,
+    lpPosition,
+    minPtOut,
+    minSyOut,
+    ptDst: ptDstParam,
+    syDst: syDstParam,
+  }: {
+    lpIn: bigint
+    withdrawer: web3.PublicKey
+    lpPosition: web3.PublicKey
+    minPtOut: bigint
+    minSyOut: bigint
+    ptDst?: web3.PublicKey
+    syDst?: web3.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 ixs = await this.clmmProgram.methods
+      .withdrawLiquidity(new BN(lpIn.toString()), new BN(minPtOut.toString()), new BN(minSyOut.toString()))
+      .accountsStrict({
+        owner: withdrawer,
+        market: this.selfAddress,
+        tokenPtDst: ptDst,
+        tokenSyDst: syDst,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        systemProgram: web3.SystemProgram.programId,
+        lpPosition,
+        ticks: this.ticksKey,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx] }
+  }
+
+  async ixTradePt({
+    trader,
+    traderAmount,
+    outConstraint,
+    swapDirection,
+    tokenPt: tokenPtParam,
+    tokenSy: tokenSyParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    traderAmount: bigint
+    outConstraint: bigint
+    swapDirection: SwapDirection
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.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,
+    ])
+
+    let outConstraintOptional = outConstraint ? new BN(outConstraint.toString()) : null
+    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+
+    const ix = await this.clmmProgram.methods
+      .tradePt(new BN(traderAmount.toString()), swapDirection, outConstraintOptional, lnImpliedApyLimitOptional)
+      .accountsStrict({
+        trader,
+        market: this.selfAddress,
+        tokenPtTrader: tokenPt,
+        tokenSyTrader: tokenSy,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] }
+  }
+
+  async ixTradePtExactOut({
+    trader,
+    amountOut,
+    swapDirection,
+    amountInConstraint,
+    tokenPt: tokenPtParam,
+    tokenSy: tokenSyParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    amountOut: bigint
+    swapDirection: SwapDirection
+    amountInConstraint?: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.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 amountInConstraintOptional = amountInConstraint !== undefined ? new BN(amountInConstraint.toString()) : null
+    const lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+
+    const ix = await this.clmmProgram.methods
+      .tradePtExactOut(
+        new BN(amountOut.toString()),
+        swapDirection,
+        amountInConstraintOptional,
+        lnImpliedApyLimitOptional,
+      )
+      .accountsStrict({
+        trader,
+        market: this.selfAddress,
+        tokenPtTrader: tokenPt,
+        tokenSyTrader: tokenSy,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    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
+   */
+  async ixBuyPt({
+    trader,
+    amountSy,
+    outConstraint,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    amountSy: bigint
+    outConstraint: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderAmount: amountSy,
+      outConstraint: outConstraint,
+      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
+   */
+  async ixSellPt({
+    trader,
+    amountPt,
+    outConstraint,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    amountPt: bigint
+    outConstraint: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderAmount: amountPt,
+      outConstraint: outConstraint,
+      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
+   */
+  async ixBuyPtExactOut({
+    trader,
+    amountPt,
+    maxSyIn,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    amountPt: bigint
+    maxSyIn?: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePtExactOut({
+      trader,
+      amountOut: amountPt,
+      amountInConstraint: maxSyIn,
+      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
+   */
+  async ixSellPtExactOut({
+    trader,
+    amountSy,
+    maxPtIn,
+    tokenPt,
+    tokenSy,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    amountSy: bigint
+    maxPtIn?: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    return this.ixTradePtExactOut({
+      trader,
+      amountOut: amountSy,
+      amountInConstraint: maxPtIn,
+      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
+   */
+  async ixBuyYt({
+    trader,
+    ytOut,
+    maxSyIn,
+    ytTrader: ytTraderParam,
+    ptTrader: ptTraderParam,
+    syTrader: syTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    ytOut: bigint
+    maxSyIn: bigint
+    ytTrader?: web3.PublicKey
+    ptTrader?: web3.PublicKey
+    syTrader?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const syTrader = syTraderParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptTrader = ptTraderParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytTrader = ytTraderParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+
+    const syTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, syTrader, trader, this.mintSy)
+    const ptTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, ptTrader, trader, this.mintPt)
+    const ytTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(trader, ytTrader, trader, this.mintYt)
+
+    const stripAccounts = this.cpiCoreAccounts.stripSy
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.depositSy,
+      ...stripAccounts,
+    ])
+
+    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+    const ix = await this.clmmProgram.methods
+      .buyYt(new BN(maxSyIn.toString()), new BN(ytOut.toString()), lnImpliedApyLimitOptional)
+      .accountsStrict({
+        trader,
+        market: this.selfAddress,
+        tokenYtTrader: ytTrader,
+        tokenPtTrader: ptTrader,
+        tokenSyTrader: syTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        tokenYtEscrow: this.tokenYtEscrow,
+        exponentCoreProgram: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    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
+   */
+  async ixSellYt({
+    trader,
+    ytIn,
+    minSyOut,
+    ytSrc: ytSrcParam,
+    ptSrc: ptSrcParam,
+    syDst: syDstParam,
+    lnImpliedApyLimit,
+  }: {
+    trader: web3.PublicKey
+    ytIn: bigint
+    minSyOut: bigint
+    ytSrc?: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    syDst?: web3.PublicKey
+    lnImpliedApyLimit?: number
+  }) {
+    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
+
+    const syDstAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, syDst, trader, this.mintSy)
+    const ptSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, ptSrc, trader, this.mintPt)
+    const ytSrcAtaIxs = createAssociatedTokenAccountIdempotentInstruction(trader, ytSrc, trader, this.mintYt)
+
+    const mergeAccounts = this.cpiCoreAccounts.mergeSy
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiSyAccounts.depositSy,
+      ...mergeAccounts,
+    ])
+
+    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+    const ix = await this.clmmProgram.methods
+      .sellYt(new BN(ytIn.toString()), new BN(minSyOut.toString()), lnImpliedApyLimitOptional)
+      .accountsStrict({
+        trader,
+        market: this.selfAddress,
+        tokenYtTrader: ytSrc,
+        tokenPtTrader: ptSrc,
+        tokenSyTrader: syDst,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        tokenYtEscrow: this.tokenYtEscrow,
+        exponentCoreProgram: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] }
+  }
+
+  async ixModifyMarketSetting({ signer, adminAction }: { signer: web3.PublicKey; adminAction: MarketAdminAction }) {
+    return this.clmmProgram.methods
+      .modifyMarketSetting(adminAction)
+      .accountsStrict({
+        market: this.selfAddress,
+        signer,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .instruction()
+  }
+
+  /**
+   * 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)
+   */
+  async ixAddFarm({
+    signer,
+    farmMint,
+    farmTokenProgram,
+    emissionsRate,
+    untilTimestamp,
+    farmTokenSrc: farmTokenSrcParam,
+    feePayer: feePayerParam,
+  }: {
+    signer: web3.PublicKey
+    farmMint: web3.PublicKey
+    farmTokenProgram: web3.PublicKey
+    emissionsRate: bigint
+    untilTimestamp: number
+    farmTokenSrc?: web3.PublicKey
+    feePayer?: web3.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 = await this.clmmProgram.methods
+      .addFarm(new BN(emissionsRate.toString()), untilTimestamp)
+      .accountsStrict({
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        signer,
+        feePayer,
+        mintNew: farmMint,
+        tokenSource: farmTokenSrc,
+        tokenFarm: farmTokenEscrow,
+        tokenProgram: farmTokenProgram,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+      })
+      .instruction()
+
+    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)
+   */
+  async ixModifyFarm({
+    signer,
+    farmMint,
+    farmTokenProgram,
+    newRate,
+    untilTimestamp,
+    farmTokenSrc: farmTokenSrcParam,
+  }: {
+    signer: web3.PublicKey
+    farmMint: web3.PublicKey
+    farmTokenProgram: web3.PublicKey
+    newRate: bigint
+    untilTimestamp: number
+    farmTokenSrc?: web3.PublicKey
+  }) {
+    const farmTokenEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
+    const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
+
+    const ix = await this.clmmProgram.methods
+      .modifyFarm(untilTimestamp, new BN(newRate.toString()))
+      .accountsStrict({
+        market: this.selfAddress,
+        ticks: this.ticksKey,
+        signer,
+        mint: farmMint,
+        tokenSource: farmTokenSrc,
+        tokenFarm: farmTokenEscrow,
+        tokenProgram: farmTokenProgram,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+      })
+      .instruction()
+
+    return {
+      ixs: [ix],
+    }
+  }
+
+  async ixWrapperBuyPt({
+    owner,
+    minPtOut,
+    baseIn,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    owner: web3.PublicKey
+    minPtOut: bigint
+    baseIn: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.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,
+    ])
+
+    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+
+    const ix = await this.clmmProgram.methods
+      .buyPt(
+        new BN(minPtOut.toString()),
+        new BN(baseIn.toString()),
+        lnImpliedApyLimitOptional,
+        mintSyRemAccounts.length,
+      )
+      .accountsStrict({
+        addressLookupTable: this.addressLookupTable,
+        buyer: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenFeeTreasuryPt: this.state.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  async ixWrapperSellPt({
+    owner,
+    amount,
+    minBaseOut,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+    lnImpliedApyLimit,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.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,
+    ])
+
+    let lnImpliedApyLimitOptional = lnImpliedApyLimit ? lnImpliedApyLimit : null
+
+    const ix = await this.clmmProgram.methods
+      .sellPt(
+        new BN(amount.toString()),
+        new BN(minBaseOut.toString()),
+        lnImpliedApyLimitOptional,
+        redeemSyRemAccounts.length,
+      )
+      .accountsStrict({
+        seller: owner,
+        market: this.selfAddress,
+        tokenPtTrader,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenSyTrader,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        ticks: this.ticksKey,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix, ...(await this.flavor.postIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  async ixWrapperBuyYt({
+    owner,
+    ytOut,
+    maxBaseIn,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    owner: web3.PublicKey
+    ytOut: bigint
+    maxBaseIn: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenYtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.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 = await 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 = await this.clmmProgram.methods
+      .wrapperBuyYt(
+        new BN(ytOut.toString()),
+        new BN(maxBaseIn.toString()),
+        mintSyRemAccounts.length,
+        depositYtAccounts_until,
+      )
+      .accountsStrict({
+        buyer: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenYtTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenYtEscrow: this.tokenYtEscrow,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        exponentCoreProgram: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(allRemainingAccounts)
+      .instruction()
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+    }
+  }
+
+  async ixWrapperSellYt({
+    owner,
+    amount,
+    minBaseOut,
+    tokenBaseTrader: tokenBaseTraderParam,
+    tokenSyTrader: tokenSyTraderParam,
+    tokenYtTrader: tokenYtTraderParam,
+    tokenPtTrader: tokenPtTraderParam,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenBaseTrader?: web3.PublicKey
+    tokenSyTrader?: web3.PublicKey
+    tokenYtTrader?: web3.PublicKey
+    tokenPtTrader?: web3.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 remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiSyAccounts.getSyState,
+      ...this.cpiSyAccounts.getPositionState,
+      ...this.cpiCoreAccounts.mergeSy,
+      ...this.cpiSyAccounts.withdrawSy,
+      ...this.cpiSyAccounts.depositSy,
+    ])
+
+    const ix1 = await this.clmmProgram.methods
+      .wrapperSellYt(new BN(amount.toString()), new BN(minBaseOut.toString()), redeemSyRemAccounts.length)
+      .accountsStrict({
+        seller: owner,
+        market: this.selfAddress,
+        tokenYtTrader,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenPtTrader,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenSyTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        tokenYtEscrow: this.tokenYtEscrow,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        ticks: this.ticksKey,
+        exponentCoreProgram: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [ix1, ...(await this.flavor.preIxs({ signer: owner }))],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+  async ixWrapperProvideLiquidity({
+    depositor,
+    amountBase,
+    minLpOut,
+    lowerTickApy,
+    upperTickApy,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+    lpPosition: lpPositionParam,
+  }: {
+    depositor: web3.PublicKey
+    amountBase: bigint
+    minLpOut: bigint
+    lowerTickApy: number
+    upperTickApy: number
+    tokenSyDepositor?: web3.PublicKey
+    tokenYtDepositor?: web3.PublicKey
+    tokenPtDepositor?: web3.PublicKey
+    tokenBaseDepositor?: web3.PublicKey
+    lpPosition?: web3.Keypair
+  }) {
+    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 || web3.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 amountBaseBn = new BN(amountBase.toString())
+    const minLpOutBn = new BN(minLpOut.toString())
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      // argument does not matter - since we are just getting the keys
+      amountBase: "0",
+      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 = await this.depositYtAccounts({
+      owner: depositor,
+      ytSrc: tokenYtDepositor,
+    })
+    const depositAccountsUntil = mintSyRemAccounts.length + depositYtAccounts.keys.length
+    const allRemainingAccounts = [...mintSyRemAccounts, ...depositYtAccounts.keys, ...unorderedRemainingAccounts]
+
+    const ix = await this.clmmProgram.methods
+      .wrapperProvideLiquidity(
+        convertApyToApyBp(lowerTickApy),
+        convertApyToApyBp(upperTickApy),
+        amountBaseBn,
+        minLpOutBn,
+        mintSyRemAccounts.length,
+        depositAccountsUntil,
+      )
+      .accountsStrict({
+        depositor,
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenSyDepositor,
+        tokenYtDepositor,
+        tokenPtDepositor,
+        mintYt: this.vault.mintYt,
+        mintPt: this.vault.mintPt,
+        systemProgram: web3.SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        marketAddressLookupTable: this.addressLookupTable,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        lpPosition: lpPosition.publicKey,
+        tokenYtEscrow: this.tokenYtEscrow,
+        ticks: this.ticksKey,
+        exponentCoreProgram: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(allRemainingAccounts)
+      .instruction()
+
+    // console.log("ix accounts length", ix.keys.length)
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: depositor })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: depositor })),
+      ],
+      signers: [lpPosition],
+      setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx],
+    }
+  }
+
+  async ixProvideLiquidityClassic({
+    depositor,
+    amountBase,
+    amountPt,
+    minLpOut,
+    lowerTickApy,
+    upperTickApy,
+    tokenSyDepositor: tokenSyDepositorParam,
+    tokenYtDepositor: tokenYtDepositorParam,
+    tokenPtDepositor: tokenPtDepositorParam,
+    tokenBaseDepositor: tokenBaseDepositorParam,
+  }: {
+    depositor: web3.PublicKey
+    amountBase: bigint
+    amountPt: bigint
+    minLpOut: bigint
+    lowerTickApy: number
+    upperTickApy: number
+    tokenSyDepositor?: web3.PublicKey
+    tokenYtDepositor?: web3.PublicKey
+    tokenPtDepositor?: web3.PublicKey
+    tokenBaseDepositor?: web3.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 = web3.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 = await this.clmmProgram.methods
+      .wrapperProvideLiquidityClassic(
+        convertApyToApyBp(lowerTickApy),
+        convertApyToApyBp(upperTickApy),
+        new BN(amountBase.toString()),
+        new BN(amountPt.toString()),
+        new BN(minLpOut.toString()),
+        mintSyRemAccounts.length,
+      )
+      .accountsStrict({
+        depositor,
+        lpPosition: lpPosition.publicKey,
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        syProgram: this.syProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenPtDepositor,
+        tokenSyDepositor,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.eventAuthority,
+        program: this.clmmProgram.programId,
+        ticks: this.ticksKey,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: depositor })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: depositor })),
+      ],
+      signers: [lpPosition],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+  async ixWithdrawLiquidityToBase({
+    owner,
+    amountLp,
+    minBaseOut,
+    lpPosition,
+    tokenSyWithdrawer: tokenSyWithdrawerParam,
+    tokenYtWithdrawer: tokenYtWithdrawerParam,
+    tokenPtWithdrawer: tokenPtWithdrawerParam,
+    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
+  }: {
+    owner: web3.PublicKey
+    amountLp: bigint
+    minBaseOut: bigint
+    lpPosition: web3.PublicKey
+    tokenSyWithdrawer?: web3.PublicKey
+    tokenYtWithdrawer?: web3.PublicKey
+    tokenPtWithdrawer?: web3.PublicKey
+    tokenBaseWithdrawer?: web3.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 = await this.clmmProgram.methods
+      .wrapperWithdrawLiquidity(
+        new BN(amountLp.toString()),
+        new BN(minSyOut.toFixed(0).toString()),
+        redeemSyRemAccounts.length,
+      )
+      .accountsStrict({
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        lpPosition,
+        marketAddressLookupTable: this.addressLookupTable,
+        eventAuthority: this.eventAuthority,
+        syProgram: this.syProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenPtWithdrawer,
+        tokenSyWithdrawer,
+        withdrawer: owner,
+        ticks: this.ticksKey,
+        tokenFeeTreasuryPt: this.tokenFeeTreasuryPt,
+        program: this.clmmProgram.programId,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    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: web3.PublicKey
+    amountLp: bigint
+    lpPosition: web3.PublicKey
+    tokenSyWithdrawer?: web3.PublicKey
+    tokenYtWithdrawer?: web3.PublicKey
+    tokenPtWithdrawer?: web3.PublicKey
+    tokenBaseWithdrawer?: web3.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 = await this.clmmProgram.methods
+      .wrapperWithdrawLiquidityClassic(new BN(amountLp.toString()), redeemSyRemAccounts.length)
+      .accountsStrict({
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        lpPosition,
+        marketAddressLookupTable: this.addressLookupTable,
+        eventAuthority: this.eventAuthority,
+        syProgram: this.syProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenPtWithdrawer,
+        tokenSyWithdrawer,
+        withdrawer: owner,
+        ticks: this.ticksKey,
+        program: this.clmmProgram.programId,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [...(await this.flavor.preIxs({ signer: owner })), ixn, ...(await this.flavor.postIxs({ signer: owner }))],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx],
+    }
+  }
+
+async getUserLpPositions(owner: web3.PublicKey, market: web3.PublicKey) {
+    const lpPositions = await (
+      await this.clmmProgram.account.lpPosition.all()
+    ).filter(
+      (lpPos) =>
+        lpPos.account.owner.toString() === owner.toString() && lpPos.account.market.toString() === market.toString(),
+    )
+    return {
+      lpPositions: [lpPositions],
+    }
+  }
+  
+  // async ixCloseMarket({ owner }: { owner: web3.PublicKey }) {
+  //   const ixn = await this.clmmProgram.methods
+  //     .closeMarket()
+  //     .accountsStrict({
+  //       market: this.selfAddress,
+  //       systemProgram: web3.SystemProgram.programId,
+  //       payer: owner,
+  //       ticks: this.ticksKey,
+  //       program: this.clmmProgram.programId,
+  //       eventAuthority: this.eventAuthority,
+  //       rent: web3.SYSVAR_RENT_PUBKEY,
+  //     })
+  //     .instruction()
+
+  //   return {
+  //     ixs: [ixn],
+  //   }
+  // }
+
+  async ixMarketAccureEmissions({ owner, lpPosition }: { owner: web3.PublicKey; lpPosition: web3.PublicKey }) {
+    const remainingAccounts = uniqueRemainingAccounts([...this.cpiSyAccounts.getPositionState])
+    const ixn = await this.clmmProgram.methods
+      .marketAccrueEmission()
+      .accountsStrict({
+        market: this.selfAddress,
+        systemProgram: web3.SystemProgram.programId,
+        ticks: this.ticksKey,
+        program: this.clmmProgram.programId,
+        eventAuthority: this.eventAuthority,
+        lpPosition,
+        owner,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    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,
+    }
+  }
+
+  async depositYtAccounts({
+    owner,
+    ytSrc: ytSrcParam,
+  }: {
+    owner: web3.PublicKey
+    ytSrc?: web3.PublicKey
+  }): Promise<web3.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: userYieldPosition,
+      escrowYt: escrowYt,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      syProgram: this.state.syProgram,
+      addressLookupTable: this.vault.addressLookupTable,
+      yieldPosition,
+      systemProgram: web3.SystemProgram.programId,
+      eventAuthority: this.coreEventAuthority,
+      program: this.state.exponentCoreProgram,
+    }
+    const remainingAccounts = this.cpiSyAccounts.getSyState
+
+    const depositIx = await this.coreProgram.methods
+      .depositYt(new BN(0))
+      .accountsStrict(mainAccounts)
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return depositIx
+  }
+
+  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,
+    }
+  }
+
+  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,
+  )
+}