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

package/src/services/eventEmitter.ts

@@ -1,26 +1,30 @@
-import mitt from 'mitt';
-import {
-  MainEvents,
+import type {
   RemoveNameField,
   Route,
   RouteEvent,
-  RouteEventType,
   RouteExecutionEvents,
-  EventSeverity,
   Step,
   StepEvent,
-  StepEventType,
-  StepExecutionEventStatus,
-  StepExecutionBlockedEventStatus,
 } from '../types';
-import { PendingSwap, PendingSwapStep } from 'rango-types/lib';
-import { getCurrentBlockchainOfOrNull } from '../shared';
+import type { PendingSwap, PendingSwapStep } from 'rango-types';
+
+import mitt from 'mitt';
+
 import {
   getCurrentStepTx,
   getFailedStep,
   getLastSuccessfulStep,
   isApprovalCurrentStepTx,
 } from '../helpers';
+import { getCurrentBlockchainOfOrNull } from '../shared';
+import {
+  EventSeverity,
+  MainEvents,
+  RouteEventType,
+  StepEventType,
+  StepExecutionBlockedEventStatus,
+  StepExecutionEventStatus,
+} from '../types';
 
 type NotifierParams = {
   swap: PendingSwap;
@@ -119,14 +123,19 @@ function getEventPayload(
     route,
     step: routeSteps[routeSteps.length - 1],
   };
-  if (swapStep) result.step = createSteps([swapStep])[0];
-  else {
+  if (swapStep) {
+    result.step = createSteps([swapStep])[0];
+  } else {
     if (type === 'failed') {
       const failedStep = getFailedStep(routeSteps);
-      if (failedStep) result.step = failedStep;
+      if (failedStep) {
+        result.step = failedStep;
+      }
     } else {
       const lastSuccessfulStep = getLastSuccessfulStep(routeSteps);
-      if (lastSuccessfulStep) result.step = lastSuccessfulStep;
+      if (lastSuccessfulStep) {
+        result.step = lastSuccessfulStep;
+      }
     }
   }
 
@@ -151,8 +160,9 @@ function emitRouteEvent(stepEvent: StepEvent, route: Route) {
     default:
       break;
   }
-  if (routeEvent)
+  if (routeEvent) {
     eventEmitter.emit(MainEvents.RouteEvent, { event: routeEvent, route });
+  }
 }
 
 function emitStepEvent(stepEvent: StepEvent, route: Route, step: Step) {
@@ -196,9 +206,11 @@ export function notifier(params: NotifierParams) {
         message = 'Please wait while the transaction is created ...';
         messageSeverity = EventSeverity.INFO;
       } else if (event.status === StepExecutionEventStatus.SEND_TX) {
-        if (params.step && isApprovalCurrentStepTx(params.step))
+        if (params.step && isApprovalCurrentStepTx(params.step)) {
           message = `Please confirm '${step.swapperName}' smart contract access to ${fromAsset}`;
-        else message = 'Please confirm transaction request in your wallet';
+        } else {
+          message = 'Please confirm transaction request in your wallet';
+        }
         messageSeverity = EventSeverity.WARNING;
       } else if (event.status === StepExecutionEventStatus.TX_SENT) {
         message = 'Transaction sent successfully';
@@ -206,9 +218,11 @@ export function notifier(params: NotifierParams) {
       }
       break;
     case StepEventType.CHECK_STATUS:
-      if (params.step && isApprovalCurrentStepTx(params.step))
-        message = 'Checking approve transacation status ...';
-      else message = 'Checking transacation status ...';
+      if (params.step && isApprovalCurrentStepTx(params.step)) {
+        message = 'Checking approve transaction status ...';
+      } else {
+        message = 'Checking transaction status ...';
+      }
       messageSeverity = EventSeverity.INFO;
       break;
     case StepEventType.APPROVAL_TX_SUCCEEDED:
@@ -251,7 +265,10 @@ export function notifier(params: NotifierParams) {
       break;
   }
 
-  if (params.step)
+  if (params.step) {
     emitStepEvent({ ...event, message, messageSeverity }, route, step);
-  else emitRouteEvent({ ...event, message, messageSeverity }, route);
+  }
+  if (params.event.type === StepEventType.FAILED || !params.step) {
+    emitRouteEvent({ ...event, message, messageSeverity }, route);
+  }
 }

package/src/shared-sentry.ts

@@ -1,6 +1,7 @@
+import type { WalletType } from '@rango-dev/wallets-shared';
+import type { PendingSwap, PendingSwapStep } from 'rango-types';
+
 import * as Sentry from '@sentry/browser';
-import { PendingSwap, PendingSwapStep } from './shared';
-import { WalletType } from '@rango-dev/wallets-shared';
 
 export function logRPCError(
   error: unknown,

package/src/shared.ts

@@ -1,31 +1,30 @@
-import { Network, WalletType } from '@rango-dev/wallets-shared';
-import {
-  CosmosTransaction,
-  EvmTransaction,
-  SimulationResult,
-  SolanaTransaction,
-  StarknetTransaction,
-  TronTransaction,
-  Transfer as TransferTransaction,
-  AmountRestrictionType,
+import type { Network, WalletType } from '@rango-dev/wallets-shared';
+import type {
   BestRouteResponse,
+  BlockchainMeta,
   MetaResponse,
-  Token,
   SwapResult,
-  BlockchainMeta,
+  Token,
 } from 'rango-sdk';
+import type {
+  PendingSwap,
+  PendingSwapStep,
+  SwapSavedSettings,
+  SwapStepRoute,
+  WalletTypeAndAddress,
+} from 'rango-types';
 
-import { PrettyError } from './shared-errors';
 import BigNumber from 'bignumber.js';
-import { numberToString } from './numbers';
 import {
-  TonTransaction,
   isCosmosBlockchain,
   isEvmBlockchain,
   isStarknetBlockchain,
   isTronBlockchain,
 } from 'rango-types';
 
+import { numberToString } from './numbers';
+import { PrettyError } from './shared-errors';
+
 export interface PendingSwapWithQueueID {
   id: string;
   swap: PendingSwap;
@@ -85,105 +84,6 @@ export type EventType =
   | 'route_failed_to_find'
   | 'transaction_expired';
 
-export type SwapSavedSettings = {
-  slippage: string;
-  disabledSwappersIds?: string[];
-  disabledSwappersGroups?: string[];
-  infiniteApprove?: boolean;
-};
-
-type InternalStepState =
-  | 'PENDING'
-  | 'CREATED'
-  | 'WAITING'
-  | 'SIGNED'
-  | 'SUCCESSED'
-  | 'FAILED';
-
-export type SwapperStatusStep = {
-  name: string;
-  state: InternalStepState;
-  current: boolean;
-};
-
-export enum PendingSwapNetworkStatus {
-  WaitingForConnectingWallet = 'waitingForConnectingWallet',
-  WaitingForQueue = 'waitingForQueue',
-  WaitingForNetworkChange = 'waitingForNetworkChange',
-  NetworkChanged = 'networkChanged',
-}
-
-export type SwapExplorerUrl = {
-  url: string;
-  description: string | null;
-};
-
-export type StepStatus =
-  | 'created'
-  | 'running'
-  | 'failed'
-  | 'success'
-  | 'waitingForApproval'
-  | 'approved';
-
-export type PendingSwapStep = {
-  // routing data
-  id: number;
-  fromBlockchain: string;
-  fromSymbol: string;
-  fromSymbolAddress: string | null;
-  fromDecimals: number;
-  fromAmountPrecision: string | null;
-  fromAmountMinValue: string | null;
-  fromAmountMaxValue: string | null;
-  fromAmountRestrictionType: AmountRestrictionType | null;
-  fromLogo: string;
-  toBlockchain: string;
-  toSymbol: string;
-  toSymbolAddress: string | null;
-  toDecimals: number;
-  toLogo: string;
-  swapperId: string;
-  expectedOutputAmountHumanReadable: string | null;
-  startTransactionTime: number;
-  internalSteps: SwapperStatusStep[] | null;
-  estimatedTimeInSeconds: number | null;
-
-  // status data
-  status: StepStatus;
-  networkStatus: PendingSwapNetworkStatus | null;
-  executedTransactionId: string | null;
-  executedTransactionTime: string | null;
-  explorerUrl: SwapExplorerUrl[] | null;
-  diagnosisUrl: string | null;
-  outputAmount: string | null;
-
-  // txs data
-  cosmosTransaction: CosmosTransaction | null;
-  transferTransaction: TransferTransaction | null;
-  solanaTransaction: SolanaTransaction | null;
-  evmApprovalTransaction: EvmTransaction | null;
-  evmTransaction: EvmTransaction | null;
-  tronApprovalTransaction: TronTransaction | null;
-  tronTransaction: TronTransaction | null;
-  starknetApprovalTransaction: StarknetTransaction | null;
-  starknetTransaction: StarknetTransaction | null;
-  tonTransaction: TonTransaction | null;
-
-  // missing fields in older versions
-  // keeping null for backward compatability
-  swapperLogo: string | null;
-  swapperType: string | null;
-  fromBlockchainLogo: string | null;
-  toBlockchainLogo: string | null;
-  feeInUsd: string | null;
-};
-
-export type WalletTypeAndAddress = {
-  walletType: WalletType;
-  address: string;
-};
-
 export enum MessageSeverity {
   error = 'error',
   warning = 'warning',
@@ -193,28 +93,6 @@ export enum MessageSeverity {
 
 export type SwapStatus = 'running' | 'failed' | 'success';
 
-export type PendingSwap = {
-  creationTime: string;
-  finishTime: string | null;
-  requestId: string;
-  inputAmount: string;
-  status: SwapStatus;
-  isPaused: boolean;
-  extraMessage: string | null;
-  extraMessageSeverity: MessageSeverity | null;
-  extraMessageErrorCode: string | null;
-  extraMessageDetail: string | null | undefined;
-  networkStatusExtraMessage: string | null;
-  networkStatusExtraMessageDetail: string | null;
-  lastNotificationTime: string | null;
-  wallets: { [p: string]: WalletTypeAndAddress };
-  settings: SwapSavedSettings;
-  steps: PendingSwapStep[];
-  simulationResult: SimulationResult;
-  validateBalanceOrFee: boolean;
-  hasAlreadyProceededToSign?: boolean | null;
-};
-
 export const getCurrentBlockchainOfOrNull = (
   swap: PendingSwap,
   step: PendingSwapStep
@@ -240,16 +118,22 @@ export const getCurrentBlockchainOf = (
     step.cosmosTransaction?.blockChain ||
     step.solanaTransaction?.blockChain ||
     step.tonTransaction?.blockChain;
-  if (b1) return b1;
+  if (b1) {
+    return b1;
+  }
 
   const transferAddress = step.transferTransaction?.fromWalletAddress;
-  if (!transferAddress) throw PrettyError.BlockchainMissing();
+  if (!transferAddress) {
+    throw PrettyError.BlockchainMissing();
+  }
 
   const blockchain =
     Object.keys(swap.wallets).find(
       (b) => swap.wallets[b]?.address === transferAddress
     ) || null;
-  if (blockchain == null) throw PrettyError.BlockchainMissing();
+  if (blockchain == null) {
+    throw PrettyError.BlockchainMissing();
+  }
 
   return blockchain;
 };
@@ -257,14 +141,15 @@ export const getCurrentBlockchainOf = (
 const getBlockchainMetaExplorerBaseUrl = (
   blockchainMeta: BlockchainMeta
 ): string | undefined => {
-  if (isCosmosBlockchain(blockchainMeta))
+  if (isCosmosBlockchain(blockchainMeta)) {
     return blockchainMeta.info?.explorerUrlToTx;
-  else if (
+  } else if (
     isEvmBlockchain(blockchainMeta) ||
     isStarknetBlockchain(blockchainMeta) ||
     isTronBlockchain(blockchainMeta)
-  )
+  ) {
     return blockchainMeta.info.transactionUrl;
+  }
   return;
 };
 
@@ -275,9 +160,12 @@ export const getScannerUrl = (
 ): string | undefined => {
   const blockchainMeta = blockchainMetaMap[network];
   const baseUrl = getBlockchainMetaExplorerBaseUrl(blockchainMeta);
-  if (!baseUrl) return;
-  if (baseUrl.indexOf('/{txHash}') !== -1)
+  if (!baseUrl) {
+    return;
+  }
+  if (baseUrl.indexOf('/{txHash}') !== -1) {
     return baseUrl.replace('{txHash}', txHash?.toLowerCase());
+  }
   return `${baseUrl}/${txHash?.toLowerCase()}`;
 };
 
@@ -316,7 +204,9 @@ export const getCurrentAddressOf = (
       ? { address: step.transferTransaction?.fromWalletAddress }
       : null) ||
     null;
-  if (result == null) throw PrettyError.WalletMissing();
+  if (result == null) {
+    throw PrettyError.WalletMissing();
+  }
   return result.address;
 };
 
@@ -333,17 +223,21 @@ export function getRelatedWallet(
   const wallet = walletKV?.v || null;
 
   const walletType = wallet?.walletType;
-  if (wallet === null)
+  if (wallet === null) {
     throw PrettyError.AssertionFailed(
       `Wallet for source ${blockchain} not passed: walletType: ${walletType}`
     );
+  }
   return wallet;
 }
 
 export function getRelatedWalletOrNull(
   swap: PendingSwap,
-  currentStep: PendingSwapStep
+  currentStep: PendingSwapStep | null
 ): WalletTypeAndAddress | null {
+  if (!currentStep) {
+    return null;
+  }
   try {
     return getRelatedWallet(swap, currentStep);
   } catch (e) {
@@ -373,7 +267,9 @@ export function getUsdFeeOfStep(
   let totalFeeInUsd = new BigNumber(0);
   for (let i = 0; i < step.fee.length; i++) {
     const fee = step.fee[i];
-    if (fee.expenseType === 'DECREASE_FROM_OUTPUT') continue;
+    if (fee.expenseType === 'DECREASE_FROM_OUTPUT') {
+      continue;
+    }
 
     const unitPrice = getUsdPrice(
       fee.asset.blockchain,
@@ -389,16 +285,61 @@ export function getUsdFeeOfStep(
   return totalFeeInUsd;
 }
 
+function mapSwapStepToPendingSwapStep(
+  swap: SwapResult,
+  meta: Pick<MetaResponse, 'blockchains' | 'tokens'> | null
+): SwapStepRoute {
+  return {
+    // from
+    fromBlockchain: swap.from.blockchain,
+    fromBlockchainLogo: swap.from.blockchainLogo,
+    fromLogo: swap.from.logo,
+    fromSymbol: swap.from.symbol,
+    fromSymbolAddress: swap.from.address,
+    fromDecimals: swap.from.decimals,
+    fromAmountPrecision: swap.fromAmountPrecision,
+    fromAmountMinValue: swap.fromAmountMinValue,
+    fromAmountMaxValue: swap.fromAmountMaxValue,
+    fromAmountRestrictionType: swap.fromAmountRestrictionType,
+    fromUsdPrice: swap.from.usdPrice,
+
+    // to
+    toBlockchain: swap.to.blockchain,
+    toBlockchainLogo: swap.to.blockchainLogo,
+    toSymbol: swap.to.symbol,
+    toSymbolAddress: swap.to.address,
+    toDecimals: swap.to.decimals,
+    toLogo: swap.to.logo,
+    toUsdPrice: swap.to.usdPrice,
+
+    // swapper
+    swapperId: swap.swapperId,
+    swapperLogo: swap.swapperLogo,
+    swapperType: swap.swapperType,
+
+    // route
+    expectedOutputAmountHumanReadable: swap.toAmount,
+    feeInUsd: meta
+      ? // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        numberToString(getUsdFeeOfStep(swap, meta?.tokens), null, 8)
+      : null,
+    estimatedTimeInSeconds: swap.estimatedTimeInSeconds || null,
+    internalSteps: null,
+  };
+}
+
 export function calculatePendingSwap(
   inputAmount: string,
   bestRoute: BestRouteResponse,
   wallets: { [p: string]: WalletTypeAndAddress },
   settings: SwapSavedSettings,
   validateBalanceOrFee: boolean,
-  meta: MetaResponse | null
+  meta: Pick<MetaResponse, 'blockchains' | 'tokens'> | null
 ): PendingSwap {
   const simulationResult = bestRoute.result;
-  if (!simulationResult) throw Error('Simulation result should not be null');
+  if (!simulationResult) {
+    throw Error('Simulation result should not be null');
+  }
 
   return {
     creationTime: new Date().getTime().toString(),
@@ -420,43 +361,23 @@ export function calculatePendingSwap(
     validateBalanceOrFee,
     steps:
       bestRoute.result?.swaps?.map((swap, index) => {
+        const stepRoute = mapSwapStepToPendingSwapStep(swap, meta);
         return {
           id: index + 1,
 
-          // from
-          fromBlockchain: swap.from.blockchain,
-          fromBlockchainLogo: swap.from.blockchainLogo,
-          fromLogo: swap.from.logo,
-          fromSymbol: swap.from.symbol,
-          fromSymbolAddress: swap.from.address,
-          fromDecimals: swap.from.decimals,
-          fromAmountPrecision: swap.fromAmountPrecision,
-          fromAmountMinValue: swap.fromAmountMinValue,
-          fromAmountMaxValue: swap.fromAmountMaxValue,
-          fromAmountRestrictionType: swap.fromAmountRestrictionType,
-
-          // to
-          toBlockchain: swap.to.blockchain,
-          toBlockchainLogo: swap.to.blockchainLogo,
-          toSymbol: swap.to.symbol,
-          toSymbolAddress: swap.to.address,
-          toDecimals: swap.to.decimals,
-          toLogo: swap.to.logo,
-
-          // swapper
-          swapperId: swap.swapperId,
-          swapperLogo: swap.swapperLogo,
-          swapperType: swap.swapperType,
-
-          // output, fee, timing
-          expectedOutputAmountHumanReadable: swap.toAmount,
-          outputAmount: '',
-          feeInUsd: meta
-            ? numberToString(getUsdFeeOfStep(swap, meta?.tokens), null, 8)
-            : null,
-          estimatedTimeInSeconds: swap.estimatedTimeInSeconds || null,
+          // route
+          ...stepRoute,
+          internalSwaps:
+            swap?.internalSwaps?.map((internalSwap) => {
+              const stepRoute = mapSwapStepToPendingSwapStep(
+                internalSwap,
+                meta
+              );
+              return stepRoute;
+            }) || null,
 
           // status, tracking
+          outputAmount: '',
           status: 'created',
           networkStatus: null,
           startTransactionTime: new Date().getTime(),

package/src/types.ts

@@ -1,15 +1,25 @@
-import { QueueStorage, QueueDef } from '@rango-dev/queue-manager-core';
-import { QueueContext } from '@rango-dev/queue-manager-core/dist/queue';
-import { ConnectResult, Providers } from '@rango-dev/wallets-react';
-import {
+import type { Wallet } from './shared';
+import type {
+  QueueContext,
+  QueueDef,
+  QueueStorage,
+} from '@rango-dev/queue-manager-core';
+import type { ConnectResult } from '@rango-dev/wallets-core';
+import type {
   Meta,
   Network,
+  Providers,
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
-import { APIErrorCode, EvmBlockchainMeta, SignerFactory } from 'rango-types';
-import { Transaction } from 'rango-sdk';
-import { PendingSwap, PendingSwapStep, Wallet } from './shared';
+import type { Transaction } from 'rango-sdk';
+import type {
+  APIErrorCode,
+  EvmBlockchainMeta,
+  PendingSwap,
+  PendingSwapStep,
+  SignerFactory,
+} from 'rango-types';
 
 export type RemoveNameField<T, U extends string> = {
   [Property in keyof T as Exclude<Property, U>]: T[Property];
@@ -61,7 +71,7 @@ export interface SwapQueueContext extends QueueContext {
   switchNetwork: (
     wallet: WalletType,
     network: Network
-  ) => Promise<ConnectResult> | undefined;
+  ) => Promise<ConnectResult | undefined> | undefined;
   canSwitchNetworkTo: (type: WalletType, network: Network) => boolean;
   connect: (
     wallet: WalletType,