@rango-dev/queue-manager-rango-preset 0.1.15-next.3 → 0.1.15-next.4

package/src/helpers.ts

@@ -21,16 +21,16 @@ import {
 import { Providers, readAccountAddress } from '@rango-dev/wallets-core';
 
 import {
-  TronTransaction,
-  StarknetTransaction,
-  CosmosTransaction,
-  EvmTransaction,
-  SolanaTransaction,
-  Transfer as TransferTransaction,
   Transaction,
   TransactionType,
   EvmBlockchainMeta,
   CreateTransactionResponse,
+  isEvmTransaction,
+  isCosmosTransaction,
+  isSolanaTransaction,
+  isTronTransaction,
+  isStarknetTransaction,
+  isTransferTransaction,
 } from 'rango-sdk';
 
 import {
@@ -44,9 +44,7 @@ import {
   EventType,
   getCurrentBlockchainOf,
   getCurrentBlockchainOfOrNull,
-  getEvmApproveUrl,
-  getStarknetApproveUrl,
-  getTronApproveUrl,
+  getScannerUrl,
   getRelatedWalletOrNull,
   MessageSeverity,
   PendingSwap,
@@ -55,7 +53,6 @@ import {
   StepStatus,
   SwapStatus,
   Wallet,
-  SwapProgressNotification,
   getRelatedWallet,
   getCurrentAddressOf,
 } from './shared';
@@ -93,6 +90,23 @@ export function claimQueue() {
   };
 }
 
+/**
+ *
+ * We use module-level variable to keep track of
+ * map of transactions hash to the TransactionResponse
+ *
+ */
+let swapTransactionToResponseMap: { [id: string]: any } = {};
+export function useTransactionsResponse() {
+  return {
+    getTransactionResponseByHash: (hash: string) =>
+      swapTransactionToResponseMap[hash],
+    setTransactionResponseByHash: (hash: string, response: any) => {
+      swapTransactionToResponseMap[hash] = response;
+    },
+  };
+}
+
 /**
  * Sample inputs are:
  *  - "metamask-ETH"
@@ -130,6 +144,110 @@ export const getCurrentStep = (swap: PendingSwap): PendingSwapStep | null => {
   );
 };
 
+/**
+ *
+ * Returns current step transaction
+ *
+ */
+export const getCurrentStepTx = (
+  currentStep: PendingSwapStep
+): Transaction | null => {
+  const {
+    evmTransaction,
+    evmApprovalTransaction,
+    cosmosTransaction,
+    solanaTransaction,
+    transferTransaction,
+    starknetApprovalTransaction,
+    starknetTransaction,
+    tronApprovalTransaction,
+    tronTransaction,
+  } = currentStep;
+  return (
+    evmTransaction ||
+    evmApprovalTransaction ||
+    cosmosTransaction ||
+    solanaTransaction ||
+    transferTransaction ||
+    starknetApprovalTransaction ||
+    starknetTransaction ||
+    tronApprovalTransaction ||
+    tronTransaction
+  );
+};
+
+/**
+ *
+ * Set current step transaction
+ *
+ */
+export const setCurrentStepTx = (
+  currentStep: PendingSwapStep,
+  transaction: Transaction
+): PendingSwapStep => {
+  currentStep.transferTransaction = null;
+  currentStep.cosmosTransaction = null;
+  currentStep.evmTransaction = null;
+  currentStep.solanaTransaction = null;
+  currentStep.evmApprovalTransaction = null;
+  currentStep.starknetApprovalTransaction = null;
+  currentStep.starknetTransaction = null;
+  currentStep.tronApprovalTransaction = null;
+  currentStep.tronTransaction = null;
+
+  if (isEvmTransaction(transaction)) {
+    if (transaction.isApprovalTx)
+      currentStep.evmApprovalTransaction = transaction;
+    else currentStep.evmTransaction = transaction;
+  } else if (isCosmosTransaction(transaction)) {
+    currentStep.cosmosTransaction = transaction;
+  } else if (isSolanaTransaction(transaction)) {
+    currentStep.solanaTransaction = transaction;
+  } else if (isTransferTransaction(transaction)) {
+    currentStep.transferTransaction = transaction;
+  } else if (isStarknetTransaction(transaction)) {
+    if (transaction.isApprovalTx)
+      currentStep.starknetApprovalTransaction = transaction;
+    else currentStep.starknetTransaction = transaction;
+  } else if (isTronTransaction(transaction)) {
+    if (transaction.isApprovalTx)
+      currentStep.tronApprovalTransaction = transaction;
+    else currentStep.tronTransaction = transaction;
+  }
+  return currentStep;
+};
+
+/**
+ *
+ * Returns current step transaction type
+ *
+ */
+export const getCurrentStepTxType = (
+  currentStep: PendingSwapStep
+): TransactionType | undefined => {
+  return getCurrentStepTx(currentStep)?.type;
+};
+
+/**
+ *
+ * Returns a boolean indicating that current step is an approval tx or not.
+ *
+ */
+export const isApprovalCurrentStepTx = (
+  currentStep: PendingSwapStep
+): boolean => {
+  const {
+    evmApprovalTransaction,
+    starknetApprovalTransaction,
+    tronApprovalTransaction,
+  } = currentStep;
+  return !!(
+    evmApprovalTransaction ||
+    starknetApprovalTransaction ||
+    tronApprovalTransaction
+  );
+};
+
 /**
  * When we are doing a swap, there are some common fields that will be updated together.
  * This function helps us to update a swap status and also it will update some more fields like `extraMessageSeverity` based on the input.
@@ -218,12 +336,17 @@ export function updateSwapStatus({
   };
 }
 
+/**
+ *
+ * Set current step transaction hash, update pending swap status, and notify user if needed
+ *
+ */
 export function setStepTransactionIds(
   { getStorage, setStorage }: ExecuterActions<SwapStorage, SwapActionTypes>,
   txId: string | null,
   notifier: SwapQueueContext['notifier'],
   eventType?: EventType,
-  approveUrl?: string
+  explorerUrl?: { url?: string; description?: string }
 ): void {
   const swap = getStorage().swapDetails;
   swap.hasAlreadyProceededToSign = null;
@@ -231,12 +354,12 @@ export function setStepTransactionIds(
   const currentStep = getCurrentStep(swap)!;
   currentStep.executedTransactionId = txId;
   currentStep.executedTransactionTime = new Date().getTime().toString();
-  if (!!approveUrl)
+  if (!!explorerUrl?.url)
     currentStep.explorerUrl = [
       ...(currentStep.explorerUrl || []),
       {
-        url: approveUrl,
-        description: `approve`,
+        url: explorerUrl.url,
+        description: explorerUrl.description || null,
       },
     ];
   if (eventType === 'check_tx_status') {
@@ -257,18 +380,6 @@ export function setStepTransactionIds(
     notifier({ eventType: eventType, swap: swap, step: currentStep });
 }
 
-export function getSwapNotitfication(
-  eventType: EventType,
-  updateResult: { swap: PendingSwap; step: PendingSwapStep | null }
-): SwapProgressNotification {
-  if (updateResult.swap.hasAlreadyProceededToSign) {
-    return {
-      eventType: 'transaction_expired',
-      ...updateResult,
-    };
-  } else return { eventType, ...updateResult };
-}
-
 /**
  * If a swap needs a wallet to be connected,
  * By calling this function some related fields will be updated to show a correct message and state for notfiying the user.
@@ -395,22 +506,6 @@ export function delay(ms: number): Promise<unknown> {
   return new Promise((res) => setTimeout(res, ms));
 }
 
-export const isEvmTransaction = (tx: Transaction): tx is EvmTransaction =>
-  tx.type === TransactionType.EVM;
-
-export const isCosmosTransaction = (tx: Transaction): tx is CosmosTransaction =>
-  tx.type === TransactionType.COSMOS;
-export const isSolanaTransaction = (tx: Transaction): tx is SolanaTransaction =>
-  tx.type === TransactionType.SOLANA;
-export const isTrasnferTransaction = (
-  tx: Transaction
-): tx is TransferTransaction => tx.type === TransactionType.TRANSFER;
-export const isStarknetTransaction = (
-  tx: Transaction
-): tx is StarknetTransaction => tx.type === TransactionType.STARKNET;
-export const isTronTransaction = (tx: Transaction): tx is TronTransaction =>
-  tx.type === TransactionType.TRON;
-
 /**
  *
  * To execute a swap, we are keeping the user prefrences on what wallet they are going to use for a sepecific blockchain
@@ -793,26 +888,18 @@ export function isRequiredWalletConnected(
 export function singTransaction(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
 ): void {
+  const { setTransactionResponseByHash } = useTransactionsResponse();
   const { getStorage, setStorage, failed, next, schedule, context } = actions;
   const { meta, getSigners, notifier, isMobileWallet } = context;
   const swap = getStorage().swapDetails;
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const currentStep = getCurrentStep(swap)!;
-  const {
-    evmTransaction,
-    evmApprovalTransaction,
-    cosmosTransaction,
-    solanaTransaction,
-    transferTransaction,
-    tronTransaction,
-    tronApprovalTransaction,
-    starknetTransaction,
-    starknetApprovalTransaction,
-  } = currentStep;
+
   const sourceWallet = getRelatedWallet(swap, currentStep);
+  const mobileWallet = isMobileWallet(sourceWallet?.walletType);
   const walletAddress = getCurrentAddressOf(swap, currentStep);
   const walletSigners = getSigners(sourceWallet.walletType);
-  const mobileWallet = isMobileWallet(sourceWallet.walletType);
+  const currentStepBlockchain = getCurrentBlockchainOf(swap, currentStep);
 
   const onFinish = () => {
     // TODO resetClaimedBy is undefined here
@@ -821,636 +908,133 @@ export function singTransaction(
     }
   };
 
-  if (!!evmApprovalTransaction) {
-    const spenderContract = evmApprovalTransaction?.to;
-
-    if (!spenderContract)
-      throw PrettyError.AssertionFailed(
-        'contract address is null for checking approval'
-      );
+  const tx = getCurrentStepTx(currentStep);
+  const txType = tx?.type;
+  const isApproval = isApprovalCurrentStepTx(currentStep);
+  const isSmartContractCall = [
+    TransactionType.EVM,
+    TransactionType.STARKNET,
+    TransactionType.TRON,
+  ].includes(txType!);
 
-    // Update swap status
-    const message = `Waiting for approval of ${currentStep?.fromSymbol} coin ${
-      mobileWallet ? '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_approve_contract',
-      ...updateResult,
-    });
-
-    // Execute transaction
-    walletSigners
-      .getSigner(TransactionType.EVM)
-      .signAndSendTx(evmApprovalTransaction, walletAddress, null)
-      .then(
-        (hash) => {
-          const approveUrl = getEvmApproveUrl(
-            hash,
-            getCurrentBlockchainOf(swap, currentStep),
-            meta.evmBasedChains
-          );
-          setStepTransactionIds(
-            actions,
-            hash,
-            notifier,
-            'check_approve_tx_status',
-            approveUrl
-          );
-          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:
-              extraMessageErrorCode === 'REJECTED_BY_USER'
-                ? 'contract_rejected'
-                : 'smart_contract_call_failed',
-            ...updateResult,
-          });
-
-          failed();
-          onFinish();
-        }
-      );
-    return;
-  } else if (!!tronApprovalTransaction) {
-    // Update swap status
-    const message = `Waiting for approval of ${currentStep?.fromSymbol} coin ${
-      mobileWallet ? '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_approve_contract',
-      ...updateResult,
-    });
-
-    // Execute transaction
-    walletSigners
-      .getSigner(TransactionType.TRON)
-      .signAndSendTx(tronApprovalTransaction, walletAddress, null)
-      .then(
-        (hash) => {
-          const approveUrl = getTronApproveUrl(hash);
-          setStepTransactionIds(
-            actions,
-            hash,
-            notifier,
-            'check_approve_tx_status',
-            approveUrl
-          );
-          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 hasAlreadyProceededToSign =
+    typeof swap.hasAlreadyProceededToSign === 'boolean';
 
-          const updateResult = updateSwapStatus({
-            getStorage,
-            setStorage,
-            nextStatus: 'failed',
-            nextStepStatus: 'failed',
-            message: extraMessage,
-            details: extraMessageDetail,
-            errorCode: extraMessageErrorCode,
-          });
-          notifier({
-            eventType:
-              extraMessageErrorCode === 'REJECTED_BY_USER'
-                ? 'contract_rejected'
-                : 'smart_contract_call_failed',
-            ...updateResult,
-          });
+  let nextStatus: SwapStatus | undefined,
+    nextStepStatus: StepStatus,
+    eventType: EventType,
+    message: string,
+    details: string;
 
-          failed();
-          onFinish();
-        }
-      );
-    return;
-  } else if (!!starknetApprovalTransaction) {
-    // Update swap status
-    const message = `Waiting for approval of ${currentStep?.fromSymbol} coin ${
-      mobileWallet ? 'on your mobile phone' : ''
+  if (isApproval) {
+    message = `Waiting for approval of ${currentStep?.fromSymbol} coin ${
+      mobileWallet ? '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_approve_contract',
-      ...updateResult,
-    });
-
-    // Execute transaction
-    walletSigners
-      .getSigner(TransactionType.STARKNET)
-      .signAndSendTx(starknetApprovalTransaction, walletAddress, null)
-      .then(
-        (hash) => {
-          const approveUrl = getStarknetApproveUrl(hash);
-          setStepTransactionIds(
-            actions,
-            hash,
-            notifier,
-            'check_approve_tx_status',
-            approveUrl
-          );
-          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
-            );
-          }
+    details =
+      'Waiting for approve transaction to be mined and confirmed successfully';
+    nextStepStatus = 'waitingForApproval';
+    nextStatus = undefined;
+    eventType = 'confirm_approve_contract';
+  } else if (hasAlreadyProceededToSign) {
+    message = 'Transaction is expired. Please try again.';
+    nextStepStatus = 'failed';
+    nextStatus = 'failed';
+    details = '';
+    eventType = 'transaction_expired';
+  } else {
+    message = 'Executing transaction ...';
+    nextStepStatus = 'running';
+    nextStatus = 'running';
+    details = `${mobileWallet ? 'Check your mobile phone!' : ''}`;
+    eventType = isSmartContractCall
+      ? 'calling_smart_contract'
+      : 'confirm_transfer';
+  }
 
-          const updateResult = updateSwapStatus({
-            getStorage,
-            setStorage,
-            nextStatus: 'failed',
-            nextStepStatus: 'failed',
-            message: extraMessage,
-            details: extraMessageDetail,
-            errorCode: extraMessageErrorCode,
-          });
-          notifier({
-            eventType:
-              extraMessageErrorCode === 'REJECTED_BY_USER'
-                ? 'contract_rejected'
-                : 'smart_contract_call_failed',
-            ...updateResult,
-          });
+  const updateResult = updateSwapStatus({
+    getStorage,
+    setStorage,
+    nextStepStatus,
+    nextStatus,
+    message: message,
+    details: details,
+    hasAlreadyProceededToSign: isApproval
+      ? undefined
+      : hasAlreadyProceededToSign,
+    errorCode: hasAlreadyProceededToSign ? 'TX_EXPIRED' : undefined,
+  });
+  notifier({
+    eventType,
+    ...updateResult,
+  });
 
-          failed();
-          onFinish();
-        }
-      );
+  if (hasAlreadyProceededToSign) {
+    failed();
+    onFinish();
     return;
   }
-
-  const hasAlreadyProceededToSign =
-    typeof swap.hasAlreadyProceededToSign === 'boolean';
-  const nextStepStatusBasedOnHasAlreadyProceededToSign =
-    hasAlreadyProceededToSign ? 'failed' : 'running';
-  const errorCodeBasedOnHasAlreadyProceededToSign = hasAlreadyProceededToSign
-    ? 'TX_EXPIRED'
-    : null;
-  const executeMessage = hasAlreadyProceededToSign
-    ? 'Transaction is expired. Please try again'
-    : 'executing transaction';
-  const executeDetails = mobileWallet ? 'Check your mobile phone' : '';
-  if (!!transferTransaction) {
-    const updateResult = updateSwapStatus({
-      getStorage,
-      setStorage,
-      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-
-    const notification = getSwapNotitfication('confirm_transfer', updateResult);
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
-      failed();
-      onFinish();
-    } else {
-      walletSigners
-        .getSigner(TransactionType.TRANSFER)
-        .signAndSendTx(transferTransaction, walletAddress, null)
-        .then(
-          (txId) => {
-            setStepTransactionIds(actions, txId, notifier, 'check_tx_status');
-            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:
-                extraMessageErrorCode === 'REJECTED_BY_USER'
-                  ? 'transfer_rejected'
-                  : 'transfer_failed',
-              ...updateResult,
-            });
-            failed();
-            onFinish();
-          }
-        );
-    }
-  } else if (!!evmTransaction) {
-    const updateResult = updateSwapStatus({
-      getStorage,
-      setStorage,
-      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-    const notification = getSwapNotitfication(
-      'calling_smart_contract',
-      updateResult
-    );
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
-      failed();
-      onFinish();
-    } else {
-      walletSigners
-        .getSigner(TransactionType.EVM)
-        .signAndSendTx(evmTransaction, walletAddress, null)
-        .then(
-          (id) => {
-            setStepTransactionIds(actions, id, notifier, 'check_tx_status');
-            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:
-                extraMessageErrorCode === 'REJECTED_BY_USER'
-                  ? 'contract_rejected'
-                  : 'smart_contract_call_failed',
-              ...updateResult,
-            });
-
-            failed();
-            onFinish();
-          }
-        );
-    }
-  } else if (!!cosmosTransaction) {
-    const updateResult = updateSwapStatus({
-      getStorage,
-      setStorage,
-      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-    const notification = getSwapNotitfication(
-      'calling_smart_contract',
-      updateResult
-    );
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
-      failed();
-      onFinish();
-    } else {
-      walletSigners
-        .getSigner(TransactionType.COSMOS)
-        .signAndSendTx(cosmosTransaction, walletAddress, null)
-        .then(
-          // todo
-          (id: string | null) => {
-            setStepTransactionIds(actions, id, notifier, 'check_tx_status');
-            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,
-      setStorage,
-      nextStepStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-    const notification = getSwapNotitfication(
-      'calling_smart_contract',
-      updateResult
-    );
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
-      failed();
-      onFinish();
-    } else {
-      const tx = solanaTransaction;
-      walletSigners
-        .getSigner(TransactionType.SOLANA)
-        .signAndSendTx(tx, walletAddress, null)
-        .then(
-          (txId) => {
-            setStepTransactionIds(actions, txId, notifier, 'check_tx_status');
-            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: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-    const notification = getSwapNotitfication(
-      'calling_smart_contract',
-      updateResult
-    );
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
-      failed();
+  const signer = walletSigners.getSigner(txType!);
+  signer.signAndSendTx(tx!, walletAddress, null).then(
+    ({ hash, response }) => {
+      const explorerUrl = getScannerUrl(
+        hash,
+        currentStepBlockchain,
+        meta.blockchains
+      );
+      setStepTransactionIds(
+        actions,
+        hash,
+        notifier,
+        isApproval ? 'check_approve_tx_status' : 'check_tx_status',
+        explorerUrl
+          ? { url: explorerUrl, description: isApproval ? 'Approve' : 'Swap' }
+          : undefined
+      );
+      // response used for evm transactions to get receipt and track replaced
+      response && setTransactionResponseByHash(hash, response);
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      next();
       onFinish();
-    } else {
-      walletSigners
-        .getSigner(TransactionType.TRON)
-        .signAndSendTx(tronTransaction, walletAddress, null)
-        .then(
-          (id) => {
-            setStepTransactionIds(actions, id, notifier, 'check_tx_status');
-            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: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      nextStatus: nextStepStatusBasedOnHasAlreadyProceededToSign,
-      message: executeMessage,
-      details: executeDetails,
-      hasAlreadyProceededToSign,
-      errorCode: errorCodeBasedOnHasAlreadyProceededToSign,
-    });
-    const notification = getSwapNotitfication(
-      'calling_smart_contract',
-      updateResult
-    );
-    notifier(notification);
-
-    if (notification.eventType === 'transaction_expired') {
+    },
+    (error) => {
+      if (swap.status === 'failed') return;
+
+      const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
+        prettifyErrorMessage(error);
+
+      // if it is an rpc error with details, send the log to sentry
+      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,
+      });
+      const eventType =
+        extraMessageErrorCode === 'REJECTED_BY_USER'
+          ? 'contract_rejected'
+          : isSmartContractCall
+          ? 'smart_contract_call_failed'
+          : 'transfer_failed';
+      notifier({
+        eventType,
+        ...updateResult,
+      });
       failed();
       onFinish();
-    } else {
-      walletSigners
-        .getSigner(TransactionType.STARKNET)
-        .signAndSendTx(starknetTransaction, walletAddress, null)
-        .then(
-          (id) => {
-            setStepTransactionIds(actions, id, notifier, 'check_tx_status');
-            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();
-          }
-        );
     }
-  }
+  );
 }
 
 export function checkWaitingForConnectWalletChange(params: {