@exponent-labs/exponent-sdk 0.1.7 → 0.1.8

package/src/orderbook/types.ts

@@ -0,0 +1,45 @@
+import { web3 } from "@coral-xyz/anchor"
+
+export type OrderbookLoadOptions = {
+  syConfig?: {
+    skipWrap?: boolean
+  }
+}
+
+type EmptyObject = Record<never, never>
+export type OfferTypeAnchor = { buyYt: EmptyObject; sellYt?: never } | { sellYt: EmptyObject; buyYt?: never }
+
+export type OfferOptionsAnchor = { fillOrKill: { "0": boolean } }
+
+export enum OfferType {
+  SellYT = 1,
+  BuyYT = 2,
+}
+
+export type Offer = {
+  type: OfferType
+  priceApy: number
+  amount: number
+  userEscrow: web3.PublicKey
+  expiryAt: number
+  createdAt: number
+  isVirtual: boolean
+}
+
+export enum OfferTradeDirection {
+  SY_TO_YT,
+  SY_TO_PT,
+  YT_TO_SY,
+  PT_TO_SY,
+}
+
+export enum QuoteDirection {
+  BASE_TO_YT,
+  BASE_TO_PT,
+  YT_TO_BASE,
+  PT_TO_BASE,
+  SY_TO_YT,
+  SY_TO_PT,
+  YT_TO_SY,
+  PT_TO_SY,
+}

package/src/orderbook/utils.ts

@@ -0,0 +1,74 @@
+import { OfferType, OfferTradeDirection, OfferTypeAnchor, QuoteDirection } from "./types"
+
+/**
+ * Get offer type by offer.orderTypeFlag value
+ */
+export function getOfferType(orderTypeFlag: number): OfferType {
+  return orderTypeFlag === 1 ? OfferType.SellYT : OfferType.BuyYT
+}
+
+/**
+ * Get price in percents and cast it to implied rate
+ */
+export function priceToImpliedRate(price: number): number {
+  return Math.log(1 + price / 100)
+}
+
+export function getOfferTypeFromTradeDirection(tradeDirection: OfferTradeDirection): {
+  offerType: OfferType
+  isVirtual: boolean
+} {
+  const isVirtual = tradeDirection === OfferTradeDirection.PT_TO_SY || tradeDirection === OfferTradeDirection.SY_TO_PT
+
+  const offerType: OfferType = (() => {
+    if (tradeDirection === OfferTradeDirection.SY_TO_YT || tradeDirection === OfferTradeDirection.PT_TO_SY) {
+      return OfferType.BuyYT
+    } else {
+      return OfferType.SellYT
+    }
+  })()
+
+  return {
+    isVirtual,
+    offerType,
+  }
+}
+
+export function convertOfferTypeToAnchorType(offerType: OfferType): OfferTypeAnchor {
+  return offerType === OfferType.BuyYT ? { buyYt: {} } : { sellYt: {} }
+}
+
+export function convertOfferTypeFromAnchorType(offerTypeAnchor: OfferTypeAnchor): OfferType {
+  return offerTypeAnchor?.buyYt ? OfferType.BuyYT : OfferType.SellYT
+}
+
+export function getOfferDirectionFromQuoteDirection(direction: QuoteDirection): OfferTradeDirection {
+  switch (direction) {
+    case QuoteDirection.BASE_TO_YT:
+      return OfferTradeDirection.SY_TO_YT
+    case QuoteDirection.BASE_TO_PT:
+      return OfferTradeDirection.SY_TO_PT
+    case QuoteDirection.YT_TO_BASE:
+      return OfferTradeDirection.YT_TO_SY
+    case QuoteDirection.PT_TO_BASE:
+      return OfferTradeDirection.PT_TO_SY
+    case QuoteDirection.SY_TO_YT:
+      return OfferTradeDirection.SY_TO_YT
+    case QuoteDirection.SY_TO_PT:
+      return OfferTradeDirection.SY_TO_PT
+    case QuoteDirection.YT_TO_SY:
+      return OfferTradeDirection.YT_TO_SY
+    case QuoteDirection.PT_TO_SY:
+      return OfferTradeDirection.PT_TO_SY
+    default:
+      throw new Error(`Unable to determine offer direction from quote direction: ${direction}`)
+  }
+}
+
+export function isQuoteInputTokenBase(direction: QuoteDirection): boolean {
+  return direction === QuoteDirection.BASE_TO_YT || direction === QuoteDirection.BASE_TO_PT
+}
+
+export function isQuoteOutputTokenBase(direction: QuoteDirection): boolean {
+  return direction === QuoteDirection.YT_TO_BASE || direction === QuoteDirection.PT_TO_BASE
+}

package/src/router.ts

@@ -0,0 +1,360 @@
+import { web3 } from "@coral-xyz/anchor"
+
+import { ExponentFetcher, MarketThree, Ticks } from "@exponent-labs/exponent-fetcher"
+import {
+  QuoteDirection as ClmmQuoteDirection,
+  MarketThreeState,
+  getSwapQuote as getClmmSwapQuote,
+} from "@exponent-labs/market-three-math"
+
+import { Environment } from "./environment"
+import { Market, MarketLoadOptions } from "./market"
+import { Orderbook, OrderbookLoadOptions, QuoteDirection as OrderbookQuoteDirection } from "./orderbook"
+import { Vault } from "./vault"
+
+export class Router {
+  private legacyMarkets: Market[]
+  private orderbooks: Orderbook[]
+  private clmmsWithTicks: ClmmWithTicks[]
+  //? For possible future use inside refetch functionality
+  private vault: Vault | null
+  private connection: web3.Connection
+
+  /**
+   * Use the constructor if markets are already initialized in your app
+   */
+  constructor(
+    connection: web3.Connection,
+    markets: { legacyMarkets?: Market[]; orderbooks?: Orderbook[]; clmmsWithTicks?: ClmmWithTicks[] },
+    vault?: Vault,
+  ) {
+    this.connection = connection
+
+    this.legacyMarkets = markets.legacyMarkets ?? []
+    this.orderbooks = markets.orderbooks ?? []
+    this.clmmsWithTicks = markets.clmmsWithTicks ?? []
+
+    this.vault = vault ?? null
+  }
+
+  /**
+   * Use the load method if you don't have already loaded markets in your app
+   */
+  public static async load(
+    connection: web3.Connection,
+    args: {
+      vault?: Vault
+      env: Environment
+      legacyMarketsParams?: {
+        address: web3.PublicKey
+        options?: MarketLoadOptions
+      }[]
+      orderbookParams?: {
+        address: web3.PublicKey
+        options?: OrderbookLoadOptions
+      }[]
+      clmmParams?: {
+        marketThreeAddress: web3.PublicKey
+      }[]
+    },
+  ): Promise<Router> {
+    const { vault, legacyMarketsParams = [], orderbookParams = [], clmmParams = [], env } = args
+
+    const legacyMarketsPromises = this.fetchLegacyMarkets(connection, { env, vault, legacyMarketsParams })
+
+    const orderbooksPromises = this.fetchOrderbooks(connection, { env, vault, orderbookParams })
+
+    const clmmsWithTicksPromises = this.fetchClmmsWithTicks(
+      connection,
+      clmmParams.map(({ marketThreeAddress }) => marketThreeAddress),
+    )
+
+    const [legacyMarkets, orderbooks, clmmsWithTicks] = await Promise.all([
+      legacyMarketsPromises,
+      orderbooksPromises,
+      clmmsWithTicksPromises,
+    ])
+
+    return new Router(
+      connection,
+      { legacyMarkets: legacyMarkets, orderbooks: orderbooks, clmmsWithTicks: clmmsWithTicks },
+      args.vault,
+    )
+  }
+
+  /**
+   * Refreshes the states of all markets, orderbooks and CLMMs
+   */
+  public async refresh(): Promise<Router> {
+    const legacyMarkets = await Promise.all(this.legacyMarkets.map((market) => market.reload(this.connection)))
+
+    const orderbooks = await Promise.all(this.orderbooks.map((orderbook) => orderbook.reload(this.connection)))
+
+    const clmmsWithTicks = await Router.fetchClmmsWithTicks(
+      this.connection,
+      this.clmmsWithTicks.map((clmmWithTicks) => clmmWithTicks.marketThree.selfAddress),
+    )
+
+    return new Router(
+      this.connection,
+      { legacyMarkets: legacyMarkets, orderbooks: orderbooks, clmmsWithTicks: clmmsWithTicks },
+      this.vault,
+    )
+  }
+
+  public getQuote(params: { direction: RouterQuoteDirection; inAmount: number; syExchangeRate: number }): Quote | null {
+    //? Better to refetch market and orderbook states before every call or trigger reload method here
+    const { direction, inAmount, syExchangeRate } = params
+
+    const marketQuotes = this.legacyMarkets.map((market) => this.getLegacyMarketQuote({ market, direction, inAmount }))
+    const orderbookQuotes = this.orderbooks.map((orderbook) =>
+      this.getOrderbookQuote({ orderbook, direction, inAmount, syExchangeRate }),
+    )
+    const clmmQuotes = this.clmmsWithTicks.map((clmmWithTicks) =>
+      this.getClmmQuote({ clmmWithTicks, syExchangeRate, direction, inAmount }),
+    )
+
+    const bestQuote: Quote | null =
+      [...marketQuotes, ...orderbookQuotes, ...clmmQuotes]
+        .filter(({ outAmount }) => outAmount > 0)
+        .sort((a, b) => b.outAmount - a.outAmount)
+        .at(0) ?? null
+
+    return bestQuote
+  }
+
+  static async fetchLegacyMarkets(
+    connection: web3.Connection,
+    args: {
+      env: Environment
+      vault?: Vault
+      legacyMarketsParams: {
+        address: web3.PublicKey
+        options?: MarketLoadOptions
+      }[]
+    },
+  ): Promise<Market[]> {
+    return await Promise.all(
+      args.legacyMarketsParams.map((market) =>
+        Market.load(args.env, connection, market.address, args.vault, market.options),
+      ),
+    )
+  }
+
+  static async fetchOrderbooks(
+    connection: web3.Connection,
+    args: {
+      env: Environment
+      vault?: Vault
+      orderbookParams: {
+        address: web3.PublicKey
+        options?: OrderbookLoadOptions
+      }[]
+    },
+  ): Promise<Orderbook[]> {
+    return await Promise.all(
+      args.orderbookParams.map((orderbook) =>
+        Orderbook.load(args.env, connection, orderbook.address, orderbook.options, args.vault),
+      ),
+    )
+  }
+
+  static async fetchClmmsWithTicks(
+    connection: web3.Connection,
+    clmmAddresses: web3.PublicKey[],
+  ): Promise<{ marketThree: MarketThree; ticks: Ticks }[]> {
+    const fetchClmmWithTicks = async (marketThreeAddress: web3.PublicKey) => {
+      const xponFetcher = new ExponentFetcher({ connection })
+      const marketThree = await xponFetcher.fetchMarketThree(marketThreeAddress)
+      const ticks = await xponFetcher.fetchMarketThreeTicks(marketThree.ticks)
+
+      return { marketThree, ticks }
+    }
+
+    return await Promise.all(clmmAddresses.map((address) => fetchClmmWithTicks(address)))
+  }
+
+  private getLegacyMarketQuote(params: { market: Market; direction: RouterQuoteDirection; inAmount: number }): Quote {
+    const { direction, inAmount, market } = params
+
+    const marketCalculator = market.marketCalculator()
+
+    if (direction === RouterQuoteDirection.BASE_TO_YT) {
+      const { ytOut, feeInAsset } = marketCalculator.estimateYtOutForExactAssetIn(inAmount)
+      return {
+        outAmount: ytOut,
+        feesInOutToken: feeInAsset,
+        source: RouterTradeSource.MARKET,
+        sourceAddress: market.selfAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.BASE_TO_PT) {
+      const ptOut = marketCalculator.estimateNetPtForExactNetAsset(inAmount)
+      const { feeAsset, netTraderPt } = marketCalculator.calcTradePt(ptOut, false)
+      return {
+        outAmount: netTraderPt,
+        feesInOutToken: feeAsset,
+        source: RouterTradeSource.MARKET,
+        sourceAddress: market.selfAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.PT_TO_BASE) {
+      const { feeAsset, netTraderAsset } = marketCalculator.calcTradePt(inAmount * -1)
+      return {
+        outAmount: netTraderAsset,
+        feesInOutToken: feeAsset,
+        source: RouterTradeSource.MARKET,
+        sourceAddress: market.selfAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.YT_TO_BASE) {
+      const { feeInAsset, assetOut } = marketCalculator.simSellYt(inAmount)
+      return {
+        outAmount: assetOut,
+        feesInOutToken: feeInAsset,
+        source: RouterTradeSource.MARKET,
+        sourceAddress: market.selfAddress,
+      }
+    }
+
+    throw new Error(`Unknown quote direction: ${direction}`)
+  }
+
+  private getOrderbookQuote(params: {
+    orderbook: Orderbook
+    direction: RouterQuoteDirection
+    inAmount: number
+    syExchangeRate: number
+  }): Quote {
+    const { direction, inAmount, orderbook, syExchangeRate } = params
+
+    const unixNow = Math.round(Date.now() / 1000)
+    const { outAmount, takerFees } = orderbook.getQuote({
+      inAmount,
+      unixNow,
+      direction: castToOrderbookQuoteDirection(direction),
+      syExchangeRate,
+    })
+
+    return {
+      outAmount: outAmount,
+      feesInOutToken: takerFees,
+      source: RouterTradeSource.ORDERBOOK,
+      sourceAddress: orderbook.selfAddress,
+    }
+  }
+
+  private getClmmQuote(params: {
+    clmmWithTicks: ClmmWithTicks
+    syExchangeRate: number
+    direction: RouterQuoteDirection
+    inAmount: number
+  }): Quote {
+    const { clmmWithTicks, syExchangeRate, inAmount, direction } = params
+    const sourceAddress = clmmWithTicks.marketThree.selfAddress
+
+    const marketThreeState: MarketThreeState = {
+      financials: clmmWithTicks.marketThree.financials,
+      configurationOptions: clmmWithTicks.marketThree.configurationOptions,
+      ticks: clmmWithTicks.ticks,
+      currentSyExchangeRate: syExchangeRate,
+    }
+
+    if (direction === RouterQuoteDirection.BASE_TO_PT) {
+      const syInAmount = inAmount / syExchangeRate
+
+      const { amountOut, lpFee, protocolFee } = getClmmSwapQuote(
+        marketThreeState,
+        syInAmount,
+        ClmmQuoteDirection.SyToPt,
+      )
+      return {
+        outAmount: amountOut,
+        feesInOutToken: lpFee + protocolFee,
+        source: RouterTradeSource.CLMM,
+        sourceAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.PT_TO_BASE) {
+      const { amountOut, lpFee, protocolFee } = getClmmSwapQuote(marketThreeState, inAmount, ClmmQuoteDirection.PtToSy)
+
+      const baseOutAmount = amountOut * syExchangeRate
+
+      return {
+        outAmount: baseOutAmount,
+        feesInOutToken: lpFee + protocolFee,
+        source: RouterTradeSource.CLMM,
+        sourceAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.BASE_TO_YT) {
+      const syInAmount = inAmount / syExchangeRate
+      const { amountOut, lpFee, protocolFee } = getClmmSwapQuote(
+        marketThreeState,
+        syInAmount,
+        ClmmQuoteDirection.SyToYt,
+      )
+
+      return {
+        outAmount: amountOut,
+        feesInOutToken: lpFee + protocolFee,
+        source: RouterTradeSource.CLMM,
+        sourceAddress,
+      }
+    }
+
+    if (direction === RouterQuoteDirection.YT_TO_BASE) {
+      const { amountOut, lpFee, protocolFee } = getClmmSwapQuote(marketThreeState, inAmount, ClmmQuoteDirection.YtToSy)
+      const baseOutAmount = amountOut * syExchangeRate
+      return {
+        outAmount: baseOutAmount,
+        feesInOutToken: lpFee + protocolFee,
+        source: RouterTradeSource.CLMM,
+        sourceAddress,
+      }
+    }
+
+    throw new Error(`Unknown quote direction: ${direction}`)
+  }
+}
+
+export type ClmmWithTicks = {
+  marketThree: MarketThree
+  ticks: Ticks
+}
+
+export type Quote = {
+  outAmount: number
+  feesInOutToken: number
+  source: RouterTradeSource
+  sourceAddress: web3.PublicKey
+}
+
+/**
+ * As orderbook supports more trade directions than market, we need to cast it for type safety
+ */
+function castToOrderbookQuoteDirection(direction: RouterQuoteDirection): OrderbookQuoteDirection {
+  if (direction === RouterQuoteDirection.BASE_TO_YT) return OrderbookQuoteDirection.BASE_TO_YT
+  if (direction === RouterQuoteDirection.BASE_TO_PT) return OrderbookQuoteDirection.BASE_TO_PT
+  if (direction === RouterQuoteDirection.YT_TO_BASE) return OrderbookQuoteDirection.YT_TO_BASE
+  if (direction === RouterQuoteDirection.PT_TO_BASE) return OrderbookQuoteDirection.PT_TO_BASE
+  throw new Error("Unknown quote direction")
+}
+
+export enum RouterTradeSource {
+  MARKET = "MARKET",
+  ORDERBOOK = "ORDERBOOK",
+  CLMM = "CLMM",
+}
+
+export enum RouterQuoteDirection {
+  BASE_TO_YT,
+  BASE_TO_PT,
+  YT_TO_BASE,
+  PT_TO_BASE,
+}

package/src/syPosition.ts

@@ -168,6 +168,10 @@ async function makeSyPositionGeneric(
     interfaceIndex = 11 // InterfaceType.KaminoVault
   } else if ("solstice" in interfaceType) {
     interfaceIndex = 12 // InterfaceType.Solstice
+  } else if ("reflect" in interfaceType) {
+    interfaceIndex = 13 // InterfaceType.Reflect
+  } else if ("ore" in interfaceType) {
+    interfaceIndex = 14 // InterfaceType.Ore
   } else {
     throw new Error("Unsupported interface type")
   }

package/src/utils/index.ts

@@ -1,8 +1,8 @@
-import { web3 } from "@coral-xyz/anchor"
+import { Program as AnchorProgram, AnchorProvider, Idl, web3 } from "@coral-xyz/anchor"
 
 import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
 
-export { InstructionAccounts } from "./ix"
+export type { InstructionAccounts } from "./ix"
 
 export function uniqueRemainingAccounts(xs: web3.AccountMeta[]): web3.AccountMeta[] {
   const seen: Record<string, web3.AccountMeta> = {}
@@ -32,3 +32,28 @@ export function getExponentAdminStatePda() {
   const exponentAdminPda = new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID)
   return exponentAdminPda.exponentAdmin()
 }
+
+// Browser-compatible mock wallet for creating anchor programs
+class MockWallet {
+  constructor(readonly payer: web3.Keypair) {}
+
+  async signTransaction<T extends web3.Transaction | web3.VersionedTransaction>(tx: T): Promise<T> {
+    return tx
+  }
+
+  async signAllTransactions<T extends web3.Transaction | web3.VersionedTransaction>(txs: T[]): Promise<T[]> {
+    return txs
+  }
+
+  get publicKey(): web3.PublicKey {
+    return this.payer.publicKey
+  }
+}
+
+export function createAnchorProgram<IDL extends Idl = Idl>(idl: IDL) {
+  const mockProvider = new AnchorProvider(
+    new web3.Connection(web3.clusterApiUrl("devnet")),
+    new MockWallet(web3.Keypair.generate()) as any,
+  )
+  return new AnchorProgram<IDL>(idl, mockProvider)
+}