@lifi/sdk 3.13.7 → 3.14.0

package/src/core/Solana/jito/JitoConnection.ts

@@ -0,0 +1,190 @@
+import { Connection, type VersionedTransaction } from '@solana/web3.js'
+import { uint8ArrayToBase64 } from '../../../utils/uint8ArrayToBase64.js'
+import { JITO_TIP_ACCOUNTS } from './constants.js'
+
+export type SimulateBundleResult = {
+  value: {
+    summary: 'succeeded' | { failed: { error: any; tx_signature: string } }
+    transactionResults: Array<{
+      err: any
+      logs: string[] | null
+      unitsConsumed?: number
+    }>
+  }
+}
+
+export type BundleStatus = {
+  bundle_id: string
+  transactions: string[]
+  slot: number
+  confirmation_status: 'processed' | 'confirmed' | 'finalized'
+  err:
+    | {
+        Ok: null
+      }
+    | any
+}
+
+export type BundleStatusResult = {
+  context: {
+    slot: number
+  }
+  value: BundleStatus[]
+}
+
+/**
+ * Makes a direct RPC request to an endpoint
+ *
+ */
+async function rpcRequest<T>(
+  endpoint: string,
+  method: string,
+  params: any[]
+): Promise<T> {
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method,
+      params,
+    }),
+  })
+  if (!response.ok) {
+    throw new Error(`Jito RPC Error: ${response.status} ${response.statusText}`)
+  }
+  const data = await response.json()
+  if (data.error) {
+    throw new Error(`Jito RPC Error: ${data.error.message}`)
+  }
+  return data.result
+}
+
+/**
+ * Extended Connection class with Jito bundle support
+ * Adds simulateBundle, sendBundle, and getTipAccounts methods
+ */
+export class JitoConnection extends Connection {
+  private tipAccountsCache: string[] | null = null
+
+  /**
+   * Check if an RPC endpoint supports Jito bundles
+   * @param rpcUrl - The RPC endpoint URL to check
+   * @returns true if the endpoint supports Jito bundle methods
+   */
+  static async isJitoRpc(rpcUrl: string): Promise<boolean> {
+    try {
+      // method exists if the request is successfull and doesn't throw an error
+      await rpcRequest(rpcUrl, 'getTipAccounts', [])
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Makes a direct RPC request to the Jito-enabled endpoint
+   */
+  protected async rpcRequest<T>(method: string, params: any[]): Promise<T> {
+    try {
+      return await rpcRequest(this.rpcEndpoint, method, params)
+    } catch (error) {
+      console.error(`Jito RPC request failed: ${method}`, {
+        endpoint: this.rpcEndpoint,
+        params,
+        error,
+      })
+      throw error
+    }
+  }
+
+  /**
+   * Serialize a transaction to base64 for RPC submission
+   */
+  private serializeTransaction(transaction: VersionedTransaction): string {
+    return uint8ArrayToBase64(transaction.serialize())
+  }
+
+  /**
+   * Get the tip accounts from the Jito endpoint, using fallbacks if results are empty
+   * Results are cached to avoid repeated RPC calls
+   */
+  async getTipAccounts(): Promise<string[]> {
+    if (this.tipAccountsCache) {
+      return this.tipAccountsCache
+    }
+
+    try {
+      const accounts = await this.rpcRequest<string[]>('getTipAccounts', [])
+      if (!accounts.length) {
+        throw new Error('RPC has no tip accounts')
+      }
+      this.tipAccountsCache = accounts
+      return accounts
+    } catch (error) {
+      const fallbackAccounts = JITO_TIP_ACCOUNTS
+      console.warn(
+        `Failed to fetch tip accounts from RPC, using  fallback`,
+        error
+      )
+      return fallbackAccounts
+    }
+  }
+
+  /**
+   * Get a random Jito tip account to reduce contention
+   */
+  async getRandomTipAccount(): Promise<string> {
+    const accounts = await this.getTipAccounts()
+    return accounts[Math.floor(Math.random() * accounts.length)]
+  }
+
+  /**
+   * Manually refresh the tip accounts cache
+   * Useful for long-running processes that may need updated tip accounts
+   */
+  async refreshTipAccounts(): Promise<string[]> {
+    this.tipAccountsCache = null
+    return this.getTipAccounts()
+  }
+
+  /**
+   * Simulate a bundle before sending it
+   * @param bundle - Array of signed transactions
+   * @returns Simulation result
+   */
+  async simulateBundle(
+    bundle: VersionedTransaction[]
+  ): Promise<SimulateBundleResult> {
+    const encodedTransactions = bundle.map((tx) =>
+      this.serializeTransaction(tx)
+    )
+    return this.rpcRequest<SimulateBundleResult>('simulateBundle', [
+      { encodedTransactions },
+    ])
+  }
+
+  /**
+   * Send a bundle to the Jito block engine
+   * @param bundle - Array of signed transactions
+   * @returns Bundle UUID
+   */
+  async sendBundle(bundle: VersionedTransaction[]): Promise<string> {
+    const encodedTransactions = bundle.map((tx) =>
+      this.serializeTransaction(tx)
+    )
+    return this.rpcRequest<string>('sendBundle', [encodedTransactions])
+  }
+
+  /**
+   * Get the status of submitted bundles
+   * @param bundleIds - Array of bundle UUIDs to check
+   * @returns Bundle status information
+   */
+  async getBundleStatuses(bundleIds: string[]): Promise<BundleStatusResult> {
+    return this.rpcRequest<BundleStatusResult>('getBundleStatuses', [bundleIds])
+  }
+}

package/src/core/Solana/jito/constants.ts

@@ -0,0 +1,11 @@
+// Jito Tip accounts gotten from https://jito-foundation.gitbook.io/mev/mev-payment-and-distribution/on-chain-addresses
+export const JITO_TIP_ACCOUNTS = [
+  'Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY',
+  'DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL',
+  '96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5',
+  '3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT',
+  'HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe',
+  'ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49',
+  'ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt',
+  'DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh',
+]

package/src/core/Solana/jito/sendAndConfirmBundle.ts

@@ -0,0 +1,110 @@
+import type { SignatureResult, VersionedTransaction } from '@solana/web3.js'
+import { sleep } from '../../../utils/sleep.js'
+import { getJitoConnections } from '../connection.js'
+
+export type BundleResult = {
+  bundleId: string
+  txSignatures: string[]
+  signatureResults: (SignatureResult | null)[]
+}
+
+/**
+ * Send and confirm a bundle of transactions using Jito
+ * Automatically selects a Jito-enabled RPC connection and polls for confirmation
+ * across multiple Jito RPCs in parallel
+ * @param signedTransactions - an Array of signed transactions
+ * @returns - {@link BundleResult} object containing Bundle ID, transaction signatures, and confirmation results
+ */
+export async function sendAndConfirmBundle(
+  signedTransactions: VersionedTransaction[]
+): Promise<BundleResult> {
+  const jitoConnections = await getJitoConnections()
+
+  if (jitoConnections.length === 0) {
+    throw new Error(
+      'No Jito-enabled RPC connection available for bundle submission'
+    )
+  }
+
+  const abortController = new AbortController()
+
+  const confirmPromises = jitoConnections.map(async (jitoConnection) => {
+    try {
+      // Send initial bundle for this connection
+      let bundleId: string
+      try {
+        bundleId = await jitoConnection.sendBundle(signedTransactions)
+      } catch (_) {
+        return null
+      }
+
+      const [blockhashResult, initialBlockHeight] = await Promise.all([
+        jitoConnection.getLatestBlockhash('confirmed'),
+        jitoConnection.getBlockHeight('confirmed'),
+      ])
+      let currentBlockHeight = initialBlockHeight
+
+      while (
+        currentBlockHeight < blockhashResult.lastValidBlockHeight &&
+        !abortController.signal.aborted
+      ) {
+        const statusResponse = await jitoConnection.getBundleStatuses([
+          bundleId,
+        ])
+
+        const bundleStatus = statusResponse.value[0]
+
+        // Check if bundle is confirmed or finalized
+        if (
+          bundleStatus &&
+          (bundleStatus.confirmation_status === 'confirmed' ||
+            bundleStatus.confirmation_status === 'finalized')
+        ) {
+          // Bundle confirmed! Extract transaction signatures from bundle status
+          const txSignatures = bundleStatus.transactions
+          // Fetch individual signature results
+          const sigResponse =
+            await jitoConnection.getSignatureStatuses(txSignatures)
+
+          if (!sigResponse?.value || !Array.isArray(sigResponse.value)) {
+            // Keep polling, if can't find signature results.
+            continue
+          }
+
+          // Immediately abort all other connections when we find a result
+          abortController.abort()
+          return {
+            bundleId,
+            txSignatures,
+            signatureResults: sigResponse.value,
+          }
+        }
+
+        await sleep(400)
+        if (!abortController.signal.aborted) {
+          currentBlockHeight = await jitoConnection.getBlockHeight('confirmed')
+        }
+      }
+
+      return null
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return null // Don't treat abortion as an error
+      }
+      throw error
+    }
+  })
+
+  // Wait for first successful confirmation
+  const result = await Promise.any(confirmPromises).catch(() => null)
+
+  if (!abortController.signal.aborted) {
+    abortController.abort()
+  }
+
+  if (!result) {
+    throw new Error('Failed to send and confirm bundle')
+  }
+
+  return result
+}

package/src/index.ts

@@ -129,7 +129,12 @@ export type {
   QuoteRequestFromAmount,
   QuoteRequestToAmount,
 } from './services/types.js'
-export type { RPCUrls, SDKBaseConfig, SDKConfig } from './types/internal.js'
+export type {
+  RequestInterceptor,
+  RPCUrls,
+  SDKBaseConfig,
+  SDKConfig,
+} from './types/internal.js'
 export { checkPackageUpdates } from './utils/checkPackageUpdates.js'
 export { convertQuoteToRoute } from './utils/convertQuoteToRoute.js'
 export { fetchTxErrorDetails } from './utils/fetchTxErrorDetails.js'

package/src/request.ts

@@ -23,7 +23,8 @@ export const request = async <T = Response>(
     retries: requestSettings.retries,
   }
 ): Promise<T> => {
-  const { userId, integrator, widgetVersion, apiKey } = config.get()
+  const { userId, integrator, widgetVersion, apiKey, requestInterceptor } =
+    config.get()
 
   if (!integrator) {
     throw new SDKError(
@@ -70,6 +71,10 @@ export const request = async <T = Response>(
       'x-lifi-integrator': integrator,
     }
 
+    if (requestInterceptor) {
+      options = await requestInterceptor(options)
+    }
+
     const response: Response = await fetch(
       url,
       stripExtendRequestInitProperties(options)
@@ -81,9 +86,10 @@ export const request = async <T = Response>(
 
     return await response.json()
   } catch (error) {
-    if (options.retries > 0 && (error as HTTPError).status === 500) {
+    const retries = options.retries ?? 0
+    if (retries > 0 && (error as HTTPError).status === 500) {
       await sleep(500)
-      return request<T>(url, { ...options, retries: options.retries - 1 })
+      return request<T>(url, { ...options, retries: retries - 1 })
     }
 
     await (error as HTTPError).buildAdditionalDetails?.()

package/src/services/api.ts

@@ -1,5 +1,5 @@
 import {
-  type ChainId,
+  ChainId,
   type ChainKey,
   type ChainsRequest,
   type ChainsResponse,
@@ -247,17 +247,24 @@ export const getStepTransaction = async (
     console.warn('SDK Validation: Invalid Step', step)
   }
 
-  return await request<LiFiStep>(
-    `${config.get().apiUrl}/advanced/stepTransaction`,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(step),
-      signal: options?.signal,
-    }
-  )
+  const _config = config.get()
+  let requestUrl = `${_config.apiUrl}/advanced/stepTransaction`
+  const isJitoBundleEnabled = Boolean(_config.routeOptions?.jitoBundle)
+
+  if (isJitoBundleEnabled && step.action.fromChainId === ChainId.SOL) {
+    // add jitoBundle param to url if from chain is SVM and jitoBundle is enabled in config
+    const queryParams = new URLSearchParams({ jitoBundle: 'true' })
+    requestUrl = `${requestUrl}?${queryParams}`
+  }
+
+  return await request<LiFiStep>(requestUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(step),
+    signal: options?.signal,
+  })
 }
 
 /**

package/src/types/internal.ts

@@ -1,5 +1,10 @@
 import type { ChainId, ExtendedChain, RouteOptions } from '@lifi/types'
 import type { SDKProvider } from '../core/types.js'
+import type { ExtendedRequestInit } from './request.js'
+
+export type RequestInterceptor = (
+  request: ExtendedRequestInit
+) => ExtendedRequestInit | Promise<ExtendedRequestInit>
 
 export interface SDKBaseConfig {
   apiKey?: string
@@ -14,6 +19,7 @@ export interface SDKBaseConfig {
   widgetVersion?: string
   preloadChains: boolean
   debug: boolean
+  requestInterceptor?: RequestInterceptor
 }
 
 export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {

package/src/utils/uint8ArrayToBase64.ts

@@ -0,0 +1,12 @@
+export function uint8ArrayToBase64(bytes: Uint8Array): string {
+  // Node.js environment
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(bytes).toString('base64')
+  }
+
+  // Browser environment
+  const binaryString = Array.from(bytes, (byte) =>
+    String.fromCharCode(byte)
+  ).join('')
+  return btoa(binaryString)
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.13.7'
+export const version = '3.14.0'