@defillama/sdk 5.0.9 → 5.0.11

package/build/util/blockscout.js

@@ -1,42 +1,10 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlockscoutBlock = exports.blockscoutEndpoints = void 0;
+const axios_1 = __importDefault(require("axios"));
 exports.blockscoutEndpoints = {
     celo: 'https://explorer.celo.org',
     kava: 'https://explorer.kava.io',
@@ -44,28 +12,15 @@ exports.blockscoutEndpoints = {
     base: 'https://base.blockscout.com',
     scroll: 'https://blockscout.scroll.io',
 };
-function getBlockscoutBlock(timestamp, chain) {
-    return __awaiter(this, void 0, void 0, function () {
-        var api, res, data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    api = "".concat(exports.blockscoutEndpoints[chain], "/api?module=block&action=getblocknobytime&timestamp=").concat(timestamp, "&closest=before");
-                    return [4 /*yield*/, fetch(api)];
-                case 1:
-                    res = _a.sent();
-                    return [4 /*yield*/, res.json()];
-                case 2:
-                    data = _a.sent();
-                    if (data.status !== '1')
-                        throw new Error(data.message);
-                    return [2 /*return*/, {
-                            timestamp: timestamp,
-                            block: +data.result.blockNumber,
-                            number: +data.result.blockNumber,
-                        }];
-            }
-        });
-    });
+async function getBlockscoutBlock(timestamp, chain) {
+    const api = `${exports.blockscoutEndpoints[chain]}/api?module=block&action=getblocknobytime&timestamp=${timestamp}&closest=before`;
+    const { data } = await (0, axios_1.default)(api);
+    if (data.status !== '1')
+        throw new Error(data.message);
+    return {
+        timestamp,
+        block: +data.result.blockNumber,
+        number: +data.result.blockNumber,
+    };
 }
 exports.getBlockscoutBlock = getBlockscoutBlock;

package/build/util/cache.js

@@ -1,252 +1,124 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeExpiringJsonCache = exports.readExpiringJsonCache = exports.deleteCache = exports.getTempLocalCache = exports.compressCache = exports.parseCache = exports.writeCache = exports.readCache = exports.currentVersion = void 0;
-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,
-    _a);
+const debugLog_1 = require("./debugLog");
+const r2_1 = require("./r2");
+const zlib_1 = require("zlib");
+const util_1 = require("util");
+const env_1 = require("./env");
+const brotliOptions = {
+    [zlib_1.constants.BROTLI_PARAM_MODE]: zlib_1.constants.BROTLI_MODE_TEXT,
+    [zlib_1.constants.BROTLI_PARAM_QUALITY]: zlib_1.constants.BROTLI_MAX_QUALITY,
+};
 function zipAsync(data) {
     return (0, util_1.promisify)(zlib_1.brotliCompress)(data, brotliOptions);
 }
 function unzipAsync(data) {
-    return (0, util_1.promisify)(zlib_1.brotliDecompress)(data, brotliOptions).then(function (r) { return r.toString(); });
+    return (0, util_1.promisify)(zlib_1.brotliDecompress)(data, brotliOptions).then(r => r.toString());
 }
-var _fs = require('fs');
-var fs = _fs.promises;
-var path = require('path');
-var foldersCreated = {};
+const _fs = require('fs');
+const fs = _fs.promises;
+const path = require('path');
+const foldersCreated = {};
 exports.currentVersion = 'zlib-1.0';
 function getCacheRootFolder() {
-    var defaultCacheRootFolder = path.join(__dirname, 'local_cache');
+    const defaultCacheRootFolder = path.join(__dirname, 'local_cache');
     return path.join((0, env_1.getEnvCacheFolder)(defaultCacheRootFolder), exports.currentVersion);
 }
 function getFilePath(file) {
     return path.join(getCacheRootFolder(), file);
 }
-function createSubPath(folderPath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datRoot, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datRoot = getCacheRootFolder();
-                    folderPath = folderPath.replace(datRoot, '');
-                    if (foldersCreated[folderPath])
-                        return [2 /*return*/];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, fs.mkdir(path.join(datRoot, folderPath), { recursive: true })];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    error_1 = _a.sent();
-                    return [3 /*break*/, 4];
-                case 4:
-                    foldersCreated[folderPath] = true;
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function createSubPath(folderPath) {
+    const datRoot = getCacheRootFolder();
+    folderPath = folderPath.replace(datRoot, '');
+    if (foldersCreated[folderPath])
+        return;
+    try {
+        await fs.mkdir(path.join(datRoot, folderPath), { recursive: true });
+    }
+    catch (error) {
+        // sdk.log('Error creating folder path:', error)
+    }
+    foldersCreated[folderPath] = true;
 }
-function readCache(file, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        function readFile(file, options) {
-            if (options === void 0) { options = {}; }
-            return __awaiter(this, void 0, void 0, function () {
-                var filePath, data, error_3, r2Data;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            filePath = getFilePath(file);
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 7]);
-                            if (options.readFromR2Cache)
-                                throw new Error('Read from R2 cache');
-                            return [4 /*yield*/, fs.readFile(filePath)];
-                        case 2:
-                            data = _a.sent();
-                            return [2 /*return*/, data];
-                        case 3:
-                            error_3 = _a.sent();
-                            // debugLog('Error reading cache:', error)
-                            if (options.skipR2Cache)
-                                return [2 /*return*/];
-                            return [4 /*yield*/, (0, r2_1.getR2JSONString)(exports.currentVersion + '/' + file)];
-                        case 4:
-                            r2Data = _a.sent();
-                            if (!r2Data) return [3 /*break*/, 6];
-                            return [4 /*yield*/, writeCache(file, r2Data, { alreadyCompressed: true, skipR2CacheWrite: true })];
-                        case 5:
-                            _a.sent();
-                            return [2 /*return*/, r2Data];
-                        case 6: return [3 /*break*/, 7];
-                        case 7: return [2 /*return*/];
-                    }
-                });
-            });
+async function readCache(file, options = {}) {
+    try {
+        const data = await readFile(file, options);
+        return await parseCache(data);
+    }
+    catch (error) {
+        // debugLog('Error reading cache:', error)
+        return {};
+    }
+    async function readFile(file, options = {}) {
+        const filePath = getFilePath(file);
+        try {
+            if (options.readFromR2Cache)
+                throw new Error('Read from R2 cache');
+            const data = await fs.readFile(filePath);
+            return data;
         }
-        var data, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, readFile(file, options)];
-                case 1:
-                    data = _a.sent();
-                    return [4 /*yield*/, parseCache(data)];
-                case 2: return [2 /*return*/, _a.sent()];
-                case 3:
-                    error_2 = _a.sent();
-                    // debugLog('Error reading cache:', error)
-                    return [2 /*return*/, {}];
-                case 4: return [2 /*return*/];
+        catch (error) {
+            // debugLog('Error reading cache:', error)
+            if (options.skipR2Cache)
+                return;
+            const r2Data = await (0, r2_1.getR2JSONString)(exports.currentVersion + '/' + file);
+            if (r2Data) {
+                await writeCache(file, r2Data, { alreadyCompressed: true, skipR2CacheWrite: true });
+                return r2Data;
             }
-        });
-    });
+        }
+    }
 }
 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, 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];
-                case 1: return [4 /*yield*/, compressCache(data)];
-                case 2:
-                    _a = _d.sent();
-                    _d.label = 3;
-                case 3:
-                    fileData = _a;
-                    if (!data || (typeof data === 'string' && data.length < 20) || fileData.length < 20) {
-                        (0, debugLog_1.debugLog)('Data too small to cache: ', file);
-                        return [2 /*return*/];
-                    }
-                    _b = isSameData;
-                    _c = [data];
-                    return [4 /*yield*/, readCache(file, { skipR2Cache: true })];
-                case 4:
-                    if (_b.apply(void 0, _c.concat([_d.sent()])))
-                        return [2 /*return*/];
-                    filePath = getFilePath(file);
-                    return [4 /*yield*/, createSubPath(path.dirname(filePath))];
-                case 5:
-                    _d.sent();
-                    return [4 /*yield*/, fs.writeFile(filePath, fileData)];
-                case 6:
-                    _d.sent();
-                    if (!!options.skipR2CacheWrite) return [3 /*break*/, 8];
-                    return [4 /*yield*/, (0, r2_1.storeR2JSONString)(exports.currentVersion + '/' + file, fileData)];
-                case 7:
-                    _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*/];
-            }
-        });
-    });
+async function writeCache(file, data, options = {}) {
+    try {
+        const fileData = options.alreadyCompressed ? data : await compressCache(data);
+        if (!data || (typeof data === 'string' && data.length < 20) || fileData.length < 20) {
+            (0, debugLog_1.debugLog)('Data too small to cache: ', file);
+            return;
+        }
+        if (isSameData(data, await readCache(file, { skipR2Cache: true })))
+            return;
+        const filePath = getFilePath(file);
+        await createSubPath(path.dirname(filePath));
+        await fs.writeFile(filePath, fileData);
+        if (!options.skipR2CacheWrite) {
+            await (0, r2_1.storeR2JSONString)(exports.currentVersion + '/' + file, fileData);
+        }
+        return fileData;
+    }
+    catch (error) {
+        (0, debugLog_1.debugLog)('Error writing cache:', error);
+    }
 }
 exports.writeCache = writeCache;
-function parseCache(dataString) {
-    return __awaiter(this, void 0, void 0, function () {
-        var decompressed;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (typeof dataString === 'string')
-                        dataString = Buffer.from(dataString, 'base64');
-                    return [4 /*yield*/, unzipAsync(dataString)];
-                case 1:
-                    decompressed = _a.sent();
-                    return [2 /*return*/, JSON.parse(decompressed).llamaWrapped];
-            }
-        });
-    });
+async function parseCache(dataString) {
+    if (typeof dataString === 'string')
+        dataString = Buffer.from(dataString, 'base64');
+    const decompressed = await unzipAsync(dataString);
+    return JSON.parse(decompressed).llamaWrapped;
 }
 exports.parseCache = parseCache;
-function compressCache(data) {
-    return __awaiter(this, void 0, void 0, function () {
-        var comressedCache;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, zipAsync(JSON.stringify({ version: exports.currentVersion, llamaWrapped: data }))];
-                case 1:
-                    comressedCache = _a.sent();
-                    return [2 /*return*/, comressedCache];
-            }
-        });
-    });
+async function compressCache(data) {
+    const comressedCache = await zipAsync(JSON.stringify({ version: exports.currentVersion, llamaWrapped: data }));
+    return comressedCache;
 }
 exports.compressCache = compressCache;
 function isSameData(data1, data2) {
     return JSON.stringify(data1) === JSON.stringify(data2);
 }
-var ONE_WEEK = 1000 * 60 * 60 * 24 * 7;
-function getTempLocalCache(_a) {
-    var file = _a.file, _b = _a.defaultData, defaultData = _b === void 0 ? {} : _b, _c = _a.clearAfter, clearAfter = _c === void 0 ? ONE_WEEK : _c;
-    var cache = defaultData;
-    var now = Math.floor(Date.now() / 1e3);
-    var emptyFile = { created: now, data: defaultData };
-    var fileData = emptyFile;
-    var filePath = getFilePath(file);
-    var saveCacheFlag = false;
+const ONE_WEEK = 1000 * 60 * 60 * 24 * 7;
+function getTempLocalCache({ file, defaultData = {}, clearAfter = ONE_WEEK }) {
+    let cache = defaultData;
+    const now = Math.floor(Date.now() / 1e3);
+    let emptyFile = { created: now, data: defaultData };
+    let fileData = emptyFile;
+    const filePath = getFilePath(file);
+    let saveCacheFlag = false;
     createSubPath(path.dirname(filePath)); // create folder if not exists, this is async but we don't care
     try {
-        var data = _fs.readFileSync(filePath);
+        const data = _fs.readFileSync(filePath);
         fileData = JSON.parse(data.toString());
         if (now - fileData.created > clearAfter)
             fileData = emptyFile; // clear cache
@@ -272,7 +144,7 @@ function getTempLocalCache(_a) {
     }
     function removePromisesAndFunctions(data) {
         if (typeof data === 'object') {
-            for (var key in data) {
+            for (const key in data) {
                 if (typeof data[key] === 'function')
                     delete data[key];
                 if (data[key] instanceof Promise)
@@ -285,64 +157,30 @@ function getTempLocalCache(_a) {
 }
 exports.getTempLocalCache = getTempLocalCache;
 // this removes data only from the file cache, not from the R2 cache
-function deleteCache(file) {
-    return __awaiter(this, void 0, void 0, function () {
-        var filePath;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    filePath = getFilePath(file);
-                    return [4 /*yield*/, fs.unlink(filePath)];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function deleteCache(file) {
+    const filePath = getFilePath(file);
+    await fs.unlink(filePath);
 }
 exports.deleteCache = deleteCache;
-function readExpiringJsonCache(file) {
-    return __awaiter(this, void 0, void 0, function () {
-        var options, data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    options = { readFromR2Cache: false, skipR2Cache: true };
-                    file = 'expiring/' + file;
-                    return [4 /*yield*/, readCache(file, options)];
-                case 1:
-                    data = _a.sent();
-                    if (!data || Object.keys(data).length === 0)
-                        return [2 /*return*/, null];
-                    if (!(data.expiryTimestamp < (Date.now() / 1e3))) return [3 /*break*/, 3];
-                    return [4 /*yield*/, deleteCache(file)];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/, null];
-                case 3: return [2 /*return*/, data.data];
-            }
-        });
-    });
+async function readExpiringJsonCache(file) {
+    const options = { readFromR2Cache: false, skipR2Cache: true };
+    file = 'expiring/' + file;
+    const data = await readCache(file, options);
+    if (!data || Object.keys(data).length === 0)
+        return null;
+    if (data.expiryTimestamp < (Date.now() / 1e3)) {
+        await deleteCache(file);
+        return null;
+    }
+    return data.data;
 }
 exports.readExpiringJsonCache = readExpiringJsonCache;
-function writeExpiringJsonCache(file, data, _a) {
-    var _b = _a.expireAfter, expireAfter = _b === void 0 ? 60 * 60 * 24 : _b, // cache for 1 day by default
-    expiryTimestamp = _a.expiryTimestamp;
-    return __awaiter(this, void 0, void 0, function () {
-        var options;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    file = 'expiring/' + file;
-                    if (!expiryTimestamp)
-                        expiryTimestamp = Math.floor(Date.now() / 1e3) + expireAfter;
-                    options = { skipR2CacheWrite: true };
-                    return [4 /*yield*/, writeCache(file, { data: data, expiryTimestamp: expiryTimestamp }, options)];
-                case 1:
-                    _c.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function writeExpiringJsonCache(file, data, { expireAfter = 60 * 60 * 24, // cache for 1 day by default
+expiryTimestamp, }) {
+    file = 'expiring/' + file;
+    if (!expiryTimestamp)
+        expiryTimestamp = Math.floor(Date.now() / 1e3) + expireAfter;
+    const options = { skipR2CacheWrite: true };
+    await writeCache(file, { data, expiryTimestamp }, options);
 }
 exports.writeExpiringJsonCache = writeExpiringJsonCache;