@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/exponentVaults/titan-quote.ts

@@ -1,446 +0,0 @@
-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) ---
-
-interface TitanWireAccountMeta {
-  p: Uint8Array // pubkey
-  s: boolean // isSigner
-  w: boolean // isWritable
-}
-
-interface TitanWireInstruction {
-  p: Uint8Array // programId
-  a: TitanWireAccountMeta[] // accounts
-  d: Uint8Array // data
-}
-
-interface TitanRoute {
-  inAmount: bigint
-  outAmount: bigint
-  transaction?: Uint8Array
-  instructions?: TitanWireInstruction[]
-  addressLookupTables?: Uint8Array[]
-}
-
-interface TitanSwapQuotes {
-  quotes: Record<string, TitanRoute>
-}
-
-type TitanServerMessage =
-  | { Error: { code: number; message: string }; StreamData?: never; StreamEnd?: never }
-  | { StreamData: { payload: { SwapQuotes?: TitanSwapQuotes } }; Error?: never; StreamEnd?: never }
-  | { StreamEnd: { errorCode?: number; errorMessage?: string }; Error?: never; StreamData?: never }
-
-// --- Public API ---
-
-interface TitanSwapParams {
-  inputMint: PublicKey
-  outputMint: PublicKey
-  amount: bigint
-  slippageBps?: number
-  userPublicKey: PublicKey
-}
-
-export interface TitanQuoteResult {
-  instruction: TransactionInstruction
-  /** ALT addresses from the Titan route — fetch these on-chain and include in V0 message compilation */
-  addressLookupTableAddresses: PublicKey[]
-}
-
-const TITAN_VAULT_INCOMPATIBLE_PROGRAM_IDS = new Set<string>([
-  "ALPHAQmeA7bjrVuccPsYPiCvsi428SNwte66Srvs4pHA",
-])
-
-const JITO_BUNDLE_BLOCKED_ACCOUNT_PREFIXES = ["jitodontfront", "jitonobundle"]
-
-/**
- * Fetch a single Titan swap quote and return the SwapRouteV2 instruction
- * along with any Address Lookup Table addresses needed for transaction compression.
- */
-export async function getTitanQuote(
-  connection: Connection,
-  auth: { wsUrl: string; authToken: string },
-  params: TitanSwapParams,
-): Promise<TitanQuoteResult> {
-  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)
-      }
-    }
-
-    if (attempt < INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS && (lastBlockedRoute || lastError)) {
-      await sleep(INCOMPATIBLE_ROUTE_RETRY_DELAY_MS)
-    }
-  }
-
-  if (lastBlockedRoute) {
-    throw new Error(
-      `Titan returned only routes incompatible with vault-owned execution after ${INCOMPATIBLE_ROUTE_RETRY_ATTEMPTS} attempts`,
-    )
-  }
-
-  if (lastError) {
-    throw lastError
-  }
-
-  throw new Error("Titan route has neither transaction bytes nor a SwapRouteV2 instruction")
-}
-
-// --- Internals ---
-
-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[]> {
-  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(() => {
-      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))
-    })
-
-    ws.on("open", () => {
-      const request = {
-        id: 0,
-        data: {
-          NewSwapQuoteStream: {
-            swap: {
-              inputMint: params.inputMint.toBytes(),
-              outputMint: params.outputMint.toBytes(),
-              amount: params.amount,
-              slippageBps: params.slippageBps ?? 50,
-            },
-                        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
-      }
-
-      if (msg.StreamData) {
-        const quotes = msg.StreamData.payload?.SwapQuotes
-        if (!quotes) 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"
-        reject(new Error(err))
-      }
-    })
-  })
-}
-
-function selectUsableRoutes(routes: TitanRoute[]) {
-  return [...routes]
-    .sort((a, b) => (a.outAmount > b.outAmount ? -1 : a.outAmount < b.outAmount ? 1 : 0))
-    .filter(isUsableTitanRoute)
-}
-
-function isUsableTitanRoute(route: TitanRoute) {
-  if (route.transaction) {
-    return true
-  }
-
-  return (
-    route.instructions?.some((ix) => {
-      return ix.d.length >= 8 && Buffer.from(ix.d.subarray(0, 8)).equals(SWAP_ROUTE_V2_DISCRIMINATOR)
-    }) ?? false
-  )
-}
-
-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,
-): Promise<TransactionInstruction> {
-  const message = vTx.message
-  
-  let lookupTableAccounts: AddressLookupTableAccount[] = []
-  if ("addressTableLookups" in message && message.addressTableLookups.length > 0) {
-    lookupTableAccounts = await Promise.all(
-      message.addressTableLookups.map(async (lookup) => {
-        const result = await connection.getAddressLookupTable(lookup.accountKey)
-        if (!result.value) {
-          throw new Error("Failed to resolve address lookup table: " + lookup.accountKey.toBase58())
-        }
-        return result.value
-      }),
-    )
-  }
-
-  const decompiled = TransactionMessage.decompile(message, {
-    addressLookupTableAccounts: lookupTableAccounts,
-  })
-    const swapIx = decompiled.instructions.find(
-    (ix) =>
-      ix.data.length >= 8 && Buffer.from(ix.data.subarray(0, 8)).equals(SWAP_ROUTE_V2_DISCRIMINATOR),
-  )
-
-  if (!swapIx) {
-    throw new Error("No SwapRouteV2 instruction found in Titan transaction")
-  }
-
-  return sanitizeTitanInstructionForBundles(swapIx)
-}
-
-function sanitizeTitanInstructionForBundles(instruction: TransactionInstruction) {
-  const filteredKeys = instruction.keys.filter((key) => {
-    const address = key.pubkey.toBase58().toLowerCase()
-    if (!JITO_BUNDLE_BLOCKED_ACCOUNT_PREFIXES.some((prefix) => address.startsWith(prefix))) {
-      return true
-    }
-
-    return key.isSigner || key.isWritable
-  })
-
-  if (filteredKeys.length === instruction.keys.length) {
-    return instruction
-  }
-
-  return new TransactionInstruction({
-    programId: instruction.programId,
-    keys: filteredKeys,
-    data: instruction.data,
-  })
-}