@ethereansos/interfaces-core 0.4.109 → 0.4.112

package/dist/index.cjs.js

@@ -48779,51 +48779,6 @@ var useEthosContext = function useEthosContext() {
 var Web3Context = /*#__PURE__*/React__default["default"].createContext('web3');
 var DEFAULT_BLOCK_INTERVAL = 15;
 var DEFAULT_BLOCK_INTERVAL_TIMEOUT = 40000;
-
-var chains = require('use-wallet').chains;
-/**
- * WRAP CHAINS START
- **/
-
-
-var ETH = chains.getChainInformation(1).nativeCurrency;
-var WRAPPED_CHAINS = {
-  10: {
-    id: 10,
-    nativeCurrency: ETH,
-    type: 'main',
-    fullName: 'Optimism Mainnet',
-    shortName: 'Optimism',
-    explorerUrl: 'https://optimistic.etherscan.io',
-    testnet: false
-  }
-};
-
-function wrap(methodName, funct, force) {
-  var oldFunction = chains[methodName];
-
-  chains[methodName] = function (chainId) {
-    var args = [].concat(Array.prototype.slice.call(arguments), [oldFunction]);
-    return (WRAPPED_CHAINS[parseInt(chainId)] || force ? funct : oldFunction).apply(chains, args);
-  };
-}
-
-wrap('isKnownChain', function () {
-  return true;
-});
-wrap('getChainInformation', function (chainId) {
-  return WRAPPED_CHAINS[parseInt(chainId)];
-});
-wrap('getKnownChainsIds', function (oldFunction) {
-  return [].concat(_toConsumableArray(oldFunction()), _toConsumableArray(Object.keys(WRAPPED_CHAINS)));
-});
-wrap('getKnownChainInformation', function (oldFunction) {
-  return [].concat(_toConsumableArray(oldFunction()), _toConsumableArray(Object.values(WRAPPED_CHAINS)));
-});
-/**
- * WRAP CHAINS END
- **/
-
 var web3States = {
   NOT_CONNECTED: NOT_CONNECTED,
   CONNECTED: CONNECTED,
@@ -48899,103 +48854,79 @@ var Web3ContextInitializer = function Web3ContextInitializer(_ref) {
       block = _useState18[0],
       setBlock = _useState18[1];
 
+  var _useState19 = React.useState(null),
+      _useState20 = _slicedToArray(_useState19, 2),
+      dualChainId = _useState20[0],
+      setDualChainId = _useState20[1];
+
+  var _useState21 = React.useState(0),
+      _useState22 = _slicedToArray(_useState21, 2),
+      dualBlock = _useState22[0],
+      setDualBlock = _useState22[1];
+
+  var _useState23 = React.useState(null),
+      _useState24 = _slicedToArray(_useState23, 2),
+      dualProvider = _useState24[0],
+      setDualProvider = _useState24[1];
+
   React.useEffect(function () {
     setIpfsHttpClient(ipfsHttpClient.create(context.ipfsHost));
   }, [context]);
-
-  function tryUpdateBlock(_x) {
-    return _tryUpdateBlock.apply(this, arguments);
-  }
-
-  function _tryUpdateBlock() {
-    _tryUpdateBlock = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(force) {
-      var currentBlock, currentBlockNumber;
-      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+  var tryUpdateBlock = React.useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(provider, oldValue, setter, force) {
+      var currentBlockNumber;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
-              _context2.prev = 0;
-              _context2.next = 3;
-              return sendAsync(wallet.ethereum, 'eth_getBlockByNumber', 'latest', true);
-
-            case 3:
-              currentBlock = _context2.sent;
-              currentBlockNumber = parseInt(currentBlock.number);
-
-              if (force === true || currentBlockNumber - block >= realBlockInterval) {
-                setBlock(currentBlockNumber);
+              if (!provider) {
+                setter(0);
               }
 
-              _context2.next = 10;
-              break;
-
-            case 8:
-              _context2.prev = 8;
-              _context2.t0 = _context2["catch"](0);
-
-            case 10:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, _callee2, null, [[0, 8]]);
-    }));
-    return _tryUpdateBlock.apply(this, arguments);
-  }
+              _context.prev = 1;
+              _context.t0 = parseInt;
+              _context.next = 5;
+              return sendAsync(provider, 'eth_blockNumber');
 
-  window.updateAccount = /*#__PURE__*/function () {
-    var _updateAccount = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(acc) {
-      return regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              delete window.account;
-              acc && (window.account = acc);
-              _context.prev = 2;
-              _context.t0 = acc && window.ganache;
+            case 5:
+              _context.t1 = _context.sent;
+              currentBlockNumber = (0, _context.t0)(_context.t1);
 
-              if (!_context.t0) {
-                _context.next = 7;
-                break;
+              if (force === true || currentBlockNumber - oldValue >= realBlockInterval) {
+                setter(currentBlockNumber);
               }
 
-              _context.next = 7;
-              return sendAsync(window.ganache, 'evm_addAccount', acc, 0);
-
-            case 7:
-              _context.next = 11;
+              _context.next = 12;
               break;
 
-            case 9:
-              _context.prev = 9;
-              _context.t1 = _context["catch"](2);
-
-            case 11:
-              setBlock(new Date().getTime());
-              setTimeout(resetBlockInterval);
+            case 10:
+              _context.prev = 10;
+              _context.t2 = _context["catch"](1);
 
-            case 13:
+            case 12:
             case "end":
               return _context.stop();
           }
         }
-      }, _callee, null, [[2, 9]]);
+      }, _callee, null, [[1, 10]]);
     }));
 
-    function updateAccount(_x2) {
-      return _updateAccount.apply(this, arguments);
-    }
-
-    return updateAccount;
-  }();
-
-  function resetBlockInterval() {
+    return function (_x, _x2, _x3, _x4) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [realBlockInterval]);
+  var resetBlockInterval = React.useCallback(function () {
     intervalId && clearInterval(intervalId);
-    wallet && wallet.ethereum && tryUpdateBlock(true);
-    wallet && wallet.ethereum && setIntervalId(setInterval(tryUpdateBlock, realBlockIntervalTimeout));
-  }
-
-  React.useEffect(resetBlockInterval, [realBlockInterval, realBlockIntervalTimeout, wallet && wallet.ethereum]);
+    tryUpdateBlock(wallet === null || wallet === void 0 ? void 0 : wallet.ethereum, block, setBlock, true);
+    tryUpdateBlock(dualProvider, dualBlock, setDualBlock, true);
+    wallet && wallet.ethereum && setIntervalId(setInterval(function () {
+      return tryUpdateBlock(wallet.ethereum, block, setBlock);
+    }, realBlockIntervalTimeout));
+    dualProvider && setIntervalId(setInterval(function () {
+      return tryUpdateBlock(dualProvider, dualBlock, setDualBlock);
+    }, realBlockIntervalTimeout));
+  }, [wallet, dualProvider, realBlockIntervalTimeout, intervalId]);
+  React.useEffect(resetBlockInterval, [realBlockInterval, realBlockIntervalTimeout, wallet && wallet.ethereum, dualProvider]);
   React.useEffect(function () {
     setConnectionStatus(wallet && wallet.ethereum ? CONNECTED : connectionStatus === CONNECTING ? CONNECTING : NOT_CONNECTED);
     setWeb3Instance(wallet && wallet.ethereum && (web3Instance || new Web3__default["default"](wallet.ethereum)) || null);
@@ -49003,7 +48934,11 @@ var Web3ContextInitializer = function Web3ContextInitializer(_ref) {
   React.useEffect(function () {
     setContracts({});
     setGlobalContracts(globalContractNames.map(newContractByName));
-    setChainId(wallet && wallet.chainId || null);
+    var actualChainId = wallet && wallet.chainId || null;
+    setChainId(actualChainId);
+    var actualDualChainId = actualChainId && context.dualChainId[actualChainId] || null;
+    setDualChainId(actualDualChainId);
+    setDualProvider(actualDualChainId && new Web3__default["default"].providers.HttpProvider(context.chainProvider[actualDualChainId]) || null);
     resetBlockInterval();
   }, [wallet && wallet.chainId]);
 
@@ -49059,6 +48994,53 @@ var Web3ContextInitializer = function Web3ContextInitializer(_ref) {
     return globalContracts[index];
   };
 
+  window.setAccount = /*#__PURE__*/function () {
+    var _setAccount = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(acc) {
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              delete window.account;
+              acc && (window.account = acc);
+              _context2.prev = 2;
+              _context2.t0 = acc && window.ganache;
+
+              if (!_context2.t0) {
+                _context2.next = 7;
+                break;
+              }
+
+              _context2.next = 7;
+              return sendAsync(window.ganache, 'evm_addAccount', acc, 0);
+
+            case 7:
+              _context2.next = 11;
+              break;
+
+            case 9:
+              _context2.prev = 9;
+              _context2.t1 = _context2["catch"](2);
+
+            case 11:
+              setBlock(new Date().getTime());
+              setDualBlock(new Date().getTime());
+              setTimeout(resetBlockInterval);
+
+            case 14:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[2, 9]]);
+    }));
+
+    function setAccount(_x5) {
+      return _setAccount.apply(this, arguments);
+    }
+
+    return setAccount;
+  }();
+
   var value = _objectSpread2(_objectSpread2({
     connectionStatus: connectionStatus,
     setConnector: setConnector,
@@ -49077,7 +49059,10 @@ var Web3ContextInitializer = function Web3ContextInitializer(_ref) {
     web3: web3Instance,
     block: block,
     getGlobalContract: getGlobalContract,
-    newContract: newContract
+    newContract: newContract,
+    dualChainId: dualChainId,
+    dualBlock: dualBlock,
+    dualProvider: dualProvider
   }), wallet && wallet.error && {
     errorMessage: wallet.error.message
   });