@rango-dev/queue-manager-rango-preset 0.23.0 → 0.24.0

package/src/actions/scheduleNextStep.ts

@@ -1,14 +1,16 @@
-import type { SwapQueueContext, SwapStorage } from '../types';
-import type { ExecuterActions } from '@rango-dev/queue-manager-core';
-import type { PendingSwapStep } from 'rango-types';
-
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import {
+  StepEventType,
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../types';
 import {
   getCurrentStep,
   getLastSuccessfulStep,
   isTxAlreadyCreated,
 } from '../helpers';
 import { notifier } from '../services/eventEmitter';
-import { StepEventType, SwapActionTypes } from '../types';
 
 /**
  *
@@ -28,9 +30,7 @@ export function scheduleNextStep({
 }: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>): void {
   const swap = getStorage().swapDetails;
   const currentStep = getCurrentStep(swap);
-  const isFailed = swap.steps.find(
-    (step: PendingSwapStep) => step.status === 'failed'
-  );
+  const isFailed = swap.steps.find((step) => step.status === 'failed');
 
   if (!!currentStep && !isFailed) {
     if (isTxAlreadyCreated(swap, currentStep)) {
@@ -84,10 +84,7 @@ export function scheduleNextStep({
       step: null,
     });
 
-    if (isFailed) {
-      failed();
-    } else {
-      next();
-    }
+    if (isFailed) failed();
+    else next();
   }
 }

package/src/helpers.ts

@@ -1,50 +1,37 @@
-/* eslint-disable destructuring/in-params */
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-/* eslint-disable @typescript-eslint/no-floating-promises */
-import type { SwapStatus, Wallet } from './shared';
-import type {
-  ArrayElement,
-  Step,
-  SwapQueueContext,
-  SwapQueueDef,
-  SwapStorage,
-} from './types';
-import type {
+import {
   ExecuterActions,
-  Manager,
   QueueInfo,
   QueueName,
   QueueType,
 } from '@rango-dev/queue-manager-core';
-import type {
+import {
+  ArrayElement,
+  BlockReason,
+  StepEventType,
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapQueueDef,
+  SwapStorage,
+  StepExecutionEventStatus,
+  StepExecutionBlockedEventStatus,
+  Step,
+} from './types';
+import {
+  getBlockChainNameFromId,
   Meta,
   Network,
-  Providers,
+  Networks,
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
-import type {
-  CreateTransactionResponse,
-  EvmBlockchainMeta,
-  Transaction,
-} from 'rango-sdk';
-import type {
-  APIErrorCode,
-  PendingSwap,
-  PendingSwapStep,
-  SignerErrorCode,
-  StepStatus,
-} from 'rango-types';
+import { Providers, readAccountAddress } from '@rango-dev/wallets-react';
 
-import { Status } from '@rango-dev/queue-manager-core';
-import { readAccountAddress } from '@rango-dev/wallets-core';
 import {
-  getBlockChainNameFromId,
-  getEvmProvider,
-  splitWalletNetwork,
-} from '@rango-dev/wallets-shared';
-import { TransactionType } from 'rango-sdk';
-import { PendingSwapNetworkStatus } from 'rango-types';
+  Transaction,
+  TransactionType,
+  EvmBlockchainMeta,
+  CreateTransactionResponse,
+} from 'rango-sdk';
 
 import {
   DEFAULT_ERROR_CODE,
@@ -52,30 +39,32 @@ import {
   ERROR_MESSAGE_WAIT_FOR_WALLET,
   ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION,
 } from './constants';
-import { httpService } from './services';
-import { notifier } from './services/eventEmitter';
+import { Manager } from '@rango-dev/queue-manager-core';
+import { Status } from '@rango-dev/queue-manager-core';
 import {
-  getCurrentAddressOf,
   getCurrentBlockchainOf,
   getCurrentBlockchainOfOrNull,
-  getRelatedWallet,
-  getRelatedWalletOrNull,
   getScannerUrl,
+  getRelatedWalletOrNull,
   MessageSeverity,
+  PendingSwap,
+  PendingSwapNetworkStatus,
+  PendingSwapStep,
+  StepStatus,
+  SwapStatus,
+  Wallet,
+  getRelatedWallet,
+  getCurrentAddressOf,
 } from './shared';
+import { logRPCError } from './shared-sentry';
 import {
+  PrettyError,
   mapAppErrorCodesToAPIErrorCode,
   prettifyErrorMessage,
-  PrettyError,
 } from './shared-errors';
-import { logRPCError } from './shared-sentry';
-import {
-  BlockReason,
-  StepEventType,
-  StepExecutionBlockedEventStatus,
-  StepExecutionEventStatus,
-  SwapActionTypes,
-} from './types';
+import { httpService } from './services';
+import { APIErrorCode, SignerErrorCode } from 'rango-types/lib';
+import { notifier } from './services/eventEmitter';
 
 type WhenTaskBlocked = Parameters<NonNullable<SwapQueueDef['whenTaskBlocked']>>;
 type WhenTaskBlockedEvent = WhenTaskBlocked[0];
@@ -119,9 +108,7 @@ export function inMemoryTransactionsData() {
       swapTransactionToDataMap[hash] || {},
     setTransactionDataByHash: (hash: string, data: TransactionData) => {
       const r = swapTransactionToDataMap[hash];
-      if (!r) {
-        swapTransactionToDataMap[hash] = {};
-      }
+      if (!r) swapTransactionToDataMap[hash] = {};
       swapTransactionToDataMap[hash].response =
         data.response || swapTransactionToDataMap[hash].response;
       swapTransactionToDataMap[hash].receiptReceived =
@@ -132,6 +119,29 @@ export function inMemoryTransactionsData() {
   };
 }
 
+/**
+ * Sample inputs are:
+ *  - "metamask-ETH"
+ *  - "metamask-BSC-BSC:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ *  - "token-pocket-BSC-BSC:0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ * Returns "wallet and network" separately, even if the wallet is dashed inside.
+ *
+ */
+
+export function splitWalletNetwork(input: string): string[] {
+  const removedAddressInput = input?.split(':')[0] || '';
+  const splittedInput = removedAddressInput.split('-');
+  const network = splittedInput[splittedInput.length - 1];
+  const walletNetwork = splittedInput.slice(0, -1);
+
+  if (walletNetwork[walletNetwork.length - 1] === network) {
+    walletNetwork.pop();
+  }
+  const wallet = walletNetwork.join('-');
+
+  return [wallet, network];
+}
+
 /**
  *
  * Returns `steps`, if it's a `running` swap.
@@ -203,25 +213,19 @@ export const setCurrentStepTx = (
   const txType = transaction.type;
   switch (txType) {
     case TransactionType.EVM:
-      if (transaction.isApprovalTx) {
+      if (transaction.isApprovalTx)
         currentStep.evmApprovalTransaction = transaction;
-      } else {
-        currentStep.evmTransaction = transaction;
-      }
+      else currentStep.evmTransaction = transaction;
       break;
     case TransactionType.TRON:
-      if (transaction.isApprovalTx) {
+      if (transaction.isApprovalTx)
         currentStep.tronApprovalTransaction = transaction;
-      } else {
-        currentStep.tronTransaction = transaction;
-      }
+      else currentStep.tronTransaction = transaction;
       break;
     case TransactionType.STARKNET:
-      if (transaction.isApprovalTx) {
+      if (transaction.isApprovalTx)
         currentStep.starknetApprovalTransaction = transaction;
-      } else {
-        currentStep.starknetTransaction = transaction;
-      }
+      else currentStep.starknetTransaction = transaction;
       break;
     case TransactionType.COSMOS:
       currentStep.cosmosTransaction = transaction;
@@ -319,17 +323,12 @@ export function updateSwapStatus({
     swap,
     step: currentStep,
   };
-  if (!!nextStepStatus && !!currentStep) {
-    currentStep.status = nextStepStatus;
-  }
+  if (!!nextStepStatus && !!currentStep) currentStep.status = nextStepStatus;
 
-  if (nextStatus) {
-    swap.status = nextStatus;
-  }
+  if (nextStatus) swap.status = nextStatus;
   swap.hasAlreadyProceededToSign = hasAlreadyProceededToSign;
-  if (!!nextStatus && ['failed', 'success'].includes(nextStatus)) {
+  if (!!nextStatus && ['failed', 'success'].includes(nextStatus))
     swap.finishTime = new Date().getTime().toString();
-  }
 
   if (!!message || !!details) {
     swap.extraMessage = message || '';
@@ -342,7 +341,7 @@ export function updateSwapStatus({
       details && details.includes('Warning')
         ? 'Swap canceled by user.'
         : details;
-    const walletType = getRelatedWalletOrNull(swap, currentStep)?.walletType;
+    const walletType = getRelatedWalletOrNull(swap, currentStep!)?.walletType;
     swap.extraMessageSeverity = MessageSeverity.error;
 
     const failureType = mapAppErrorCodesToAPIErrorCode(errorCode);
@@ -362,23 +361,15 @@ export function updateSwapStatus({
       })
       .then()
       .catch();
-  } else if (!!nextStepStatus && ['running'].includes(nextStepStatus)) {
+  } else if (!!nextStepStatus && ['running'].includes(nextStepStatus))
     swap.extraMessageSeverity = MessageSeverity.info;
-  } else if (
-    !!nextStepStatus &&
-    ['success', 'approved'].includes(nextStepStatus)
-  ) {
+  else if (!!nextStepStatus && ['success', 'approved'].includes(nextStepStatus))
     swap.extraMessageSeverity = MessageSeverity.success;
-  } else if (
-    nextStepStatus &&
-    ['waitingForApproval'].includes(nextStepStatus)
-  ) {
+  else if (nextStepStatus && ['waitingForApproval'].includes(nextStepStatus))
     swap.extraMessageSeverity = MessageSeverity.warning;
-  }
 
-  if (nextStepStatus === 'running' && currentStep) {
+  if (nextStepStatus === 'running' && currentStep)
     currentStep.startTransactionTime = new Date().getTime();
-  }
 
   setStorage({
     ...getStorage(),
@@ -404,7 +395,7 @@ export function setStepTransactionIds(
   const currentStep = getCurrentStep(swap)!;
   currentStep.executedTransactionId = txId;
   currentStep.executedTransactionTime = new Date().getTime().toString();
-  if (explorerUrl?.url) {
+  if (explorerUrl?.url)
     currentStep.explorerUrl = [
       ...(currentStep.explorerUrl || []),
       {
@@ -412,15 +403,11 @@ export function setStepTransactionIds(
         description: explorerUrl.description || null,
       },
     ];
-  }
 
   const isApproval = isApprovalCurrentStepTx(currentStep);
 
-  if (isApproval) {
-    swap.extraMessage = 'Checking approve transaction status ...';
-  } else {
-    swap.extraMessage = 'Checking transaction status ...';
-  }
+  if (isApproval) swap.extraMessage = 'Checking approve transaction status ...';
+  else swap.extraMessage = 'Checking transaction status ...';
 
   swap.extraMessageDetail = '';
   swap.extraMessageSeverity = MessageSeverity.info;
@@ -460,9 +447,7 @@ export function markRunningSwapAsWaitingForConnectingWallet(
 ): void {
   const swap = getStorage().swapDetails as SwapStorage['swapDetails'];
   const currentStep = getCurrentStep(swap);
-  if (!currentStep) {
-    return;
-  }
+  if (!currentStep) return;
   const currentTime = new Date();
   swap.lastNotificationTime = currentTime.getTime().toString();
 
@@ -503,9 +488,7 @@ export function markRunningSwapAsSwitchingNetwork({
   const swap = getStorage().swapDetails as SwapStorage['swapDetails'];
 
   const currentStep = getCurrentStep(swap);
-  if (!currentStep) {
-    return;
-  }
+  if (!currentStep) return;
 
   // Generate message
   const { type } = getRequiredWallet(swap);
@@ -546,9 +529,7 @@ export function markRunningSwapAsDependsOnOtherQueues({
   | undefined {
   const swap = getStorage().swapDetails as SwapStorage['swapDetails'];
   const currentStep = getCurrentStep(swap);
-  if (!currentStep) {
-    return;
-  }
+  if (!currentStep) return;
 
   swap.networkStatusExtraMessage = '';
   swap.networkStatusExtraMessageDetail = '';
@@ -574,7 +555,7 @@ export function markRunningSwapAsDependsOnOtherQueues({
   };
 }
 
-export async function delay(ms: number): Promise<unknown> {
+export function delay(ms: number): Promise<unknown> {
   return new Promise((res) => setTimeout(res, ms));
 }
 
@@ -605,6 +586,23 @@ export function isWalletNull(wallet: Wallet | null): boolean {
   );
 }
 
+/**
+ * On our implementation for `wallets` package, We keep the instance in 2 ways
+ * If it's a single chain wallet, it returns the instance directly,
+ * If it's a multichain wallet, it returns a `Map` of instances.
+ * This function will get the `ETHEREUM` instance in both types.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getEvmProvider(providers: Providers, type: WalletType): any {
+  if (type && providers[type]) {
+    // we need this because provider can return an instance or a map of instances, so what you are doing here is try to detect that.
+    if (providers[type].size) return providers[type].get(Networks.ETHEREUM);
+
+    return providers[type];
+  }
+  return null;
+}
+
 /**
  * In a `PendingSwap`, each step needs a wallet to proceed,
  * By using this function we can access what wallet exactly we need to run current step.
@@ -665,9 +663,7 @@ export async function isNetworkMatchedForTransaction(
     return false;
   }
   const fromBlockChain = getCurrentBlockchainOfOrNull(swap, step);
-  if (!fromBlockChain) {
-    return false;
-  }
+  if (!fromBlockChain) return false;
 
   if (
     meta.evmBasedChains.find(
@@ -689,15 +685,13 @@ export async function isNetworkMatchedForTransaction(
           if (
             blockChain &&
             blockChain.toLowerCase() === fromBlockChain.toLowerCase()
-          ) {
+          )
             return true;
-          }
           if (
             blockChain &&
             blockChain.toLowerCase() !== fromBlockChain.toLowerCase()
-          ) {
+          )
             return false;
-          }
         }
       }
     } catch (e) {
@@ -837,9 +831,7 @@ export function onBlockForChangeNetwork(
   const swap = queue.getStorage().swapDetails as SwapStorage['swapDetails'];
   const currentStep = getCurrentStep(swap);
 
-  if (!currentStep || swap.status !== 'running') {
-    return;
-  }
+  if (!currentStep || swap.status !== 'running') return;
 
   const result = markRunningSwapAsSwitchingNetwork({
     getStorage: queue.getStorage.bind(queue),
@@ -912,9 +904,7 @@ export function onDependsOnOtherQueues(
   const claimerId = claimedBy();
   const isClaimedByAnyQueue = !!claimerId;
 
-  if (claimerId === queue.id) {
-    return;
-  }
+  if (claimerId === queue.id) return;
 
   // Check if any queue `claimed` before, if yes, we don't should do anything.
   if (isClaimedByAnyQueue) {
@@ -970,9 +960,7 @@ export function isRequiredWalletConnected(
   const walletState = getState(type);
   const { accounts, connected } = walletState;
   const connectedAccounts = accounts || [];
-  if (!connected) {
-    return { ok: false, reason: 'not_connected' };
-  }
+  if (!connected) return { ok: false, reason: 'not_connected' };
 
   const matched = connectedAccounts.some((account) => {
     const { address: accountAddress } = readAccountAddress(account);
@@ -981,7 +969,7 @@ export function isRequiredWalletConnected(
   return { ok: matched, reason: 'account_miss_match' };
 }
 
-export function signTransaction(
+export function singTransaction(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
 ): void {
   const { setTransactionDataByHash } = inMemoryTransactionsData();
@@ -1087,12 +1075,11 @@ export function signTransaction(
       },
       ...updateResult,
     });
-  } else {
+  } else
     notifier({
       event: { type: eventType, status: StepExecutionEventStatus.SEND_TX },
       ...updateResult,
     });
-  }
 
   if (hasAlreadyProceededToSign) {
     failed();
@@ -1122,9 +1109,7 @@ export function signTransaction(
       onFinish();
     },
     (error) => {
-      if (swap.status === 'failed') {
-        return;
-      }
+      if (swap.status === 'failed') return;
 
       const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
         prettifyErrorMessage(error);
@@ -1168,9 +1153,7 @@ export function checkWaitingForConnectWalletChange(params: {
   const { wallet_network, evmChains, manager } = params;
   const [wallet, network] = splitWalletNetwork(wallet_network);
   // We only need change network for EVM chains.
-  if (!evmChains.some((chain) => chain.name == network)) {
-    return;
-  }
+  if (!evmChains.some((chain) => chain.name == network)) return;
 
   manager?.getAll().forEach((q) => {
     const queueStorage = q.list.getStorage() as SwapStorage | undefined;
@@ -1284,9 +1267,7 @@ export function getRunningSwaps(manager: Manager): PendingSwap[] {
     // retry only on affected queues
     const queueStorage = q.list.getStorage() as SwapStorage | undefined;
     const swap = queueStorage?.swapDetails;
-    if (!swap || swap.status !== 'running') {
-      return;
-    }
+    if (!swap || swap.status !== 'running') return;
     result.push(swap);
   });
   return result;
@@ -1309,11 +1290,9 @@ export function resetRunningSwapNotifsOnPageLoad(runningSwaps: PendingSwap[]) {
       | StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE
       | StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT
       | undefined;
-    if (
-      currentStep?.networkStatus === PendingSwapNetworkStatus.WaitingForQueue
-    ) {
+    if (currentStep?.networkStatus === PendingSwapNetworkStatus.WaitingForQueue)
       eventSubtype = StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE;
-    } else if (swap?.status === 'running') {
+    else if (swap?.status === 'running') {
       eventSubtype = StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT;
     }
     if (!!eventType && !!notifier) {
@@ -1398,25 +1377,22 @@ export function retryOn(
     finalQueueToBeRun = onlyWalletMatched[0];
   }
 
-  if (!canSwitchNetworkTo?.(wallet, network)) {
-    finalQueueToBeRun?.unblock();
-  } else {
-    finalQueueToBeRun?.checkBlock();
-  }
+  if (!canSwitchNetworkTo?.(wallet, network)) finalQueueToBeRun?.unblock();
+  else finalQueueToBeRun?.checkBlock();
 }
 
-/*
- *For avoiding conflict by making too many requests to wallet, we need to make sure
- *We only run one request at a time (In parallel mode).
- */
+/* 
+  For avoiding conflict by making too many requests to wallet, we need to make sure
+  We only run one request at a time (In parallel mode).
+  */
 export function isNeedBlockQueueForParallel(step: PendingSwapStep): boolean {
   return !!step.evmTransaction || !!step.evmApprovalTransaction;
 }
 
 /*
- *Create transaction endpoint doesn't return error code on http status code,
- *For backward compatibilty with server and sdk, we use this wrapper to reject the promise.
- */
+Create transaction endpoint doesn't return error code on http status code,
+For backward compatibilty with server and sdk, we use this wrapper to reject the promise.
+*/
 export async function throwOnOK(
   rawResponse: Promise<CreateTransactionResponse>
 ): Promise<CreateTransactionResponse> {
@@ -1462,9 +1438,7 @@ export function cancelSwap(
   });
 
   reset();
-  if (manager) {
-    manager?.retry();
-  }
+  if (manager) manager?.retry();
 
   return updateResult;
 }

package/src/index.ts

@@ -33,21 +33,29 @@ export {
   StepExecutionEventStatus,
   StepExecutionBlockedEventStatus,
 } from './types';
-export type { PendingSwapWithQueueID, EventType } from './shared';
+export type {
+  PendingSwapWithQueueID,
+  PendingSwapStep,
+  PendingSwap,
+  EventType,
+} from './shared';
 export {
   getCurrentBlockchainOfOrNull,
   getRelatedWalletOrNull,
   getRelatedWallet,
   MessageSeverity,
+  PendingSwapNetworkStatus,
   calculatePendingSwap,
 } from './shared';
 export {
   updateSwapStatus,
   checkWaitingForNetworkChange,
   getCurrentStep,
+  getEvmProvider,
   cancelSwap,
   getRequiredWallet,
   getRunningSwaps,
+  splitWalletNetwork,
   resetRunningSwapNotifsOnPageLoad,
   isApprovalTX,
   getLastSuccessfulStep,

package/src/migration.ts

@@ -1,9 +1,11 @@
-import type { PersistedQueue } from '@rango-dev/queue-manager-core';
-import type { PendingSwap } from 'rango-types';
-
-import { DB_NAME, Persistor, Status } from '@rango-dev/queue-manager-core';
+import {
+  PersistedQueue,
+  Persistor,
+  Status,
+  DB_NAME,
+} from '@rango-dev/queue-manager-core';
 import { v4 as uuid } from 'uuid';
-
+import { PendingSwap } from './shared';
 import { SwapActionTypes } from './types';
 
 const MIGRATED_KEY = 'migratedToQueueManager';
@@ -47,9 +49,9 @@ async function migration(): Promise<boolean> {
   const convertedSwaps: PersistedQueue[] = [];
 
   swaps.forEach((swap) => {
-    /*
-     *For running task we need to add some more work
-     *We need to create a queue task to be run and resume the running task from queue manager.
+    /* 
+      For running task we need to add some more work
+      We need to create a queue task to be run and resume the running task from queue manager.
      */
     if (swap.status === 'running') {
       const taskId = uuid();
@@ -110,9 +112,7 @@ async function migration(): Promise<boolean> {
   // Getting an instance from persistor, so we can directly put our data inside it.
   const persistor = new Persistor();
 
-  const promises = convertedSwaps.map(async (queue) =>
-    persistor.insertQueue(queue)
-  );
+  const promises = convertedSwaps.map((queue) => persistor.insertQueue(queue));
   await Promise.all(promises);
 
   // Mark as the data has been successfully migrated.