@lifi/sdk 3.3.1 → 3.4.1

package/src/core/Solana/SolanaStepExecutor.ts

@@ -1,11 +1,6 @@
 import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
 import type { SignerWalletAdapter } from '@solana/wallet-adapter-base'
-import {
-  type SendOptions,
-  type SignatureResult,
-  VersionedTransaction,
-} from '@solana/web3.js'
-import bs58 from 'bs58'
+import { VersionedTransaction } from '@solana/web3.js'
 import { withTimeout } from 'viem'
 import { config } from '../../config.js'
 import { LiFiErrorCode } from '../../errors/constants.js'
@@ -13,7 +8,6 @@ import { TransactionError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
 import { base64ToUint8Array } from '../../utils/base64ToUint8Array.js'
 import { getTransactionFailedMessage } from '../../utils/getTransactionMessage.js'
-import { sleep } from '../../utils/sleep.js'
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
 import { getSubstatusMessage } from '../processMessages.js'
@@ -24,8 +18,9 @@ import type {
   TransactionParameters,
 } from '../types.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
-import { getSolanaConnection } from './connection.js'
+import { callSolanaWithRetry } from './connection.js'
 import { parseSolanaErrors } from './parseSolanaErrors.js'
+import { sendAndConfirmTransaction } from './sendAndConfirmTransaction.js'
 
 export interface SolanaStepExecutorOptions extends StepExecutorOptions {
   walletAdapter: SignerWalletAdapter
@@ -66,8 +61,6 @@ export class SolanaStepExecutor extends BaseStepExecutor {
 
     if (process.status !== 'DONE') {
       try {
-        const connection = await getSolanaConnection()
-
         process = this.statusManager.updateProcess(
           step,
           process.type,
@@ -115,10 +108,6 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           data: step.transactionRequest.data,
         }
 
-        const blockhashResult = await connection.getLatestBlockhash({
-          commitment: 'confirmed',
-        })
-
         if (this.executionOptions?.updateTransactionRequestHook) {
           const customizedTransactionRequest: TransactionParameters =
             await this.executionOptions.updateTransactionRequestHook({
@@ -165,12 +154,11 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           'PENDING'
         )
 
-        const simulationResult = await connection.simulateTransaction(
-          signedTx,
-          {
-            commitment: 'processed',
+        const simulationResult = await callSolanaWithRetry((connection) =>
+          connection.simulateTransaction(signedTx, {
+            commitment: 'confirmed',
             replaceRecentBlockhash: true,
-          }
+          })
         )
 
         if (simulationResult.value.err) {
@@ -180,79 +168,20 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           )
         }
 
-        // Create transaction hash (signature)
-        const txSignature = bs58.encode(signedTx.signatures[0])
-
-        // A known weirdness - MAX_RECENT_BLOCKHASHES is 300
-        // https://github.com/solana-labs/solana/blob/master/sdk/program/src/clock.rs#L123
-        // but MAX_PROCESSING_AGE is 150
-        // https://github.com/solana-labs/solana/blob/master/sdk/program/src/clock.rs#L129
-        // the blockhash queue in the bank tells you 300 + current slot, but it won't be accepted 150 blocks later.
-        // https://solana.com/docs/advanced/confirmation#transaction-expiration
-        const lastValidBlockHeight = blockhashResult.lastValidBlockHeight - 150
-
-        // In the following section, we wait and constantly check for the transaction to be confirmed
-        // and resend the transaction if it is not confirmed within a certain time interval
-        // thus handling tx retries on the client side rather than relying on the RPC
-        const abortController = new AbortController()
-        const confirmTransactionPromise = connection
-          .confirmTransaction(
-            {
-              signature: txSignature,
-              blockhash: blockhashResult.blockhash,
-              lastValidBlockHeight: lastValidBlockHeight,
-              abortSignal: abortController.signal,
-            },
-            'confirmed'
-          )
-          .then((result) => result.value)
-
-        let confirmedTx: SignatureResult | null = null
-        let blockHeight = await connection.getBlockHeight()
-
-        const rawTransactionOptions: SendOptions = {
-          // We can skip preflight check after the first transaction has been sent
-          // https://solana.com/docs/advanced/retry#the-cost-of-skipping-preflight
-          skipPreflight: true,
-          // Setting max retries to 0 as we are handling retries manually
-          maxRetries: 0,
-          // https://solana.com/docs/advanced/confirmation#use-an-appropriate-preflight-commitment-level
-          preflightCommitment: 'confirmed',
-        }
-
-        const signedTxSerialized = signedTx.serialize()
-
-        // https://solana.com/docs/advanced/retry#customizing-rebroadcast-logic
-        while (!confirmedTx && blockHeight < lastValidBlockHeight) {
-          await connection.sendRawTransaction(
-            signedTxSerialized,
-            rawTransactionOptions
-          )
-          confirmedTx = await Promise.race([
-            confirmTransactionPromise,
-            sleep(1000),
-          ])
-          if (confirmedTx) {
-            break
-          }
-          blockHeight = await connection.getBlockHeight()
-        }
-
-        // Stop waiting for tx confirmation
-        abortController.abort()
+        const confirmedTx = await sendAndConfirmTransaction(signedTx)
 
-        if (!confirmedTx) {
+        if (!confirmedTx.signatureResult) {
           throw new TransactionError(
             LiFiErrorCode.TransactionExpired,
             'Transaction has expired: The block height has exceeded the maximum allowed limit.'
           )
         }
 
-        if (confirmedTx?.err) {
+        if (confirmedTx.signatureResult.err) {
           const reason =
-            typeof confirmedTx.err === 'object'
-              ? JSON.stringify(confirmedTx.err)
-              : confirmedTx.err
+            typeof confirmedTx.signatureResult.err === 'object'
+              ? JSON.stringify(confirmedTx.signatureResult.err)
+              : confirmedTx.signatureResult.err
           throw new TransactionError(
             LiFiErrorCode.TransactionFailed,
             `Transaction failed: ${reason}`
@@ -265,8 +194,8 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           process.type,
           'PENDING',
           {
-            txHash: txSignature,
-            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txSignature}`,
+            txHash: confirmedTx.txSignature,
+            txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${confirmedTx.txSignature}`,
           }
         )
 

package/src/core/Solana/connection.ts

@@ -1,18 +1,51 @@
 import { ChainId } from '@lifi/types'
 import { Connection } from '@solana/web3.js'
-import { getRpcUrl } from '../rpc.js'
+import { getRpcUrls } from '../rpc.js'
 
-let connection: Connection | undefined = undefined
+const connections = new Map<string, Connection>()
 
 /**
- * getSolanaConnection is just a thin wrapper around getting the connection (RPC provider) for Solana
- * @returns - Solana RPC connection
+ * Initializes the Solana connections if they haven't been initialized yet.
+ * @returns - Promise that resolves when connections are initialized.
  */
-export const getSolanaConnection = async (): Promise<Connection> => {
-  if (!connection) {
-    const rpcUrl = await getRpcUrl(ChainId.SOL)
-    connection = new Connection(rpcUrl)
-    return connection
+export const ensureConnections = async (): Promise<void> => {
+  const rpcUrls = await getRpcUrls(ChainId.SOL)
+  for (const rpcUrl of rpcUrls) {
+    if (!connections.get(rpcUrl)) {
+      const connection = new Connection(rpcUrl)
+      connections.set(rpcUrl, connection)
+    }
   }
-  return connection
+}
+
+/**
+ * Wrapper around getting the connection (RPC provider) for Solana
+ * @returns - Solana RPC connections
+ */
+export const getSolanaConnections = async (): Promise<Connection[]> => {
+  await ensureConnections()
+  return Array.from(connections.values())
+}
+
+/**
+ * Calls a function on the Connection instances with retry logic.
+ * @param fn - The function to call, which receives a Connection instance.
+ * @returns - The result of the function call.
+ */
+export async function callSolanaWithRetry<R>(
+  fn: (connection: Connection) => Promise<R>
+): Promise<R> {
+  // Ensure connections are initialized
+  await ensureConnections()
+  let lastError: any = null
+  for (const connection of connections.values()) {
+    try {
+      const result = await fn(connection)
+      return result
+    } catch (error) {
+      lastError = error
+    }
+  }
+  // Throw the last encountered error
+  throw lastError
 }

package/src/core/Solana/getSolanaBalance.ts

@@ -1,7 +1,8 @@
 import type { ChainId, Token, TokenAmount } from '@lifi/types'
 import { PublicKey } from '@solana/web3.js'
 import { SolSystemProgram } from '../../constants.js'
-import { getSolanaConnection } from './connection.js'
+import { withDedupe } from '../../utils/withDedupe.js'
+import { callSolanaWithRetry } from './connection.js'
 import { TokenProgramAddress } from './types.js'
 
 export const getSolanaBalance = async (
@@ -26,15 +27,34 @@ const getSolanaBalanceDefault = async (
   tokens: Token[],
   walletAddress: string
 ): Promise<TokenAmount[]> => {
-  const connection = await getSolanaConnection()
   const accountPublicKey = new PublicKey(walletAddress)
   const tokenProgramPublicKey = new PublicKey(TokenProgramAddress)
   const [slot, balance, tokenAccountsByOwner] = await Promise.allSettled([
-    connection.getSlot(),
-    connection.getBalance(accountPublicKey),
-    connection.getParsedTokenAccountsByOwner(accountPublicKey, {
-      programId: tokenProgramPublicKey,
-    }),
+    withDedupe(
+      () =>
+        callSolanaWithRetry((connection) => connection.getSlot('confirmed')),
+      { id: `${getSolanaBalanceDefault.name}.getSlot` }
+    ),
+    withDedupe(
+      () =>
+        callSolanaWithRetry((connection) =>
+          connection.getBalance(accountPublicKey, 'confirmed')
+        ),
+      { id: `${getSolanaBalanceDefault.name}.getBalance` }
+    ),
+    withDedupe(
+      () =>
+        callSolanaWithRetry((connection) =>
+          connection.getParsedTokenAccountsByOwner(
+            accountPublicKey,
+            {
+              programId: tokenProgramPublicKey,
+            },
+            'confirmed'
+          )
+        ),
+      { id: `${getSolanaBalanceDefault.name}.getParsedTokenAccountsByOwner` }
+    ),
   ])
   const blockNumber = slot.status === 'fulfilled' ? BigInt(slot.value) : 0n
   const solBalance = balance.status === 'fulfilled' ? BigInt(balance.value) : 0n

package/src/core/Solana/sendAndConfirmTransaction.ts

@@ -0,0 +1,111 @@
+import type {
+  SendOptions,
+  SignatureResult,
+  VersionedTransaction,
+} from '@solana/web3.js'
+import bs58 from 'bs58'
+import { sleep } from '../../utils/sleep.js'
+import { getSolanaConnections } from './connection.js'
+
+export type ConfirmedTransactionResult = {
+  signatureResult: SignatureResult | null
+  txSignature: string
+}
+
+/**
+ * Sends a Solana transaction to multiple RPC endpoints and returns the confirmation
+ * as soon as any of them confirm the transaction.
+ * @param signedTx - The signed transaction to send.
+ * @returns - The confirmation result of the transaction.
+ */
+export async function sendAndConfirmTransaction(
+  signedTx: VersionedTransaction
+): Promise<ConfirmedTransactionResult> {
+  const connections = await getSolanaConnections()
+
+  const signedTxSerialized = signedTx.serialize()
+  // Create transaction hash (signature)
+  const txSignature = bs58.encode(signedTx.signatures[0])
+
+  if (!txSignature) {
+    throw new Error('Transaction signature is missing.')
+  }
+
+  const rawTransactionOptions: SendOptions = {
+    // We can skip preflight check after the first transaction has been sent
+    // https://solana.com/docs/advanced/retry#the-cost-of-skipping-preflight
+    skipPreflight: true,
+    // Setting max retries to 0 as we are handling retries manually
+    maxRetries: 0,
+    // https://solana.com/docs/advanced/confirmation#use-an-appropriate-preflight-commitment-level
+    preflightCommitment: 'confirmed',
+  }
+
+  for (const connection of connections) {
+    connection
+      .sendRawTransaction(signedTxSerialized, rawTransactionOptions)
+      .catch()
+  }
+
+  const abortControllers: AbortController[] = []
+
+  const confirmPromises = connections.map(async (connection) => {
+    const abortController = new AbortController()
+    abortControllers.push(abortController)
+    try {
+      const blockhashResult = await connection.getLatestBlockhash('confirmed')
+
+      const confirmTransactionPromise = connection
+        .confirmTransaction(
+          {
+            signature: txSignature,
+            blockhash: blockhashResult.blockhash,
+            lastValidBlockHeight: blockhashResult.lastValidBlockHeight,
+            abortSignal: abortController.signal,
+          },
+          'confirmed'
+        )
+        .then((result) => result.value)
+
+      let signatureResult: SignatureResult | null = null
+      let blockHeight = await connection.getBlockHeight('confirmed')
+
+      while (
+        !signatureResult &&
+        blockHeight < blockhashResult.lastValidBlockHeight
+      ) {
+        await connection.sendRawTransaction(
+          signedTxSerialized,
+          rawTransactionOptions
+        )
+        signatureResult = await Promise.race([
+          confirmTransactionPromise,
+          sleep(1000),
+        ])
+
+        if (signatureResult || abortController.signal.aborted) {
+          break
+        }
+
+        blockHeight = await connection.getBlockHeight('confirmed')
+      }
+
+      abortController.abort()
+
+      return signatureResult
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return Promise.reject(new Error('Confirmation aborted.'))
+      }
+      throw error
+    }
+  })
+
+  const signatureResult = await Promise.any(confirmPromises).catch(() => null)
+
+  for (const abortController of abortControllers) {
+    abortController.abort()
+  }
+
+  return { signatureResult, txSignature }
+}

package/src/index.ts

@@ -11,7 +11,10 @@ export {
   revokeTokenApproval,
   setTokenAllowance,
 } from './core/EVM/setAllowance.js'
+export { isEVM } from './core/EVM/types.js'
 export type {
+  EVMProvider,
+  EVMProviderOptions,
   MultisigConfig,
   MultisigTransaction,
   MultisigTxDetails,
@@ -53,7 +56,14 @@ export {
   KeypairWalletName,
 } from './core/Solana/KeypairWalletAdapter.js'
 export { Solana } from './core/Solana/Solana.js'
+export { isSolana } from './core/Solana/types.js'
+export type {
+  SolanaProvider,
+  SolanaProviderOptions,
+} from './core/Solana/types.js'
 export { UTXO } from './core/UTXO/UTXO.js'
+export { isUTXO } from './core/UTXO/types.js'
+export type { UTXOProvider, UTXOProviderOptions } from './core/UTXO/types.js'
 export { createConfig } from './createConfig.js'
 export {
   checkPackageUpdates,

package/src/utils/withDedupe.ts

@@ -29,10 +29,10 @@ type WithDedupeOptions = {
 }
 
 /** Deduplicates in-flight promises. */
-export function withDedupe<data>(
-  fn: () => Promise<data>,
+export function withDedupe<T>(
+  fn: () => Promise<T>,
   { enabled = true, id }: WithDedupeOptions
-): Promise<data> {
+): Promise<T> {
   if (!enabled || !id) {
     return fn()
   }

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.3.1'
+export const version = '3.4.1'