@rango-dev/queue-manager-rango-preset 0.5.1-next.7 → 0.5.1-next.9

package/src/services/eventEmitter.ts

@@ -0,0 +1,258 @@
+import mitt from 'mitt';
+import {
+  MainEvents,
+  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 {
+  getCurrentStepTx,
+  getFailedStep,
+  getLastSuccessfulStep,
+  isApprovalCurrentStepTx,
+} from '../helpers';
+
+type NotifierParams = {
+  swap: PendingSwap;
+  step: PendingSwapStep | null;
+} & {
+  event: RemoveNameField<StepEvent, 'message' | 'messageSeverity'>;
+};
+
+function createSteps(swapSteps: PendingSwapStep[]): Step[] {
+  return swapSteps.map((swapStep) => {
+    const {
+      diagnosisUrl,
+      estimatedTimeInSeconds,
+      explorerUrl,
+      feeInUsd,
+      executedTransactionId,
+      executedTransactionTime,
+      expectedOutputAmountHumanReadable,
+      fromBlockchain,
+      toBlockchain,
+      fromSymbol,
+      toSymbol,
+      fromSymbolAddress,
+      toSymbolAddress,
+      swapperType,
+      swapperId,
+      outputAmount,
+      fromAmountMaxValue,
+      fromAmountMinValue,
+      fromAmountPrecision,
+      fromAmountRestrictionType,
+      fromDecimals,
+      status: stepStatus,
+    } = swapStep;
+
+    const step: Step = {
+      diagnosisUrl,
+      estimatedTimeInSeconds,
+      explorerUrl,
+      feeInUsd,
+      executedTransactionId,
+      executedTransactionTime,
+      expectedOutputAmountHumanReadable,
+      fromBlockchain,
+      toBlockchain,
+      fromSymbol,
+      toSymbol,
+      fromSymbolAddress,
+      toSymbolAddress,
+      swapperName: swapperId,
+      swapperType,
+      outputAmount,
+      fromAmountMaxValue,
+      fromAmountMinValue,
+      fromAmountPrecision,
+      fromAmountRestrictionType,
+      fromDecimals,
+      status: stepStatus,
+      transaction: getCurrentStepTx(swapStep),
+    };
+
+    return step;
+  });
+}
+
+function getEventPayload(
+  swap: PendingSwap,
+  type: StepEventType | RouteEventType,
+  swapStep?: PendingSwapStep
+): { route: Route; step: Step } {
+  const {
+    creationTime,
+    finishTime,
+    requestId,
+    inputAmount,
+    status,
+    wallets,
+    steps,
+    settings,
+  } = swap;
+
+  const routeSteps = createSteps(steps);
+  const route: Route = {
+    creationTime,
+    finishTime,
+    requestId,
+    inputAmount,
+    status,
+    wallets,
+    steps: routeSteps,
+    slippage: settings.slippage,
+    infiniteApproval: settings.infiniteApprove,
+  };
+
+  const result: { route: Route; step: Step } = {
+    route,
+    step: routeSteps[routeSteps.length - 1],
+  };
+  if (swapStep) result.step = createSteps([swapStep])[0];
+  else {
+    if (type === 'failed') {
+      const failedStep = getFailedStep(routeSteps);
+      if (failedStep) result.step = failedStep;
+    } else {
+      const lastSuccessfulStep = getLastSuccessfulStep(routeSteps);
+      if (lastSuccessfulStep) result.step = lastSuccessfulStep;
+    }
+  }
+
+  return result;
+}
+
+export const eventEmitter = mitt<RouteExecutionEvents>();
+
+function emitRouteEvent(stepEvent: StepEvent, route: Route) {
+  let routeEvent: RouteEvent | undefined;
+  const { type } = stepEvent;
+  switch (type) {
+    case StepEventType.STARTED:
+      routeEvent = { ...stepEvent, type: RouteEventType.STARTED };
+      break;
+    case StepEventType.FAILED:
+      routeEvent = { ...stepEvent, type: RouteEventType.FAILED };
+      break;
+    case StepEventType.SUCCEEDED:
+      routeEvent = { ...stepEvent, type: RouteEventType.SUCCEEDED };
+      break;
+    default:
+      break;
+  }
+  if (routeEvent)
+    eventEmitter.emit(MainEvents.RouteEvent, { event: routeEvent, route });
+}
+
+function emitStepEvent(stepEvent: StepEvent, route: Route, step: Step) {
+  eventEmitter.emit(MainEvents.StepEvent, { event: stepEvent, route, step });
+}
+
+export function notifier(params: NotifierParams) {
+  console.log({ originalEvent: params.step });
+  const { event } = params;
+  const { type } = event;
+  const { route, step } = getEventPayload(
+    params.swap,
+    type,
+    params.step ?? undefined
+  );
+  const fromAsset = `${step.fromBlockchain}.${step.fromSymbol}`;
+  const toAsset = `${step.toBlockchain}.${step.toSymbol}`;
+  const outputAmount = step.outputAmount ?? '';
+  const currentFromBlockchain = !!params.step
+    ? getCurrentBlockchainOfOrNull(params.swap, params.step)
+    : null;
+  let message = '';
+  let messageSeverity: StepEvent['messageSeverity'] = EventSeverity.INFO;
+
+  switch (type) {
+    case StepEventType.STARTED:
+      message = 'Swap process started';
+      messageSeverity = EventSeverity.SUCCESS;
+      break;
+    case StepEventType.SUCCEEDED:
+      message = `You received ${outputAmount} ${toAsset}, hooray!`;
+      messageSeverity = EventSeverity.SUCCESS;
+      break;
+    case StepEventType.FAILED:
+      message = `Swap failed: ${
+        params.swap?.extraMessage ?? 'Reason is unknown'
+      }`;
+      messageSeverity = EventSeverity.ERROR;
+      break;
+    case StepEventType.TX_EXECUTION:
+      if (event.status === StepExecutionEventStatus.CREATE_TX) {
+        message = 'Please wait while the transaction is created ...';
+        messageSeverity = EventSeverity.INFO;
+      } else if (event.status === StepExecutionEventStatus.SEND_TX) {
+        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';
+        messageSeverity = EventSeverity.WARNING;
+      } else if (event.status === StepExecutionEventStatus.TX_SENT) {
+        message = 'Transaction sent successfully';
+        messageSeverity = EventSeverity.INFO;
+      }
+      break;
+    case StepEventType.CHECK_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:
+      message = 'Smart contract called successfully';
+      messageSeverity = EventSeverity.SUCCESS;
+      break;
+    case StepEventType.OUTPUT_REVEALED:
+      message = 'Transaction output amount revealed';
+      messageSeverity = EventSeverity.SUCCESS;
+      break;
+
+    case StepEventType.TX_EXECUTION_BLOCKED:
+      if (
+        event.status ===
+        StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT
+      ) {
+        message = 'Please connect your wallet.';
+        messageSeverity = EventSeverity.WARNING;
+      } else if (
+        event.status === StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE
+      ) {
+        message = 'Waiting for other swaps to complete';
+        messageSeverity = EventSeverity.WARNING;
+      } else if (
+        event.status ===
+        StepExecutionBlockedEventStatus.WAITING_FOR_CHANGE_WALLET_ACCOUNT
+      ) {
+        message = 'Please change your wallet account.';
+        messageSeverity = EventSeverity.WARNING;
+      } else if (
+        event.status ===
+        StepExecutionBlockedEventStatus.WAITING_FOR_NETWORK_CHANGE
+      ) {
+        message = `Please change your wallet network to ${currentFromBlockchain}.`;
+        messageSeverity = EventSeverity.WARNING;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  if (params.step)
+    emitStepEvent({ ...event, message, messageSeverity }, route, step);
+  else emitRouteEvent({ ...event, message, messageSeverity }, route);
+}

package/src/shared-errors.ts

@@ -8,6 +8,7 @@ import {
   isSignerErrorCode,
   isAPIErrorCode,
 } from 'rango-types';
+import { DEFAULT_ERROR_CODE } from './constants';
 
 export type ErrorDetail = {
   extraMessage: string;
@@ -117,24 +118,23 @@ export class PrettyError extends Error {
 export function mapAppErrorCodesToAPIErrorCode(
   errorCode: string | null
 ): APIErrorCode {
-  const defaultErrorCode = 'CLIENT_UNEXPECTED_BEHAVIOUR';
   try {
-    if (!errorCode) return defaultErrorCode;
+    if (!errorCode) return DEFAULT_ERROR_CODE;
     if (isAPIErrorCode(errorCode)) return errorCode;
     if (isSignerErrorCode(errorCode)) {
       const t: { [key in SignerErrorCodeType]: APIErrorCode } = {
         [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,
+        [SignerErrorCode.NOT_IMPLEMENTED]: DEFAULT_ERROR_CODE,
+        [SignerErrorCode.OPERATION_UNSUPPORTED]: DEFAULT_ERROR_CODE,
+        [SignerErrorCode.UNEXPECTED_BEHAVIOUR]: DEFAULT_ERROR_CODE,
       };
       return t[errorCode];
     }
-    return defaultErrorCode;
+    return DEFAULT_ERROR_CODE;
   } catch (err) {
-    return defaultErrorCode;
+    return DEFAULT_ERROR_CODE;
   }
 }
 

package/src/shared.ts

@@ -30,12 +30,6 @@ export interface PendingSwapWithQueueID {
   swap: PendingSwap;
 }
 
-export type SwapProgressNotification = {
-  eventType: EventType;
-  swap: PendingSwap | null;
-  step: PendingSwapStep | null;
-};
-
 export type WalletBalance = {
   chain: Network;
   symbol: string;

package/src/types.ts

@@ -7,8 +7,15 @@ import {
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
-import { PendingSwap, SwapProgressNotification, Wallet } from './shared';
-import type { EvmBlockchainMeta, 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];
+};
+
+export type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
 
 export type SwapQueueDef = QueueDef<
   SwapStorage,
@@ -62,7 +69,6 @@ export interface SwapQueueContext extends QueueContext {
   ) => Promise<ConnectResult> | undefined;
   state: (type: WalletType) => WalletState;
   isMobileWallet: (type: WalletType) => boolean;
-  notifier: (data: SwapProgressNotification) => void;
 
   // Dynamically will be added to context.
   claimedBy?: string;
@@ -74,6 +80,146 @@ export interface UseQueueManagerParams {
   disconnectedWallet: WalletType | undefined;
   clearDisconnectedWallet: () => void;
   evmChains: EvmBlockchainMeta[];
-  notifier: SwapQueueContext['notifier'];
   canSwitchNetworkTo: (type: WalletType, network: Network) => boolean;
 }
+
+export enum MainEvents {
+  RouteEvent = 'routeEvent',
+  StepEvent = 'stepEvent',
+}
+
+export type Step = Pick<
+  PendingSwapStep,
+  | 'diagnosisUrl'
+  | 'estimatedTimeInSeconds'
+  | 'explorerUrl'
+  | 'feeInUsd'
+  | 'executedTransactionId'
+  | 'executedTransactionTime'
+  | 'expectedOutputAmountHumanReadable'
+  | 'fromBlockchain'
+  | 'toBlockchain'
+  | 'fromSymbol'
+  | 'toSymbol'
+  | 'toSymbolAddress'
+  | 'fromSymbolAddress'
+  | 'swapperType'
+  | 'outputAmount'
+  | 'fromAmountMaxValue'
+  | 'fromAmountMinValue'
+  | 'fromAmountPrecision'
+  | 'fromAmountRestrictionType'
+  | 'fromDecimals'
+  | 'status'
+> & { swapperName: string; transaction: Transaction | null };
+
+export type Route = Pick<
+  PendingSwap,
+  | 'creationTime'
+  | 'finishTime'
+  | 'requestId'
+  | 'inputAmount'
+  | 'status'
+  | 'wallets'
+> & { steps: Step[]; slippage: string; infiniteApproval?: boolean };
+
+export type SwapEvent = RouteEvent | StepEvent;
+
+export enum RouteEventType {
+  STARTED = 'started',
+  FAILED = 'failed',
+  SUCCEEDED = 'succeeded',
+}
+
+export enum StepExecutionEventStatus {
+  CREATE_TX = 'create_tx',
+  SEND_TX = 'send_tx',
+  TX_SENT = 'tx_sent',
+}
+
+export enum StepExecutionBlockedEventStatus {
+  WAITING_FOR_QUEUE = 'waiting_for_queue',
+  WAITING_FOR_WALLET_CONNECT = 'waiting_for_wallet_connect',
+  WAITING_FOR_NETWORK_CHANGE = 'waiting_for_network_change',
+  WAITING_FOR_CHANGE_WALLET_ACCOUNT = 'waiting_for_change_wallet_account',
+}
+
+export enum StepEventType {
+  STARTED = 'started',
+  FAILED = 'failed',
+  SUCCEEDED = 'succeeded',
+  TX_EXECUTION = 'tx_execution',
+  TX_EXECUTION_BLOCKED = 'tx_execution_blocked',
+  APPROVAL_TX_SUCCEEDED = 'approval_tx_succeeded',
+  CHECK_STATUS = 'check_status',
+  OUTPUT_REVEALED = 'output_revealed',
+}
+
+export enum EventSeverity {
+  ERROR = 'error',
+  SUCCESS = 'success',
+  WARNING = 'warning',
+  INFO = 'info',
+}
+
+export type Event<
+  T extends StepEventType | RouteEventType,
+  U extends Record<string, unknown> = Record<string, unknown>
+> = {
+  type: T;
+  message: string;
+  messageSeverity: EventSeverity;
+} & U;
+
+export type FailedRouteEventPayload = {
+  reason?: string;
+  reasonCode: APIErrorCode;
+};
+
+export type SucceededRouteEventPayload = {
+  outputAmount: string;
+};
+
+export type StepExecutionEventPayload = {
+  status:
+    | StepExecutionEventStatus.CREATE_TX
+    | StepExecutionEventStatus.SEND_TX
+    | StepExecutionEventStatus.TX_SENT;
+};
+
+export type StepBlockedEventPayload =
+  | { status: StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE }
+  | {
+      status: StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT;
+      requiredWallet?: string;
+      requiredAccount?: string;
+    }
+  | {
+      status: StepExecutionBlockedEventStatus.WAITING_FOR_CHANGE_WALLET_ACCOUNT;
+      requiredAccount?: string;
+    }
+  | {
+      status: StepExecutionBlockedEventStatus.WAITING_FOR_NETWORK_CHANGE;
+      currentNetwork?: string;
+      requiredNetwork?: string;
+    };
+
+export type StepEvent =
+  | Event<StepEventType.STARTED>
+  | Event<StepEventType.SUCCEEDED, { outputAmount: string }>
+  | Event<StepEventType.FAILED, FailedRouteEventPayload>
+  | Event<StepEventType.TX_EXECUTION, StepExecutionEventPayload>
+  | Event<StepEventType.TX_EXECUTION_BLOCKED, StepBlockedEventPayload>
+  | Event<StepEventType.CHECK_STATUS>
+  | Event<StepEventType.APPROVAL_TX_SUCCEEDED>
+  | Event<StepEventType.OUTPUT_REVEALED, { outputAmount: string }>;
+
+export type RouteEvent =
+  | Event<RouteEventType.STARTED>
+  | Event<RouteEventType.FAILED, FailedRouteEventPayload>
+  | Event<RouteEventType.SUCCEEDED, SucceededRouteEventPayload>;
+
+export type RouteExecutionEvents = {
+  [MainEvents.RouteEvent]: { route: Route; event: RouteEvent };
+  [MainEvents.StepEvent]: { route: Route; step: Step; event: StepEvent };
+};