@lifi/sdk 3.0.1 → 3.1.0-beta.0

package/src/_types/services/balance.d.ts

@@ -4,7 +4,7 @@ import type { Token, TokenAmount } from '@lifi/types';
  * @param walletAddress - A wallet address.
  * @param token - A Token object.
  * @returns An object containing the token and the amounts on different chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export declare const getTokenBalance: (walletAddress: string, token: Token) => Promise<TokenAmount | null>;
 /**
@@ -12,7 +12,7 @@ export declare const getTokenBalance: (walletAddress: string, token: Token) => P
  * @param walletAddress - A wallet address.
  * @param tokens - A list of Token objects.
  * @returns A list of objects containing the tokens and the amounts on different chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export declare const getTokenBalances: (walletAddress: string, tokens: Token[]) => Promise<TokenAmount[]>;
 /**
@@ -20,7 +20,7 @@ export declare const getTokenBalances: (walletAddress: string, tokens: Token[])
  * @param walletAddress - A walletaddress.
  * @param tokensByChain - A list of Token objects organized by chain ids.
  * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
- * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ * @throws {BaseError} Throws a ValidationError if parameters are invalid.
  */
 export declare const getTokenBalancesByChain: (walletAddress: string, tokensByChain: {
     [chainId: number]: Token[];

package/src/_types/types/request.d.ts

@@ -0,0 +1,4 @@
+export interface ExtendedRequestInit extends RequestInit {
+    retries?: number;
+}
+//# sourceMappingURL=request.d.ts.map

package/src/_types/types/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../types/request.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB"}

package/src/_types/utils/errors.d.ts

@@ -1,109 +1 @@
-declare enum ErrorType {
-    RPCError = "RPCError",
-    ProviderError = "ProviderError",
-    ServerError = "ServerError",
-    TransactionError = "TransactionError",
-    ValidationError = "ValidationError",
-    NotFoundError = "NotFoundError",
-    UnknownError = "UnknownError",
-    SlippageError = "SlippageError"
-}
-export declare enum LiFiErrorCode {
-    InternalError = 1000,
-    ValidationError = 1001,
-    TransactionUnderpriced = 1002,
-    TransactionFailed = 1003,
-    Timeout = 1004,
-    ProviderUnavailable = 1005,
-    NotFound = 1006,
-    ChainSwitchError = 1007,
-    TransactionUnprepared = 1008,
-    GasLimitError = 1009,
-    TransactionCanceled = 1010,
-    SlippageError = 1011,
-    SignatureRejected = 1012,
-    BalanceError = 1013,
-    AllowanceRequired = 1014,
-    InsufficientFunds = 1015,
-    ExchangeRateUpdateCanceled = 1016,
-    WalletChangedDuringExecution = 1017
-}
-export declare enum EthersErrorType {
-    ActionRejected = "ACTION_REJECTED",
-    CallExecption = "CALL_EXCEPTION",
-    InsufficientFunds = "INSUFFICIENT_FUNDS"
-}
-export declare enum EthersErrorMessage {
-    ERC20Allowance = "ERC20: transfer amount exceeds allowance",
-    LowGas = "intrinsic gas too low",
-    OutOfGas = "out of gas",
-    Underpriced = "underpriced",
-    LowReplacementFee = "replacement fee too low"
-}
-export declare enum ErrorMessage {
-    UnknownError = "Unknown error occurred.",
-    SlippageError = "The slippage is larger than the defined threshold. Please request a new route to get a fresh quote.",
-    GasLimitLow = "Gas limit is too low.",
-    TransactionUnderpriced = "Transaction is underpriced.",
-    Default = "Something went wrong."
-}
-export declare enum MetaMaskRPCErrorCode {
-    invalidInput = -32000,
-    resourceNotFound = -32001,
-    resourceUnavailable = -32002,
-    transactionRejected = -32003,
-    methodNotSupported = -32004,
-    limitExceeded = -32005,
-    parse = -32700,
-    invalidRequest = -32600,
-    methodNotFound = -32601,
-    invalidParams = -32602,
-    internal = -32603
-}
-export declare enum MetaMaskProviderErrorCode {
-    userRejectedRequest = 4001,
-    unauthorized = 4100,
-    unsupportedMethod = 4200,
-    disconnected = 4900,
-    chainDisconnected = 4901
-}
-export type ErrorCode = LiFiErrorCode | MetaMaskRPCErrorCode | MetaMaskProviderErrorCode;
-export declare class LiFiError extends Error {
-    code: ErrorCode;
-    htmlMessage?: string;
-    constructor(type: ErrorType, code: number, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class RPCError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ProviderError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ServerError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class ValidationError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class TransactionError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class SlippageError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class BalanceError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class NotFoundError extends LiFiError {
-    constructor(message: string, htmlMessage?: string, stack?: string);
-}
-export declare class UnknownError extends LiFiError {
-    constructor(code: ErrorCode, message: string, htmlMessage?: string, stack?: string);
-}
-export declare class HTTPError extends Error {
-    response: Response;
-    status: number;
-    constructor(response: Response);
-}
-export {};
 //# sourceMappingURL=errors.d.ts.map

package/src/_types/utils/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../utils/errors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../utils/errors.ts"],"names":[],"mappings":""}

package/src/_types/utils/index.d.ts

@@ -1,6 +1,5 @@
-export * from './errors.js';
+export * from '../errors/index.js';
 export * from './getTransactionMessage.js';
 export * from './median.js';
-export * from './parseError.js';
 export * from './utils.js';
 //# sourceMappingURL=index.d.ts.map

package/src/_types/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA"}

package/src/_types/version.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "3.0.1";
+export declare const version = "3.1.0-beta.0";
 //# sourceMappingURL=version.d.ts.map

package/src/_types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,UAAU,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,iBAAiB,CAAA"}

package/src/constants.ts

@@ -2,3 +2,4 @@ export const AddressZero = '0x0000000000000000000000000000000000000000'
 export const AlternativeAddressZero =
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
 export const wrappedSolAddress = 'So11111111111111111111111111111111111111112'
+export const SolSystemProgram = '11111111111111111111111111111111'

package/src/core/EVM/EVMStepExecutor.ts

@@ -13,22 +13,21 @@ import { publicActions } from 'viem'
 import { config } from '../../config.js'
 import { getStepTransaction } from '../../services/api.js'
 import {
-  LiFiErrorCode,
-  TransactionError,
-  ValidationError,
   getTransactionFailedMessage,
   isZeroAddress,
-  parseError,
 } from '../../utils/index.js'
+import { ValidationError, TransactionError } from '../../errors/errors.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { parseEVMErrors } from './parseEVMErrors.js'
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
+import { getSubstatusMessage } from '../processMessages.js'
 import { stepComparison } from '../stepComparison.js'
 import type {
   LiFiStepExtended,
   StepExecutorOptions,
   TransactionParameters,
 } from '../types.js'
-import { getSubstatusMessage } from '../utils.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { checkAllowance } from './checkAllowance.js'
 import { updateMultisigRouteProcess } from './multisig.js'
@@ -87,9 +86,13 @@ export class EVMStepExecutor extends BaseStepExecutor {
         },
       })
       this.statusManager.updateExecution(step, 'FAILED')
-      throw new TransactionError(
-        LiFiErrorCode.WalletChangedDuringExecution,
-        errorMessage
+      throw await parseEVMErrors(
+        new TransactionError(
+          LiFiErrorCode.WalletChangedDuringExecution,
+          errorMessage
+        ),
+        step,
+        process
       )
     }
     return updatedWalletClient
@@ -397,20 +400,20 @@ export class EVMStepExecutor extends BaseStepExecutor {
           process = this.statusManager.updateProcess(step, process.type, 'DONE')
         }
       } catch (e: any) {
-        const error = await parseError(e, step, process)
+        const error = await parseEVMErrors(e, step, process)
         process = this.statusManager.updateProcess(
           step,
           process.type,
           'FAILED',
           {
             error: {
-              message: error.message,
-              htmlMessage: error.htmlMessage,
+              message: error.cause.message,
               code: error.code,
             },
           }
         )
         this.statusManager.updateExecution(step, 'FAILED')
+
         throw error
       }
     }
@@ -479,8 +482,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
         },
       })
       this.statusManager.updateExecution(step, 'FAILED')
-      console.warn(e)
-      throw e
+      throw await parseEVMErrors(e as Error, step, process)
     }
 
     // DONE

package/src/core/EVM/checkAllowance.ts

@@ -1,7 +1,7 @@
 import type { Chain, LiFiStep, Process, ProcessType } from '@lifi/types'
 import type { Address, Hash, WalletClient } from 'viem'
 import { maxUint256 } from 'viem'
-import { parseError } from '../../utils/parseError.js'
+import { parseEVMErrors } from './parseEVMErrors.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { ExecutionOptions } from '../types.js'
 import { getAllowance } from './getAllowance.js'
@@ -100,15 +100,14 @@ export const checkAllowance = async (
       }
     }
   } catch (e: any) {
-    const error = await parseError(e, step, allowanceProcess)
+    const error = await parseEVMErrors(e, step, allowanceProcess)
     allowanceProcess = statusManager.updateProcess(
       step,
       allowanceProcess.type,
       'FAILED',
       {
         error: {
-          message: error.message,
-          htmlMessage: error.htmlMessage,
+          message: error.cause.message,
           code: error.code,
         },
       }

package/src/core/EVM/multisig.ts

@@ -1,6 +1,7 @@
 import type { ExtendedChain, LiFiStep, ProcessType } from '@lifi/types'
 import type { Hash } from 'viem'
-import { LiFiErrorCode, TransactionError } from '../../utils/errors.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { MultisigConfig, MultisigTxDetails } from './types.js'
 

package/src/core/EVM/parseEVMErrors.ts

@@ -0,0 +1,60 @@
+import { type LiFiStep, type Process } from '@lifi/types'
+import { TransactionError, UnknownError } from '../../errors/errors.js'
+import { SDKError } from '../../errors/SDKError.js'
+import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
+import { BaseError } from '../../utils/index.js'
+import { fetchTxErrorDetails } from '../../helpers.js'
+
+export const parseEVMErrors = async (
+  e: Error,
+  step?: LiFiStep,
+  process?: Process
+): Promise<SDKError> => {
+  if (e instanceof SDKError) {
+    e.step = e.step ?? step
+    e.process = e.process ?? process
+    return e
+  }
+
+  const baseError = await handleSpecificErrors(e, step, process)
+
+  return new SDKError(baseError, step, process)
+}
+
+const handleSpecificErrors = async (
+  e: any,
+  step?: LiFiStep,
+  process?: Process
+) => {
+  if (e.cause?.name === 'UserRejectedRequestError') {
+    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
+  }
+
+  if (
+    step &&
+    process?.txHash &&
+    e.code === LiFiErrorCode.TransactionFailed &&
+    e.message === ErrorMessage.TransactionReverted
+  ) {
+    const response = await fetchTxErrorDetails(
+      process.txHash,
+      step.action.fromChainId
+    )
+
+    const errorMessage = response?.error_message
+
+    if (errorMessage?.toLowerCase().includes('out of gas')) {
+      return new TransactionError(
+        LiFiErrorCode.GasLimitError,
+        ErrorMessage.GasLimitLow,
+        e
+      )
+    }
+  }
+
+  if (e instanceof BaseError) {
+    return e
+  }
+
+  return new UnknownError(e.message || ErrorMessage.UnknownError, e)
+}

package/src/core/EVM/publicClient.ts

@@ -1,6 +1,6 @@
 import { ChainId } from '@lifi/types'
 import type { PublicClient } from 'viem'
-import { createPublicClient, fallback, http } from 'viem'
+import { createPublicClient, fallback, http, webSocket } from 'viem'
 import { mainnet, type Chain } from 'viem/chains'
 import { config } from '../../config.js'
 import { getRpcUrls } from '../rpc.js'
@@ -19,9 +19,11 @@ export const getPublicClient = async (
   if (!publicClients[chainId]) {
     const urls = await getRpcUrls(chainId)
     const fallbackTransports = urls.map((url) =>
-      http(url, {
-        batch: true,
-      })
+      url.startsWith('wss')
+        ? webSocket(url)
+        : http(url, {
+            batch: true,
+          })
     )
     const _chain = await config.getChainById(chainId)
     const chain: Chain = {
@@ -43,6 +45,9 @@ export const getPublicClient = async (
     publicClients[chainId] = createPublicClient({
       chain: chain,
       transport: fallback(fallbackTransports),
+      batch: {
+        multicall: true,
+      },
     })
   }
 

package/src/core/EVM/switchChain.ts

@@ -1,5 +1,6 @@
 import type { WalletClient } from 'viem'
-import { LiFiErrorCode, ProviderError } from '../../utils/errors.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { ProviderError } from '../../errors/errors.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { LiFiStepExtended, SwitchChainHook } from '../types.js'
 

package/src/core/Solana/SolanaStepExecutor.ts

@@ -1,39 +1,36 @@
 import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
 import { type SignerWalletAdapter } from '@solana/wallet-adapter-base'
 import {
+  TransactionExpiredBlockheightExceededError,
   VersionedTransaction,
   type SendOptions,
   type SignatureResult,
 } from '@solana/web3.js'
+import bs58 from 'bs58'
 import { config } from '../../config.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
 import { base64ToUint8Array } from '../../utils/base64ToUint8Array.js'
-import {
-  LiFiErrorCode,
-  TransactionError,
-  getTransactionFailedMessage,
-  parseError,
-} from '../../utils/index.js'
+import { getTransactionFailedMessage } from '../../utils/index.js'
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
+import { getSubstatusMessage } from '../processMessages.js'
 import { stepComparison } from '../stepComparison.js'
 import type {
   LiFiStepExtended,
   StepExecutorOptions,
   TransactionParameters,
 } from '../types.js'
-import { getSubstatusMessage } from '../utils.js'
+import { sleep } from '../utils.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { getSolanaConnection } from './connection.js'
+import { parseSolanaErrors } from './parseSolanaErrors.js'
 
 export interface SolanaStepExecutorOptions extends StepExecutorOptions {
   walletAdapter: SignerWalletAdapter
 }
 
-const TX_RETRY_INTERVAL = 500
-// https://solana.com/docs/advanced/confirmation
-const TIMEOUT_PERIOD = 60_000
-
 export class SolanaStepExecutor extends BaseStepExecutor {
   private walletAdapter: SignerWalletAdapter
 
@@ -117,6 +114,10 @@ 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({
@@ -141,18 +142,25 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           base64ToUint8Array(transactionRequest.data)
         )
 
-        const blockhashResult = await connection.getLatestBlockhashAndContext({
-          commitment: 'confirmed',
-        })
+        this.checkWalletAdapter(step)
 
-        // Update transaction recent blockhash with the latest blockhash
-        versionedTransaction.message.recentBlockhash =
-          blockhashResult.value.blockhash
+        const signedTxPromise =
+          this.walletAdapter.signTransaction(versionedTransaction)
 
-        this.checkWalletAdapter(step)
+        // We give users 2 minutes to sign the transaction or it should be considered expired
+        const signedTx = await Promise.race([
+          signedTxPromise,
+          // https://solana.com/docs/advanced/confirmation#transaction-expiration
+          // Use 2 minutes to account for fluctuations
+          sleep(120_000),
+        ])
 
-        const signedTx =
-          await this.walletAdapter.signTransaction(versionedTransaction)
+        if (!signedTx) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionExpired,
+            'Transaction has expired: blockhash is no longer recent enough.'
+          )
+        }
 
         process = this.statusManager.updateProcess(
           step,
@@ -160,63 +168,96 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           'PENDING'
         )
 
-        const rawTransactionOptions: SendOptions = {
-          // Skipping preflight i.e. tx simulation by RPC as we simulated the tx above
-          skipPreflight: true,
-          // Setting max retries to 0 as we are handling retries manually
-          // Set this manually so that the default is skipped
-          maxRetries: 0,
-          // https://solana.com/docs/advanced/confirmation#use-an-appropriate-preflight-commitment-level
-          preflightCommitment: 'confirmed',
-          // minContextSlot: blockhashResult.context.slot,
+        const simulationResult = await connection.simulateTransaction(
+          signedTx,
+          {
+            commitment: 'processed',
+            replaceRecentBlockhash: true,
+          }
+        )
+
+        if (simulationResult.value.err) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionSimulationFailed,
+            'Transaction simulation failed'
+          )
         }
 
-        const txSignature = await connection.sendRawTransaction(
-          signedTx.serialize(),
-          rawTransactionOptions
-        )
+        // 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.value.blockhash,
-              lastValidBlockHeight: blockhashResult.value.lastValidBlockHeight,
+              blockhash: blockhashResult.blockhash,
+              lastValidBlockHeight: lastValidBlockHeight,
+              abortSignal: abortController.signal,
             },
             'confirmed'
           )
           .then((result) => result.value)
 
         let confirmedTx: SignatureResult | null = null
-        const startTime = Date.now()
+        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',
+        }
 
-        while (!confirmedTx && Date.now() - startTime <= TIMEOUT_PERIOD) {
+        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,
-            new Promise<null>((resolve) =>
-              setTimeout(() => {
-                resolve(null)
-              }, TX_RETRY_INTERVAL)
-            ),
+            sleep(1000),
           ])
           if (confirmedTx) {
             break
           }
-
-          await connection.sendRawTransaction(
-            signedTx.serialize(),
-            rawTransactionOptions
-          )
+          blockHeight = await connection.getBlockHeight()
         }
 
+        // Stop waiting for tx confirmation
+        abortController.abort()
+
         if (confirmedTx?.err) {
           const reason =
             typeof confirmedTx.err === 'object'
               ? JSON.stringify(confirmedTx.err)
               : confirmedTx.err
+          if (
+            confirmedTx.err instanceof
+            TransactionExpiredBlockheightExceededError
+          ) {
+            throw new TransactionError(
+              LiFiErrorCode.TransactionExpired,
+              `${reason}`
+            )
+          }
           throw new TransactionError(
             LiFiErrorCode.TransactionFailed,
             `Transaction failed: ${reason}`
@@ -225,8 +266,8 @@ export class SolanaStepExecutor extends BaseStepExecutor {
 
         if (!confirmedTx) {
           throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
-            'Failed to land the transaction'
+            LiFiErrorCode.TransactionExpired,
+            'Transaction has expired: The block height has exceeded the maximum allowed limit.'
           )
         }
 
@@ -245,15 +286,14 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           process = this.statusManager.updateProcess(step, process.type, 'DONE')
         }
       } catch (e: any) {
-        const error = await parseError(e, step, process)
+        const error = await parseSolanaErrors(e, step, process)
         process = this.statusManager.updateProcess(
           step,
           process.type,
           'FAILED',
           {
             error: {
-              message: error.message,
-              htmlMessage: error.htmlMessage,
+              message: error.cause.message,
               code: error.code,
             },
           }

package/src/core/Solana/connection.ts

@@ -5,9 +5,8 @@ import { getRpcUrl } from '../rpc.js'
 let connection: Connection | undefined = undefined
 
 /**
- * getSolanaConnection is just a thin wrapper around getting the
- * connection (rpc provider) for Solana
- * @returns - Solana rpc connection
+ * getSolanaConnection is just a thin wrapper around getting the connection (RPC provider) for Solana
+ * @returns - Solana RPC connection
  */
 export const getSolanaConnection = async (): Promise<Connection> => {
   if (!connection) {