@ethereansos/interfaces-core 0.4.133 → 0.4.137

package/dist/index.cjs.js

@@ -23766,22 +23766,18 @@ function instrumentProvider(_x, _x2) {
 
 function _instrumentProvider() {
   _instrumentProvider = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(provider, method) {
-    var _instrumentableMethod2;
-
-    var instrumentableMethods, _instrumentableMethod, entry, chainId, _ref, chainProvider;
+    var instrumentableMethods, entry, chainId, _ref, chainProvider;
 
     return regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            instrumentableMethods = [];
+            instrumentableMethods = [].concat(defaultInstrumentableMethods);
 
             try {
-              (_instrumentableMethod = instrumentableMethods).push.apply(_instrumentableMethod, _toConsumableArray(sendAsync.context.providerInstrumentableMethods || []));
+              instrumentableMethods = _toConsumableArray(sendAsync.context.providerInstrumentableMethods || defaultInstrumentableMethods);
             } catch (e) {}
 
-            (_instrumentableMethod2 = instrumentableMethods).push.apply(_instrumentableMethod2, defaultInstrumentableMethods);
-
             instrumentableMethods = instrumentableMethods.map(function (it) {
               return it.toLowerCase();
             }).filter(function (it, i, arr) {
@@ -23789,30 +23785,30 @@ function _instrumentProvider() {
             });
 
             if (!(instrumentableMethods.indexOf(method.toLowerCase()) === -1)) {
-              _context.next = 6;
+              _context.next = 5;
               break;
             }
 
             return _context.abrupt("return", provider);
 
-          case 6:
+          case 5:
             entry = sendAsync.instrumentedProviders.filter(function (it) {
               return it.provider === provider;
             })[0];
 
             if (!entry) {
-              _context.next = 9;
+              _context.next = 8;
               break;
             }
 
             return _context.abrupt("return", entry.instrumentedProvider);
 
-          case 9:
+          case 8:
             _context.t0 = parseInt;
-            _context.next = 12;
+            _context.next = 11;
             return sendAsync(provider, 'eth_chainId');
 
-          case 12:
+          case 11:
             _context.t1 = _context.sent;
             chainId = (0, _context.t0)(_context.t1);
             entry = {
@@ -23826,7 +23822,7 @@ function _instrumentProvider() {
             }, chainProvider = _ref.chainProvider;
             return _context.abrupt("return", entry.instrumentedProvider = chainId !== 1 && chainProvider[chainId] ? new Web3__default["default"].providers.HttpProvider(chainProvider[chainId]) : provider);
 
-          case 18:
+          case 17:
           case "end":
             return _context.stop();
         }
@@ -23836,26 +23832,17 @@ function _instrumentProvider() {
   return _instrumentProvider.apply(this, arguments);
 }
 
-function sendAsync(_x3, _x4) {
-  return _sendAsync.apply(this, arguments);
+function sendAsyncInternal(_x3, _x4, _x5) {
+  return _sendAsyncInternal.apply(this, arguments);
 }
 
-function _sendAsync() {
-  _sendAsync = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(inputProvider, method) {
-    var provider,
-        params,
-        _args3 = arguments;
+function _sendAsyncInternal() {
+  _sendAsyncInternal = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(provider, method, params) {
     return regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
             _context3.next = 2;
-            return instrumentProvider(inputProvider, method);
-
-          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 _callee2(ok, ko) {
                 return regeneratorRuntime.wrap(function _callee2$(_context2) {
@@ -23890,21 +23877,75 @@ function _sendAsync() {
                 }, _callee2, null, [[0, 5]]);
               }));
 
-              return function (_x5, _x6) {
+              return function (_x8, _x9) {
                 return _ref2.apply(this, arguments);
               };
             }());
 
-          case 6:
+          case 2:
             return _context3.abrupt("return", _context3.sent);
 
-          case 7:
+          case 3:
           case "end":
             return _context3.stop();
         }
       }
     }, _callee3);
   }));
+  return _sendAsyncInternal.apply(this, arguments);
+}
+
+function sendAsync(_x6, _x7) {
+  return _sendAsync.apply(this, arguments);
+}
+
+function _sendAsync() {
+  _sendAsync = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(provider, method) {
+    var params,
+        instrumentedProvider,
+        _args4 = arguments;
+    return regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            params = Array.prototype.slice.call(_args4).slice(2) || [];
+            _context4.prev = 1;
+            _context4.next = 4;
+            return sendAsyncInternal(provider, method, params);
+
+          case 4:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](1);
+            _context4.next = 11;
+            return instrumentProvider(provider, method);
+
+          case 11:
+            instrumentedProvider = _context4.sent;
+
+            if (!(provider === instrumentedProvider)) {
+              _context4.next = 14;
+              break;
+            }
+
+            throw _context4.t0;
+
+          case 14:
+            _context4.next = 16;
+            return sendAsyncInternal(instrumentedProvider, method, params);
+
+          case 16:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 17:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[1, 7]]);
+  }));
   return _sendAsync.apply(this, arguments);
 }