@chain-registry/client 1.19.2 → 1.20.0

package/main/client.js

@@ -0,0 +1,277 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainRegistryClient = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _bfsPath = require("bfs-path");
+var _utils = require("@chain-registry/utils");
+var _utils2 = require("./utils");
+var DEFAULT_BASE_URL = 'https://raw.githubusercontent.com/cosmos/chain-registry/master';
+var ChainRegistryClient = /*#__PURE__*/function () {
+  function ChainRegistryClient() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    (0, _classCallCheck2["default"])(this, ChainRegistryClient);
+    (0, _defineProperty2["default"])(this, "_allUrls", []);
+    (0, _defineProperty2["default"])(this, "_baseUrl", DEFAULT_BASE_URL);
+    (0, _defineProperty2["default"])(this, "_chainNames", []);
+    (0, _defineProperty2["default"])(this, "_notFoundUrls", []);
+    (0, _defineProperty2["default"])(this, "_chains", []);
+    (0, _defineProperty2["default"])(this, "_assetLists", []);
+    (0, _defineProperty2["default"])(this, "_ibcInfo", []);
+    var urls = options.urls,
+      chainNames = options.chainNames,
+      baseUrl = options.baseUrl;
+    this._baseUrl = baseUrl !== null && baseUrl !== void 0 ? baseUrl : this._baseUrl;
+    this._allUrls = this.generateUrls({
+      urls: urls,
+      chainNames: chainNames
+    });
+  }
+  (0, _createClass2["default"])(ChainRegistryClient, [{
+    key: "urls",
+    get: function get() {
+      return this._allUrls;
+    }
+  }, {
+    key: "chains",
+    get: function get() {
+      return this._chains;
+    }
+  }, {
+    key: "assetLists",
+    get: function get() {
+      return this._assetLists;
+    }
+  }, {
+    key: "ibcInfo",
+    get: function get() {
+      return this._ibcInfo;
+    }
+  }, {
+    key: "getChain",
+    value: function getChain(chainName) {
+      return this._chains.find(function (_ref) {
+        var chain_name = _ref.chain_name;
+        return chain_name === chainName;
+      });
+    }
+  }, {
+    key: "getChainAssetList",
+    value: function getChainAssetList(chainName) {
+      return this._assetLists.find(function (_ref2) {
+        var chain_name = _ref2.chain_name;
+        return chain_name === chainName;
+      });
+    }
+  }, {
+    key: "getChainIbcInfo",
+    value: function getChainIbcInfo(chainName) {
+      return this._ibcInfo.filter(function (info) {
+        return info.chain_1.chain_name === chainName || info.chain_2.chain_name === chainName;
+      });
+    }
+  }, {
+    key: "getChainIbcAssetList",
+    value: function getChainIbcAssetList(chainName) {
+      return (0, _utils.getAssetLists)(chainName, this._ibcInfo, this._assetLists)[0];
+    }
+  }, {
+    key: "getChainFullData",
+    value: function getChainFullData(chainName) {
+      return {
+        chain: this.getChain(chainName),
+        assetList: this.getChainAssetList(chainName),
+        ibcInfo: this.getChainIbcInfo(chainName),
+        ibcAssetList: this.getChainIbcAssetList(chainName)
+      };
+    }
+  }, {
+    key: "getChainUtils",
+    value: function getChainUtils(chainName) {
+      return new _utils2.ChainRegistryUtils({
+        chainName: chainName,
+        assetList: this.getChainAssetList(chainName),
+        ibcAssetList: this.getChainIbcAssetList(chainName)
+      });
+    }
+  }, {
+    key: "fetch",
+    value: function () {
+      var _fetch = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var _this = this;
+        var options,
+          urls,
+          newUrls,
+          responses,
+          _args = arguments;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              options = _args.length > 0 && _args[0] !== undefined ? _args[0] : {};
+              urls = [];
+              if (Object.keys(options).length === 0) {
+                urls = this._allUrls;
+              } else {
+                newUrls = this.generateUrls(options);
+                urls = newUrls;
+                this._allUrls = (0, _toConsumableArray2["default"])(new Set([].concat((0, _toConsumableArray2["default"])(this._allUrls), (0, _toConsumableArray2["default"])(newUrls))));
+              }
+              _context.next = 5;
+              return Promise.all(urls.map(function (url) {
+                return _this.fetchUrl(url);
+              }));
+            case 5:
+              responses = _context.sent;
+              responses.filter(Boolean).forEach(function (data) {
+                return _this.save(data);
+              });
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function fetch() {
+        return _fetch.apply(this, arguments);
+      }
+      return fetch;
+    }()
+  }, {
+    key: "formatChainUrl",
+    value: function formatChainUrl(chainName) {
+      return "".concat(this._baseUrl, "/").concat(chainName, "/chain.json");
+    }
+  }, {
+    key: "formatAssetListUrl",
+    value: function formatAssetListUrl(chainName) {
+      return "".concat(this._baseUrl, "/").concat(chainName, "/assetlist.json");
+    }
+  }, {
+    key: "formatIbcUrl",
+    value: function formatIbcUrl(chain1, chain2) {
+      return "".concat(this._baseUrl, "/_IBC/").concat(chain1, "-").concat(chain2, ".json");
+    }
+  }, {
+    key: "generateNamePairs",
+    value: function generateNamePairs(chainNames) {
+      var pairs = [];
+      for (var i = 0; i < chainNames.length; i++) {
+        for (var j = i + 1; j < chainNames.length; j++) {
+          pairs.push([chainNames[i], chainNames[j]].sort());
+        }
+      }
+      return pairs;
+    }
+  }, {
+    key: "generateUrls",
+    value: function generateUrls(_ref3) {
+      var _this2 = this;
+      var _ref3$urls = _ref3.urls,
+        urls = _ref3$urls === void 0 ? [] : _ref3$urls,
+        _ref3$chainNames = _ref3.chainNames,
+        chainNames = _ref3$chainNames === void 0 ? [] : _ref3$chainNames;
+      var chainUrls = chainNames.map(function (chain) {
+        return _this2.formatChainUrl(chain);
+      });
+      var assetListUrls = chainNames.map(function (chain) {
+        return _this2.formatAssetListUrl(chain);
+      });
+      this._chainNames = (0, _toConsumableArray2["default"])(new Set([].concat((0, _toConsumableArray2["default"])(this._chainNames), (0, _toConsumableArray2["default"])(chainNames))));
+      var allPairs = this.generateNamePairs(this._chainNames);
+      var newPairs = allPairs.filter(function (pair) {
+        return !_this2._ibcInfo.some(function (info) {
+          return info.chain_1.chain_name === pair[0] && info.chain_2.chain_name === pair[1];
+        });
+      });
+      var ibcUrls = newPairs.map(function (pair) {
+        return _this2.formatIbcUrl(pair[0], pair[1]);
+      });
+      var allUrls = (0, _toConsumableArray2["default"])(new Set([].concat((0, _toConsumableArray2["default"])(chainUrls), (0, _toConsumableArray2["default"])(assetListUrls), (0, _toConsumableArray2["default"])(ibcUrls), (0, _toConsumableArray2["default"])(urls))));
+      return allUrls.filter(function (url) {
+        return !_this2._notFoundUrls.includes(url);
+      });
+    }
+  }, {
+    key: "fetchUrl",
+    value: function () {
+      var _fetchUrl = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(url) {
+        var _this3 = this;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", (0, _crossFetch["default"])(url).then(function (res) {
+                if (res.status === 404) {
+                  console.error("Failed to fetch ".concat(url, " with status 404"));
+                  _this3._notFoundUrls.push(url);
+                  return null;
+                }
+                if (res.status >= 400) {
+                  throw new Error("Failed to fetch ".concat(url, " with status ").concat(res.status));
+                }
+                return res.json();
+              }));
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function fetchUrl(_x) {
+        return _fetchUrl.apply(this, arguments);
+      }
+      return fetchUrl;
+    }()
+  }, {
+    key: "upsert",
+    value: function upsert(array, element, filterFn) {
+      var res = array.find(filterFn);
+      if (!res) {
+        return [].concat((0, _toConsumableArray2["default"])(array), [element]);
+      }
+      return array.map(function (item) {
+        if (filterFn(item)) {
+          return element;
+        }
+        return item;
+      });
+    }
+  }, {
+    key: "save",
+    value: function save(data) {
+      if (!data.$schema) {
+        throw new Error('Invalid data: Missing $schema property');
+      }
+      var type = (0, _bfsPath.basename)(data.$schema, '.schema.json');
+      switch (type) {
+        case 'chain':
+          this._chains = this.upsert(this._chains, data, function (chain) {
+            return chain.chain_name === data.chain_name && chain.network_type === data.network_type;
+          });
+          break;
+        case 'assetlist':
+          this._assetLists = this.upsert(this._assetLists, data, function (assetList) {
+            return assetList.chain_name === data.chain_name;
+          });
+          break;
+        case 'ibc_data':
+          this._ibcInfo = this.upsert(this._ibcInfo, data, function (info) {
+            return info.chain_1.chain_name === data.chain_1.chain_name && info.chain_2.chain_name === data.chain_2.chain_name;
+          });
+          break;
+        default:
+          throw new Error("Unsupported json schema: ".concat(data.$schema));
+      }
+    }
+  }]);
+  return ChainRegistryClient;
+}();
+exports.ChainRegistryClient = ChainRegistryClient;

package/main/index.js

@@ -3,47 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _chainInfo = require("./chain-info");
-Object.keys(_chainInfo).forEach(function (key) {
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _chainInfo[key]) return;
+  if (key in exports && exports[key] === _utils[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _chainInfo[key];
+      return _utils[key];
     }
   });
 });
-var _chainUtil = require("./chain-util");
-Object.keys(_chainUtil).forEach(function (key) {
+var _client = require("./client");
+Object.keys(_client).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _chainUtil[key]) return;
+  if (key in exports && exports[key] === _client[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _chainUtil[key];
-    }
-  });
-});
-var _fetcher = require("./fetcher");
-Object.keys(_fetcher).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _fetcher[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _fetcher[key];
-    }
-  });
-});
-var _registry = require("./registry");
-Object.keys(_registry).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _registry[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _registry[key];
+      return _client[key];
     }
   });
 });

package/main/utils.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChainRegistryUtils = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _utils = require("@chain-registry/utils");
+var ChainRegistryUtils = /*#__PURE__*/function () {
+  function ChainRegistryUtils(options) {
+    var _options$assetList, _options$ibcAssetList;
+    (0, _classCallCheck2["default"])(this, ChainRegistryUtils);
+    (0, _defineProperty2["default"])(this, "_chainName", void 0);
+    (0, _defineProperty2["default"])(this, "_assets", []);
+    this._chainName = options.chainName;
+    this._assets = [{
+      assets: [].concat((0, _toConsumableArray2["default"])(((_options$assetList = options.assetList) === null || _options$assetList === void 0 ? void 0 : _options$assetList.assets) || []), (0, _toConsumableArray2["default"])(((_options$ibcAssetList = options.ibcAssetList) === null || _options$ibcAssetList === void 0 ? void 0 : _options$ibcAssetList.assets) || [])),
+      chain_name: options.chainName
+    }];
+  }
+  (0, _createClass2["default"])(ChainRegistryUtils, [{
+    key: "getAssetByDenom",
+    value: function getAssetByDenom(denom) {
+      return (0, _utils.getAssetByDenom)(this._assets, denom, this._chainName);
+    }
+  }, {
+    key: "getAssetBySymbol",
+    value: function getAssetBySymbol(symbol) {
+      return (0, _utils.getAssetBySymbol)(this._assets, symbol, this._chainName);
+    }
+  }, {
+    key: "getDenomByCoinGeckoId",
+    value: function getDenomByCoinGeckoId(coinGeckoId) {
+      return (0, _utils.getDenomByCoinGeckoId)(this._assets, coinGeckoId, this._chainName);
+    }
+  }, {
+    key: "getCoinGeckoIdByDenom",
+    value: function getCoinGeckoIdByDenom(coinGeckoId) {
+      return (0, _utils.getCoinGeckoIdByDenom)(this._assets, coinGeckoId, {
+        chainName: this._chainName
+      });
+    }
+  }, {
+    key: "getSymbolByDenom",
+    value: function getSymbolByDenom(denom) {
+      return (0, _utils.getSymbolByDenom)(this._assets, denom, this._chainName);
+    }
+  }, {
+    key: "getDenomBySymbol",
+    value: function getDenomBySymbol(symbol) {
+      return (0, _utils.getDenomBySymbol)(this._assets, symbol, this._chainName);
+    }
+  }, {
+    key: "getExponentByDenom",
+    value: function getExponentByDenom(denom) {
+      return (0, _utils.getExponentByDenom)(this._assets, denom, this._chainName);
+    }
+  }, {
+    key: "getExponentBySymbol",
+    value: function getExponentBySymbol(symbol) {
+      return (0, _utils.getExponentBySymbol)(this._assets, symbol, this._chainName);
+    }
+  }, {
+    key: "getTokenLogoByDenom",
+    value: function getTokenLogoByDenom(denom) {
+      return (0, _utils.getTokenLogoByDenom)(this._assets, denom, this._chainName);
+    }
+  }, {
+    key: "getTokenNameByDenom",
+    value: function getTokenNameByDenom(denom) {
+      return (0, _utils.getTokenNameByDenom)(this._assets, denom, this._chainName);
+    }
+  }, {
+    key: "getChainNameByDenom",
+    value: function getChainNameByDenom(denom) {
+      return (0, _utils.getChainNameByDenom)(this._assets, denom);
+    }
+  }, {
+    key: "mapCoinGeckoPricesToDenoms",
+    value: function mapCoinGeckoPricesToDenoms(prices) {
+      return (0, _utils.mapCoinGeckoPricesToDenoms)(this._assets, prices);
+    }
+  }, {
+    key: "convertBaseUnitToDollarValue",
+    value: function convertBaseUnitToDollarValue(prices, symbol, amount) {
+      return (0, _utils.convertBaseUnitToDollarValue)(this._assets, prices, symbol, amount, this._chainName);
+    }
+  }, {
+    key: "convertDollarValueToBaseUnit",
+    value: function convertDollarValueToBaseUnit(prices, symbol, value) {
+      return (0, _utils.convertDollarValueToBaseUnit)(this._assets, prices, symbol, value, this._chainName);
+    }
+  }, {
+    key: "convertBaseUnitToDisplayUnit",
+    value: function convertBaseUnitToDisplayUnit(symbol, amount) {
+      return (0, _utils.convertBaseUnitToDisplayUnit)(this._assets, symbol, amount, this._chainName);
+    }
+  }, {
+    key: "convertDisplayUnitToBaseUnit",
+    value: function convertDisplayUnitToBaseUnit(symbol, amount) {
+      return (0, _utils.convertDisplayUnitToBaseUnit)(this._assets, symbol, amount, this._chainName);
+    }
+  }]);
+  return ChainRegistryUtils;
+}();
+exports.ChainRegistryUtils = ChainRegistryUtils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chain-registry/client",
-  "version": "1.19.2",
+  "version": "1.20.0",
   "description": "Chain Registry Client",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/cosmology-tech/chain-registry",
@@ -76,9 +76,9 @@
   "dependencies": {
     "@babel/runtime": "^7.21.0",
     "@chain-registry/types": "^0.18.1",
-    "@chain-registry/utils": "^1.18.2",
+    "@chain-registry/utils": "^1.19.0",
     "bfs-path": "^1.0.2",
     "cross-fetch": "^3.1.5"
   },
-  "gitHead": "2430b615d7efb97cefa0cb7a36282671c3b2a756"
+  "gitHead": "e57916824aad1598342fe9175e9e87b1ba0babcb"
 }

package/types/client.d.ts

@@ -0,0 +1,43 @@
+import { AssetList, Chain, IBCInfo } from '@chain-registry/types';
+import { ChainRegistryUtils } from './utils';
+export interface FetchOptions {
+    urls?: string[];
+    chainNames?: string[];
+}
+export interface ChainRegistryClientOptions extends FetchOptions {
+    baseUrl?: string;
+}
+export declare class ChainRegistryClient {
+    private _allUrls;
+    private _baseUrl;
+    private _chainNames;
+    private _notFoundUrls;
+    private _chains;
+    private _assetLists;
+    private _ibcInfo;
+    constructor(options?: ChainRegistryClientOptions);
+    get urls(): string[];
+    get chains(): Chain[];
+    get assetLists(): AssetList[];
+    get ibcInfo(): IBCInfo[];
+    getChain(chainName: string): Chain | undefined;
+    getChainAssetList(chainName: string): AssetList | undefined;
+    getChainIbcInfo(chainName: string): IBCInfo[];
+    getChainIbcAssetList(chainName: string): AssetList;
+    getChainFullData(chainName: string): {
+        chain: Chain;
+        assetList: AssetList;
+        ibcInfo: IBCInfo[];
+        ibcAssetList: AssetList;
+    };
+    getChainUtils(chainName: string): ChainRegistryUtils;
+    fetch(options?: FetchOptions): Promise<void>;
+    private formatChainUrl;
+    private formatAssetListUrl;
+    private formatIbcUrl;
+    private generateNamePairs;
+    private generateUrls;
+    private fetchUrl;
+    private upsert;
+    private save;
+}

package/types/index.d.ts

@@ -1,4 +1,2 @@
-export * from './chain-info';
-export * from './chain-util';
-export * from './fetcher';
-export * from './registry';
+export * from './utils';
+export * from './client';

package/types/utils.d.ts

@@ -0,0 +1,28 @@
+import { Asset, AssetList } from '@chain-registry/types';
+import type { Denom, Exponent, DenomPriceMap, CoinGeckoUSDPrice } from '@chain-registry/utils';
+export interface ChainRegistryUtilsOptions {
+    chainName: string;
+    assetList?: AssetList;
+    ibcAssetList?: AssetList;
+}
+export declare class ChainRegistryUtils {
+    private _chainName;
+    private _assets;
+    constructor(options: ChainRegistryUtilsOptions);
+    getAssetByDenom(denom: Denom): Asset | undefined;
+    getAssetBySymbol(symbol: string): Asset | undefined;
+    getDenomByCoinGeckoId(coinGeckoId: string): Denom | undefined;
+    getCoinGeckoIdByDenom(coinGeckoId: string): Denom | undefined;
+    getSymbolByDenom(denom: Denom): string | undefined;
+    getDenomBySymbol(symbol: string): Denom | undefined;
+    getExponentByDenom(denom: Denom): Exponent | undefined;
+    getExponentBySymbol(symbol: string): Exponent | undefined;
+    getTokenLogoByDenom(denom: Denom): string | undefined;
+    getTokenNameByDenom(denom: Denom): string | undefined;
+    getChainNameByDenom(denom: Denom): string | undefined;
+    mapCoinGeckoPricesToDenoms(prices: Record<string, CoinGeckoUSDPrice>): DenomPriceMap;
+    convertBaseUnitToDollarValue(prices: DenomPriceMap, symbol: string, amount: string | number): string;
+    convertDollarValueToBaseUnit(prices: DenomPriceMap, symbol: string, value: string | number): string;
+    convertBaseUnitToDisplayUnit(symbol: string, amount: string | number): string;
+    convertDisplayUnitToBaseUnit(symbol: string, amount: string | number): string;
+}