@ethereansos/interfaces-core 0.4.126 → 0.4.129

package/dist/index.esm.js

@@ -23746,55 +23746,96 @@ var URL_REGEXP = new RegExp('(http://www.|https://www.|http://|https://)?[a-z0-9
 var solidityImportRule = new RegExp('import( )+"(\\d+)"( )*;', 'gs');
 var pragmaSolidityRule = new RegExp('pragma( )+solidity( )*(\\^|>)\\d+.\\d+.\\d+;', 'gs');
 
-var instrumentedProviders = {};
+var instrumentedProviders = [];
+var instrumentableMethods = ['eth_call', 'eth_getLogs'];
 
-function sendAsync(_x, _x2) {
-  return _sendAsync.apply(this, arguments);
+function instrumentProvider(_x, _x2) {
+  return _instrumentProvider.apply(this, arguments);
 }
 
-function _sendAsync() {
-  _sendAsync = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(inputProvider, method) {
-    var provider,
-        chainId,
-        _ref,
-        chainProvider,
-        params,
-        _args2 = arguments;
+function _instrumentProvider() {
+  _instrumentProvider = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(provider, method) {
+    var entry, chainId, _ref, chainProvider;
 
-    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+    return regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context.prev = _context.next) {
           case 0:
-            provider = inputProvider;
+            if (!(instrumentableMethods.indexOf(method) === -1)) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return", provider);
+
+          case 2:
+            entry = instrumentedProviders.filter(function (it) {
+              return it.provider === provider;
+            })[0];
 
-            if (!(method !== 'eth_chainId')) {
-              _context2.next = 9;
+            if (!entry) {
+              _context.next = 5;
               break;
             }
 
-            _context2.t0 = parseInt;
-            _context2.next = 5;
-            return sendAsync(provider, 'eth_chainId');
+            return _context.abrupt("return", entry.instrumentedProvider);
 
           case 5:
-            _context2.t1 = _context2.sent;
-            chainId = (0, _context2.t0)(_context2.t1);
+            _context.t0 = parseInt;
+            _context.next = 8;
+            return sendAsync(provider, 'eth_chainId');
+
+          case 8:
+            _context.t1 = _context.sent;
+            chainId = (0, _context.t0)(_context.t1);
+            instrumentedProviders.push(entry = {
+              chainId: chainId,
+              provider: provider,
+              instrumentedProvider: provider
+            });
             _ref = sendAsync.context || {
               chainProvider: {}
             }, chainProvider = _ref.chainProvider;
-            provider = chainId !== 1 && chainProvider[chainId] ? instrumentedProviders[chainId] = instrumentedProviders[chainId] || new Web3.providers.HttpProvider(chainProvider[chainId]) : provider;
+            return _context.abrupt("return", entry.instrumentedProvider = chainId !== 1 && chainProvider[chainId] ? new Web3.providers.HttpProvider(chainProvider[chainId]) : provider);
 
-          case 9:
-            params = Array.prototype.slice.call(_args2).slice(2) || [];
-            _context2.next = 12;
+          case 13:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _instrumentProvider.apply(this, arguments);
+}
+
+function sendAsync(_x3, _x4) {
+  return _sendAsync.apply(this, arguments);
+}
+
+function _sendAsync() {
+  _sendAsync = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(inputProvider, method) {
+    var provider,
+        params,
+        _args3 = arguments;
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return instrumentProvider(inputProvider);
+
+          case 2:
+            provider = _context3.sent;
+            params = Array.prototype.slice.call(_args3).slice(2) || [];
+            _context3.next = 6;
             return new Promise( /*#__PURE__*/function () {
-              var _ref2 = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(ok, ko) {
-                return regeneratorRuntime.wrap(function _callee$(_context) {
+              var _ref2 = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(ok, ko) {
+                return regeneratorRuntime.wrap(function _callee2$(_context2) {
                   while (1) {
-                    switch (_context.prev = _context.next) {
+                    switch (_context2.prev = _context2.next) {
                       case 0:
-                        _context.prev = 0;
-                        _context.next = 3;
+                        _context2.prev = 0;
+                        _context2.next = 3;
                         return (provider.sendAsync || provider.send).call(provider, {
                           jsonrpc: '2.0',
                           method: method,
@@ -23805,36 +23846,36 @@ function _sendAsync() {
                         });
 
                       case 3:
-                        _context.next = 8;
+                        _context2.next = 8;
                         break;
 
                       case 5:
-                        _context.prev = 5;
-                        _context.t0 = _context["catch"](0);
-                        return _context.abrupt("return", ko(_context.t0));
+                        _context2.prev = 5;
+                        _context2.t0 = _context2["catch"](0);
+                        return _context2.abrupt("return", ko(_context2.t0));
 
                       case 8:
                       case "end":
-                        return _context.stop();
+                        return _context2.stop();
                     }
                   }
-                }, _callee, null, [[0, 5]]);
+                }, _callee2, null, [[0, 5]]);
               }));
 
-              return function (_x3, _x4) {
+              return function (_x5, _x6) {
                 return _ref2.apply(this, arguments);
               };
             }());
 
-          case 12:
-            return _context2.abrupt("return", _context2.sent);
+          case 6:
+            return _context3.abrupt("return", _context3.sent);
 
-          case 13:
+          case 7:
           case "end":
-            return _context2.stop();
+            return _context3.stop();
         }
       }
-    }, _callee2);
+    }, _callee3);
   }));
   return _sendAsync.apply(this, arguments);
 }