@defillama/sdk 5.0.9 → 5.0.11

package/build/util/blocks.js

@@ -1,166 +1,69 @@
 "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"];
+const general_1 = require("../general");
+const axios_1 = __importDefault(require("axios"));
+const generalUtil_1 = require("../generalUtil");
+const debugLog_1 = require("./debugLog");
+const cosmos_1 = require("./cosmos");
+const cache_1 = require("./cache");
+const blockscout_1 = require("./blockscout");
+const 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];
-            }
-        });
-    });
+const blockRetries = 3;
+async function getChainBlocks(timestamp, chains = defaultChains) {
+    const chainBlocks = {};
+    const setBlock = async (chain) => chainBlocks[chain] = (await getBlock(chain, timestamp)).block;
+    await Promise.all(chains.map(setBlock));
+    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,
-                        }];
-            }
-        });
-    });
+async function getBlocks(timestamp, chains = undefined) {
+    chains = chains === null || chains === void 0 ? void 0 : chains.filter(i => i !== 'ethereum');
+    const [ethBlock, chainBlocks] = await Promise.all([getBlock('ethereum', timestamp), getChainBlocks(timestamp, chains)]);
+    chainBlocks['ethereum'] = ethBlock.block;
+    return {
+        ethereumBlock: ethBlock.block,
+        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,
-                        }];
-            }
-        });
-    });
+async function getCurrentBlocks(chains = undefined) {
+    if (chains)
+        chains = chains.filter(i => i !== "ethereum");
+    const block = await getBlock('ethereum');
+    const chainBlocks = await getChainBlocks(undefined, chains);
+    chainBlocks['ethereum'] = block.block;
+    return {
+        timestamp: block.timestamp,
+        ethereumBlock: block.block,
+        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;
-            }
-        });
-    });
+async function getBlock(chain, timestamp) {
+    if (!timestamp)
+        return getCurrentChainBlock(chain);
+    let error;
+    for (let i = 0; i < blockRetries; i++) {
+        try {
+            let res = await lookupBlock(timestamp, { chain, });
+            return res;
+        }
+        catch (e) {
+            error = e;
+        }
+    }
+    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();
+const refreshInterval = 1000 * 60 * 5; // 5 minutes
+function getCurrentChainBlock(chain = 'ethereum') {
+    const { timestamp, } = currentChainBlockCache[chain] || {};
+    const currentTimestamp = Date.now();
     if (!timestamp || currentTimestamp - timestamp > refreshInterval) {
         currentChainBlockCache[chain] = {
             timestamp: currentTimestamp,
@@ -168,68 +71,46 @@ function getCurrentChainBlock(chain) {
         };
     }
     return currentChainBlockCache[chain].promise;
-    function _getCurrentChainBlock() {
+    async 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*/];
-                }
-            });
-        });
+        try {
+            const provider = getExtraProvider(chain);
+            const { number, timestamp, } = await provider.getBlock('latest');
+            const response = { block: number, timestamp, number };
+            validateCurrentBlock(response, chain);
+            currentChainBlockCache[chain] = { timestamp: currentTimestamp, promise: response };
+            return response; // we are interested only in these fields
+        }
+        catch (e) {
+            delete currentChainBlockCache[chain];
+            if ((_b = (_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, "Last block of chain"))
+                throw e;
+            throw (0, generalUtil_1.formError)(e);
+        }
     }
 }
 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); })];
-        });
-    }); }
+const algorandBlockProvider = {
+    getBlock: async (height) => {
+        if (height !== 'latest')
+            return (0, axios_1.default)(`https://algoindexer.algoexplorerapi.io/v2/blocks/${height}`)
+                .then((res) => res.data)
+                .then((block) => ({
+                number: block.round,
+                timestamp: block.timestamp
+            }));
+        return (0, axios_1.default)('https://algoindexer.algoexplorerapi.io/health')
+            .then((res) => res.data)
+            .then((block) => 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];
-            }
-        });
-    });
+async function fetchBlockFromProvider(height, chain) {
+    const provider = getExtraProvider(chain !== null && chain !== void 0 ? chain : "ethereum");
+    const block = await provider.getBlock(height);
+    if (block === null) {
+        throw new Error(`Can't get block of chain ${chain !== null && chain !== void 0 ? chain : "ethereum"}`);
+    }
+    return block;
 }
 function getExtraProvider(chain) {
     if (chain && (0, cosmos_1.isCosmosChain)(chain))
@@ -239,184 +120,144 @@ function getExtraProvider(chain) {
     return (0, general_1.getProvider)(chain);
 }
 exports.getLatestBlock = getCurrentChainBlock;
-var intialBlocks = {
+const intialBlocks = {
     terra: 4724001,
     crab: 4969901
 };
-var blockTimeCache = (0, cache_1.getTempLocalCache)({ file: 'BlockCache.json', defaultData: {} });
-function validateCurrentBlock(block, chain) {
-    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);
+const blockTimeCache = (0, cache_1.getTempLocalCache)({ file: 'BlockCache.json', defaultData: {} });
+function validateCurrentBlock(block, chain = 'ethereum') {
+    const provider = getExtraProvider(chain);
+    const now = Math.floor(Date.now() / 1000);
+    const 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((0, generalUtil_1.getProviderUrl)(provider), "\""));
+        throw new Error(`Last block for ${chain} is ${minutesDiff} minutes behind (${new Date(block.timestamp * 1000)}). Provider is "${(0, generalUtil_1.getProviderUrl)(provider)}"`);
 }
-function lookupBlock(timestamp, extraParams) {
+async 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)`)
+    const { allowedTimeRange = 5 * 60, acceptableBlockImprecision = 10 } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
+    const chain = (_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum";
+    if (blockscout_1.blockscoutEndpoints[chain]) {
+        try {
+            const block = await (0, blockscout_1.getBlockscoutBlock)(timestamp, chain);
+            addBlockToCache(block);
+            return block;
         }
-        function getChainBlockTimeCache(chain) {
-            if (!blockTimeCache[chain])
-                blockTimeCache[chain] = {};
-            return blockTimeCache[chain];
+        catch (e) { // fallback to usual way of fetching logs
+            (0, debugLog_1.debugLog)('error fetching block from blockscout', e, chain);
         }
-        function addBlockToCache(block) {
-            var number = block.number, timestamp = block.timestamp;
-            getChainBlockTimeCache(chain)[block.number] = { number: number, timestamp: timestamp, };
+    }
+    if (chain === 'waves') {
+        const api = `https://nodes.wavesnodes.com/blocks/heightByTimestamp/${timestamp}`;
+        const { data } = await (0, axios_1.default)(api);
+        return {
+            timestamp,
+            block: +data.height,
+            number: +data.height,
+        };
+    }
+    let low = (_b = intialBlocks[chain]) !== null && _b !== void 0 ? _b : 100;
+    let lowBlock = getLowBlock();
+    let highBlock = getHighBlock();
+    let block;
+    let i = 0;
+    let time = Date.now();
+    let blockImprecision;
+    let imprecision;
+    try {
+        let firstBlock, lastBlock;
+        if (['evmos'].includes(chain)) {
+            lastBlock = await (0, exports.getLatestBlock)(chain);
+            let firstBlockNum = lastBlock.number;
+            switch (chain) {
+                default: firstBlockNum -= 2 * 1e5; // evmos hold only the last 200k block data
+            }
+            firstBlock = await fetchBlockFromProvider(firstBlockNum, chain);
         }
-        function getLowBlock() {
-            return Object.values(getChainBlockTimeCache(chain))
-                .filter(function (i) { return i.timestamp < timestamp; })
-                .sort(function (a, b) { return b.timestamp - a.timestamp; })[0];
+        else {
+            [lastBlock, firstBlock] = await Promise.all([
+                (0, exports.getLatestBlock)(chain),
+                lowBlock ? lowBlock : fetchBlockFromProvider(low, chain),
+            ]);
         }
-        function getHighBlock() {
-            return Object.values(getChainBlockTimeCache(chain))
-                .filter(function (i) { return i.timestamp > timestamp; })
-                .sort(function (a, b) { return a.timestamp - b.timestamp; })[0];
+        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 {
+                block: highBlock.number,
+                number: highBlock.number,
+                timestamp: highBlock.timestamp
+            };
         }
-        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*/];
-            }
-        });
-    });
+        updateBlock();
+        while (imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision) { // We lose some precision (max ~15 minutes) but reduce #calls needed 
+            ++i;
+            const blockDiff = highBlock.number - lowBlock.number;
+            const timeDiff = highBlock.timestamp - lowBlock.timestamp;
+            const avgBlockTime = timeDiff / blockDiff;
+            let closeBlock = Math.floor(lowBlock.number + (timestamp - lowBlock.timestamp) / avgBlockTime);
+            if (closeBlock > highBlock.number)
+                closeBlock = highBlock.number;
+            const midBlock = Math.floor((lowBlock.number + highBlock.number) / 2);
+            const blocks = await Promise.all([
+                fetchBlockFromProvider(closeBlock, chain),
+                fetchBlockFromProvider(midBlock, chain),
+            ]);
+            updateBlock(blocks);
+        }
+        (0, debugLog_1.debugLog)(`chain: ${chain} block: ${block.number} #calls: ${i} imprecision: ${Number((imprecision) / 60).toFixed(2)} (min) Time Taken: ${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 {
+            number: block.number,
+            block: block.number,
+            timestamp: block.timestamp
+        };
+    }
+    catch (e) {
+        throw (0, generalUtil_1.formError)(e);
+    }
+    function updateBlock(blocks = []) {
+        blocks.forEach(addBlockToCache);
+        const getPrecision = (block) => block.timestamp - timestamp > 0 ? block.timestamp - timestamp : timestamp - block.timestamp;
+        blocks.push(highBlock, lowBlock);
+        blocks.sort((a, b) => getPrecision(a) - getPrecision(b));
+        block = blocks[0];
+        // find the closest upper and lower bound between 4 points
+        lowBlock = blocks.filter(i => i.timestamp < timestamp).reduce((lowestBlock, block) => (timestamp - lowestBlock.timestamp) < (timestamp - block.timestamp) ? lowestBlock : block);
+        highBlock = blocks.filter(i => i.timestamp > timestamp).reduce((highestBlock, block) => (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) {
+        const { number, timestamp } = block;
+        getChainBlockTimeCache(chain)[block.number] = { number, timestamp, };
+    }
+    function getLowBlock() {
+        return Object.values(getChainBlockTimeCache(chain))
+            .filter(i => i.timestamp < timestamp)
+            .sort((a, b) => b.timestamp - a.timestamp)[0];
+    }
+    function getHighBlock() {
+        return Object.values(getChainBlockTimeCache(chain))
+            .filter(i => i.timestamp > timestamp)
+            .sort((a, b) => a.timestamp - b.timestamp)[0];
+    }
 }
 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];
-            }
-        });
-    });
+async function getTimestamp(height, chain) {
+    const provider = getExtraProvider(chain);
+    const block = await provider.getBlock(height);
+    return block.timestamp;
 }
 exports.getTimestamp = getTimestamp;
-var currentChainBlockCache = (0, cache_1.getTempLocalCache)({ file: 'currentChainBlockCache.json', defaultData: {} });
+const currentChainBlockCache = (0, cache_1.getTempLocalCache)({ file: 'currentChainBlockCache.json', defaultData: {} });