@defillama/sdk 5.0.6 → 5.0.9

package/build/util/cache.js

@@ -42,6 +42,7 @@ var debugLog_1 = require("./debugLog");
 var r2_1 = require("./r2");
 var zlib_1 = require("zlib");
 var util_1 = require("util");
+var env_1 = require("./env");
 var brotliOptions = (_a = {},
     _a[zlib_1.constants.BROTLI_PARAM_MODE] = zlib_1.constants.BROTLI_MODE_TEXT,
     _a[zlib_1.constants.BROTLI_PARAM_QUALITY] = zlib_1.constants.BROTLI_MAX_QUALITY,
@@ -58,7 +59,8 @@ var path = require('path');
 var foldersCreated = {};
 exports.currentVersion = 'zlib-1.0';
 function getCacheRootFolder() {
-    return path.join(process.env.TVL_LOCAL_CACHE_ROOT_FOLDER || path.join(__dirname, 'local_cache'), exports.currentVersion);
+    var defaultCacheRootFolder = path.join(__dirname, 'local_cache');
+    return path.join((0, env_1.getEnvCacheFolder)(defaultCacheRootFolder), exports.currentVersion);
 }
 function getFilePath(file) {
     return path.join(getCacheRootFolder(), file);
@@ -152,10 +154,11 @@ exports.readCache = readCache;
 function writeCache(file, data, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
-        var fileData, _a, _b, _c, filePath;
+        var fileData, _a, _b, _c, filePath, error_4;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
+                    _d.trys.push([0, 9, , 10]);
                     if (!options.alreadyCompressed) return [3 /*break*/, 1];
                     _a = data;
                     return [3 /*break*/, 3];
@@ -188,6 +191,11 @@ function writeCache(file, data, options) {
                     _d.sent();
                     _d.label = 8;
                 case 8: return [2 /*return*/, fileData];
+                case 9:
+                    error_4 = _d.sent();
+                    (0, debugLog_1.debugLog)('Error writing cache:', error_4);
+                    return [3 /*break*/, 10];
+                case 10: return [2 /*return*/];
             }
         });
     });

package/build/util/cosmos.js

@@ -41,6 +41,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCosmosProvider = exports.getCosmosBlock = exports.isCosmosChain = void 0;
 var node_fetch_1 = __importDefault(require("node-fetch"));
+var env_1 = require("./env");
 // where to find chain info
 // https://proxy.atomscan.com/chains.json
 // https://cosmos-chain.directory/chains/cosmoshub
@@ -89,7 +90,7 @@ function getCosmosBlock(block, chain) {
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
-                    endPoint = process.env[chain.toUpperCase() + '_RPC'] || endPoints[chain] || 'https://rest.cosmos.directory/' + chain;
+                    endPoint = (0, env_1.getEnvRPC)(chain) || endPoints[chain] || 'https://rest.cosmos.directory/' + chain;
                     _c.label = 1;
                 case 1:
                     _c.trys.push([1, 4, , 5]);

package/build/util/debugLog.d.ts

@@ -1,3 +1,3 @@
-export declare const DEBUG_ENABLED: string | true | undefined;
+export declare const DEBUG_ENABLED: boolean;
 export declare function debugLog(...args: any): void;
 export declare function debugTable(...args: any): void;

package/build/util/debugLog.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugTable = exports.debugLog = exports.DEBUG_ENABLED = void 0;
-exports.DEBUG_ENABLED = process.env.SDK_DEBUG === "true" || process.env.LLAMA_DEBUG_MODE;
+var env_1 = require("./env");
+exports.DEBUG_ENABLED = env_1.ENV_CONSTANTS.SDK_DEBUG === "true";
 function debugLog() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {

package/build/util/env.d.ts

@@ -0,0 +1,14 @@
+export declare const ENV_CONSTANTS: {
+    [x: string]: string | undefined;
+};
+export declare function getChainId(chain: string, chainId: number | undefined): number | undefined;
+export declare function getMaxParallelRequests(chain: string): number;
+export declare function getParallelGetLogsLimit(chain: string): number;
+export declare function getEnvRPC(chain: string): string | undefined;
+export declare function getEnvValue(key: string, defaultValue?: string): string | undefined;
+export declare function getEnvCacheFolder(defaultCacheFolder: string): string;
+export declare function getEnvMulticallAddress(chain: string): string | undefined;
+export declare function getDefaultChunkSize(chain: string): number;
+export declare function getBatchMaxCount(chain: string): number;
+export declare function getArchivalRPCs(chain: string): string[];
+export declare function getChainRPCs(chain: string, defaultList?: string[]): string | undefined;

package/build/util/env.js

@@ -0,0 +1,103 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChainRPCs = exports.getArchivalRPCs = exports.getBatchMaxCount = exports.getDefaultChunkSize = exports.getEnvMulticallAddress = exports.getEnvCacheFolder = exports.getEnvValue = exports.getEnvRPC = exports.getParallelGetLogsLimit = exports.getMaxParallelRequests = exports.getChainId = exports.ENV_CONSTANTS = void 0;
+var _ENV_CONSTANTS = {
+    DEBUG_ENABLED: getEnvValue('DEBUG') === "true" || process.env.LLAMA_DEBUG_MODE ? 'true' : 'false',
+};
+var whitelistedEnvConstants = [
+    'R2_ENDPOINT', 'R2_ACCESS_KEY_ID', 'R2_SECRET_ACCESS_KEY', 'TRON_PRO_API_KEY',
+];
+var defaultEnvValues = {
+    INTERNAL_SDK_CACHE_FILE: './cache.json',
+    TRON_RPC_CONCURRENCY_LIMIT: '5',
+    TRON_RPC: 'https://api.trongrid.io',
+};
+whitelistedEnvConstants.forEach(function (key) { return _ENV_CONSTANTS[key] = getEnvValue(key); });
+Object.keys(defaultEnvValues).forEach(function (key) { return _ENV_CONSTANTS[key] = getEnvValue(key, defaultEnvValues[key]); });
+// doing this as I am paranoid that that empty object when first declared might be exported before values are set
+exports.ENV_CONSTANTS = __assign({}, _ENV_CONSTANTS);
+function getChainId(chain, chainId) {
+    var _a;
+    var value = (_a = getEnvValue("".concat(chain, "_RPC_CHAIN_ID"))) !== null && _a !== void 0 ? _a : chainId;
+    if (value)
+        return +value;
+}
+exports.getChainId = getChainId;
+function getMaxParallelRequests(chain) {
+    var chainKey = "".concat(chain, "_RPC_MAX_PARALLEL");
+    if (getEnvValue(chainKey))
+        return +getEnvValue(chainKey);
+    if (['harmony', 'avax'].includes(chain))
+        return 20;
+    return +getEnvValue('MAX_PARALLEL', '100');
+}
+exports.getMaxParallelRequests = getMaxParallelRequests;
+function getParallelGetLogsLimit(chain) {
+    var defaultLimit = chain === 'fantom' ? '10' : '42';
+    return +(getEnvValue("".concat(chain, "_RPC_GET_LOGS_CONCURRENCY_LIMIT"), defaultLimit));
+}
+exports.getParallelGetLogsLimit = getParallelGetLogsLimit;
+function getEnvRPC(chain) {
+    return getEnvValue("".concat(chain, "_RPC"));
+}
+exports.getEnvRPC = getEnvRPC;
+function getEnvValue(key, defaultValue) {
+    var _a, _b, _c;
+    key = key.toUpperCase();
+    return (_c = (_b = (_a = process.env[key]) !== null && _a !== void 0 ? _a : process.env['SDK_' + key]) !== null && _b !== void 0 ? _b : process.env['LLAMA_SDK_' + key]) !== null && _c !== void 0 ? _c : defaultValue;
+}
+exports.getEnvValue = getEnvValue;
+function getEnvCacheFolder(defaultCacheFolder) {
+    return getEnvValue('TVL_LOCAL_CACHE_ROOT_FOLDER', defaultCacheFolder);
+}
+exports.getEnvCacheFolder = getEnvCacheFolder;
+function getEnvMulticallAddress(chain) {
+    return getEnvValue("".concat(chain, "_RPC_MULTICALL"));
+}
+exports.getEnvMulticallAddress = getEnvMulticallAddress;
+function getDefaultChunkSize(chain) {
+    var key = chain + '_MULTICALL_CHUNK_SIZE';
+    if (getEnvValue(key))
+        return +getEnvValue(key);
+    if (chain === 'cronos')
+        return 50;
+    return +(getEnvValue('MULTICALL_CHUNK_SIZE', '300'));
+}
+exports.getDefaultChunkSize = getDefaultChunkSize;
+function getBatchMaxCount(chain) {
+    var key = chain + 'BATCH_MAX_COUNT';
+    if (getEnvValue(key))
+        return +getEnvValue(key);
+    if (chain === 'cronos')
+        return 10;
+    return +(getEnvValue('BATCH_MAX_COUNT', '99'));
+}
+exports.getBatchMaxCount = getBatchMaxCount;
+function getArchivalRPCs(chain) {
+    var key = chain + '_ARCHIVAL_RPC';
+    if (getEnvValue(key))
+        return getEnvValue(key).split(',');
+    return [];
+}
+exports.getArchivalRPCs = getArchivalRPCs;
+function getChainRPCs(chain, defaultList) {
+    if (defaultList === void 0) { defaultList = []; }
+    var key = chain + '_RPC';
+    if (getEnvValue(key))
+        return getEnvValue(key).split(',').concat(defaultList).join(',');
+    if (defaultList.length === 0)
+        return undefined;
+    return defaultList.join(',');
+}
+exports.getChainRPCs = getChainRPCs;

package/build/util/index.js

@@ -111,9 +111,9 @@ function getLogs(params) {
                 case 4:
                     e_1 = _b.sent();
                     (0, debugLog_1.debugLog)("Error fetching logs for chain ".concat(params.chain, " blockSpread: ").concat(blockSpread, ". ").concat((0, generalUtil_1.formError)(e_1, { chain: params.chain, target: params.target, provider: provider })));
-                    if (blockSpread >= 2e3) {
+                    if (blockSpread >= 1500) {
                         // We got too many results
-                        // We could chop it up into 2K block spreads as that is guaranteed to always return but then we'll have to make a lot of queries (easily >1000), so instead we'll keep dividing the block spread by two until we make it
+                        // We could chop it up into 1500 block spreads as that is guaranteed to always return but then we'll have to make a lot of queries (easily >1000), so instead we'll keep dividing the block spread by two until we make it
                         blockSpread = Math.floor(blockSpread / 2);
                     }
                     else {

package/build/util/internal-cache.js

@@ -25,8 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retriveCache = exports.startCache = exports.saveCache = exports.setCache = exports.getCache = void 0;
 var fs = __importStar(require("fs"));
+var env_1 = require("./env");
 // const cacheFile = __dirname + '/../../../sc-cache1.json'
-var cacheFile = process.env.INTERNAL_SDK_CACHE_FILE;
+var cacheFile = env_1.ENV_CONSTANTS.INTERNAL_SDK_CACHE_FILE;
 var cache = {};
 // if (cacheFile) cache = require(cacheFile) // disabled for now
 function getCache(options) {

package/build/util/logs.js

@@ -57,6 +57,7 @@ var blocks_1 = require("./blocks");
 var cache_1 = require("./cache");
 var debugLog_1 = require("./debugLog");
 var p_limit_1 = __importDefault(require("p-limit"));
+var env_1 = require("./env");
 var currentVersion = 'v2';
 function getLogs(options) {
     return __awaiter(this, void 0, void 0, function () {
@@ -240,10 +241,7 @@ function getChainLimiter(chain) {
         chainLimiters[chain] = createLimiter(chain);
     return chainLimiters[chain];
     function createLimiter(chain) {
-        var _a;
-        var defaultLimit = chain === 'fantom' ? 10 : 20;
-        var limit = +((_a = process.env["".concat(chain.toUpperCase(), "_RPC_GET_LOGS_CONCURRENCY_LIMIT")]) !== null && _a !== void 0 ? _a : defaultLimit);
-        return (0, p_limit_1.default)(limit);
+        return (0, p_limit_1.default)((0, env_1.getParallelGetLogsLimit)(chain));
     }
 }
 exports.default = getLogs;

package/build/util/r2.js

@@ -37,8 +37,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getR2JSONString = exports.storeR2JSONString = void 0;
+var env_1 = require("./env");
 var _a = require("@aws-sdk/client-s3"), S3Client = _a.S3Client, PutObjectCommand = _a.PutObjectCommand, GetObjectCommand = _a.GetObjectCommand;
-var _b = process.env, R2_ENDPOINT = _b.R2_ENDPOINT, R2_ACCESS_KEY_ID = _b.R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY = _b.R2_SECRET_ACCESS_KEY;
+var R2_ENDPOINT = env_1.ENV_CONSTANTS.R2_ENDPOINT, R2_ACCESS_KEY_ID = env_1.ENV_CONSTANTS.R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY = env_1.ENV_CONSTANTS.R2_SECRET_ACCESS_KEY;
 var datasetBucket = "defillama-datasets";
 var publicBucketUrl = "https://defillama-datasets.llama.fi";
 var R2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defillama/sdk",
-  "version": "5.0.6",
+  "version": "5.0.9",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {