@lifi/sdk 3.0.0 → 3.0.2-beta.0

package/src/_types/version.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "@lifi/sdk";
-export declare const version = "3.0.0";
+export declare const version = "3.0.2-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/config.ts

@@ -77,7 +77,10 @@ export const config = (() => {
         if (!_config.rpcUrls[chainId]?.length) {
           _config.rpcUrls[chainId] = Array.from(urls)
         } else {
-          _config.rpcUrls[chainId]?.push(...urls)
+          const filteredUrls = urls.filter(
+            (url) => !_config.rpcUrls[chainId]?.includes(url)
+          )
+          _config.rpcUrls[chainId]?.push(...filteredUrls)
         }
       }
     },

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

@@ -6,7 +6,6 @@ import type {
 import type {
   Hash,
   PublicClient,
-  ReplacementReason,
   SendTransactionParameters,
   WalletClient,
 } from 'viem'
@@ -23,19 +22,20 @@ import {
 } 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 { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { checkAllowance } from './checkAllowance.js'
 import { updateMultisigRouteProcess } from './multisig.js'
 import { switchChain } from './switchChain.js'
 import type { MultisigConfig, MultisigTransaction } from './types.js'
-import { getMaxPriorityFeePerGas, retryCount, retryDelay } from './utils.js'
+import { getMaxPriorityFeePerGas } from './utils.js'
+import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
 export interface EVMStepExecutorOptions extends StepExecutorOptions {
   walletClient: WalletClient
@@ -350,40 +350,23 @@ export class EVMStepExecutor extends BaseStepExecutor {
           }
         }
 
-        let replacementReason: ReplacementReason | undefined
-        const transactionReceipt = await this.walletClient
-          .extend(publicActions)
-          .waitForTransactionReceipt({
-            hash: txHash,
-            onReplaced: (response) => {
-              replacementReason = response.reason
-              this.statusManager.updateProcess(step, process.type, 'PENDING', {
-                txHash: response.transaction.hash,
-                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
-              })
-            },
-            retryCount,
-            retryDelay,
-          })
-
-        if (transactionReceipt.status === 'reverted') {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
-            'Transaction was reverted.'
-          )
-        }
-        if (replacementReason === 'cancelled') {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionCanceled,
-            'User canceled transaction.'
-          )
-        }
+        const transactionReceipt = await waitForTransactionReceipt({
+          walletClient: this.walletClient,
+          chainId: fromChain.id,
+          txHash,
+          onReplaced: (response) => {
+            this.statusManager.updateProcess(step, process.type, 'PENDING', {
+              txHash: response.transaction.hash,
+              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
+            })
+          },
+        })
 
         // if it's multisig wallet client and the process is in ACTION_REQUIRED
         // then signatures are still needed
         if (isMultisigWalletClient && process.status === 'ACTION_REQUIRED') {
           await updateMultisigRouteProcess(
-            transactionReceipt.transactionHash,
+            transactionReceipt?.transactionHash || txHash,
             step,
             process.type,
             fromChain,
@@ -392,7 +375,13 @@ export class EVMStepExecutor extends BaseStepExecutor {
           )
         }
 
-        if (!isMultisigWalletClient) {
+        // Update pending process if the transaction hash from the receipt is different.
+        // This might happen if the transaction was replaced.
+        if (
+          !isMultisigWalletClient &&
+          transactionReceipt?.transactionHash &&
+          transactionReceipt.transactionHash !== txHash
+        ) {
           process = this.statusManager.updateProcess(
             step,
             process.type,

package/src/core/EVM/checkAllowance.ts

@@ -1,13 +1,12 @@
 import type { Chain, LiFiStep, Process, ProcessType } from '@lifi/types'
-import type { Address, Hash, ReplacementReason, WalletClient } from 'viem'
-import { maxUint256, publicActions } from 'viem'
-import { LiFiErrorCode, TransactionError } from '../../utils/index.js'
+import type { Address, Hash, WalletClient } from 'viem'
+import { maxUint256 } from 'viem'
 import { parseError } from '../../utils/parseError.js'
 import type { StatusManager } from '../StatusManager.js'
 import type { ExecutionOptions } from '../types.js'
 import { getAllowance } from './getAllowance.js'
 import { setAllowance } from './setAllowance.js'
-import { retryCount, retryDelay } from './utils.js'
+import { waitForTransactionReceipt } from './waitForTransactionReceipt.js'
 
 export const checkAllowance = async (
   chain: Chain,
@@ -127,42 +126,26 @@ const waitForApprovalTransaction = async (
   chain: Chain,
   statusManager: StatusManager
 ) => {
-  const client = walletClient.extend(publicActions)
   statusManager.updateProcess(step, processType, 'PENDING', {
     txHash,
     txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
   })
 
-  let replacementReason: ReplacementReason | undefined
-  const transactionReceipt = await client.waitForTransactionReceipt({
-    hash: txHash,
+  const transactionReceipt = await waitForTransactionReceipt({
+    walletClient,
+    chainId: chain.id,
+    txHash: txHash,
     onReplaced(response) {
-      replacementReason = response.reason
       statusManager.updateProcess(step, processType, 'PENDING', {
         txHash: response.transaction.hash,
         txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${response.transaction.hash}`,
       })
     },
-    retryCount,
-    retryDelay,
   })
 
-  if (transactionReceipt.status === 'reverted') {
-    throw new TransactionError(
-      LiFiErrorCode.TransactionFailed,
-      'Transaction was reverted.'
-    )
-  }
-
-  if (replacementReason === 'cancelled') {
-    throw new TransactionError(
-      LiFiErrorCode.TransactionCanceled,
-      'User canceled transaction.'
-    )
-  }
-
+  const transactionHash = transactionReceipt?.transactionHash || txHash
   statusManager.updateProcess(step, processType, 'DONE', {
-    txHash: transactionReceipt.transactionHash,
-    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+    txHash: transactionHash,
+    txLink: `${chain.metamask.blockExplorerUrls[0]}tx/${transactionHash}`,
   })
 }

package/src/core/EVM/utils.ts

@@ -45,4 +45,4 @@ export const getMulticallAddress = async (
 export const retryDelay = ({ count }: { count: number; error: Error }) =>
   Math.min(~~(1 << count) * 200, 3000)
 
-export const retryCount = 20
+export const retryCount = 30

package/src/core/EVM/waitForTransactionReceipt.ts

@@ -0,0 +1,86 @@
+import type { ChainId } from '@lifi/types'
+import type {
+  Chain,
+  Hash,
+  PublicClient,
+  ReplacementReason,
+  ReplacementReturnType,
+  TransactionReceipt,
+  WalletClient,
+} from 'viem'
+import { publicActions } from 'viem'
+import { LiFiErrorCode, TransactionError } from '../../utils/index.js'
+import { getPublicClient } from './publicClient.js'
+import { retryCount, retryDelay } from './utils.js'
+
+interface WaitForTransactionReceiptProps {
+  walletClient: WalletClient
+  chainId: ChainId
+  txHash: Hash
+  onReplaced?: (response: ReplacementReturnType<Chain | undefined>) => void
+}
+
+export async function waitForTransactionReceipt({
+  walletClient,
+  chainId,
+  txHash,
+  onReplaced,
+}: WaitForTransactionReceiptProps): Promise<TransactionReceipt | undefined> {
+  let { transactionReceipt, replacementReason } = await waitForReceipt(
+    walletClient.extend(publicActions),
+    txHash,
+    onReplaced
+  )
+
+  if (!transactionReceipt?.status) {
+    const publicClient = await getPublicClient(chainId)
+    const result = await waitForReceipt(publicClient, txHash, onReplaced)
+    transactionReceipt = result.transactionReceipt
+    replacementReason = result.replacementReason
+  }
+
+  if (transactionReceipt?.status === 'reverted') {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionFailed,
+      'Transaction was reverted.'
+    )
+  }
+  if (replacementReason === 'cancelled') {
+    throw new TransactionError(
+      LiFiErrorCode.TransactionCanceled,
+      'User canceled transaction.'
+    )
+  }
+
+  return transactionReceipt
+}
+
+async function waitForReceipt(
+  client: PublicClient | WalletClient,
+  txHash: Hash,
+  onReplaced?: (response: ReplacementReturnType<Chain | undefined>) => void
+): Promise<{
+  transactionReceipt?: TransactionReceipt
+  replacementReason?: ReplacementReason
+}> {
+  let replacementReason: ReplacementReason | undefined
+  let transactionReceipt: TransactionReceipt | undefined
+
+  try {
+    transactionReceipt = await (
+      client as PublicClient
+    ).waitForTransactionReceipt({
+      hash: txHash,
+      onReplaced: (response) => {
+        replacementReason = response.reason
+        onReplaced?.(response)
+      },
+      retryCount,
+      retryDelay,
+    })
+  } catch (error) {
+    // We can ignore errors from waitForTransactionReceipt as we have a status check fallback
+  }
+
+  return { transactionReceipt, replacementReason }
+}

package/src/core/Solana/KeypairWalletAdapter.ts

@@ -16,7 +16,7 @@ import type {
   VersionedTransaction,
 } from '@solana/web3.js'
 import { Keypair } from '@solana/web3.js'
-import * as bs58 from 'bs58'
+import bs58 from 'bs58'
 
 export const KeypairWalletName =
   'Keypair Wallet' as WalletName<'Keypair Wallet'>

package/src/core/Solana/SolanaStepExecutor.ts

@@ -1,6 +1,7 @@
 import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
 import { type SignerWalletAdapter } from '@solana/wallet-adapter-base'
 import {
+  TransactionExpiredBlockheightExceededError,
   VersionedTransaction,
   type SendOptions,
   type SignatureResult,
@@ -16,13 +17,14 @@ import {
 } 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'
 
@@ -30,7 +32,7 @@ export interface SolanaStepExecutorOptions extends StepExecutorOptions {
   walletAdapter: SignerWalletAdapter
 }
 
-const TX_RETRY_INTERVAL = 500
+const TX_RETRY_INTERVAL = 1000
 // https://solana.com/docs/advanced/confirmation
 const TIMEOUT_PERIOD = 60_000
 
@@ -117,6 +119,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,14 +147,6 @@ export class SolanaStepExecutor extends BaseStepExecutor {
           base64ToUint8Array(transactionRequest.data)
         )
 
-        const blockhashResult = await connection.getLatestBlockhashAndContext({
-          commitment: 'confirmed',
-        })
-
-        // Update transaction recent blockhash with the latest blockhash
-        versionedTransaction.message.recentBlockhash =
-          blockhashResult.value.blockhash
-
         this.checkWalletAdapter(step)
 
         const signedTx =
@@ -179,12 +177,14 @@ export class SolanaStepExecutor extends BaseStepExecutor {
         // 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: blockhashResult.lastValidBlockHeight,
+              abortSignal: abortController.signal,
             },
             'confirmed'
           )
@@ -194,29 +194,36 @@ export class SolanaStepExecutor extends BaseStepExecutor {
         const startTime = Date.now()
 
         while (!confirmedTx && Date.now() - startTime <= TIMEOUT_PERIOD) {
+          await connection.sendRawTransaction(
+            signedTx.serialize(),
+            rawTransactionOptions
+          )
           confirmedTx = await Promise.race([
             confirmTransactionPromise,
-            new Promise<null>((resolve) =>
-              setTimeout(() => {
-                resolve(null)
-              }, TX_RETRY_INTERVAL)
-            ),
+            sleep(TX_RETRY_INTERVAL),
           ])
           if (confirmedTx) {
             break
           }
-
-          await connection.sendRawTransaction(
-            signedTx.serialize(),
-            rawTransactionOptions
-          )
         }
 
+        // 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,7 +232,7 @@ export class SolanaStepExecutor extends BaseStepExecutor {
 
         if (!confirmedTx) {
           throw new TransactionError(
-            LiFiErrorCode.TransactionFailed,
+            LiFiErrorCode.TransactionExpired,
             'Failed to land the transaction'
           )
         }

package/src/core/Solana/getSolanaBalance.ts

@@ -1,6 +1,6 @@
 import type { ChainId, Token, TokenAmount } from '@lifi/types'
 import { PublicKey } from '@solana/web3.js'
-import { wrappedSolAddress } from '../../constants.js'
+import { SolSystemProgram } from '../../constants.js'
 import { getSolanaConnection } from './connection.js'
 import { TokenProgramAddress } from './types.js'
 
@@ -53,8 +53,7 @@ const getSolanaBalanceDefault = async (
           {} as Record<string, bigint>
         )
       : {}
-  walletTokenAmounts[wrappedSolAddress] ??= 0n
-  walletTokenAmounts[wrappedSolAddress] += solBalance
+  walletTokenAmounts[SolSystemProgram] = solBalance
   const tokenAmounts: TokenAmount[] = tokens.map((token) => {
     if (walletTokenAmounts[token.address]) {
       return {

package/src/core/StatusManager.ts

@@ -7,8 +7,8 @@ import type {
   ProcessType,
 } from '@lifi/types'
 import { executionState } from './executionState.js'
+import { getProcessMessage } from './processMessages.js'
 import type { LiFiStepExtended } from './types.js'
-import { getProcessMessage } from './utils.js'
 
 type OptionalParameters = Partial<
   Pick<

package/src/core/checkBalance.ts

@@ -2,6 +2,7 @@ import type { LiFiStep } from '@lifi/types'
 import { formatUnits } from 'viem'
 import { getTokenBalance } from '../services/balance.js'
 import { BalanceError } from '../utils/errors.js'
+import { sleep } from './utils.js'
 
 export const checkBalance = async (
   walletAddress: string,
@@ -15,9 +16,7 @@ export const checkBalance = async (
 
     if (currentBalance < neededBalance) {
       if (depth <= 3) {
-        await new Promise((resolve) => {
-          setTimeout(resolve, 200)
-        })
+        await sleep(200)
         await checkBalance(walletAddress, step, depth + 1)
       } else if (
         (neededBalance * BigInt((1 - step.action.slippage) * 1_000_000_000)) /

package/src/core/processMessages.ts

@@ -0,0 +1,81 @@
+import {
+  type ProcessStatus,
+  type ProcessType,
+  type StatusMessage,
+  type Substatus,
+} from '@lifi/types'
+
+const processMessages: Record<
+  ProcessType,
+  Partial<Record<ProcessStatus, string>>
+> = {
+  TOKEN_ALLOWANCE: {
+    STARTED: 'Setting token allowance.',
+    PENDING: 'Waiting for token allowance.',
+    DONE: 'Token allowance set.',
+  },
+  SWITCH_CHAIN: {
+    PENDING: 'Chain switch required.',
+    DONE: 'Chain switched successfully.',
+  },
+  SWAP: {
+    STARTED: 'Preparing swap transaction.',
+    ACTION_REQUIRED: 'Please sign the transaction.',
+    PENDING: 'Waiting for swap transaction.',
+    DONE: 'Swap completed.',
+  },
+  CROSS_CHAIN: {
+    STARTED: 'Preparing bridge transaction.',
+    ACTION_REQUIRED: 'Please sign the transaction.',
+    PENDING: 'Waiting for bridge transaction.',
+    DONE: 'Bridge transaction confirmed.',
+  },
+  RECEIVING_CHAIN: {
+    PENDING: 'Waiting for destination chain.',
+    DONE: 'Bridge completed.',
+  },
+  TRANSACTION: {},
+}
+const substatusMessages: Record<
+  StatusMessage,
+  Partial<Record<Substatus, string>>
+> = {
+  PENDING: {
+    BRIDGE_NOT_AVAILABLE: 'Bridge communication is temporarily unavailable.',
+    CHAIN_NOT_AVAILABLE: 'RPC communication is temporarily unavailable.',
+    UNKNOWN_ERROR:
+      'An unexpected error occurred. Please seek assistance in the LI.FI discord server.',
+    WAIT_SOURCE_CONFIRMATIONS:
+      'The bridge deposit has been received. The bridge is waiting for more confirmations to start the off-chain logic.',
+    WAIT_DESTINATION_TRANSACTION:
+      'The bridge off-chain logic is being executed. Wait for the transaction to appear on the destination chain.',
+  },
+  DONE: {
+    PARTIAL:
+      'Some of the received tokens are not the requested destination tokens.',
+    REFUNDED: 'The tokens were refunded to the sender address.',
+    COMPLETED: 'The transfer is complete.',
+  },
+  FAILED: {},
+  INVALID: {},
+  NOT_FOUND: {},
+}
+
+export function getProcessMessage(
+  type: ProcessType,
+  status: ProcessStatus
+): string | undefined {
+  const processMessage = processMessages[type][status]
+  return processMessage
+}
+
+export function getSubstatusMessage(
+  status: StatusMessage,
+  substatus?: Substatus
+): string | undefined {
+  if (!substatus) {
+    return
+  }
+  const message = substatusMessages[status][substatus]
+  return message
+}

package/src/core/utils.ts

@@ -1,92 +1,11 @@
-import {
-  type LiFiStep,
-  type ProcessStatus,
-  type ProcessType,
-  type StatusMessage,
-  type Substatus,
-} from '@lifi/types'
-
-const processMessages: Record<
-  ProcessType,
-  Partial<Record<ProcessStatus, string>>
-> = {
-  TOKEN_ALLOWANCE: {
-    STARTED: 'Setting token allowance.',
-    PENDING: 'Waiting for token allowance.',
-    DONE: 'Token allowance set.',
-  },
-  SWITCH_CHAIN: {
-    PENDING: 'Chain switch required.',
-    DONE: 'Chain switched successfully.',
-  },
-  SWAP: {
-    STARTED: 'Preparing swap transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for swap transaction.',
-    DONE: 'Swap completed.',
-  },
-  CROSS_CHAIN: {
-    STARTED: 'Preparing bridge transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for bridge transaction.',
-    DONE: 'Bridge transaction confirmed.',
-  },
-  RECEIVING_CHAIN: {
-    PENDING: 'Waiting for destination chain.',
-    DONE: 'Bridge completed.',
-  },
-  TRANSACTION: {},
-}
-const substatusMessages: Record<
-  StatusMessage,
-  Partial<Record<Substatus, string>>
-> = {
-  PENDING: {
-    BRIDGE_NOT_AVAILABLE: 'Bridge communication is temporarily unavailable.',
-    CHAIN_NOT_AVAILABLE: 'RPC communication is temporarily unavailable.',
-    UNKNOWN_ERROR:
-      'An unexpected error occurred. Please seek assistance in the LI.FI discord server.',
-    WAIT_SOURCE_CONFIRMATIONS:
-      'The bridge deposit has been received. The bridge is waiting for more confirmations to start the off-chain logic.',
-    WAIT_DESTINATION_TRANSACTION:
-      'The bridge off-chain logic is being executed. Wait for the transaction to appear on the destination chain.',
-  },
-  DONE: {
-    PARTIAL:
-      'Some of the received tokens are not the requested destination tokens.',
-    REFUNDED: 'The tokens were refunded to the sender address.',
-    COMPLETED: 'The transfer is complete.',
-  },
-  FAILED: {},
-  INVALID: {},
-  NOT_FOUND: {},
-}
-
-export function getProcessMessage(
-  type: ProcessType,
-  status: ProcessStatus
-): string | undefined {
-  const processMessage = processMessages[type][status]
-  return processMessage
-}
-
-export function getSubstatusMessage(
-  status: StatusMessage,
-  substatus?: Substatus
-): string | undefined {
-  if (!substatus) {
-    return
-  }
-  const message = substatusMessages[status][substatus]
-  return message
-}
+import { type LiFiStep } from '@lifi/types'
 
 /**
  * Used to check if changed exchange rate is in the range of slippage threshold.
  * We use a slippage value as a threshold to trigger the rate change hook.
  * This can result in almost doubled slippage for the user and need to be revisited.
- * @param oldStep
- * @param newStep
+ * @param oldStep - old step
+ * @param newStep - new step
  * @returns Boolean
  */
 export function checkStepSlippageThreshold(
@@ -106,3 +25,9 @@ export function checkStepSlippageThreshold(
   }
   return actualSlippage <= setSlippage
 }
+
+export function sleep(ms: number): Promise<null> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(null), ms)
+  })
+}

package/src/core/waitForReceivingTransaction.ts

@@ -8,7 +8,7 @@ import { getStatus } from '../services/api.js'
 import { ServerError } from '../utils/errors.js'
 import { repeatUntilDone } from '../utils/utils.js'
 import type { StatusManager } from './StatusManager.js'
-import { getSubstatusMessage } from './utils.js'
+import { getSubstatusMessage } from './processMessages.js'
 
 const TRANSACTION_HASH_OBSERVERS: Record<string, Promise<StatusResponse>> = {}