@rango-dev/queue-manager-rango-preset 0.1.10-next.98 → 0.1.11-next.2

package/src/hooks.ts

@@ -54,8 +54,9 @@ function useQueueManager(params: UseQueueManagerParams): void {
         evmChains: params.evmChains,
         wallet_network: params.lastConnectedWallet,
         manager,
+        notifier: params.notifier,
       });
-      retryOn(params.lastConnectedWallet, manager);
+      retryOn(params.lastConnectedWallet, params.notifier, manager);
     }
   }, [params.lastConnectedWallet]);
 

package/src/index.ts

@@ -1,53 +1,28 @@
-import { BlockReason, SwapActionTypes, SwapQueueDef } from './types';
-import { checkStatus } from './actions/checkStatus';
-import { createTransaction } from './actions/createTransaction';
-import { executeTransaction } from './actions/executeTransaction';
-import { scheduleNextStep } from './actions/scheduleNextStep';
-import { start } from './actions/start';
-import {
-  onBlockForChangeNetwork,
-  onBlockForConnectWallet,
-  onDependsOnOtherQueues,
-} from './helpers';
-
-/**
- *
- * The idea behind this queue is to be able dynamically add some steps.
- * After running a swap, it can be blocked (like on waiting for switch netwrok)
- *  or waits for something happend (like checking status of a transaction from server)
- *
- */
-export const swapQueueDef: SwapQueueDef = {
-  name: 'swap',
-  actions: {
-    [SwapActionTypes.START]: start,
-    [SwapActionTypes.SCHEDULE_NEXT_STEP]: scheduleNextStep,
-    [SwapActionTypes.CREATE_TRANSACTION]: createTransaction,
-    [SwapActionTypes.EXECUTE_TRANSACTION]: executeTransaction,
-    [SwapActionTypes.CHECK_TRANSACTION_STATUS]: checkStatus,
-  },
-  run: [SwapActionTypes.START],
-  whenTaskBlocked: (event: any, meta: any) => {
-    if (event.reason.reason === BlockReason.WAIT_FOR_CONNECT_WALLET) {
-      onBlockForConnectWallet(event, meta);
-    } else if (event.reason.reason === BlockReason.WAIT_FOR_NETWORK_CHANGE) {
-      onBlockForChangeNetwork(event, meta);
-    } else if (event.reason.reason === BlockReason.DEPENDS_ON_OTHER_QUEUES) {
-      onDependsOnOtherQueues(event, meta);
-    }
-  },
-};
-
+export { PrettyError, prettifyErrorMessage } from './shared-errors';
 export { SwapQueueContext, SwapStorage } from './types';
-export { PendingSwapWithQueueID } from './shared';
-
-// TODO: This is for our frontend, some of them can be removed.
+export {
+  PendingSwapWithQueueID,
+  getCurrentBlockchainOfOrNull,
+  getRelatedWalletOrNull,
+  getRelatedWallet,
+  MessageSeverity,
+  PendingSwapStep,
+  PendingSwapNetworkStatus,
+  PendingSwap,
+  EventType,
+  SwapProgressNotification,
+  calculatePendingSwap,
+} from './shared';
 export {
   updateSwapStatus,
   checkWaitingForNetworkChange,
   getCurrentStep,
   getEvmProvider,
-  getRelatedWallet,
   cancelSwap,
+  getRequiredWallet,
+  getRunningSwaps,
+  splitWalletNetwork,
+  resetRunningSwapNotifsOnPageLoad,
 } from './helpers';
+export { swapQueueDef } from './queueDef';
 export { useMigration, useQueueManager } from './hooks';

package/src/numbers.ts

@@ -0,0 +1,68 @@
+import BigNumber from 'bignumber.js';
+
+export const numberToString = (
+  number: BigNumber | string | null,
+  minDecimals: number | null = null,
+  maxDecimals: number | null = null
+): string => {
+  if (number === null) return '';
+  if (number === '') return '';
+  const n = new BigNumber(number);
+  const roundingMode = 1;
+  let maxI = 1000;
+  for (let i = 0; i < 60; i++) {
+    if (new BigNumber(n.toFixed(i, roundingMode)).eq(n)) {
+      maxI = i;
+      break;
+    }
+  }
+
+  if (n.gte(10000)) return n.toFormat(0, roundingMode);
+  if (n.gte(1000))
+    return n.toFormat(
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))
+      ),
+      roundingMode
+    );
+  if (n.gte(100))
+    return n.toFormat(
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 1))
+      ),
+      roundingMode
+    );
+  if (n.gte(1))
+    return n.toFormat(
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 2))
+      ),
+      roundingMode
+    );
+  if (n.gte(0.01))
+    return n.toFormat(
+      Math.min(
+        maxI,
+        Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 4))
+      ),
+      roundingMode
+    );
+  for (let i = minDecimals || 4; i < 17; i++)
+    if (n.gte(Math.pow(10, -i)))
+      return n.toFormat(
+        Math.min(
+          maxI,
+          Math.min(maxDecimals || 100, Math.max(minDecimals || 0, i))
+        ),
+        roundingMode
+      );
+  if (n.isEqualTo(0)) return '0';
+
+  return n.toFormat(
+    Math.min(maxI, Math.min(maxDecimals || 100, Math.max(minDecimals || 0, 8))),
+    roundingMode
+  );
+};

package/src/shared-errors.ts

@@ -1,61 +1,20 @@
-import { WalletType } from '@rango-dev/wallets-shared';
-import { SignerErrorCode, isSignerErrorCode } from 'rango-types';
+import {
+  APIErrorCode,
+  SignerError,
+  SignerErrorCode,
+  isAPIErrorCode,
+  isSignerErrorCode,
+} from 'rango-types';
 
 export type ErrorDetail = {
   extraMessage: string;
   extraMessageDetail?: string | null | undefined;
-  extraMessageErrorCode: string | null;
+  extraMessageErrorCode: SignerErrorCode | APIErrorCode | null;
 };
 
-export enum APIErrorCode {
-  TX_FAIL = 'TX_FAIL',
-  FETCH_TX_FAILED = 'FETCH_TX_FAILED',
-  USER_REJECT = 'USER_REJECT',
-  CALL_WALLET_FAILED = 'CALL_WALLET_FAILED',
-  SEND_TX_FAILED = 'SEND_TX_FAILED',
-  CALL_OR_SEND_FAILED = 'CALL_OR_SEND_FAILED',
-  USER_CANCEL = 'USER_CANCEL',
-  CLIENT_UNEXPECTED_BEHAVIOUR = 'CLIENT_UNEXPECTED_BEHAVIOUR',
-}
-
-export enum ApiMethodName {
-  RequestingSwapTransaction = 'Requesting Swap Transaction',
-  CreatingSwap = 'Creating Swap',
-  CheckingTransactionStatus = 'Checking transaction status',
-  CreateTransaction = 'Create Transaction',
-  CheckApproval = 'Check TX Approval',
-  GettingSwapDetail = 'Getting Swap Detail',
-  GettingUserLimits = 'Getting user limits',
-}
-
-export enum TransactionName {
-  GenericTransaction = 'transaction',
-  SendingOneInchTransaction = '1inch transaction',
-  Approval = 'approve transaction',
-}
-
-export const ERROR_ASSERTION_FAILED = 'Assertion failed (Unexpected behaviour)';
-
-export const ERROR_COMMUNICATING_WITH_API = (
-  apiMethodName: ApiMethodName
-): string => `Unexpected response from API (${apiMethodName})`;
-
-export const ERROR_DESCRIPTION_UNSUPPORTED_TRANSACTION = (
-  method: string,
-  walletType: WalletType
-): string => `method: ${method} call is unsupported for wallet ${walletType}`;
-
-export const ERROR_SIGNING_TRANSACTION = (
-  transactionName: TransactionName
-): string => `Error sending ${transactionName}`;
-export const ERROR_REJECTING_TRANSACTION = 'User rejected the message signing';
-
-export const ERROR_CREATE_TRANSACTION =
-  'Create transaction failed in Rango Server';
-export const ERROR_INPUT_WALLET_NOT_FOUND = 'Input wallet not found';
-
-export const DEFAULT_WALLET_INJECTION_ERROR =
-  'Failed to connect to wallet, if you have turned injection off (disable default wallet for xDefi), turn it on and refresh the page';
+const ERROR_ASSERTION_FAILED = 'Assertion failed (Unexpected behaviour)';
+const ERROR_CREATE_TRANSACTION = 'Create transaction failed in Rango Server';
+const ERROR_INPUT_WALLET_NOT_FOUND = 'Input wallet not found';
 
 type ErrorRoot = string | Record<string, string> | null;
 
@@ -63,6 +22,7 @@ export class PrettyError extends Error {
   private readonly detail?: string;
   private readonly root?: ErrorRoot;
   private readonly code?: APIErrorCode;
+  public _isPrettyError = true;
 
   constructor(
     code: APIErrorCode,
@@ -72,11 +32,19 @@ export class PrettyError extends Error {
   ) {
     super(m);
     Object.setPrototypeOf(this, PrettyError.prototype);
+    PrettyError.prototype._isPrettyError = true;
     this.code = code;
     this.detail = detail;
     this.root = root;
   }
 
+  static isPrettyError(obj: unknown): obj is PrettyError {
+    return (
+      obj instanceof PrettyError ||
+      Object.prototype.hasOwnProperty('_isPrettyError')
+    );
+  }
+
   getErrorDetail(): ErrorDetail {
     const rawMessage =
       typeof this.root === 'object' && this.root && this.root.error
@@ -97,7 +65,7 @@ export class PrettyError extends Error {
 
   static AssertionFailed(m: string): PrettyError {
     return new PrettyError(
-      APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR,
+      'CLIENT_UNEXPECTED_BEHAVIOUR',
       ERROR_ASSERTION_FAILED,
       m
     );
@@ -108,7 +76,7 @@ export class PrettyError extends Error {
     statusCode: number | string
   ): PrettyError {
     return new PrettyError(
-      APIErrorCode.TX_FAIL,
+      'TX_FAIL',
       message,
       null,
       `status code = ${statusCode}`
@@ -117,7 +85,7 @@ export class PrettyError extends Error {
 
   static CreateTransaction(detail: string): PrettyError {
     return new PrettyError(
-      APIErrorCode.FETCH_TX_FAILED,
+      'FETCH_TX_FAILED',
       ERROR_CREATE_TRANSACTION,
       null,
       detail
@@ -126,7 +94,7 @@ export class PrettyError extends Error {
 
   static WalletMissing(): PrettyError {
     return new PrettyError(
-      APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR,
+      'CLIENT_UNEXPECTED_BEHAVIOUR',
       ERROR_INPUT_WALLET_NOT_FOUND,
       null,
       'Server requested for a blockchain or address not selected by user'
@@ -135,7 +103,7 @@ export class PrettyError extends Error {
 
   static BlockchainMissing(): PrettyError {
     return new PrettyError(
-      APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR,
+      'CLIENT_UNEXPECTED_BEHAVIOUR',
       ERROR_INPUT_WALLET_NOT_FOUND,
       null,
       'Server requested for a blockchain or address not selected by user'
@@ -143,33 +111,18 @@ export class PrettyError extends Error {
   }
 }
 
-export const ERROR_GETTING_BEST_ROUTE = (status: number | string): string =>
-  `Failed to get best route (status: ${status}), please try again.`;
-
-export const ERROR_CONFIRM_SWAP = (status?: number | string): string =>
-  `Failed to confirm swap (${!!status ? 'status' : 'route'}: ${
-    status || null
-  }), please try again.`;
-
-export const WARNING_STARKNET_FOUND =
-  'StarknNet blockchain is still an ALPHA version. As such, delays may occur, and catastrophic bugs may lurk.';
-
-function isAPIErrorCode(value: string): value is APIErrorCode {
-  return (Object.values(APIErrorCode) as string[]).includes(value);
-}
-
 export function mapAppErrorCodesToAPIErrorCode(
   errorCode: string | null
 ): APIErrorCode {
-  const defaultErrorCode = APIErrorCode.CLIENT_UNEXPECTED_BEHAVIOUR;
+  const defaultErrorCode = 'CLIENT_UNEXPECTED_BEHAVIOUR';
   try {
     if (!errorCode) return defaultErrorCode;
     if (isAPIErrorCode(errorCode)) return errorCode;
     if (isSignerErrorCode(errorCode)) {
       const t: { [key in SignerErrorCode]: APIErrorCode } = {
-        [SignerErrorCode.REJECTED_BY_USER]: APIErrorCode.USER_REJECT,
-        [SignerErrorCode.SIGN_TX_ERROR]: APIErrorCode.CALL_WALLET_FAILED,
-        [SignerErrorCode.SEND_TX_ERROR]: APIErrorCode.SEND_TX_FAILED,
+        [SignerErrorCode.REJECTED_BY_USER]: 'USER_REJECT',
+        [SignerErrorCode.SIGN_TX_ERROR]: 'CALL_WALLET_FAILED',
+        [SignerErrorCode.SEND_TX_ERROR]: 'SEND_TX_FAILED',
         [SignerErrorCode.NOT_IMPLEMENTED]: defaultErrorCode,
         [SignerErrorCode.OPERATION_UNSUPPORTED]: defaultErrorCode,
         [SignerErrorCode.UNEXPECTED_BEHAVIOUR]: defaultErrorCode,
@@ -181,3 +134,27 @@ export function mapAppErrorCodesToAPIErrorCode(
     return defaultErrorCode;
   }
 }
+
+export const prettifyErrorMessage = (obj: unknown): ErrorDetail => {
+  if (!obj) return { extraMessage: '', extraMessageErrorCode: null };
+  if (PrettyError.isPrettyError(obj)) return obj.getErrorDetail();
+  if (SignerError.isSignerError(obj)) {
+    const t = obj.getErrorDetail();
+    return {
+      extraMessage: t.message,
+      extraMessageDetail: t.detail,
+      extraMessageErrorCode: t.code,
+    };
+  }
+  if (obj instanceof Error)
+    return {
+      extraMessage: obj.toString(),
+      extraMessageErrorCode: null,
+    };
+  if (typeof obj !== 'string')
+    return {
+      extraMessage: JSON.stringify(obj),
+      extraMessageErrorCode: null,
+    };
+  return { extraMessage: obj, extraMessageErrorCode: null };
+};

package/src/shared-sentry.ts

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