@defillama/sdk 5.0.240 → 5.0.242

package/build/util/chainUtils/index.d.ts

@@ -0,0 +1,11 @@
+import { chainKeyToChainLabelMap, chainLabelsToKeyMap } from './data.json';
+export { chainKeyToChainLabelMap, chainLabelsToKeyMap, };
+export declare function updateData(): Promise<void>;
+export declare function updateChainLabels(): Promise<void>;
+export declare const sluggifyString: (name: string) => string;
+export declare function getSluggifiedChainLabel(label: string): string;
+export declare function getChainKeyFromLabel(label: string): string;
+export declare function getChainLabelFromKey(id: string): string;
+export declare function getDeadChains(): string[];
+export declare function getDeadChainsSet(): Set<string>;
+export declare function isDeadChain(chainKeyOrLabel: string): boolean;

package/build/util/chainUtils/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sluggifyString = exports.chainLabelsToKeyMap = exports.chainKeyToChainLabelMap = void 0;
+exports.updateData = updateData;
+exports.updateChainLabels = updateChainLabels;
+exports.getSluggifiedChainLabel = getSluggifiedChainLabel;
+exports.getChainKeyFromLabel = getChainKeyFromLabel;
+exports.getChainLabelFromKey = getChainLabelFromKey;
+exports.getDeadChains = getDeadChains;
+exports.getDeadChainsSet = getDeadChainsSet;
+exports.isDeadChain = isDeadChain;
+const data_json_1 = require("./data.json");
+Object.defineProperty(exports, "chainKeyToChainLabelMap", { enumerable: true, get: function () { return data_json_1.chainKeyToChainLabelMap; } });
+Object.defineProperty(exports, "chainLabelsToKeyMap", { enumerable: true, get: function () { return data_json_1.chainLabelsToKeyMap; } });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const deadChainsArray = Object.keys(data_json_1.deadChains);
+const deadChainsSet = new Set(deadChainsArray);
+async function updateData() {
+    var _a;
+    try {
+        // mapping pulled from https://github.com/DefiLlama/defillama-server/blob/master/defi/src/utils/normalizeChain.ts
+        const response = await fetch('https://api.llama.fi/overview/_internal/chain-name-id-map-v2');
+        const remoteData = await response.json();
+        for (const [key, value] of Object.entries(remoteData.chainKeyToChainLabelMap)) {
+            data_json_1.chainKeyToChainLabelMap[key] = value;
+        }
+        for (const [key, value] of Object.entries(remoteData.chainLabelsToKeyMap)) {
+            data_json_1.chainLabelsToKeyMap[key] = value;
+        }
+        // dead chains are pulled from the `deadFrom` field on chainCoingeckoIds entries in https://api.llama.fi/config
+        const configResponse = await fetch('https://api.llama.fi/config');
+        const config = await configResponse.json();
+        for (const [label, value] of Object.entries((_a = config.chainCoingeckoIds) !== null && _a !== void 0 ? _a : {})) {
+            const deadFrom = value === null || value === void 0 ? void 0 : value.deadFrom;
+            if (!deadFrom)
+                continue;
+            const key = getChainKeyFromLabel(label);
+            data_json_1.deadChains[key] = deadFrom;
+            if (!deadChainsSet.has(key)) {
+                deadChainsSet.add(key);
+                deadChainsArray.push(key);
+            }
+        }
+        // Save to data.json file
+        const dataFilePath = path_1.default.join(__dirname, 'data.json');
+        fs_1.default.writeFileSync(dataFilePath, JSON.stringify({
+            chainKeyToChainLabelMap: sortJSONData(data_json_1.chainKeyToChainLabelMap),
+            chainLabelsToKeyMap: sortJSONData(data_json_1.chainLabelsToKeyMap),
+            deadChains: sortJSONData(data_json_1.deadChains),
+        }, null, 2));
+    }
+    catch (error) {
+        console.error('Error updating chain data:', error);
+    }
+}
+// runs updateData and sanity checks that the mappings only grew
+async function updateChainLabels() {
+    const chainKeyLabelMapCountBefore = Object.keys(data_json_1.chainKeyToChainLabelMap).length;
+    const chainLabelsKeyMapCountBefore = Object.keys(data_json_1.chainLabelsToKeyMap).length;
+    await updateData();
+    const chainKeyLabelMapCountAfter = Object.keys(data_json_1.chainKeyToChainLabelMap).length;
+    const chainLabelsKeyMapCountAfter = Object.keys(data_json_1.chainLabelsToKeyMap).length;
+    if (chainKeyLabelMapCountAfter > chainKeyLabelMapCountBefore) {
+        console.log(`Updated chainKeyToChainLabelMap: ${chainKeyLabelMapCountBefore} -> ${chainKeyLabelMapCountAfter}`);
+    }
+    if (chainLabelsKeyMapCountAfter > chainLabelsKeyMapCountBefore) {
+        console.log(`Updated chainLabelsToKeyMap: ${chainLabelsKeyMapCountBefore} -> ${chainLabelsKeyMapCountAfter}`);
+    }
+    if (chainKeyLabelMapCountAfter < chainKeyLabelMapCountBefore)
+        throw new Error('chainKeyToChainLabelMap count decreased, please investigate');
+    if (chainLabelsKeyMapCountAfter < chainLabelsKeyMapCountBefore)
+        throw new Error('chainLabelsToKeyMap count decreased, please investigate');
+}
+const sluggifyString = (name) => name.toLowerCase().split(" ").join("-").split("'").join("");
+exports.sluggifyString = sluggifyString;
+function sortJSONData(jsonData) {
+    const sortedKeys = Object.keys(jsonData).sort();
+    const sortedData = {};
+    for (const key of sortedKeys) {
+        sortedData[key] = jsonData[key];
+    }
+    return sortedData;
+}
+const _chainLabelToChainIdCache = {};
+Object.entries(data_json_1.chainLabelsToKeyMap).forEach(([label, id]) => {
+    _chainLabelToChainIdCache[label] = id;
+    _chainLabelToChainIdCache[(0, exports.sluggifyString)(label)] = id;
+});
+// this is needed because multiple labels can point to the same chain key, so we need to ensure that while writing/reading from the cache, we always use the same label irrespective what is passed in
+// now, Avalance, Avax, avalanche -> avalanche
+function getSluggifiedChainLabel(label) {
+    const chainKey = getChainKeyFromLabel(label);
+    label = getChainLabelFromKey(chainKey);
+    return (0, exports.sluggifyString)(label);
+}
+// to be used if we are unsure if a label exists in our system, if it is known, use chainLabelsToKeyMap instead
+function getChainKeyFromLabel(label) {
+    let value = _chainLabelToChainIdCache[label];
+    if (!value) {
+        let sluggifiedLabel = (0, exports.sluggifyString)(label);
+        value = _chainLabelToChainIdCache[sluggifiedLabel];
+        if (!value) {
+            value = sluggifiedLabel.replace(/\-/g, '_'); // try replacing - with _
+            _chainLabelToChainIdCache[sluggifiedLabel] = value;
+        }
+        _chainLabelToChainIdCache[label] = value;
+    }
+    return value;
+}
+// to be used if we are unsure if a label exists in our system, if it is known, use chainKeyToChainLabelMap instead
+function getChainLabelFromKey(id) {
+    let value = data_json_1.chainKeyToChainLabelMap[id];
+    if (value)
+        return value;
+    value = id.slice(0, 1).toUpperCase() + id.slice(1); // Capitalize first letter
+    data_json_1.chainKeyToChainLabelMap[id] = value;
+    return value;
+}
+// returns the map of dead chains keyed by chain key, with the date (YYYY-MM-DD) the chain was marked dead as the value
+function getDeadChains() {
+    return deadChainsArray;
+}
+// returns a Set of dead chain keys (cached)
+function getDeadChainsSet() {
+    return deadChainsSet;
+}
+// returns true if the given chain (by key or label) is dead
+function isDeadChain(chainKeyOrLabel) {
+    if (deadChainsSet.has(chainKeyOrLabel))
+        return true;
+    return deadChainsSet.has(getChainKeyFromLabel(chainKeyOrLabel));
+}

package/build/util/coins.d.ts

@@ -0,0 +1,19 @@
+type CoinsApiData = {
+    decimals: number;
+    price: number;
+    symbol: string;
+    timestamp: number;
+    PK?: string;
+    isDistressed?: boolean;
+};
+type McapsApiData = {
+    mcap: number;
+    timestamp: number;
+};
+export declare function getPrices(readKeys: string[], timestamp: number | "now"): Promise<{
+    [address: string]: CoinsApiData;
+}>;
+export declare function getMcaps(readKeys: string[], timestamp: number | "now"): Promise<{
+    [address: string]: McapsApiData;
+}>;
+export {};

package/build/util/coins.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrices = getPrices;
+exports.getMcaps = getMcaps;
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("./env");
+const promisePool_1 = __importDefault(require("./promisePool"));
+const common_1 = require("./common");
+const _1 = require(".");
+const coinsApiKey = (0, env_1.getEnvValue)("COINS_API_KEY");
+const proApiKey = (0, env_1.getEnvValue)("INTERNAL_API_KEY");
+const bodySize = 100;
+function getBodies(readKeys, timestamp) {
+    const chunks = (0, _1.sliceIntoChunks)(readKeys, bodySize);
+    return chunks.map(chunk => {
+        const body = { coins: chunk };
+        if (timestamp !== "now")
+            body.timestamp = timestamp;
+        return body;
+    });
+}
+async function restCallWrapper(request, retries = 3, name = "-") {
+    retries--;
+    try {
+        const res = await request();
+        return res;
+    }
+    catch (e) {
+        if (retries <= 0)
+            throw (0, common_1.formError)(e);
+    }
+    await (0, common_1.sleepRandom)(2000 + 10000, 2000);
+    return restCallWrapper(request, retries, name);
+}
+async function fetchWithProFallback(body, subRoute) {
+    // if pro api key is set, try the pro route first and fall back to the normal route on failure
+    if (proApiKey) {
+        try {
+            return await restCallWrapper(() => axios_1.default.post(`https://pro-api.llama.fi/${proApiKey}/coins/${subRoute}`, body, {
+                headers: { "Content-Type": "application/json" },
+            }), 2);
+        }
+        catch (e) {
+            // fall through to the normal route below
+        }
+    }
+    return restCallWrapper(() => axios_1.default.post(`https://coins.llama.fi/${subRoute}`, body, {
+        headers: { "Content-Type": "application/json" },
+        params: { source: "internal", apikey: coinsApiKey },
+    }));
+}
+const nowCacheTTL = 1000 * 60 * 30; // 30 minutes, matches priceUpdateTime in computeTVL
+let lastNowCacheClear = +Date.now();
+function seedNowPriceCache() {
+    return {
+        "coingecko:tether": {
+            price: 1,
+            symbol: "USDT",
+            timestamp: Math.floor(Date.now() / 1e3 + 3600), // an hour from script start time
+        },
+    };
+}
+const priceCacheAll = {
+    now: seedNowPriceCache()
+};
+const mcapCacheAll = {};
+async function getPrices(readKeys, timestamp) {
+    return getPricesData(readKeys, timestamp, "price");
+}
+async function getPricesData(readKeys, timestamp, dataType) {
+    if (!readKeys.length)
+        return {};
+    // expire the "now" caches so current prices are never served older than nowCacheTTL
+    if (+Date.now() - lastNowCacheClear > nowCacheTTL) {
+        lastNowCacheClear = +Date.now();
+        priceCacheAll.now = seedNowPriceCache();
+        delete mcapCacheAll.now;
+    }
+    const cacheAllObject = dataType === "price" ? priceCacheAll : mcapCacheAll;
+    const subRoute = dataType === "price" ? "prices" : "mcaps";
+    const aggregatedRes = {};
+    const timestampString = timestamp.toString();
+    const priceCache = cacheAllObject[timestampString] || {};
+    if (!cacheAllObject[timestampString])
+        cacheAllObject[timestampString] = priceCache;
+    // read data from cache where possible
+    readKeys = readKeys.filter((PK) => {
+        const pkNormalized = PK.toLowerCase();
+        let pkData = priceCache[pkNormalized];
+        if (pkData) {
+            aggregatedRes[PK] = { ...pkData, PK };
+            return false;
+        }
+        return true;
+    });
+    const bodies = getBodies(readKeys, timestamp);
+    await (0, promisePool_1.default)({
+        items: bodies,
+        concurrency: 10,
+        processor: async (body) => {
+            if (!body.coins.length)
+                return;
+            const res = await fetchWithProFallback(body, subRoute);
+            const data = dataType === "price" ? res.data.coins : res.data;
+            Object.entries(data).forEach(([PK, value]) => {
+                const pkNormalized = PK.toLowerCase();
+                priceCache[pkNormalized] = value;
+            });
+            body.coins.forEach((PK) => {
+                const pkNormalized = PK.toLowerCase();
+                const coinData = priceCache[pkNormalized];
+                if (coinData)
+                    aggregatedRes[PK] = { ...coinData, PK };
+            });
+        },
+    });
+    return aggregatedRes;
+}
+async function getMcaps(readKeys, timestamp) {
+    return getPricesData(readKeys, timestamp, "mcap");
+}

package/build/util/common.d.ts

@@ -0,0 +1,34 @@
+import type { Balances, StringNumber, Address } from "../types";
+export declare function convertToBigInt(value: any): bigint;
+export declare function sumMultiBalanceOf(balances: Balances, results: {
+    ethCallCount?: number;
+    output: {
+        output: StringNumber;
+        success: boolean;
+        input: {
+            target: Address;
+            params: string[];
+        };
+    }[];
+}, allCallsMustBeSuccessful?: boolean, transformAddress?: (addr: string) => string): void;
+export declare function sumSingleBalance(balances: Balances, token: string, balance: string | number | BigInt, chain?: string): void;
+export declare function mergeBalances(balances: Balances, balancesToMerge: Balances): void;
+export declare function removeTokenBalance(balances: Balances, token: string, isCaseSensitive?: boolean): Balances;
+type ChainBlocks = {
+    [chain: string]: number;
+};
+export declare function sumChainTvls(chainTvls: Array<(timestamp: number, ethBlock: number, chainBlocks: ChainBlocks, params: any) => Promise<Balances>>): (timestamp: number, ethBlock: number, chainBlocks: ChainBlocks, params: any) => Promise<any>;
+export declare function getUniqueAddresses(addresses: string[], chain?: string): string[];
+export declare function getProviderUrl(provider: any): any;
+export declare function formErrorString(e: any, errorParams?: any): any;
+export declare function shortenString(str: string, length?: number): string;
+export declare function formError(e: any, errorParams?: any): Error;
+export declare function fetchJson(url: string, params?: any): Promise<any>;
+export declare function postJson(url: string, data?: any, params?: any): Promise<any>;
+export declare function tronToEvmAddress(address: string): string;
+export declare function evmToTronAddress(address: string): string;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function sleepRandom(max: number, min?: number): Promise<unknown>;
+export declare function fixTronCallParams(params: any): void;
+export declare function getHash(str: string | string[]): string;
+export {};