@lifi/sdk 3.13.5 → 3.14.0-alpha.0

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

@@ -0,0 +1,21 @@
+export async function isJitoRpc(rpcUrl: string): Promise<boolean> {
+  try {
+    const response = await fetch(rpcUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'getTipAccounts',
+        params: [],
+      }),
+    })
+
+    const data = await response.json()
+
+    // If we get a result (not a "method not found" error), it supports Jito
+    return !!data.result && !data.error
+  } catch {
+    return false
+  }
+}

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

@@ -0,0 +1,195 @@
+import type { SignatureResult, VersionedTransaction } from '@solana/web3.js'
+import bs58 from 'bs58'
+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 - Array of signed transactions
+ * @returns 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'
+    )
+  }
+
+  // Validate bundle requirements
+  if (signedTransactions.length === 0) {
+    throw new Error('Bundle must contain at least one transaction')
+  }
+
+  // Check that all transactions have the same blockhash (required for bundles)
+  const firstBlockhash = signedTransactions[0].message.recentBlockhash
+  const allSameBlockhash = signedTransactions.every(
+    (tx) => tx.message.recentBlockhash === firstBlockhash
+  )
+
+  if (!allSameBlockhash) {
+    console.warn(
+      'Bundle transactions have different blockhashes:',
+      signedTransactions.map((tx) => tx.message.recentBlockhash)
+    )
+  }
+
+  // Extract transaction signatures
+  const txSignatures = signedTransactions.map((tx, index) => {
+    if (!tx.signatures[0]) {
+      throw new Error(
+        `Transaction signature is missing for transaction at index ${index}.`
+      )
+    }
+    const signature = bs58.encode(tx.signatures[0])
+    return signature
+  })
+
+  const abortController = new AbortController()
+  let bundleId: string | null = null
+
+  // Try to simulate and send bundle with the first connection
+  for (const jitoConnection of jitoConnections) {
+    try {
+      // Simulate bundle first
+      const simulationResult =
+        await jitoConnection.simulateBundle(signedTransactions)
+
+      if (simulationResult.value.summary !== 'succeeded') {
+        const summary = simulationResult.value.summary as {
+          failed: { error: any; tx_signature: string }
+        }
+
+        // Extract readable error message from TransactionFailure
+        const errorMsg =
+          summary.failed?.error?.TransactionFailure?.[1] ||
+          JSON.stringify(summary.failed?.error) ||
+          'Unknown simulation error'
+
+        throw new Error(`Bundle simulation failed: ${errorMsg}`)
+      }
+
+      // Send bundle using JitoConnection method
+      bundleId = await jitoConnection.sendBundle(signedTransactions)
+      break
+    } catch (error) {
+      // Try next connection if this one fails
+      if (jitoConnection === jitoConnections[jitoConnections.length - 1]) {
+        throw error
+      }
+    }
+  }
+
+  if (!bundleId) {
+    throw new Error('Failed to send bundle to any Jito connection')
+  }
+
+  // Now confirm the bundle across all Jito connections in parallel
+  const confirmPromises = jitoConnections.map(async (jitoConnection) => {
+    try {
+      // Get initial blockhash and block height
+      const [blockhashResult, initialBlockHeight] = await Promise.all([
+        jitoConnection.getLatestBlockhash('confirmed'),
+        jitoConnection.getBlockHeight('confirmed'),
+      ])
+      let signatureResults: (SignatureResult | null)[] = txSignatures.map(
+        () => null
+      )
+
+      const pollingPromise = (async () => {
+        let pollingBlockHeight = initialBlockHeight
+        while (
+          pollingBlockHeight < blockhashResult.lastValidBlockHeight &&
+          !abortController.signal.aborted
+        ) {
+          const statusResponse =
+            await jitoConnection.getSignatureStatuses(txSignatures)
+
+          const allConfirmed = statusResponse.value.every(
+            (status) =>
+              status &&
+              (status.confirmationStatus === 'confirmed' ||
+                status.confirmationStatus === 'finalized')
+          )
+
+          if (allConfirmed) {
+            signatureResults = statusResponse.value
+            // Immediately abort all other connections when we find results
+            abortController.abort()
+            return signatureResults
+          }
+
+          await sleep(400)
+          // Update block height independently to avoid stale reads
+          if (!abortController.signal.aborted) {
+            pollingBlockHeight =
+              await jitoConnection.getBlockHeight('confirmed')
+          }
+        }
+        return null
+      })()
+
+      const sendingPromise = (async (): Promise<
+        (SignatureResult | null)[] | null
+      > => {
+        let sendingBlockHeight = initialBlockHeight
+        while (
+          sendingBlockHeight < blockhashResult.lastValidBlockHeight &&
+          !abortController.signal.aborted &&
+          signatureResults.every((r) => r === null)
+        ) {
+          try {
+            // Re-send bundle periodically
+            await jitoConnection.sendBundle(signedTransactions)
+          } catch (_) {
+            // Silently retry on send failures - polling will detect success
+          }
+
+          await sleep(1000)
+          if (!abortController.signal.aborted) {
+            sendingBlockHeight =
+              await jitoConnection.getBlockHeight('confirmed')
+          }
+        }
+        return null
+      })()
+
+      // Wait for polling to find the results
+      const result = await Promise.race([pollingPromise, sendingPromise])
+      return result
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return null // Don't treat abortion as an error
+      }
+      throw error
+    }
+  })
+
+  // Wait for the first connection to return (either success or timeout)
+  // If a connection finds confirmation, it aborts all others via abortController
+  // If all connections reject (throw errors), catch and return null array
+  const signatureResults =
+    (await Promise.any(confirmPromises).catch(() => null)) ??
+    txSignatures.map(() => null)
+
+  if (!abortController.signal.aborted) {
+    abortController.abort()
+  }
+
+  return {
+    bundleId,
+    txSignatures,
+    signatureResults,
+  }
+}

package/src/index.ts

@@ -125,6 +125,7 @@ export {
 export { getNameServiceAddress } from './services/getNameServiceAddress.js'
 export type {
   GetStatusRequestExtended,
+  GetStepTransactionRequest,
   QuoteRequest,
   QuoteRequestFromAmount,
   QuoteRequestToAmount,

package/src/services/api.ts

@@ -3,6 +3,7 @@ import {
   type ChainKey,
   type ChainsRequest,
   type ChainsResponse,
+  ChainType,
   type ConnectionsRequest,
   type ConnectionsResponse,
   type ContractCallsQuoteRequest,
@@ -247,17 +248,25 @@ 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 fromChain = await config.getChainById(step.action.fromChainId)
+
+  const isJitoBundleEnabled = Boolean(_config.routeOptions?.jitoBundle)
+  // add jitoBundle param to url if from chain is SVM and jitoBundle is enabled in config
+  if (fromChain.chainType === ChainType.SVM && isJitoBundleEnabled) {
+    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/services/types.ts

@@ -7,6 +7,10 @@ export type GetStatusRequestExtended = GetStatusRequest & {
   fromAddress?: string
 }
 
+export type GetStepTransactionRequest = {
+  jitoBundle?: boolean
+}
+
 export type QuoteRequestFromAmount = QuoteRequestBase
 
 export type QuoteRequestToAmount = Omit<QuoteRequestBase, 'fromAmount'> & {

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.5'
+export const version = '3.14.0-alpha.0'