@rango-dev/queue-manager-rango-preset 0.1.10-next.77 → 0.1.10-next.80

package/src/helpers.ts

@@ -7,12 +7,9 @@ import {
   SwapStorage,
 } from './types';
 import {
-  EvmBlockchainMeta,
   getBlockChainNameFromId,
   Meta,
   Network,
-  Transaction,
-  TransactionType,
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
@@ -25,6 +22,9 @@ import {
   EvmTransaction,
   SolanaTransaction,
   Transfer as TransferTransaction,
+  Transaction,
+  TransactionType,
+  EvmBlockchainMeta,
 } from 'rango-sdk';
 
 import {
@@ -39,6 +39,8 @@ import {
   getCurrentBlockchainOf,
   getCurrentBlockchainOfOrNull,
   getEvmApproveUrl,
+  getStarknetApproveUrl,
+  getTronApproveUrl,
   getRelatedWalletOrNull,
   MessageSeverity,
   PendingSwap,
@@ -51,8 +53,8 @@ import {
   WalletTypeAndAddress,
 } from './shared';
 import { logRPCError } from './shared-sentry';
-import { PrettyError } from './shared-errors';
-import { mapAppErrorCodesToAPIErrorCode, reportFailed } from './shared-api';
+import { PrettyError, mapAppErrorCodesToAPIErrorCode } from './shared-errors';
+import { httpService } from './services';
 
 type WhenTaskBlocked = Parameters<NonNullable<SwapQueueDef['whenTaskBlocked']>>;
 type WhenTaskBlockedEvent = WhenTaskBlocked[0];
@@ -144,16 +146,18 @@ export function updateSwapStatus({
       details && details.includes('Warning')
         ? 'Swap canceled by user.'
         : details;
+    const walletType = getRelatedWalletOrNull(swap, currentStep!)?.walletType;
     swap.extraMessageSeverity = MessageSeverity.error;
-    reportFailed(
-      swap.requestId,
-      currentStep?.id || 1,
-      mapAppErrorCodesToAPIErrorCode(errorCode),
-      errorReason || '',
-      (currentStep
-        ? getRelatedWalletOrNull(swap, currentStep)?.walletType
-        : null) || null
-    ).then();
+    httpService
+      .reportFailure({
+        requestId: swap.requestId,
+        step: currentStep?.id || 1,
+        eventType: mapAppErrorCodesToAPIErrorCode(errorCode),
+        reason: errorReason || '',
+        data: walletType ? { wallet: walletType } : undefined,
+      })
+      .then()
+      .catch();
   } else if (!!nextStepStatus && ['running'].includes(nextStepStatus))
     swap.extraMessageSeverity = MessageSeverity.info;
   else if (!!nextStepStatus && ['success', 'approved'].includes(nextStepStatus))
@@ -456,6 +460,8 @@ export async function isNetworkMatchedForTransaction(
             WalletType.COSMOSTATION,
             WalletType.CLOVER,
             WalletType.BRAVE,
+            WalletType.FRONTIER,
+            WalletType.KUCOIN,
           ].includes(sourceWallet.walletType)
         ) {
           const provider = getEvmProvider(providers, sourceWallet.walletType);
@@ -500,6 +506,10 @@ export const getCurrentAddressOf = (
   const result =
     swap.wallets[step.evmTransaction?.blockChain || ''] ||
     swap.wallets[step.evmApprovalTransaction?.blockChain || ''] ||
+    swap.wallets[step.tronTransaction?.blockChain || ''] ||
+    swap.wallets[step.tronApprovalTransaction?.blockChain || ''] ||
+    swap.wallets[step.starknetTransaction?.blockChain || ''] ||
+    swap.wallets[step.starknetApprovalTransaction?.blockChain || ''] ||
     swap.wallets[step.cosmosTransaction?.blockChain || ''] ||
     swap.wallets[step.solanaTransaction?.blockChain || ''] ||
     (step.transferTransaction?.fromWalletAddress
@@ -526,7 +536,7 @@ export function getRelatedWallet(
   const walletType = wallet?.walletType;
   if (walletType === WalletType.UNKNOWN || wallet === null)
     throw PrettyError.AssertionFailed(
-      `Wallet for source ${blockchain} not passed to transfer: walletType: ${walletType}`
+      `Wallet for source ${blockchain} not passed: walletType: ${walletType}`
     );
   return wallet;
 }
@@ -538,6 +548,10 @@ export const isTxAlreadyCreated = (
   const result =
     swap.wallets[step.evmTransaction?.blockChain || ''] ||
     swap.wallets[step.evmApprovalTransaction?.blockChain || ''] ||
+    swap.wallets[step.tronTransaction?.blockChain || ''] ||
+    swap.wallets[step.tronApprovalTransaction?.blockChain || ''] ||
+    swap.wallets[step.starknetTransaction?.blockChain || ''] ||
+    swap.wallets[step.starknetApprovalTransaction?.blockChain || ''] ||
     swap.wallets[step.cosmosTransaction?.blockChain || ''] ||
     swap.wallets[step.solanaTransaction?.blockChain || ''] ||
     step.transferTransaction?.fromWalletAddress ||
@@ -762,9 +776,15 @@ export function singTransaction(
     cosmosTransaction,
     solanaTransaction,
     transferTransaction,
+    tronTransaction,
+    tronApprovalTransaction,
+    starknetTransaction,
+    starknetApprovalTransaction,
   } = currentStep;
   const sourceWallet = getRelatedWallet(swap, currentStep);
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
   const walletSigners = getSigners(sourceWallet.walletType);
+
   const onFinish = () => {
     if (actions.context.resetClaimedBy) {
       actions.context.resetClaimedBy();
@@ -799,65 +819,243 @@ export function singTransaction(
     });
 
     // Execute transaction
-    walletSigners.executeEvmTransaction(evmApprovalTransaction, meta).then(
-      (hash) => {
-        console.debug('transaction of approval minted successfully', hash);
-        const approveUrl = getEvmApproveUrl(
-          hash,
-          getCurrentBlockchainOf(swap, currentStep),
-          meta.evmBasedChains
-        );
-        currentStep.explorerUrl = [
-          ...(currentStep.explorerUrl || []),
-          {
-            url: approveUrl,
-            description: `approve`,
-          },
-        ];
-
-        // `currentStep` has been mutated, let's update storage.
-        setStorage({
-          ...getStorage(),
-          swapDetails: swap,
-        });
-        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
-        next();
-        onFinish();
-      },
+    walletSigners
+      .getSigner(TransactionType.EVM)
+      .signAndSendTx(evmApprovalTransaction, walletAddress, null)
+      .then(
+        (hash) => {
+          console.debug('transaction of approval minted successfully', hash);
+          const approveUrl = getEvmApproveUrl(
+            hash,
+            getCurrentBlockchainOf(swap, currentStep),
+            meta.evmBasedChains
+          );
+          currentStep.explorerUrl = [
+            ...(currentStep.explorerUrl || []),
+            {
+              url: approveUrl,
+              description: `approve`,
+            },
+          ];
 
-      (error) => {
-        if (swap.status === 'failed') return;
-        console.debug('error in approving', error);
-        const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
-          prettifyErrorMessage(error);
-        if (
-          error &&
-          error?.root &&
-          error?.root?.message &&
-          error?.root?.code &&
-          error?.root?.reason
-        ) {
-          logRPCError(error.root, swap, currentStep, sourceWallet?.walletType);
+          // `currentStep` has been mutated, let's update storage.
+          setStorage({
+            ...getStorage(),
+            swapDetails: swap,
+          });
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+
+        (error) => {
+          if (swap.status === 'failed') return;
+          console.debug('error in approving', error);
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'contract_rejected',
+            ...updateResult,
+          });
+
+          failed();
+          onFinish();
         }
+      );
+    return;
+  } else if (!!tronApprovalTransaction) {
+    // Update swap status
+    const message = `waiting for approval of ${currentStep?.fromSymbol} coin ${
+      sourceWallet.walletType === WalletType.WALLET_CONNECT
+        ? 'on your mobile phone'
+        : ''
+    }`;
+    const updateResult = updateSwapStatus({
+      getStorage,
+      setStorage,
+      nextStepStatus: 'waitingForApproval',
+      message,
+      details:
+        'Waiting for approve transaction to be mined and confirmed successfully',
+    });
+    notifier({
+      eventType: 'confirm_contract',
+      ...updateResult,
+    });
 
-        const updateResult = updateSwapStatus({
-          getStorage,
-          setStorage,
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: extraMessage,
-          details: extraMessageDetail,
-          errorCode: extraMessageErrorCode,
-        });
-        notifier({
-          eventType: 'contract_rejected',
-          ...updateResult,
-        });
+    // Execute transaction
+    walletSigners
+      .getSigner(TransactionType.TRON)
+      .signAndSendTx(tronApprovalTransaction, walletAddress, null)
+      .then(
+        (hash) => {
+          console.debug('transaction of approval minted successfully', hash);
+          const approveUrl = getTronApproveUrl(hash);
+          currentStep.explorerUrl = [
+            ...(currentStep.explorerUrl || []),
+            {
+              url: approveUrl,
+              description: `approve`,
+            },
+          ];
 
-        failed();
-        onFinish();
-      }
-    );
+          // `currentStep` has been mutated, let's update storage.
+          setStorage({
+            ...getStorage(),
+            swapDetails: swap,
+          });
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+
+        (error) => {
+          if (swap.status === 'failed') return;
+          console.debug('error in approving', error);
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'contract_rejected',
+            ...updateResult,
+          });
+
+          failed();
+          onFinish();
+        }
+      );
+    return;
+  } else if (!!starknetApprovalTransaction) {
+    // Update swap status
+    const message = `waiting for approval of ${currentStep?.fromSymbol} coin ${
+      sourceWallet.walletType === WalletType.WALLET_CONNECT
+        ? 'on your mobile phone'
+        : ''
+    }`;
+    const updateResult = updateSwapStatus({
+      getStorage,
+      setStorage,
+      nextStepStatus: 'waitingForApproval',
+      message,
+      details:
+        'Waiting for approve transaction to be mined and confirmed successfully',
+    });
+    notifier({
+      eventType: 'confirm_contract',
+      ...updateResult,
+    });
+
+    // Execute transaction
+    walletSigners
+      .getSigner(TransactionType.STARKNET)
+      .signAndSendTx(starknetApprovalTransaction, walletAddress, null)
+      .then(
+        (hash) => {
+          console.debug('transaction of approval minted successfully', hash);
+          const approveUrl = getStarknetApproveUrl(hash);
+          currentStep.explorerUrl = [
+            ...(currentStep.explorerUrl || []),
+            {
+              url: approveUrl,
+              description: `approve`,
+            },
+          ];
+
+          // `currentStep` has been mutated, let's update storage.
+          setStorage({
+            ...getStorage(),
+            swapDetails: swap,
+          });
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+
+        (error) => {
+          if (swap.status === 'failed') return;
+          console.debug('error in approving', error);
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'contract_rejected',
+            ...updateResult,
+          });
+
+          failed();
+          onFinish();
+        }
+      );
     return;
   }
 
@@ -881,34 +1079,37 @@ export function singTransaction(
       ...updateResult,
     });
 
-    walletSigners.executeTransfer(transferTransaction, meta).then(
-      (txId) => {
-        setStepTransactionIds(actions, txId, 'transfer_confirmed', notifier);
-        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
-        next();
-        onFinish();
-      },
-      (error) => {
-        if (swap.status === 'failed') return;
-        const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
-          prettifyErrorMessage(error);
-        const updateResult = updateSwapStatus({
-          getStorage,
-          setStorage,
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: extraMessage,
-          details: extraMessageDetail,
-          errorCode: extraMessageErrorCode,
-        });
-        notifier({
-          eventType: 'transfer_rejected',
-          ...updateResult,
-        });
-        failed();
-        onFinish();
-      }
-    );
+    walletSigners
+      .getSigner(TransactionType.TRANSFER)
+      .signAndSendTx(transferTransaction, walletAddress, null)
+      .then(
+        (txId) => {
+          setStepTransactionIds(actions, txId, 'transfer_confirmed', notifier);
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'transfer_rejected',
+            ...updateResult,
+          });
+          failed();
+          onFinish();
+        }
+      );
   } else if (!!evmTransaction) {
     const updateResult = updateSwapStatus({
       getStorage,
@@ -922,44 +1123,52 @@ export function singTransaction(
       ...updateResult,
     });
 
-    walletSigners.executeEvmTransaction(evmTransaction, meta).then(
-      (id) => {
-        setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
-        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
-        next();
-        onFinish();
-      },
-      (error) => {
-        if (swap.status === 'failed') return;
-        const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
-          prettifyErrorMessage(error);
-        if (
-          error &&
-          error?.root &&
-          error?.root?.message &&
-          error?.root?.code &&
-          error?.root?.reason
-        ) {
-          logRPCError(error.root, swap, currentStep, sourceWallet?.walletType);
-        }
-        const updateResult = updateSwapStatus({
-          getStorage,
-          setStorage,
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: extraMessage,
-          details: extraMessageDetail,
-          errorCode: extraMessageErrorCode,
-        });
-        notifier({
-          eventType: 'smart_contract_call_failed',
-          ...updateResult,
-        });
+    walletSigners
+      .getSigner(TransactionType.EVM)
+      .signAndSendTx(evmTransaction, walletAddress, null)
+      .then(
+        (id) => {
+          setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'smart_contract_call_failed',
+            ...updateResult,
+          });
 
-        failed();
-        onFinish();
-      }
-    );
+          failed();
+          onFinish();
+        }
+      );
   } else if (!!cosmosTransaction) {
     const updateResult = updateSwapStatus({
       getStorage,
@@ -1005,35 +1214,38 @@ export function singTransaction(
       return;
     }
 
-    walletSigners.executeCosmosMessage(cosmosTransaction, meta).then(
-      // todo
-      (id: string | null) => {
-        setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
-        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
-        next();
-        onFinish();
-      },
-      (error: string | null) => {
-        if (swap.status === 'failed') return;
-        const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
-          prettifyErrorMessage(error);
-        const updateResult = updateSwapStatus({
-          getStorage,
-          setStorage,
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: extraMessage,
-          details: extraMessageDetail,
-          errorCode: extraMessageErrorCode,
-        });
-        notifier({
-          eventType: 'smart_contract_call_failed',
-          ...updateResult,
-        });
-        failed();
-        onFinish();
-      }
-    );
+    walletSigners
+      .getSigner(TransactionType.COSMOS)
+      .signAndSendTx(cosmosTransaction, walletAddress, null)
+      .then(
+        // todo
+        (id: string | null) => {
+          setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error: string | null) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'smart_contract_call_failed',
+            ...updateResult,
+          });
+          failed();
+          onFinish();
+        }
+      );
   } else if (!!solanaTransaction) {
     const updateResult = updateSwapStatus({
       getStorage,
@@ -1048,34 +1260,160 @@ export function singTransaction(
     });
 
     const tx = solanaTransaction;
-    walletSigners.executeSolanaTransaction(tx, swap.requestId).then(
-      (txId) => {
-        setStepTransactionIds(actions, txId, 'smart_contract_called', notifier);
-        schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
-        next();
-        onFinish();
-      },
-      (error) => {
-        if (swap.status === 'failed') return;
-        const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
-          prettifyErrorMessage(error);
-        const updateResult = updateSwapStatus({
-          getStorage,
-          setStorage,
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: extraMessage,
-          details: extraMessageDetail,
-          errorCode: extraMessageErrorCode,
-        });
-        notifier({
-          eventType: 'smart_contract_call_failed',
-          ...updateResult,
-        });
-        failed();
-        onFinish();
-      }
-    );
+    walletSigners
+      .getSigner(TransactionType.SOLANA)
+      .signAndSendTx(tx, walletAddress, null)
+      .then(
+        (txId) => {
+          setStepTransactionIds(
+            actions,
+            txId,
+            'smart_contract_called',
+            notifier
+          );
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'smart_contract_call_failed',
+            ...updateResult,
+          });
+          failed();
+          onFinish();
+        }
+      );
+  } else if (!!tronTransaction) {
+    const updateResult = updateSwapStatus({
+      getStorage,
+      setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails,
+    });
+    notifier({
+      eventType: 'calling_smart_contract',
+      ...updateResult,
+    });
+
+    walletSigners
+      .getSigner(TransactionType.TRON)
+      .signAndSendTx(tronTransaction, walletAddress, null)
+      .then(
+        (id) => {
+          setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'smart_contract_call_failed',
+            ...updateResult,
+          });
+
+          failed();
+          onFinish();
+        }
+      );
+  } else if (!!starknetTransaction) {
+    const updateResult = updateSwapStatus({
+      getStorage,
+      setStorage,
+      nextStepStatus: 'running',
+      message: executeMessage,
+      details: executeDetails,
+    });
+    notifier({
+      eventType: 'calling_smart_contract',
+      ...updateResult,
+    });
+
+    walletSigners
+      .getSigner(TransactionType.STARKNET)
+      .signAndSendTx(starknetTransaction, walletAddress, null)
+      .then(
+        (id) => {
+          setStepTransactionIds(actions, id, 'smart_contract_called', notifier);
+          schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+          next();
+          onFinish();
+        },
+        (error) => {
+          if (swap.status === 'failed') return;
+          const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+            prettifyErrorMessage(error);
+          if (
+            error &&
+            error?.root &&
+            error?.root?.message &&
+            error?.root?.code &&
+            error?.root?.reason
+          ) {
+            logRPCError(
+              error.root,
+              swap,
+              currentStep,
+              sourceWallet?.walletType
+            );
+          }
+          const updateResult = updateSwapStatus({
+            getStorage,
+            setStorage,
+            nextStatus: 'failed',
+            nextStepStatus: 'failed',
+            message: extraMessage,
+            details: extraMessageDetail,
+            errorCode: extraMessageErrorCode,
+          });
+          notifier({
+            eventType: 'smart_contract_call_failed',
+            ...updateResult,
+          });
+
+          failed();
+          onFinish();
+        }
+      );
   }
 }