@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/src/orderbook/orderbook.ts

@@ -0,0 +1,1354 @@
+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
+}