@lifi/sdk 3.3.0-alpha.2 → 3.3.0-beta.0

package/src/core/StatusManager.ts

@@ -1,4 +1,5 @@
 import type {
+  ChainId,
   Execution,
   ExecutionStatus,
   LiFiStep,
@@ -10,19 +11,12 @@ import { executionState } from './executionState.js'
 import { getProcessMessage } from './processMessages.js'
 import type { LiFiStepExtended } from './types.js'
 
-type OptionalParameters = Partial<
-  Pick<
-    Process,
-    | 'doneAt'
-    | 'failedAt'
-    | 'txHash'
-    | 'txLink'
-    | 'error'
-    | 'substatus'
-    | 'substatusMessage'
-    | 'multisigTxHash'
-  >
->
+export type FindOrCreateProcessProps = {
+  step: LiFiStepExtended
+  type: ProcessType
+  chainId?: ChainId
+  status?: ProcessStatus
+}
 
 /**
  * Manages status updates of a route and provides various functions for tracking processes
@@ -88,16 +82,23 @@ export class StatusManager {
 
   /**
    * Create and push a new process into the execution.
-   * @param step The step that should contain the new process.
-   * @param type Type of the process. Used to identify already existing processes.
-   * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
+   * @param step.step The step that should contain the new process.
+   * @param step.type Type of the process. Used to identify already existing processes.
+   * @param step.chainId Chain Id of the process.
+   * @param step.status By default created procces is set to the STARTED status. We can override new process with the needed status.
+   * @param root0
+   * @param root0.step
+   * @param root0.type
+   * @param root0.chainId
+   * @param root0.status
    * @returns Returns process.
    */
-  findOrCreateProcess = (
-    step: LiFiStepExtended,
-    type: ProcessType,
-    status?: ProcessStatus
-  ): Process => {
+  findOrCreateProcess = ({
+    step,
+    type,
+    chainId,
+    status,
+  }: FindOrCreateProcessProps): Process => {
     if (!step.execution?.process) {
       throw new Error("Execution hasn't been initialized.")
     }
@@ -117,6 +118,7 @@ export class StatusManager {
       startedAt: Date.now(),
       message: getProcessMessage(type, status ?? 'STARTED'),
       status: status ?? 'STARTED',
+      chainId: chainId,
     }
 
     step.execution.process.push(newProcess)
@@ -136,7 +138,7 @@ export class StatusManager {
     step: LiFiStepExtended,
     type: ProcessType,
     status: ProcessStatus,
-    params?: OptionalParameters
+    params?: Partial<Process>
   ): Process => {
     if (!step.execution) {
       throw new Error("Can't update an empty step execution.")

package/src/core/UTXO/UTXOStepExecutor.ts

@@ -4,15 +4,12 @@ import {
   type FullStatusData,
 } from '@lifi/types'
 import { address, networks, Psbt } from 'bitcoinjs-lib'
-import { withRetry, withTimeout, type Client } from 'viem'
+import { withTimeout, type Client } from 'viem'
 import { config } from '../../config.js'
 import { LiFiErrorCode } from '../../errors/constants.js'
 import { TransactionError } from '../../errors/errors.js'
 import { getStepTransaction } from '../../services/api.js'
-import {
-  getTransactionFailedMessage,
-  waitForResult,
-} 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'
@@ -26,6 +23,10 @@ import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { getUTXOPublicClient } from './getUTXOPublicClient.js'
 import { parseUTXOErrors } from './parseUTXOErrors.js'
 import { signPsbt } from './utxo-stack/actions/signPsbt.js'
+import {
+  waitForTransaction,
+  type ReplacementReason,
+} from './utxo-stack/actions/waitForTransaction.js'
 
 export interface UTXOStepExecutorOptions extends StepExecutorOptions {
   client: Client
@@ -60,22 +61,25 @@ export class UTXOStepExecutor extends BaseStepExecutor {
     const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
 
     // STEP 2: Get transaction
-    let process = this.statusManager.findOrCreateProcess(
+    let process = this.statusManager.findOrCreateProcess({
       step,
-      currentProcessType
-    )
+      type: currentProcessType,
+      chainId: fromChain.id,
+    })
 
     const publicClient = await getUTXOPublicClient(ChainId.BTC)
 
     if (process.status !== 'DONE') {
       try {
         let txHash: string
+        let txHex: string
         if (process.txHash) {
           // Make sure that the chain is still correct
           this.checkClient(step)
 
           // Wait for exiting transaction
           txHash = process.txHash
+          txHex = process.txHex
         } else {
           process = this.statusManager.updateProcess(
             step,
@@ -146,24 +150,7 @@ export class UTXOStepExecutor extends BaseStepExecutor {
 
           this.checkClient(step)
 
-          // const toolbox = getToolboxByChain('BTC')({})
-
-          // const apiClient = blockchairApi({ chain: Chain.Bitcoin })
-          // const txFeeRate = await apiClient.getSuggestedTxFee()
-
-          // const tx = await toolbox.buildTx({
-          //   assetValue: {
-          //     bigIntValue: step.transactionRequest.value,
-          //   },
-          //   recipient: step.transactionRequest.to,
-          //   memo: step.transactionRequest.data,
-          //   sender: this.client.account?.address,
-          //   chain: 'BTC',
-          //   apiClient: blockchairApi({ chain: Chain.Bitcoin }),
-          //   feeRate: txFeeRate,
-          // })
-
-          let psbtHex = transactionRequest.data // tx.psbt.toHex()
+          const psbtHex = transactionRequest.data
 
           const psbt = Psbt.fromHex(psbtHex, { network: networks.bitcoin })
 
@@ -190,8 +177,6 @@ export class UTXOStepExecutor extends BaseStepExecutor {
               .values()
           )
 
-          psbtHex = psbt.toHex()
-
           // We give users 10 minutes to sign the transaction or it should be considered expired
           const signedPsbtHex = await withTimeout(
             () =>
@@ -211,10 +196,10 @@ export class UTXOStepExecutor extends BaseStepExecutor {
 
           const signedPsbt = Psbt.fromHex(signedPsbtHex).finalizeAllInputs()
 
-          const transactionHex = signedPsbt.extractTransaction().toHex()
+          txHex = signedPsbt.extractTransaction().toHex()
 
           txHash = await publicClient.sendUTXOTransaction({
-            hex: transactionHex,
+            hex: txHex,
           })
 
           process = this.statusManager.updateProcess(
@@ -224,31 +209,48 @@ export class UTXOStepExecutor extends BaseStepExecutor {
             {
               txHash: txHash,
               txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+              txHex,
             }
           )
         }
 
-        // TODO: improve logic to detect RBF transactions
-        await waitForResult(
-          () =>
-            withRetry(
-              async () => {
-                const tx = await publicClient.getUTXOTransaction({
-                  txId: txHash,
-                })
-                // If there are no confirmations, it means the transaction is still in the mempool
-                if (!tx.confirmations) {
-                  return
-                }
-                return tx
-              },
+        let replacementReason: ReplacementReason | undefined
+        const transaction = await waitForTransaction(publicClient, {
+          txId: txHash,
+          txHex,
+          senderAddress: this.client.account?.address,
+          onReplaced: (response) => {
+            replacementReason = response.reason
+            process = this.statusManager.updateProcess(
+              step,
+              process.type,
+              'PENDING',
               {
-                retryCount: 10,
-                delay: 1000,
+                txHash: response.transaction.txid,
+                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.txid}`,
               }
-            ),
-          10_000
-        )
+            )
+          },
+        })
+
+        if (replacementReason === 'cancelled') {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionCanceled,
+            'User canceled transaction.'
+          )
+        }
+
+        if (transaction.txid !== txHash) {
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'PENDING',
+            {
+              txHash: transaction.txid,
+              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transaction.txid}`,
+            }
+          )
+        }
 
         if (isBridgeExecution) {
           process = this.statusManager.updateProcess(step, process.type, 'DONE')
@@ -274,11 +276,12 @@ export class UTXOStepExecutor extends BaseStepExecutor {
     // STEP 5: Wait for the receiving chain
     const processTxHash = process.txHash
     if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess(
+      process = this.statusManager.findOrCreateProcess({
         step,
-        'RECEIVING_CHAIN',
-        'PENDING'
-      )
+        type: 'RECEIVING_CHAIN',
+        status: 'PENDING',
+        chainId: toChain.id,
+      })
     }
     let statusResponse: FullStatusData
     try {

package/src/core/UTXO/getUTXOPublicClient.ts

@@ -48,6 +48,7 @@ export const getUTXOPublicClient = async (chainId: number) => {
       chain,
       rpcSchema: rpcSchema<UTXOSchema>(),
       transport: fallback(fallbackTransports),
+      pollingInterval: 10_000,
     }).extend(UTXOActions)
     publicClients[chainId] = client
   }

package/src/core/UTXO/parseUTXOErrors.ts

@@ -21,6 +21,17 @@ export const parseUTXOErrors = async (
 }
 
 const handleSpecificErrors = (e: any) => {
+  // txn-mempool-conflict
+  if (
+    e.details?.includes?.('conflict') ||
+    e.cause?.message?.includes?.('conflict')
+  ) {
+    return new TransactionError(
+      LiFiErrorCode.TransactionConflict,
+      'Your transaction conflicts with another transaction already in the mempool. One or more inputs have been spent by another transaction.',
+      e
+    )
+  }
   if (e.code === 4001 || e.code === -32000 || e.cause?.includes?.('rejected')) {
     return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
   }

package/src/core/UTXO/utxo-stack/actions/getBlock.ts

@@ -0,0 +1,58 @@
+import { Block } from 'bitcoinjs-lib'
+import {
+  BlockNotFoundError,
+  type Account,
+  type Chain,
+  type Client,
+  type Transport,
+} from 'viem'
+import type { UTXOSchema } from '../transports/utxo/types.js'
+
+export type GetBlockParameters =
+  | {
+      blockHash: string
+      blockNumber?: never
+    }
+  | {
+      blockHash?: never
+      blockNumber: number
+    }
+
+export type GetBlockReturnType = Block
+
+export async function getBlock<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOSchema>,
+  { blockHash, blockNumber }: GetBlockParameters
+): Promise<GetBlockReturnType> {
+  let blockHex: string | undefined
+  try {
+    let _blockHash = blockHash
+    if (!_blockHash && blockNumber) {
+      _blockHash = await client.request(
+        {
+          method: 'getblockhash',
+          params: [blockNumber],
+        },
+        { dedupe: true }
+      )
+    }
+    if (_blockHash) {
+      blockHex = await client.request(
+        {
+          method: 'getblock',
+          params: [_blockHash, 0],
+        },
+        { dedupe: true }
+      )
+    }
+  } catch (error) {
+    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
+  }
+  if (!blockHex) {
+    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
+  }
+  return Block.fromHex(blockHex)
+}

package/src/core/UTXO/utxo-stack/actions/getBlockStats.ts

@@ -0,0 +1,55 @@
+import {
+  BlockNotFoundError,
+  type Account,
+  type Chain,
+  type Client,
+  type Transport,
+} from 'viem'
+import type { UTXOSchema } from '../transports/utxo/types.js'
+import type { BlockStats, BlockStatsKeys } from '../types/blockStats.js'
+
+export type GetBlockStatsParameters = (
+  | {
+      blockHash: string
+      blockNumber?: never
+    }
+  | {
+      blockHash?: never
+      blockNumber: number
+    }
+) & {
+  stats?: Array<BlockStatsKeys>
+}
+
+export type GetBlockStatsReturnType = BlockStats
+
+export async function getBlockStats<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOSchema>,
+  { blockHash, blockNumber, stats }: GetBlockStatsParameters
+): Promise<GetBlockStatsReturnType> {
+  const blockHashOrNumber = blockHash || blockNumber
+  if (!blockHashOrNumber) {
+    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
+  }
+  try {
+    const params: [string | number, Array<BlockStatsKeys>?] = [
+      blockHashOrNumber,
+    ]
+    if (stats) {
+      params.push(stats)
+    }
+    const data = await client.request(
+      {
+        method: 'getblockstats',
+        params: params,
+      },
+      { dedupe: true }
+    )
+    return data
+  } catch (error) {
+    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
+  }
+}

package/src/core/UTXO/utxo-stack/actions/getUTXOTransaction.ts

@@ -1,4 +1,10 @@
-import { type Account, type Chain, type Client, type Transport } from 'viem'
+import {
+  TransactionNotFoundError,
+  type Account,
+  type Chain,
+  type Client,
+  type Transport,
+} from 'viem'
 import type { UTXOSchema } from '../transports/utxo/types.js'
 import type { UTXOTransaction } from '../types/transaction.js'
 
@@ -6,7 +12,7 @@ export type GetUTXOTransactionParameters = {
   /** The Id of the transaction */
   txId: string
   /** The block in which to look for the transaction */
-  blockhash?: string
+  blockHash?: string
 }
 
 export type GetUTXOTransactionReturnType = UTXOTransaction
@@ -16,15 +22,22 @@ export async function getUTXOTransaction<
   A extends Account | undefined = Account | undefined,
 >(
   client: Client<Transport, C, A, UTXOSchema>,
-  { txId, blockhash }: GetUTXOTransactionParameters
+  { txId, blockHash }: GetUTXOTransactionParameters
 ): Promise<GetUTXOTransactionReturnType> {
-  const params: [string, boolean, string?] = [txId, true]
-  if (blockhash) {
-    params.push(blockhash)
+  try {
+    const params: [string, boolean, string?] = [txId, true]
+    if (blockHash) {
+      params.push(blockHash)
+    }
+    const data = await client.request({
+      method: 'getrawtransaction',
+      params: params,
+    })
+    return data
+  } catch (error) {
+    throw new TransactionNotFoundError({
+      blockHash: blockHash as never,
+      hash: txId as never,
+    })
   }
-  const data = await client.request({
-    method: 'getrawtransaction',
-    params: params,
-  })
-  return data
 }

package/src/core/UTXO/utxo-stack/actions/sendUTXOTransaction.ts

@@ -2,7 +2,7 @@ import { type Account, type Chain, type Client, type Transport } from 'viem'
 import type { UTXOSchema } from '../transports/utxo/types.js'
 
 export type SendUTXOTransactionParameters = {
-  /** The hex string of the raw transaction */
+  /** The hex string of the raw transaction. */
   hex: string
   /** Rejects transactions whose fee rate is higher than the specified value, expressed in BTC/kB. Set to 0 to accept any fee rate. Default = 0.10 */
   maxFeeRate?: number