@defillama/sdk 4.0.76 → 4.0.78

package/build/util/blocks.d.ts

@@ -0,0 +1,33 @@
+import { Chain } from "../general";
+export declare const chainsForBlocks: string[];
+export declare function getChainBlocks(timestamp: number | undefined, chains?: Chain[]): Promise<{
+    [chain: string]: number;
+}>;
+export declare function getBlocks(timestamp: number, chains?: Chain[] | undefined): Promise<{
+    ethereumBlock: number;
+    chainBlocks: {
+        [chain: string]: number;
+    };
+}>;
+export declare function getCurrentBlocks(chains?: Chain[] | undefined): Promise<{
+    timestamp: number;
+    ethereumBlock: number;
+    chainBlocks: {
+        [chain: string]: number;
+    };
+}>;
+export declare function getBlock(chain: Chain, timestamp?: number): Promise<Block>;
+export declare function getCurrentChainBlock(chain?: Chain): Promise<Block>;
+export declare const getLatestBlock: typeof getCurrentChainBlock;
+export declare function lookupBlock(timestamp: number, extraParams?: {
+    chain?: Chain | "kava" | "algorand";
+    allowedTimeRange?: number;
+    acceptableBlockImprecision?: number;
+}): Promise<Block>;
+export declare function getTimestamp(height: number, chain: Chain): Promise<number>;
+export type Block = {
+    timestamp: number;
+    block: number;
+    hash?: string;
+    number: number;
+};

package/build/util/blocks.js

@@ -0,0 +1,423 @@
+"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.getTimestamp = exports.lookupBlock = exports.getLatestBlock = exports.getCurrentChainBlock = exports.getBlock = exports.getCurrentBlocks = exports.getBlocks = exports.getChainBlocks = exports.chainsForBlocks = void 0;
+var general_1 = require("../general");
+var node_fetch_1 = __importDefault(require("node-fetch"));
+var generalUtil_1 = require("../generalUtil");
+var debugLog_1 = require("./debugLog");
+var cosmos_1 = require("./cosmos");
+var cache_1 = require("./cache");
+var blockscout_1 = require("./blockscout");
+var defaultChains = ["avax", "bsc", "polygon", "arbitrum"];
+exports.chainsForBlocks = defaultChains;
+var blockRetries = 3;
+function getChainBlocks(timestamp, chains) {
+    if (chains === void 0) { chains = defaultChains; }
+    return __awaiter(this, void 0, void 0, function () {
+        var chainBlocks, setBlock;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    chainBlocks = {};
+                    setBlock = function (chain) { return __awaiter(_this, void 0, void 0, function () { var _a, _b; return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _a = chainBlocks;
+                                _b = chain;
+                                return [4 /*yield*/, getBlock(chain, timestamp)];
+                            case 1: return [2 /*return*/, _a[_b] = (_c.sent()).block];
+                        }
+                    }); }); };
+                    return [4 /*yield*/, Promise.all(chains.map(setBlock))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, chainBlocks];
+            }
+        });
+    });
+}
+exports.getChainBlocks = getChainBlocks;
+function getBlocks(timestamp, chains) {
+    if (chains === void 0) { chains = undefined; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, ethBlock, chainBlocks;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    chains = chains === null || chains === void 0 ? void 0 : chains.filter(function (i) { return i !== 'ethereum'; });
+                    return [4 /*yield*/, Promise.all([getBlock('ethereum', timestamp), getChainBlocks(timestamp, chains)])];
+                case 1:
+                    _a = _b.sent(), ethBlock = _a[0], chainBlocks = _a[1];
+                    chainBlocks['ethereum'] = ethBlock.block;
+                    return [2 /*return*/, {
+                            ethereumBlock: ethBlock.block,
+                            chainBlocks: chainBlocks,
+                        }];
+            }
+        });
+    });
+}
+exports.getBlocks = getBlocks;
+function getCurrentBlocks(chains) {
+    if (chains === void 0) { chains = undefined; }
+    return __awaiter(this, void 0, void 0, function () {
+        var block, chainBlocks;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (chains)
+                        chains = chains.filter(function (i) { return i !== "ethereum"; });
+                    return [4 /*yield*/, getBlock('ethereum')];
+                case 1:
+                    block = _a.sent();
+                    return [4 /*yield*/, getChainBlocks(undefined, chains)];
+                case 2:
+                    chainBlocks = _a.sent();
+                    chainBlocks['ethereum'] = block.block;
+                    return [2 /*return*/, {
+                            timestamp: block.timestamp,
+                            ethereumBlock: block.block,
+                            chainBlocks: chainBlocks,
+                        }];
+            }
+        });
+    });
+}
+exports.getCurrentBlocks = getCurrentBlocks;
+function getBlock(chain, timestamp) {
+    return __awaiter(this, void 0, void 0, function () {
+        var error, i, res, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!timestamp)
+                        return [2 /*return*/, getCurrentChainBlock(chain)];
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < blockRetries)) return [3 /*break*/, 6];
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, lookupBlock(timestamp, { chain: chain, })];
+                case 3:
+                    res = _a.sent();
+                    return [2 /*return*/, res];
+                case 4:
+                    e_1 = _a.sent();
+                    error = e_1;
+                    return [3 /*break*/, 5];
+                case 5:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 6: throw error;
+            }
+        });
+    });
+}
+exports.getBlock = getBlock;
+var refreshInterval = 1000 * 60 * 5; // 5 minutes
+function getCurrentChainBlock(chain) {
+    if (chain === void 0) { chain = 'ethereum'; }
+    var timestamp = (currentChainBlockCache[chain] || {}).timestamp;
+    var currentTimestamp = Date.now();
+    if (!timestamp || currentTimestamp - timestamp > refreshInterval) {
+        currentChainBlockCache[chain] = {
+            timestamp: currentTimestamp,
+            promise: _getCurrentChainBlock()
+        };
+    }
+    return currentChainBlockCache[chain].promise;
+    function _getCurrentChainBlock() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var provider, _c, number, timestamp_1, response, e_2;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 2, , 3]);
+                        provider = getExtraProvider(chain);
+                        return [4 /*yield*/, provider.getBlock('latest')];
+                    case 1:
+                        _c = _d.sent(), number = _c.number, timestamp_1 = _c.timestamp;
+                        response = { block: number, timestamp: timestamp_1, number: number };
+                        validateCurrentBlock(response, chain);
+                        currentChainBlockCache[chain] = { timestamp: currentTimestamp, promise: response };
+                        return [2 /*return*/, response]; // we are interested only in these fields
+                    case 2:
+                        e_2 = _d.sent();
+                        delete currentChainBlockCache[chain];
+                        if ((_b = (_a = e_2 === null || e_2 === void 0 ? void 0 : e_2.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, "Last block of chain"))
+                            throw e_2;
+                        throw (0, generalUtil_1.formError)(e_2);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    }
+}
+exports.getCurrentChainBlock = getCurrentChainBlock;
+var algorandBlockProvider = {
+    getBlock: function (height) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            if (height !== 'latest')
+                return [2 /*return*/, (0, node_fetch_1.default)("https://algoindexer.algoexplorerapi.io/v2/blocks/".concat(height))
+                        .then(function (res) { return res.json(); })
+                        .then(function (block) { return ({
+                        number: block.round,
+                        timestamp: block.timestamp
+                    }); })];
+            return [2 /*return*/, (0, node_fetch_1.default)('https://algoindexer.algoexplorerapi.io/health')
+                    .then(function (res) { return res.json(); })
+                    .then(function (block) { return algorandBlockProvider.getBlock(block.round); })];
+        });
+    }); }
+};
+function fetchBlockFromProvider(height, chain) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, block;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = getExtraProvider(chain !== null && chain !== void 0 ? chain : "ethereum");
+                    return [4 /*yield*/, provider.getBlock(height)];
+                case 1:
+                    block = _a.sent();
+                    if (block === null) {
+                        throw new Error("Can't get block of chain ".concat(chain !== null && chain !== void 0 ? chain : "ethereum"));
+                    }
+                    return [2 /*return*/, block];
+            }
+        });
+    });
+}
+function getExtraProvider(chain) {
+    if (chain && (0, cosmos_1.isCosmosChain)(chain))
+        return (0, cosmos_1.getCosmosProvider)(chain);
+    if (chain === "algorand")
+        return algorandBlockProvider;
+    return (0, general_1.getProvider)(chain);
+}
+exports.getLatestBlock = getCurrentChainBlock;
+var intialBlocks = {
+    terra: 4724001,
+    crab: 4969901
+};
+var blockTimeCache = (0, cache_1.getTempLocalCache)({ file: 'BlockCache.json', defaultData: {} });
+function validateCurrentBlock(block, chain) {
+    var _a, _b, _c, _d, _e, _f;
+    if (chain === void 0) { chain = 'ethereum'; }
+    var provider = getExtraProvider(chain);
+    var now = Math.floor(Date.now() / 1000);
+    var minutesDiff = Math.floor((now - block.timestamp) / 60);
+    if (minutesDiff > 60)
+        throw new Error("Last block for ".concat(chain, " is ").concat(minutesDiff, " minutes behind (").concat(new Date(block.timestamp * 1000), "). Provider is \"").concat((_b = (_a = provider === null || provider === void 0 ? void 0 : provider.connection) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : (_f = (_e = (_d = ((_c = provider === null || provider === void 0 ? void 0 : provider.providerConfigs) !== null && _c !== void 0 ? _c : [])[0]) === null || _d === void 0 ? void 0 : _d.provider) === null || _e === void 0 ? void 0 : _e.connection) === null || _f === void 0 ? void 0 : _f.url, "\""));
+}
+function lookupBlock(timestamp, extraParams) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        function updateBlock(blocks) {
+            if (blocks === void 0) { blocks = []; }
+            blocks.forEach(addBlockToCache);
+            var getPrecision = function (block) { return block.timestamp - timestamp > 0 ? block.timestamp - timestamp : timestamp - block.timestamp; };
+            blocks.push(highBlock, lowBlock);
+            blocks.sort(function (a, b) { return getPrecision(a) - getPrecision(b); });
+            block = blocks[0];
+            // find the closest upper and lower bound between 4 points
+            lowBlock = blocks.filter(function (i) { return i.timestamp < timestamp; }).reduce(function (lowestBlock, block) { return (timestamp - lowestBlock.timestamp) < (timestamp - block.timestamp) ? lowestBlock : block; });
+            highBlock = blocks.filter(function (i) { return i.timestamp > timestamp; }).reduce(function (highestBlock, block) { return (highestBlock.timestamp - timestamp) < (block.timestamp - timestamp) ? highestBlock : block; });
+            imprecision = getPrecision(block);
+            blockImprecision = highBlock.number - lowBlock.number;
+            // debugLog(`chain: ${chain} block: ${block.number} #calls: ${i} imprecision: ${Number((imprecision)/60).toFixed(2)} (min) block diff: ${blockImprecision} Time Taken: ${Number((Date.now()-time)/1000).toFixed(2)} (in sec)`)
+        }
+        function getChainBlockTimeCache(chain) {
+            if (!blockTimeCache[chain])
+                blockTimeCache[chain] = {};
+            return blockTimeCache[chain];
+        }
+        function addBlockToCache(block) {
+            var number = block.number, timestamp = block.timestamp;
+            getChainBlockTimeCache(chain)[block.number] = { number: number, timestamp: timestamp, };
+        }
+        function getLowBlock() {
+            return Object.values(getChainBlockTimeCache(chain))
+                .filter(function (i) { return i.timestamp < timestamp; })
+                .sort(function (a, b) { return b.timestamp - a.timestamp; })[0];
+        }
+        function getHighBlock() {
+            return Object.values(getChainBlockTimeCache(chain))
+                .filter(function (i) { return i.timestamp > timestamp; })
+                .sort(function (a, b) { return a.timestamp - b.timestamp; })[0];
+        }
+        var _c, _d, allowedTimeRange, _e, acceptableBlockImprecision, chain, block_1, e_3, api, res, data, low, lowBlock, highBlock, block, i, time, blockImprecision, imprecision, firstBlock, lastBlock, firstBlockNum, blockDiff, timeDiff, avgBlockTime, closeBlock, midBlock, blocks, e_4;
+        var _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    _c = extraParams !== null && extraParams !== void 0 ? extraParams : {}, _d = _c.allowedTimeRange, allowedTimeRange = _d === void 0 ? 5 * 60 : _d, _e = _c.acceptableBlockImprecision, acceptableBlockImprecision = _e === void 0 ? 10 : _e;
+                    chain = (_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum";
+                    if (!blockscout_1.blockscoutEndpoints[chain]) return [3 /*break*/, 4];
+                    _g.label = 1;
+                case 1:
+                    _g.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, (0, blockscout_1.getBlockscoutBlock)(timestamp, chain)];
+                case 2:
+                    block_1 = _g.sent();
+                    addBlockToCache(block_1);
+                    return [2 /*return*/, block_1];
+                case 3:
+                    e_3 = _g.sent();
+                    (0, debugLog_1.debugLog)('error fetching block from blockscout', e_3, chain);
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!(chain === 'waves')) return [3 /*break*/, 7];
+                    api = "https://nodes.wavesnodes.com/blocks/heightByTimestamp/".concat(timestamp);
+                    return [4 /*yield*/, (0, node_fetch_1.default)(api)];
+                case 5:
+                    res = _g.sent();
+                    return [4 /*yield*/, res.json()];
+                case 6:
+                    data = _g.sent();
+                    return [2 /*return*/, {
+                            timestamp: timestamp,
+                            block: +data.height,
+                            number: +data.height,
+                        }];
+                case 7:
+                    low = (_b = intialBlocks[chain]) !== null && _b !== void 0 ? _b : 100;
+                    lowBlock = getLowBlock();
+                    highBlock = getHighBlock();
+                    i = 0;
+                    time = Date.now();
+                    _g.label = 8;
+                case 8:
+                    _g.trys.push([8, 17, , 18]);
+                    firstBlock = void 0, lastBlock = void 0;
+                    if (!['evmos'].includes(chain)) return [3 /*break*/, 11];
+                    return [4 /*yield*/, (0, exports.getLatestBlock)(chain)];
+                case 9:
+                    lastBlock = _g.sent();
+                    firstBlockNum = lastBlock.number;
+                    switch (chain) {
+                        default: firstBlockNum -= 2 * 1e5; // evmos hold only the last 200k block data
+                    }
+                    return [4 /*yield*/, fetchBlockFromProvider(firstBlockNum, chain)];
+                case 10:
+                    firstBlock = _g.sent();
+                    return [3 /*break*/, 13];
+                case 11: return [4 /*yield*/, Promise.all([
+                        (0, exports.getLatestBlock)(chain),
+                        lowBlock ? lowBlock : fetchBlockFromProvider(low, chain),
+                    ])];
+                case 12:
+                    _f = _g.sent(), lastBlock = _f[0], firstBlock = _f[1];
+                    _g.label = 13;
+                case 13:
+                    lowBlock = firstBlock;
+                    if (!highBlock)
+                        highBlock = lastBlock;
+                    if (Math.abs(highBlock.timestamp - timestamp) < 60 * 30) {
+                        // Short-circuit in case we are trying to get the current block
+                        return [2 /*return*/, {
+                                block: highBlock.number,
+                                number: highBlock.number,
+                                timestamp: highBlock.timestamp
+                            }];
+                    }
+                    updateBlock();
+                    _g.label = 14;
+                case 14:
+                    if (!(imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision)) return [3 /*break*/, 16];
+                    ++i;
+                    blockDiff = highBlock.number - lowBlock.number;
+                    timeDiff = highBlock.timestamp - lowBlock.timestamp;
+                    avgBlockTime = timeDiff / blockDiff;
+                    closeBlock = Math.floor(lowBlock.number + (timestamp - lowBlock.timestamp) / avgBlockTime);
+                    if (closeBlock > highBlock.number)
+                        closeBlock = highBlock.number;
+                    midBlock = Math.floor((lowBlock.number + highBlock.number) / 2);
+                    return [4 /*yield*/, Promise.all([
+                            fetchBlockFromProvider(closeBlock, chain),
+                            fetchBlockFromProvider(midBlock, chain),
+                        ])];
+                case 15:
+                    blocks = _g.sent();
+                    updateBlock(blocks);
+                    return [3 /*break*/, 14];
+                case 16:
+                    (0, debugLog_1.debugLog)("chain: ".concat(chain, " block: ").concat(block.number, " #calls: ").concat(i, " imprecision: ").concat(Number((imprecision) / 60).toFixed(2), " (min) Time Taken: ").concat(Number((Date.now() - time) / 1000).toFixed(2), " (in sec)"));
+                    if (chain !== "bsc" && // this check is there because bsc halted the chain for few days
+                        Math.abs(block.timestamp - timestamp) > 3600) {
+                        throw new Error("Block selected is more than 1 hour away from the requested timestamp");
+                    }
+                    return [2 /*return*/, {
+                            number: block.number,
+                            block: block.number,
+                            timestamp: block.timestamp
+                        }];
+                case 17:
+                    e_4 = _g.sent();
+                    throw (0, generalUtil_1.formError)(e_4);
+                case 18: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.lookupBlock = lookupBlock;
+function getTimestamp(height, chain) {
+    return __awaiter(this, void 0, void 0, function () {
+        var provider, block;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    provider = getExtraProvider(chain);
+                    return [4 /*yield*/, provider.getBlock(height)];
+                case 1:
+                    block = _a.sent();
+                    return [2 /*return*/, block.timestamp];
+            }
+        });
+    });
+}
+exports.getTimestamp = getTimestamp;
+var currentChainBlockCache = (0, cache_1.getTempLocalCache)({ file: 'currentChainBlockCache.json', defaultData: {} });

package/build/util/blockscout.d.ts

@@ -0,0 +1,6 @@
+export declare const blockscoutEndpoints: any;
+export declare function getBlockscoutBlock(timestamp: number, chain: string): Promise<{
+    timestamp: number;
+    block: number;
+    number: number;
+}>;

package/build/util/blockscout.js

@@ -0,0 +1,71 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockscoutBlock = exports.blockscoutEndpoints = void 0;
+exports.blockscoutEndpoints = {
+    celo: 'https://explorer.celo.org',
+    kava: 'https://explorer.kava.io',
+    onus: 'https://explorer.onuschain.io',
+    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,
+                        }];
+            }
+        });
+    });
+}
+exports.getBlockscoutBlock = getBlockscoutBlock;

package/build/util/cache.d.ts

@@ -12,4 +12,9 @@ interface ReadCacheOptions {
 export declare function writeCache(file: string, data: any, options?: WriteCacheOptions): Promise<string | undefined>;
 export declare function parseCache(dataString: string | Buffer): Promise<any>;
 export declare function compressCache(data: any): Promise<Buffer>;
+export declare function getTempLocalCache({ file, defaultData, clearAfter }: {
+    file: string;
+    defaultData?: any;
+    clearAfter?: number;
+}): any;
 export {};

package/build/util/cache.js

@@ -37,7 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compressCache = exports.parseCache = exports.writeCache = exports.readCache = exports.currentVersion = void 0;
+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");
@@ -52,7 +52,8 @@ function zipAsync(data) {
 function unzipAsync(data) {
     return (0, util_1.promisify)(zlib_1.brotliDecompress)(data, brotliOptions).then(function (r) { return r.toString(); });
 }
-var fs = require('fs').promises;
+var _fs = require('fs');
+var fs = _fs.promises;
 var path = require('path');
 var foldersCreated = {};
 exports.currentVersion = 'zlib-1.0';
@@ -226,3 +227,50 @@ 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;
+    try {
+        var data = _fs.readFileSync(filePath);
+        fileData = JSON.parse(data.toString());
+        if (now - fileData.created > clearAfter)
+            fileData = emptyFile; // clear cache
+    }
+    catch (error) { }
+    // save cache on exit
+    process.on('exit', saveCache);
+    process.on('SIGTERM', saveCache);
+    process.on('SIGINT', saveCache);
+    return fileData.data;
+    function saveCache() {
+        if (saveCacheFlag)
+            return;
+        saveCacheFlag = true;
+        try {
+            removePromisesAndFunctions(fileData);
+            _fs.writeFileSync(filePath, JSON.stringify(fileData));
+        }
+        catch (error) {
+            (0, debugLog_1.debugLog)('Error writing cache:', error, file);
+        }
+    }
+    function removePromisesAndFunctions(data) {
+        if (typeof data === 'object') {
+            for (var key in data) {
+                if (typeof data[key] === 'function')
+                    delete data[key];
+                if (data[key] instanceof Promise)
+                    delete data[key];
+                else
+                    removePromisesAndFunctions(data[key]);
+            }
+        }
+    }
+}
+exports.getTempLocalCache = getTempLocalCache;

package/build/util/cosmos.d.ts

@@ -0,0 +1,11 @@
+export declare const isCosmosChain: (chain: string) => boolean;
+export declare function getCosmosBlock(block?: number | string, chain?: string): Promise<{
+    number: number;
+    timestamp: number;
+}>;
+export declare function getCosmosProvider(chain: string): {
+    getBlock: (block?: number | string) => Promise<{
+        number: number;
+        timestamp: number;
+    }>;
+};