@chain-registry/client/fetcher.js

Chain Registry Client

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ChainRegistryFetcher = void 0;
const utils_1 = require("@chain-registry/utils");
const bfs_path_1 = require("bfs-path");
const cross_fetch_1 = __importDefault(require("cross-fetch"));
const chain_info_1 = require("./chain-info");
const keysToCamel = (o) => {
    if (o === Object(o) && !Array.isArray(o) && typeof o !== 'function') {
        const n = {};
        Object.keys(o).forEach((k) => {
            n[k.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : '')] = keysToCamel(o[k]);
        });
        return n;
    }
    else if (Array.isArray(o)) {
        return o.map((i) => keysToCamel(i));
    }
    return o;
};
const fetchUrl = (url) => {
    return (0, cross_fetch_1.default)(url).then((res) => {
        if (res.status >= 400) {
            throw new Error('Bad response');
        }
        return res.json();
    });
};
// QUESTION: should ChainRegistryFetcher just be ChainRegistry?
class ChainRegistryFetcher {
    urls = [];
    _assetLists = [];
    _chains = [];
    _ibcData = [];
    chainInfoList = [];
    constructor(options = {}) {
        //
        if (options.chains) {
            this._chains = options.chains;
        }
        if (options.assetLists) {
            this._assetLists = options.assetLists;
        }
        if (options.ibcData) {
            this._ibcData = options.ibcData;
        }
        if (options.urls) {
            this.urls = options.urls;
        }
    }
    get chains() {
        return this._chains;
    }
    get assetLists() {
        return this._assetLists;
    }
    get ibcData() {
        return this._ibcData;
    }
    getChain(chainName) {
        return this._chains.find((chain) => chain.chainName === chainName);
    }
    getChainAssetList(chainName) {
        return this._assetLists.find((list) => list.chainName === chainName);
    }
    getGeneratedAssetLists(chainName) {
        return (0, utils_1.getAssetLists)(chainName, this._ibcData, this._assetLists);
    }
    getChainIbcData(chainName) {
        return this._ibcData.filter((info) => info.chain1.chainName === chainName ||
            info.chain2.chainName === chainName);
    }
    getChainInfo(chainName) {
        let chainInfo = this.chainInfoList.find((it) => it.chainName === chainName);
        if (!chainInfo) {
            chainInfo = new chain_info_1.ChainInfo({
                chainName: chainName,
                fetcher: this
            });
            this.chainInfoList.push(chainInfo);
        }
        return chainInfo;
    }
    upsertChain(data) {
        const found = this._chains.find((chain) => {
            return (chain.chainName === data.chainName &&
                chain.networkType === data.networkType);
        });
        const convertedData = keysToCamel(data);
        if (!found) {
            this._chains.push(convertedData);
            return;
        }
        this._chains = this._chains.map((chain) => {
            if (chain.chainName === data.chainName &&
                chain.networkType === data.networkType) {
                return convertedData;
            }
            else {
                return chain;
            }
        });
    }
    updateAssetList(data) {
        const found = this._assetLists.find((list) => {
            return list.chainName === data.chainName;
        });
        const convertedData = keysToCamel(data);
        if (!found) {
            this._assetLists.push(convertedData);
            return;
        }
        this._assetLists = this._assetLists.map((list) => {
            if (list.chainName === data.chainName) {
                return convertedData;
            }
            else {
                return list;
            }
        });
    }
    upsertIbcData(data) {
        const found = this._ibcData.find((info) => {
            return (info.chain1.chainName === data.chain1.chainName &&
                info.chain2.chainName === data.chain2.chainName);
        });
        const convertedData = keysToCamel(data);
        if (!found) {
            this._ibcData.push(convertedData);
            return;
        }
        this._ibcData = this._ibcData.map((info) => {
            if (info.chain1.chainName === data.chain1.chainName &&
                info.chain2.chainName === data.chain2.chainName) {
                return convertedData;
            }
            else {
                return info;
            }
        });
    }
    update(data) {
        if (!data.$schema)
            throw new Error('not a registered JSON schema type');
        const type = (0, bfs_path_1.basename)(data.$schema, '.schema.json');
        switch (type) {
            case 'chain':
                this.upsertChain(data);
                break;
            case 'assetlist':
                this.updateAssetList(data);
                break;
            case 'ibc_data':
                this.upsertIbcData(data);
                break;
            default:
                throw new Error('unknown schema type');
        }
        this.chainInfoList.forEach((chainInfo) => {
            chainInfo.refresh();
        });
    }
    async fetch(url) {
        const data = await fetchUrl(url);
        this.update(data);
    }
    async fetchUrls() {
        return Promise.all(this.urls.map((url) => this.fetch(url)));
    }
}
exports.ChainRegistryFetcher = ChainRegistryFetcher;