@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/market.ts

@@ -1,2432 +0,0 @@
-import {
-  TOKEN_PROGRAM_ID,
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token"
-
-import { ExponentFetcher, LiquidityNetBalanceLimits, LpFarm } from "@exponent-labs/exponent-fetcher"
-import { ExponentPDA } from "@exponent-labs/exponent-pda"
-import {
-  AnchorizedPNum,
-  CpiAccountsRaw,
-  CpiAccountsRawJson,
-  Flavor,
-  SyPosition,
-  serializeCpiAccountsRaw,
-} from "@exponent-labs/exponent-types"
-import {
-  FlavorGenericStateJson,
-  SyPositionJson,
-  VaultJson,
-  deserializeCpiAccountsRaw,
-} from "@exponent-labs/exponent-types"
-import { LiquidityAdd, MarketCalculator, lpOutForTokensIn } from "@exponent-labs/market-math"
-import { PreciseNumber } from "@exponent-labs/precise-number"
-
-import { fetchAddressLookupTable, makeCpiAccountMetaLists } from "./addressLookupTableUtil"
-import { Environment } from "./environment"
-import {
-  deserializeFlavor,
-  makeFlavorGenericSync,
-  makeFlavorJitoRestakingSync,
-  makeFlavorKaminoSync,
-  makeFlavorMarginfiSync,
-  makeFlavorPerenaSync,
-  serializeFlavor,
-} from "./flavors"
-import { deserializeSyPosition, serializeSyPosition } from "./syPosition"
-import { makeSyPosition } from "./syPosition"
-import { getMultipleMintSupply } from "./tokenUtil"
-import { emitEventAuthority, getExponentAdminStatePda, uniqueRemainingAccounts } from "./utils"
-import { extendAddressLookupTable } from "./utils/altUtil"
-import { Vault } from "./vault"
-import { Connection, PublicKey, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from "@solana/web3.js"
-import * as exponentCore from "./client/core"
-import BN from 'bn.js'
-export type { LiquidityAdd }
-
-const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
-
-interface Emission {
-  /** Token account that holds emission tokens */
-  escrowAccountAddress: PublicKey
-
-  /** Mint for the emission token */
-  mint: PublicKey
-
-  /** Token program ID for the emission token */
-  tokenProgramAddress: PublicKey
-
-  /** How many emissions have been claimed by SY holders */
-  totalClaimed: bigint
-
-  /** How many emissions have been earned by the SY robot over its lifetime */
-  lastSeenTotalAccruedEmissions: bigint
-
-  /** Global index for sharing out rewards to SY holders */
-  index: AnchorizedPNum
-}
-
-export type MarketAdminAction = exponentCore.MarketAdminAction
-
-type MarketArgs = {
-  ptBalance: bigint
-  syBalance: bigint
-  lpSupply: bigint
-  sySupply: bigint
-  lpEscrowAmount: bigint
-  maxLpSupply: bigint
-  rateScalarRoot: number
-  lnFeeRateRoot: number
-  lastLnImpliedRate: number
-  expirationTs: number
-  addressLookupTable: PublicKey
-  mintSy: PublicKey
-  mintPt: PublicKey
-  vault: Vault
-  mintLp: PublicKey
-  tokenPtEscrow: PublicKey
-  tokenSyEscrow: PublicKey
-  tokenLpEscrow: PublicKey
-  syProgram: PublicKey
-  statusFlags: number
-  cpiAccounts: CpiAccountsRaw
-  feeTreasurySyBps: number
-  tokenFeeTreasurySy: PublicKey
-  isCurrentFlashSwap: boolean
-  lpFarm: LpFarm
-  flavor: Flavor
-  liquidityNetBalanceLimits: LiquidityNetBalanceLimits
-  syPosition: SyPosition
-  emissions: {
-    trackers: {
-      tokenEscrow: PublicKey
-      lpShareIndex: number
-      lastSeenStaged: number
-    }[]
-  }
-  seedId: number[]
-}
-
-
-export interface MarketLoadOptions {
-  syConfig?: {
-    skipWrap?: boolean
-  }
-}
-
-export class Market {
-  xponPda: ExponentPDA
-
-  constructor(
-    public state: MarketArgs,
-    public selfAddress: PublicKey,
-    public env: Environment,
-    public connection: Connection,
-  ) {
-    this.xponPda = new ExponentPDA(env.coreProgramId)
-  }
-
-  static async load(
-    env: Environment,
-    connection: Connection,
-    address: PublicKey,
-    vault?: Vault,
-    options: MarketLoadOptions = {},
-  ): Promise<Market> {
-    const fetcher = new ExponentFetcher({ connection })
-    const fetchedMarket = await fetcher.fetchMarket(address)
-    const [[lpSupply, sySupply], alt, loadedVault] = await Promise.all([
-      getMultipleMintSupply(connection, [fetchedMarket.mintLp, fetchedMarket.mintSy]),
-      fetchAddressLookupTable(connection, fetchedMarket.addressLookupTable),
-      vault || Vault.load(env, connection, fetchedMarket.vault, options),
-    ])
-    const cpiAccounts = makeCpiAccountMetaLists(alt, fetchedMarket.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, options.syConfig)
-        default:
-          throw new Error(`Unknown flavor: ${loadedVault.flavor}`)
-      }
-    })()
-
-    const syPosition = await makeSyPosition(fetcher, flavor, fetchedMarket.syProgram, address)
-
-    const state: MarketArgs = {
-      ...fetchedMarket,
-      vault: loadedVault,
-      cpiAccounts,
-      lpSupply,
-      sySupply,
-      flavor,
-      syPosition,
-    }
-    return new Market(state, address, env, connection)
-  }
-
-  async reload(connection: Connection = this.connection) {
-    const market = await Market.load(this.env, connection, this.selfAddress)
-    this.state = market.state
-    return market
-  }
-
-  /** 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(): PublicKey[] {
-    return this.emissions.map((e) => e.escrowAccountAddress)
-  }
-
-  /** Pass-through SY account owned by the market */
-  get tokenSyEscrow(): PublicKey {
-    return this.state.tokenSyEscrow
-  }
-
-  /** SY account that holds treasury SY fees from PT trading */
-  get tokenFeeTreasurySy(): PublicKey {
-    return this.state.tokenFeeTreasurySy
-  }
-
-  /** Market liquidity for PT */
-  get tokenPtEscrow(): PublicKey {
-    return this.state.tokenPtEscrow
-  }
-
-  get tokenLpEscrow(): PublicKey {
-    return this.state.tokenLpEscrow
-  }
-
-  get currentSyExchangeRate(): number {
-    return this.flavor.currentSyExchangeRate
-  }
-
-  /** Special account for event emit self-cpi */
-  get eventAuthority(): PublicKey {
-    return emitEventAuthority(this.env.coreProgramId)
-  }
-
-  get currentPtPriceInSy(): number {
-    return this.currentPtPriceInAsset / this.currentSyExchangeRate
-  }
-
-  get currentPtPriceInAsset(): number {
-    const marketCalculator = this.marketCalculator()
-    return marketCalculator.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)
-  }
-
-  // Calculate total value of liquidity in asset units
-  get liquidityPoolTvl(): number {
-    return (
-      Number(this.syBalance) * this.flavor.currentSyExchangeRate + Number(this.ptBalance) / this.currentPtPriceInAsset
-    )
-  }
-
-  get secondsRemaining(): number {
-    const timeNow = Date.now() / 1000
-    return Math.max(0, Math.round(this.state.expirationTs - timeNow))
-  }
-
-  get absolutePtYield(): number {
-    const ptAssetExchangeRate = this.ptDiscount
-    return (1 - ptAssetExchangeRate) / ptAssetExchangeRate
-  }
-
-  /** 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
-  }
-
-  /** Annualized PT fixed rate */
-  get ptApr(): number {
-    return Market.annualize(this.absolutePtYield, this.secondsRemaining)
-  }
-
-  get ptApy(): number {
-    return Market.annualizeApy(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 amount 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 timeNow = Date.now() / 1000
-    const secondsRemaining = Math.max(0, Math.round(this.state.expirationTs - timeNow))
-    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,
-      feeTreasurySyBps: this.state.feeTreasurySyBps,
-    })
-  }
-
-  /** Deposit a pair of tokens as liquidity to the market
-   * Adds PT & SY from the `depositor` to the market
-   *
-   * Due to unforeseeable slippage, the PT & SY amounts intended are effectively the maximum amounts
-   * The minimum LP tokens to receive is specified by `minLpOut`
-   *
-   * The token accounts themselves are optional, and will be derived from the depositor's wallet if not provided
-   */
-  ixDepositLiquidity({
-    ptInIntent,
-    syInIntent,
-    minLpOut,
-    depositor,
-    ptSrc: ptSrcParam,
-    sySrc: sySrcParam,
-    lpDst: lpDstParam,
-  }: {
-    /** Intended (maximum) amount of PT in */
-    ptInIntent: bigint
-    /** Intended (maximum) amount of SY in */
-    syInIntent: bigint
-    /** Minimum LP tokens out */
-    minLpOut: bigint
-    depositor: PublicKey
-    ptSrc?: PublicKey
-    sySrc?: PublicKey
-    lpDst?: PublicKey
-  }): TransactionInstruction {
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(this.mintSy, depositor, true, TOKEN_PROGRAM_ID)
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, depositor, true, TOKEN_PROGRAM_ID)
-    const lpDst = lpDstParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
-
-    const syRemAccounts = this.cpiAccounts.depositSy
-
-    const ix = exponentCore.createMarketTwoDepositLiquidityInstruction(
-      {
-        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: TOKEN_PROGRAM_ID,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { ptIntent: ptInIntent, syIntent: syInIntent, minLpOut },
-    )
-    ix.keys.push(...syRemAccounts)
-    return ix
-  }
-
-  ixModifyMarketSetting({ signer, adminAction }: { signer: PublicKey; adminAction: exponentCore.MarketAdminAction }): TransactionInstruction {
-    return exponentCore.createModifyMarketSettingInstruction(
-      {
-        market: this.selfAddress,
-        adminState: getExponentAdminStatePda(),
-        signer,
-        systemProgram: SystemProgram.programId,
-      },
-      { action: adminAction },
-    )
-  }
-
-  ixModifyFarm({
-    newRate,
-    untilTimestamp,
-    signer,
-    farmMint,
-    farmTokenProgram,
-    farmTokenSrc: farmTokenSrcParam,
-  }: {
-    newRate: bigint
-    untilTimestamp: number
-    signer: PublicKey
-    farmMint: PublicKey
-    farmTokenProgram: PublicKey
-    farmTokenSrc?: PublicKey
-  }): TransactionInstruction {
-    const farmTokenSrc = farmTokenSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmTokenProgram)
-    const tokenFarm = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmTokenProgram)
-
-    return exponentCore.createModifyFarmInstruction(
-      {
-        market: this.selfAddress,
-        signer,
-        mint: farmMint,
-        adminState: getExponentAdminStatePda(),
-        tokenSource: farmTokenSrc,
-        tokenFarm,
-        tokenProgram: farmTokenProgram,
-      },
-      { untilTimestamp, newRate },
-    )
-  }
-
-  /**
-   * Redeem LP tokens for PT & SY  (liquidity removal)
-   *
-   * The lpIn is exactly the amount of LP tokens to burn
-   * The minimum PT & SY out are specified by minPtOut & minSyOut
-   * The transaction may fail due to unforeseeable slippage on the redemption rate
-   *
-   * The token accounts themselves are optional, and will be derived from the withdrawer's wallet if not provided
-   */
-  ixWithdrawLiquidity({
-    lpIn,
-    withdrawer,
-    minPtOut,
-    minSyOut,
-    ptDst: ptDstParam,
-    syDst: syDstParam,
-    lpSrc: lpSrcParam,
-  }: {
-    lpIn: bigint
-    withdrawer: PublicKey
-    minPtOut: bigint
-    minSyOut: bigint
-    ptDst?: PublicKey
-    syDst?: PublicKey
-    lpSrc?: PublicKey
-  }) {
-    const ptDst = ptDstParam || getAssociatedTokenAddressSync(this.mintPt, withdrawer, true, TOKEN_PROGRAM_ID)
-    const syDst = syDstParam || getAssociatedTokenAddressSync(this.mintSy, withdrawer, true, TOKEN_PROGRAM_ID)
-    const lpSrc = lpSrcParam || 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 ix = exponentCore.createMarketTwoWithdrawLiquidityInstruction(
-      {
-        withdrawer,
-        market: this.selfAddress,
-        tokenPtDst: ptDst,
-        tokenSyDst: syDst,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpSrc: lpSrc,
-        mintLp: this.mintLp,
-        addressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { lpIn, minPtOut, minSyOut },
-    )
-    ix.keys.push(...syRemAccounts)
-
-    return { ixs: [ix], 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: PublicKey
-    amountPt: bigint
-    maxSySpend: bigint
-    tokenPt?: PublicKey
-    tokenSy?: 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: PublicKey
-    amountPt: bigint
-    minSyReceive: bigint
-    tokenPt?: PublicKey
-    tokenSy?: PublicKey
-  }) {
-    return this.ixTradePt({
-      trader,
-      traderPt: amountPt,
-      syConstraint: minSyReceive,
-      isBuy: false,
-      tokenPt,
-      tokenSy,
-    })
-  }
-
-  ixTradePt({
-    trader,
-    traderPt,
-    syConstraint,
-    isBuy,
-    tokenPt: tokenPtParam,
-    tokenSy: tokenSyParam,
-  }: {
-    trader: PublicKey
-    traderPt: bigint
-    syConstraint: bigint
-    isBuy: boolean
-    tokenPt?: PublicKey
-    tokenSy?: PublicKey
-  }) {
-    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 = [
-      ...this.cpiAccounts.getSyState,
-      ...this.cpiAccounts.depositSy,
-      ...this.cpiAccounts.withdrawSy,
-    ]
-
-    const netTraderPt = isBuy ? traderPt : -traderPt
-    const syConstraintSigned = isBuy ? -syConstraint : syConstraint
-
-    const ix = exponentCore.createTradePtInstruction(
-      {
-        trader,
-        market: this.selfAddress,
-        tokenSyTrader: tokenSy,
-        tokenPtTrader: tokenPt,
-        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: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { netTraderPt, syConstraint: syConstraintSigned },
-    )
-    ix.keys.push(...remainingAccounts)
-
-    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
-   */
-  ixSellYt({
-    trader,
-    ytIn,
-    minSyOut,
-    ytSrc: ytSrcParam,
-    ptSrc: ptSrcParam,
-    syDst: syDstParam,
-  }: {
-    trader: PublicKey
-    ytIn: bigint
-    minSyOut: bigint
-    ytSrc?: PublicKey
-    ptSrc?: PublicKey
-    syDst?: PublicKey
-  }) {
-    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.vault.mergeAccounts({ owner: trader, ytSrc, ptSrc, syDst })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.cpiAccounts.getSyState,
-      ...this.cpiAccounts.depositSy,
-      ...mergeAccounts.remainingAccounts,
-    ])
-    remainingAccounts.push({ pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false })
-
-    const ix = exponentCore.createSellYtInstruction(
-      {
-        trader,
-        market: this.selfAddress,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        tokenSyTrader: syDst,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        addressLookupTable: this.addressLookupTable,
-        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
-        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,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { ytIn, minSyOut },
-    )
-    ix.keys.push(...remainingAccounts)
-
-    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
-   */
-  ixBuyYt({
-    trader,
-    ytOut,
-    maxSyIn,
-    ytTrader: ytTraderParam,
-    ptTrader: ptTraderParam,
-    syTrader: syTraderParam,
-  }: {
-    trader: PublicKey
-    ytOut: bigint
-    maxSyIn: bigint
-    ytTrader?: PublicKey
-    ptTrader?: PublicKey
-    syTrader?: PublicKey
-  }) {
-    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.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: exponentCore.EXPONENTCORE_PROGRAM_ID, isWritable: false, isSigner: false })
-
-    const ix = exponentCore.createBuyYtInstruction(
-      {
-        trader,
-        market: this.selfAddress,
-        tokenSyTrader: syTrader,
-        tokenYtTrader: ytTrader,
-        tokenPtTrader: ptTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenFeeTreasurySy: this.vault.state.treasurySyTokenAccount,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        addressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        vaultAuthority: stripAccounts.mainAccounts.authority,
-        vault: stripAccounts.mainAccounts.vault,
-        tokenSyEscrowVault: stripAccounts.mainAccounts.escrowSy,
-        mintYt: this.mintYt,
-        mintPt: this.mintPt,
-        addressLookupTableVault: stripAccounts.mainAccounts.addressLookupTable,
-        yieldPosition: stripAccounts.mainAccounts.yieldPosition,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { syIn: maxSyIn, ytOut },
-    )
-    ix.keys.push(...remainingAccounts)
-
-    return { ixs: [ix], setupIxs: [syTraderAtaIx, ptTraderAtaIx, ytTraderAtaIx] }
-  }
-
-  ixInitLpPosition({ owner, feePayer }: { owner: PublicKey; feePayer?: PublicKey }): TransactionInstruction {
-    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
-    return exponentCore.createInitLpPositionInstruction({
-      feePayer: feePayer || owner,
-      owner,
-      market: this.selfAddress,
-      lpPosition,
-      systemProgram: SystemProgram.programId,
-      eventAuthority: this.vault.eventAuthority,
-      program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-    })
-  }
-
-  /** Deposit LP tokens into the farming module to earn rewards */
-  ixDepositLp({
-    owner,
-    amount,
-    lpSrc: lpSrcParam,
-  }: {
-    owner: PublicKey
-    amount: bigint
-    lpSrc?: PublicKey
-  }): TransactionInstruction {
-    const lpSrc = lpSrcParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
-    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
-
-    const ix = exponentCore.createMarketDepositLpInstruction(
-      {
-        owner,
-        market: this.selfAddress,
-        lpPosition,
-        tokenLpSrc: lpSrc,
-        tokenLpEscrow: this.tokenLpEscrow,
-        mintLp: this.mintLp,
-        syProgram: this.syProgram,
-        addressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amount },
-    )
-    ix.keys.push(...this.cpiAccounts.getPositionState)
-    return ix
-  }
-
-  /** Withdraw LP tokens from the farming module */
-  ixWithdrawLp({
-    owner,
-    amount,
-    lpDst: lpDstParam,
-  }: {
-    owner: PublicKey
-    amount: bigint
-    lpDst?: PublicKey
-  }): TransactionInstruction {
-    const lpDst = lpDstParam || getAssociatedTokenAddressSync(this.mintLp, owner, true, TOKEN_PROGRAM_ID)
-
-    const lpPosition = this.xponPda.marketLpPosition({ market: this.selfAddress, owner })
-    const ix = exponentCore.createMarketWithdrawLpInstruction(
-      {
-        owner,
-        market: this.selfAddress,
-        mintLp: this.mintLp,
-        lpPosition,
-        tokenLpDst: lpDst,
-        tokenLpEscrow: this.tokenLpEscrow,
-        syProgram: this.syProgram,
-        addressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amount },
-    )
-    ix.keys.push(...this.cpiAccounts.getPositionState)
-    return ix
-  }
-
-  async ixWrapperCollectInterest({
-    claimer,
-    tokenSyDst: tokenSyDstParam,
-  }: {
-    claimer: PublicKey
-    tokenSyDst?: PublicKey
-  }) {
-    const yieldPosition = this.xponPda.yieldPosition({ owner: claimer, vault: this.vault.selfAddress })
-    const tokenSyDst = tokenSyDstParam || 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,
-      this.flavor.baseTokenProgram,
-    )
-
-    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 = exponentCore.createWrapperCollectInterestInstruction(
-      {
-        claimer,
-        authority: this.vault.state.authority,
-        vault: this.vault.selfAddress,
-        addressLookupTable: this.vault.addressLookupTable,
-        escrowSy: this.vault.escrowSy,
-        syProgram: this.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        yieldPosition,
-        tokenSyDst,
-        treasurySyTokenAccount: this.vault.state.treasurySyTokenAccount,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { redeemSyAccountsLength: redeemSyIx.keys.length },
-    )
-    ix.keys.push(...redeemSyIx.keys.concat(remainingAccounts))
-
-    return {
-      ixs: [
-        ...(await this.flavor.preIxs({ signer: claimer })),
-        ix,
-        ...(await this.flavor.postIxs({ signer: claimer })),
-      ],
-      setupIxs: [tokenBaseClaimerAtaIx, tokenSyClaimerAtaIx],
-    }
-  }
-
-  async ixWrapperBuyPt({
-    owner,
-    ptOut,
-    maxBaseIn,
-    tokenSyTrader: tokenSyTraderParam,
-    tokenPtTrader: tokenPtTraderParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    owner: PublicKey
-    ptOut: bigint
-    maxBaseIn: bigint
-    tokenSyTrader?: PublicKey
-    tokenPtTrader?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const tokenSyTrader =
-      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const tokenPtTrader =
-      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const 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,
-      this.flavor.baseTokenProgram,
-    )
-
-    const mintSyIx = await this.flavor.ixMintSy({
-      amountBase: "0",
-      depositor: owner,
-      depositorBaseTokenAccount: tokenBaseTrader,
-      depositorSyTokenAccount: tokenSyTrader,
-    })
-
-    const mintSyRemAccounts = mintSyIx.keys
-
-    mintSyRemAccounts.push({
-      pubkey: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      isWritable: false,
-      isSigner: false,
-    })
-
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.cpiAccounts.getSyState,
-      ...this.cpiAccounts.depositSy,
-    ])
-
-    const ix = exponentCore.createWrapperBuyPtInstruction(
-      {
-        buyer: owner,
-        market: this.selfAddress,
-        tokenSyTrader,
-        tokenPtTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        addressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { ptAmount: ptOut, maxBaseAmount: maxBaseIn, mintSyRemAccountsUntil: mintSyRemAccounts.length - 1 },
-    )
-    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
-
-    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,
-  }: {
-    owner: PublicKey
-    amount: bigint
-    minBaseOut: bigint
-    tokenSyTrader?: PublicKey
-    tokenPtTrader?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const tokenSyTrader =
-      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const tokenPtTrader =
-      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const 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,
-      this.flavor.baseTokenProgram,
-    )
-
-    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])
-
-    const ix = exponentCore.createWrapperSellPtInstruction(
-      {
-        seller: owner,
-        market: this.selfAddress,
-        tokenSyTrader,
-        tokenPtTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        addressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountPt: amount, minBaseAmount: minBaseOut, redeemSyRemAccountsUntil: redeemSyRemAccounts.length },
-    )
-    ix.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
-
-    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: PublicKey
-    ytOut: bigint
-    maxBaseIn: bigint
-    tokenSyTrader?: PublicKey
-    tokenPtTrader?: PublicKey
-    tokenYtTrader?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const tokenSyTrader =
-      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const tokenPtTrader =
-      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-    const tokenYtTrader =
-      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
-
-    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenSyTrader,
-      owner,
-      this.mintSy,
-    )
-    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenPtTrader,
-      owner,
-      this.mintPt,
-    )
-    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenYtTrader,
-      owner,
-      this.mintYt,
-    )
-
-    const mintSyIx = await this.flavor.ixMintSy({
-      amountBase: "0",
-      depositor: owner,
-      depositorBaseTokenAccount: tokenBaseTrader,
-      depositorSyTokenAccount: tokenSyTrader,
-    })
-
-    const 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 = exponentCore.createWrapperBuyYtInstruction(
-      {
-        buyer: owner,
-        market: this.selfAddress,
-        tokenSyTrader,
-        tokenYtTrader,
-        tokenPtTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        marketAddressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        vaultAuthority: this.vault.authority,
-        vault: this.vault.selfAddress,
-        tokenSyEscrowVault: this.vault.escrowSy,
-        mintYt: this.vault.mintYt,
-        mintPt: this.vault.mintPt,
-        vaultAddressLookupTable: this.vault.addressLookupTable,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
-        yieldPosition: this.vault.state.yieldPositonAddress,
-        escrowYt: this.vault.escrowYt,
-        systemProgram: SystemProgram.programId,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { ytOut, maxBaseAmount: maxBaseIn, mintSyAccountsLength: mintSyRemAccounts.length },
-    )
-    ix1.keys.push(...allRemainingAccounts)
-
-    return {
-      ixs: [...(await this.flavor.preIxs({ signer: owner })), ix1, ...(await this.flavor.postIxs({ signer: owner }))],
-      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx],
-    }
-  }
-
-  async ixWrapperSellYt({
-    owner,
-    amount,
-    minBaseOut,
-    tokenBaseTrader: tokenBaseTraderParam,
-    tokenSyTrader: tokenSyTraderParam,
-    tokenYtTrader: tokenYtTraderParam,
-    tokenPtTrader: tokenPtTraderParam,
-  }: {
-    owner: PublicKey
-    amount: bigint
-    minBaseOut: bigint
-    tokenBaseTrader?: PublicKey
-    tokenSyTrader?: PublicKey
-    tokenYtTrader?: PublicKey
-    tokenPtTrader?: PublicKey
-  }) {
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, owner, true, this.flavor.baseTokenProgram)
-    const tokenSyTrader =
-      tokenSyTraderParam || getAssociatedTokenAddressSync(this.mintSy, owner, true, TOKEN_PROGRAM_ID)
-    const tokenYtTrader =
-      tokenYtTraderParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    const tokenPtTrader =
-      tokenPtTraderParam || getAssociatedTokenAddressSync(this.mintPt, owner, true, TOKEN_PROGRAM_ID)
-
-    const tokenSyTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenSyTrader,
-      owner,
-      this.mintSy,
-    )
-    const tokenPtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenPtTrader,
-      owner,
-      this.mintPt,
-    )
-    const tokenYtTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenYtTrader,
-      owner,
-      this.mintYt,
-    )
-    const tokenBaseTraderAtaIx = createAssociatedTokenAccountIdempotentInstruction(
-      owner,
-      tokenBaseTrader,
-      owner,
-      this.flavor.mintBase,
-      this.flavor.baseTokenProgram,
-    )
-
-    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,
-    ])
-
-    const ix1 = exponentCore.createWithdrawYtInstruction(
-      {
-        owner,
-        vault: this.vault.selfAddress,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner }),
-        ytDst: tokenYtTrader,
-        escrowYt: this.vault.escrowYt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        authority: this.vault.authority,
-        syProgram: this.syProgram,
-        addressLookupTable: this.vault.addressLookupTable,
-        yieldPosition: this.vault.state.yieldPositonAddress,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amount },
-    )
-    ix1.keys.push(...remainingAccounts)
-
-    const ix2 = exponentCore.createWrapperSellYtInstruction(
-      {
-        seller: owner,
-        market: this.selfAddress,
-        tokenSyTrader,
-        tokenYtTrader,
-        tokenPtTrader,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenPtEscrow: this.tokenPtEscrow,
-        marketAddressLookupTable: this.addressLookupTable,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.syProgram,
-        vaultAuthority: this.vault.authority,
-        vault: this.vault.selfAddress,
-        tokenSyEscrowVault: this.vault.escrowSy,
-        mintYt: this.vault.mintYt,
-        mintPt: this.vault.mintPt,
-        vaultAddressLookupTable: this.vault.addressLookupTable,
-        yieldPosition: this.vault.state.yieldPositonAddress,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { ytAmount: amount, minBaseAmount: minBaseOut, redeemSyAccountsUntil: redeemSyRemAccounts.length },
-    )
-    ix2.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
-
-    return {
-      ixs: [
-        ix1,
-        ...(await this.flavor.preIxs({ signer: owner })),
-        ix2,
-        ...(await this.flavor.postIxs({ signer: owner })),
-      ],
-      setupIxs: [tokenSyTraderAtaIx, tokenPtTraderAtaIx, tokenYtTraderAtaIx, tokenBaseTraderAtaIx],
-    }
-  }
-
-  ixCollectMarketEmission({
-    owner,
-    emissionIndex,
-    emissionDst,
-  }: {
-    owner: PublicKey
-    emissionIndex: number
-    emissionDst?: 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 = exponentCore.createMarketCollectEmissionInstruction(
-      {
-        owner,
-        market: this.selfAddress,
-        lpPosition: this.xponPda.marketLpPosition({ market: this.selfAddress, owner }),
-        tokenEmissionEscrow: this.marketEmissions.trackers[emissionIndex].tokenEscrow,
-        tokenEmissionDst,
-        tokenProgram: emission.tokenProgramAddress,
-        addressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { emissionIndex },
-    )
-    ix.keys.push(...this.cpiAccounts.claimEmission[emissionIndex])
-
-    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: tokenSyDepositorParam,
-    tokenYtDepositor: tokenYtDepositorParam,
-    tokenPtDepositor: tokenPtDepositorParam,
-    tokenBaseDepositor: tokenBaseDepositorParam,
-    tokenLpDepositor: tokenLpDepositorParam,
-  }: {
-    depositor: PublicKey
-    amountBase: bigint
-    minLpOut: bigint
-    tokenSyDepositor?: PublicKey
-    tokenYtDepositor?: PublicKey
-    tokenPtDepositor?: PublicKey
-    tokenBaseDepositor?: PublicKey
-    tokenLpDepositor?: 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 tokenLpDepositor =
-      tokenLpDepositorParam || getAssociatedTokenAddressSync(this.mintLp, depositor, true, TOKEN_PROGRAM_ID)
-
-    console.log("Mint Base: ", this.flavor.mintBase.toBase58())
-
-    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,
-    )
-
-    // amountBase and minLpOut are already bigint
-
-    // 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
-
-    const beforeVaultAccounts = [...this.vault.cpiAccounts.getSyState, ...this.vault.cpiAccounts.depositSy]
-    // Log vault accounts before filtering
-    // 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() !== 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 = exponentCore.createWrapperProvideLiquidityInstruction(
-      {
-        depositor,
-        authority: this.vault.authority,
-        vault: this.vault.selfAddress,
-        market: this.selfAddress,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpDst: tokenLpDepositor,
-        mintLp: this.mintLp,
-        tokenSyDepositor,
-        escrowSy: this.vault.escrowSy,
-        tokenYtDepositor,
-        tokenPtDepositor,
-        mintYt: this.vault.mintYt,
-        mintPt: this.vault.mintPt,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        vaultAddressLookupTable: this.vault.addressLookupTable,
-        marketAddressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        userYieldPosition: this.xponPda.yieldPosition({ vault: this.vault.selfAddress, owner: depositor }),
-        escrowYt: this.vault.escrowYt,
-        tokenLpEscrow: this.tokenLpEscrow,
-        lpPosition,
-        vaultRobotYieldPosition: this.vault.state.yieldPositonAddress,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountBase, minLpOut, mintBaseAccountsUntil: mintSyRemAccounts.length },
-    )
-    ix.keys.push(...allRemainingAccounts)
-
-    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: tokenSyDepositorParam,
-    tokenYtDepositor: tokenYtDepositorParam,
-    tokenPtDepositor: tokenPtDepositorParam,
-    tokenBaseDepositor: tokenBaseDepositorParam,
-    tokenLpDepositor: tokenLpDepositorParam,
-  }: {
-    depositor: PublicKey
-    amountBase: bigint
-    minLpOut: bigint
-    externalPtToBuy: bigint
-    externalSyConstraint: bigint
-    tokenSyDepositor?: PublicKey
-    tokenYtDepositor?: PublicKey
-    tokenPtDepositor?: PublicKey
-    tokenBaseDepositor?: PublicKey
-    tokenLpDepositor?: 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 tokenLpDepositor =
-      tokenLpDepositorParam || 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 = exponentCore.createWrapperProvideLiquidityBaseInstruction(
-      {
-        depositor,
-        market: this.selfAddress,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpDst: tokenLpDepositor,
-        mintLp: this.mintLp,
-        tokenSyDepositor,
-        tokenPtDepositor,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        marketAddressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        tokenLpEscrow: this.tokenLpEscrow,
-        lpPosition,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountBase, minLpOut, mintSyAccountsUntil: mintSyRemAccounts.length, externalPtToBuy, externalSyConstraint },
-    )
-    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
-
-    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: tokenSyDepositorParam,
-    tokenYtDepositor: tokenYtDepositorParam,
-    tokenPtDepositor: tokenPtDepositorParam,
-    tokenBaseDepositor: tokenBaseDepositorParam,
-    tokenLpDepositor: tokenLpDepositorParam,
-  }: {
-    depositor: PublicKey
-    amountBase: bigint
-    amountPt: bigint
-    minLpOut: bigint
-    tokenSyDepositor?: PublicKey
-    tokenYtDepositor?: PublicKey
-    tokenPtDepositor?: PublicKey
-    tokenBaseDepositor?: PublicKey
-    tokenLpDepositor?: 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 tokenLpDepositor =
-      tokenLpDepositorParam || 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 = exponentCore.createWrapperProvideLiquidityClassicInstruction(
-      {
-        depositor,
-        market: this.selfAddress,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpDst: tokenLpDepositor,
-        mintLp: this.mintLp,
-        tokenSyDepositor,
-        tokenPtDepositor,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        marketAddressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        tokenLpEscrow: this.tokenLpEscrow,
-        lpPosition,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountBase, amountPt, minLpOut, mintSyAccountsUntil: mintSyRemAccounts.length },
-    )
-    ix.keys.push(...mintSyRemAccounts.concat(remainingAccounts))
-
-    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: tokenSyWithdrawerParam,
-    tokenYtWithdrawer: tokenYtWithdrawerParam,
-    tokenPtWithdrawer: tokenPtWithdrawerParam,
-    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
-    tokenLpWithdrawer: tokenLpWithdrawerParam,
-  }: {
-    owner: PublicKey
-    amountLp: bigint
-    minBaseOut: bigint
-    tokenSyWithdrawer?: PublicKey
-    tokenYtWithdrawer?: PublicKey
-    tokenPtWithdrawer?: PublicKey
-    tokenBaseWithdrawer?: PublicKey
-    tokenLpWithdrawer?: 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 tokenLpWithdrawer =
-      tokenLpWithdrawerParam || 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 = exponentCore.createWrapperWithdrawLiquidityInstruction(
-      {
-        withdrawer: owner,
-        market: this.selfAddress,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpSrc: tokenLpWithdrawer,
-        mintLp: this.mintLp,
-        tokenSyWithdrawer,
-        tokenPtWithdrawer,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        marketAddressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        tokenLpEscrow: this.tokenLpEscrow,
-        tokenFeeTreasurySy: this.state.tokenFeeTreasurySy,
-        lpPosition,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountLp, syConstraint: BigInt(minSyOut.toFixed(0)), redeemSyAccountsLength: redeemSyRemAccounts.length },
-    )
-    ix.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
-
-    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,
-    tokenSyWithdrawer: tokenSyWithdrawerParam,
-    tokenYtWithdrawer: tokenYtWithdrawerParam,
-    tokenPtWithdrawer: tokenPtWithdrawerParam,
-    tokenBaseWithdrawer: tokenBaseWithdrawerParam,
-    tokenLpWithdrawer: tokenLpWithdrawerParam,
-  }: {
-    owner: PublicKey
-    amountLp: bigint
-    tokenSyWithdrawer?: PublicKey
-    tokenYtWithdrawer?: PublicKey
-    tokenPtWithdrawer?: PublicKey
-    tokenBaseWithdrawer?: PublicKey
-    tokenLpWithdrawer?: 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 tokenLpWithdrawer =
-      tokenLpWithdrawerParam || 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 = exponentCore.createWrapperWithdrawLiquidityClassicInstruction(
-      {
-        withdrawer: owner,
-        market: this.selfAddress,
-        tokenPtEscrow: this.tokenPtEscrow,
-        tokenSyEscrow: this.tokenSyEscrow,
-        tokenLpSrc: tokenLpWithdrawer,
-        mintLp: this.mintLp,
-        tokenSyWithdrawer,
-        tokenPtWithdrawer,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        marketAddressLookupTable: this.addressLookupTable,
-        syProgram: this.syProgram,
-        tokenLpEscrow: this.tokenLpEscrow,
-        lpPosition,
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.vault.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amountLp, redeemSyAccountsLength: redeemSyRemAccounts.length },
-    )
-    ixn.keys.push(...redeemSyRemAccounts.concat(remainingAccounts))
-
-    return {
-      ixs: [...(await this.flavor.preIxs({ signer: owner })), ixn, ...(await this.flavor.postIxs({ signer: owner }))],
-      setupIxs: [tokenSyAtaIx, tokenYtAtaIx, tokenPtAtaIx, tokenBaseAtaIx, tokenLpAtaIx],
-    }
-  }
-
-  claimFarmEmissions({
-    owner,
-    mint,
-    tokenProgram,
-    tokenDst: tokenDstParam,
-  }: {
-    owner: PublicKey
-    mint: PublicKey
-    tokenProgram: PublicKey
-    tokenDst?: PublicKey
-  }) {
-    const tokenDst = tokenDstParam || 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 = exponentCore.createClaimFarmEmissionsInstruction(
-      {
-        owner,
-        market: this.selfAddress,
-        lpPosition,
-        tokenDst,
-        mint,
-        tokenFarm,
-        tokenProgram,
-        eventAuthority: this.eventAuthority,
-        program: exponentCore.EXPONENTCORE_PROGRAM_ID,
-      },
-      { amount: exponentCore.amount("All") },
-    )
-
-    return {
-      ixs: [ix],
-      setupIxs: [tokenAtaIx],
-    }
-  }
-
-  ixAddStandaloneEmission({
-    signer,
-    emissionMint,
-    emissionTokenProgram = TOKEN_PROGRAM_ID,
-    altAddresses,
-    cpiAccounts,
-  }: {
-    signer: PublicKey
-    emissionMint: PublicKey
-    emissionTokenProgram?: PublicKey
-    altAddresses: PublicKey[]
-    cpiAccounts: CpiAccountsRaw
-  }) {
-    const altUtil = extendAddressLookupTable(altAddresses, cpiAccounts)
-
-    const tokenEmission = getAssociatedTokenAddressSync(emissionMint, this.selfAddress, true, emissionTokenProgram)
-    const ix = exponentCore.createAddMarketEmissionInstruction(
-      {
-        market: this.selfAddress,
-        signer,
-        feePayer: signer,
-        mintNew: emissionMint,
-        adminState: getExponentAdminStatePda(),
-        tokenEmission,
-        tokenProgram: emissionTokenProgram,
-        systemProgram: SystemProgram.programId,
-      },
-      { cpiAccounts: altUtil.cpiAccountIndexes },
-    )
-
-    return {
-      extendAddressLookupTableExtensionAccounts: altUtil.addressLookupTableExtension,
-      addMarketEmissionIx: ix,
-    }
-  }
-
-  addFarm({
-    signer,
-    farmMint,
-    farmRewardTokenProgram,
-    emissionsRate,
-    untilTimestamp,
-    farmRewardSrc: farmRewardSrcParam,
-    feePayer: feePayerParam,
-  }: {
-    signer: PublicKey
-    farmMint: PublicKey
-    farmRewardTokenProgram: PublicKey
-    emissionsRate: number
-    untilTimestamp: number
-    farmRewardSrc?: PublicKey
-    feePayer?: PublicKey
-  }) {
-    const feePayer = feePayerParam || signer
-    const farmRewardEscrow = getAssociatedTokenAddressSync(farmMint, this.selfAddress, true, farmRewardTokenProgram)
-    const farmRewardSrc =
-      farmRewardSrcParam || getAssociatedTokenAddressSync(farmMint, signer, true, farmRewardTokenProgram)
-
-    const ix = exponentCore.createAddFarmInstruction(
-      {
-        market: this.selfAddress,
-        signer,
-        feePayer,
-        mintNew: farmMint,
-        adminState: getExponentAdminStatePda(),
-        tokenSource: farmRewardSrc,
-        tokenFarm: farmRewardEscrow,
-        tokenProgram: farmRewardTokenProgram,
-        systemProgram: SystemProgram.programId,
-      },
-      { tokenRate: BigInt(emissionsRate), untilTimestamp },
-    )
-
-    return {
-      ixs: [ix],
-    }
-  }
-
-  static fromJson(json: MarketJson, env: Environment, connection: Connection): Market {
-    const state: MarketArgs = {
-      seedId: [json.seedId],
-      ptBalance: BigInt(json.ptBalance),
-      syBalance: BigInt(json.syBalance),
-      lpSupply: BigInt(json.lpSupply),
-      lpEscrowAmount: BigInt(json.lpEscrowAmount),
-      maxLpSupply: BigInt(json.maxLpSupply),
-      rateScalarRoot: json.rateScalarRoot,
-      lnFeeRateRoot: json.lnFeeRateRoot,
-      lastLnImpliedRate: json.lastLnImpliedRate,
-      expirationTs: json.expirationTs,
-      addressLookupTable: new PublicKey(json.addressLookupTable),
-      mintSy: new PublicKey(json.mintSy),
-      mintPt: new PublicKey(json.mintPt),
-      mintLp: new PublicKey(json.mintLp),
-      tokenPtEscrow: new PublicKey(json.tokenPtEscrow),
-      tokenSyEscrow: new PublicKey(json.tokenSyEscrow),
-      tokenLpEscrow: new PublicKey(json.tokenLpEscrow),
-      syProgram: new PublicKey(json.syProgram),
-      cpiAccounts: deserializeCpiAccountsRaw(json.cpiAccounts),
-      feeTreasurySyBps: json.feeTreasurySyBps,
-      tokenFeeTreasurySy: new PublicKey(json.treasurySyTokenAccount),
-      lpFarm: {
-        farmEmissions: json.lpFarm.farmEmissions.map((e) => ({
-          mint: new PublicKey(e.mint),
-          tokenRate: new BN(e.tokenRate),
-          expiryTimestamp: e.expiryTimestamp,
-          index: new PreciseNumber(e.index).anchorify(),
-        })),
-        lastSeenTimestamp: json.lpFarm.lastSeenTimestamp,
-      },
-      liquidityNetBalanceLimits: {
-        windowStartTimestamp: json.liquidityNetBalanceLimits.windowStartTimestamp,
-        windowStartNetBalance: new BN(json.liquidityNetBalanceLimits.windowStartNetBalance),
-        maxNetBalanceChangeNegativePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
-        maxNetBalanceChangePositivePercentage: json.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
-        windowDurationSeconds: json.liquidityNetBalanceLimits.windowDurationSeconds,
-      },
-      emissions: {
-        trackers: json.emissions.trackers.map((e) => ({
-          tokenEscrow: new PublicKey(e.tokenEscrow),
-          lpShareIndex: e.lpShareIndex,
-          lastSeenStaged: e.lastSeenStaged,
-        })),
-      },
-      vault: Vault.loadFromJson(json.vault, new PublicKey(json.vault.selfAddress), env, connection),
-      sySupply: BigInt(json.sySupply),
-      statusFlags: json.statusFlags,
-      isCurrentFlashSwap: json.isCurrentFlashSwap,
-      flavor: deserializeFlavor(json.flavor),
-      syPosition: deserializeSyPosition(json.syPosition),
-    }
-
-    return new Market(state, new PublicKey(json.address), env, connection)
-  }
-
-  /** Calculate available liquidity for PT trades
-   * @param isBuy - true if buying PT with SY, false if selling PT for SY
-   * @param sizePt - amount of PT to trade (in PT decimals)
-   * @returns amount of PT that can be traded given current liquidity
-   */
-  liquidityAvailable(isBuy: boolean, sizePt: bigint): bigint {
-    const calc = this.marketCalculator()
-
-    if (isBuy) {
-      // When buying PT, we're limited by SY liquidity
-      // Convert PT amount to SY using current price
-      const syNeeded = Number(sizePt) * calc.exchangeRate
-      // Available SY in the market
-      const syAvailable = Number(this.syBalance)
-
-      if (syNeeded <= syAvailable) {
-        return sizePt
-      } 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 (sizePt <= ptAvailable) {
-        return sizePt
-      } else {
-        return ptAvailable
-      }
-    }
-  }
-
-  /**
-   * Reallocate market data
-   * @param additionalBytes - number of additional bytes to allocate
-   * @returns transaction instruction to realloc market
-   */
-  realloc_market({ signer, additionalBytes }: { signer: PublicKey; additionalBytes: number }) {
-    const ix = exponentCore.createReallocMarketInstruction(
-      {
-        market: this.selfAddress,
-        signer,
-        adminState: getExponentAdminStatePda(),
-        systemProgram: SystemProgram.programId,
-        rent: SYSVAR_RENT_PUBKEY,
-      },
-      { additionalBytes: BigInt(additionalBytes) },
-    )
-
-    return {
-      ixs: [ix],
-    }
-  }
-}
-
-export type MarketJson = {
-  /** The market's public key */
-  address: string
-  /** The market's seed ID */
-  seedId: number
-  /** 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
-
-  vault: VaultJson
-
-  sySupply: string
-
-  statusFlags: number
-
-  isCurrentFlashSwap: boolean
-
-  flavor: FlavorGenericStateJson
-
-  syPosition: SyPositionJson
-
-  ptApy: 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(market: Market): MarketJson {
-  const marketCalculator = market.marketCalculator()
-  return {
-    treasurySyTokenAccount: market.state.tokenFeeTreasurySy.toBase58(),
-    address: market.selfAddress.toBase58(),
-    addressLookupTable: market.addressLookupTable.toBase58(),
-    tokenSyEscrow: market.tokenSyEscrow.toBase58(),
-    tokenPtEscrow: market.tokenPtEscrow.toBase58(),
-    tokenLpEscrow: market.tokenLpEscrow.toBase58(),
-    lpSupply: market.state.lpSupply.toString(),
-    syProgram: market.state.syProgram.toBase58(),
-    mintPt: market.state.mintPt.toBase58(),
-    mintSy: market.state.mintSy.toBase58(),
-    mintLp: market.state.mintLp.toBase58(),
-    feeTreasurySyBps: market.state.feeTreasurySyBps,
-    ptBalance: market.state.ptBalance.toString(),
-    syBalance: market.state.syBalance.toString(),
-    currentSyRate: market.flavor.currentSyExchangeRate,
-    expirationTs: market.state.expirationTs,
-    expirationDate: new Date(market.state.expirationTs * 1000).toISOString(),
-    lnFeeRateRoot: market.state.lnFeeRateRoot,
-    rateScalarRoot: market.state.rateScalarRoot,
-    lastLnImpliedRate: market.state.lastLnImpliedRate,
-    currentPtPriceInSy: market.currentPtPriceInSy,
-    currentPtPriceInAsset: market.currentPtPriceInAsset,
-    secondsRemaining: market.secondsRemaining,
-    proportionPtInAsset: marketCalculator.proportionPtInAsset,
-    proportionPtInSy: marketCalculator.proportionPtInSy,
-    currentFeeRate: marketCalculator.feeRate,
-    currentRateScalar: marketCalculator.rateScalar,
-    currentRateAnchor: marketCalculator.findRateAnchor(),
-    cpiAccounts: serializeCpiAccountsRaw(market.cpiAccounts),
-    emissions: {
-      trackers: market.marketEmissions.trackers.map((e) => ({
-        tokenEscrow: e.tokenEscrow.toBase58(),
-        lpShareIndex: e.lpShareIndex,
-        lastSeenStaged: e.lastSeenStaged,
-      })),
-    },
-    ptApr: market.ptApr,
-    ptApy: market.ptApy,
-    lpEscrowAmount: market.state.lpEscrowAmount.toString(),
-    maxLpSupply: market.state.maxLpSupply.toString(),
-    liquidityNetBalanceLimits: {
-      windowStartTimestamp: market.state.liquidityNetBalanceLimits.windowStartTimestamp,
-      windowStartNetBalance: market.state.liquidityNetBalanceLimits.windowStartNetBalance.toString(),
-      maxNetBalanceChangeNegativePercentage:
-        market.state.liquidityNetBalanceLimits.maxNetBalanceChangeNegativePercentage,
-      maxNetBalanceChangePositivePercentage:
-        market.state.liquidityNetBalanceLimits.maxNetBalanceChangePositivePercentage,
-      windowDurationSeconds: market.state.liquidityNetBalanceLimits.windowDurationSeconds,
-    },
-    lpFarm: {
-      lastSeenTimestamp: market.state.lpFarm.lastSeenTimestamp,
-      farmEmissions: market.state.lpFarm.farmEmissions.map((e) => ({
-        mint: e.mint.toBase58(),
-        tokenRate: e.tokenRate.toString(),
-        expiryTimestamp: e.expiryTimestamp,
-        index: PreciseNumber.fromRaw(e.index[0]).valueString,
-      })),
-    },
-    vault: market.vault.toJson(),
-    sySupply: market.state.sySupply.toString(),
-    statusFlags: market.state.statusFlags,
-    isCurrentFlashSwap: market.state.isCurrentFlashSwap,
-    // @ts-ignore
-    flavor: serializeFlavor(market.state.flavor),
-    syPosition: serializeSyPosition(market.state.syPosition),
-  }
-}