@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/orderbook/orderbook.ts

@@ -1,1354 +0,0 @@
-import {
-  TOKEN_PROGRAM_ID,
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token"
-
-import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
-import { ExponentFetcher } from "@exponent-labs/exponent-fetcher"
-import { ExponentOrderbookPDA, ExponentPDA } from "@exponent-labs/exponent-pda"
-import { AccountInfo, ConfigurationOptions, OrderbookState } from "@exponent-labs/exponent-types"
-import { feeRate } from "@exponent-labs/market-math"
-
-import {
-  fetchAddressLookupTable,
-  makeCoreCpiAccountMetaLists,
-  makeCpiAccountMetaLists,
-} from "../addressLookupTableUtil"
-import { Environment } from "../environment"
-import {
-  makeFlavorGenericSync,
-  makeFlavorJitoRestakingSync,
-  makeFlavorKaminoSync,
-  makeFlavorMarginfiSync,
-  makeFlavorPerenaSync,
-} from "../flavors"
-import { emitEventAuthority, uniqueRemainingAccounts } from "../utils"
-import { Vault } from "../vault"
-import {
-  MAX_FILLED_OFFERS,
-  PRICE_BASE_POINTS,
-  calcOutAmountOnCounterOfferFilling,
-  calcRemainingAmountOnCounterOfferFilling,
-  getOfferAmountToGet,
-  getOfferAmountToGetNoVirtual,
-  getOfferSize,
-  roundPriceApy,
-} from "./math"
-import { Offer, OfferType, OrderbookLoadOptions, QuoteDirection } from "./types"
-import {
-  getOfferDirectionFromQuoteDirection,
-  getOfferType,
-  getOfferTypeFromTradeDirection,
-  isQuoteInputTokenBase,
-  isQuoteOutputTokenBase,
-  priceToImpliedRate,
-} from "./utils"
-
-import * as exponentCore from '../client/core';
-import * as exponentOrderbook from '../client/orderbook';
-import { PublicKey, Connection, SystemProgram, TransactionInstruction } from "@solana/web3.js"
-
-export class Orderbook {
-
-  constructor(
-    public state: OrderbookState,
-    public selfAddress: PublicKey,
-    public env: Environment,
-    public connection: Connection,
-    public vaulLookupTable: PublicKey,
-    /** Vault instance - required for merge/strip which uses vault's SY position (owned by vault authority) */
-    public vault: Vault,
-  ) {
-   
-  }
-
-  static async load(
-    env: Environment,
-    connection: Connection,
-    address: PublicKey,
-    options: OrderbookLoadOptions = {},
-    vault?: Vault,
-  ) {
-    const fetcher = new ExponentFetcher({ connection })
-    const orderbook = await fetcher.fetchOrderbook(address)
-    const pda = new ExponentOrderbookPDA()
-    const orderbookCpiAccounts = await fetcher.fetchOrderbookCpiAccounts(
-      pda.orderbookCpiAccounts({ orderbook: address }),
-    )
-    const altOrderbook = await fetchAddressLookupTable(connection, orderbook.addressLookupTable)
-    const cpiAccounts = makeCpiAccountMetaLists(altOrderbook, orderbookCpiAccounts.syCpiAccounts)
-    const cpiCoreAccounts = makeCoreCpiAccountMetaLists(altOrderbook, orderbookCpiAccounts.exponentCoreCpiAccounts)
-    const loadedVault = vault || (await Vault.load(env, connection, orderbook.vault))
-    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 state: OrderbookState = {
-      ...orderbook,
-      syCpiAccounts: cpiAccounts,
-      exponentCoreCpiAccounts: cpiCoreAccounts,
-      flavor,
-    }
-
-    return new Orderbook(state, address, env, connection, loadedVault.addressLookupTable, loadedVault)
-  }
-
-  async reload(conn: Connection = this.connection) {
-    const v = await Orderbook.load(this.env, conn, this.selfAddress)
-    this.state = v.state
-    ;(this as { vault: Vault }).vault = v.vault
-    return v
-  }
-
-  get corePda() {
-    return new ExponentPDA()
-  }
-
-  get pda() {
-    return new ExponentOrderbookPDA()
-  }
-
-  get adminPda() {
-    return new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID)
-  }
-
-  get eventAuthority() {
-    return emitEventAuthority(exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID)
-  }
-
-  get coreEventAuthority() {
-    return emitEventAuthority(this.state.exponentCoreProgram)
-  }
-
-  get mintYt() {
-    return this.corePda.mintYt({ vault: this.state.vault })
-  }
-
-  get mintPt() {
-    return this.corePda.mintPt({ vault: this.state.vault })
-  }
-
-  get syCpiAccounts() {
-    return this.state.syCpiAccounts
-  }
-
-  get exponentCoreCpiAccounts() {
-    return this.state.exponentCoreCpiAccounts
-  }
-
-  get flavor() {
-    return this.state.flavor
-  }
-
-  get secondsRemaining() {
-    return Math.max(this.state.financials.expirationTs - Math.floor(Date.now() / 1000), 0)
-  }
-
-  /** Fee rate is 1 + the actual fee rate - is is for convenience with calculations
-   * A feeRate of 1.001 means the fee is 0.1%
-   * A feeRate of 1 means there is no fee
-   */
-  get makerFeeRate() {
-    if (this.secondsRemaining == 0) {
-      return 1
-    }
-
-    return feeRate({
-      lnFeeRateRoot: this.state.configurationOptions.lnMakerFeeRate,
-      secondsRemaining: this.secondsRemaining,
-    })
-  }
-
-  get takerFeeRate() {
-    if (this.secondsRemaining == 0) {
-      return 1
-    }
-
-    return feeRate({
-      lnFeeRateRoot: this.state.configurationOptions.lnTakerFeeRate,
-      secondsRemaining: this.secondsRemaining,
-    })
-  }
-
-  /** Post offer instruction */
-  ixPostOffer({
-    trader,
-    price,
-    amount,
-    offerType,
-    offerOption,
-    virtualOffer,
-    expirySeconds,
-    offerIdx,
-    mintSy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-  }: {
-    trader: PublicKey
-    price: number
-    amount: bigint
-    offerType: exponentOrderbook.OfferType
-    offerOption: exponentOrderbook.OfferOptions
-    virtualOffer: boolean
-    expirySeconds: number
-    offerIdx?: number | null
-    mintSy: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const impliedRate = priceToImpliedRate(price)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.mergeSy,
-      ...this.exponentCoreCpiAccounts.stripSy,
-      ...this.exponentCoreCpiAccounts.depositYt,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-      // Merge uses vault's cpi_accounts.withdraw_sy - needs vault's SY position (owner = vault authority)
-      ...this.vault.cpiAccounts.getSyState,
-      ...this.vault.cpiAccounts.withdrawSy,
-    ])
-    const ix = exponentOrderbook.createPostOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        priceApy: impliedRate,
-        amount,
-        offerTypeFlag: offerType,
-        virtualOffer,
-        expirySeconds,
-        options: offerOption,
-        offerIdx: offerIdx ?? null,
-      },
-    )
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  /** Market offer instruction */
-  ixMarketOffer({
-    trader,
-    maxPriceApy,
-    amount,
-    minAmountOut,
-    offerType,
-    virtualOffer,
-    mintSy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-  }: {
-    trader: PublicKey
-    maxPriceApy: number
-    amount: bigint
-    minAmountOut: bigint
-    offerType: exponentOrderbook.OfferType
-    virtualOffer: boolean
-    mintSy: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const impliedRate = priceToImpliedRate(maxPriceApy)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.mergeSy,
-      ...this.exponentCoreCpiAccounts.stripSy,
-      ...this.exponentCoreCpiAccounts.depositYt,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-      // Merge uses vault's cpi_accounts.withdraw_sy - needs vault's SY position (owner = vault authority)
-      ...this.vault.cpiAccounts.getSyState,
-      ...this.vault.cpiAccounts.withdrawSy,
-    ])
-    const ix = exponentOrderbook.createMarketOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        maxPriceApy: impliedRate,
-        amount,
-        minAmountOut,
-        offerType,
-        virtualOffer,
-      },
-    )
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  /** High trust set configuration options instruction */
-  ixSetConfigurationOptions({
-    admin,
-    configurationOptions,
-  }: {
-    admin: PublicKey
-    configurationOptions: ConfigurationOptions
-  }) {
-    return exponentOrderbook.createSetConfigurationOptionsInstruction(
-      {
-        adminSigner: admin,
-        orderbook: this.selfAddress,
-      },
-      {
-        setConfigurationOptionsEnum: exponentOrderbook.setConfigurationOptionsEnum(
-          "ThresholdAmount",
-          [BigInt(configurationOptions.thresholdAmount.toString())],
-        ),
-      },
-    )
-  }
-
-  /**
-   * Set a single configuration option on the orderbook.
-   *
-   * Each call sets exactly one of the four on-chain enum variants:
-   *   { thresholdAmount: bigint }  – minimum lot size (u64)
-   *   { priceDecimals: number }    – APY tick precision (u8), e.g. 6 → 0.0001% resolution
-   *   { takerFeeRateBp: number }   – ln-space taker fee rate (f64)
-   *   { makerFeeRateBp: number }   – ln-space maker fee rate (f64)
-   */
-  ixSetConfigurationOption({
-    admin,
-    option,
-  }: {
-    admin: PublicKey
-    option:
-      | { thresholdAmount: bigint }
-      | { priceDecimals: number }
-      | { takerFeeRateBp: number }
-      | { makerFeeRateBp: number }
-  }) {
-    return Orderbook.buildSetConfigurationOptionIx({
-      orderbookAddress: this.selfAddress,
-      admin,
-      option,
-    })
-  }
-
-  /**
-   * Build a `setConfigurationOptions` instruction without loading the full orderbook.
-   *
-   * Use this when you only have the orderbook address and admin key — it avoids
-   * fetching the vault, ALT, or any other on-chain state.
-   */
-  static buildSetConfigurationOptionIx({
-    orderbookAddress,
-    admin,
-    option,
-  }: {
-    orderbookAddress: PublicKey
-    admin: PublicKey
-    option:
-      | { thresholdAmount: bigint }
-      | { priceDecimals: number }
-      | { takerFeeRateBp: number }
-      | { makerFeeRateBp: number }
-  }) {
-    let enumArg: exponentOrderbook.SetConfigurationOptionsEnum
-    if ('thresholdAmount' in option) {
-      enumArg = exponentOrderbook.setConfigurationOptionsEnum("ThresholdAmount", [option.thresholdAmount])
-    } else if ('priceDecimals' in option) {
-      enumArg = exponentOrderbook.setConfigurationOptionsEnum("PriceDecimals", [option.priceDecimals])
-    } else if ('takerFeeRateBp' in option) {
-      enumArg = exponentOrderbook.setConfigurationOptionsEnum("TakerFeeRateBp", [option.takerFeeRateBp])
-    } else {
-      enumArg = exponentOrderbook.setConfigurationOptionsEnum("MakerFeeRateBp", [option.makerFeeRateBp])
-    }
-
-    return exponentOrderbook.createSetConfigurationOptionsInstruction(
-      { adminSigner: admin, orderbook: orderbookAddress },
-      { setConfigurationOptionsEnum: enumArg },
-    )
-  }
-
-  getOffers(): Offer[] {
-    const { offers, prices, userEscrows } = this.state
-
-    return offers.map((o) => {
-      //? pricePointer - 1 because of TreeNode allocator specifics
-      const priceApy = prices[o.pricePointer - 1]!.key / PRICE_BASE_POINTS
-      const userEscrow = userEscrows[o.userVaultPointer - 1]!.user
-
-      const type = getOfferType(o.orderTypeFlag)
-
-      return {
-        type,
-        priceApy,
-        amount: Number(o.amount.toString()),
-        userEscrow: userEscrow,
-        expiryAt: o.expiryAt,
-        createdAt: o.createdAt,
-        isVirtual: o.virtualOffer,
-        offerIndex: o.offerIndex,
-      }
-    })
-  }
-
-  /** Remove offer instruction */
-  ixRemoveOffer({
-    trader,
-    offerIdx,
-    mintSy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-  }: {
-    trader: PublicKey
-    offerIdx: number
-    mintSy: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const ix = exponentOrderbook.createRemoveOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.state.syProgram,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        offerIdx,
-      },
-    )
-    ix.keys.push(...this.syCpiAccounts.getSyState)
-    return ix
-  }
-
-  /** Post offer instruction
-   * @param offerIdx - Optional offer index for vault position tracking. Must be unique per trader when provided.
-   *                   For vault managers, this should be tracked in the vault's OrderbookEntry.offerIdxVec.
-   *                   Omit for direct user orders (no vault position tracking).
-   */
-  async ixWrapperPostOffer({
-    trader,
-    setupPayer,
-    price,
-    amount,
-    offerType,
-    offerOption,
-    virtualOffer,
-    expirySeconds,
-    mintSy,
-    offerIdx,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    trader: PublicKey
-    setupPayer?: PublicKey
-    price: number
-    amount: bigint
-    offerType: exponentOrderbook.OfferType
-    offerOption: exponentOrderbook.OfferOptions
-    virtualOffer: boolean
-    expirySeconds: number
-    mintSy: PublicKey
-    /** Offer index for vault position tracking. Omit for direct user orders. */
-    offerIdx?: number | null
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, trader, true, this.flavor.baseTokenProgram)
-    const impliedRate = priceToImpliedRate(price)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.mergeSy,
-      ...this.exponentCoreCpiAccounts.stripSy,
-      ...this.exponentCoreCpiAccounts.depositYt,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-      // Merge uses vault's cpi_accounts.withdraw_sy - needs vault's SY position (owner = vault authority)
-      ...this.vault.cpiAccounts.getSyState,
-      ...this.vault.cpiAccounts.withdrawSy,
-    ])
-
-    const ataPayer = setupPayer ?? trader
-    const tokenSyDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, sySrc, trader, mintSy)
-    const tokenYtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ytSrc, trader, this.mintYt)
-    const tokenPtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ptSrc, trader, this.mintPt)
-
-    const mintSyIx = await this.flavor.ixMintSy({
-      amountBase: "0",
-      depositor: trader,
-      depositorBaseTokenAccount: tokenBaseTrader,
-      depositorSyTokenAccount: sySrc,
-    })
-
-    const mintSyRemAccounts = mintSyIx.keys
-    const ix = exponentOrderbook.createWrapperPostOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        priceApy: impliedRate,
-        amountBase: amount,
-        offerType,
-        virtualOffer,
-        expirySeconds,
-        options: offerOption,
-        offerIdx: offerIdx ?? null,
-        mintSyOrWithdrawYtAccountsUntil: mintSyRemAccounts.length,
-      },
-    )
-    ix.keys.push(...mintSyRemAccounts, ...remainingAccounts)
-
-    return { ix, setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx] }
-  }
-
-  /** Market offer instruction */
-  async ixWrapperMarketOffer({
-    trader,
-    setupPayer,
-    maxPriceApy,
-    amount,
-    offerType,
-    minAmountOut,
-    virtualOffer,
-    mintSy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    trader: PublicKey
-    setupPayer?: PublicKey
-    maxPriceApy: number
-    amount: bigint
-    offerType: exponentOrderbook.OfferType
-    minAmountOut: bigint
-    virtualOffer: boolean
-    mintSy: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, trader, true, this.flavor.baseTokenProgram)
-    const impliedRate = priceToImpliedRate(maxPriceApy)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.mergeSy,
-      ...this.exponentCoreCpiAccounts.stripSy,
-      ...this.exponentCoreCpiAccounts.depositYt,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-      // Merge uses vault's cpi_accounts.withdraw_sy - needs vault's SY position (owner = vault authority)
-      ...this.vault.cpiAccounts.getSyState,
-      ...this.vault.cpiAccounts.withdrawSy,
-    ])
-
-    const ataPayer = setupPayer ?? trader
-    const tokenSyDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, sySrc, trader, mintSy)
-    const tokenYtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ytSrc, trader, this.mintYt)
-    const tokenPtDepositorAtaIx = createAssociatedTokenAccountIdempotentInstruction(ataPayer, ptSrc, trader, this.mintPt)
-
-    const mintSyIx = await this.flavor.ixMintSy({
-      amountBase: "0",
-      depositor: trader,
-      depositorBaseTokenAccount: tokenBaseTrader,
-      depositorSyTokenAccount: sySrc,
-    })
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: trader,
-      redeemerBaseTokenAccount: tokenBaseTrader,
-      redeemerSyTokenAccount: sySrc,
-    })
-
-    const depositYtAccounts = this.depositYtAccounts({
-      owner: trader,
-      ytSrc: ytSrc,
-    })
-    const redeem_sy_or_deposit_yt_accounts =
-      (!virtualOffer && offerType == OfferType.SellYt) || (virtualOffer && offerType == OfferType.BuyYt)
-        ? redeemSyIx.keys
-        : depositYtAccounts.keys
-
-    const mintSyRemAccounts = mintSyIx.keys
-    const redeem_sy_or_deposit_yt_accounts_untill = mintSyRemAccounts.length + redeem_sy_or_deposit_yt_accounts.length
-    const ix = exponentOrderbook.createWrapperMarketOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        maxPriceApy: impliedRate,
-        amountBase: amount,
-        minAmountOut,
-        offerType,
-        virtualOffer,
-        mintSyOrWithdrawYtAccountsUntil: mintSyRemAccounts.length,
-        redeemSyOrDepsoitYtAccountsUntil: redeem_sy_or_deposit_yt_accounts_untill,
-      },
-    )
-    ix.keys.push(...mintSyRemAccounts, ...redeem_sy_or_deposit_yt_accounts, ...remainingAccounts)
-
-    return { ix, setupIxs: [tokenSyDepositorAtaIx, tokenYtDepositorAtaIx, tokenPtDepositorAtaIx] }
-  }
-
-  /** Wrapper remove offer instruction */
-  async ixWrapperRemoveOffer({
-    trader,
-    offerIdx,
-    mintSy,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    trader: PublicKey
-    offerIdx: number
-    mintSy: PublicKey
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, trader, true, this.flavor.baseTokenProgram)
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: trader,
-      redeemerBaseTokenAccount: tokenBaseTrader,
-      redeemerSyTokenAccount: sySrc,
-    })
-
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-    ])
-
-    const redeemSyRemAccounts = redeemSyIx.keys
-    const ix = exponentOrderbook.createWrapperRemoveOfferInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        offerIdx,
-        redeemSyAccountsUntil: redeemSyIx.keys.length,
-      },
-    )
-    ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts)
-    return ix
-  }
-
-  /** Wrapper collect interest instruction */
-  async ixWrapperCollectInterest({
-    trader,
-    mintSy,
-    sySrc: sySrcParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    trader: PublicKey
-    mintSy: PublicKey
-    sySrc?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, trader, true, this.flavor.baseTokenProgram)
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: trader,
-      redeemerBaseTokenAccount: tokenBaseTrader,
-      redeemerSyTokenAccount: sySrc,
-    })
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.collectInterest,
-      ...this.syCpiAccounts.withdrawSy,
-    ])
-    const redeemSyRemAccounts = redeemSyIx.keys
-    const ix = exponentOrderbook.createWrapperCollectInterestInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        redeemSyAccountsUntil: redeemSyIx.keys.length,
-      },
-    )
-    ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts)
-    return ix
-  }
-
-  /** Wrapper withdraw funds instruction */
-  async ixWrapperWithdrawFunds({
-    trader,
-    mintSy,
-    ptAmount,
-    ytAmount,
-    syAmount,
-    ptSrc: ptSrcParam,
-    ytSrc: ytSrcParam,
-    sySrc: sySrcParam,
-    tokenBaseTrader: tokenBaseTraderParam,
-  }: {
-    trader: PublicKey
-    mintSy: PublicKey
-    ptAmount: exponentOrderbook.Amount
-    ytAmount: exponentOrderbook.Amount
-    syAmount: exponentOrderbook.Amount
-    ptSrc?: PublicKey
-    ytSrc?: PublicKey
-    sySrc?: PublicKey
-    tokenBaseTrader?: PublicKey
-  }) {
-    const ptSrc = ptSrcParam || getAssociatedTokenAddressSync(this.mintPt, trader, true, TOKEN_PROGRAM_ID)
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, trader, true, TOKEN_PROGRAM_ID)
-    const sySrc = sySrcParam || getAssociatedTokenAddressSync(mintSy, trader, true, TOKEN_PROGRAM_ID)
-
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const tokenBaseTrader =
-      tokenBaseTraderParam ||
-      getAssociatedTokenAddressSync(this.flavor.mintBase, trader, true, this.flavor.baseTokenProgram)
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: trader,
-      redeemerBaseTokenAccount: tokenBaseTrader,
-      redeemerSyTokenAccount: sySrc,
-    })
-
-    const redeemSyRemAccounts = redeemSyIx.keys
-
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-    ])
-
-    const ix = exponentOrderbook.createWrapperWithdrawFundsInstruction(
-      {
-        trader,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        ptAmountOptional: ptAmount,
-        ytAmountOptional: ytAmount,
-        syAmountOptional: syAmount,
-        redeemSyAccountsUntil: redeemSyIx.keys.length,
-      },
-    )
-    ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts)
-    return ix
-  }
-
-  /** Wrapper collect admin fee instruction */
-  async ixWrapperCollectAdminFee({ admin, mintSy }: { admin: PublicKey; mintSy: PublicKey }) {
-    const ptSrc = getAssociatedTokenAddressSync(this.mintPt, admin, true, TOKEN_PROGRAM_ID)
-    const ytSrc = getAssociatedTokenAddressSync(this.mintYt, admin, true, TOKEN_PROGRAM_ID)
-    const sySrc = getAssociatedTokenAddressSync(mintSy, admin, true, TOKEN_PROGRAM_ID)
-
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-    const tokenBaseTrader = getAssociatedTokenAddressSync(
-      this.flavor.mintBase,
-      admin,
-      true,
-      this.flavor.baseTokenProgram,
-    )
-
-    const redeemSyIx = await this.flavor.ixRedeemSy({
-      amountSy: "0",
-      redeemer: admin,
-      redeemerBaseTokenAccount: tokenBaseTrader,
-      redeemerSyTokenAccount: sySrc,
-    })
-
-    const redeemSyRemAccounts = redeemSyIx.keys
-
-    const remainingAccounts = uniqueRemainingAccounts([
-      ...this.syCpiAccounts.getSyState,
-      ...this.exponentCoreCpiAccounts.collectInterest,
-      ...this.exponentCoreCpiAccounts.withdrawYt,
-    ])
-
-    const ix = exponentOrderbook.createWrapperCollectAdminFeeInstruction(
-      {
-        admin,
-        orderbook: this.selfAddress,
-        vault: this.state.vault,
-        cpiAccountOrderbook,
-        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
-        tokenSyAdmin: sySrc,
-        tokenYtAdmin: ytSrc,
-        tokenPtAdmin: ptSrc,
-        systemProgram: SystemProgram.programId,
-        syProgram: this.state.syProgram,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        exponentCore: this.state.exponentCoreProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        redeemSyAccountsUntil: redeemSyIx.keys.length,
-      },
-    )
-    ix.keys.push(...redeemSyRemAccounts, ...remainingAccounts)
-    return ix
-  }
-
-  /** Wrapper collect admin emission instruction */
-  ixCollectAdminEmission({
-    emissionEscrow,
-    amount,
-    index,
-    treasuryEmissionTokenAccount,
-    tokenEmissionAdmin,
-  }: {
-    emissionEscrow: PublicKey
-    index: number
-    amount: exponentOrderbook.Amount
-    treasuryEmissionTokenAccount: PublicKey
-    tokenEmissionAdmin: PublicKey
-  }) {
-    const claimEmissionAccounts = this.collectAdminEmissionCoreAccounts({
-      emissionDst: tokenEmissionAdmin,
-      emissionEscrow,
-      treasuryEmissionTokenAccount,
-    })
-    const remainingAccounts = [...claimEmissionAccounts, ...this.syCpiAccounts.claimEmission[index]]
-
-    const ix = exponentOrderbook.createCollectAdminEmissionInstruction(
-      {
-        admin: this.state.admin,
-        orderbook: this.selfAddress,
-        exponentCore: this.state.exponentCoreProgram,
-        eventAuthority: this.eventAuthority,
-        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-      },
-      {
-        amount,
-        index,
-      },
-    )
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  collectAdminEmissionCoreAccounts({
-    emissionDst,
-    emissionEscrow,
-    treasuryEmissionTokenAccount,
-  }: {
-    emissionDst: PublicKey
-    emissionEscrow: PublicKey
-    treasuryEmissionTokenAccount: PublicKey
-  }): AccountInfo[] {
-    return [
-      {
-        pubkey: this.selfAddress,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: this.state.vault,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: this.state.yieldPosition,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: this.state.syProgram,
-        isSigner: false,
-        isWritable: false,
-      },
-      {
-        pubkey: emissionEscrow,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: emissionDst,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: treasuryEmissionTokenAccount,
-        isSigner: false,
-        isWritable: true,
-      },
-      {
-        pubkey: TOKEN_PROGRAM_ID,
-        isSigner: false,
-        isWritable: false,
-      },
-      {
-        pubkey: this.coreEventAuthority,
-        isSigner: false,
-        isWritable: false,
-      },
-      {
-        pubkey: this.state.exponentCoreProgram,
-        isSigner: false,
-        isWritable: false,
-      },
-    ]
-  }
-
-  /** Wrapper collect admin fee instruction */
-  ixRemoveExpiredOffers({ admin }: { admin: PublicKey }) {
-    const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
-
-    const remainingAccounts = uniqueRemainingAccounts([...this.syCpiAccounts.getSyState])
-
-    const ix = exponentOrderbook.createRemoveExpiredOffersInstruction({
-      admin,
-      orderbook: this.selfAddress,
-      vault: this.state.vault,
-      syProgram: this.state.syProgram,
-      addressLookupTable: this.state.addressLookupTable,
-      cpiAccountOrderbook,
-      eventAuthority: this.eventAuthority,
-      program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
-    })
-    ix.keys.push(...remainingAccounts)
-    return ix
-  }
-
-  getQuote({
-    priceApy: rawPriceApy,
-    inAmount: inAmountRaw,
-    direction,
-    unixNow,
-    syExchangeRate,
-  }: {
-    priceApy?: number //? In percents!!!
-    inAmount: number //? In lamports
-    unixNow: number //? Time is very important for calculations. Better to avoid using Date.now()
-    direction: QuoteDirection
-    syExchangeRate: number //? E.g. 1.000009210084
-  }) {
-    const offerDirection = getOfferDirectionFromQuoteDirection(direction)
-    const { isVirtual: isQuoteVirtualOffer, offerType: quoteOfferType } = getOfferTypeFromTradeDirection(offerDirection)
-
-    //? If inAmount is in base, convert Base to SY
-    const inAmount = isQuoteInputTokenBase(direction) ? inAmountRaw / syExchangeRate : inAmountRaw
-    //? Offer on contract stores its APY price in ln(1+ apy) view. Convert it before all calculations
-    const priceApy =
-      rawPriceApy &&
-      roundPriceApy(priceToImpliedRate(rawPriceApy), this.state.configurationOptions.priceDecimals) / PRICE_BASE_POINTS
-
-    const secUntilMaturity = this.state.financials.expirationTs - unixNow
-
-    //? If offerType === BuyYT, sort by priceApy asc, otherwise by priceApy desc
-    const suitableOffersByType = this.getOffers()
-      .filter(({ type, expiryAt, priceApy: offerPriceApy }) => {
-        const isExpired = expiryAt < unixNow
-        const satisfyPriceApy = (() => {
-          if (!priceApy) return true
-          if (quoteOfferType === OfferType.BuyYt) return offerPriceApy <= priceApy
-          return offerPriceApy >= priceApy
-        })()
-        return type !== quoteOfferType && !isExpired && satisfyPriceApy
-      })
-      .sort((a, b) => {
-        const expiryCompare = a.expiryAt - b.expiryAt
-        //? If we buyYT -- sort priceApy ascending, otherwise descending
-        if (quoteOfferType === OfferType.BuyYt) {
-          return a.priceApy - b.priceApy || expiryCompare
-        }
-        return b.priceApy - a.priceApy || expiryCompare
-      })
-
-    let remainingAmount = inAmount
-    let outAmount = 0
-    let offersUsed = 0
-    let makerFees = 0
-    let takerFees = 0
-    suitableOffersByType.forEach((counterOffer) => {
-      if (remainingAmount <= 0) return
-
-      if (offersUsed > MAX_FILLED_OFFERS) return
-
-      //? How much counter type tokens we request using current counter offer price+type
-      //? Returns YT amount for SY->YT quote
-      //? Returns SY amount for quote YT->SY quote
-      //? Returns SY amount for SY->PT quote. How much SY should be (in theory) in counter offer to satisfy strip: SY_get->PT+YT
-      //? Returns YT amount for PT->SY quote. YT amount in merge operation: PT+YT->SY
-      const remainingAmountInCounterOfferToken = getOfferAmountToGet(
-        {
-          type: quoteOfferType,
-          amount: remainingAmount,
-          priceApy: counterOffer.priceApy,
-          isVirtual: isQuoteVirtualOffer,
-          userEscrow: PublicKey.default,
-          expiryAt: Infinity,
-          createdAt: unixNow,
-        },
-        syExchangeRate,
-        secUntilMaturity,
-      )
-
-      //? YT amount for SY->YT quote
-      //? SY amount for quote YT->SY quote
-      //? SY amount for SY->PT quote
-      //? YT amount for PT->SY quote
-      const offerSize = getOfferSize(counterOffer, secUntilMaturity, syExchangeRate)
-
-      if (remainingAmountInCounterOfferToken > offerSize) {
-        //? How much token you can sell into this offer. To extract all the liquidity (offer.amount)
-        const offerToGet = getOfferAmountToGetNoVirtual(
-          {
-            ...counterOffer,
-            amount: offerSize,
-          },
-          syExchangeRate,
-          secUntilMaturity,
-        )
-
-        const remainingAmountFromCounterOffer = calcRemainingAmountOnCounterOfferFilling(
-          offerToGet,
-          offerSize,
-          isQuoteVirtualOffer,
-          quoteOfferType,
-          syExchangeRate,
-        )
-
-        const outAmountFromCounterOffer = calcOutAmountOnCounterOfferFilling(
-          offerToGet,
-          offerSize,
-          isQuoteVirtualOffer,
-          quoteOfferType,
-          counterOffer.isVirtual,
-          syExchangeRate,
-          this.makerFeeRate,
-          this.takerFeeRate,
-        )
-
-        remainingAmount -= remainingAmountFromCounterOffer
-        outAmount += outAmountFromCounterOffer.outAmount
-        makerFees += outAmountFromCounterOffer.tradeMakerFee
-        takerFees += outAmountFromCounterOffer.tradeTakerFee
-      } else {
-        //? How much token you can sell into this offer. To extract all the liquidity (offer.amount)
-        const offerToGet = getOfferAmountToGetNoVirtual(
-          {
-            ...counterOffer,
-            amount: remainingAmountInCounterOfferToken,
-          },
-          syExchangeRate,
-          secUntilMaturity,
-        )
-
-        const outAmountFromCounterOffer = calcOutAmountOnCounterOfferFilling(
-          offerToGet,
-          remainingAmountInCounterOfferToken,
-          isQuoteVirtualOffer,
-          quoteOfferType,
-          counterOffer.isVirtual,
-          syExchangeRate,
-          this.makerFeeRate,
-          this.takerFeeRate,
-        )
-
-        remainingAmount = 0
-        outAmount += outAmountFromCounterOffer.outAmount
-        makerFees += outAmountFromCounterOffer.tradeMakerFee
-        takerFees += outAmountFromCounterOffer.tradeTakerFee
-      }
-
-      offersUsed++
-    })
-
-    //? If output is in base, convert SY to Base
-    const outAmountAdjusted = isQuoteOutputTokenBase(direction) ? outAmount * syExchangeRate : outAmount
-    const isConsumedAllInput = remainingAmount <= this.state.configurationOptions.thresholdAmount
-    if (!isConsumedAllInput) {
-      return {
-        outAmount: 0,
-        makerFees: 0,
-        takerFees: 0,
-      }
-    }
-
-    return {
-      outAmount: Math.floor(outAmountAdjusted),
-      makerFees: Math.floor(makerFees),
-      takerFees: Math.floor(takerFees),
-    }
-  }
-
-  depositYtAccounts({
-    owner,
-    ytSrc: ytSrcParam,
-  }: {
-    owner: PublicKey
-    ytSrc?: PublicKey
-  }): TransactionInstruction {
-    const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    const ix = exponentCore.createDepositYtInstruction(
-      {
-        depositor: owner,
-        vault: this.state.vault,
-        userYieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner }),
-        ytSrc,
-        escrowYt: this.corePda.escrowYt({ vault: this.state.vault }),
-        tokenProgram: TOKEN_PROGRAM_ID,
-        syProgram: this.state.syProgram,
-        addressLookupTable: this.vaulLookupTable,
-        yieldPosition: this.corePda.vaultYieldPosition({ vault: this.state.vault }),
-        systemProgram: SystemProgram.programId,
-        eventAuthority: this.coreEventAuthority,
-        program: this.state.exponentCoreProgram,
-      },
-      { amount: 0n },
-    )
-    ix.keys.push(...this.syCpiAccounts.getSyState)
-    return ix
-  }
-
-  /**
-   * Gets the user's escrow balances locked in the orderbook
-   * Returns PT, YT, and SY token amounts held in escrow for active orders
-   */
-  getUserBalances(user: PublicKey) {
-    // Find user's escrow balances from the orderbook state
-    const userEscrow = this.state.userEscrows.find((escrow) => escrow.user.equals(user))
-
-    return {
-      pt: userEscrow?.ptAmount?.toString() || "0",
-      yt: userEscrow?.ytAmount?.toString() || "0",
-      sy: userEscrow?.syAmount?.toString() || "0",
-      stakedYt: userEscrow?.stakedYtAmount?.toString() || "0",
-      staged: userEscrow?.staged?.toString() || "0",
-    }
-  }
-
-  /**
-   * Gets all open orders for a specific user
-   * Returns detailed information about each order including type, price, amount, and expiry
-   */
-  getUserOpenOrders(user: PublicKey): Offer[] {
-    const { offers, prices, userEscrows } = this.state
-    const currentTime = Math.floor(Date.now() / 1000)
-
-    return offers
-      .map((o, index) => {
-        const priceApy = prices[o.pricePointer - 1]!.key / PRICE_BASE_POINTS
-        const userEscrow = userEscrows[o.userVaultPointer - 1]!.user
-        const type = getOfferType(o.orderTypeFlag)
-
-        return {
-          type,
-          priceApy,
-          amount: Number(o.amount.toString()),
-          userEscrow: userEscrow,
-          expiryAt: o.expiryAt,
-          createdAt: o.createdAt,
-          isVirtual: o.virtualOffer,
-          offerIndex: o.offerIndex,
-        }
-      })
-      .filter((offer) => {
-        // Filter for this specific user and non-expired orders
-        return offer.userEscrow.equals(user) && offer.expiryAt > currentTime
-      })
-  }
-
-  /**
-   * Gets the next offer index that will be allocated by the orderbook.
-   * Use the free-list head when available, otherwise fall back to the bump index
-   * for fresh allocations.
-   */
-  getNextOfferIndex(): number {
-    return this.state.offersFreeListHead !== 0
-      ? this.state.offersFreeListHead
-      : this.state.offersBumpIndex
-  }
-}
-
-type DepositYtAccounts = {
-  [K in
-    | "depositor"
-    | "vault"
-    | "userYieldPosition"
-    | "ytSrc"
-    | "escrowYt"
-    | "tokenProgram"
-    | "syProgram"
-    | "addressLookupTable"
-    | "yieldPosition"
-    | "systemProgram"
-    | "eventAuthority"
-    | "program"]: PublicKey
-}