@rango-dev/queue-manager-rango-preset 0.5.1-next.0 → 0.5.1-next.10

package/src/helpers.ts

@@ -5,16 +5,22 @@ import {
   QueueType,
 } from '@rango-dev/queue-manager-core';
 import {
+  ArrayElement,
   BlockReason,
+  StepEventType,
   SwapActionTypes,
   SwapQueueContext,
   SwapQueueDef,
   SwapStorage,
+  StepExecutionEventStatus,
+  StepExecutionBlockedEventStatus,
+  Step,
 } from './types';
 import {
   getBlockChainNameFromId,
   Meta,
   Network,
+  Networks,
   WalletState,
   WalletType,
 } from '@rango-dev/wallets-shared';
@@ -25,15 +31,10 @@ import {
   TransactionType,
   EvmBlockchainMeta,
   CreateTransactionResponse,
-  isEvmTransaction,
-  isCosmosTransaction,
-  isSolanaTransaction,
-  isTronTransaction,
-  isStarknetTransaction,
-  isTransferTransaction,
 } from 'rango-sdk';
 
 import {
+  DEFAULT_ERROR_CODE,
   ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK,
   ERROR_MESSAGE_WAIT_FOR_WALLET,
   ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION,
@@ -41,7 +42,6 @@ import {
 import { Manager } from '@rango-dev/queue-manager-core';
 import { Status } from '@rango-dev/queue-manager-core';
 import {
-  EventType,
   getCurrentBlockchainOf,
   getCurrentBlockchainOfOrNull,
   getScannerUrl,
@@ -64,6 +64,7 @@ import {
 } from './shared-errors';
 import { httpService } from './services';
 import { APIErrorCode, SignerErrorCode } from 'rango-types/lib';
+import { notifier } from './services/eventEmitter';
 
 type WhenTaskBlocked = Parameters<NonNullable<SwapQueueDef['whenTaskBlocked']>>;
 type WhenTaskBlockedEvent = WhenTaskBlocked[0];
@@ -101,7 +102,7 @@ type TransactionData = {
   receiptReceived?: boolean; // e.g. is TransactionReceipt ready in case of EVM transactions
 };
 const swapTransactionToDataMap: { [id: string]: TransactionData } = {};
-export function useTransactionsData() {
+export function inMemoryTransactionsData() {
   return {
     getTransactionDataByHash: (hash: string) =>
       swapTransactionToDataMap[hash] || {},
@@ -206,24 +207,36 @@ export const setCurrentStepTx = (
   currentStep.tronApprovalTransaction = null;
   currentStep.tronTransaction = null;
 
-  if (isEvmTransaction(transaction)) {
-    if (transaction.isApprovalTx)
-      currentStep.evmApprovalTransaction = transaction;
-    else currentStep.evmTransaction = transaction;
-  } else if (isCosmosTransaction(transaction)) {
-    currentStep.cosmosTransaction = transaction;
-  } else if (isSolanaTransaction(transaction)) {
-    currentStep.solanaTransaction = transaction;
-  } else if (isTransferTransaction(transaction)) {
-    currentStep.transferTransaction = transaction;
-  } else if (isStarknetTransaction(transaction)) {
-    if (transaction.isApprovalTx)
-      currentStep.starknetApprovalTransaction = transaction;
-    else currentStep.starknetTransaction = transaction;
-  } else if (isTronTransaction(transaction)) {
-    if (transaction.isApprovalTx)
-      currentStep.tronApprovalTransaction = transaction;
-    else currentStep.tronTransaction = transaction;
+  const txType = transaction.type;
+  switch (txType) {
+    case TransactionType.EVM:
+      if (transaction.isApprovalTx)
+        currentStep.evmApprovalTransaction = transaction;
+      else currentStep.evmTransaction = transaction;
+      break;
+    case TransactionType.TRON:
+      if (transaction.isApprovalTx)
+        currentStep.tronApprovalTransaction = transaction;
+      else currentStep.tronTransaction = transaction;
+      break;
+    case TransactionType.STARKNET:
+      if (transaction.isApprovalTx)
+        currentStep.starknetApprovalTransaction = transaction;
+      else currentStep.starknetTransaction = transaction;
+      break;
+    case TransactionType.COSMOS:
+      currentStep.cosmosTransaction = transaction;
+      break;
+    case TransactionType.SOLANA:
+      currentStep.solanaTransaction = transaction;
+      break;
+    case TransactionType.TRANSFER:
+      currentStep.transferTransaction = transaction;
+      break;
+    default:
+      ((x: never) => {
+        throw new Error(`${x} was unhandled!`);
+      })(txType);
   }
   return currentStep;
 };
@@ -292,9 +305,18 @@ export function updateSwapStatus({
 }): {
   swap: PendingSwap;
   step: PendingSwapStep | null;
+  failureType?: APIErrorCode;
 } {
   const swap = getStorage().swapDetails;
   const currentStep = getCurrentStep(swap);
+  const updatedResult: {
+    swap: PendingSwap;
+    step: PendingSwapStep | null;
+    failureType?: APIErrorCode;
+  } = {
+    swap,
+    step: currentStep,
+  };
   if (!!nextStepStatus && !!currentStep) currentStep.status = nextStepStatus;
 
   if (nextStatus) swap.status = nextStatus;
@@ -316,11 +338,14 @@ export function updateSwapStatus({
     const walletType = getRelatedWalletOrNull(swap, currentStep!)?.walletType;
     swap.extraMessageSeverity = MessageSeverity.error;
 
+    const failureType = mapAppErrorCodesToAPIErrorCode(errorCode);
+    updatedResult.failureType = failureType;
+
     httpService()
       .reportFailure({
         requestId: swap.requestId,
         step: currentStep?.id || 1,
-        eventType: mapAppErrorCodesToAPIErrorCode(errorCode),
+        eventType: failureType,
         reason: errorReason || '',
         data: walletType ? { wallet: walletType } : undefined,
       })
@@ -341,10 +366,7 @@ export function updateSwapStatus({
     swapDetails: swap,
   });
 
-  return {
-    swap,
-    step: currentStep,
-  };
+  return updatedResult;
 }
 
 /**
@@ -355,8 +377,6 @@ export function updateSwapStatus({
 export function setStepTransactionIds(
   { getStorage, setStorage }: ExecuterActions<SwapStorage, SwapActionTypes>,
   txId: string | null,
-  notifier: SwapQueueContext['notifier'],
-  eventType?: EventType,
   explorerUrl?: { url?: string; description?: string }
 ): void {
   const swap = getStorage().swapDetails;
@@ -373,22 +393,29 @@ export function setStepTransactionIds(
         description: explorerUrl.description || null,
       },
     ];
-  if (eventType === 'check_tx_status') {
-    swap.extraMessage = 'Checking transaction status ...';
-    swap.extraMessageDetail = '';
-    swap.extraMessageSeverity = MessageSeverity.info;
-  } else if (eventType === 'check_approve_tx_status') {
-    swap.extraMessage = 'Checking approve transaction status ...';
-    swap.extraMessageDetail = '';
-    swap.extraMessageSeverity = MessageSeverity.info;
-  }
+  swap.extraMessage = 'Transaction sent ...';
+  swap.extraMessageDetail = '';
+  swap.extraMessageSeverity = MessageSeverity.info;
 
   setStorage({
     ...getStorage(),
     swapDetails: swap,
   });
-  if (eventType)
-    notifier({ eventType: eventType, swap: swap, step: currentStep });
+
+  notifier({
+    event: {
+      type: StepEventType.TX_EXECUTION,
+      status: StepExecutionEventStatus.TX_SENT,
+    },
+    swap: swap,
+    step: currentStep,
+  });
+
+  notifier({
+    event: { type: StepEventType.CHECK_STATUS },
+    swap: swap,
+    step: currentStep,
+  });
 }
 
 /**
@@ -479,10 +506,7 @@ export function markRunningSwapAsSwitchingNetwork({
 export function markRunningSwapAsDependsOnOtherQueues({
   getStorage,
   setStorage,
-  notifier,
-}: Pick<ExecuterActions, 'getStorage' | 'setStorage'> & {
-  notifier: SwapQueueContext['notifier'];
-}):
+}: Pick<ExecuterActions, 'getStorage' | 'setStorage'>):
   | {
       swap: PendingSwap;
       step: PendingSwapStep;
@@ -497,7 +521,10 @@ export function markRunningSwapAsDependsOnOtherQueues({
   currentStep.networkStatus = PendingSwapNetworkStatus.WaitingForQueue;
 
   notifier({
-    eventType: 'waiting_for_queue',
+    event: {
+      type: StepEventType.TX_EXECUTION_BLOCKED,
+      status: StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE,
+    },
     swap,
     step: currentStep,
   });
@@ -554,7 +581,7 @@ export function isWalletNull(wallet: Wallet | null): boolean {
 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(Network.ETHEREUM);
+    if (providers[type].size) return providers[type].get(Networks.ETHEREUM);
 
     return providers[type];
   }
@@ -736,11 +763,23 @@ export function onBlockForConnectWallet(
   if (!ok) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const currentStep = getCurrentStep(swap)!;
-    context.notifier({
-      eventType:
-        reason === 'account_miss_match'
-          ? 'waiting_for_change_wallet_account'
-          : 'waiting_for_connecting_wallet',
+    const { type: walletType, address } = getRequiredWallet(swap);
+    notifier({
+      event: {
+        type: StepEventType.TX_EXECUTION_BLOCKED,
+        ...(reason === 'account_miss_match'
+          ? {
+              status:
+                StepExecutionBlockedEventStatus.WAITING_FOR_CHANGE_WALLET_ACCOUNT,
+              requiredAccount: address ?? undefined,
+            }
+          : {
+              status:
+                StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT,
+              requiredWallet: walletType ?? undefined,
+              requiredAccount: address ?? undefined,
+            }),
+      },
       swap: swap,
       step: currentStep,
     });
@@ -783,9 +822,22 @@ export function onBlockForChangeNetwork(
     setStorage: queue.setStorage.bind(queue),
   });
 
+  const requiredNetwork = getCurrentBlockchainOfOrNull(swap, currentStep);
+
+  const requiredWallet = getRequiredWallet(swap).type;
+
+  const currentNetwork = requiredWallet
+    ? context.state(requiredWallet).network
+    : undefined;
+
   if (result) {
-    context.notifier({
-      eventType: 'waiting_for_network_change',
+    notifier({
+      event: {
+        type: StepEventType.TX_EXECUTION_BLOCKED,
+        status: StepExecutionBlockedEventStatus.WAITING_FOR_NETWORK_CHANGE,
+        requiredNetwork: requiredNetwork ?? undefined,
+        currentNetwork: currentNetwork ?? undefined,
+      },
       swap: result.swap,
       step: result.step,
     });
@@ -844,7 +896,6 @@ export function onDependsOnOtherQueues(
     markRunningSwapAsDependsOnOtherQueues({
       getStorage: queue.getStorage.bind(queue),
       setStorage: queue.setStorage.bind(queue),
-      notifier: context.notifier,
     });
     return;
   }
@@ -875,7 +926,6 @@ export function onDependsOnOtherQueues(
       // TODO: Use key generator
       retryOn(
         `${type}-${network}:${address}`,
-        context.notifier,
         manager,
         context.canSwitchNetworkTo
       );
@@ -906,9 +956,9 @@ export function isRequiredWalletConnected(
 export function singTransaction(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
 ): void {
-  const { setTransactionDataByHash } = useTransactionsData();
+  const { setTransactionDataByHash } = inMemoryTransactionsData();
   const { getStorage, setStorage, failed, next, schedule, context } = actions;
-  const { meta, getSigners, notifier, isMobileWallet } = context;
+  const { meta, getSigners, isMobileWallet } = context;
   const swap = getStorage().swapDetails;
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const currentStep = getCurrentStep(swap)!;
@@ -929,20 +979,40 @@ export function singTransaction(
   const tx = getCurrentStepTx(currentStep);
   const txType = tx?.type;
   const isApproval = isApprovalCurrentStepTx(currentStep);
-  const isSmartContractCall = [
-    TransactionType.EVM,
-    TransactionType.STARKNET,
-    TransactionType.TRON,
-  ].includes(txType!);
+
+  if (!tx || !txType) {
+    const extraMessage = 'Unexpected Error: tx is null!';
+    const updateResult = updateSwapStatus({
+      getStorage,
+      setStorage,
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: extraMessage,
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+    notifier({
+      event: {
+        type: StepEventType.FAILED,
+        reason: extraMessage,
+        reasonCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      },
+      ...updateResult,
+    });
+    failed();
+    return onFinish();
+  }
+
+  const chainId = meta.blockchains?.[tx.blockChain]?.chainId;
 
   const hasAlreadyProceededToSign =
     typeof swap.hasAlreadyProceededToSign === 'boolean';
 
   let nextStatus: SwapStatus | undefined,
     nextStepStatus: StepStatus,
-    eventType: EventType,
     message: string,
-    details: string;
+    details: string,
+    eventType: StepEventType;
 
   if (isApproval) {
     message = `Waiting for approval of ${currentStep?.fromSymbol} coin ${
@@ -952,21 +1022,19 @@ export function singTransaction(
       'Waiting for approve transaction to be mined and confirmed successfully';
     nextStepStatus = 'waitingForApproval';
     nextStatus = undefined;
-    eventType = 'confirm_approve_contract';
+    eventType = StepEventType.TX_EXECUTION;
   } else if (hasAlreadyProceededToSign) {
     message = 'Transaction is expired. Please try again.';
     nextStepStatus = 'failed';
     nextStatus = 'failed';
     details = '';
-    eventType = 'transaction_expired';
+    eventType = StepEventType.FAILED;
   } else {
     message = 'Executing transaction ...';
     nextStepStatus = 'running';
     nextStatus = 'running';
     details = `${mobileWallet ? 'Check your mobile phone!' : ''}`;
-    eventType = isSmartContractCall
-      ? 'calling_smart_contract'
-      : 'confirm_transfer';
+    eventType = StepEventType.TX_EXECUTION;
   }
 
   const updateResult = updateSwapStatus({
@@ -981,18 +1049,29 @@ export function singTransaction(
       : hasAlreadyProceededToSign,
     errorCode: hasAlreadyProceededToSign ? 'TX_EXPIRED' : undefined,
   });
-  notifier({
-    eventType,
-    ...updateResult,
-  });
+
+  if (eventType === StepEventType.FAILED) {
+    notifier({
+      event: {
+        type: eventType,
+        reason: message,
+        reasonCode: updateResult.failureType ?? DEFAULT_ERROR_CODE,
+      },
+      ...updateResult,
+    });
+  } else
+    notifier({
+      event: { type: eventType, status: StepExecutionEventStatus.SEND_TX },
+      ...updateResult,
+    });
 
   if (hasAlreadyProceededToSign) {
     failed();
     onFinish();
     return;
   }
-  const signer = walletSigners.getSigner(txType!);
-  signer.signAndSendTx(tx!, walletAddress, null).then(
+  const signer = walletSigners.getSigner(txType);
+  signer.signAndSendTx(tx, walletAddress, chainId).then(
     ({ hash, response }) => {
       const explorerUrl = getScannerUrl(
         hash,
@@ -1002,8 +1081,6 @@ export function singTransaction(
       setStepTransactionIds(
         actions,
         hash,
-        notifier,
-        isApproval ? 'check_approve_tx_status' : 'check_tx_status',
         explorerUrl
           ? { url: explorerUrl, description: isApproval ? 'Approve' : 'Swap' }
           : undefined
@@ -1021,13 +1098,7 @@ export function singTransaction(
         prettifyErrorMessage(error);
 
       // if it is an rpc error with details, send the log to sentry
-      if (
-        error &&
-        error?.root &&
-        error?.root?.message &&
-        error?.root?.code &&
-        error?.root?.reason
-      )
+      if (error?.root?.message && error?.root?.code && error?.root?.reason)
         logRPCError(error.root, swap, currentStep, sourceWallet?.walletType);
 
       const updateResult = updateSwapStatus({
@@ -1039,14 +1110,13 @@ export function singTransaction(
         details: extraMessageDetail,
         errorCode: extraMessageErrorCode,
       });
-      const eventType =
-        extraMessageErrorCode === 'REJECTED_BY_USER'
-          ? 'contract_rejected'
-          : isSmartContractCall
-          ? 'smart_contract_call_failed'
-          : 'transfer_failed';
+
       notifier({
-        eventType,
+        event: {
+          type: StepEventType.FAILED,
+          reason: extraMessage,
+          reasonCode: updateResult.failureType ?? DEFAULT_ERROR_CODE,
+        },
         ...updateResult,
       });
       failed();
@@ -1059,7 +1129,6 @@ export function checkWaitingForConnectWalletChange(params: {
   wallet_network: string;
   manager?: Manager;
   evmChains: EvmBlockchainMeta[];
-  notifier: SwapQueueContext['notifier'];
 }): void {
   const { wallet_network, evmChains, manager } = params;
   const [wallet, network] = splitWalletNetwork(wallet_network);
@@ -1088,10 +1157,12 @@ export function checkWaitingForConnectWalletChange(params: {
           }
         );
 
+        const requiredNetwork = getCurrentBlockchainOfOrNull(swap, currentStep);
+
         if (
           currentStepRequiredWallet === wallet &&
           hasWaitingForConnect &&
-          getCurrentBlockchainOfOrNull(swap, currentStep) != network
+          requiredNetwork != network
         ) {
           const queueInstance = q.list;
           const { type } = getRequiredWallet(swap);
@@ -1111,8 +1182,14 @@ export function checkWaitingForConnectWalletChange(params: {
           });
 
           if (result) {
-            params?.notifier({
-              eventType: 'waiting_for_network_change',
+            notifier({
+              event: {
+                type: StepEventType.TX_EXECUTION_BLOCKED,
+                status:
+                  StepExecutionBlockedEventStatus.WAITING_FOR_NETWORK_CHANGE,
+                currentNetwork: network,
+                requiredNetwork: requiredNetwork ?? undefined,
+              },
               swap: result.swap,
               step: result.step,
             });
@@ -1185,21 +1262,26 @@ export function getRunningSwaps(manager: Manager): PendingSwap[] {
  * @param notifier
  * @returns
  */
-export function resetRunningSwapNotifsOnPageLoad(
-  runningSwaps: PendingSwap[],
-  notifier: SwapQueueContext['notifier']
-) {
+export function resetRunningSwapNotifsOnPageLoad(runningSwaps: PendingSwap[]) {
   runningSwaps.forEach((swap) => {
     const currentStep = getCurrentStep(swap);
-    let eventType: EventType | undefined;
+    const eventType = StepEventType.TX_EXECUTION_BLOCKED;
+    let eventSubtype:
+      | StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE
+      | StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT
+      | undefined;
     if (currentStep?.networkStatus === PendingSwapNetworkStatus.WaitingForQueue)
-      eventType = 'waiting_for_queue';
+      eventSubtype = StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE;
     else if (swap?.status === 'running') {
-      eventType = 'waiting_for_connecting_wallet';
+      eventSubtype = StepExecutionBlockedEventStatus.WAITING_FOR_WALLET_CONNECT;
     }
     if (!!eventType && !!notifier) {
       notifier({
-        eventType,
+        event: {
+          type: eventType,
+          status:
+            eventSubtype ?? StepExecutionBlockedEventStatus.WAITING_FOR_QUEUE,
+        },
         swap: swap,
         step: currentStep,
       });
@@ -1220,7 +1302,6 @@ export function resetRunningSwapNotifsOnPageLoad(
  */
 export function retryOn(
   wallet_network: string,
-  notifier: SwapQueueContext['notifier'],
   manager?: Manager,
   canSwitchNetworkTo?: (type: WalletType, network: Network) => boolean,
   options = { fallbackToOnlyWallet: true }
@@ -1269,7 +1350,6 @@ export function retryOn(
         markRunningSwapAsDependsOnOtherQueues({
           getStorage: currentQueue.getStorage.bind(currentQueue),
           setStorage: currentQueue.setStorage.bind(currentQueue),
-          notifier: notifier,
         });
       }
     }
@@ -1277,8 +1357,7 @@ export function retryOn(
     finalQueueToBeRun = onlyWalletMatched[0];
   }
 
-  if (!canSwitchNetworkTo?.(wallet, network as Network))
-    finalQueueToBeRun?.unblock();
+  if (!canSwitchNetworkTo?.(wallet, network)) finalQueueToBeRun?.unblock();
   else finalQueueToBeRun?.checkBlock();
 }
 
@@ -1326,8 +1405,49 @@ export function cancelSwap(
     nextStepStatus: 'failed',
     errorCode: 'USER_CANCEL',
   });
+
+  notifier({
+    event: {
+      type: StepEventType.FAILED,
+      reasonCode: 'USER_CANCEL',
+      reason: updateResult.swap.extraMessage ?? undefined,
+    },
+
+    swap: updateResult.swap,
+    step: updateResult.step,
+  });
+
   reset();
   if (manager) manager?.retry();
 
   return updateResult;
 }
+
+export function getLastSuccessfulStep<T extends { status: StepStatus }[]>(
+  steps: T
+): ArrayElement<T> | undefined {
+  return steps
+    .slice()
+    .reverse()
+    .find((step) => step.status === 'success') as ArrayElement<T> | undefined;
+}
+
+export function getFailedStep<T extends { status: StepStatus }[]>(
+  steps: T
+): ArrayElement<T> | undefined {
+  return steps
+    .slice()
+    .reverse()
+    .find((step) => step.status === 'failed') as ArrayElement<T> | undefined;
+}
+
+export function isApprovalTX(step: Step): boolean {
+  const { transaction } = step;
+  const approvalTx =
+    (transaction?.type === TransactionType.EVM && transaction.isApprovalTx) ||
+    (transaction?.type === TransactionType.STARKNET &&
+      transaction.isApprovalTx) ||
+    (transaction?.type === TransactionType.TRON && transaction.isApprovalTx);
+
+  return approvalTx;
+}

package/src/hooks.ts

@@ -7,6 +7,7 @@ import {
 } from './helpers';
 import { migrated, migration } from './migration';
 import { UseQueueManagerParams } from './types';
+import { eventEmitter } from './services/eventEmitter';
 
 let isCalled = 0;
 
@@ -54,14 +55,8 @@ function useQueueManager(params: UseQueueManagerParams): void {
         evmChains: params.evmChains,
         wallet_network: params.lastConnectedWallet,
         manager,
-        notifier: params.notifier,
       });
-      retryOn(
-        params.lastConnectedWallet,
-        params.notifier,
-        manager,
-        params.canSwitchNetworkTo
-      );
+      retryOn(params.lastConnectedWallet, manager, params.canSwitchNetworkTo);
     }
   }, [params.lastConnectedWallet]);
 
@@ -78,4 +73,8 @@ function useQueueManager(params: UseQueueManagerParams): void {
   }, [params.disconnectedWallet]);
 }
 
-export { useQueueManager, useMigration };
+function useEvents() {
+  return eventEmitter;
+}
+
+export { useQueueManager, useMigration, useEvents };

package/src/index.ts

@@ -3,13 +3,28 @@ import { SwapQueueDef } from './types';
 import { swapQueueDef } from './queueDef';
 
 export { PrettyError, prettifyErrorMessage } from './shared-errors';
-export type { SwapQueueContext, SwapStorage } from './types';
+export type {
+  SwapQueueContext,
+  SwapStorage,
+  RouteExecutionEvents,
+  Route,
+  Step,
+  RouteEvent,
+  StepEvent,
+  EventSeverity,
+} from './types';
+export {
+  MainEvents,
+  StepEventType,
+  RouteEventType,
+  StepExecutionEventStatus,
+  StepExecutionBlockedEventStatus,
+} from './types';
 export type {
   PendingSwapWithQueueID,
   PendingSwapStep,
   PendingSwap,
   EventType,
-  SwapProgressNotification,
 } from './shared';
 export {
   getCurrentBlockchainOfOrNull,
@@ -29,8 +44,9 @@ export {
   getRunningSwaps,
   splitWalletNetwork,
   resetRunningSwapNotifsOnPageLoad,
+  isApprovalTX,
 } from './helpers';
-export { useMigration, useQueueManager } from './hooks';
+export { useMigration, useQueueManager, useEvents } from './hooks';
 
 export function makeQueueDefinition(configs: Configs): SwapQueueDef {
   initConfig(configs);