@exponent-labs/exponent-sdk 0.0.3

package/src/market.ts

@@ -0,0 +1,2338 @@
+import { AnchorProvider, Program, Wallet, web3 } from "@coral-xyz/anchor"
+import { ExponentFetcher, LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher"
+import { ClaimAmount, ExponentIx } from "@exponent-labs/exponent-ix"
+import {
+  createAssociatedTokenAccountIdempotentInstruction,
+  getAssociatedTokenAddressSync,
+  TOKEN_PROGRAM_ID,
+} from "@solana/spl-token"
+import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
+import { Environment } from "./environment"
+import { getMultipleMintSupply } from "./tokenUtil"
+import {
+  makeFlavorMarginfiSync,
+  makeFlavorKaminoSync,
+  makeFlavorJitoRestakingSync,
+  makeFlavorPerenaSync,
+  makeFlavorGenericSync,
+} from "./flavors"
+import { ExponentCore, IDL } from "@exponent-labs/exponent-idl"
+import { BN } from "@coral-xyz/anchor"
+import { ExponentPDA } from "@exponent-labs/exponent-pda"
+import { Vault } from "./vault"
+import { LiquidityAdd, lpOutForTokensIn, MarketCalculator } from "@exponent-labs/market-math"
+import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
+import { CpiAccountsRaw, Flavor, SyPosition } from "@exponent-labs/exponent-types"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+import { AnchorizedPNum } from "@exponent-labs/exponent-types"
+import { extendAddressLookupTable } from "./utils/altUtil"
+import { makeSyPosition } from "./syPosition"
+import { serializeCpiAccountsRaw } from "@exponent-labs/exponent-ix"
+import { CpiAccountsRawJson } from "@exponent-labs/exponent-types"
+
+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] }
+  | { changeLnFeeRateRoot: [number] }
+  | { changeRateScalarRoot: [number] }
+  | {
+      changeLiquidityNetBalanceLimits: {
+        maxNetBalanceChangeNegativePercentage: number
+        maxNetBalanceChangePositivePercentage: number
+        windowDurationSeconds: number
+      }
+    }
+  | { removeMarketEmission: [number] }
+
+type MarketArgs = {
+  ptBalance: bigint
+  syBalance: bigint
+  lpSupply: bigint
+  sySupply: bigint
+  lpEscrowAmount: bigint
+  maxLpSupply: bigint
+  rateScalarRoot: number
+  lnFeeRateRoot: number
+  lastLnImpliedRate: number
+  expirationTs: number
+  addressLookupTable: web3.PublicKey
+  mintSy: web3.PublicKey
+  mintPt: web3.PublicKey
+  vault: Vault
+  mintLp: web3.PublicKey
+  tokenPtEscrow: web3.PublicKey
+  tokenSyEscrow: web3.PublicKey
+  tokenLpEscrow: web3.PublicKey
+  syProgram: web3.PublicKey
+  statusFlags: number
+  cpiAccounts: CpiAccountsRaw
+  feeTreasurySyBps: number
+  tokenFeeTreasurySy: web3.PublicKey
+  isCurrentFlashSwap: boolean
+  lpFarm: LpFarm
+  flavor: Flavor
+  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
+  syPosition: SyPosition
+  emissions: {
+    trackers: {
+      tokenEscrow: web3.PublicKey
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+}
+
+export class MyWallet implements Wallet {
+  constructor(readonly payer: web3.Keypair) {
+    this.payer = payer
+  }
+
+  async signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T> {
+    if (tx instanceof web3.Transaction) {
+      tx.partialSign(this.payer)
+    } else {
+      tx.sign([this.payer])
+    }
+    return tx
+  }
+
+  async signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]> {
+    return txs.map((t) => {
+      if (t instanceof web3.Transaction) {
+        t.partialSign(this.payer)
+      } else if (t instanceof web3.VersionedTransaction) {
+        t.sign([this.payer])
+      }
+      return t
+    })
+  }
+
+  get publicKey(): web3.PublicKey {
+    return this.payer.publicKey
+  }
+}
+
+export class Market {
+  coreProgram: Program<ExponentCore>
+  xponIx: ExponentIx
+  xponPda: ExponentPDA
+
+  constructor(
+    public state: MarketArgs,
+    public selfAddress: web3.PublicKey,
+    public env: Environment,
+    public connection: web3.Connection,
+  ) {
+    this.xponPda = new ExponentPDA(env.coreProgramId)
+    this.xponIx = new ExponentIx(env.coreProgramId)
+    const mockWallet = new MyWallet(web3.Keypair.generate())
+    this.coreProgram = new Program(IDL as ExponentCore, new AnchorProvider(connection, mockWallet))
+  }
+
+  static async load(
+    env: Environment,
+    connection: web3.Connection,
+    address: web3.PublicKey,
+    vault?: Vault,
+  ): Promise<Market> {
+    const fetcher = new ExponentFetcher({ connection })
+    const m = await fetcher.fetchMarket(address)
+    const [[lpSupply, sySupply], alt, loadedVault] = await Promise.all([
+      getMultipleMintSupply(connection, [m.mintLp, m.mintSy]),
+      fetchAddressLookupTable(connection, m.addressLookupTable),
+      vault || Vault.load(env, connection, m.vault),
+    ])
+    const cpiAccounts = makeCpiAccountMetaLists(alt, m.cpiAccounts)
+
+    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)
+        default:
+          throw new Error(`Unknown flavor: ${loadedVault.flavor}`)
+      }
+    })()
+
+    const syPosition = await makeSyPosition(fetcher, flavor, m.syProgram, address)
+
+    const state: MarketArgs = {
+      ...m,
+      vault: loadedVault,
+      cpiAccounts,
+      lpSupply,
+      sySupply,
+      flavor,
+      syPosition,
+    }
+    return new Market(state, address, env, connection)
+  }
+
+  async reload(conn: web3.Connection = this.connection) {
+    const m = await Market.load(this.env, conn, this.selfAddress)
+    this.state = m.state
+    return m
+  }
+
+  /** Convert to a JSON representation */
+  toJson() {
+    return toJson(this)
+  }
+
+  get vault() {
+    return this.state.vault
+  }
+
+  get flavor() {
+    return this.state.flavor
+  }
+
+  get lpSupply() {
+    return this.state.lpSupply
+  }
+
+  get syBalance() {
+    return this.state.syBalance
+  }
+
+  get ptBalance() {
+    return this.state.ptBalance
+  }
+
+  get mintSy() {
+    return this.state.mintSy
+  }
+
+  get mintPt() {
+    return this.state.mintPt
+  }
+
+  get statusFlags() {
+    return this.state.statusFlags
+  }
+
+  get mintYt() {
+    return this.vault.mintYt
+  }
+
+  get mintLp() {
+    return this.state.mintLp
+  }
+
+  get addressLookupTable() {
+    return this.state.addressLookupTable
+  }
+
+  get syProgram() {
+    return this.state.syProgram
+  }
+
+  get cpiAccounts() {
+    return this.state.cpiAccounts
+  }
+
+  get marketEmissions() {
+    return this.state.emissions
+  }
+
+  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
+  }
+
+  /** SY account that holds treasury SY fees from PT trading */
+  get tokenFeeTreasurySy(): web3.PublicKey {
+    return this.state.tokenFeeTreasurySy
+  }
+
+  /** Market liquidity for PT */
+  get tokenPtEscrow(): web3.PublicKey {
+    return this.state.tokenPtEscrow
+  }
+
+  get tokenLpEscrow(): web3.PublicKey {
+    return this.state.tokenLpEscrow
+  }
+
+  get currentSyExchangeRate(): number {
+    return this.flavor.currentSyExchangeRate
+  }
+
+  /** Special account for event emit self-cpi */
+  get eventAuthority(): web3.PublicKey {
+    return emitEventAuthority(this.env.coreProgramId)
+  }
+
+  get currentPtPriceInSy(): number {
+    return this.currentPtPriceInAsset / this.currentSyExchangeRate
+  }
+
+  get currentPtPriceInAsset(): number {
+    const c = this.marketCalculator()
+    return c.exchangeRate
+  }
+
+  get ptDiscount(): number {
+    return 1 / this.currentPtPriceInAsset
+  }
+
+  get lpPriceInAsset(): number {
+    // Calculate total value of liquidity in asset units
+    const liquidityPoolTvl =
+      Number(this.syBalance) * this.flavor.currentSyExchangeRate + Number(this.ptBalance) / this.currentPtPriceInAsset
+    // Return LP price in asset units (0 if no supply to avoid division by zero)
+    return Number(this.lpSupply) === 0 ? 0 : liquidityPoolTvl / Number(this.lpSupply)
+  }
+
+  get secondsRemaining(): number {
+    const now = Date.now() / 1000
+    return Math.max(0, Math.round(this.state.expirationTs - now))
+  }
+
+  get absolutePtYield(): number {
+    const ptAssetExchangeRate = this.ptDiscount
+    return (1 - ptAssetExchangeRate) / ptAssetExchangeRate
+  }
+
+  /** Annualize a rate given the number of seconds remaining until maturity */
+  static annualize(r: number, secondsRemaining: number) {
+    return (r * SECONDS_PER_YEAR) / secondsRemaining
+  }
+
+  /** Annualized PT fixed rate */
+  get ptApr(): number {
+    return Market.annualize(this.absolutePtYield, this.secondsRemaining)
+  }
+
+  /** The fee rate taken off of trade fees (typically around 20%) expressed as a BPS number */
+  get feeTreasuryBps(): number {
+    return this.state.feeTreasurySyBps
+  }
+
+  /** The fee rate on assets when trading PT
+   * Expressed as a rational number
+   * eg 0.01 = 1%
+   */
+  get feeRatePtTrade(): number {
+    return 1 - this.marketCalculator().feeRate
+  }
+
+  /** The fee rate taken off of trade fees (typically around 20%) expressed as a rational number */
+  get feeTreasuryRate(): number {
+    return this.feeTreasuryBps / 10_000
+  }
+
+  /** Calculate amonut of LP tokens to expect for tokens in */
+  lpOutForTokensIn(syInIntent: bigint, ptInIntent: bigint): LiquidityAdd {
+    return lpOutForTokensIn({
+      syIntent: Number(syInIntent),
+      ptIntent: Number(ptInIntent),
+      lpSupply: Number(this.lpSupply),
+      syLiquidity: Number(this.syBalance),
+      ptLiquidity: Number(this.ptBalance),
+    })
+  }
+
+  marketCalculator() {
+    const secondsRemaining = Math.max(0, Math.round(this.state.expirationTs - Date.now() / 1000))
+    return new MarketCalculator({
+      liquiditySy: parseInt(this.syBalance.toString()),
+      liquidityPt: parseInt(this.ptBalance.toString()),
+      currentSyExchangeRate: this.currentSyExchangeRate,
+      lnFeeRateRoot: this.state.lnFeeRateRoot,
+      secondsRemaining,
+      lpTokenSupply: this.lpSupply,
+      rateScalarRoot: this.state.rateScalarRoot,
+      lastLnImpliedRate: this.state.lastLnImpliedRate,
+      maxNetBalanceChangeNegativePercentage: this.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+      maxNetBalanceChangePositivePercentage: this.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+      windowStartTimestamp: this.state.liquidityNetBalanceLimits.windowStartTimestamp,
+      windowStartNetBalance: this.state.liquidityNetBalanceLimits.windowStartNetBalance.toNumber(),
+      windowDurationSeconds: this.state.liquidityNetBalanceLimits.windowDurationSeconds,
+    })
+  }
+
+  /** 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,
+    minLpOut,
+    depositor,
+    ptSrc,
+    sySrc,
+    lpDst,
+  }: {
+    /** Intended (maximum) amount of PT in */
+    ptInIntent: bigint
+    /** Intended (maximum) amount of SY in */
+    syInIntent: bigint
+    /** Minimum LP tokens out */
+    minLpOut: bigint
+    depositor: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    lpDst?: web3.PublicKey
+  }) {
+    const tokenProgram = TOKEN_PROGRAM_ID
+
+    sySrc = sySrc || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    lpDst = lpDst || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+
+    const syRemAccounts = this.cpiAccounts.depositSy
+
+    return this.coreProgram.methods
+      .marketTwoDepositLiquidity(
+        new BN(ptInIntent.toString()),
+        new BN(syInIntent.toString()),
+        new BN(minLpOut.toString()),
+      )
+      .accountsStrict({
+        depositor,
+        market: this.selfAddress,
+        mintLp: this.mintLp,
+        tokenPtSrc: ptSrc,
+        tokenSySrc: sySrc,
+        tokenLpDst: lpDst,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenProgram,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(syRemAccounts)
+      .instruction()
+  }
+
+  async ixModifyMarketSetting({ signer, adminAction }: { signer: web3.PublicKey; adminAction: MarketAdminAction }) {
+    return this.coreProgram.methods
+      .modifyMarketSetting(adminAction)
+      .accountsStrict({
+        market: this.selfAddress,
+        adminState: getExponentAdminStatePda(),
+        signer,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .instruction()
+  }
+
+  async ixModifyFarm({
+    newRate,
+    untilTimestamp,
+    signer,
+    farmMint,
+    farmTokenProgram,
+    farmTokenSrc,
+  }: {
+    newRate: bigint
+    untilTimestamp: number
+    signer: web3.PublicKey
+    farmMint: web3.PublicKey
+    farmTokenProgram: web3.PublicKey
+    farmTokenSrc?: web3.PublicKey
+  }) {
+    farmTokenSrc = farmTokenSrc || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
+
+    const tokenFarm = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
+
+    return this.coreProgram.methods
+      .modifyFarm(untilTimestamp, new BN(newRate.toString()))
+      .accountsStrict({
+        adminState: getExponentAdminStatePda(),
+        market: this.selfAddress,
+        mint: farmMint,
+        tokenFarm: tokenFarm,
+        signer,
+        tokenProgram: farmTokenProgram,
+        tokenSource: farmTokenSrc,
+      })
+      .instruction()
+  }
+  /**
+   * 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,
+    minPtOut,
+    minSyOut,
+    ptDst,
+    syDst,
+    lpSrc,
+  }: {
+    lpIn: bigint
+    withdrawer: web3.PublicKey
+    minPtOut: bigint
+    minSyOut: bigint
+    ptDst?: web3.PublicKey
+    syDst?: web3.PublicKey
+    lpSrc?: web3.PublicKey
+  }) {
+    ptDst = ptDst || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
+    syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
+    lpSrc = lpSrc || getAssociatedTokenAddressSync(this.mintLp, withdrawer, true, TOKEN_PROGRAM_ID)
+
+    const ptDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, ptDst, withdrawer, this.mintPt)
+    const syDstAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, syDst, withdrawer, this.mintSy)
+    const lpSrcAtaIx = createAssociatedTokenAccountIdempotentInstruction(withdrawer, lpSrc, withdrawer, this.mintLp)
+
+    const syRemAccounts = this.cpiAccounts.withdrawSy
+
+    const ixs = await this.coreProgram.methods
+      .marketTwoWithdrawLiquidity(new BN(lpIn.toString()), new BN(minPtOut.toString()), new BN(minSyOut.toString()))
+      .accountsStrict({
+        withdrawer,
+        market: this.selfAddress,
+        mintLp: this.mintLp,
+        tokenPtDst: ptDst,
+        tokenSyDst: syDst,
+        tokenLpSrc: lpSrc,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(syRemAccounts)
+      .instruction()
+
+    return { ixs: [ixs], setupIxs: [ptDstAtaIx, syDstAtaIx, lpSrcAtaIx] }
+  }
+
+  /** 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,
+    amountPt,
+    maxSySpend,
+    tokenPt,
+    tokenSy,
+  }: {
+    trader: web3.PublicKey
+    amountPt: bigint
+    maxSySpend: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderPt: amountPt,
+      syConstraint: maxSySpend,
+      isBuy: true,
+      tokenPt,
+      tokenSy,
+    })
+  }
+
+  /**
+   * 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,
+    minSyReceive,
+    tokenPt,
+    tokenSy,
+  }: {
+    trader: web3.PublicKey
+    amountPt: bigint
+    minSyReceive: bigint
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+  }) {
+    return this.ixTradePt({
+      trader,
+      traderPt: amountPt,
+      syConstraint: minSyReceive,
+      isBuy: false,
+      tokenPt,
+      tokenSy,
+    })
+  }
+
+  async ixTradePt({
+    trader,
+    traderPt,
+    syConstraint,
+    isBuy,
+    tokenPt,
+    tokenSy,
+  }: {
+    trader: web3.PublicKey
+    traderPt: bigint
+    syConstraint: bigint
+    isBuy: boolean
+    tokenPt?: web3.PublicKey
+    tokenSy?: web3.PublicKey
+  }) {
+    tokenPt = tokenPt || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    tokenSy = tokenSy || 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 = [
+      ...this.cpiAccounts.getSyState,
+      ...this.cpiAccounts.depositSy,
+      ...this.cpiAccounts.withdrawSy,
+    ]
+
+    const netTradePtBN = new BN(traderPt.toString()).mul(isBuy ? new BN(1) : new BN(-1))
+    const syConstraintBN = new BN(syConstraint.toString()).mul(isBuy ? new BN(-1) : new BN(1))
+
+    const ix = await this.coreProgram.methods
+      .tradePt(netTradePtBN, syConstraintBN)
+      .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.vault.state.treasurySyTokenAccount,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ix], setupIxs: [tokenPtAtaIx, tokenSyAtaIx] }
+  }
+
+  /** 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,
+    ptSrc,
+    syDst,
+  }: {
+    trader: web3.PublicKey
+    ytIn: bigint
+    minSyOut: bigint
+    ytSrc?: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    syDst?: web3.PublicKey
+  }) {
+    syDst = syDst || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    ptSrc = ptSrc || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    ytSrc = ytSrc || 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.vault.mergeAccounts({ owner: trader, ytSrc, ptSrc, syDst })
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.getSyState,
+      ...this.cpiAccounts.depositSy,
+      ...mergeAccounts.remainingAccounts,
+    ])
+    remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false })
+
+    const ix = await this.coreProgram.methods
+      .sellYt(new BN(ytIn.toString()), new BN(minSyOut.toString()))
+      .accountsStrict({
+        trader,
+        market: this.selfAddress,
+        tokenYtTrader: ytSrc,
+        tokenPtTrader: ptSrc,
+        tokenSyTrader: syDst,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        addressLookupTable: this.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        vault: mergeAccounts.mainAccounts.vault,
+        authorityVault: mergeAccounts.mainAccounts.authority,
+        tokenSyEscrowVault: mergeAccounts.mainAccounts.escrowSy,
+        mintYt: this.mintYt,
+        mintPt: this.mintPt,
+        addressLookupTableVault: mergeAccounts.mainAccounts.addressLookupTable,
+        yieldPositionVault: mergeAccounts.mainAccounts.yieldPosition,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ix], setupIxs: [syDstAtaIxs, ptSrcAtaIxs, ytSrcAtaIxs] }
+  }
+
+  /** 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,
+    ptTrader,
+    syTrader,
+  }: {
+    trader: web3.PublicKey
+    ytOut: bigint
+    maxSyIn: bigint
+    ytTrader?: web3.PublicKey
+    ptTrader?: web3.PublicKey
+    syTrader?: web3.PublicKey
+  }) {
+    syTrader = syTrader || getAssociatedTokenAddressSync(this.mintSy, trader, true, TOKEN_PROGRAM_ID)
+    ptTrader = ptTrader || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
+    ytTrader = ytTrader || 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.vault.stripAccounts({
+      depositor: trader,
+      ytDst: ytTrader,
+      ptDst: ptTrader,
+      sySrc: syTrader,
+    })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.getSyState,
+      ...this.cpiAccounts.withdrawSy,
+      ...this.cpiAccounts.depositSy,
+      ...stripAccounts.remainingAccounts,
+    ])
+    remainingAccounts.push({ pubkey: this.coreProgram.programId, isWritable: false, isSigner: false })
+
+    const ix = await this.coreProgram.methods
+      .buyYt(new BN(maxSyIn.toString()), new BN(ytOut.toString()))
+      .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,
+        vault: stripAccounts.mainAccounts.vault,
+        vaultAuthority: stripAccounts.mainAccounts.authority,
+        tokenSyEscrowVault: stripAccounts.mainAccounts.escrowSy,
+        mintYt: this.mintYt,
+        mintPt: this.mintPt,
+        addressLookupTableVault: stripAccounts.mainAccounts.addressLookupTable,
+        yieldPosition: stripAccounts.mainAccounts.yieldPosition,
+        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] }
+  }
+
+  async ixInitLpPosition({ owner, feePayer }: { owner: web3.PublicKey; feePayer?: web3.PublicKey }) {
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+    return this.coreProgram.methods
+      .initLpPosition()
+      .accountsStrict({
+        owner,
+        feePayer: feePayer || owner,
+        lpPosition,
+        market: this.selfAddress,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .instruction()
+  }
+
+  /** Deposit LP tokens into the farming module to earn rewards */
+  async ixDepositLp({ owner, amount, lpSrc }: { owner: web3.PublicKey; amount: bigint; lpSrc?: web3.PublicKey }) {
+    lpSrc = lpSrc || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+
+    return this.coreProgram.methods
+      .marketDepositLp(new BN(amount.toString()))
+      .accountsStrict({
+        owner,
+        lpPosition,
+        tokenLpSrc: lpSrc,
+        tokenLpEscrow: this.tokenLpEscrow,
+        market: this.selfAddress,
+        addressLookupTable: this.addressLookupTable,
+        syProgram: this.syProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        mintLp: this.mintLp,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(this.cpiAccounts.getPositionState)
+      .instruction()
+  }
+
+  /** Withdraw LP tokens from the farming module */
+  async ixWithdrawLp({ owner, amount, lpDst }: { owner: web3.PublicKey; amount: bigint; lpDst?: web3.PublicKey }) {
+    lpDst = lpDst || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+    return this.coreProgram.methods
+      .marketWithdrawLp(new BN(amount.toString()))
+      .accountsStrict({
+        owner,
+        lpPosition,
+        tokenLpDst: lpDst,
+        tokenLpEscrow: this.tokenLpEscrow,
+        market: this.selfAddress,
+        addressLookupTable: this.addressLookupTable,
+        mintLp: this.mintLp,
+        syProgram: this.syProgram,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(this.cpiAccounts.getPositionState)
+      .instruction()
+  }
+
+  async ixWrapperCollectInterest({ claimer, tokenSyDst }: { claimer: web3.PublicKey; tokenSyDst?: web3.PublicKey }) {
+    const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress })
+    tokenSyDst = tokenSyDst || getAssociatedTokenAddressSync(this.mintSy, claimer, true, TOKEN_PROGRAM_ID)
+    const tokenBaseClaimer = getAssociatedTokenAddressSync(
+      this.flavor.mintBase,
+      claimer,
+      true,
+      this.flavor.baseTokenProgram,
+    )
+    const tokenBaseClaimerAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      claimer,
+      tokenBaseClaimer,
+      claimer,
+      this.flavor.mintBase,
+    )
+
+    const tokenSyClaimer = getAssociatedTokenAddressSync(this.mintSy, claimer, true)
+    const tokenSyClaimerAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      claimer,
+      tokenSyClaimer,
+      claimer,
+      this.mintSy,
+    )
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.vault.cpiAccounts.getSyState,
+      ...this.vault.cpiAccounts.withdrawSy,
+    ])
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: claimer,
+      redeemerBaseTokenAccount: tokenBaseClaimer,
+      redeemerSyTokenAccount: tokenSyDst,
+    })
+
+    const ix = await this.coreProgram.methods
+      .wrapperCollectInterest(redeemSyIx.keys.length)
+      .accountsStrict({
+        addressLookupTable: this.vault.addressLookupTable,
+        authority: this.vault.state.authority,
+        claimer,
+        escrowSy: this.vault.escrowSy,
+        syProgram: this.syProgram,
+        vault: this.vault.selfAddress,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
+        yieldPosition: yieldPosition,
+        tokenSyDst,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(redeemSyIx.keys.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: claimer })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: claimer })),
+      ],
+      setupIxs: [tokenBaseClaimerAtaIx, tokenSyClaimerAtaIx],
+    }
+  }
+
+  async ixWrapperBuyPt({
+    owner,
+    ptOut,
+    maxBaseIn,
+    tokenSyTrader,
+    tokenPtTrader,
+    tokenBaseTrader,
+  }: {
+    owner: web3.PublicKey
+    ptOut: bigint
+    maxBaseIn: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.PublicKey
+  }) {
+    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    tokenBaseTrader =
+      tokenBaseTrader || 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
+
+    console.log("mintSyRemAccounts", mintSyRemAccounts)
+
+    mintSyRemAccounts.push({
+      pubkey: this.coreProgram.programId,
+      isWritable: false,
+      isSigner: false,
+    })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.getSyState,
+      ...this.cpiAccounts.depositSy,
+      // ...this.cpiAccounts.withdrawSy,
+    ])
+
+    const ix = await this.coreProgram.methods
+      .wrapperBuyPt(new BN(ptOut.toString()), new BN(maxBaseIn.toString()), 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.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .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,
+    tokenPtTrader,
+    tokenBaseTrader,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.PublicKey
+  }) {
+    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    tokenBaseTrader =
+      tokenBaseTrader || 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
+    redeemSyRemAccounts.push({
+      pubkey: this.coreProgram.programId,
+      isWritable: false,
+      isSigner: false,
+    })
+
+    const remainingAccounts = uniqueRemainingAccounts([...this.cpiAccounts.getSyState, ...this.cpiAccounts.withdrawSy])
+
+    const ix = await this.coreProgram.methods
+      .wrapperSellPt(new BN(amount.toString()), new BN(minBaseOut.toString()), 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.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .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,
+    tokenPtTrader,
+    tokenYtTrader,
+    tokenBaseTrader,
+  }: {
+    owner: web3.PublicKey
+    ytOut: bigint
+    maxBaseIn: bigint
+    tokenSyTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+    tokenYtTrader?: web3.PublicKey
+    tokenBaseTrader?: web3.PublicKey
+  }) {
+    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtTrader = tokenPtTrader || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    tokenYtTrader = tokenYtTrader || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    tokenBaseTrader =
+      tokenBaseTrader || 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 mintSyRemAccounts = mintSyIx.keys
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.getSyState,
+      ...this.vault.cpiAccounts.depositSy,
+      ...this.vault.cpiAccounts.getSyState,
+      ...this.cpiAccounts.withdrawSy,
+      ...this.cpiAccounts.getPositionState,
+    ])
+
+    const allRemainingAccounts = mintSyRemAccounts.concat(remainingAccounts)
+
+    const ix1 = await this.coreProgram.methods
+      .wrapperBuyYt(new BN(ytOut.toString()), new BN(maxBaseIn.toString()), mintSyRemAccounts.length)
+      .accountsStrict({
+        buyer: owner,
+        market: this.selfAddress,
+        tokenSyTrader,
+        tokenYtTrader,
+        tokenPtTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenPtEscrow: this.tokenPtEscrow,
+        marketAddressLookupTable: this.addressLookupTable,
+        vault: this.vault.selfAddress,
+        vaultAuthority: this.vault.authority,
+        tokenSyEscrowVault: this.vault.escrowSy,
+        vaultAddressLookupTable: this.vault.addressLookupTable,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        mintPt: this.vault.mintPt,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+        mintYt: this.vault.mintYt,
+        escrowYt: this.vault.escrowYt,
+        systemProgram: web3.SystemProgram.programId,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(allRemainingAccounts)
+      .instruction()
+
+    const ix2 = await this.coreProgram.methods
+      .depositYt(new BN(ytOut.toString()))
+      .accountsStrict({
+        depositor: owner,
+        vault: this.vault.selfAddress,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+        ytSrc: tokenYtTrader,
+        escrowYt: this.vault.escrowYt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        addressLookupTable: this.vault.addressLookupTable,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: owner })),
+        ix1,
+        ...(await this.flavor.postIxs({ signer: owner })),
+        ix2,
+      ],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
+    }
+  }
+
+  async ixWrapperSellYt({
+    owner,
+    amount,
+    minBaseOut,
+    tokenBaseTrader,
+    tokenSyTrader,
+    tokenYtTrader,
+    tokenPtTrader,
+  }: {
+    owner: web3.PublicKey
+    amount: bigint
+    minBaseOut: bigint
+    tokenBaseTrader?: web3.PublicKey
+    tokenSyTrader?: web3.PublicKey
+    tokenYtTrader?: web3.PublicKey
+    tokenPtTrader?: web3.PublicKey
+  }) {
+    tokenBaseTrader =
+      tokenBaseTrader || getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    tokenSyTrader = tokenSyTrader || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenYtTrader = tokenYtTrader || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtTrader = tokenPtTrader || 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.cpiAccounts.getSyState,
+      ...this.cpiAccounts.withdrawSy,
+      ...this.vault.cpiAccounts.depositSy,
+    ])
+
+    console.log(" remaining accounts length", remainingAccounts.length)
+
+    // remainingAccounts.push({
+    //   pubkey: this.coreProgram.programId,
+    //   isWritable: false,
+    //   isSigner: false,
+    // })
+
+    const ix1 = await this.coreProgram.methods
+      .withdrawYt(new BN(amount.toString()))
+      .accountsStrict({
+        ytDst: tokenYtTrader,
+        escrowYt: this.vault.escrowYt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        addressLookupTable: this.vault.addressLookupTable,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
+        authority: this.vault.authority,
+        owner,
+        vault: this.vault.selfAddress,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+
+    const ix2 = await this.coreProgram.methods
+      .wrapperSellYt(new BN(amount.toString()), new BN(minBaseOut.toString()), redeemSyRemAccounts.length)
+      .accountsStrict({
+        seller: owner,
+        market: this.selfAddress,
+        tokenYtTrader,
+        marketAddressLookupTable: this.addressLookupTable,
+        vault: this.vault.selfAddress,
+        vaultAuthority: this.vault.authority,
+        tokenPtTrader,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrowVault: this.vault.escrowSy,
+        vaultAddressLookupTable: this.vault.addressLookupTable,
+        yieldPosition: this.vault.state.yieldPositonAddress,
+        mintPt: this.vault.mintPt,
+        mintYt: this.vault.mintYt,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        tokenSyTrader,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [
+        ix1,
+        ...(await this.flavor.preIxs({ signer: owner })),
+        ix2,
+        ...(await this.flavor.postIxs({ signer: owner })),
+      ],
+      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
+    }
+  }
+
+  async ixCollectMarketEmission({
+    owner,
+    emissionIndex,
+    emissionDst,
+  }: {
+    owner: web3.PublicKey
+    emissionIndex: number
+    emissionDst?: web3.PublicKey
+  }) {
+    const emission = this.emissions[emissionIndex]
+    const tokenEmissionDst =
+      emissionDst || getAssociatedTokenAddressSync(emission.mint, owner, true, emission.tokenProgramAddress)
+
+    const tokenEmissionDstIx = createAssociatedTokenAccountIdempotentInstruction(
+      owner,
+      tokenEmissionDst,
+      owner,
+      emission.mint,
+    )
+    const ix = await this.coreProgram.methods
+      .marketCollectEmission(emissionIndex)
+      .accountsStrict({
+        addressLookupTable: this.addressLookupTable,
+        lpPosition: this.xponPda.marketLpPosition({ market: this.selfAddress, owner }),
+        market: this.selfAddress,
+        owner,
+        syProgram: this.syProgram,
+        tokenEmissionDst,
+        tokenEmissionEscrow: this.marketEmissions.trackers[emissionIndex].tokenEscrow,
+        tokenProgram: emission.tokenProgramAddress,
+        program: this.coreProgram.programId,
+        eventAuthority: this.eventAuthority,
+      })
+      .remainingAccounts(this.cpiAccounts.claimEmission[emissionIndex])
+      .instruction()
+
+    return {
+      ixs: [ix],
+      setupIxs: [tokenEmissionDstIx],
+    }
+  }
+
+  /** Provide liquidity from a base asset - and receive YT and LP tokens in return */
+  async ixProvideLiquidityNoPriceImpact({
+    depositor,
+    amountBase,
+    minLpOut,
+    tokenSyDepositor,
+    tokenYtDepositor,
+    tokenPtDepositor,
+    tokenBaseDepositor,
+    tokenLpDepositor,
+  }: {
+    depositor: web3.PublicKey
+    amountBase: bigint
+    minLpOut: bigint
+    tokenSyDepositor?: web3.PublicKey
+    tokenYtDepositor?: web3.PublicKey
+    tokenPtDepositor?: web3.PublicKey
+    tokenBaseDepositor?: web3.PublicKey
+    tokenLpDepositor?: web3.PublicKey
+  }) {
+    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenBaseDepositor =
+      tokenBaseDepositor ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
+    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+
+    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 tokenLpDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenLpDepositor,
+      depositor,
+      this.mintLp,
+    )
+
+    const amountBaseBn = new BN(amountBase.toString())
+    const minLpOutBn = new BN(minLpOut.toString())
+
+    // TODO - fix this
+    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
+
+    // Log vault accounts before filtering
+    const beforeVaultAccounts = [...this.vault.cpiAccounts.getSyState, ...this.vault.cpiAccounts.depositSy]
+    console.log("Before filtering vault accounts:", beforeVaultAccounts.length, "accounts")
+
+    // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from vault remaining accounts
+    const vaultCpiRemainingAccounts = beforeVaultAccounts.filter(
+      (account) => account.pubkey.toBase58() !== TOKEN_PROGRAM_ID.toBase58(),
+    )
+
+    // Log vault accounts after filtering
+    console.log("After filtering vault accounts:", vaultCpiRemainingAccounts.length, "accounts")
+
+    // Log market accounts before filtering
+    const beforeMarketAccounts = [...this.cpiAccounts.depositSy]
+    console.log("Before filtering market accounts:", beforeMarketAccounts.length, "accounts")
+
+    // Filter out TOKEN_PROGRAM_ID and SystemProgram.programId from market remaining accounts
+    const marketCpiRemainingAccounts = beforeMarketAccounts.filter(
+      (account) =>
+        account.pubkey.toBase58() !== TOKEN_PROGRAM_ID.toBase58() &&
+        account.pubkey.toBase58() !== web3.SystemProgram.programId.toBase58() &&
+        account.pubkey.toBase58() !== this.selfAddress.toBase58(),
+    )
+
+    // Log market accounts after filtering
+    console.log("After filtering market accounts:", marketCpiRemainingAccounts.length, "accounts")
+
+    // These remaining accounts can be in any order, and they can be unique-ified
+    const unorderedRemainingAccounts = uniqueRemainingAccounts([
+      ...vaultCpiRemainingAccounts,
+      ...marketCpiRemainingAccounts,
+    ])
+
+    const allRemainingAccounts = [...mintSyRemAccounts, ...unorderedRemainingAccounts]
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
+
+    const ix = await this.coreProgram.methods
+      .wrapperProvideLiquidity(amountBaseBn, minLpOutBn, mintSyRemAccounts.length)
+      .accountsStrict({
+        depositor,
+        authority: this.vault.authority,
+        vault: this.vault.selfAddress,
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpDst: tokenLpDepositor,
+        mintLp: this.mintLp,
+        escrowSy: this.vault.escrowSy,
+        escrowYt: this.vault.escrowYt,
+        tokenSyDepositor,
+        tokenYtDepositor,
+        tokenPtDepositor,
+        mintYt: this.vault.mintYt,
+        mintPt: this.vault.mintPt,
+        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner: depositor }),
+        systemProgram: web3.SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        syProgram: this.syProgram,
+        marketAddressLookupTable: this.addressLookupTable,
+        vaultAddressLookupTable: this.vault.addressLookupTable,
+        vaultRobotYieldPosition: this.vault.state.yieldPositonAddress,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+        lpPosition,
+        tokenLpEscrow: this.tokenLpEscrow,
+      })
+      .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 })),
+      ],
+      setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx, tokenLpDepositorAtaIx],
+    }
+  }
+
+  async ixProvideLiquidityBase({
+    depositor,
+    amountBase,
+    minLpOut,
+    externalPtToBuy,
+    externalSyConstraint,
+    tokenSyDepositor,
+    tokenYtDepositor,
+    tokenPtDepositor,
+    tokenBaseDepositor,
+    tokenLpDepositor,
+  }: {
+    depositor: web3.PublicKey
+    amountBase: bigint
+    minLpOut: bigint
+    externalPtToBuy: bigint
+    externalSyConstraint: bigint
+    tokenSyDepositor?: web3.PublicKey
+    tokenYtDepositor?: web3.PublicKey
+    tokenPtDepositor?: web3.PublicKey
+    tokenBaseDepositor?: web3.PublicKey
+    tokenLpDepositor?: web3.PublicKey
+  }) {
+    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenBaseDepositor =
+      tokenBaseDepositor ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
+    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+
+    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 tokenLpAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenLpDepositor,
+      depositor,
+      this.mintLp,
+    )
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.depositSy,
+      ...this.cpiAccounts.getPositionState,
+    ])
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      amountBase: "0",
+      depositor,
+      depositorBaseTokenAccount: tokenBaseDepositor,
+      depositorSyTokenAccount: tokenSyDepositor,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+
+    const ix = await this.coreProgram.methods
+      .wrapperProvideLiquidityBase(
+        new BN(amountBase.toString()),
+        new BN(minLpOut.toString()),
+        mintSyRemAccounts.length,
+        new BN(externalPtToBuy.toString()),
+        new BN(externalSyConstraint.toString()),
+      )
+      .accountsStrict({
+        depositor,
+        lpPosition,
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpDst: tokenLpDepositor,
+        mintLp: this.mintLp,
+        syProgram: this.syProgram,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenLpEscrow: this.tokenLpEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenPtDepositor,
+        tokenSyDepositor,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: depositor })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: depositor })),
+      ],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
+    }
+  }
+
+  async ixProvideLiquidityClassic({
+    depositor,
+    amountBase,
+    amountPt,
+    minLpOut,
+    tokenSyDepositor,
+    tokenYtDepositor,
+    tokenPtDepositor,
+    tokenBaseDepositor,
+    tokenLpDepositor,
+  }: {
+    depositor: web3.PublicKey
+    amountBase: bigint
+    amountPt: bigint
+    minLpOut: bigint
+    tokenSyDepositor?: web3.PublicKey
+    tokenYtDepositor?: web3.PublicKey
+    tokenPtDepositor?: web3.PublicKey
+    tokenBaseDepositor?: web3.PublicKey
+    tokenLpDepositor?: web3.PublicKey
+  }) {
+    tokenSyDepositor = tokenSyDepositor || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
+    tokenYtDepositor = tokenYtDepositor || getAssociatedTokenAddressSync(this.mintYt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenPtDepositor = tokenPtDepositor || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
+    tokenBaseDepositor =
+      tokenBaseDepositor ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, depositor, true, this.flavor.baseTokenProgram)
+    tokenLpDepositor = tokenLpDepositor || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
+
+    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 tokenLpAtaIx = createAssociatedTokenAccountIdempotentInstruction(
+      depositor,
+      tokenLpDepositor,
+      depositor,
+      this.mintLp,
+    )
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner: depositor })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.depositSy,
+      ...this.cpiAccounts.getPositionState,
+    ])
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      amountBase: "0",
+      depositor,
+      depositorBaseTokenAccount: tokenBaseDepositor,
+      depositorSyTokenAccount: tokenSyDepositor,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+
+    const ix = await this.coreProgram.methods
+      .wrapperProvideLiquidityClassic(
+        new BN(amountBase.toString()),
+        new BN(amountPt.toString()),
+        new BN(minLpOut.toString()),
+        mintSyRemAccounts.length,
+      )
+      .accountsStrict({
+        depositor,
+        lpPosition,
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpDst: tokenLpDepositor,
+        mintLp: this.mintLp,
+        syProgram: this.syProgram,
+        tokenLpEscrow: this.tokenLpEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        marketAddressLookupTable: this.addressLookupTable,
+        tokenPtDepositor,
+        tokenSyDepositor,
+        systemProgram: web3.SystemProgram.programId,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .remainingAccounts(mintSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+
+    return {
+      ixs: [
+        ...(await this.flavor.preIxs({ signer: depositor })),
+        ix,
+        ...(await this.flavor.postIxs({ signer: depositor })),
+      ],
+      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenLpAtaIx],
+    }
+  }
+
+  async ixWithdrawLiquidityToBase({
+    owner,
+    amountLp,
+    minBaseOut,
+    tokenSyWithdrawer,
+    tokenYtWithdrawer,
+    tokenPtWithdrawer,
+    tokenBaseWithdrawer,
+    tokenLpWithdrawer,
+  }: {
+    owner: web3.PublicKey
+    amountLp: bigint
+    minBaseOut: bigint
+    tokenSyWithdrawer?: web3.PublicKey
+    tokenYtWithdrawer?: web3.PublicKey
+    tokenPtWithdrawer?: web3.PublicKey
+    tokenBaseWithdrawer?: web3.PublicKey
+    tokenLpWithdrawer?: web3.PublicKey
+  }) {
+    tokenSyWithdrawer = tokenSyWithdrawer || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenYtWithdrawer = tokenYtWithdrawer || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtWithdrawer = tokenPtWithdrawer || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    tokenBaseWithdrawer =
+      tokenBaseWithdrawer ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    tokenLpWithdrawer = tokenLpWithdrawer || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+
+    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 tokenLpAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenLpWithdrawer, owner, this.mintLp)
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.withdrawSy,
+      ...this.cpiAccounts.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.coreProgram.methods
+      .wrapperWithdrawLiquidity(
+        new BN(amountLp.toString()),
+        new BN(minSyOut.toFixed(0).toString()),
+        redeemSyRemAccounts.length,
+      )
+      .accountsStrict({
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpSrc: tokenLpWithdrawer,
+        lpPosition,
+        marketAddressLookupTable: this.addressLookupTable,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+        syProgram: this.syProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
+        tokenLpEscrow: this.tokenLpEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenPtWithdrawer,
+        tokenSyWithdrawer,
+        mintLp: this.mintLp,
+        withdrawer: owner,
+      })
+      .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, tokenLpAtaIx],
+    }
+  }
+
+  async ixWithdrawLiquidityClassic({
+    owner,
+    amountLp,
+    minBaseOut,
+    tokenSyWithdrawer,
+    tokenYtWithdrawer,
+    tokenPtWithdrawer,
+    tokenBaseWithdrawer,
+    tokenLpWithdrawer,
+  }: {
+    owner: web3.PublicKey
+    amountLp: bigint
+    minBaseOut: bigint
+    tokenSyWithdrawer?: web3.PublicKey
+    tokenYtWithdrawer?: web3.PublicKey
+    tokenPtWithdrawer?: web3.PublicKey
+    tokenBaseWithdrawer?: web3.PublicKey
+    tokenLpWithdrawer?: web3.PublicKey
+  }) {
+    tokenSyWithdrawer = tokenSyWithdrawer || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
+    tokenYtWithdrawer = tokenYtWithdrawer || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
+    tokenPtWithdrawer = tokenPtWithdrawer || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
+    tokenBaseWithdrawer =
+      tokenBaseWithdrawer ||
+      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
+    tokenLpWithdrawer = tokenLpWithdrawer || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
+
+    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 tokenLpAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenLpWithdrawer, owner, this.mintLp)
+
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+
+    const remainingAccounts = uniqueRemainingAccounts([
+      ...this.cpiAccounts.withdrawSy,
+      ...this.cpiAccounts.getPositionState,
+    ])
+
+    const redeemSyIx = await this.flavor.ixRedeemSy({
+      amountSy: "0",
+      redeemer: owner,
+      redeemerBaseTokenAccount: tokenBaseWithdrawer,
+      redeemerSyTokenAccount: tokenSyWithdrawer,
+    })
+
+    const redeemSyRemAccounts = redeemSyIx.keys
+
+    const ixn = await this.coreProgram.methods
+      .wrapperWithdrawLiquidityClassic(new BN(amountLp.toString()), redeemSyRemAccounts.length)
+      .accountsStrict({
+        market: this.selfAddress,
+        tokenPtEscrow: this.tokenPtEscrow,
+        tokenSyEscrow: this.tokenSyEscrow,
+        tokenLpSrc: tokenLpWithdrawer,
+        lpPosition,
+        marketAddressLookupTable: this.addressLookupTable,
+        eventAuthority: this.vault.eventAuthority,
+        program: this.coreProgram.programId,
+        syProgram: this.syProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenLpEscrow: this.tokenLpEscrow,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenPtWithdrawer,
+        tokenSyWithdrawer,
+        mintLp: this.mintLp,
+        withdrawer: owner,
+      })
+      .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, tokenLpAtaIx],
+    }
+  }
+
+  async claimFarmEmissions({
+    owner,
+    mint,
+    tokenProgram,
+    tokenDst,
+  }: {
+    owner: web3.PublicKey
+    mint: web3.PublicKey
+    tokenProgram: web3.PublicKey
+    tokenDst?: web3.PublicKey
+  }) {
+    tokenDst = tokenDst || getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
+    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
+
+    const tokenFarm = getAssociatedTokenAddressSync(mint, this.selfAddress, true, tokenProgram)
+    const tokenAtaIx = createAssociatedTokenAccountIdempotentInstruction(owner, tokenDst, owner, mint)
+
+    const ix = await this.coreProgram.methods
+      .claimFarmEmissions({ all: {} })
+      .accountsStrict({
+        market: this.selfAddress,
+        lpPosition,
+        mint,
+        tokenFarm,
+        owner,
+        tokenDst,
+        tokenProgram,
+        eventAuthority: this.eventAuthority,
+        program: this.coreProgram.programId,
+      })
+      .instruction()
+
+    return {
+      ixs: [ix],
+      setupIxs: [tokenAtaIx],
+    }
+  }
+
+  async ixAddStandaloneEmission({
+    signer,
+    emissionMint,
+    emissionTokenProgram = TOKEN_PROGRAM_ID,
+    altAddresses,
+    cpiAccounts,
+  }: {
+    signer: web3.PublicKey
+    emissionMint: web3.PublicKey
+    emissionTokenProgram?: web3.PublicKey
+    altAddresses: web3.PublicKey[]
+    cpiAccounts: CpiAccountsRaw
+  }) {
+    const altUtil = extendAddressLookupTable(altAddresses, cpiAccounts)
+
+    const tokenEmission = getAssociatedTokenAddressSync(emissionMint, this.selfAddress, true, emissionTokenProgram)
+    const ix = await this.coreProgram.methods
+      .addMarketEmission(altUtil.cpiAccountIndexes)
+      .accountsStrict({
+        market: this.selfAddress,
+        adminState: getExponentAdminStatePda(),
+        feePayer: signer,
+        mintNew: emissionMint,
+        signer,
+        systemProgram: web3.SystemProgram.programId,
+        tokenEmission,
+        tokenProgram: emissionTokenProgram,
+      })
+      .instruction()
+
+    return {
+      extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
+      addMarketEmissionIx: ix,
+    }
+  }
+
+  async addFarm({
+    signer,
+    farmMint,
+    farmRewardTokenProgram,
+    emissionsRate,
+    untilTimestamp,
+    farmRewardSrc,
+    feePayer,
+  }: {
+    signer: web3.PublicKey
+    farmMint: web3.PublicKey
+    farmRewardTokenProgram: web3.PublicKey
+    emissionsRate: number
+    untilTimestamp: number
+    farmRewardSrc?: web3.PublicKey
+    feePayer?: web3.PublicKey
+  }) {
+    feePayer = feePayer || signer
+    const farmRewardEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmRewardTokenProgram)
+    farmRewardSrc = farmRewardSrc || getAssociatedTokenAddressSync(farmMint, signer, true, farmRewardTokenProgram)
+
+    const ix = await this.coreProgram.methods
+      .addFarm(new BN(emissionsRate), untilTimestamp)
+      .accountsStrict({
+        adminState: getExponentAdminStatePda(),
+        market: this.selfAddress,
+        feePayer,
+        signer,
+        mintNew: farmMint,
+        tokenFarm: farmRewardEscrow,
+        tokenProgram: farmRewardTokenProgram,
+        systemProgram: web3.SystemProgram.programId,
+        tokenSource: farmRewardSrc,
+      })
+      .instruction()
+
+    return {
+      ixs: [ix],
+    }
+  }
+
+  /** Calculate available liquidity for PT trades
+   * @param is_buy - true if buying PT with SY, false if selling PT for SY
+   * @param size_pt - amount of PT to trade (in PT decimals)
+   * @returns amount of PT that can be traded given current liquidity
+   */
+  liquidityAvailable(is_buy: boolean, size_pt: bigint): bigint {
+    const calc = this.marketCalculator()
+
+    if (is_buy) {
+      // When buying PT, we're limited by SY liquidity
+      // Convert PT amount to SY using current price
+      const syNeeded = Number(size_pt) * calc.exchangeRate
+      // Available SY in the market
+      const syAvailable = Number(this.syBalance)
+
+      if (syNeeded <= syAvailable) {
+        return size_pt
+      } else {
+        // Calculate max PT that can be bought with available SY
+        return BigInt(Math.floor(syAvailable / calc.exchangeRate))
+      }
+    } else {
+      // When selling PT, we're limited by PT liquidity in the market
+      const ptAvailable = this.ptBalance
+
+      if (size_pt <= ptAvailable) {
+        return size_pt
+      } else {
+        return ptAvailable
+      }
+    }
+  }
+}
+
+export type MarketJson = {
+  /** The market's public key */
+  address: string
+  /** The market's address lookup table public key */
+  addressLookupTable: string
+  /** The market's SY escrow account public key - this is a pass-through account which moves SY between an end-user and the SY program where it is deposited and withdrawn from */
+  tokenSyEscrow: string
+  /** The market's PT escrow account public key - this account holds the market's PT liquidity*/
+  tokenPtEscrow: string
+  /** The market's LP escrow account public key - this account holds the market's LP tokens which are used to farm rewards */
+  tokenLpEscrow: string
+
+  /** Token account that holds the market's SY fees */
+  treasurySyTokenAccount: string
+
+  /** The market's LP supply */
+  lpSupply: string
+
+  /** The SY program ID */
+  syProgram: string
+
+  mintPt: string
+  mintSy: string
+  mintLp: string
+
+  /** The market's PT balance */
+  ptBalance: string
+  /** The market's SY balance */
+  syBalance: string
+
+  /** The market's LP escrow amount */
+  lpEscrowAmount: string
+
+  /** The market's current SY rate */
+  currentSyRate: number
+
+  /** The market's expiration timestamp */
+  expirationTs: number
+
+  /** The market's expiration date */
+  expirationDate: string
+
+  /** The number of seconds remaining until the market expires */
+  secondsRemaining: number
+
+  /** The market's maximum LP supply */
+  maxLpSupply: string
+
+  lnFeeRateRoot: number
+
+  rateScalarRoot: number
+
+  feeTreasurySyBps: number
+
+  lastLnImpliedRate: number
+
+  /** The current rate scalar, taking into account the time decay*/
+  currentRateScalar: number
+
+  /** The current rate anchor that preserves the last implied rate */
+  currentRateAnchor: number
+
+  /** How many SY are required to buy 1 PT */
+  currentPtPriceInSy: number
+
+  /** How many assets are required to buy 1 PT */
+  currentPtPriceInAsset: number
+
+  /** Proportion of PT in terms of assets */
+  proportionPtInAsset: number
+
+  /** Proportion of PT in terms of SY */
+  proportionPtInSy: number
+
+  /** Current fee rate */
+  currentFeeRate: number
+
+  /** CPI accounts */
+  cpiAccounts: CpiAccountsRawJson
+
+  /** Annualized yield for PT */
+  ptApr: number
+
+  /** Emission tokens */
+  emissions: {
+    trackers: {
+      tokenEscrow: string
+      lpShareIndex: number
+      lastSeenStaged: number
+    }[]
+  }
+
+  liquidityNetBalanceLimits: {
+    windowStartTimestamp: number
+    windowStartNetBalance: string
+    maxNetBalanceChangeNegativePercentage: number
+    maxNetBalanceChangePositivePercentage: number
+    windowDurationSeconds: number
+  }
+
+  lpFarm: {
+    lastSeenTimestamp: number
+    farmEmissions: {
+      mint: string
+      /** Tokens per second */
+      tokenRate: string
+      expiryTimestamp: number
+      /** Index for converting LP shares into earned emissions */
+      index: string
+    }[]
+  }
+}
+
+function toJson(m: Market): MarketJson {
+  const c = m.marketCalculator()
+  return {
+    treasurySyTokenAccount: m.state.tokenFeeTreasurySy.toBase58(),
+    address: m.selfAddress.toBase58(),
+    addressLookupTable: m.addressLookupTable.toBase58(),
+    tokenSyEscrow: m.tokenSyEscrow.toBase58(),
+    tokenPtEscrow: m.tokenPtEscrow.toBase58(),
+    tokenLpEscrow: m.tokenLpEscrow.toBase58(),
+    lpSupply: m.state.lpSupply.toString(),
+    syProgram: m.state.syProgram.toBase58(),
+    mintPt: m.state.mintPt.toBase58(),
+    mintSy: m.state.mintSy.toBase58(),
+    mintLp: m.state.mintLp.toBase58(),
+    feeTreasurySyBps: m.state.feeTreasurySyBps,
+    ptBalance: m.state.ptBalance.toString(),
+    syBalance: m.state.syBalance.toString(),
+    currentSyRate: m.flavor.currentSyExchangeRate,
+    expirationTs: m.state.expirationTs,
+    expirationDate: new Date(m.state.expirationTs * 1000).toISOString(),
+    lnFeeRateRoot: m.state.lnFeeRateRoot,
+    rateScalarRoot: m.state.rateScalarRoot,
+    lastLnImpliedRate: m.state.lastLnImpliedRate,
+    currentPtPriceInSy: m.currentPtPriceInSy,
+    currentPtPriceInAsset: m.currentPtPriceInAsset,
+    secondsRemaining: m.secondsRemaining,
+    proportionPtInAsset: c.proportionPtInAsset,
+    proportionPtInSy: c.proportionPtInSy,
+    currentFeeRate: c.feeRate,
+    currentRateScalar: c.rateScalar,
+    currentRateAnchor: c.findRateAnchor(),
+    cpiAccounts: serializeCpiAccountsRaw(m.cpiAccounts),
+    emissions: {
+      trackers: m.marketEmissions.trackers.map((e) => ({
+        tokenEscrow: e.tokenEscrow.toBase58(),
+        lpShareIndex: e.lpShareIndex,
+        lastSeenStaged: e.lastSeenStaged,
+      })),
+    },
+    ptApr: m.ptApr,
+    lpEscrowAmount: m.state.lpEscrowAmount.toString(),
+    maxLpSupply: m.state.maxLpSupply.toString(),
+    liquidityNetBalanceLimits: {
+      windowStartTimestamp: m.state.liquidityNetBalanceLimits.windowStartTimestamp,
+      windowStartNetBalance: m.state.liquidityNetBalanceLimits.windowStartNetBalance.toString(),
+      maxNetBalanceChangeNegativePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
+      maxNetBalanceChangePositivePercentage: m.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
+      windowDurationSeconds: m.state.liquidityNetBalanceLimits.windowDurationSeconds,
+    },
+    lpFarm: {
+      lastSeenTimestamp: m.state.lpFarm.lastSeenTimestamp,
+      farmEmissions: m.state.lpFarm.farmEmissions.map((e) => ({
+        mint: e.mint.toBase58(),
+        tokenRate: e.tokenRate.toString(),
+        expiryTimestamp: e.expiryTimestamp,
+        index: PreciseNumber.fromRaw(e.index[0]).valueString,
+      })),
+    },
+  }
+}