@rango-dev/queue-manager-rango-preset 0.24.0 → 0.24.1-next.0

package/src/actions/scheduleNextStep.ts

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

package/src/helpers.ts

@@ -1,37 +1,50 @@
-import {
-  ExecuterActions,
-  QueueInfo,
-  QueueName,
-  QueueType,
-} from '@rango-dev/queue-manager-core';
-import {
+/* 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,
-  BlockReason,
-  StepEventType,
-  SwapActionTypes,
+  Step,
   SwapQueueContext,
   SwapQueueDef,
   SwapStorage,
-  StepExecutionEventStatus,
-  StepExecutionBlockedEventStatus,
-  Step,
 } from './types';
-import {
-  getBlockChainNameFromId,
+import type {
+  ExecuterActions,
+  Manager,
+  QueueInfo,
+  QueueName,
+  QueueType,
+} from '@rango-dev/queue-manager-core';
+import type {
   Meta,
   Network,
-  Networks,
+  Providers,
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
-import { Providers, readAccountAddress } from '@rango-dev/wallets-react';
-
-import {
-  Transaction,
-  TransactionType,
-  EvmBlockchainMeta,
+import type {
   CreateTransactionResponse,
+  EvmBlockchainMeta,
+  Transaction,
 } from 'rango-sdk';
+import type {
+  APIErrorCode,
+  PendingSwap,
+  PendingSwapStep,
+  SignerErrorCode,
+  StepStatus,
+} from 'rango-types';
+
+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';
 
 import {
   DEFAULT_ERROR_CODE,
@@ -39,32 +52,30 @@ import {
   ERROR_MESSAGE_WAIT_FOR_WALLET,
   ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION,
 } from './constants';
-import { Manager } from '@rango-dev/queue-manager-core';
-import { Status } from '@rango-dev/queue-manager-core';
+import { httpService } from './services';
+import { notifier } from './services/eventEmitter';
 import {
+  getCurrentAddressOf,
   getCurrentBlockchainOf,
   getCurrentBlockchainOfOrNull,
-  getScannerUrl,
+  getRelatedWallet,
   getRelatedWalletOrNull,
+  getScannerUrl,
   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 { httpService } from './services';
-import { APIErrorCode, SignerErrorCode } from 'rango-types/lib';
-import { notifier } from './services/eventEmitter';
+import { logRPCError } from './shared-sentry';
+import {
+  BlockReason,
+  StepEventType,
+  StepExecutionBlockedEventStatus,
+  StepExecutionEventStatus,
+  SwapActionTypes,
+} from './types';
 
 type WhenTaskBlocked = Parameters<NonNullable<SwapQueueDef['whenTaskBlocked']>>;
 type WhenTaskBlockedEvent = WhenTaskBlocked[0];
@@ -108,7 +119,9 @@ 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 =
@@ -119,29 +132,6 @@ 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.
@@ -213,19 +203,25 @@ 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;
@@ -323,12 +319,17 @@ 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 || '';
@@ -341,7 +342,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);
@@ -361,15 +362,23 @@ 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(),
@@ -395,7 +404,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 || []),
       {
@@ -403,11 +412,15 @@ 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;
@@ -447,7 +460,9 @@ 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();
 
@@ -488,7 +503,9 @@ 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);
@@ -529,7 +546,9 @@ 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 = '';
@@ -555,7 +574,7 @@ export function markRunningSwapAsDependsOnOtherQueues({
   };
 }
 
-export function delay(ms: number): Promise<unknown> {
+export async function delay(ms: number): Promise<unknown> {
   return new Promise((res) => setTimeout(res, ms));
 }
 
@@ -586,23 +605,6 @@ 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.
@@ -663,7 +665,9 @@ export async function isNetworkMatchedForTransaction(
     return false;
   }
   const fromBlockChain = getCurrentBlockchainOfOrNull(swap, step);
-  if (!fromBlockChain) return false;
+  if (!fromBlockChain) {
+    return false;
+  }
 
   if (
     meta.evmBasedChains.find(
@@ -685,13 +689,15 @@ export async function isNetworkMatchedForTransaction(
           if (
             blockChain &&
             blockChain.toLowerCase() === fromBlockChain.toLowerCase()
-          )
+          ) {
             return true;
+          }
           if (
             blockChain &&
             blockChain.toLowerCase() !== fromBlockChain.toLowerCase()
-          )
+          ) {
             return false;
+          }
         }
       }
     } catch (e) {
@@ -831,7 +837,9 @@ 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),
@@ -904,7 +912,9 @@ 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) {
@@ -960,7 +970,9 @@ 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);
@@ -969,7 +981,7 @@ export function isRequiredWalletConnected(
   return { ok: matched, reason: 'account_miss_match' };
 }
 
-export function singTransaction(
+export function signTransaction(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
 ): void {
   const { setTransactionDataByHash } = inMemoryTransactionsData();
@@ -1075,11 +1087,12 @@ export function singTransaction(
       },
       ...updateResult,
     });
-  } else
+  } else {
     notifier({
       event: { type: eventType, status: StepExecutionEventStatus.SEND_TX },
       ...updateResult,
     });
+  }
 
   if (hasAlreadyProceededToSign) {
     failed();
@@ -1109,7 +1122,9 @@ export function singTransaction(
       onFinish();
     },
     (error) => {
-      if (swap.status === 'failed') return;
+      if (swap.status === 'failed') {
+        return;
+      }
 
       const { extraMessage, extraMessageDetail, extraMessageErrorCode } =
         prettifyErrorMessage(error);
@@ -1153,7 +1168,9 @@ 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;
@@ -1267,7 +1284,9 @@ 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;
@@ -1290,9 +1309,11 @@ 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) {
@@ -1377,22 +1398,25 @@ 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> {
@@ -1438,7 +1462,9 @@ export function cancelSwap(
   });
 
   reset();
-  if (manager) manager?.retry();
+  if (manager) {
+    manager?.retry();
+  }
 
   return updateResult;
 }

package/src/index.ts

@@ -33,29 +33,21 @@ export {
   StepExecutionEventStatus,
   StepExecutionBlockedEventStatus,
 } from './types';
-export type {
-  PendingSwapWithQueueID,
-  PendingSwapStep,
-  PendingSwap,
-  EventType,
-} from './shared';
+export type { PendingSwapWithQueueID, 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,11 +1,9 @@
-import {
-  PersistedQueue,
-  Persistor,
-  Status,
-  DB_NAME,
-} from '@rango-dev/queue-manager-core';
+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 { v4 as uuid } from 'uuid';
-import { PendingSwap } from './shared';
+
 import { SwapActionTypes } from './types';
 
 const MIGRATED_KEY = 'migratedToQueueManager';
@@ -49,9 +47,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();
@@ -112,7 +110,9 @@ 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((queue) => persistor.insertQueue(queue));
+  const promises = convertedSwaps.map(async (queue) =>
+    persistor.insertQueue(queue)
+  );
   await Promise.all(promises);
 
   // Mark as the data has been successfully migrated.