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

package/src/services/eventEmitter.ts

@@ -1,30 +1,26 @@
-import type {
+import mitt from 'mitt';
+import {
+  MainEvents,
   RemoveNameField,
   Route,
   RouteEvent,
+  RouteEventType,
   RouteExecutionEvents,
+  EventSeverity,
   Step,
   StepEvent,
+  StepEventType,
+  StepExecutionEventStatus,
+  StepExecutionBlockedEventStatus,
 } from '../types';
-import type { PendingSwap, PendingSwapStep } from 'rango-types';
-
-import mitt from 'mitt';
-
+import { PendingSwap, PendingSwapStep } from 'rango-types/lib';
+import { getCurrentBlockchainOfOrNull } from '../shared';
 import {
   getCurrentStepTx,
   getFailedStep,
   getLastSuccessfulStep,
   isApprovalCurrentStepTx,
 } from '../helpers';
-import { getCurrentBlockchainOfOrNull } from '../shared';
-import {
-  EventSeverity,
-  MainEvents,
-  RouteEventType,
-  StepEventType,
-  StepExecutionBlockedEventStatus,
-  StepExecutionEventStatus,
-} from '../types';
 
 type NotifierParams = {
   swap: PendingSwap;
@@ -123,19 +119,14 @@ 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;
     }
   }
 
@@ -160,9 +151,8 @@ 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) {
@@ -206,11 +196,9 @@ 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';
@@ -218,11 +206,9 @@ export function notifier(params: NotifierParams) {
       }
       break;
     case StepEventType.CHECK_STATUS:
-      if (params.step && isApprovalCurrentStepTx(params.step)) {
-        message = 'Checking approve transaction status ...';
-      } else {
-        message = 'Checking transaction status ...';
-      }
+      if (params.step && isApprovalCurrentStepTx(params.step))
+        message = 'Checking approve transacation status ...';
+      else message = 'Checking transacation status ...';
       messageSeverity = EventSeverity.INFO;
       break;
     case StepEventType.APPROVAL_TX_SUCCEEDED:
@@ -265,10 +251,7 @@ export function notifier(params: NotifierParams) {
       break;
   }
 
-  if (params.step) {
+  if (params.step)
     emitStepEvent({ ...event, message, messageSeverity }, route, step);
-  }
-  if (params.event.type === StepEventType.FAILED || !params.step) {
-    emitRouteEvent({ ...event, message, messageSeverity }, route);
-  }
+  else emitRouteEvent({ ...event, message, messageSeverity }, route);
 }

package/src/shared-sentry.ts

@@ -1,7 +1,6 @@
-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,30 +1,31 @@
-import type { Network, WalletType } from '@rango-dev/wallets-shared';
-import type {
+import { Network, WalletType } from '@rango-dev/wallets-shared';
+import {
+  CosmosTransaction,
+  EvmTransaction,
+  SimulationResult,
+  SolanaTransaction,
+  StarknetTransaction,
+  TronTransaction,
+  Transfer as TransferTransaction,
+  AmountRestrictionType,
   BestRouteResponse,
-  BlockchainMeta,
   MetaResponse,
-  SwapResult,
   Token,
+  SwapResult,
+  BlockchainMeta,
 } 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;
@@ -84,6 +85,105 @@ 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',
@@ -93,6 +193,28 @@ 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
@@ -118,22 +240,16 @@ 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;
 };
@@ -141,15 +257,14 @@ 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;
 };
 
@@ -160,12 +275,9 @@ 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()}`;
 };
 
@@ -204,9 +316,7 @@ export const getCurrentAddressOf = (
       ? { address: step.transferTransaction?.fromWalletAddress }
       : null) ||
     null;
-  if (result == null) {
-    throw PrettyError.WalletMissing();
-  }
+  if (result == null) throw PrettyError.WalletMissing();
   return result.address;
 };
 
@@ -223,21 +333,17 @@ 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 | null
+  currentStep: PendingSwapStep
 ): WalletTypeAndAddress | null {
-  if (!currentStep) {
-    return null;
-  }
   try {
     return getRelatedWallet(swap, currentStep);
   } catch (e) {
@@ -267,9 +373,7 @@ 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,
@@ -285,61 +389,16 @@ 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: Pick<MetaResponse, 'blockchains' | 'tokens'> | null
+  meta: MetaResponse | 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(),
@@ -361,23 +420,43 @@ export function calculatePendingSwap(
     validateBalanceOrFee,
     steps:
       bestRoute.result?.swaps?.map((swap, index) => {
-        const stepRoute = mapSwapStepToPendingSwapStep(swap, meta);
         return {
           id: index + 1,
 
-          // route
-          ...stepRoute,
-          internalSwaps:
-            swap?.internalSwaps?.map((internalSwap) => {
-              const stepRoute = mapSwapStepToPendingSwapStep(
-                internalSwap,
-                meta
-              );
-              return stepRoute;
-            }) || null,
+          // 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,
 
           // status, tracking
-          outputAmount: '',
           status: 'created',
           networkStatus: null,
           startTransactionTime: new Date().getTime(),

package/src/types.ts

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