@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/src/orderbook/orderbook.ts

@@ -1,13 +1,14 @@
-import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
-import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token"
+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 { IDL as EXPONENT_CORE_IDL, ExponentCore } from "@exponent-labs/exponent-idl"
-import { IDL as EXPONENT_ORDERBOOK_IDL, ExponentOrderbook } from "@exponent-labs/exponent-orderbook-idl"
 import { ExponentOrderbookPDA, ExponentPDA } from "@exponent-labs/exponent-pda"
 import { AccountInfo, ConfigurationOptions, OrderbookState } from "@exponent-labs/exponent-types"
-import { ClaimAmount } from "@exponent-labs/marginfi-sy-sdk"
+import { feeRate } from "@exponent-labs/market-math"
 
 import {
   fetchAddressLookupTable,
@@ -22,9 +23,8 @@ import {
   makeFlavorMarginfiSync,
   makeFlavorPerenaSync,
 } from "../flavors"
-import { MyWallet } from "../market"
-import { InstructionAccounts, emitEventAuthority, uniqueRemainingAccounts } from "../utils"
-import { CollectEmissionAccounts, Vault } from "../vault"
+import { emitEventAuthority, uniqueRemainingAccounts } from "../utils"
+import { Vault } from "../vault"
 import {
   MAX_FILLED_OFFERS,
   PRICE_BASE_POINTS,
@@ -35,7 +35,7 @@ import {
   getOfferSize,
   roundPriceApy,
 } from "./math"
-import { Offer, OfferOptionsAnchor, OfferType, OfferTypeAnchor, OrderbookLoadOptions, QuoteDirection } from "./types"
+import { Offer, OfferType, OrderbookLoadOptions, QuoteDirection } from "./types"
 import {
   getOfferDirectionFromQuoteDirection,
   getOfferType,
@@ -44,33 +44,29 @@ import {
   isQuoteOutputTokenBase,
   priceToImpliedRate,
 } from "./utils"
-import { feeRate } from "@exponent-labs/market-math"
+
+import * as exponentCore from '../client/core';
+import * as exponentOrderbook from '../client/orderbook';
+import { PublicKey, Connection, SystemProgram, TransactionInstruction } from "@solana/web3.js"
 
 export class Orderbook {
-  private orderbookProgram: Program<ExponentOrderbook>
-  private coreProgram: Program<ExponentCore>
 
   constructor(
     public state: OrderbookState,
-    public selfAddress: web3.PublicKey,
+    public selfAddress: PublicKey,
     public env: Environment,
-    public connection: web3.Connection,
-    public vaulLookupTable: web3.PublicKey,
+    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,
   ) {
-    this.orderbookProgram = new Program(
-      EXPONENT_ORDERBOOK_IDL as ExponentOrderbook,
-      new AnchorProvider(connection, new MyWallet(web3.Keypair.generate())),
-    )
-    this.coreProgram = new Program(
-      EXPONENT_CORE_IDL as ExponentCore,
-      new AnchorProvider(connection, new MyWallet(web3.Keypair.generate())),
-    )
+   
   }
 
   static async load(
     env: Environment,
-    connection: web3.Connection,
-    address: web3.PublicKey,
+    connection: Connection,
+    address: PublicKey,
     options: OrderbookLoadOptions = {},
     vault?: Vault,
   ) {
@@ -108,12 +104,13 @@ export class Orderbook {
       flavor,
     }
 
-    return new Orderbook(state, address, env, connection, loadedVault.addressLookupTable)
+    return new Orderbook(state, address, env, connection, loadedVault.addressLookupTable, loadedVault)
   }
 
-  async reload(conn: web3.Connection = this.connection) {
+  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
   }
 
@@ -122,7 +119,7 @@ export class Orderbook {
   }
 
   get pda() {
-    return new ExponentOrderbookPDA(this.orderbookProgram.programId)
+    return new ExponentOrderbookPDA()
   }
 
   get adminPda() {
@@ -130,7 +127,7 @@ export class Orderbook {
   }
 
   get eventAuthority() {
-    return emitEventAuthority(this.orderbookProgram.programId)
+    return emitEventAuthority(exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID)
   }
 
   get coreEventAuthority() {
@@ -187,8 +184,6 @@ export class Orderbook {
     })
   }
 
-  
-
   /** Post offer instruction */
   ixPostOffer({
     trader,
@@ -198,22 +193,24 @@ export class Orderbook {
     offerOption,
     virtualOffer,
     expirySeconds,
+    offerIdx,
     mintSy,
     ptSrc: ptSrcParam,
     ytSrc: ytSrcParam,
     sySrc: sySrcParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     price: number
-    amount: BN
-    offerType: OfferTypeAnchor
-    offerOption: OfferOptionsAnchor
+    amount: bigint
+    offerType: exponentOrderbook.OfferType
+    offerOption: exponentOrderbook.OfferOptions
     virtualOffer: boolean
     expirySeconds: number
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
+    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)
@@ -226,31 +223,43 @@ export class Orderbook {
       ...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,
     ])
-    return this.orderbookProgram.methods
-      .postOffer(impliedRate, amount, offerType, virtualOffer, expirySeconds, offerOption)
-      .accountsStrict({
+    const ix = exponentOrderbook.createPostOfferInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
         vault: this.state.vault,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        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 }),
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
+        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,
-        trader,
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
         eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        cpiAccountOrderbook,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        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 */
@@ -266,16 +275,16 @@ export class Orderbook {
     ytSrc: ytSrcParam,
     sySrc: sySrcParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     maxPriceApy: number
-    amount: BN
-    minAmountOut: BN
-    offerType: OfferTypeAnchor
+    amount: bigint
+    minAmountOut: bigint
+    offerType: exponentOrderbook.OfferType
     virtualOffer: boolean
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
+    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)
@@ -288,31 +297,41 @@ export class Orderbook {
       ...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,
     ])
-    return this.orderbookProgram.methods
-      .marketOffer(impliedRate, amount, minAmountOut, offerType, virtualOffer)
-      .accountsStrict({
+    const ix = exponentOrderbook.createMarketOfferInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
         vault: this.state.vault,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        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 }),
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
+        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,
-        trader,
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
         eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        cpiAccountOrderbook,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
+      },
+      {
+        maxPriceApy: impliedRate,
+        amount,
+        minAmountOut,
+        offerType,
+        virtualOffer,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
   }
 
   /** High trust set configuration options instruction */
@@ -320,16 +339,84 @@ export class Orderbook {
     admin,
     configurationOptions,
   }: {
-    admin: web3.PublicKey
+    admin: PublicKey
     configurationOptions: ConfigurationOptions
   }) {
-    return this.orderbookProgram.methods
-      .setConfigurationOptions({ thresholdAmount: { 0: new BN(configurationOptions.thresholdAmount.toString()) } })
-      .accountsStrict({
-        orderbook: this.selfAddress,
+    return exponentOrderbook.createSetConfigurationOptionsInstruction(
+      {
         adminSigner: admin,
-      })
-      .instruction()
+        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[] {
@@ -350,6 +437,7 @@ export class Orderbook {
         expiryAt: o.expiryAt,
         createdAt: o.createdAt,
         isVirtual: o.virtualOffer,
+        offerIndex: o.offerIndex,
       }
     })
   }
@@ -363,44 +451,53 @@ export class Orderbook {
     ytSrc: ytSrcParam,
     sySrc: sySrcParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     offerIdx: number
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
+    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 })
-    return this.orderbookProgram.methods
-      .removeOffer(offerIdx)
-      .accountsStrict({
+    const ix = exponentOrderbook.createRemoveOfferInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ 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 }),
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        trader,
         tokenSyTrader: sySrc,
         tokenYtTrader: ytSrc,
         tokenPtTrader: ptSrc,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
+        systemProgram: SystemProgram.programId,
+        tokenProgram: TOKEN_PROGRAM_ID,
         syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
         exponentCore: this.state.exponentCoreProgram,
-      })
-      .remainingAccounts(this.syCpiAccounts.getSyState)
-      .instruction()
+        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 */
+  /** 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,
@@ -408,23 +505,27 @@ export class Orderbook {
     virtualOffer,
     expirySeconds,
     mintSy,
+    offerIdx,
     ptSrc: ptSrcParam,
     ytSrc: ytSrcParam,
     sySrc: sySrcParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
+    setupPayer?: PublicKey
     price: number
-    amount: BN
-    offerType: OfferTypeAnchor
-    offerOption: OfferOptionsAnchor
+    amount: bigint
+    offerType: exponentOrderbook.OfferType
+    offerOption: exponentOrderbook.OfferOptions
     virtualOffer: boolean
     expirySeconds: number
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    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)
@@ -440,8 +541,16 @@ export class Orderbook {
       ...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,
@@ -450,43 +559,47 @@ export class Orderbook {
     })
 
     const mintSyRemAccounts = mintSyIx.keys
-    return this.orderbookProgram.methods
-      .wrapperPostOffer(
-        impliedRate,
-        amount,
-        offerType,
-        virtualOffer,
-        expirySeconds,
-        offerOption,
-        mintSyRemAccounts.length - 1,
-      )
-      .accountsStrict({
+    const ix = exponentOrderbook.createWrapperPostOfferInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
         vault: this.state.vault,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        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 }),
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
+        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,
-        trader,
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
         eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        cpiAccountOrderbook,
-      })
-      .remainingAccounts([...mintSyRemAccounts, ...remainingAccounts])
-      .instruction()
+        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,
@@ -498,17 +611,18 @@ export class Orderbook {
     sySrc: sySrcParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
+    setupPayer?: PublicKey
     maxPriceApy: number
-    amount: BN
-    offerType: OfferTypeAnchor
-    minAmountOut: BN
+    amount: bigint
+    offerType: exponentOrderbook.OfferType
+    minAmountOut: bigint
     virtualOffer: boolean
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    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)
@@ -524,8 +638,16 @@ export class Orderbook {
       ...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,
@@ -540,52 +662,51 @@ export class Orderbook {
       redeemerSyTokenAccount: sySrc,
     })
 
-    const depositYtAccounts = await this.depositYtAccounts({
+    const depositYtAccounts = this.depositYtAccounts({
       owner: trader,
       ytSrc: ytSrc,
     })
-    const offerTypeEnum = offerType.sellYt ? OfferType.SellYT : OfferType.BuyYT
     const redeem_sy_or_deposit_yt_accounts =
-      (!virtualOffer && offerTypeEnum == OfferType.SellYT) || (virtualOffer && offerTypeEnum == OfferType.BuyYT)
+      (!virtualOffer && offerType == OfferType.SellYt) || (virtualOffer && offerType == OfferType.BuyYt)
         ? redeemSyIx.keys
-        : depositYtAccounts.keys;
-
-    
+        : depositYtAccounts.keys
 
     const mintSyRemAccounts = mintSyIx.keys
-    const redeem_sy_or_deposit_yt_accounts_untill = mintSyRemAccounts.length + redeem_sy_or_deposit_yt_accounts.length;
-    return this.orderbookProgram.methods
-      .wrapperMarketOffer(
-        impliedRate,
-        amount,
-        minAmountOut,
-        offerType,
-        virtualOffer,
-        mintSyRemAccounts.length,
-        redeem_sy_or_deposit_yt_accounts_untill,
-      )
-      .accountsStrict({
+    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,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        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 }),
-        yieldPosition: this.corePda.yieldPosition({ vault: this.state.vault, owner: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
+        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,
-        trader,
-        tokenSyTrader: sySrc,
-        tokenYtTrader: ytSrc,
-        tokenPtTrader: ptSrc,
         eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        cpiAccountOrderbook,
-      })
-      .remainingAccounts(mintSyRemAccounts.concat(redeem_sy_or_deposit_yt_accounts).concat(remainingAccounts))
-      .instruction()
+        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 */
@@ -598,13 +719,13 @@ export class Orderbook {
     sySrc: sySrcParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    trader: web3.PublicKey
+    trader: PublicKey
     offerIdx: number
-    mintSy: web3.PublicKey
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    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)
@@ -627,29 +748,33 @@ export class Orderbook {
     ])
 
     const redeemSyRemAccounts = redeemSyIx.keys
-    return this.orderbookProgram.methods
-      .wrapperRemoveOffer(offerIdx, redeemSyIx.keys.length - 1)
-      .accountsStrict({
+    const ix = exponentOrderbook.createWrapperRemoveOfferInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ 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 }),
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        trader,
         tokenSyTrader: sySrc,
         tokenYtTrader: ytSrc,
         tokenPtTrader: ptSrc,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
+        systemProgram: SystemProgram.programId,
         syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
+        tokenProgram: TOKEN_PROGRAM_ID,
         exponentCore: this.state.exponentCoreProgram,
-        vault: this.state.vault,
-      })
-      .remainingAccounts([...redeemSyRemAccounts, ...remainingAccounts])
-      .instruction()
+        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 */
@@ -659,10 +784,10 @@ export class Orderbook {
     sySrc: sySrcParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    trader: web3.PublicKey
-    mintSy: web3.PublicKey
-    sySrc?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    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 })
@@ -682,25 +807,28 @@ export class Orderbook {
       ...this.syCpiAccounts.withdrawSy,
     ])
     const redeemSyRemAccounts = redeemSyIx.keys
-    return this.orderbookProgram.methods
-      .wrapperCollectInterest(redeemSyIx.keys.length - 1)
-      .accountsStrict({
+    const ix = exponentOrderbook.createWrapperCollectInterestInstruction(
+      {
+        trader,
         orderbook: this.selfAddress,
+        vault: this.state.vault,
+        cpiAccountOrderbook,
         tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
-        trader,
         tokenSyTrader: sySrc,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
+        systemProgram: SystemProgram.programId,
         syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
+        tokenProgram: TOKEN_PROGRAM_ID,
         exponentCore: this.state.exponentCoreProgram,
-        vault: this.state.vault,
-      })
-      .remainingAccounts([...redeemSyRemAccounts, ...remainingAccounts])
-      .instruction()
+        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 */
@@ -715,15 +843,15 @@ export class Orderbook {
     sySrc: sySrcParam,
     tokenBaseTrader: tokenBaseTraderParam,
   }: {
-    trader: web3.PublicKey
-    mintSy: web3.PublicKey
-    ptAmount: ClaimAmount
-    ytAmount: ClaimAmount
-    syAmount: ClaimAmount
-    ptSrc?: web3.PublicKey
-    ytSrc?: web3.PublicKey
-    sySrc?: web3.PublicKey
-    tokenBaseTrader?: web3.PublicKey
+    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)
@@ -748,38 +876,39 @@ export class Orderbook {
       ...this.exponentCoreCpiAccounts.withdrawYt,
     ])
 
-    return this.orderbookProgram.methods
-      .wrapperWithdrawFunds(
-        ptAmount,
-        ytAmount,
-        syAmount,
-        redeemSyIx.keys.length - 1
-      )
-      .accountsStrict({
-        orderbook: this.selfAddress,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
+    const ix = exponentOrderbook.createWrapperWithdrawFundsInstruction(
+      {
         trader,
-        tokenSyTrader: sySrc,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
-        exponentCore: this.state.exponentCoreProgram,
+        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,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        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: web3.PublicKey; mintSy: web3.PublicKey }) {
+  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)
@@ -807,44 +936,47 @@ export class Orderbook {
       ...this.exponentCoreCpiAccounts.withdrawYt,
     ])
 
-    return this.orderbookProgram.methods
-      .wrapperCollectAdminFee(redeemSyIx.keys.length - 1)
-      .accountsStrict({
-        orderbook: this.selfAddress,
-        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
-        systemProgram: web3.SystemProgram.programId,
-        tokenProgram: TOKEN_PROGRAM_ID,
+    const ix = exponentOrderbook.createWrapperCollectAdminFeeInstruction(
+      {
         admin,
-        tokenSyAdmin: sySrc,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
-        exponentCore: this.state.exponentCoreProgram,
+        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,
-      })
-      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
-      .instruction()
+        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 */
-  async ixCollectAdminEmission({
+  ixCollectAdminEmission({
     emissionEscrow,
     amount,
     index,
     treasuryEmissionTokenAccount,
     tokenEmissionAdmin,
   }: {
-    emissionEscrow: web3.PublicKey
+    emissionEscrow: PublicKey
     index: number
-    amount: ClaimAmount
-    treasuryEmissionTokenAccount: web3.PublicKey
-    tokenEmissionAdmin: web3.PublicKey
+    amount: exponentOrderbook.Amount
+    treasuryEmissionTokenAccount: PublicKey
+    tokenEmissionAdmin: PublicKey
   }) {
     const claimEmissionAccounts = this.collectAdminEmissionCoreAccounts({
       emissionDst: tokenEmissionAdmin,
@@ -853,17 +985,21 @@ export class Orderbook {
     })
     const remainingAccounts = [...claimEmissionAccounts, ...this.syCpiAccounts.claimEmission[index]]
 
-    return this.orderbookProgram.methods
-      .collectAdminEmission(amount, index)
-      .accountsStrict({
+    const ix = exponentOrderbook.createCollectAdminEmissionInstruction(
+      {
+        admin: this.state.admin,
         orderbook: this.selfAddress,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
         exponentCore: this.state.exponentCoreProgram,
-        admin: this.state.admin,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+        eventAuthority: this.eventAuthority,
+        program: exponentOrderbook.EXPONENTORDERBOOK_PROGRAM_ID,
+      },
+      {
+        amount,
+        index,
+      },
+    )
+    ix.keys.push(...remainingAccounts)
+    return ix
   }
 
   collectAdminEmissionCoreAccounts({
@@ -871,9 +1007,9 @@ export class Orderbook {
     emissionEscrow,
     treasuryEmissionTokenAccount,
   }: {
-    emissionDst: web3.PublicKey
-    emissionEscrow: web3.PublicKey
-    treasuryEmissionTokenAccount: web3.PublicKey
+    emissionDst: PublicKey
+    emissionEscrow: PublicKey
+    treasuryEmissionTokenAccount: PublicKey
   }): AccountInfo[] {
     return [
       {
@@ -930,24 +1066,23 @@ export class Orderbook {
   }
 
   /** Wrapper collect admin fee instruction */
-  async ixRemoveExpiredOffers({ admin }: { admin: web3.PublicKey }) {
+  ixRemoveExpiredOffers({ admin }: { admin: PublicKey }) {
     const cpiAccountOrderbook = this.pda.orderbookCpiAccounts({ orderbook: this.selfAddress })
 
     const remainingAccounts = uniqueRemainingAccounts([...this.syCpiAccounts.getSyState])
 
-    return this.orderbookProgram.methods
-      .removeExpiredOffers()
-      .accountsStrict({
-        orderbook: this.selfAddress,
-        admin,
-        eventAuthority: this.eventAuthority,
-        program: this.orderbookProgram.programId,
-        syProgram: this.state.syProgram,
-        addressLookupTable: this.state.addressLookupTable,
-        cpiAccountOrderbook: cpiAccountOrderbook,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction()
+    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({
@@ -958,7 +1093,7 @@ export class Orderbook {
     syExchangeRate,
   }: {
     priceApy?: number //? In percents!!!
-    inAmount: number
+    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
@@ -981,7 +1116,7 @@ export class Orderbook {
         const isExpired = expiryAt < unixNow
         const satisfyPriceApy = (() => {
           if (!priceApy) return true
-          if (quoteOfferType === OfferType.BuyYT) return offerPriceApy <= priceApy
+          if (quoteOfferType === OfferType.BuyYt) return offerPriceApy <= priceApy
           return offerPriceApy >= priceApy
         })()
         return type !== quoteOfferType && !isExpired && satisfyPriceApy
@@ -989,7 +1124,7 @@ export class Orderbook {
       .sort((a, b) => {
         const expiryCompare = a.expiryAt - b.expiryAt
         //? If we buyYT -- sort priceApy ascending, otherwise descending
-        if (quoteOfferType === OfferType.BuyYT) {
+        if (quoteOfferType === OfferType.BuyYt) {
           return a.priceApy - b.priceApy || expiryCompare
         }
         return b.priceApy - a.priceApy || expiryCompare
@@ -998,8 +1133,8 @@ export class Orderbook {
     let remainingAmount = inAmount
     let outAmount = 0
     let offersUsed = 0
-    let makerFees = 0;
-    let takerFees = 0;
+    let makerFees = 0
+    let takerFees = 0
     suitableOffersByType.forEach((counterOffer) => {
       if (remainingAmount <= 0) return
 
@@ -1016,7 +1151,7 @@ export class Orderbook {
           amount: remainingAmount,
           priceApy: counterOffer.priceApy,
           isVirtual: isQuoteVirtualOffer,
-          userEscrow: web3.PublicKey.default,
+          userEscrow: PublicKey.default,
           expiryAt: Infinity,
           createdAt: unixNow,
         },
@@ -1054,13 +1189,16 @@ export class Orderbook {
           offerSize,
           isQuoteVirtualOffer,
           quoteOfferType,
+          counterOffer.isVirtual,
           syExchangeRate,
           this.makerFeeRate,
+          this.takerFeeRate,
         )
 
         remainingAmount -= remainingAmountFromCounterOffer
         outAmount += outAmountFromCounterOffer.outAmount
-        makerFees += outAmountFromCounterOffer.tradeFee
+        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(
@@ -1077,13 +1215,16 @@ export class Orderbook {
           remainingAmountInCounterOfferToken,
           isQuoteVirtualOffer,
           quoteOfferType,
+          counterOffer.isVirtual,
           syExchangeRate,
           this.makerFeeRate,
+          this.takerFeeRate,
         )
 
         remainingAmount = 0
         outAmount += outAmountFromCounterOffer.outAmount
-        makerFees += outAmountFromCounterOffer.tradeFee
+        makerFees += outAmountFromCounterOffer.tradeMakerFee
+        takerFees += outAmountFromCounterOffer.tradeTakerFee
       }
 
       offersUsed++
@@ -1091,6 +1232,14 @@ export class Orderbook {
 
     //? 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),
@@ -1099,40 +1248,92 @@ export class Orderbook {
     }
   }
 
-  async depositYtAccounts({
+  depositYtAccounts({
     owner,
     ytSrc: ytSrcParam,
   }: {
-    owner: web3.PublicKey
-    ytSrc?: web3.PublicKey
-  }): Promise<web3.TransactionInstruction> {
+    owner: PublicKey
+    ytSrc?: PublicKey
+  }): TransactionInstruction {
     const ytSrc = ytSrcParam || getAssociatedTokenAddressSync(this.mintYt, owner, true, TOKEN_PROGRAM_ID)
-    const userYieldPosition = this.corePda.yieldPosition({ vault: this.state.vault, owner })
-    const yieldPosition = this.corePda.vaultYieldPosition({ vault: this.state.vault })
-    const escrowYt = this.corePda.escrowYt({ vault: this.state.vault })
-    const mainAccounts = {
-      depositor: owner,
-      ytSrc,
-      vault: this.state.vault,
-      userYieldPosition: userYieldPosition,
-      escrowYt: escrowYt,
-      tokenProgram: TOKEN_PROGRAM_ID,
-      syProgram: this.state.syProgram,
-      addressLookupTable: this.vaulLookupTable,
-      yieldPosition,
-      systemProgram: web3.SystemProgram.programId,
-      eventAuthority: this.coreEventAuthority,
-      program: this.state.exponentCoreProgram,
+    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",
     }
-    const remainingAccounts = this.syCpiAccounts.getSyState
+  }
 
-    const depositIx = await this.coreProgram.methods
-      .depositYt(new BN(0))
-      .accountsStrict(mainAccounts)
-      .remainingAccounts(remainingAccounts)
-      .instruction();
+  /**
+   * 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
+      })
+  }
 
-    return depositIx
+  /**
+   * 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
   }
 }
 
@@ -1149,5 +1350,5 @@ type DepositYtAccounts = {
     | "yieldPosition"
     | "systemProgram"
     | "eventAuthority"
-    | "program"]: web3.PublicKey
+    | "program"]: PublicKey
 }