@rango-dev/queue-manager-rango-preset 0.1.10-next.82 → 0.1.10-next.85

package/dist/queue-manager-rango-preset.esm.js

@@ -1,9 +1,12 @@
-import { WalletType, getBlockChainNameFromId, Network } from '@rango-dev/wallets-shared';
+import { WalletType, Network, getBlockChainNameFromId } from '@rango-dev/wallets-shared';
 import { readAccountAddress } from '@rango-dev/wallets-core';
 import { RangoClient, TransactionType } from 'rango-sdk';
-import { Status } from '@rango-dev/queue-manager-core';
+import { Status, Persistor } from '@rango-dev/queue-manager-core';
 import { isSignerErrorCode, SignerErrorCode, SignerError } from 'rango-types';
 import { captureException } from '@sentry/browser';
+import { useManager } from '@rango-dev/queue-manager-react';
+import { useState, useEffect } from 'react';
+import { v4 } from 'uuid';
 
 var SwapActionTypes;
 (function (SwapActionTypes) {
@@ -1732,6 +1735,76 @@ function singTransaction(actions) {
     });
   }
 }
+function checkWaitingForConnectWalletChange(params) {
+  var wallet_network = params.wallet_network,
+    evmChains = params.evmChains,
+    manager = params.manager;
+  var _wallet_network$split = wallet_network.split('-'),
+    wallet = _wallet_network$split[0],
+    network = _wallet_network$split[1];
+  // We only need change network for EVM chains.
+  if (!evmChains.some(function (chain) {
+    return chain.name == network;
+  })) return;
+  manager == null ? void 0 : manager.getAll().forEach(function (q) {
+    var queueStorage = q.list.getStorage();
+    var swap = queueStorage == null ? void 0 : queueStorage.swapDetails;
+    if (swap) {
+      var currentStep = getCurrentStep(swap);
+      if (currentStep) {
+        var _queueStorage$swapDet;
+        var currentStepRequiredWallet = queueStorage == null ? void 0 : (_queueStorage$swapDet = queueStorage.swapDetails.wallets[currentStep.fromBlockchain]) == null ? void 0 : _queueStorage$swapDet.walletType;
+        var hasWaitingForConnect = Object.keys(q.list.state.tasks).some(function (taskId) {
+          var _task$blockedFor;
+          var task = q.list.state.tasks[taskId];
+          return task.status === Status.BLOCKED && [BlockReason.WAIT_FOR_CONNECT_WALLET].includes((_task$blockedFor = task.blockedFor) == null ? void 0 : _task$blockedFor.reason);
+        });
+        if (currentStepRequiredWallet === wallet && hasWaitingForConnect) {
+          var _queueInstance$getSto;
+          var queueInstance = q.list;
+          var _swap = (_queueInstance$getSto = queueInstance.getStorage()) == null ? void 0 : _queueInstance$getSto.swapDetails;
+          var _getRequiredWallet5 = getRequiredWallet(_swap),
+            type = _getRequiredWallet5.type;
+          var description = ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK(type);
+          q.list.block({
+            reason: {
+              reason: BlockReason.WAIT_FOR_NETWORK_CHANGE,
+              description: description
+            },
+            silent: true
+          });
+          markRunningSwapAsSwitchingNetwork({
+            getStorage: queueInstance.getStorage.bind(queueInstance),
+            setStorage: queueInstance.setStorage.bind(queueInstance)
+          });
+        }
+      }
+    }
+  });
+}
+function checkWaitingForNetworkChange(manager) {
+  manager == null ? void 0 : manager.getAll().forEach(function (q) {
+    var hasWaitingForNetwork = Object.keys(q.list.state.tasks).some(function (taskId) {
+      var _task$blockedFor2;
+      var task = q.list.state.tasks[taskId];
+      return task.status === Status.BLOCKED && [BlockReason.WAIT_FOR_NETWORK_CHANGE, BlockReason.DEPENDS_ON_OTHER_QUEUES].includes((_task$blockedFor2 = task.blockedFor) == null ? void 0 : _task$blockedFor2.reason);
+    });
+    if (hasWaitingForNetwork) {
+      var _q$list$getStorage;
+      var swap = (_q$list$getStorage = q.list.getStorage()) == null ? void 0 : _q$list$getStorage.swapDetails;
+      var _getRequiredWallet6 = getRequiredWallet(swap),
+        type = _getRequiredWallet6.type;
+      var description = ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(type);
+      // Change the block reason to waiting for connecting wallet
+      q.list.block({
+        reason: {
+          reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+          description: description
+        }
+      });
+    }
+  });
+}
 /**
  *
  * Try to run blocked tasks by wallet and network name.
@@ -2276,6 +2349,183 @@ function start(_ref) {
   next();
 }
 
+var MIGRATED_KEY = 'migratedToQueueManager';
+/**
+ *
+ * If `MIGRATED_KEY` is set, it means we already migrated data from localstorage.
+ *
+ */
+function migrated() {
+  return !!window.localStorage.getItem(MIGRATED_KEY);
+}
+/**
+ *
+ * By calling this function, we first check if the data already migrated or not,
+ * If not, starting to migrating to IndexedDb with proper format that queue manager is understand.
+ *
+ */
+function migration() {
+  return _migration.apply(this, arguments);
+}
+function _migration() {
+  _migration = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var swapsFromStorage, swaps, convertedSwaps, persistor, promises;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          swapsFromStorage = window.localStorage.getItem('pendingSwaps'); // For new users or already migrated.
+          if (!(!swapsFromStorage || migrated())) {
+            _context.next = 3;
+            break;
+          }
+          return _context.abrupt("return", true);
+        case 3:
+          // For old users, but they didn't do any swaps yet.
+          swaps = JSON.parse(swapsFromStorage);
+          convertedSwaps = [];
+          swaps.forEach(function (swap) {
+            /*
+              For running task we need to add some more work
+              We need to create a queue task to be run and resume the running task from queue manager.
+             */
+            if (swap.status === 'running') {
+              var _tasks;
+              var taskId = v4();
+              var convertedSwap = {
+                id: v4(),
+                createdAt: Number(swap.creationTime),
+                name: 'swap',
+                status: Status.RUNNING,
+                storage: {
+                  swapDetails: swap
+                },
+                state: {
+                  status: Status.RUNNING,
+                  activeTaskIndex: 0,
+                  tasks: (_tasks = {}, _tasks[taskId] = {
+                    blockedFor: null,
+                    status: Status.RUNNING
+                  }, _tasks)
+                },
+                tasks: [{
+                  id: taskId,
+                  action: SwapActionTypes.SCHEDULE_NEXT_STEP
+                }]
+              };
+              convertedSwaps.push(convertedSwap);
+            } else {
+              /*
+               * For failed or successful swaps, we only move it to IndexedDB,
+               * And there is no need to consider them to be run.
+               */
+              var status = swap.status === 'success' ? Status.SUCCESS : Status.FAILED;
+              var _convertedSwap = {
+                id: v4(),
+                createdAt: Number(swap.creationTime),
+                name: 'swap',
+                status: status,
+                storage: {
+                  swapDetails: swap
+                },
+                state: {
+                  status: status,
+                  activeTaskIndex: 0,
+                  tasks: {}
+                },
+                tasks: []
+              };
+              convertedSwaps.push(_convertedSwap);
+            }
+          });
+          // Getting an instance from persistor, so we can directly put our data inside it.
+          persistor = new Persistor();
+          promises = convertedSwaps.map(function (queue) {
+            return persistor.insertQueue(queue);
+          });
+          _context.next = 10;
+          return Promise.all(promises);
+        case 10:
+          // Mark as the data has been successfully migrated.
+          window.localStorage.setItem(MIGRATED_KEY, '1');
+          return _context.abrupt("return", true);
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _migration.apply(this, arguments);
+}
+
+var isCalled = 0;
+/**
+ *
+ * Runs a migration (old swaps from localstorage to queue manager's IndexedDB)
+ * It will be run only once on page load.
+ *
+ */
+function useMigration() {
+  var isMigrated = migrated();
+  var _useState = useState(isMigrated),
+    status = _useState[0],
+    setStatus = _useState[1];
+  useEffect(function () {
+    _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!isCalled) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return");
+          case 2:
+            isCalled = 1;
+            migration()["finally"](function () {
+              setStatus(true);
+            });
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  }, []);
+  return {
+    status: status
+  };
+}
+/**
+ *
+ * On initial load and also connect/disconnet we may need to update swap's notified message.
+ * And also if a new wallet is connected we will retry the queue to see we can resume it or not.
+ *
+ */
+function useQueueManager(params) {
+  var _useManager = useManager(),
+    manager = _useManager.manager;
+  useEffect(function () {
+    if (params.lastConnectedWallet) {
+      checkWaitingForConnectWalletChange({
+        evmChains: params.evmChains,
+        wallet_network: params.lastConnectedWallet,
+        manager: manager
+      });
+      retryOn(params.lastConnectedWallet, manager);
+    }
+  }, [params.lastConnectedWallet]);
+  useEffect(function () {
+    if (params.disconnectedWallet) {
+      checkWaitingForNetworkChange(manager);
+      /*
+        We need to reset the state value, so if a wallet disconnected twice (after reconnect),
+        this effect will be run properly.
+      */
+      params.clearDisconnectedWallet();
+    }
+  }, [params.disconnectedWallet]);
+}
+
 var _actions;
 /**
  *
@@ -2299,5 +2549,5 @@ var swapQueueDef = {
   }
 };
 
-export { swapQueueDef };
+export { checkWaitingForNetworkChange, getCurrentStep, getEvmProvider, getRelatedWallet$1 as getRelatedWallet, swapQueueDef, updateSwapStatus, useMigration, useQueueManager };
 //# sourceMappingURL=queue-manager-rango-preset.esm.js.map