@ethereansos/interfaces-core 0.4.99 → 0.4.100

package/dist/index.cjs.js

@@ -23086,6 +23086,10 @@ function _createSuper(Derived) {
   };
 }
 
+function _readOnlyError(name) {
+  throw new TypeError("\"" + name + "\" is read-only");
+}
+
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
 }
@@ -64110,6 +64114,335 @@ function _getTokenPriceInDollarsOnUniswapV() {
   return _getTokenPriceInDollarsOnUniswapV.apply(this, arguments);
 }
 
+var tokenPrices = {};
+var tokenPricesPromises = {};
+
+function elaboratePrices(_x, _x2, _x3) {
+  return _elaboratePrices.apply(this, arguments);
+}
+
+function _elaboratePrices() {
+  _elaboratePrices = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref, res, tokens) {
+    var context, web3Data, response, _iterator, _step, token;
+
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            context = _ref.context, web3Data = _ref.web3Data;
+            response = {
+              data: {}
+            };
+            Object.entries(res.data).forEach(function (entry) {
+              return response.data[entry[0]] = entry[1];
+            });
+            tokens = (!(tokens instanceof Array) ? tokens = tokens.split(',') : tokens).map(function (it) {
+              return it.toLowerCase();
+            }).filter(function (it) {
+              return it && it !== VOID_ETHEREUM_ADDRESS && !response.data[it];
+            });
+            _iterator = _createForOfIteratorHelper(tokens);
+            _context.prev = 5;
+
+            _iterator.s();
+
+          case 7:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 36;
+              break;
+            }
+
+            token = _step.value;
+            _context.prev = 9;
+            _context.t0 = getTokenPriceInDollarsOnUniswapV3;
+            _context.t1 = _objectSpread2({
+              context: context
+            }, web3Data);
+            _context.t2 = token;
+            _context.next = 15;
+            return blockchainCall(web3Data.newContract(context.ERC20ABI, token).methods.decimals);
+
+          case 15:
+            _context.t3 = _context.sent;
+            _context.next = 18;
+            return (0, _context.t0)(_context.t1, _context.t2, _context.t3);
+
+          case 18:
+            _context.t4 = _context.sent;
+            response.data[token] = {
+              usd: _context.t4
+            };
+            _context.next = 34;
+            break;
+
+          case 22:
+            _context.prev = 22;
+            _context.t5 = _context["catch"](9);
+            _context.t6 = getTokenPriceInDollarsOnUniswap;
+            _context.t7 = _objectSpread2({
+              context: context
+            }, web3Data);
+            _context.t8 = token;
+            _context.next = 29;
+            return blockchainCall(web3Data.newContract(context.ERC20ABI, token).methods.decimals);
+
+          case 29:
+            _context.t9 = _context.sent;
+            _context.next = 32;
+            return (0, _context.t6)(_context.t7, _context.t8, _context.t9);
+
+          case 32:
+            _context.t10 = _context.sent;
+            response.data[token] = {
+              usd: _context.t10
+            };
+
+          case 34:
+            _context.next = 7;
+            break;
+
+          case 36:
+            _context.next = 41;
+            break;
+
+          case 38:
+            _context.prev = 38;
+            _context.t11 = _context["catch"](5);
+
+            _iterator.e(_context.t11);
+
+          case 41:
+            _context.prev = 41;
+
+            _iterator.f();
+
+            return _context.finish(41);
+
+          case 44:
+            return _context.abrupt("return", response);
+
+          case 45:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[5, 38, 41, 44], [9, 22]]);
+  }));
+  return _elaboratePrices.apply(this, arguments);
+}
+
+function getTokenPricesInDollarsOnCoingecko(_x4, _x5) {
+  return _getTokenPricesInDollarsOnCoingecko.apply(this, arguments);
+}
+
+function _getTokenPricesInDollarsOnCoingecko() {
+  _getTokenPricesInDollarsOnCoingecko = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(_ref2, t) {
+    var context, web3Data, tokens, response, tkns, _iterator2, _step2, token, prom, _i, _tkns, _i2, _tkns2, _iterator3, _step3;
+
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            context = _ref2.context, web3Data = _ref2.web3Data;
+            tokens = (!(t instanceof Array) ? t = t.split(',') : t).map(function (it) {
+              return it.toLowerCase();
+            });
+            response = {
+              data: {}
+            };
+            _readOnlyError("tokenPrices");
+            _readOnlyError("tokenPricesPromises");
+            tkns = [];
+            _iterator2 = _createForOfIteratorHelper(tokens);
+            _context3.prev = 7;
+
+            _iterator2.s();
+
+          case 9:
+            if ((_step2 = _iterator2.n()).done) {
+              _context3.next = 31;
+              break;
+            }
+
+            token = _step2.value;
+
+            if (!(!token || token === VOID_ETHEREUM_ADDRESS)) {
+              _context3.next = 16;
+              break;
+            }
+
+            _context3.next = 14;
+            return getEthereumPrice({
+              context: context
+            });
+
+          case 14:
+            response.data[token] = _context3.sent;
+            return _context3.abrupt("continue", 29);
+
+          case 16:
+            if (!(tokenPrices[token] && tokenPrices[token].requestExpires > new Date().getTime() && tokenPrices[token].price !== 0)) {
+              _context3.next = 20;
+              break;
+            }
+
+            response.data[token] = {
+              usd: tokenPrices[token].price
+            };
+            _context3.next = 29;
+            break;
+
+          case 20:
+            if (!tokenPricesPromises[token]) {
+              _context3.next = 28;
+              break;
+            }
+
+            _context3.next = 23;
+            return tokenPricesPromises[token];
+
+          case 23:
+            _context3.t0 = token;
+            _context3.t1 = _context3.sent.data[_context3.t0].usd;
+            response.data[token] = {
+              usd: _context3.t1
+            };
+            _context3.next = 29;
+            break;
+
+          case 28:
+            tkns.push(token);
+
+          case 29:
+            _context3.next = 9;
+            break;
+
+          case 31:
+            _context3.next = 36;
+            break;
+
+          case 33:
+            _context3.prev = 33;
+            _context3.t2 = _context3["catch"](7);
+
+            _iterator2.e(_context3.t2);
+
+          case 36:
+            _context3.prev = 36;
+
+            _iterator2.f();
+
+            return _context3.finish(36);
+
+          case 39:
+            prom = /*#__PURE__*/function () {
+              var _ref3 = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(t1, t2) {
+                var res;
+                return regeneratorRuntime.wrap(function _callee2$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        res = {
+                          data: {}
+                        };
+                        _context2.prev = 1;
+                        _context2.t0 = t1.length > 0;
+
+                        if (!_context2.t0) {
+                          _context2.next = 9;
+                          break;
+                        }
+
+                        _context2.next = 6;
+                        return fetch(context.coingeckoCoinPriceURL + t1.join(','));
+
+                      case 6:
+                        _context2.next = 8;
+                        return _context2.sent.json();
+
+                      case 8:
+                        res.data = _context2.sent;
+
+                      case 9:
+                        _context2.next = 13;
+                        break;
+
+                      case 11:
+                        _context2.prev = 11;
+                        _context2.t1 = _context2["catch"](1);
+
+                      case 13:
+                        _context2.next = 15;
+                        return elaboratePrices({
+                          context: context,
+                          web3Data: web3Data
+                        }, res, t2);
+
+                      case 15:
+                        return _context2.abrupt("return", _context2.sent);
+
+                      case 16:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee2, null, [[1, 11]]);
+              }));
+
+              return function prom(_x6, _x7) {
+                return _ref3.apply(this, arguments);
+              };
+            }();
+
+            prom = prom(tkns, t);
+
+            for (_i = 0, _tkns = tkns; _i < _tkns.length; _i++) {
+              token = _tkns[_i];
+              tokenPricesPromises[token] = prom;
+            }
+
+            _context3.next = 44;
+            return prom;
+
+          case 44:
+            prom = _context3.sent;
+            Object.entries(prom.data).forEach(function (it) {
+              return response.data[it[0]] = it[1];
+            });
+
+            for (_i2 = 0, _tkns2 = tkns; _i2 < _tkns2.length; _i2++) {
+              token = _tkns2[_i2];
+              tokenPrices[token] = {
+                requestExpires: new Date().getTime() + context.coingeckoEthereumPriceRequestInterval,
+                price: response.data[token].usd
+              };
+            }
+
+            _iterator3 = _createForOfIteratorHelper(tokens);
+
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                token = _step3.value;
+                delete tokenPricesPromises[token];
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+
+            return _context3.abrupt("return", response);
+
+          case 50:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[7, 33, 36, 39]]);
+  }));
+  return _getTokenPricesInDollarsOnCoingecko.apply(this, arguments);
+}
+
 function op(a, operator, b) {
   var operations = {
     '+': 'add',
@@ -64656,6 +64989,7 @@ exports.getSolidityUtilities = SolidityUtilities;
 exports.getSupportedSolidityVersion = getSupportedSolidityVersion;
 exports.getTokenPriceInDollarsOnUniswap = getTokenPriceInDollarsOnUniswap;
 exports.getTokenPriceInDollarsOnUniswapV3 = getTokenPriceInDollarsOnUniswapV3;
+exports.getTokenPricesInDollarsOnCoingecko = getTokenPricesInDollarsOnCoingecko;
 exports.hasEthereumAddress = hasEthereumAddress;
 exports.isEthereumAddress = isEthereumAddress;
 exports.isSorted = isSorted;