@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/exponentVaults/pricePathResolver.test.ts

@@ -1,466 +0,0 @@
-import { describe, expect, it } from "@jest/globals"
-import { PublicKey } from "@solana/web3.js"
-import type { ExponentPrice, ExponentPrices } from "@exponent-labs/exponent-vaults-fetcher"
-import {
-  extractPriceIds,
-  resolveExponentPricePath,
-  resolveBestKaminoQuotePath,
-  resolveKaminoReservePriceIdOrThrow,
-  resolvePriceIdFromMintToUnderlying,
-  resolvePriceIdFromMintToUnderlyingOrThrow,
-  getPriceInputMintFromPriceId,
-} from "./pricePathResolver"
-
-// ============================================================================
-// Test helpers
-// ============================================================================
-
-/** Create a deterministic PublicKey from a seed byte. */
-function pk(seed: number): PublicKey {
-  return new PublicKey(Uint8Array.from({ length: 32 }, () => seed))
-}
-
-/** Named mints for readability. */
-const USDC = pk(1)
-const SOL = pk(2)
-const PT_SOL = pk(3)
-const USDT = pk(6)
-const BSOL = pk(8)
-const PT_BSOL = pk(9)
-
-function makePriceEntry(params: {
-  priceId: bigint
-  priceMint: PublicKey
-  underlyingMint: PublicKey
-}): ExponentPrice {
-  return {
-    priceId: params.priceId,
-    priceMint: params.priceMint,
-    underlyingMint: params.underlyingMint,
-    price: [[0n, 0n, 0n, 0n]],
-    positionsAmount: 0n,
-    lastUpdatedAt: 0n,
-    lastUpdatedSlot: 0n,
-    priceType: 0,
-    impliedApyBps: null,
-    impliedApy: null,
-    priceInterfaceAccounts: PublicKey.default,
-    interfaceAccounts: [],
-  } as unknown as ExponentPrice
-}
-
-function makePrices(entries: ExponentPrice[]): ExponentPrices {
-  return {
-    managers: [],
-    prices: entries,
-  } as unknown as ExponentPrices
-}
-
-// ============================================================================
-// resolveExponentPricePath — BFS core
-// ============================================================================
-
-describe("resolveExponentPricePath", () => {
-  it("resolves a direct 1-hop path (PT_SOL → SOL)", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: PT_SOL, underlyingMint: SOL }),
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_SOL, SOL)
-
-    expect(path).not.toBeNull()
-    expect(path!.sourceMint.equals(PT_SOL)).toBe(true)
-    expect(path!.targetMint.equals(SOL)).toBe(true)
-    expect(path!.edges).toHaveLength(1)
-    expect(path!.edges[0].priceId).toBe(1n)
-    expect(path!.mints).toHaveLength(2)
-  })
-
-  it("resolves a 2-hop path (PT_SOL → SOL → USDC)", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: PT_SOL, underlyingMint: SOL }),
-      makePriceEntry({ priceId: 2n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_SOL, USDC)
-
-    expect(path).not.toBeNull()
-    expect(path!.edges).toHaveLength(2)
-    expect(path!.mints).toHaveLength(3)
-    expect(path!.mints[0].equals(PT_SOL)).toBe(true)
-    expect(path!.mints[1].equals(SOL)).toBe(true)
-    expect(path!.mints[2].equals(USDC)).toBe(true)
-  })
-
-  it("resolves a 3-hop path (PT_BSOL → BSOL → SOL → USDC)", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: PT_BSOL, underlyingMint: BSOL }),
-      makePriceEntry({ priceId: 2n, priceMint: BSOL, underlyingMint: SOL }),
-      makePriceEntry({ priceId: 3n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_BSOL, USDC)
-
-    expect(path).not.toBeNull()
-    expect(path!.edges).toHaveLength(3)
-    expect(path!.mints[0].equals(PT_BSOL)).toBe(true)
-    expect(path!.mints[1].equals(BSOL)).toBe(true)
-    expect(path!.mints[2].equals(SOL)).toBe(true)
-    expect(path!.mints[3].equals(USDC)).toBe(true)
-  })
-
-  it("returns null when no path exists", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: PT_SOL, underlyingMint: SOL }),
-      // No edge from SOL to USDC — disconnected
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_SOL, USDC)
-
-    expect(path).toBeNull()
-  })
-
-  it("returns null for empty price graph", () => {
-    const prices = makePrices([])
-    expect(resolveExponentPricePath(prices, PT_SOL, SOL)).toBeNull()
-  })
-
-  it("finds the shortest path when multiple paths exist", () => {
-    const prices = makePrices([
-      // Direct: PT_SOL → USDC (1 hop)
-      makePriceEntry({ priceId: 10n, priceMint: PT_SOL, underlyingMint: USDC }),
-      // Indirect: PT_SOL → SOL → USDC (2 hops)
-      makePriceEntry({ priceId: 1n, priceMint: PT_SOL, underlyingMint: SOL }),
-      makePriceEntry({ priceId: 2n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_SOL, USDC)
-
-    // BFS finds shortest first
-    expect(path).not.toBeNull()
-    expect(path!.edges).toHaveLength(1)
-    expect(path!.edges[0].priceId).toBe(10n)
-  })
-
-  it("handles cycles in the graph without infinite loop", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: SOL, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 2n, priceMint: USDC, underlyingMint: SOL }), // Cycle
-      makePriceEntry({ priceId: 3n, priceMint: PT_SOL, underlyingMint: SOL }),
-    ])
-
-    const path = resolveExponentPricePath(prices, PT_SOL, USDC)
-
-    expect(path).not.toBeNull()
-    expect(path!.edges).toHaveLength(2)
-  })
-})
-
-// ============================================================================
-// resolvePriceIdFromMintToUnderlying — PriceId construction
-// ============================================================================
-
-describe("resolvePriceIdFromMintToUnderlying", () => {
-  it("returns Simple PriceId for a 1-hop path", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 7n, priceMint: PT_SOL, underlyingMint: SOL }),
-    ])
-
-    const resolved = resolvePriceIdFromMintToUnderlyingOrThrow({
-      prices,
-      sourceMint: PT_SOL,
-      targetMint: SOL,
-      label: "test",
-    })
-
-    expect(resolved.__kind).toBe("Simple")
-    expect(extractPriceIds(resolved)).toEqual([7n])
-  })
-
-  it("returns Multiply PriceId for a 2-hop path in underlying-to-input order", () => {
-    // Path: PT_SOL → SOL → USDC
-    // Edges: [edge(12n, PT_SOL→SOL), edge(11n, SOL→USDC)]
-    // On-chain expects: multiply prices from underlying→input, so reversed: [11n, 12n]
-    const prices = makePrices([
-      makePriceEntry({ priceId: 11n, priceMint: SOL, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 12n, priceMint: PT_SOL, underlyingMint: SOL }),
-    ])
-
-    const resolved = resolvePriceIdFromMintToUnderlyingOrThrow({
-      prices,
-      sourceMint: PT_SOL,
-      targetMint: USDC,
-      label: "test",
-    })
-
-    expect(resolved.__kind).toBe("Multiply")
-    // On-chain validates: first entry's underlying_mint = vault underlying (USDC)
-    // Then chains: USDC ← SOL ← PT_SOL
-    expect(extractPriceIds(resolved)).toEqual([11n, 12n])
-  })
-
-  it("returns Multiply PriceId for a 3-hop path", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: PT_BSOL, underlyingMint: BSOL }),
-      makePriceEntry({ priceId: 2n, priceMint: BSOL, underlyingMint: SOL }),
-      makePriceEntry({ priceId: 3n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const resolved = resolvePriceIdFromMintToUnderlyingOrThrow({
-      prices,
-      sourceMint: PT_BSOL,
-      targetMint: USDC,
-      label: "test",
-    })
-
-    expect(resolved.__kind).toBe("Multiply")
-    // Reversed edge order: [3n (SOL→USDC), 2n (BSOL→SOL), 1n (PT_BSOL→BSOL)]
-    expect(extractPriceIds(resolved)).toEqual([3n, 2n, 1n])
-  })
-
-  it("returns null when no path exists", () => {
-    const prices = makePrices([])
-    const resolved = resolvePriceIdFromMintToUnderlying(prices, PT_SOL, SOL)
-    expect(resolved).toBeNull()
-  })
-
-  it("throws with descriptive error when path is missing (OrThrow variant)", () => {
-    const prices = makePrices([])
-
-    expect(() =>
-      resolvePriceIdFromMintToUnderlyingOrThrow({
-        prices,
-        sourceMint: PT_SOL,
-        targetMint: SOL,
-        label: "test label",
-      })
-    ).toThrow(`Missing Exponent price path for test label: ${PT_SOL.toBase58()} -> ${SOL.toBase58()}`)
-  })
-})
-
-// ============================================================================
-// resolveBestKaminoQuotePath — Kamino quote mint selection
-// ============================================================================
-
-describe("resolveBestKaminoQuotePath", () => {
-  it("always uses vault underlying as the quote mint", () => {
-    // USDC vault — quote should be USDC itself via the One price entry
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: USDC, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 2n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const result = resolveBestKaminoQuotePath({
-      prices,
-      vaultUnderlyingMint: USDC,
-    })
-
-    expect(result.quoteInputMint.equals(USDC)).toBe(true)
-    expect(extractPriceIds(result.quotePriceId)).toEqual([1n])
-  })
-
-  it("works for a SOL vault with a SOL→SOL identity entry", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 3n, priceMint: SOL, underlyingMint: SOL }),
-    ])
-
-    const result = resolveBestKaminoQuotePath({
-      prices,
-      vaultUnderlyingMint: SOL,
-    })
-
-    expect(result.quoteInputMint.equals(SOL)).toBe(true)
-    expect(extractPriceIds(result.quotePriceId)).toEqual([3n])
-  })
-
-  it("throws when no identity price exists for vault underlying", () => {
-    const prices = makePrices([])
-
-    expect(() =>
-      resolveBestKaminoQuotePath({
-        prices,
-        vaultUnderlyingMint: USDC,
-      })
-    ).toThrow("Missing Exponent price path for Kamino quote resolution")
-  })
-})
-
-// ============================================================================
-// resolveKaminoReservePriceIdOrThrow — reserve-to-quote mapping
-// ============================================================================
-
-describe("resolveKaminoReservePriceIdOrThrow", () => {
-  it("returns identity (Simple 0) when reserve mint equals quote mint", () => {
-    const prices = makePrices([])
-
-    const result = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: USDC,
-      quoteInputMint: USDC,
-    })
-
-    expect(result.__kind).toBe("Simple")
-    expect(extractPriceIds(result)).toEqual([0n])
-  })
-
-  it("resolves reserve → quote when they differ", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 5n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const result = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: SOL,
-      quoteInputMint: USDC,
-    })
-
-    expect(extractPriceIds(result)).toEqual([5n])
-  })
-
-  it("throws when reserve cannot reach quote", () => {
-    const prices = makePrices([])
-
-    expect(() =>
-      resolveKaminoReservePriceIdOrThrow({
-        prices,
-        reserveMint: SOL,
-        quoteInputMint: USDC,
-      })
-    ).toThrow("Missing Exponent price path for Kamino reserve mapping")
-  })
-})
-
-// ============================================================================
-// Kamino end-to-end: quote selection + reserve mapping
-// ============================================================================
-
-describe("Kamino end-to-end price resolution", () => {
-  it("resolves a SOL vault with SOL and USDC reserves", () => {
-    // SOL vault: underlying = SOL
-    // Reserves: SOL (passthrough), USDC (needs USDC→SOL price)
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: SOL, underlyingMint: SOL }),
-      makePriceEntry({ priceId: 2n, priceMint: USDC, underlyingMint: SOL }),
-    ])
-
-    // Quote is always vault underlying
-    const quotePath = resolveBestKaminoQuotePath({
-      prices,
-      vaultUnderlyingMint: SOL,
-    })
-    expect(quotePath.quoteInputMint.equals(SOL)).toBe(true)
-
-    // SOL reserve → SOL quote: passthrough
-    const solReservePrice = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: SOL,
-      quoteInputMint: quotePath.quoteInputMint,
-    })
-    expect(extractPriceIds(solReservePrice)).toEqual([0n])
-
-    // USDC reserve → SOL quote: needs the USDC→SOL price
-    const usdcReservePrice = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: USDC,
-      quoteInputMint: quotePath.quoteInputMint,
-    })
-    expect(extractPriceIds(usdcReservePrice)).toEqual([2n])
-  })
-
-  it("resolves a USDC vault with BSOL needing a Multiply chain", () => {
-    // USDC vault: underlying = USDC
-    // BSOL reserve needs BSOL → SOL → USDC (two hops)
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: USDC, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 2n, priceMint: SOL, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 3n, priceMint: BSOL, underlyingMint: SOL }),
-    ])
-
-    const quotePath = resolveBestKaminoQuotePath({
-      prices,
-      vaultUnderlyingMint: USDC,
-    })
-    expect(quotePath.quoteInputMint.equals(USDC)).toBe(true)
-
-    // BSOL → USDC requires chaining: Multiply [SOL→USDC, BSOL→SOL]
-    const bsolReservePrice = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: BSOL,
-      quoteInputMint: quotePath.quoteInputMint,
-    })
-    expect(extractPriceIds(bsolReservePrice)).toEqual([2n, 3n])
-
-    // USDC → USDC: passthrough
-    const usdcReservePrice = resolveKaminoReservePriceIdOrThrow({
-      prices,
-      reserveMint: USDC,
-      quoteInputMint: quotePath.quoteInputMint,
-    })
-    expect(extractPriceIds(usdcReservePrice)).toEqual([0n])
-  })
-})
-
-// ============================================================================
-// extractPriceIds — parsing
-// ============================================================================
-
-describe("extractPriceIds", () => {
-  it("extracts from Simple (__kind format)", () => {
-    expect(extractPriceIds({ __kind: "Simple", priceId: 42n })).toEqual([42n])
-  })
-
-  it("extracts from Multiply (__kind format)", () => {
-    expect(extractPriceIds({ __kind: "Multiply", priceIds: [1n, 2n, 3n] })).toEqual([1n, 2n, 3n])
-  })
-
-  it("extracts from Simple (nested format)", () => {
-    expect(extractPriceIds({ simple: { priceId: 42n } })).toEqual([42n])
-  })
-
-  it("extracts from Multiply (nested format)", () => {
-    expect(extractPriceIds({ multiply: { priceIds: [1n, 2n, 3n] } })).toEqual([1n, 2n, 3n])
-  })
-
-  it("handles number priceIds in nested format", () => {
-    expect(extractPriceIds({ simple: { priceId: 42 } })).toEqual([42n])
-  })
-
-  it("throws for invalid shapes", () => {
-    expect(() => extractPriceIds(null)).toThrow("Invalid PriceId")
-    expect(() => extractPriceIds({})).toThrow("Unsupported PriceId shape")
-  })
-})
-
-// ============================================================================
-// getPriceInputMintFromPriceId — reverse lookup
-// ============================================================================
-
-describe("getPriceInputMintFromPriceId", () => {
-  it("returns the priceMint of the last price in a Simple PriceId", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 5n, priceMint: SOL, underlyingMint: USDC }),
-    ])
-
-    const mint = getPriceInputMintFromPriceId(prices, { __kind: "Simple", priceId: 5n })
-    expect(mint.equals(SOL)).toBe(true)
-  })
-
-  it("returns the priceMint of the last price in a Multiply PriceId", () => {
-    const prices = makePrices([
-      makePriceEntry({ priceId: 1n, priceMint: SOL, underlyingMint: USDC }),
-      makePriceEntry({ priceId: 2n, priceMint: PT_SOL, underlyingMint: SOL }),
-    ])
-
-    // Multiply [1n, 2n] — last entry is priceId 2n, which has priceMint PT_SOL
-    const mint = getPriceInputMintFromPriceId(prices, { __kind: "Multiply", priceIds: [1n, 2n] })
-    expect(mint.equals(PT_SOL)).toBe(true)
-  })
-
-  it("throws when price entry not found", () => {
-    const prices = makePrices([])
-
-    expect(() =>
-      getPriceInputMintFromPriceId(prices, { __kind: "Simple", priceId: 999n })
-    ).toThrow("Price entry not found for id 999")
-  })
-})