@lifi/sdk 3.14.0-alpha.0 → 3.14.1

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

@@ -1,5 +1,4 @@
 import type { SignatureResult, VersionedTransaction } from '@solana/web3.js'
-import bs58 from 'bs58'
 import { sleep } from '../../../utils/sleep.js'
 import { getJitoConnections } from '../connection.js'
 
@@ -13,8 +12,8 @@ export type BundleResult = {
  * 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
+ * @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[]
@@ -27,147 +26,67 @@ export async function sendAndConfirmBundle(
     )
   }
 
-  // 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) {
+  const confirmPromises = jitoConnections.map(async (jitoConnection) => {
     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
+      // Send initial bundle for this connection
+      let bundleId: string
+      try {
+        bundleId = await jitoConnection.sendBundle(signedTransactions)
+      } catch (_) {
+        return null
       }
-    }
-  }
 
-  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
+      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')
         ) {
-          const statusResponse =
+          // Bundle confirmed! Extract transaction signatures from bundle status
+          const txSignatures = bundleStatus.transactions
+          // Fetch individual signature results
+          const sigResponse =
             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
+          if (!sigResponse?.value || !Array.isArray(sigResponse.value)) {
+            // Keep polling, if can't find signature results.
+            continue
           }
 
-          await sleep(400)
-          // Update block height independently to avoid stale reads
-          if (!abortController.signal.aborted) {
-            pollingBlockHeight =
-              await jitoConnection.getBlockHeight('confirmed')
+          // Immediately abort all other connections when we find a result
+          abortController.abort()
+          return {
+            bundleId,
+            txSignatures,
+            signatureResults: sigResponse.value,
           }
         }
-        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')
-          }
+        await sleep(400)
+        if (!abortController.signal.aborted) {
+          currentBlockHeight = await jitoConnection.getBlockHeight('confirmed')
         }
-        return null
-      })()
+      }
 
-      // Wait for polling to find the results
-      const result = await Promise.race([pollingPromise, sendingPromise])
-      return result
+      return null
     } catch (error) {
       if (abortController.signal.aborted) {
         return null // Don't treat abortion as an error
@@ -176,20 +95,16 @@ export async function sendAndConfirmBundle(
     }
   })
 
-  // 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)
+  // Wait for first successful confirmation
+  const result = await Promise.any(confirmPromises).catch(() => null)
 
   if (!abortController.signal.aborted) {
     abortController.abort()
   }
 
-  return {
-    bundleId,
-    txSignatures,
-    signatureResults,
+  if (!result) {
+    throw new Error('Failed to send and confirm bundle')
   }
+
+  return result
 }

package/src/core/utils.ts

@@ -1,4 +1,4 @@
-import type { LiFiStep, Token } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 
 // Standard threshold for destination amount difference (0.5%)
 const standardThreshold = 0.005
@@ -28,15 +28,3 @@ export function checkStepSlippageThreshold(
   }
   return actualSlippage <= setSlippage
 }
-
-/**
- * Checks whether a given token is eligible for message signing.
- * Tokens with '₮' symbol in their name are disallowed,
- * since such tokens may have non-standard signing requirements or compatibility issues with hardware wallets.
- *
- * @param token - The token object to check.
- * @returns true if the token is allowed for message signing, false otherwise.
- */
-export const isTokenMessageSigningAllowed = (token: Token): boolean => {
-  return !token.name?.includes('₮') && !token.symbol?.includes('₮')
-}

package/src/index.ts

@@ -83,7 +83,6 @@ export type {
 export type { UTXOProvider, UTXOProviderOptions } from './core/UTXO/types.js'
 export { isUTXO } from './core/UTXO/types.js'
 export { UTXO } from './core/UTXO/UTXO.js'
-export { isTokenMessageSigningAllowed } from './core/utils.js'
 export { createConfig } from './createConfig.js'
 export { BaseError } from './errors/baseError.js'
 export type { ErrorCode } from './errors/constants.js'
@@ -125,12 +124,16 @@ export {
 export { getNameServiceAddress } from './services/getNameServiceAddress.js'
 export type {
   GetStatusRequestExtended,
-  GetStepTransactionRequest,
   QuoteRequest,
   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,9 +1,8 @@
 import {
-  type ChainId,
+  ChainId,
   type ChainKey,
   type ChainsRequest,
   type ChainsResponse,
-  ChainType,
   type ConnectionsRequest,
   type ConnectionsResponse,
   type ContractCallsQuoteRequest,
@@ -250,11 +249,10 @@ export const getStepTransaction = async (
 
   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) {
+
+  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}`
   }

package/src/services/types.ts

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

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/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.14.0-alpha.0'
+export const version = '3.14.1'

package/src/_cjs/core/Solana/jito/isJitoRpc.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJitoRpc = isJitoRpc;
-async function isJitoRpc(rpcUrl) {
-    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();
-        return !!data.result && !data.error;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=isJitoRpc.js.map

package/src/_cjs/core/Solana/jito/isJitoRpc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isJitoRpc.js","sourceRoot":"","sources":["../../../../core/Solana/jito/isJitoRpc.ts"],"names":[],"mappings":";;AAAA,8BAoBC;AApBM,KAAK,UAAU,SAAS,CAAC,MAAc;IAC5C,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE;YACnC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,OAAO,EAAE,KAAK;gBACd,EAAE,EAAE,CAAC;gBACL,MAAM,EAAE,gBAAgB;gBACxB,MAAM,EAAE,EAAE;aACX,CAAC;SACH,CAAC,CAAA;QAEF,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;QAGlC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAA;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC"}

package/src/_esm/core/Solana/jito/isJitoRpc.js

@@ -1,21 +0,0 @@
-export async function isJitoRpc(rpcUrl) {
-    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;
-    }
-}
-//# sourceMappingURL=isJitoRpc.js.map

package/src/_esm/core/Solana/jito/isJitoRpc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isJitoRpc.js","sourceRoot":"","sources":["../../../../core/Solana/jito/isJitoRpc.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAAc;IAC5C,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE;YACnC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,OAAO,EAAE,KAAK;gBACd,EAAE,EAAE,CAAC;gBACL,MAAM,EAAE,gBAAgB;gBACxB,MAAM,EAAE,EAAE;aACX,CAAC;SACH,CAAC,CAAA;QAEF,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;QAElC,wEAAwE;QACxE,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAA;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare function isJitoRpc(rpcUrl: string): Promise<boolean>;
-//# sourceMappingURL=isJitoRpc.d.ts.map

package/src/_types/core/Solana/jito/isJitoRpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isJitoRpc.d.ts","sourceRoot":"","sources":["../../../../core/Solana/jito/isJitoRpc.ts"],"names":[],"mappings":"AAAA,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBhE"}

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

@@ -1,21 +0,0 @@
-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
-  }
-}