@lifi/sdk 3.6.0-beta.3 → 3.6.0-beta.5

package/src/core/EVM/EVMStepExecutor.ts

@@ -1,4 +1,4 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { ExtendedChain, LiFiStep } from '@lifi/types'
 import type {
   Address,
   Client,
@@ -20,12 +20,12 @@ import {
   getStepTransaction,
   relayTransaction,
 } from '../../services/api.js'
-import { isZeroAddress } from '../../utils/isZeroAddress.js'
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
 import { stepComparison } from '../stepComparison.js'
 import type {
   LiFiStepExtended,
+  Process,
   StepExecutorOptions,
   TransactionParameters,
 } from '../types.js'
@@ -35,8 +35,8 @@ import { getNativePermit } from './getNativePermit.js'
 import { parseEVMErrors } from './parseEVMErrors.js'
 import { type PermitSignature, signPermitMessage } from './signPermitMessage.js'
 import { switchChain } from './switchChain.js'
-import { isEVMPermitStep } from './typeguards.js'
-import { getMaxPriorityFeePerGas } from './utils.js'
+import { isRelayerStep } from './typeguards.js'
+import { convertExtendedChain, getMaxPriorityFeePerGas } from './utils.js'
 import {
   type WalletCallReceipt,
   waitForBatchTransactionReceipt,
@@ -86,7 +86,9 @@ export class EVMStepExecutor extends BaseStepExecutor {
       )(undefined)) as GetAddressesReturnType
       accountAddress = accountAddresses?.[0]
     }
-    if (accountAddress !== step.action.fromAddress) {
+    if (
+      accountAddress?.toLowerCase() !== step.action.fromAddress?.toLowerCase()
+    ) {
       let processToUpdate = process
       if (!processToUpdate) {
         // We need to create some process if we don't have one so we can show the error
@@ -116,6 +118,78 @@ export class EVMStepExecutor extends BaseStepExecutor {
     return updatedClient
   }
 
+  waitForTransaction = async ({
+    step,
+    process,
+    fromChain,
+    toChain,
+    atomicBatchSupported,
+    isRelayerTransaction,
+    txHash,
+    isBridgeExecution,
+  }: {
+    step: LiFiStepExtended
+    process: Process
+    fromChain: ExtendedChain
+    toChain: ExtendedChain
+    atomicBatchSupported: boolean
+    isRelayerTransaction: boolean
+    txHash: Hash
+    isBridgeExecution: boolean
+  }) => {
+    let transactionReceipt: TransactionReceipt | WalletCallReceipt | undefined
+
+    if (atomicBatchSupported) {
+      transactionReceipt = await waitForBatchTransactionReceipt(
+        this.client,
+        txHash
+      )
+    } else if (isRelayerTransaction) {
+      transactionReceipt = await waitForRelayedTransactionReceipt(txHash)
+    } else {
+      transactionReceipt = await waitForTransactionReceipt({
+        client: this.client,
+        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}`,
+          })
+        },
+      })
+    }
+
+    // Update pending process if the transaction hash from the receipt is different.
+    // This might happen if the transaction was replaced.
+    if (
+      transactionReceipt?.transactionHash &&
+      transactionReceipt.transactionHash !== txHash
+    ) {
+      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')
+    }
+
+    await waitForDestinationChainTransaction(
+      step,
+      process,
+      fromChain,
+      toChain,
+      this.statusManager
+    )
+  }
+
   executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
     step.execution = this.statusManager.initExecutionObject(step)
 
@@ -138,6 +212,8 @@ export class EVMStepExecutor extends BaseStepExecutor {
     const fromChain = await config.getChainById(step.action.fromChainId)
     const toChain = await config.getChainById(step.action.toChainId)
 
+    // Check if the wallet supports atomic batch transactions (EIP-5792)
+    const calls: Call[] = []
     let atomicBatchSupported = false
     try {
       const capabilities = (await getAction(
@@ -147,11 +223,10 @@ export class EVMStepExecutor extends BaseStepExecutor {
       )(undefined)) as GetCapabilitiesReturnType
       atomicBatchSupported = capabilities[fromChain.id]?.atomicBatch?.supported
     } catch {
-      // If the wallet does not support getCapabilities, we assume that atomic batch is not supported
+      // If the wallet does not support getCapabilities or the call fails,
+      // we assume that atomic batch is not supported
     }
 
-    const calls: Call[] = []
-
     const isBridgeExecution = fromChain.id !== toChain.id
     const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
 
@@ -160,8 +235,11 @@ export class EVMStepExecutor extends BaseStepExecutor {
       (p) => p.type === currentProcessType
     )
 
+    const isFromNativeToken =
+      fromChain.nativeToken.address === step.action.fromToken.address
+
     // Check if step requires permit signature and will be used with relayer service
-    const isPermitStep = isEVMPermitStep(step)
+    const isRelayerTransaction = isRelayerStep(step)
 
     // Check if token requires approval
     // Native tokens (like ETH) don't need approval since they're not ERC20 tokens
@@ -176,13 +254,17 @@ export class EVMStepExecutor extends BaseStepExecutor {
     )
     // Check if proxy contract is available and token supports native permits, not available for atomic batch
     const nativePermitSupported =
-      !!fromChain.permit2Proxy &&
       nativePermit.supported &&
+      !!fromChain.permit2Proxy &&
       !atomicBatchSupported &&
-      !isPermitStep
+      !isRelayerTransaction && // TODO: remove once we support ERC-2771
+      !isFromNativeToken
     // Check if chain has Permit2 contract deployed. Permit2 should not be available for atomic batch.
     const permit2Supported =
-      !!fromChain.permit2 && !!fromChain.permit2Proxy && !atomicBatchSupported
+      !!fromChain.permit2 &&
+      !!fromChain.permit2Proxy &&
+      !atomicBatchSupported &&
+      !isFromNativeToken
     // Token supports either native permits or Permit2
     const permitSupported = permit2Supported || nativePermitSupported
 
@@ -190,7 +272,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
       // No existing swap/bridgetransaction is pending
       !existingProcess?.txHash &&
       // Token is not native (address is not zero)
-      !isZeroAddress(step.action.fromToken.address) &&
+      !isFromNativeToken &&
       // Token doesn't support native permits
       !nativePermitSupported
 
@@ -220,325 +302,297 @@ export class EVMStepExecutor extends BaseStepExecutor {
       }
     }
 
-    let process = this.statusManager.findOrCreateProcess({
-      step,
-      type: currentProcessType,
-      chainId: fromChain.id,
-    })
-
-    if (process.status !== 'DONE') {
-      try {
-        let txHash: Hash
-        if (process.txHash) {
-          // Make sure that the chain is still correct
-          const updatedClient = await this.checkClient(step, process)
-          if (!updatedClient) {
-            return step
-          }
+    let process = this.statusManager.findProcess(step, currentProcessType)
 
-          // Wait for exiting transaction
-          txHash = process.txHash as Hash
-        } else {
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            'STARTED'
-          )
+    if (process?.status === 'DONE') {
+      await waitForDestinationChainTransaction(
+        step,
+        process,
+        fromChain,
+        toChain,
+        this.statusManager
+      )
 
-          // Check balance
-          await checkBalance(this.client.account!.address, step)
-
-          // Create new transaction request
-          if (!step.transactionRequest) {
-            const { execution, ...stepBase } = step
-            let updatedStep: LiFiStep
-            if (isPermitStep) {
-              const updatedRelayedStep = await getRelayerQuote({
-                fromChain: stepBase.action.fromChainId,
-                fromToken: stepBase.action.fromToken.address,
-                fromAddress: stepBase.action.fromAddress!,
-                fromAmount: stepBase.action.fromAmount,
-                toChain: stepBase.action.toChainId,
-                toToken: stepBase.action.toToken.address,
-                slippage: stepBase.action.slippage,
-                toAddress: stepBase.action.toAddress,
-                allowBridges: [stepBase.tool],
-              })
-              updatedStep = {
-                ...updatedRelayedStep.data.quote.step,
-                ...updatedRelayedStep.data.quote,
-                id: stepBase.id,
-              }
-            } else {
-              updatedStep = await getStepTransaction(stepBase)
-            }
-            const comparedStep = await stepComparison(
-              this.statusManager,
-              step,
-              updatedStep,
-              this.allowUserInteraction,
-              this.executionOptions
-            )
-            Object.assign(step, {
-              ...comparedStep,
-              execution: step.execution,
-            })
-          }
+      return step
+    }
 
-          if (!step.transactionRequest) {
-            throw new TransactionError(
-              LiFiErrorCode.TransactionUnprepared,
-              'Unable to prepare transaction.'
-            )
+    try {
+      if (process?.txHash) {
+        // Make sure that the chain is still correct
+        const updatedClient = await this.checkClient(step, process)
+        if (!updatedClient) {
+          return step
+        }
+
+        // Wait for exiting transaction
+        const txHash = process.txHash as Hash
+
+        await this.waitForTransaction({
+          step,
+          process,
+          fromChain,
+          toChain,
+          atomicBatchSupported,
+          isRelayerTransaction,
+          txHash,
+          isBridgeExecution,
+        })
+
+        return step
+      }
+
+      process = this.statusManager.findOrCreateProcess({
+        step,
+        type: permitSupported ? 'PERMIT' : currentProcessType,
+        status: 'STARTED',
+      })
+
+      // Check balance
+      await checkBalance(this.client.account!.address, step)
+
+      // Create new transaction request
+      if (!step.transactionRequest) {
+        const { execution, ...stepBase } = step
+        let updatedStep: LiFiStep
+        if (isRelayerTransaction) {
+          const updatedRelayedStep = await getRelayerQuote({
+            fromChain: stepBase.action.fromChainId,
+            fromToken: stepBase.action.fromToken.address,
+            fromAddress: stepBase.action.fromAddress!,
+            fromAmount: stepBase.action.fromAmount,
+            toChain: stepBase.action.toChainId,
+            toToken: stepBase.action.toToken.address,
+            slippage: stepBase.action.slippage,
+            toAddress: stepBase.action.toAddress,
+            allowBridges: [stepBase.tool],
+          })
+          updatedStep = {
+            ...updatedRelayedStep.data.quote.step,
+            ...updatedRelayedStep.data.quote,
+            id: stepBase.id,
           }
+        } else {
+          updatedStep = await getStepTransaction(stepBase)
+        }
+        const comparedStep = await stepComparison(
+          this.statusManager,
+          step,
+          updatedStep,
+          this.allowUserInteraction,
+          this.executionOptions
+        )
+        Object.assign(step, {
+          ...comparedStep,
+          execution: step.execution,
+        })
+      }
 
-          let transactionRequest: TransactionParameters = {
-            to: step.transactionRequest.to,
-            from: step.transactionRequest.from,
-            data: step.transactionRequest.data,
-            value: step.transactionRequest.value
-              ? BigInt(step.transactionRequest.value)
-              : undefined,
-            gas: step.transactionRequest.gasLimit
-              ? BigInt(step.transactionRequest.gasLimit)
+      if (!step.transactionRequest) {
+        throw new TransactionError(
+          LiFiErrorCode.TransactionUnprepared,
+          'Unable to prepare transaction.'
+        )
+      }
+
+      let transactionRequest: TransactionParameters = {
+        to: step.transactionRequest.to,
+        from: step.transactionRequest.from,
+        data: step.transactionRequest.data,
+        value: step.transactionRequest.value
+          ? BigInt(step.transactionRequest.value)
+          : undefined,
+        gas: step.transactionRequest.gasLimit
+          ? BigInt(step.transactionRequest.gasLimit)
+          : 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.client.account?.type === 'local'
+            ? await getMaxPriorityFeePerGas(this.client)
+            : step.transactionRequest.maxPriorityFeePerGas
+              ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
               : 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.client.account?.type === 'local'
-                ? await getMaxPriorityFeePerGas(this.client)
-                : step.transactionRequest.maxPriorityFeePerGas
-                  ? BigInt(step.transactionRequest.maxPriorityFeePerGas)
-                  : undefined,
-          }
+      }
 
-          if (this.executionOptions?.updateTransactionRequestHook) {
-            const customizedTransactionRequest: TransactionParameters =
-              await this.executionOptions.updateTransactionRequestHook({
-                requestType: 'transaction',
-                ...transactionRequest,
-              })
+      if (this.executionOptions?.updateTransactionRequestHook) {
+        const customizedTransactionRequest: TransactionParameters =
+          await this.executionOptions.updateTransactionRequestHook({
+            requestType: 'transaction',
+            ...transactionRequest,
+          })
 
-            transactionRequest = {
-              ...transactionRequest,
-              ...customizedTransactionRequest,
-            }
-          }
+        transactionRequest = {
+          ...transactionRequest,
+          ...customizedTransactionRequest,
+        }
+      }
 
-          // Make sure that the chain is still correct
-          const updatedClient = await this.checkClient(step, process)
-          if (!updatedClient) {
-            return step
-          }
+      // Make sure that the chain is still correct
+      const updatedClient = await this.checkClient(step, process)
+      if (!updatedClient) {
+        return step
+      }
 
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            permitSupported ? 'PERMIT_REQUIRED' : 'ACTION_REQUIRED'
-          )
+      process = this.statusManager.updateProcess(
+        step,
+        process.type,
+        'ACTION_REQUIRED'
+      )
 
-          if (!this.allowUserInteraction) {
-            return step
-          }
+      if (!this.allowUserInteraction) {
+        return step
+      }
 
-          let isTransactionRelayed = false
+      let txHash: Hash
+      let isTransactionRelayed = false
 
-          if (atomicBatchSupported) {
-            const transferCall: Call = {
-              chainId: fromChain.id,
-              data: transactionRequest.data as Hex,
-              to: transactionRequest.to as Address,
-              value: transactionRequest.value,
-            }
+      if (atomicBatchSupported) {
+        const transferCall: Call = {
+          chainId: fromChain.id,
+          data: transactionRequest.data as Hex,
+          to: transactionRequest.to as Address,
+          value: transactionRequest.value,
+        }
 
-            calls.push(transferCall)
-
-            txHash = (await getAction(
-              this.client,
-              sendCalls,
-              'sendCalls'
-            )({
-              account: this.client.account!,
-              calls,
-            })) as Address
-          } else {
-            let permitSignature: PermitSignature | undefined
-            if (permitSupported) {
-              permitSignature = await signPermitMessage(this.client, {
-                transactionRequest,
-                chain: fromChain,
-                tokenAddress: step.action.fromToken.address as Address,
-                amount: BigInt(step.action.fromAmount),
-                nativePermit,
-                permitData: isPermitStep ? step.permitData : undefined,
-                useWitness: isPermitStep,
-              })
-              transactionRequest.to = fromChain.permit2Proxy
-            }
-            if (isPermitStep && permitSignature) {
-              const relayedTransaction = await relayTransaction({
-                tokenOwner: this.client.account!.address,
-                chainId: fromChain.id,
-                permit: step.permit,
-                witness: step.witness,
-                signedPermitData: permitSignature.signature,
-                callData: transactionRequest.data!,
-              })
-              txHash = relayedTransaction.data.taskId
-              isTransactionRelayed = true
-            } else {
-              if (permitSignature) {
-                // If we have a permit signature, we need to use updated data
-                transactionRequest.data = permitSignature.data
-                try {
-                  // Try to re-estimate the gas due to additional Permit data
-                  const estimatedGas = await estimateGas(this.client, {
-                    account: this.client.account!,
-                    to: transactionRequest.to as Address,
-                    data: transactionRequest.data as Hex,
-                    value: transactionRequest.value,
-                  })
-                  transactionRequest.gas =
-                    transactionRequest.gas &&
-                    transactionRequest.gas > estimatedGas
-                      ? transactionRequest.gas
-                      : estimatedGas
-                } catch {
-                  // Let the wallet estimate the gas in case of failure
-                  transactionRequest.gas = undefined
-                }
-              }
-              process = this.statusManager.updateProcess(
-                step,
-                process.type,
-                'ACTION_REQUIRED'
-              )
-              txHash = await getAction(
-                this.client,
-                sendTransaction,
-                'sendTransaction'
-              )({
-                to: transactionRequest.to,
+        calls.push(transferCall)
+
+        txHash = (await getAction(
+          this.client,
+          sendCalls,
+          'sendCalls'
+        )({
+          account: this.client.account!,
+          calls,
+        })) as Address
+      } else {
+        let permitSignature: PermitSignature | undefined
+        if (permitSupported) {
+          permitSignature = await signPermitMessage(this.client, {
+            transactionRequest,
+            chain: fromChain,
+            tokenAddress: step.action.fromToken.address as Address,
+            amount: BigInt(step.action.fromAmount),
+            nativePermit,
+            permitData: isRelayerTransaction ? step.permitData : undefined,
+            useWitness: isRelayerTransaction,
+          })
+          transactionRequest.to = fromChain.permit2Proxy
+          this.statusManager.updateProcess(step, process.type, 'DONE')
+        }
+        if (isRelayerTransaction && permitSignature) {
+          process = this.statusManager.findOrCreateProcess({
+            step,
+            type: currentProcessType,
+            status: 'PENDING',
+          })
+          const relayedTransaction = await relayTransaction({
+            tokenOwner: this.client.account!.address,
+            chainId: fromChain.id,
+            permit: step.permit,
+            witness: step.witness,
+            signedPermitData: permitSignature.signature,
+            callData: transactionRequest.data!,
+          })
+          txHash = relayedTransaction.data.taskId
+          isTransactionRelayed = true
+        } else {
+          process = this.statusManager.findOrCreateProcess({
+            step,
+            type: currentProcessType,
+            status: 'STARTED',
+          })
+          if (permitSignature) {
+            // If we have a permit signature, we need to use updated data
+            transactionRequest.data = permitSignature.data
+            try {
+              // Try to re-estimate the gas due to additional Permit data
+              const estimatedGas = await estimateGas(this.client, {
                 account: this.client.account!,
-                data: transactionRequest.data,
+                to: transactionRequest.to as Address,
+                data: transactionRequest.data as Hex,
                 value: transactionRequest.value,
-                gas: transactionRequest.gas,
-                gasPrice: transactionRequest.gasPrice,
-                maxFeePerGas: transactionRequest.maxFeePerGas,
-                maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
-              } as SendTransactionParameters)
+              })
+              transactionRequest.gas =
+                transactionRequest.gas && transactionRequest.gas > estimatedGas
+                  ? transactionRequest.gas
+                  : estimatedGas
+            } catch {
+              // Let the wallet estimate the gas in case of failure
+              transactionRequest.gas = undefined
             }
           }
           process = this.statusManager.updateProcess(
             step,
             process.type,
-            'PENDING',
-            // When atomic batch is supported, txHash represents the batch hash rather than an individual transaction hash at this point
-            atomicBatchSupported
-              ? {
-                  atomicBatchSupported,
-                }
-              : isTransactionRelayed
-                ? undefined
-                : {
-                    txHash: txHash,
-                    txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-                  }
+            'ACTION_REQUIRED'
           )
-        }
-
-        let transactionReceipt:
-          | TransactionReceipt
-          | WalletCallReceipt
-          | undefined
-
-        if (atomicBatchSupported) {
-          transactionReceipt = await waitForBatchTransactionReceipt(
+          txHash = await getAction(
             this.client,
-            txHash
-          )
-        } else if (isPermitStep) {
-          transactionReceipt = await waitForRelayedTransactionReceipt(txHash)
-        } else {
-          transactionReceipt = await waitForTransactionReceipt({
-            client: this.client,
-            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}`,
-              })
-            },
-          })
+            sendTransaction,
+            'sendTransaction'
+          )({
+            to: transactionRequest.to as Address,
+            account: this.client.account!,
+            data: transactionRequest.data as Hex,
+            value: transactionRequest.value,
+            gas: transactionRequest.gas,
+            gasPrice: transactionRequest.gasPrice,
+            maxFeePerGas: transactionRequest.maxFeePerGas,
+            maxPriorityFeePerGas: transactionRequest.maxPriorityFeePerGas,
+            chain: convertExtendedChain(fromChain),
+          } as SendTransactionParameters)
         }
-
-        // Update pending process if the transaction hash from the receipt is different.
-        // This might happen if the transaction was replaced.
-        if (
-          transactionReceipt?.transactionHash &&
-          transactionReceipt.transactionHash !== txHash
-        ) {
-          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 parseEVMErrors(e, step, process)
-        process = this.statusManager.updateProcess(
-          step,
-          process.type,
-          'FAILED',
-          {
-            error: {
-              message: error.cause.message,
-              code: error.code,
-            },
-          }
-        )
-        this.statusManager.updateExecution(step, 'FAILED')
-
-        throw error
       }
-    }
+      process = this.statusManager.updateProcess(
+        step,
+        process.type,
+        'PENDING',
+        // When atomic batch is supported, txHash represents the batch hash rather than an individual transaction hash at this point
+        atomicBatchSupported
+          ? {
+              atomicBatchSupported,
+            }
+          : isTransactionRelayed
+            ? undefined
+            : {
+                txHash: txHash,
+                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
+              }
+      )
 
-    // Wait for the transaction status on the destination chain
-    const transactionHash = process.txHash
-    if (!transactionHash) {
-      throw new Error('Transaction hash is undefined.')
-    }
-    if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess({
+      await this.waitForTransaction({
         step,
-        type: 'RECEIVING_CHAIN',
-        status: 'PENDING',
-        chainId: toChain.id,
+        process,
+        fromChain,
+        toChain,
+        atomicBatchSupported,
+        isRelayerTransaction,
+        txHash,
+        isBridgeExecution,
       })
-    }
 
-    await waitForDestinationChainTransaction(
-      step,
-      process.type,
-      transactionHash,
-      toChain,
-      this.statusManager
-    )
+      // DONE
+      return step
+    } catch (e: any) {
+      const error = await parseEVMErrors(e, step, process)
+      process = this.statusManager.updateProcess(
+        step,
+        process?.type || currentProcessType,
+        'FAILED',
+        {
+          error: {
+            message: error.cause.message,
+            code: error.code,
+          },
+        }
+      )
+      this.statusManager.updateExecution(step, 'FAILED')
 
-    // DONE
-    return step
+      throw error
+    }
   }
 }