@lifi/sdk 3.0.0-alpha.2 → 3.0.0-alpha.21

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"./dist/","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"}

package/dist/{cjs → _types}/utils/median.d.ts

@@ -1 +1,2 @@
 export declare const median: (arr: bigint[]) => bigint | undefined;
+//# sourceMappingURL=median.d.ts.map

package/dist/_types/utils/median.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"median.d.ts","sourceRoot":"./dist/","sources":["utils/median.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,QAAS,MAAM,EAAE,KAAG,MAAM,GAAG,SAU/C,CAAA"}

package/dist/_types/utils/parseBackendError.d.ts

@@ -0,0 +1,3 @@
+import type { LiFiError } from './errors.js';
+export declare const parseBackendError: (e: any) => Promise<LiFiError>;
+//# sourceMappingURL=parseBackendError.d.ts.map

package/dist/_types/utils/parseBackendError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseBackendError.d.ts","sourceRoot":"./dist/","sources":["utils/parseBackendError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAS5C,eAAO,MAAM,iBAAiB,MAAa,GAAG,KAAG,QAAQ,SAAS,CAwCjE,CAAA"}

package/dist/{utils → _types/utils}/parseError.d.ts

@@ -1,5 +1,5 @@
-import type { LifiStep, Process } from '@lifi/types';
-import { LiFiError } from './errors';
+import type { LiFiStep, Process } from '@lifi/types';
+import { LiFiError } from './errors.js';
 /**
  * Available MetaMask error codes:
  *
@@ -31,7 +31,5 @@ import { LiFiError } from './errors';
  * https://eips.ethereum.org/EIPS/eip-1474#error-codes
  * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
  */
-export declare const getTransactionNotSentMessage: (step?: LifiStep, process?: Process) => Promise<string>;
-export declare const getTransactionFailedMessage: (step: LifiStep, txLink?: string) => Promise<string>;
-export declare const parseError: (e: any, step?: LifiStep, process?: Process) => Promise<LiFiError>;
-export declare const parseBackendError: (e: any) => Promise<LiFiError>;
+export declare const parseError: (e: any, step?: LiFiStep, process?: Process) => Promise<LiFiError>;
+//# sourceMappingURL=parseError.d.ts.map

package/dist/_types/utils/parseError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseError.d.ts","sourceRoot":"./dist/","sources":["utils/parseError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAMpD,OAAO,EAIL,SAAS,EAOV,MAAM,aAAa,CAAA;AAGpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,eAAO,MAAM,UAAU,MAClB,GAAG,SACC,QAAQ,YACL,OAAO,KAChB,QAAQ,SAAS,CAmJnB,CAAA"}

package/dist/{utils → _types/utils}/utils.d.ts

@@ -8,3 +8,4 @@ export declare const wait: (ms: number) => Promise<undefined>;
 export declare const repeatUntilDone: <T>(toRepeat: () => Promise<T | undefined>, timeout?: number) => Promise<T>;
 export declare const isZeroAddress: (address: string) => boolean;
 export declare const isNativeTokenAddress: (address: string) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/_types/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"./dist/","sources":["utils/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,OAAQ,MAAM,KAAG,QAAQ,SAAS,CAIlD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,6EAc3B,CAAA;AAED,eAAO,MAAM,aAAa,YAAa,MAAM,KAAG,OAK/C,CAAA;AAED,eAAO,MAAM,oBAAoB,YAAa,MAAM,KAAG,OAUtD,CAAA"}

package/dist/_types/version.d.ts

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

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

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

package/dist/config.ts

@@ -0,0 +1,47 @@
+import type { ChainId, ExtendedChain } from '@lifi/types'
+import type { SDKConfig, SDKOptions } from './types/index.js'
+
+export const config = (() => {
+  const _config: SDKConfig = {
+    integrator: 'lifi-sdk',
+    apiUrl: 'https://li.quest/v1',
+    rpcUrls: {},
+  }
+  let _chains: ExtendedChain[]
+  let _loading: Promise<void> | undefined
+  return {
+    get chains() {
+      return _chains
+    },
+    set chains(chains: ExtendedChain[]) {
+      _chains = chains
+      _loading = undefined
+    },
+    set loading(loading: Promise<void>) {
+      _loading = loading
+    },
+    async getRPCUrls() {
+      if (_loading) {
+        await _loading
+      }
+      return _config.rpcUrls
+    },
+    async getChainById(chainId: ChainId) {
+      if (_loading) {
+        await _loading
+      }
+      const chain = this.chains?.find((chain) => chain.id === chainId)
+      if (!chain) {
+        throw new Error(`ChainId ${chainId} not found`)
+      }
+      return chain
+    },
+    set(options: SDKOptions) {
+      Object.assign(_config, options)
+      return _config
+    },
+    get() {
+      return _config
+    },
+  }
+})()

package/dist/constants.ts

@@ -0,0 +1,7 @@
+export const AddressZero = '0x0000000000000000000000000000000000000000'
+export const AlternativeAddressZero =
+  '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+/**
+ * Cronos require bigger multicall chunks than default 1024 (1 KB)
+ */
+export const MulticallBatchSize = 16_384 // 16 Kilobytes (KB)

package/dist/core/BaseStepExecutor.ts

@@ -0,0 +1,40 @@
+import type { LiFiStep } from '@lifi/types'
+import { StatusManager } from './StatusManager.js'
+import type {
+  ExecutionOptions,
+  InteractionSettings,
+  StepExecutor,
+  StepExecutorOptions,
+} from './types.js'
+
+// Please be careful when changing the defaults as it may break the behavior (e.g., background execution)
+const defaultInteractionSettings = {
+  allowInteraction: true,
+  allowUpdates: true,
+  allowExecution: true,
+}
+
+export abstract class BaseStepExecutor implements StepExecutor {
+  protected executionOptions?: ExecutionOptions
+  protected statusManager: StatusManager
+
+  public allowUserInteraction = true
+  public allowExecution = true
+
+  constructor(options: StepExecutorOptions) {
+    this.statusManager = new StatusManager(options.routeId)
+    this.executionOptions = options.executionOptions
+  }
+
+  setInteraction = (settings?: InteractionSettings): void => {
+    const interactionSettings = {
+      ...defaultInteractionSettings,
+      ...settings,
+    }
+    this.allowUserInteraction = interactionSettings.allowInteraction
+    this.statusManager.allowUpdates(interactionSettings.allowUpdates)
+    this.allowExecution = interactionSettings.allowExecution
+  }
+
+  abstract executeStep(step: LiFiStep): Promise<LiFiStep>
+}

package/dist/core/EVM/EVM.ts

@@ -0,0 +1,50 @@
+import { ChainType } from '@lifi/types'
+import { isAddress } from 'viem'
+import type { StepExecutorOptions } from '../types.js'
+import { EVMStepExecutor } from './EVMStepExecutor.js'
+import { getEVMBalance } from './getEVMBalance.js'
+import type { EVMProvider, EVMProviderOptions } from './types.js'
+
+export function EVM(options?: EVMProviderOptions): EVMProvider {
+  const _options: EVMProviderOptions = options ?? {}
+  return {
+    get type() {
+      return ChainType.EVM
+    },
+    get multicall() {
+      return _options.multicall
+    },
+    get multisig() {
+      return _options.multisig
+    },
+    isAddress(address: string): boolean {
+      return isAddress(address)
+    },
+    getBalance: getEVMBalance,
+    async getStepExecutor(
+      options: StepExecutorOptions
+    ): Promise<EVMStepExecutor> {
+      if (!_options.getWalletClient) {
+        throw new Error(`getWalletClient is not provided.`)
+      }
+
+      const walletClient = await _options.getWalletClient()
+
+      const executor = new EVMStepExecutor({
+        walletClient,
+        multisig: _options.multisig,
+        routeId: options.routeId,
+        executionOptions: {
+          ...options.executionOptions,
+          switchChainHook:
+            _options.switchChain ?? options.executionOptions?.switchChainHook,
+        },
+      })
+
+      return executor
+    },
+    setOptions(options: EVMProviderOptions) {
+      Object.assign(_options, options)
+    },
+  }
+}

package/dist/core/EVM/EVMStepExecutor.ts

@@ -0,0 +1,472 @@
+import type {
+  ExtendedTransactionInfo,
+  FullStatusData,
+  LiFiStep,
+} from '@lifi/types'
+import type {
+  Address,
+  Hash,
+  PublicClient,
+  ReplacementReason,
+  SendTransactionParameters,
+  WalletClient,
+} from 'viem'
+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 { BaseStepExecutor } from '../BaseStepExecutor.js'
+import { checkBalance } from '../checkBalance.js'
+import { stepComparison } from '../stepComparison.js'
+import type { 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 } from './utils.js'
+
+export interface EVMStepExecutorOptions extends StepExecutorOptions {
+  walletClient: WalletClient
+  multisig?: MultisigConfig
+}
+
+export class EVMStepExecutor extends BaseStepExecutor {
+  private walletClient: WalletClient
+  private multisig?: MultisigConfig
+
+  constructor(options: EVMStepExecutorOptions) {
+    super(options)
+    this.walletClient = options.walletClient
+    this.multisig = options.multisig
+  }
+
+  // TODO: add checkChain method and update wallet client inside executors
+  // This can come in handy when we execute multiple routes simultaneously and
+  // should be sure that we are on the right chain when waiting for transactions.
+  checkChain = () => {
+    throw new Error('checkChain is not implemented.')
+  }
+
+  executeStep = async (step: LiFiStep): Promise<LiFiStep> => {
+    // Make sure that the chain is still correct
+
+    // Find if it's bridging and the step is waiting for a transaction on the receiving chain
+    const recievingChainProcess = step.execution?.process.find(
+      (process) => process.type === 'RECEIVING_CHAIN'
+    )
+
+    // If the step is waiting for a transaction on the receiving chain, we do not switch the chain
+    // All changes are already done from the source chain
+    // Return the step
+    if (
+      recievingChainProcess?.substatus !== 'WAIT_DESTINATION_TRANSACTION' ||
+      !recievingChainProcess
+    ) {
+      const updatedWalletClient = await switchChain(
+        this.walletClient,
+        this.statusManager,
+        step,
+        this.allowUserInteraction,
+        this.executionOptions?.switchChainHook
+      )
+
+      if (!updatedWalletClient) {
+        // Chain switch was not successful, stop execution here
+        return step
+      }
+
+      this.walletClient = updatedWalletClient
+    }
+
+    const client = this.walletClient.extend(publicActions)
+
+    const isMultisigWalletClient = !!this.multisig?.isMultisigWalletClient
+    const multisigBatchTransactions: MultisigTransaction[] = []
+
+    const shouldBatchTransactions =
+      this.multisig?.shouldBatchTransactions &&
+      !!this.multisig.sendBatchTransaction
+
+    step.execution = this.statusManager.initExecutionObject(step)
+
+    const fromChain = await config.getChainById(step.action.fromChainId)
+    const toChain = await config.getChainById(step.action.toChainId)
+
+    const isBridgeExecution = fromChain.id !== toChain.id
+    const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+
+    // STEP 1: Check allowance
+    const existingProcess = step.execution.process.find(
+      (p) => p.type === currentProcessType
+    )
+
+    // Check token approval only if fromToken is not the native token => no approval needed in that case
+
+    const checkForAllowance =
+      !existingProcess?.txHash &&
+      !isZeroAddress(step.action.fromToken.address) &&
+      (shouldBatchTransactions || !isMultisigWalletClient)
+
+    if (checkForAllowance) {
+      const data = await checkAllowance(
+        fromChain,
+        step,
+        client,
+        this.statusManager,
+        this.executionOptions,
+        this.allowUserInteraction,
+        shouldBatchTransactions
+      )
+
+      if (data) {
+        // allowance doesn't need value
+        const baseTransaction: MultisigTransaction = {
+          to: step.action.fromToken.address,
+          data,
+        }
+
+        multisigBatchTransactions.push(baseTransaction)
+      }
+    }
+
+    // STEP 2: Get transaction
+    let process = this.statusManager.findOrCreateProcess(
+      step,
+      currentProcessType
+    )
+
+    if (process.status !== 'DONE') {
+      const multisigProcess = step.execution.process.find(
+        (p) => !!p.multisigTxHash
+      )
+
+      try {
+        if (isMultisigWalletClient && multisigProcess) {
+          const multisigTxHash = multisigProcess.multisigTxHash as Hash
+          if (!multisigTxHash) {
+            throw new ValidationError(
+              'Multisig internal transaction hash is undefined.'
+            )
+          }
+          await updateMultisigRouteProcess(
+            multisigTxHash,
+            step,
+            process.type,
+            fromChain,
+            this.statusManager,
+            this.multisig
+          )
+        }
+
+        let txHash: Hash
+        if (process.txHash) {
+          // Make sure that the chain is still correct
+          const updatedWalletClient = await switchChain(
+            this.walletClient,
+            this.statusManager,
+            step,
+            this.allowUserInteraction,
+            this.executionOptions?.switchChainHook
+          )
+
+          if (!updatedWalletClient) {
+            // Chain switch was not successful, stop execution here
+            return step
+          }
+
+          this.walletClient = updatedWalletClient
+
+          // Load exiting transaction
+          txHash = process.txHash as Hash
+        } else {
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'STARTED'
+          )
+
+          // Check balance
+          await checkBalance(client.account!.address, step)
+
+          // Create new transaction
+          if (!step.transactionRequest) {
+            const { execution, ...stepBase } = step
+            const updatedStep = await getStepTransaction(stepBase)
+            const comparedStep = await stepComparison(
+              this.statusManager,
+              step,
+              updatedStep,
+              this.allowUserInteraction,
+              this.executionOptions
+            )
+            step = {
+              ...comparedStep,
+              execution: step.execution,
+            }
+          }
+
+          if (!step.transactionRequest) {
+            throw new TransactionError(
+              LiFiErrorCode.TransactionUnprepared,
+              'Unable to prepare transaction.'
+            )
+          }
+
+          // STEP 3: Send the transaction
+          // Make sure that the chain is still correct
+          const updatedWalletClient = await switchChain(
+            this.walletClient,
+            this.statusManager,
+            step,
+            this.allowUserInteraction,
+            this.executionOptions?.switchChainHook
+          )
+
+          if (!updatedWalletClient) {
+            // Chain switch was not successful, stop execution here
+            return step
+          }
+
+          this.walletClient = updatedWalletClient
+
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'ACTION_REQUIRED'
+          )
+
+          if (!this.allowUserInteraction) {
+            return step
+          }
+
+          let transactionRequest: TransactionParameters = {
+            to: step.transactionRequest.to as Hash,
+            from: step.transactionRequest.from as Hash,
+            data: step.transactionRequest.data as Hash,
+            value: step.transactionRequest.value
+              ? BigInt(step.transactionRequest.value as string)
+              : undefined,
+            gas: step.transactionRequest.gasLimit
+              ? BigInt(step.transactionRequest.gasLimit as string)
+              : undefined,
+            // gasPrice: step.transactionRequest.gasPrice
+            //   ? BigInt(step.transactionRequest.gasPrice as string)
+            //   : undefined,
+            // maxFeePerGas: step.transactionRequest.maxFeePerGas
+            //   ? BigInt(step.transactionRequest.maxFeePerGas as string)
+            //   : undefined,
+            maxPriorityFeePerGas:
+              this.walletClient.account?.type === 'local'
+                ? await getMaxPriorityFeePerGas(client as PublicClient)
+                : step.transactionRequest.maxPriorityFeePerGas
+                ? BigInt(step.transactionRequest.maxPriorityFeePerGas as string)
+                : undefined,
+          }
+
+          if (this.executionOptions?.updateTransactionRequestHook) {
+            const customizedTransactionRequest: TransactionParameters =
+              await this.executionOptions.updateTransactionRequestHook({
+                requestType: 'transaction',
+                ...transactionRequest,
+              })
+
+            transactionRequest = {
+              ...transactionRequest,
+              ...customizedTransactionRequest,
+            }
+          }
+
+          if (shouldBatchTransactions && this.multisig?.sendBatchTransaction) {
+            if (transactionRequest.to && transactionRequest.data) {
+              const populatedTransaction: MultisigTransaction = {
+                value: transactionRequest.value,
+                to: transactionRequest.to,
+                data: transactionRequest.data,
+              }
+              multisigBatchTransactions.push(populatedTransaction)
+
+              txHash = await this.multisig?.sendBatchTransaction(
+                multisigBatchTransactions
+              )
+            } else {
+              throw new TransactionError(
+                LiFiErrorCode.TransactionUnprepared,
+                'Unable to prepare transaction.'
+              )
+            }
+          } else {
+            txHash = await this.walletClient.sendTransaction({
+              to: transactionRequest.to as Address,
+              account: this.walletClient.account!,
+              data: transactionRequest.data,
+              gas: transactionRequest.gas,
+              gasPrice: transactionRequest.gasPrice,
+              maxFeePerGas: transactionRequest.maxFeePerGas,
+              maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+              chain: null,
+            } as SendTransactionParameters)
+          }
+
+          // STEP 4: Wait for the transaction
+          if (isMultisigWalletClient) {
+            process = this.statusManager.updateProcess(
+              step,
+              process.type,
+              'ACTION_REQUIRED',
+              {
+                multisigTxHash: txHash,
+              }
+            )
+          } else {
+            process = this.statusManager.updateProcess(
+              step,
+              process.type,
+              'PENDING',
+              {
+                txHash: txHash,
+                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+              }
+            )
+          }
+        }
+
+        let replacementReason: ReplacementReason | undefined
+        const transactionReceipt = await client.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}`,
+            })
+          },
+        })
+
+        if (replacementReason === 'cancelled') {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionCanceled,
+            'User canceled transaction.'
+          )
+        }
+
+        // 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,
+            step,
+            process.type,
+            fromChain,
+            this.statusManager,
+            this.multisig
+          )
+        }
+
+        if (!isMultisigWalletClient) {
+          process = this.statusManager.updateProcess(
+            step,
+            process.type,
+            'PENDING',
+            {
+              txHash: transactionReceipt.transactionHash,
+              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transactionReceipt.transactionHash}`,
+            }
+          )
+        }
+
+        if (isBridgeExecution) {
+          process = this.statusManager.updateProcess(step, process.type, 'DONE')
+        }
+      } catch (e: any) {
+        const error = await parseError(e, step, process)
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'FAILED',
+          {
+            error: {
+              message: error.message,
+              htmlMessage: error.htmlMessage,
+              code: error.code,
+            },
+          }
+        )
+        this.statusManager.updateExecution(step, 'FAILED')
+        throw error
+      }
+    }
+
+    // STEP 5: Wait for the receiving chain
+    const processTxHash = process.txHash
+    if (isBridgeExecution) {
+      process = this.statusManager.findOrCreateProcess(
+        step,
+        'RECEIVING_CHAIN',
+        'PENDING'
+      )
+    }
+    let statusResponse: FullStatusData
+    try {
+      if (!processTxHash) {
+        throw new Error('Transaction hash is undefined.')
+      }
+      statusResponse = (await waitForReceivingTransaction(
+        processTxHash,
+        this.statusManager,
+        process.type,
+        step
+      )) as FullStatusData
+
+      const statusReceiving =
+        statusResponse.receiving as ExtendedTransactionInfo
+
+      process = this.statusManager.updateProcess(step, process.type, 'DONE', {
+        substatus: statusResponse.substatus,
+        substatusMessage:
+          statusResponse.substatusMessage ||
+          getSubstatusMessage(statusResponse.status, statusResponse.substatus),
+        txHash: statusReceiving?.txHash,
+        txLink: `${toChain.metamask.blockExplorerUrls[0]}tx/${statusReceiving?.txHash}`,
+      })
+
+      this.statusManager.updateExecution(step, 'DONE', {
+        fromAmount: statusResponse.sending.amount,
+        toAmount: statusReceiving?.amount,
+        toToken: statusReceiving?.token,
+        gasAmount: statusResponse.sending.gasAmount,
+        gasAmountUSD: statusResponse.sending.gasAmountUSD,
+        gasPrice: statusResponse.sending.gasPrice,
+        gasToken: statusResponse.sending.gasToken,
+        gasUsed: statusResponse.sending.gasUsed,
+      })
+    } catch (e: unknown) {
+      const htmlMessage = await getTransactionFailedMessage(
+        step,
+        process.txLink
+      )
+
+      process = this.statusManager.updateProcess(step, process.type, 'FAILED', {
+        error: {
+          code: LiFiErrorCode.TransactionFailed,
+          message: 'Failed while waiting for receiving chain.',
+          htmlMessage,
+        },
+      })
+      this.statusManager.updateExecution(step, 'FAILED')
+      console.warn(e)
+      throw e
+    }
+
+    // DONE
+    return step
+  }
+}