example-js-sdk 0.0.1

package/lib/clients/TokenClient.js

@@ -0,0 +1,715 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pagination_1 = require("../codec/cosmos/base/query/v1beta1/pagination");
+const tendermint_1 = require("../codec/ibc/lightclients/tendermint/v1/tendermint");
+const constant_1 = require("../constant");
+const ibc_1 = require("../constant/ibc");
+const util_1 = require("../util");
+const blockchain_1 = require("../util/blockchain");
+const number_1 = require("../util/number");
+const long_1 = __importDefault(require("long"));
+const InsightsQueryClient_1 = __importDefault(require("./InsightsQueryClient"));
+const SYMBOL_OVERRIDE = {
+    swth: "SWTH",
+    NNEO: "nNEO",
+    YAM1: "YAM",
+    YAM2: "YAM",
+    ASA1: "ASA",
+    ASA2: "ASA",
+    DBC1: "DBC",
+    DBC2: "DBC",
+    AVA1: "AVA",
+    TSWTH: "tSWTH",
+    "cibStride Liquid Staked LUNA": "cibstLUNA",
+};
+const regexCdpDenom = RegExp(`^${constant_1.DenomPrefix.CDPToken}/`, "i");
+const regexLPDenom = RegExp(`^${constant_1.DenomPrefix.LPToken}/(\\d+)$`, "i");
+const regexPerpPoolDenom = RegExp(`^${constant_1.DenomPrefix.PerpPoolToken}/\\d+$`, "i");
+const regexUserVaultDenom = RegExp(`^${constant_1.DenomPrefix.UserVaultToken}/\\d+$`, "i");
+const onError = (error) => {
+    console.error("failed to reload usd values");
+    console.error(error);
+};
+class TokenClient {
+    constructor(query, configProvider) {
+        this.query = query;
+        this.configProvider = configProvider;
+        this.tokens = {};
+        this.wrapperMap = {};
+        this.poolTokens = {};
+        this.cdpTokens = {};
+        this.bridges = { polynetwork: [], ibc: [], axelar: [] };
+        this.symbols = {};
+        this.usdValues = {};
+        this.commonAssetNames = constant_1.CommonAssetName;
+        this.geckoTokenNames = constant_1.CoinGeckoTokenNames;
+        this.initialUsdValuesLoaded = false;
+        this.additionalGeckoDenoms = {};
+        this.getIbcBridgeFromBlockchainV2 = (blockchain) => {
+            return this.bridges.ibc.find(bridge => (bridge.chainName === blockchain || bridge.chainName.toLowerCase() === blockchain));
+        };
+        this.getIbcChainFromBlockchainV2 = (blockchain) => {
+            const ibcBridge = this.getIbcBridgeFromBlockchainV2(blockchain);
+            return ibcBridge?.chain_id_name;
+        };
+    }
+    static instance(query, configProvider) {
+        return new TokenClient(query, configProvider);
+    }
+    async initialize() {
+        this.setCommonAssetConfig();
+        try {
+            await Promise.all([
+                this.reloadTokens(),
+                this.reloadWrapperMap(),
+                this.getBridges(),
+            ]);
+        }
+        finally {
+            // non-blocking reload
+            this.reloadDenomGeckoMap().catch(onError).finally(() => {
+                this.reloadUSDValues().catch(onError);
+            });
+        }
+    }
+    registerGeckoIdMap(map) {
+        this.additionalGeckoDenoms = {
+            ...this.additionalGeckoDenoms,
+            ...map,
+        };
+    }
+    getCommonDenom(denom) {
+        return this.commonAssetNames[denom] ?? denom;
+    }
+    getDecimals(denom) {
+        return (this.tokens[denom] ?? this.poolTokens[denom] ?? this.cdpTokens[denom])?.decimals.toNumber();
+    }
+    getBlockchain(denom) {
+        const networkConfig = this.configProvider.getConfig();
+        const tokenData = this.tokens[denom];
+        // chainId defaults to 3 so that blockchain will be undefined
+        let chainId = tokenData?.chainId?.toNumber() ?? 3;
+        if (this.isNativeToken(denom) || this.isNativeStablecoin(denom) || TokenClient.isPoolToken(denom) || TokenClient.isCdpToken(denom) || TokenClient.isVaultToken(denom)) {
+            // native denoms "swth" and "usc" should be native.
+            // pool and cdp tokens are on the Native blockchain, hence 0
+            chainId = 0;
+        }
+        if (TokenClient.isIBCDenom(denom)) {
+            return util_1.IBCUtils.BlockchainMap[denom];
+        }
+        const blockchain = util_1.BlockchainUtils.blockchainForChainId(chainId, networkConfig.network);
+        return blockchain;
+    }
+    getBlockchainV2(denom) {
+        if (!denom)
+            return undefined;
+        const token = this.tokenForDenom(denom);
+        if (this.isBridgedToken(denom)) {
+            // brdg tokens will all be chain_id 0 which will also be deprecated in future
+            // hence for brdg tokens cannot use chain_id to differentiate between blockchains
+            const bridgeList = this.bridges.axelar;
+            const chainName = bridgeList.find((bridge) => bridge.bridgeAddress === token?.bridgeAddress)?.chainName;
+            return chainName;
+        }
+        else if (token?.chainId.eq(0) && token?.bridgeId.eq(0)) {
+            return 'Native';
+        }
+        const bridge = this.getBridgeFromToken(token);
+        return bridge?.chainName;
+    }
+    /**
+     * use getTokenName directly instead
+     * @deprecated
+    */
+    getSymbol(denom) {
+        if (TokenClient.isCdpToken(denom)) {
+            return this.symbols[denom] ?? denom;
+        }
+        const commonDenom = this.getCommonDenom(denom);
+        return this.symbols[commonDenom] ?? commonDenom.toUpperCase();
+    }
+    getUSDValue(denom) {
+        return this.usdValues[denom];
+    }
+    toHuman(denom, unitlessAmt) {
+        const decimals = this.getDecimals(denom);
+        return util_1.NumberUtils.toHuman(unitlessAmt, decimals) ?? number_1.BN_ZERO;
+    }
+    toUnitless(denom, humanAmt) {
+        const decimals = this.getDecimals(denom);
+        return util_1.NumberUtils.toUnitless(humanAmt, decimals) ?? number_1.BN_ZERO;
+    }
+    tokenForId(id) {
+        let tokensList = Object.values(this.tokens);
+        if (TokenClient.isPoolToken(id)) {
+            tokensList = Object.values(this.poolTokens);
+        }
+        else if (TokenClient.isCdpToken(id)) {
+            tokensList = Object.values(this.cdpTokens);
+        }
+        return tokensList.find((token) => token.id === id);
+    }
+    tokenForDenom(denom) {
+        return this.poolTokens[denom] ?? this.cdpTokens[denom] ?? this.tokens[denom];
+    }
+    async getFeeInfo(denom) {
+        const config = this.configProvider.getConfig();
+        const url = `${config.hydrogenUrl}/fee_quote?token_denom=${denom}`;
+        const requestOptions = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({}),
+        };
+        const result = await util_1.FetchUtils.fetch(url, requestOptions).then((res) => res.json());
+        return result;
+    }
+    getTokenName(denom, overrideMap) {
+        if (typeof denom !== "string")
+            return "";
+        if (!TokenClient.isIBCDenom(denom) && !TokenClient.isCdpIbcDenom(denom)) {
+            denom = denom.toLowerCase();
+        }
+        const symbol = this.getSymbol(denom);
+        if (TokenClient.isPoolTokenLegacy(denom)) {
+            const match = symbol.match(/^([a-z\d.-/]+)-(\d+)-([a-z\d.-/]+)-(\d+)-lp\d+$/i);
+            // inconsistent implementation of isPoolToken, exit
+            if (match === null)
+                return symbol;
+            const denomA = match[1];
+            const denomB = match[3];
+            const symbolA = this.getTokenName(denomA);
+            const symbolB = this.getTokenName(denomB);
+            return `${symbolA}-${symbolB}`;
+        }
+        if (TokenClient.isIBCDenom(denom)) {
+            const splitDenom = denom.split("/");
+            denom = `${splitDenom[0].toLowerCase()}/${splitDenom[1].toUpperCase()}`;
+            return this.symbols[denom] ?? denom.toUpperCase();
+        }
+        if (SYMBOL_OVERRIDE[symbol]) {
+            return SYMBOL_OVERRIDE[symbol];
+        }
+        if (overrideMap?.[symbol]) {
+            return overrideMap[symbol];
+        }
+        return symbol;
+    }
+    getTokenDesc(denom) {
+        if (typeof denom !== "string")
+            return "";
+        denom = denom.toLowerCase();
+        if (TokenClient.isPoolTokenLegacy(denom)) {
+            const match = denom.match(/^([a-z\d.-/]+)-(\d+)-([a-z\d.-/]+)-(\d+)-lp\d+$/i);
+            // inconsistent implementation of isPoolToken, exit
+            if (match === null)
+                return this.getSymbol(denom);
+            const denomA = match[1];
+            const weightA = match[2];
+            const denomB = match[3];
+            const weightB = match[4];
+            const symbolA = this.getTokenName(denomA);
+            const symbolB = this.getTokenName(denomB);
+            return `${weightA}% ${symbolA} / ${weightB}% ${symbolB}`;
+        }
+        if (TokenClient.isCdpToken(denom)) {
+            return this.cdpTokens[denom]?.name ?? this.getSymbol(denom);
+        }
+        return this.tokens[denom]?.name ?? this.getSymbol(denom);
+    }
+    static isPoolTokenNew(denom) {
+        return denom.match(regexLPDenom) !== null;
+    }
+    static isPoolTokenLegacy(denom) {
+        return denom.match(/^([a-z\d.-]+)-(\d+)-([a-z\d.-]+)-(\d+)-lp\d+$/i) !== null;
+    }
+    static isCdpToken(denom) {
+        return denom.match(regexCdpDenom) !== null;
+    }
+    static isPoolToken(denom) {
+        return this.isPoolTokenNew(denom) || this.isPoolTokenLegacy(denom);
+    }
+    static isVaultToken(denom) {
+        return this.isPerpPoolToken(denom) || this.isUserVaultToken(denom);
+    }
+    static isPerpPoolToken(denom) {
+        return denom.match(regexPerpPoolDenom) !== null;
+    }
+    static isUserVaultToken(denom) {
+        return denom.match(regexUserVaultDenom) !== null;
+    }
+    static isIBCDenom(denom) {
+        return denom.match(ibc_1.ibcTokenRegex) !== null;
+    }
+    static isCdpIbcDenom(denom) {
+        return ibc_1.cibtIbcTokenRegex.test(denom);
+    }
+    isWrappedToken(denom) {
+        return !!this.wrapperMap[denom ?? ""];
+    }
+    hasWrappedToken(denom) {
+        return Object.values(this.wrapperMap).includes(denom ?? "");
+    }
+    getWrappedTokens(denom) {
+        const result = [];
+        if (!this.tokens)
+            return result;
+        // check if denom is source token
+        if (Object.values(this.wrapperMap).includes(denom)) {
+            for (const [wrappedDenom, sourceDenom] of Object.entries(this.wrapperMap)) {
+                // if mapping is not relevant to current source denom, skip.
+                if (sourceDenom !== denom) {
+                    continue;
+                }
+                // add wrapped to result list
+                const token = this.tokens[wrappedDenom];
+                if (token) {
+                    result.push(token);
+                }
+            }
+        }
+        return result;
+    }
+    getWrappedToken(denom, blockchain, version = 'V1') {
+        // if denom is already a wrapped denom or no blockchain was specified,
+        // just return the input denom.
+        if (this.wrapperMap[denom] || !blockchain) {
+            return this.tokens[denom];
+        }
+        // check if denom is source token
+        if (Object.values(this.wrapperMap).includes(denom)) {
+            for (const [wrappedDenom, sourceDenom] of Object.entries(this.wrapperMap)) {
+                // if mapping is not relevant to current source denom, skip.
+                if (sourceDenom !== denom) {
+                    continue;
+                }
+                // check if wrapped denom is of correct blockchain
+                const token = this.tokens[wrappedDenom];
+                let tokenChain = '';
+                if (version === "V1") {
+                    tokenChain = util_1.BlockchainUtils.blockchainForChainId(token.chainId.toNumber());
+                    if (TokenClient.isIBCDenom(token.denom)) {
+                        tokenChain = util_1.IBCUtils.BlockchainMap[wrappedDenom];
+                    }
+                }
+                else {
+                    tokenChain = this.getBlockchainV2(token.denom);
+                }
+                if (!tokenChain) {
+                    continue; // unknown chain! just ignore this source token
+                }
+                if (tokenChain === blockchain) {
+                    return token;
+                }
+            }
+        }
+        return null;
+    }
+    getSourceToken(denom) {
+        // check if denom is source token
+        if (Object.values(this.wrapperMap).includes(denom)) {
+            return this.tokens[denom];
+        }
+        // check if denom is wrapped token
+        if (this.wrapperMap[denom]) {
+            const sourceDenom = this.wrapperMap[denom];
+            return this.tokens[sourceDenom];
+        }
+        return null;
+    }
+    getNativeToken() {
+        return this.tokenForId("swth");
+    }
+    getNativeStablecoin() {
+        return this.tokenForId("usc");
+    }
+    isNativeToken(denom) {
+        return denom === "swth";
+    }
+    isNativeStablecoin(denom) {
+        return denom === "usc";
+    }
+    isGroupChequeDenom(denom) {
+        const groupedTokenRegex = new RegExp(/^cgt\/\d+$/);
+        return groupedTokenRegex.test(denom);
+    }
+    isBridgedToken(denom) {
+        const bridgedTokenRegex = new RegExp(/^brdg\//);
+        return bridgedTokenRegex.test(denom);
+    }
+    isCarbonToken(token) {
+        return Boolean(token && (this.isNativeToken(token.denom) || token.bridgeId.eq(0)));
+    }
+    getDepositTokenFor(tokenDenom, chain, version = "V1") {
+        const networkConfig = this.configProvider.getConfig();
+        const token = this.tokenForDenom(tokenDenom);
+        if (!token) {
+            console.debug("getDepositTokenFor token not found for", tokenDenom);
+            return;
+        }
+        let targetChain = "";
+        // check if selected token is a source token
+        if (version === "V1") {
+            targetChain = util_1.BlockchainUtils.blockchainForChainId(token.chainId.toNumber(), networkConfig.network);
+            if (TokenClient.isIBCDenom(token.denom)) {
+                targetChain = util_1.IBCUtils.BlockchainMap[token.denom];
+            }
+        }
+        else {
+            targetChain = this.getBlockchainV2(token.denom);
+        }
+        const isSourceToken = targetChain === chain && token.denom !== "swth";
+        // if not source token find wrapped token for chain
+        const depositToken = isSourceToken ? token : this.getWrappedToken(token.denom, chain, version);
+        if (!depositToken) {
+            console.debug(`getDepositTokenFor wrapped token not found for "${token.denom}"`);
+            return;
+        }
+        return depositToken;
+    }
+    async getAllTokens() {
+        const result = await this.query.coin.TokenAll({
+            pagination: {
+                limit: new long_1.default(10000),
+                offset: long_1.default.UZERO,
+                key: new Uint8Array(),
+                countTotal: false,
+                reverse: false,
+            },
+        });
+        const networkConfig = this.configProvider.getConfig();
+        const tokenBlacklist = constant_1.TokenBlacklist[networkConfig.network] ?? [];
+        return result.tokens.filter((token) => !tokenBlacklist.includes(token.denom));
+    }
+    async reloadTokens() {
+        const tokenResponse = await this.getAllTokens();
+        for (const token of tokenResponse) {
+            if (TokenClient.isPoolToken(token.denom)) {
+                this.poolTokens[token.denom] = token;
+            }
+            else if (TokenClient.isCdpToken(token.denom)) {
+                this.cdpTokens[token.denom] = token;
+                this.symbols[token.denom] = token.symbol;
+            }
+            else {
+                this.tokens[token.denom] = token;
+                this.symbols[token.denom] = token.symbol;
+            }
+        }
+        return this.tokens;
+    }
+    async getBridges() {
+        const allBridges = await this.query.coin.BridgeAll({
+            pagination: {
+                key: new Uint8Array(),
+                limit: new long_1.default(10000),
+                offset: long_1.default.UZERO,
+                countTotal: true,
+                reverse: false,
+            },
+        });
+        const unmatchedIbcBridgeList = allBridges.bridges.filter(bridge => {
+            if (!bridge.enabled)
+                return;
+            return bridge.bridgeId.toNumber() === blockchain_1.BRIDGE_IDS.ibc;
+        });
+        const ibcBridges = await this.matchChainsWithDifferentChainIds(unmatchedIbcBridgeList);
+        const axelarBridges = await this.mapBridgesFromConnections();
+        const polynetworkBridges = allBridges.bridges.reduce((prev, bridge) => {
+            if (bridge.bridgeId.toNumber() !== blockchain_1.BRIDGE_IDS.polynetwork)
+                return prev;
+            prev.push({
+                ...bridge,
+                isEvmChain: util_1.BlockchainUtils.isEvmChain(bridge.chainName),
+            });
+            return prev;
+        }, []);
+        Object.assign(this.bridges, {
+            polynetwork: polynetworkBridges,
+            ibc: ibcBridges,
+            axelar: axelarBridges,
+        });
+        return this.bridges;
+    }
+    async matchChainsWithDifferentChainIds(bridges) {
+        let newBridges = [];
+        try {
+            const pagination = pagination_1.PageRequest.fromPartial({ limit: new long_1.default(1e6) });
+            const results = await Promise.all([
+                this.query.ibc.channel.Channels({ pagination }),
+                this.query.ibc.connection.Connections({ pagination }),
+                this.query.ibc.client.ClientStates({ pagination }),
+            ]);
+            const [{ channels }, { connections }, { clientStates: rawClientStates }] = results;
+            const clientStates = rawClientStates.map(s => ({
+                clientState: tendermint_1.ClientState.decode(s.clientState.value),
+                clientId: s.clientId,
+            }));
+            newBridges = bridges.map(bridge => {
+                const connection = channels.find(channel => channel.channelId === ("channel-" + (bridge.chainId.toNumber() - 1)));
+                const connectionId = connection?.connectionHops[0];
+                const src_channel = connection?.channelId ?? "";
+                const dst_channel = connection?.counterparty?.channelId ?? "";
+                const cosmRegexArr = connection?.counterparty?.portId?.match(ibc_1.cosmBridgeRegex);
+                const portId = cosmRegexArr?.[1] ?? "transfer";
+                const clientId = connections.find(connection => connection.id === connectionId)?.clientId;
+                const chainIdName = (clientStates.find(client => client.clientId === clientId)?.clientState)?.chainId;
+                return { ...bridge, chain_id_name: chainIdName ?? "", channels: { src_channel, dst_channel, port_id: portId } };
+            });
+        }
+        finally {
+            const checkedBefore = new Array(newBridges.length).fill(false);
+            const chainMap = {};
+            for (let i = 0; i < newBridges.length; i++) {
+                if (checkedBefore[i])
+                    continue;
+                const bridge = newBridges[i];
+                const chainId = bridge.chain_id_name;
+                if (chainMap[chainId]) {
+                    const chainName = chainMap[chainId];
+                    for (let j = i; j < newBridges.length; j++) {
+                        const subBridge = newBridges[j];
+                        if (subBridge.chain_id_name === chainId) {
+                            subBridge.chainName = chainName;
+                            checkedBefore[j] = true;
+                        }
+                    }
+                }
+                else {
+                    chainMap[chainId] = bridge.chainName;
+                }
+            }
+        }
+        return newBridges;
+    }
+    async mapBridgesFromConnections() {
+        const newBridges = [];
+        try {
+            const results = await this.query.bridge.ConnectionAll({
+                bridgeId: new long_1.default(0),
+                pagination: pagination_1.PageRequest.fromPartial({
+                    limit: new long_1.default(10000),
+                }),
+            });
+            const connections = results.connections;
+            connections.forEach(connection => {
+                newBridges.push({
+                    name: `${connection.chainDisplayName} via Axelar`,
+                    bridgeId: new long_1.default(blockchain_1.BRIDGE_IDS.axelar),
+                    chainId: new long_1.default(blockchain_1.BRIDGE_IDS.axelar),
+                    bridgeAddress: connection.connectionId,
+                    chain_id_name: connection.chainId,
+                    chainName: connection.chainDisplayName,
+                    bridgeName: 'Axelar',
+                    bridgeAddresses: [],
+                    enabled: connection.isEnabled,
+                });
+            });
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            const chainMap = {};
+            newBridges.forEach((bridge) => {
+                const chainId = bridge.chain_id_name;
+                if (chainMap[chainId]) {
+                    bridge.chainName = chainMap[chainId];
+                }
+                else {
+                    chainMap[chainId] = bridge.chainName;
+                }
+            });
+        }
+        return newBridges;
+    }
+    getIbcBlockchainNames() {
+        return this.bridges.ibc.map(bridge => bridge.chainName);
+    }
+    getAxelarBlockchainNames() {
+        return this.bridges.axelar.map(bridge => bridge.chainName);
+    }
+    getPolynetworkBlockchainNames() {
+        return this.bridges.polynetwork.map(bridge => bridge.chainName);
+    }
+    getAllBlockchainNames() {
+        return this.getIbcBlockchainNames().concat(this.getPolynetworkBlockchainNames()).concat(this.getAxelarBlockchainNames());
+    }
+    getBridgesFromBridgeId(bridgeId) {
+        switch (bridgeId) {
+            case blockchain_1.BRIDGE_IDS.polynetwork:
+                return this.bridges.polynetwork;
+            case blockchain_1.BRIDGE_IDS.ibc:
+                return this.bridges.ibc;
+            case blockchain_1.BRIDGE_IDS.axelar:
+                return this.bridges.axelar;
+            default:
+                return this.bridges.polynetwork;
+        }
+    }
+    getIbcTokens() {
+        const ibcTokens = Object.values(this.tokens).reduce((prev, token) => {
+            const newPrev = prev;
+            if (token.bridgeId.toNumber() === blockchain_1.BRIDGE_IDS.ibc) {
+                newPrev[token.denom] = token;
+            }
+            return newPrev;
+        }, {});
+        return ibcTokens;
+    }
+    getPolyNetworkTokens() {
+        const polynetworkTokens = Object.values(this.tokens).reduce((prev, token) => {
+            const newPrev = prev;
+            if (token.bridgeId.toNumber() === blockchain_1.BRIDGE_IDS.polynetwork) {
+                newPrev[token.denom] = token;
+            }
+            return newPrev;
+        }, {});
+        return polynetworkTokens;
+    }
+    getBlockchainV2FromIDs(chainId, bridgeId) {
+        if ((chainId === 5 && bridgeId === 1) || (chainId === 0 && bridgeId === 2))
+            return "Carbon";
+        const bridgeList = this.getBridgesFromBridgeId(bridgeId);
+        return bridgeList.find(bridge => bridge.chainId.toNumber() === chainId)?.chainName ?? undefined;
+    }
+    getBridgeFromToken(token) {
+        if (!token || !token.bridgeId)
+            return undefined;
+        const bridgeList = this.getBridgesFromBridgeId(token.bridgeId.toNumber());
+        return bridgeList.find(bridge => token.chainId.equals(bridge.chainId));
+    }
+    getIbcChainIdFromToken(token) {
+        if (!token)
+            return undefined;
+        const bridge = this.getBridgeFromToken(token);
+        if (!bridge || !(0, blockchain_1.isIbcBridge)(bridge))
+            return undefined;
+        return bridge.chain_id_name;
+    }
+    getCdpUnderlyingToken(cdpDenom) {
+        if (!this.cdpTokens[cdpDenom]) {
+            console.error("not a CDP denom");
+            return undefined;
+        }
+        const tokenDenom = cdpDenom.replace(regexCdpDenom, "");
+        if (TokenClient.isPoolToken(tokenDenom)) {
+            return this.poolTokens[tokenDenom];
+        }
+        return this.tokenForDenom(tokenDenom);
+    }
+    async reloadWrapperMap() {
+        const mappingResponse = await this.query.coin.WrapperMappings({});
+        Object.assign(this.wrapperMap, mappingResponse.wrapperMappings ?? {});
+        return this.wrapperMap;
+    }
+    async reloadDenomGeckoMap() {
+        const geckoTokensDenomToCoinIdMap = (await this.getDenomToGeckoIdMap());
+        for (const geckoDenom in geckoTokensDenomToCoinIdMap) {
+            this.geckoTokenNames[geckoDenom] = geckoTokensDenomToCoinIdMap[geckoDenom];
+        }
+    }
+    async reloadUSDValues(denoms = Object.keys(this.tokens)) {
+        this.usdValues.iusd = number_1.BN_ONE;
+        this.usdValues.cgusd = number_1.BN_ONE;
+        //Get corresponding geckoId for denoms and removes any duplicated geckoIds (espeically for different wrapped tokens as they correspond to the same geckoId(same price))
+        const geckoIds = denoms.reduce((coinIds, denom) => {
+            // To ensure that ibc denoms are not added to the gecko ids list, the default is removed.
+            const geckoId = this.geckoTokenNames[denom];
+            if (geckoId && !coinIds.includes(geckoId)) {
+                coinIds.push(geckoId);
+            }
+            return coinIds;
+        }, []);
+        const geckoIdToUsdPriceMap = await this.getUSDValuesFromCoinGecko(geckoIds);
+        const carbonTokenPrices = await this.getUSDValuesFromPricingModule();
+        const uscStablecoin = this.getNativeStablecoin();
+        // add carbon token prices first
+        Object.entries(carbonTokenPrices).forEach(([key, value]) => {
+            this.usdValues[key] = value;
+        });
+        //store price based on denoms
+        for (const denom of denoms) {
+            // if token price in pricing module exists for denom, return that as usd price first
+            // else check coingecko
+            if (this.usdValues[denom])
+                continue;
+            const coinId = this.geckoTokenNames[denom] ?? denom;
+            const price = util_1.NumberUtils.bnOrZero(geckoIdToUsdPriceMap?.[coinId]?.usd);
+            if (price.gt(0)) {
+                // if denom is usc, then return uscUsdValue, else return coingecko usd price
+                this.usdValues[denom] = denom === uscStablecoin?.denom ? constant_1.uscUsdValue : price;
+            }
+        }
+        if (!this.initialUsdValuesLoaded)
+            this.initialUsdValuesLoaded = true;
+        return this.usdValues;
+    }
+    async getUSDValuesFromCoinGecko(geckoIds) {
+        const response = await util_1.FetchUtils.fetch(`https://coingecko-proxy.dem.exchange/api/v3/simple/price?ids=${geckoIds.join(",")}&vs_currencies=usd`);
+        return await response.json();
+    }
+    processTokenPrices(tokenPrices) {
+        return tokenPrices.reduce((prevPrices, price) => {
+            const newPrev = prevPrices;
+            newPrev[price.denom] = (0, number_1.bnOrZero)(price.twap).shiftedBy(-constant_1.decTypeDecimals);
+            return newPrev;
+        }, {});
+    }
+    async getUSDValuesFromPricingModule() {
+        const initTokenPrices = await this.query.pricing.TokenPriceAll({
+            pagination: {
+                limit: new long_1.default(10000),
+                offset: new long_1.default(0),
+                key: new Uint8Array(),
+                countTotal: true,
+                reverse: false,
+            },
+        });
+        if (initTokenPrices.pagination?.total && initTokenPrices.pagination?.total.lt(10000)) {
+            const tokenPricesMap = this.processTokenPrices(initTokenPrices.tokenPrices);
+            return tokenPricesMap;
+        }
+        const fullTokenPrices = await this.query.pricing.TokenPriceAll({
+            pagination: {
+                limit: initTokenPrices.pagination?.total ?? new long_1.default(0),
+                offset: new long_1.default(0),
+                key: new Uint8Array(),
+                countTotal: true,
+                reverse: false,
+            },
+        });
+        return this.processTokenPrices(fullTokenPrices.tokenPrices);
+    }
+    async getDenomToGeckoIdMap() {
+        const networkConfig = this.configProvider.getConfig();
+        const insights = new InsightsQueryClient_1.default(networkConfig);
+        const response = await insights.DenomToGeckoIdMap();
+        const tokens = response.result.gecko;
+        return tokens;
+    }
+    setCommonAssetConfig() {
+        // whitelisted ibc tokens
+        ibc_1.ibcWhitelist.forEach((chainId) => {
+            const currencies = util_1.IBCUtils.EmbedChainInfos[chainId].currencies;
+            const channelObj = ibc_1.swthChannels[chainId]?.ibc;
+            currencies.forEach((asset) => {
+                const channel = asset.coinMinimalDenom !== "swth" ? channelObj?.sourceChannel ?? "channel-0" : channelObj?.dstChannel ?? "channel-0";
+                const assetDenom = TokenClient.isIBCDenom(asset.coinMinimalDenom)
+                    ? asset.coinMinimalDenom
+                    : util_1.IBCUtils.makeIBCMinimalDenom(channel, asset.coinMinimalDenom);
+                const symbolSmall = asset.coinDenom.toLowerCase();
+                if (!this.commonAssetNames[assetDenom])
+                    this.commonAssetNames[assetDenom] = symbolSmall;
+                if (asset.coinGeckoId && !this.geckoTokenNames[symbolSmall])
+                    this.geckoTokenNames[symbolSmall] = asset.coinGeckoId;
+            });
+        });
+    }
+}
+TokenClient.Blacklist = constant_1.TokenBlacklist;
+exports.default = TokenClient;