@exponent-labs/exponent-sdk 0.9.2 → 0.9.3

package/src/exponentVaults/pricePathResolver.ts

@@ -1,273 +0,0 @@
-import type { ExponentPrice, ExponentPrices } from "@exponent-labs/exponent-vaults-fetcher"
-import { PublicKey } from "@solana/web3.js"
-import { priceId, type PriceId } from "../client/vaults/types/priceId"
-
-type PriceEdge = {
-  priceId: bigint
-  priceMint: PublicKey
-  underlyingMint: PublicKey
-}
-
-export type ResolvedPricePath = {
-  sourceMint: PublicKey
-  targetMint: PublicKey
-  edges: PriceEdge[]
-  mints: PublicKey[]
-}
-
-export type ResolvedKaminoQuotePath = {
-  quoteInputMint: PublicKey
-  quotePriceId: PriceId
-}
-
-export function resolveExponentPricePath(
-  prices: ExponentPrices,
-  sourceMint: PublicKey,
-  targetMint: PublicKey,
-): ResolvedPricePath | null {
-  const startKey = sourceMint.toBase58()
-  const targetKey = targetMint.toBase58()
-  const edgesByPriceMint = buildEdgesByPriceMint(prices)
-  const visited = new Set<string>([startKey])
-  const queue: string[] = [startKey]
-  const previous = new Map<string, { parent: string; edge: PriceEdge }>()
-  const mintByKey = new Map<string, PublicKey>([
-    [startKey, sourceMint],
-    [targetKey, targetMint],
-  ])
-
-  while (queue.length > 0) {
-    const currentKey = queue.shift()
-    if (!currentKey) {
-      continue
-    }
-
-    for (const edge of edgesByPriceMint.get(currentKey) ?? []) {
-      const nextKey = edge.underlyingMint.toBase58()
-
-      previous.set(nextKey, { parent: currentKey, edge })
-      mintByKey.set(edge.priceMint.toBase58(), edge.priceMint)
-      mintByKey.set(nextKey, edge.underlyingMint)
-
-      if (nextKey === targetKey) {
-        return buildResolvedPath(previous, mintByKey, startKey, targetKey)
-      }
-
-      if (visited.has(nextKey)) {
-        continue
-      }
-
-      visited.add(nextKey)
-      queue.push(nextKey)
-    }
-  }
-
-  return null
-}
-
-export function resolvePriceIdFromMintToUnderlying(
-  prices: ExponentPrices,
-  sourceMint: PublicKey,
-  targetMint: PublicKey,
-): PriceId | null {
-  const path = resolveExponentPricePath(prices, sourceMint, targetMint)
-  if (!path) {
-    return null
-  }
-  return priceIdFromPath(path)
-}
-
-export function resolvePriceIdFromMintToUnderlyingOrThrow(params: {
-  prices: ExponentPrices
-  sourceMint: PublicKey
-  targetMint: PublicKey
-  label: string
-}): PriceId {
-  const resolved = resolvePriceIdFromMintToUnderlying(params.prices, params.sourceMint, params.targetMint)
-  if (resolved) {
-    return resolved
-  }
-
-  throw new Error(
-    `Missing Exponent price path for ${params.label}: ${params.sourceMint.toBase58()} -> ${params.targetMint.toBase58()}`,
-  )
-}
-
-/**
- * Resolve the Kamino quote path for a vault.
- *
- * The quote mint is always the vault's underlying mint. Each reserve's
- * price chains to this mint, and the `quotePriceId` is the identity
- * price (the `One` entry for the vault underlying).
- */
-export function resolveBestKaminoQuotePath(params: {
-  prices: ExponentPrices
-  vaultUnderlyingMint: PublicKey
-}): ResolvedKaminoQuotePath {
-  const quotePriceId = resolvePriceIdFromMintToUnderlying(
-    params.prices,
-    params.vaultUnderlyingMint,
-    params.vaultUnderlyingMint,
-  )
-  if (!quotePriceId) {
-    throw new Error(
-      `Missing Exponent price path for Kamino quote resolution: no price entry for vault underlying ${params.vaultUnderlyingMint.toBase58()} to itself`,
-    )
-  }
-
-  return {
-    quoteInputMint: params.vaultUnderlyingMint,
-    quotePriceId,
-  }
-}
-
-export function resolveKaminoReservePriceIdOrThrow(params: {
-  prices: ExponentPrices
-  reserveMint: PublicKey
-  quoteInputMint: PublicKey
-}): PriceId {
-  if (params.reserveMint.equals(params.quoteInputMint)) {
-    return priceId("Simple", { priceId: 0n })
-  }
-
-  const reservePath = resolveExponentPricePath(params.prices, params.reserveMint, params.quoteInputMint)
-  if (!reservePath) {
-    throw new Error(
-      `Missing Exponent price path for Kamino reserve mapping: ${params.reserveMint.toBase58()} -> ${params.quoteInputMint.toBase58()}`,
-    )
-  }
-
-  return priceIdFromPath(reservePath)
-}
-
-export function extractPriceIds(priceIdValue: unknown): bigint[] {
-  if (!priceIdValue || typeof priceIdValue !== "object") {
-    throw new Error("Invalid PriceId: expected an object")
-  }
-
-  const value = priceIdValue as Record<string, unknown>
-  if (value.__kind === "Simple" && typeof value.priceId === "bigint") {
-    return [value.priceId]
-  }
-  if (value.__kind === "Multiply" && Array.isArray(value.priceIds)) {
-    return value.priceIds.map(asBigInt)
-  }
-  if ("simple" in value) {
-    const simple = value.simple as Record<string, unknown> | undefined
-    const raw = simple?.priceId
-    if (typeof raw === "bigint" || typeof raw === "number") {
-      return [BigInt(raw)]
-    }
-  }
-  if ("multiply" in value) {
-    const multiply = value.multiply as Record<string, unknown> | undefined
-    const rawIds = multiply?.priceIds
-    if (Array.isArray(rawIds)) {
-      return rawIds.map(asBigInt)
-    }
-  }
-
-  throw new Error("Unsupported PriceId shape")
-}
-
-export function getPriceInputMintFromPriceId(prices: ExponentPrices, priceIdValue: unknown): PublicKey {
-  const ids = extractPriceIds(priceIdValue)
-  const lastId = ids[ids.length - 1]
-  const entry = findPriceEntryById(prices, lastId)
-  if (!entry) {
-    throw new Error(`Price entry not found for id ${lastId.toString()}`)
-  }
-  return entry.priceMint
-}
-
-function buildEdgesByPriceMint(prices: ExponentPrices): Map<string, PriceEdge[]> {
-  const result = new Map<string, PriceEdge[]>()
-
-  for (const entry of prices.prices) {
-    if (!entry) {
-      continue
-    }
-
-    const key = entry.priceMint.toBase58()
-    const edges = result.get(key) ?? []
-    edges.push({
-      priceId: entry.priceId,
-      priceMint: entry.priceMint,
-      underlyingMint: entry.underlyingMint,
-    })
-    result.set(key, edges)
-  }
-
-  return result
-}
-
-function buildResolvedPath(
-  previous: Map<string, { parent: string; edge: PriceEdge }>,
-  mintByKey: Map<string, PublicKey>,
-  startKey: string,
-  targetKey: string,
-): ResolvedPricePath {
-  const reversedEdges: PriceEdge[] = []
-  const reversedMints: PublicKey[] = []
-
-  let cursor = targetKey
-  reversedMints.push(mintByKey.get(cursor) ?? new PublicKey(cursor))
-
-  if (startKey === targetKey) {
-    const step = previous.get(targetKey)
-    if (step) {
-      reversedEdges.push(step.edge)
-      reversedMints.push(mintByKey.get(startKey) ?? new PublicKey(startKey))
-    }
-  } else {
-    while (cursor !== startKey) {
-      const step = previous.get(cursor)
-      if (!step) {
-        throw new Error("Failed to reconstruct price path")
-      }
-
-      reversedEdges.push(step.edge)
-      cursor = step.parent
-      reversedMints.push(mintByKey.get(cursor) ?? new PublicKey(cursor))
-    }
-  }
-
-  const mints = reversedMints.reverse()
-  const edges = reversedEdges.reverse()
-  return {
-    sourceMint: mints[0]!,
-    targetMint: mints[mints.length - 1]!,
-    edges,
-    mints,
-  }
-}
-
-function priceIdFromPath(path: ResolvedPricePath): PriceId {
-  const ids = [...path.edges].reverse().map((edge) => edge.priceId)
-  if (ids.length === 0) {
-    throw new Error("Price path cannot be empty")
-  }
-
-  return ids.length === 1
-    ? priceId("Simple", { priceId: ids[0]! })
-    : priceId("Multiply", { priceIds: ids })
-}
-
-function findPriceEntryById(prices: ExponentPrices, priceIdValue: bigint): ExponentPrice | null {
-  for (const entry of prices.prices) {
-    if (entry?.priceId === priceIdValue) {
-      return entry
-    }
-  }
-  return null
-}
-
-function asBigInt(value: unknown): bigint {
-  if (typeof value === "bigint") {
-    return value
-  }
-  if (typeof value === "number") {
-    return BigInt(value)
-  }
-  throw new Error("Expected bigint-compatible price id")
-}

package/src/exponentVaults/scope-refresh.ts

@@ -1,169 +0,0 @@
-import { Reserve } from "@exponent-labs/kamino-reserve-deserializer"
-import { AccountMeta, Connection, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, TransactionInstruction } from "@solana/web3.js"
-
-const SCOPE_PROGRAM_ID = new PublicKey("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ")
-const U16_MAX = 65535
-
-// Known Scope feed Configuration PDAs keyed by oraclePrices address.
-// Source: @kamino-finance/scope-sdk constants/index.ts
-const SCOPE_CONFIGURATIONS: Record<string, string> = {
-  "3t4JZcueEzTbVP6kLxXrL3VpWx45jDer4eqysweBchNH": "6cMwdbrJ95D7v5655Zsoe7oXmjQJMnagWK8EcdG6qmGM", // klend
-  "3NJYftD5sjVfxSnUdZ1wVML8f3aC6mp1CXCL6L7TnU8C": "AdTiP7QyjUyv6crF4H8z7fxJKU7Z5eCAGvJN1Y55cXxb", // hubble
-}
-
-// Oracle types that cannot be refreshed by the Scope program
-const NON_REFRESHABLE_ORACLE_TYPES = new Set([5, 20]) // Chainlink, PythLazer
-
-// Scope Configuration account layout (after 8-byte discriminator):
-//   offset 8:   admin (32 bytes)
-//   offset 40:  oracleMappings (32 bytes)
-//   offset 72:  oraclePrices (32 bytes)
-//   offset 104: tokensMetadata (32 bytes)
-//   offset 136: oracleTwaps (32 bytes)
-function decodeScopeConfig(data: Buffer) {
-  return {
-    oracleMappings: new PublicKey(data.subarray(40, 72)),
-    oraclePrices: new PublicKey(data.subarray(72, 104)),
-    oracleTwaps: new PublicKey(data.subarray(136, 168)),
-  }
-}
-
-// Scope OracleMappings account layout (after 8-byte discriminator):
-//   offset 8:     priceInfoAccounts[512] (512 * 32 = 16384 bytes)
-//   offset 16392: priceTypes[512] (512 bytes)
-function decodeScopeOracleMappings(data: Buffer) {
-  const priceInfoAccounts: PublicKey[] = []
-  for (let i = 0; i < 512; i++) {
-    const start = 8 + i * 32
-    priceInfoAccounts.push(new PublicKey(data.subarray(start, start + 32)))
-  }
-  const priceTypes: number[] = []
-  for (let i = 0; i < 512; i++) {
-    priceTypes.push(data[16392 + i])
-  }
-  return { priceInfoAccounts, priceTypes }
-}
-
-// refreshPriceList discriminator: [83, 186, 207, 131, 203, 254, 198, 130]
-const REFRESH_PRICE_LIST_DISCRIMINATOR = Buffer.from([83, 186, 207, 131, 203, 254, 198, 130])
-
-function buildRefreshPriceListIx(
-  oraclePrices: PublicKey,
-  oracleMappings: PublicKey,
-  oracleTwaps: PublicKey,
-  tokens: number[],
-  oracleAccounts: AccountMeta[],
-): TransactionInstruction {
-  // Data: 8-byte discriminator + borsh Vec<u16> (4-byte length + N * 2-byte values)
-  const data = Buffer.alloc(8 + 4 + tokens.length * 2)
-  REFRESH_PRICE_LIST_DISCRIMINATOR.copy(data, 0)
-  data.writeUInt32LE(tokens.length, 8)
-  for (let i = 0; i < tokens.length; i++) {
-    data.writeUInt16LE(tokens[i], 12 + i * 2)
-  }
-
-  const keys: AccountMeta[] = [
-    { pubkey: oraclePrices, isSigner: false, isWritable: true },
-    { pubkey: oracleMappings, isSigner: false, isWritable: false },
-    { pubkey: oracleTwaps, isSigner: false, isWritable: true },
-    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
-    ...oracleAccounts,
-  ]
-
-  return new TransactionInstruction({
-    programId: SCOPE_PROGRAM_ID,
-    keys,
-    data,
-  })
-}
-
-/**
- * Build Scope refreshPriceList instructions for all reserves that use Scope oracles.
- * Should be prepended before refreshReserve instructions so that Scope oracle data
- * has fresh timestamps when reserves are refreshed.
- */
-export async function buildScopeRefreshInstructions(
-  connection: Connection,
-  reserves: { account: Reserve }[],
-): Promise<TransactionInstruction[]> {
-  const defaultKey = PublicKey.default
-
-  // 1. Group token IDs by Scope feed (oraclePrices address)
-  const feedTokens = new Map<string, Set<number>>()
-  for (const { account } of reserves) {
-    const scopeConfig = account.config.tokenInfo.scopeConfiguration
-    if (scopeConfig.priceFeed.equals(defaultKey)) continue
-
-    const feedKey = scopeConfig.priceFeed.toBase58()
-    if (!feedTokens.has(feedKey)) feedTokens.set(feedKey, new Set())
-    const tokens = feedTokens.get(feedKey)!
-
-    for (const tokenId of scopeConfig.priceChain) {
-      if (tokenId !== U16_MAX) tokens.add(tokenId)
-    }
-    for (const tokenId of scopeConfig.twapChain) {
-      if (tokenId !== U16_MAX) tokens.add(tokenId)
-    }
-  }
-
-  if (feedTokens.size === 0) return []
-
-  // 2. For each feed, fetch Scope accounts and build the instruction
-  const instructions: TransactionInstruction[] = []
-  for (const [oraclePricesKey, tokenIds] of feedTokens) {
-    const oraclePrices = new PublicKey(oraclePricesKey)
-
-    // Look up the Scope Configuration PDA for this feed
-    const configPdaStr = SCOPE_CONFIGURATIONS[oraclePricesKey]
-    if (!configPdaStr) {
-      console.warn(`Unknown Scope feed: ${oraclePricesKey}, skipping refresh`)
-      continue
-    }
-    const configPda = new PublicKey(configPdaStr)
-
-    // Fetch Configuration account to get oracleMappings and oracleTwaps
-    const configInfo = await connection.getAccountInfo(configPda)
-    if (!configInfo) {
-      console.warn(`Scope Configuration not found: ${configPdaStr}`)
-      continue
-    }
-    const config = decodeScopeConfig(configInfo.data as Buffer)
-
-    // Fetch OracleMappings to get per-token oracle accounts
-    const mappingsInfo = await connection.getAccountInfo(config.oracleMappings)
-    if (!mappingsInfo) {
-      console.warn(`Scope OracleMappings not found: ${config.oracleMappings.toBase58()}`)
-      continue
-    }
-    const mappings = decodeScopeOracleMappings(mappingsInfo.data as Buffer)
-
-    // Filter out non-refreshable oracle types and build remaining accounts
-    const sortedTokens = [...tokenIds].sort((a, b) => a - b)
-    const refreshableTokens: number[] = []
-    const oracleAccounts: AccountMeta[] = []
-
-    for (const tokenId of sortedTokens) {
-      if (NON_REFRESHABLE_ORACLE_TYPES.has(mappings.priceTypes[tokenId])) continue
-      refreshableTokens.push(tokenId)
-      oracleAccounts.push({
-        pubkey: mappings.priceInfoAccounts[tokenId],
-        isSigner: false,
-        isWritable: false,
-      })
-    }
-
-    if (refreshableTokens.length === 0) continue
-
-    instructions.push(
-      buildRefreshPriceListIx(
-        oraclePrices,
-        config.oracleMappings,
-        config.oracleTwaps,
-        refreshableTokens,
-        oracleAccounts,
-      ),
-    )
-  }
-
-  return instructions
-}

package/src/exponentVaults/squadsVaultTxnResolver/constants.ts

@@ -1,59 +0,0 @@
-import { InteractionType } from "./types"
-
-/* eslint-disable camelcase */
-export const ACTION_DISPLAY_NAMES: Record<InteractionType, string> = {
-  swap_exact_sy_for_pt: "Buy PT",
-  swap_exact_pt_for_sy: "Sell PT",
-  swap_exact_sy_for_yt: "Buy YT",
-  swap_exact_yt_for_sy: "Sell YT",
-  wrapper_post_offer: "Post Limit Order",
-  raw_post_offer: "Post Offer",
-  raw_market_offer: "Market Offer",
-  wrapper_remove_offer: "Remove Offer",
-  wrapper_withdraw_funds: "Withdraw Filled Orders",
-  initialize_yield_position: "Initialize Yield Position",
-  wrapper_strip: "Strip",
-  wrapper_merge: "Merge",
-  mint_sy: "Mint SY",
-  redeem_sy: "Redeem SY",
-  lending_account_deposit: "Deposit",
-  lending_account_withdraw: "Withdraw",
-  lending_account_borrow: "Borrow",
-  lending_account_repay: "Repay",
-  init_user_metadata: "Init User Metadata",
-  deposit_reserve_liquidity: "Deposit Reserve Liquidity",
-  init_obligation: "Init Obligation",
-  init_obligation_farms_for_reserve: "Init Obligation Farms",
-  refresh_reserve: "Refresh Reserve",
-  refresh_obligation: "Refresh Obligation",
-  swap_route_v2: "Swap",
-  collect_interest: "Collect Interest",
-  wrapper_collect_interest: "Collect Interest",
-  deposit_yt: "Deposit YT",
-  withdraw_yt: "Withdraw YT",
-  // CLMM
-  deposit_liquidity: "Deposit Liquidity",
-  add_liquidity: "Add Liquidity",
-  withdraw_liquidity: "Withdraw Liquidity",
-  trade_pt: "Trade PT",
-  trade_pt_exact_out: "Trade PT (Exact Out)",
-  buy_yt: "Buy YT",
-  sell_yt: "Sell YT",
-  claim_farm_emission: "Claim Rewards",
-  // Loopscale
-  create_loan: "Create Loan",
-  deposit_collateral: "Deposit Collateral",
-  borrow_principal: "Borrow",
-  repay_principal: "Repay",
-  withdraw_collateral: "Withdraw Collateral",
-  close_loan: "Close Loan",
-  create_strategy: "Create Strategy",
-  deposit_strategy: "Deposit",
-  withdraw_strategy: "Withdraw",
-  close_strategy: "Close Strategy",
-  update_weight_matrix: "Update Weight Matrix",
-  lock_loan: "Lock Loan",
-  unlock_loan: "Unlock Loan",
-  update_strategy: "Update Strategy",
-  refinance_ledger: "Refinance",
-}