@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/policyBuilders.ts

@@ -7,6 +7,8 @@ import { AccountConstraint, DataConstraint, InstructionConstraint, PolicyConfig,
 // ============================================================================
 
 export const KAMINO_LENDING_PROGRAM_ID = new PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD")
+export const KAMINO_VAULT_PROGRAM_ID = new PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd")
+export const KAMINO_FARMS_PROGRAM_ID = new PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr")
 
 // ============================================================================
 // Instruction Discriminators (first 8 bytes of sha256("global:<method_name>"))
@@ -33,6 +35,19 @@ export const KAMINO_DISCRIMINATORS = {
   refreshObligation: Buffer.from([33, 132, 147, 228, 151, 192, 72, 89]),
 }
 
+export const KAMINO_VAULT_DISCRIMINATORS = {
+  deposit: Buffer.from([242, 35, 198, 137, 82, 225, 242, 182]),
+  withdraw: Buffer.from([183, 18, 70, 156, 148, 109, 161, 34]),
+}
+
+export const KAMINO_FARM_DISCRIMINATORS = {
+  initializeUser: Buffer.from([111, 17, 185, 250, 60, 122, 38, 254]),
+  stake: Buffer.from([206, 176, 202, 18, 200, 209, 179, 108]),
+  unstake: Buffer.from([90, 95, 107, 42, 205, 124, 50, 225]),
+  withdrawUnstakedDeposits: Buffer.from([36, 102, 187, 49, 220, 36, 132, 67]),
+  harvestReward: Buffer.from([68, 200, 228, 233, 184, 32, 226, 188]),
+}
+
 // ============================================================================
 // Policy Builder Functions
 // ============================================================================
@@ -672,6 +687,161 @@ export function createKaminoPolicy(params: {
   })
 }
 
+export const KAMINO_VAULT_ACCOUNT_INDICES = {
+  deposit: {
+    vaultState: 1,
+    tokenMint: 3,
+  },
+  withdraw: {
+    vaultState: 1,
+    tokenMint: 6,
+    reserve: 15,
+  },
+}
+
+export type KaminoVaultPolicyAction = "deposit" | "withdraw"
+
+export function createKaminoVaultPolicy(params: {
+  allowedVaults?: PublicKey[]
+  allowedDepositMints?: PublicKey[]
+  actions: KaminoVaultPolicyAction[]
+  spendingLimits?: SpendingLimit[]
+  threshold?: number
+  timeLock?: number
+}): PolicyConfig {
+  const instructionsConstraints: InstructionConstraint[] = []
+
+  for (const action of params.actions) {
+    const accountConstraints: AccountConstraint[] = []
+    const accountIndices =
+      action === "deposit" ? KAMINO_VAULT_ACCOUNT_INDICES.deposit : KAMINO_VAULT_ACCOUNT_INDICES.withdraw
+
+    if (params.allowedVaults && params.allowedVaults.length > 0) {
+      accountConstraints.push(createAccountConstraint(accountIndices.vaultState, params.allowedVaults))
+    }
+    if (params.allowedDepositMints && params.allowedDepositMints.length > 0) {
+      accountConstraints.push(createAccountConstraint(accountIndices.tokenMint, params.allowedDepositMints))
+    }
+
+    instructionsConstraints.push(
+      createInstructionConstraint({
+        programId: KAMINO_VAULT_PROGRAM_ID,
+        accountConstraints,
+        dataConstraints: [
+          createDiscriminatorConstraint(
+            action === "deposit"
+              ? KAMINO_VAULT_DISCRIMINATORS.deposit
+              : KAMINO_VAULT_DISCRIMINATORS.withdraw,
+          ),
+        ],
+      }),
+    )
+  }
+
+  return createProgramInteractionPolicy({
+    instructionsConstraints,
+    spendingLimits: params.spendingLimits,
+    threshold: params.threshold,
+    timeLock: params.timeLock,
+  })
+}
+
+export const KAMINO_FARM_ACCOUNT_INDICES = {
+  initializeUser: {
+    farmState: 5,
+  },
+  stake: {
+    farmState: 2,
+    tokenMint: 5,
+  },
+  unstake: {
+    farmState: 2,
+  },
+  withdrawUnstakedDeposits: {
+    farmState: 2,
+  },
+  harvestReward: {
+    farmState: 2,
+    rewardMint: 4,
+  },
+}
+
+export type KaminoFarmPolicyAction =
+  | "initializeUser"
+  | "stake"
+  | "unstake"
+  | "withdrawUnstakedDeposits"
+  | "harvestReward"
+
+export function createKaminoFarmPolicy(params: {
+  allowedFarmStates?: PublicKey[]
+  allowedUnderlyingMints?: PublicKey[]
+  allowedRewardMints?: PublicKey[]
+  actions: KaminoFarmPolicyAction[]
+  spendingLimits?: SpendingLimit[]
+  threshold?: number
+  timeLock?: number
+}): PolicyConfig {
+  const instructionsConstraints: InstructionConstraint[] = []
+
+  for (const action of params.actions) {
+    const accountConstraints: AccountConstraint[] = []
+
+    const farmIndex =
+      action === "initializeUser"
+        ? KAMINO_FARM_ACCOUNT_INDICES.initializeUser.farmState
+        : action === "stake"
+          ? KAMINO_FARM_ACCOUNT_INDICES.stake.farmState
+          : action === "unstake"
+            ? KAMINO_FARM_ACCOUNT_INDICES.unstake.farmState
+            : action === "withdrawUnstakedDeposits"
+              ? KAMINO_FARM_ACCOUNT_INDICES.withdrawUnstakedDeposits.farmState
+              : KAMINO_FARM_ACCOUNT_INDICES.harvestReward.farmState
+
+    if (params.allowedFarmStates && params.allowedFarmStates.length > 0) {
+      accountConstraints.push(createAccountConstraint(farmIndex, params.allowedFarmStates))
+    }
+
+    if (action === "stake" && params.allowedUnderlyingMints && params.allowedUnderlyingMints.length > 0) {
+      accountConstraints.push(
+        createAccountConstraint(KAMINO_FARM_ACCOUNT_INDICES.stake.tokenMint, params.allowedUnderlyingMints),
+      )
+    }
+
+    if (action === "harvestReward" && params.allowedRewardMints && params.allowedRewardMints.length > 0) {
+      accountConstraints.push(
+        createAccountConstraint(KAMINO_FARM_ACCOUNT_INDICES.harvestReward.rewardMint, params.allowedRewardMints),
+      )
+    }
+
+    const discriminator =
+      action === "initializeUser"
+        ? KAMINO_FARM_DISCRIMINATORS.initializeUser
+        : action === "stake"
+          ? KAMINO_FARM_DISCRIMINATORS.stake
+          : action === "unstake"
+            ? KAMINO_FARM_DISCRIMINATORS.unstake
+            : action === "withdrawUnstakedDeposits"
+              ? KAMINO_FARM_DISCRIMINATORS.withdrawUnstakedDeposits
+              : KAMINO_FARM_DISCRIMINATORS.harvestReward
+
+    instructionsConstraints.push(
+      createInstructionConstraint({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        accountConstraints,
+        dataConstraints: [createDiscriminatorConstraint(discriminator)],
+      }),
+    )
+  }
+
+  return createProgramInteractionPolicy({
+    instructionsConstraints,
+    spendingLimits: params.spendingLimits,
+    threshold: params.threshold,
+    timeLock: params.timeLock,
+  })
+}
+
 // ============================================================================
 // Exponent Core Policy Builders (Strip/Merge)
 // ============================================================================

package/src/exponentVaults/pricePathResolver.test.ts

@@ -0,0 +1,466 @@
+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")
+  })
+})