@exponent-labs/exponent-sdk 0.1.7 → 0.1.8

package/src/orderbook/orderbook.ts

@@ -0,0 +1,1153 @@
+import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor"
+import { TOKEN_PROGRAM_ID, 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 {
+  fetchAddressLookupTable,
+  makeCoreCpiAccountMetaLists,
+  makeCpiAccountMetaLists,
+} from "../addressLookupTableUtil"
+import { Environment } from "../environment"
+import {
+  makeFlavorGenericSync,
+  makeFlavorJitoRestakingSync,
+  makeFlavorKaminoSync,
+  makeFlavorMarginfiSync,
+  makeFlavorPerenaSync,
+} from "../flavors"
+import { MyWallet } from "../market"
+import { InstructionAccounts, emitEventAuthority, uniqueRemainingAccounts } from "../utils"
+import { CollectEmissionAccounts, Vault } from "../vault"
+import {
+  MAX_FILLED_OFFERS,
+  PRICE_BASE_POINTS,
+  calcOutAmountOnCounterOfferFilling,
+  calcRemainingAmountOnCounterOfferFilling,
+  getOfferAmountToGet,
+  getOfferAmountToGetNoVirtual,
+  getOfferSize,
+  roundPriceApy,
+} from "./math"
+import { Offer, OfferOptionsAnchor, OfferType, OfferTypeAnchor, OrderbookLoadOptions, QuoteDirection } from "./types"
+import {
+  getOfferDirectionFromQuoteDirection,
+  getOfferType,
+  getOfferTypeFromTradeDirection,
+  isQuoteInputTokenBase,
+  isQuoteOutputTokenBase,
+  priceToImpliedRate,
+} from "./utils"
+import { feeRate } from "@exponent-labs/market-math"
+
+export class Orderbook {
+  private orderbookProgram: Program<ExponentOrderbook>
+  private coreProgram: Program<ExponentCore>
+
+  constructor(
+    public state: OrderbookState,
+    public selfAddress: web3.PublicKey,
+    public env: Environment,
+    public connection: web3.Connection,
+    public vaulLookupTable: web3.PublicKey,
+  ) {
+    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,
+    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)
+  }
+
+  async reload(conn: web3.Connection = this.connection) {
+    const v = await Orderbook.load(this.env, conn, this.selfAddress)
+    this.state = v.state
+    return v
+  }
+
+  get corePda() {
+    return new ExponentPDA()
+  }
+
+  get pda() {
+    return new ExponentOrderbookPDA(this.orderbookProgram.programId)
+  }
+
+  get adminPda() {
+    return new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID)
+  }
+
+  get eventAuthority() {
+    return emitEventAuthority(this.orderbookProgram.programId)
+  }
+
+  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,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+  }: {
+    trader: web3.PublicKey
+    price: number
+    amount: BN
+    offerType: OfferTypeAnchor
+    offerOption: OfferOptionsAnchor
+    virtualOffer: boolean
+    expirySeconds: number
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.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,
+    ])
+    return this.orderbookProgram.methods
+      .postOffer(impliedRate, amount, offerType, virtualOffer, expirySeconds, offerOption)
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        vault: this.state.vault,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        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()
+  }
+
+  /** Market offer instruction */
+  ixMarketOffer({
+    trader,
+    maxPriceApy,
+    amount,
+    minAmountOut,
+    offerType,
+    virtualOffer,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+  }: {
+    trader: web3.PublicKey
+    maxPriceApy: number
+    amount: BN
+    minAmountOut: BN
+    offerType: OfferTypeAnchor
+    virtualOffer: boolean
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.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,
+    ])
+    return this.orderbookProgram.methods
+      .marketOffer(impliedRate, amount, minAmountOut, offerType, virtualOffer)
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        vault: this.state.vault,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        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()
+  }
+
+  /** High trust set configuration options instruction */
+  ixSetConfigurationOptions({
+    admin,
+    configurationOptions,
+  }: {
+    admin: web3.PublicKey
+    configurationOptions: ConfigurationOptions
+  }) {
+    return this.orderbookProgram.methods
+      .setConfigurationOptions({ thresholdAmount: { 0: new BN(configurationOptions.thresholdAmount.toString()) } })
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        adminSigner: admin,
+      })
+      .instruction()
+  }
+
+  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,
+      }
+    })
+  }
+
+  /** Remove offer instruction */
+  ixRemoveOffer({
+    trader,
+    offerIdx,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+  }: {
+    trader: web3.PublicKey
+    offerIdx: number
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.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({
+        orderbook: this.selfAddress,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        syProgram: this.state.syProgram,
+        addressLookupTable: this.state.addressLookupTable,
+        cpiAccountOrderbook: cpiAccountOrderbook,
+        exponentCore: this.state.exponentCoreProgram,
+      })
+      .remainingAccounts(this.syCpiAccounts.getSyState)
+      .instruction()
+  }
+
+  /** Post offer instruction */
+  async ixWrapperPostOffer({
+    trader,
+    price,
+    amount,
+    offerType,
+    offerOption,
+    virtualOffer,
+    expirySeconds,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    trader: web3.PublicKey
+    price: number
+    amount: BN
+    offerType: OfferTypeAnchor
+    offerOption: OfferOptionsAnchor
+    virtualOffer: boolean
+    expirySeconds: number
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    tokenBaseTrader?: web3.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,
+    ])
+
+    const mintSyIx = await this.flavor.ixMintSy({
+      amountBase: "0",
+      depositor: trader,
+      depositorBaseTokenAccount: tokenBaseTrader,
+      depositorSyTokenAccount: sySrc,
+    })
+
+    const mintSyRemAccounts = mintSyIx.keys
+    return this.orderbookProgram.methods
+      .wrapperPostOffer(
+        impliedRate,
+        amount,
+        offerType,
+        virtualOffer,
+        expirySeconds,
+        offerOption,
+        mintSyRemAccounts.length - 1,
+      )
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        vault: this.state.vault,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        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()
+  }
+
+  /** Market offer instruction */
+  async ixWrapperMarketOffer({
+    trader,
+    maxPriceApy,
+    amount,
+    offerType,
+    minAmountOut,
+    virtualOffer,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    trader: web3.PublicKey
+    maxPriceApy: number
+    amount: BN
+    offerType: OfferTypeAnchor
+    minAmountOut: BN
+    virtualOffer: boolean
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    tokenBaseTrader?: web3.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,
+    ])
+
+    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 = await 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)
+        ? 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;
+    return this.orderbookProgram.methods
+      .wrapperMarketOffer(
+        impliedRate,
+        amount,
+        minAmountOut,
+        offerType,
+        virtualOffer,
+        mintSyRemAccounts.length,
+        redeem_sy_or_deposit_yt_accounts_untill,
+      )
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        vault: this.state.vault,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        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()
+  }
+
+  /** Wrapper remove offer instruction */
+  async ixWrapperRemoveOffer({
+    trader,
+    offerIdx,
+    mintSy,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    sySrc: sySrcParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    trader: web3.PublicKey
+    offerIdx: number
+    mintSy: web3.PublicKey
+    ptSrc?: web3.PublicKey
+    ytSrc?: web3.PublicKey
+    sySrc?: web3.PublicKey
+    tokenBaseTrader?: web3.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
+    return this.orderbookProgram.methods
+      .wrapperRemoveOffer(offerIdx, redeemSyIx.keys.length - 1)
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        tokenEscrowSy: this.pda.orderbookEscrowSy({ orderbook: this.selfAddress }),
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ 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,
+        syProgram: this.state.syProgram,
+        addressLookupTable: this.state.addressLookupTable,
+        cpiAccountOrderbook: cpiAccountOrderbook,
+        exponentCore: this.state.exponentCoreProgram,
+        vault: this.state.vault,
+      })
+      .remainingAccounts([...redeemSyRemAccounts, ...remainingAccounts])
+      .instruction()
+  }
+
+  /** Wrapper collect interest instruction */
+  async ixWrapperCollectInterest({
+    trader,
+    mintSy,
+    sySrc: sySrcParam,
+    tokenBaseTrader: tokenBaseTraderParam,
+  }: {
+    trader: web3.PublicKey
+    mintSy: web3.PublicKey
+    sySrc?: web3.PublicKey
+    tokenBaseTrader?: web3.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
+    return this.orderbookProgram.methods
+      .wrapperCollectInterest(redeemSyIx.keys.length - 1)
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        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,
+        syProgram: this.state.syProgram,
+        addressLookupTable: this.state.addressLookupTable,
+        cpiAccountOrderbook: cpiAccountOrderbook,
+        exponentCore: this.state.exponentCoreProgram,
+        vault: this.state.vault,
+      })
+      .remainingAccounts([...redeemSyRemAccounts, ...remainingAccounts])
+      .instruction()
+  }
+
+  /** Wrapper withdraw funds instruction */
+  async ixWrapperWithdrawFunds({
+    trader,
+    mintSy,
+    ptAmount,
+    ytAmount,
+    syAmount,
+    ptSrc: ptSrcParam,
+    ytSrc: ytSrcParam,
+    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
+  }) {
+    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,
+    ])
+
+    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,
+        trader,
+        tokenSyTrader: sySrc,
+        eventAuthority: this.eventAuthority,
+        program: this.orderbookProgram.programId,
+        syProgram: this.state.syProgram,
+        addressLookupTable: this.state.addressLookupTable,
+        cpiAccountOrderbook: cpiAccountOrderbook,
+        exponentCore: this.state.exponentCoreProgram,
+        vault: this.state.vault,
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
+        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
+        tokenYtTrader: ytSrc,
+        tokenPtTrader: ptSrc,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+  }
+
+  /** Wrapper collect admin fee instruction */
+  async ixWrapperCollectAdminFee({ admin, mintSy }: { admin: web3.PublicKey; mintSy: web3.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,
+    ])
+
+    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,
+        admin,
+        tokenSyAdmin: sySrc,
+        eventAuthority: this.eventAuthority,
+        program: this.orderbookProgram.programId,
+        syProgram: this.state.syProgram,
+        addressLookupTable: this.state.addressLookupTable,
+        cpiAccountOrderbook: cpiAccountOrderbook,
+        exponentCore: this.state.exponentCoreProgram,
+        vault: this.state.vault,
+        tokenEscrowYt: this.pda.orderbookEscrowYt({ orderbook: this.selfAddress }),
+        tokenEscrowPt: this.pda.orderbookEscrowPt({ orderbook: this.selfAddress }),
+        tokenYtAdmin: ytSrc,
+        tokenPtAdmin: ptSrc,
+      })
+      .remainingAccounts(redeemSyRemAccounts.concat(remainingAccounts))
+      .instruction()
+  }
+
+  /** Wrapper collect admin emission instruction */
+  async ixCollectAdminEmission({
+    emissionEscrow,
+    amount,
+    index,
+    treasuryEmissionTokenAccount,
+    tokenEmissionAdmin,
+  }: {
+    emissionEscrow: web3.PublicKey
+    index: number
+    amount: ClaimAmount
+    treasuryEmissionTokenAccount: web3.PublicKey
+    tokenEmissionAdmin: web3.PublicKey
+  }) {
+    const claimEmissionAccounts = this.collectAdminEmissionCoreAccounts({
+      emissionDst: tokenEmissionAdmin,
+      emissionEscrow,
+      treasuryEmissionTokenAccount,
+    })
+    const remainingAccounts = [...claimEmissionAccounts, ...this.syCpiAccounts.claimEmission[index]]
+
+    return this.orderbookProgram.methods
+      .collectAdminEmission(amount, index)
+      .accountsStrict({
+        orderbook: this.selfAddress,
+        eventAuthority: this.eventAuthority,
+        program: this.orderbookProgram.programId,
+        exponentCore: this.state.exponentCoreProgram,
+        admin: this.state.admin,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction()
+  }
+
+  collectAdminEmissionCoreAccounts({
+    emissionDst,
+    emissionEscrow,
+    treasuryEmissionTokenAccount,
+  }: {
+    emissionDst: web3.PublicKey
+    emissionEscrow: web3.PublicKey
+    treasuryEmissionTokenAccount: web3.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 */
+  async ixRemoveExpiredOffers({ admin }: { admin: web3.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()
+  }
+
+  getQuote({
+    priceApy: rawPriceApy,
+    inAmount: inAmountRaw,
+    direction,
+    unixNow,
+    syExchangeRate,
+  }: {
+    priceApy?: number //? In percents!!!
+    inAmount: number
+    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: web3.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,
+          syExchangeRate,
+          this.makerFeeRate,
+        )
+
+        remainingAmount -= remainingAmountFromCounterOffer
+        outAmount += outAmountFromCounterOffer.outAmount
+        makerFees += outAmountFromCounterOffer.tradeFee
+      } 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,
+          syExchangeRate,
+          this.makerFeeRate,
+        )
+
+        remainingAmount = 0
+        outAmount += outAmountFromCounterOffer.outAmount
+        makerFees += outAmountFromCounterOffer.tradeFee
+      }
+
+      offersUsed++
+    })
+
+    //? If output is in base, convert SY to Base
+    const outAmountAdjusted = isQuoteOutputTokenBase(direction) ? outAmount * syExchangeRate : outAmount
+
+    return {
+      outAmount: Math.floor(outAmountAdjusted),
+      makerFees: Math.floor(makerFees),
+      takerFees: Math.floor(takerFees),
+    }
+  }
+
+  async depositYtAccounts({
+    owner,
+    ytSrc: ytSrcParam,
+  }: {
+    owner: web3.PublicKey
+    ytSrc?: web3.PublicKey
+  }): Promise<web3.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 remainingAccounts = this.syCpiAccounts.getSyState
+
+    const depositIx = await this.coreProgram.methods
+      .depositYt(new BN(0))
+      .accountsStrict(mainAccounts)
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+
+    return depositIx
+  }
+}
+
+type DepositYtAccounts = {
+  [K in
+    | "depositor"
+    | "vault"
+    | "userYieldPosition"
+    | "ytSrc"
+    | "escrowYt"
+    | "tokenProgram"
+    | "syProgram"
+    | "addressLookupTable"
+    | "yieldPosition"
+    | "systemProgram"
+    | "eventAuthority"
+    | "program"]: web3.PublicKey
+}