@lifi/sdk 3.3.0 → 3.4.0

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/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.0'
+export const version = '3.4.0'