@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/pricePathResolver.ts

@@ -0,0 +1,273 @@
+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/syncTransaction.ts

@@ -115,7 +115,12 @@ export function compileToSyncTransactionPayload({
     }
 
     // Add instruction accounts
-    for (const key of ix.keys) {
+    for (const [keyIndex, key] of ix.keys.entries()) {
+      if (!key?.pubkey) {
+        throw new Error(
+          `Instruction ${ix.programId.toBase58()} is missing account meta at index ${keyIndex}`,
+        )
+      }
       const keyStr = key.pubkey.toBase58()
       const existing = accountMap.get(keyStr)
       if (existing) {

package/src/exponentVaults/titan-quote.ts

@@ -1,17 +1,28 @@
 import {
   Connection,
   PublicKey,
+  Keypair,
   TransactionInstruction,
   VersionedTransaction,
   TransactionMessage,
   AddressLookupTableAccount,
 } from "@solana/web3.js"
+import { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token"
 import { encode, decode } from "@msgpack/msgpack"
 import WebSocket from "ws"
 
 const TITAN_WS_SUBPROTOCOL = "v1.api.titan.ag"
 const SWAP_ROUTE_V2_DISCRIMINATOR = Buffer.from([249, 91, 84, 33, 69, 22, 0, 135])
 const QUOTE_TIMEOUT_MS = 45_000
+const INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS = 3
+const INCOMPATIBLE_ROUTE_RETRY_DELAY_MS = 750
+const TITAN_QUOTE_STREAM_ROUTE_COUNT = 6
+const TITAN_INPUT_MINT_ACCOUNT_INDEX = 2
+const TITAN_INPUT_TOKEN_ACCOUNT_INDEX = 3
+const TITAN_OUTPUT_MINT_ACCOUNT_INDEX = 4
+const TITAN_OUTPUT_TOKEN_ACCOUNT_INDEX = 5
+const TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX = 6
+const TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX = 7
 
 // --- Titan wire-format types (MessagePack-decoded) ---
 
@@ -60,6 +71,10 @@ export interface TitanQuoteResult {
   addressLookupTableAddresses: PublicKey[]
 }
 
+const TITAN_VAULT_INCOMPATIBLE_PROGRAM_IDS = new Set<string>([
+  "ALPHAQmeA7bjrVuccPsYPiCvsi428SNwte66Srvs4pHA",
+])
+
 const JITO_BUNDLE_BLOCKED_ACCOUNT_PREFIXES = ["jitodontfront", "jitonobundle"]
 
 /**
@@ -71,36 +86,51 @@ export async function getTitanQuote(
   auth: { wsUrl: string; authToken: string },
   params: TitanSwapParams,
 ): Promise<TitanQuoteResult> {
-  const route = await fetchBestRoute(auth, params)
-  const addressLookupTableAddresses = (route.addressLookupTables ?? []).map(
-    (bytes) => new PublicKey(bytes),
-  )
+  const candidates = buildQuoteCandidates(params.userPublicKey)
+  let lastBlockedRoute: TitanQuoteResult | null = null
+  let lastError: Error | null = null
+
+  for (let attempt = 1; attempt <= INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS; attempt++) {
+    for (const candidate of candidates) {
+      try {
+        const routes = await fetchUsableRoutes(auth, {
+          ...params,
+          userPublicKey: candidate.quoteUserPublicKey,
+        })
+
+        for (const route of routes) {
+          const quote = await buildQuoteResult(connection, route)
+          const normalizedQuote = candidate.rewriteToUserPublicKey
+            ? rewriteTitanQuoteForOwner({
+              quote,
+              quotedUserPublicKey: candidate.quoteUserPublicKey,
+              actualUserPublicKey: candidate.rewriteToUserPublicKey,
+            })
+            : quote
+
+          if (isVaultCompatibleQuote(normalizedQuote.instruction, params.userPublicKey)) {
+            return normalizedQuote
+          }
+          lastBlockedRoute = normalizedQuote
+        }
+      } catch (error) {
+        lastError = asError(error)
+      }
+    }
 
-  // Path 1: Full transaction bytes — deserialize and extract the swap ix
-  if (route.transaction) {
-    const vTx = VersionedTransaction.deserialize(new Uint8Array(route.transaction))
-    const instruction = await extractSwapInstruction(connection, vTx)
-    return { instruction, addressLookupTableAddresses }
+    if (attempt < INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS && (lastBlockedRoute || lastError)) {
+      await sleep(INCOMPATIBLE_ROUTE_RETRY_DELAY_MS)
+    }
   }
 
-  // Path 2: Reconstruct from the route's instructions array
-  if (route.instructions && route.instructions.length > 0) {
-    const swapIx = route.instructions.find((ix) => {
-      return ix.d.length >= 8 && Buffer.from(ix.d.subarray(0, 8)).equals(SWAP_ROUTE_V2_DISCRIMINATOR)
-    })
+  if (lastBlockedRoute) {
+    throw new Error(
+      `Titan returned only routes incompatible with vault-owned execution after ${INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS} attempts`,
+    )
+  }
 
-    if (swapIx) {
-      const instruction = new TransactionInstruction({
-        programId: new PublicKey(swapIx.p),
-        keys: swapIx.a.map((acc) => ({
-          pubkey: new PublicKey(acc.p),
-          isSigner: acc.s,
-          isWritable: acc.w,
-        })),
-        data: Buffer.from(swapIx.d),
-      })
-      return { instruction: sanitizeTitanInstructionForBundles(instruction), addressLookupTableAddresses }
-    }
+  if (lastError) {
+    throw lastError
   }
 
   throw new Error("Titan route has neither transaction bytes nor a SwapRouteV2 instruction")
@@ -108,27 +138,63 @@ export async function getTitanQuote(
 
 // --- Internals ---
 
-function fetchBestRoute(
+interface QuoteCandidate {
+  quoteUserPublicKey: PublicKey
+  rewriteToUserPublicKey?: PublicKey
+}
+
+function buildQuoteCandidates(userPublicKey: PublicKey): QuoteCandidate[] {
+  if (!PublicKey.isOnCurve(userPublicKey.toBytes())) {
+    return [
+      { quoteUserPublicKey: userPublicKey },
+      {
+        quoteUserPublicKey: deriveTitanQuoteSurrogateUser(userPublicKey),
+        rewriteToUserPublicKey: userPublicKey,
+      },
+    ]
+  }
+  return [{ quoteUserPublicKey: userPublicKey }]
+}
+
+function deriveTitanQuoteSurrogateUser(userPublicKey: PublicKey): PublicKey {
+  return Keypair.fromSeed(userPublicKey.toBytes()).publicKey
+}
+
+function fetchUsableRoutes(
   auth: { wsUrl: string; authToken: string },
   params: TitanSwapParams,
-): Promise<TitanRoute> {
+): Promise<TitanRoute[]> {
   return new Promise((resolve, reject) => {
     const url = `${auth.wsUrl}?auth=${auth.authToken}`
     const ws = new WebSocket(url, [TITAN_WS_SUBPROTOCOL])
     ws.binaryType = "arraybuffer"
+    const collectedRoutes: TitanRoute[] = []
+    let settled = false
 
     const timeout = setTimeout(() => {
-      ws.close()
+      cleanup()
+      if (collectedRoutes.length > 0) {
+        resolve(selectUsableRoutes(collectedRoutes))
+        return
+      }
       reject(new Error("Titan quote timed out after " + QUOTE_TIMEOUT_MS + "ms"))
     }, QUOTE_TIMEOUT_MS)
 
     const cleanup = () => {
+      settled = true
       clearTimeout(timeout)
       ws.close()
     }
 
     ws.on("error", (err) => {
+      if (settled) {
+        return
+      }
       cleanup()
+      if (collectedRoutes.length > 0) {
+        resolve(selectUsableRoutes(collectedRoutes))
+        return
+      }
       reject(new Error("Titan WebSocket error: " + (err as Error).message))
     })
 
@@ -143,22 +209,29 @@ function fetchBestRoute(
               amount: params.amount,
               slippageBps: params.slippageBps ?? 50,
             },
-            transaction: {
-              userPublicKey: params.userPublicKey.toBytes(),
-            },
-            update: {
-              num_quotes: 3,
-            },
-          },
-        },
+                        transaction: {
+                          userPublicKey: params.userPublicKey.toBytes(),
+                        },
+                        update: {
+                          num_quotes: TITAN_QUOTE_STREAM_ROUTE_COUNT,
+                        },
+                      },
+                    },
       }
       ws.send(encode(request, { useBigInt64: true }))
     })
 
     ws.on("message", (data: ArrayBuffer) => {
+      if (settled) {
+        return
+      }
       const msg = decode(new Uint8Array(data), { useBigInt64: true }) as TitanServerMessage
       if (msg.Error) {
         cleanup()
+        if (collectedRoutes.length > 0) {
+          resolve(selectUsableRoutes(collectedRoutes))
+          return
+        }
         reject(new Error(`Titan API error [${msg.Error.code}]: ${msg.Error.message}`))
         return
       }
@@ -167,16 +240,15 @@ function fetchBestRoute(
         const quotes = msg.StreamData.payload?.SwapQuotes
         if (!quotes) return
 
-        const best = selectBestUsableRoute(Object.values(quotes.quotes))
-        if (best) {
-          cleanup()
-          resolve(best)
-          return
-        }
+        collectedRoutes.push(...Object.values(quotes.quotes).filter(isUsableTitanRoute))
       }
 
       if (msg.StreamEnd) {
         cleanup()
+        if (collectedRoutes.length > 0) {
+          resolve(selectUsableRoutes(collectedRoutes))
+          return
+        }
         const err = msg.StreamEnd.errorMessage
           ? `Titan stream ended with error [${msg.StreamEnd.errorCode}]: ${msg.StreamEnd.errorMessage}`
           : "Titan stream ended unexpectedly"
@@ -186,10 +258,10 @@ function fetchBestRoute(
   })
 }
 
-function selectBestUsableRoute(routes: TitanRoute[]) {
+function selectUsableRoutes(routes: TitanRoute[]) {
   return [...routes]
     .sort((a, b) => (a.outAmount > b.outAmount ? -1 : a.outAmount < b.outAmount ? 1 : 0))
-    .find(isUsableTitanRoute)
+    .filter(isUsableTitanRoute)
 }
 
 function isUsableTitanRoute(route: TitanRoute) {
@@ -204,6 +276,120 @@ function isUsableTitanRoute(route: TitanRoute) {
   )
 }
 
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error))
+}
+
+async function buildQuoteResult(
+  connection: Connection,
+  route: TitanRoute,
+): Promise<TitanQuoteResult> {
+  const addressLookupTableAddresses = (route.addressLookupTables ?? []).map(
+    (bytes) => new PublicKey(bytes),
+  )
+
+  if (route.transaction) {
+    const vTx = VersionedTransaction.deserialize(new Uint8Array(route.transaction))
+    const instruction = await extractSwapInstruction(connection, vTx)
+    return { instruction, addressLookupTableAddresses }
+  }
+
+  if (route.instructions && route.instructions.length > 0) {
+    const swapIx = route.instructions.find((ix) => {
+      return ix.d.length >= 8 && Buffer.from(ix.d.subarray(0, 8)).equals(SWAP_ROUTE_V2_DISCRIMINATOR)
+    })
+
+    if (swapIx) {
+      const instruction = new TransactionInstruction({
+        programId: new PublicKey(swapIx.p),
+        keys: swapIx.a.map((acc) => ({
+          pubkey: new PublicKey(acc.p),
+          isSigner: acc.s,
+          isWritable: acc.w,
+        })),
+        data: Buffer.from(swapIx.d),
+      })
+      return { instruction: sanitizeTitanInstructionForBundles(instruction), addressLookupTableAddresses }
+    }
+  }
+
+  throw new Error("Titan route has neither transaction bytes nor a SwapRouteV2 instruction")
+}
+
+function rewriteTitanQuoteForOwner(params: {
+  quote: TitanQuoteResult
+  quotedUserPublicKey: PublicKey
+  actualUserPublicKey: PublicKey
+}): TitanQuoteResult {
+  return {
+    instruction: rewriteTitanInstructionForOwner(
+      params.quote.instruction,
+      params.quotedUserPublicKey,
+      params.actualUserPublicKey,
+    ),
+    addressLookupTableAddresses: params.quote.addressLookupTableAddresses,
+  }
+}
+
+function rewriteTitanInstructionForOwner(
+  instruction: TransactionInstruction,
+  quotedUserPublicKey: PublicKey,
+  actualUserPublicKey: PublicKey,
+): TransactionInstruction {
+  const rewrittenKeys = instruction.keys.map((key) => ({
+    pubkey: key.pubkey,
+    isSigner: key.isSigner,
+    isWritable: key.isWritable,
+  }))
+
+  const inputMint = instruction.keys[TITAN_INPUT_MINT_ACCOUNT_INDEX]?.pubkey
+  const outputMint = instruction.keys[TITAN_OUTPUT_MINT_ACCOUNT_INDEX]?.pubkey
+  const inputTokenProgram = instruction.keys[TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey ?? TOKEN_PROGRAM_ID
+  const outputTokenProgram = instruction.keys[TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey ?? TOKEN_PROGRAM_ID
+
+  const replacePubkey = (from: PublicKey, to: PublicKey) => {
+    for (const key of rewrittenKeys) {
+      if (key.pubkey.equals(from)) {
+        key.pubkey = to
+      }
+    }
+  }
+
+  replacePubkey(quotedUserPublicKey, actualUserPublicKey)
+
+  if (inputMint) {
+    replacePubkey(
+      getAssociatedTokenAddressSync(inputMint, quotedUserPublicKey, true, inputTokenProgram),
+      getAssociatedTokenAddressSync(inputMint, actualUserPublicKey, true, inputTokenProgram),
+    )
+  }
+
+  if (outputMint) {
+    replacePubkey(
+      getAssociatedTokenAddressSync(outputMint, quotedUserPublicKey, true, outputTokenProgram),
+      getAssociatedTokenAddressSync(outputMint, actualUserPublicKey, true, outputTokenProgram),
+    )
+  }
+
+  return new TransactionInstruction({
+    programId: instruction.programId,
+    keys: rewrittenKeys,
+    data: instruction.data,
+  })
+}
+
+function isVaultCompatibleQuote(instruction: TransactionInstruction, userPublicKey: PublicKey) {
+  if (instruction.keys.some((key) => TITAN_VAULT_INCOMPATIBLE_PROGRAM_IDS.has(key.pubkey.toBase58()))) {
+    return false
+  }
+
+  return !instruction.keys.some((key) => key.isSigner && !key.pubkey.equals(userPublicKey))
+}
+
 async function extractSwapInstruction(
   connection: Connection,
   vTx: VersionedTransaction,