@defillama/sdk 2.3.119 → 2.3.121

package/build/computeTVL/blocks.js

@@ -74,7 +74,9 @@ function getBlocks(timestamp, chains) {
         var _a, ethBlock, chainBlocks;
         return __generator(this, function (_b) {
             switch (_b.label) {
-                case 0: return [4 /*yield*/, Promise.all([getBlock('ethereum', timestamp), getChainBlocks(timestamp, chains)])];
+                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;
@@ -149,7 +151,7 @@ function getBlock(chain, timestamp) {
                             _a.trys.push([2, 4, , 5]);
                             return [4 /*yield*/, index_1.lookupBlock(timestamp, { chain: chain, })];
                         case 3:
-                            block = (_a.sent()).block;
+                            block = _a.sent();
                             return [2 /*return*/, block];
                         case 4:
                             e_1 = _a.sent();

package/build/util/index.js

@@ -139,20 +139,29 @@ var intialBlocks = {
     crab: 4969901
 };
 function lookupBlock(timestamp, extraParams) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     if (extraParams === void 0) { extraParams = {}; }
     return __awaiter(this, void 0, void 0, function () {
-        var provider, lastBlock, high, low, block, blockPrecision, i, time, mid, e_1;
+        var chain, low, lowBlock, highBlock, provider, _e, lastBlock, firstBlock, block, i, time, allowedTimeRange, imprecision, getPrecision_1, blockDiff, timeDiff, avgBlockTime, closeBlock, midBlock, blocks, e_1;
         return __generator(this, function (_f) {
             switch (_f.label) {
                 case 0:
-                    _f.trys.push([0, 6, , 7]);
-                    provider = getExtraProvider(extraParams.chain);
-                    return [4 /*yield*/, getBlock(provider, "latest", extraParams.chain)];
+                    chain = (_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum";
+                    low = (_b = intialBlocks[chain]) !== null && _b !== void 0 ? _b : 100;
+                    _f.label = 1;
                 case 1:
-                    lastBlock = _f.sent();
+                    _f.trys.push([1, 7, , 8]);
+                    provider = getExtraProvider(chain);
+                    return [4 /*yield*/, Promise.all([
+                            getBlock(provider, "latest", chain),
+                            getBlock(provider, low, chain),
+                        ])];
+                case 2:
+                    _e = _f.sent(), lastBlock = _e[0], firstBlock = _e[1];
+                    lowBlock = firstBlock;
+                    highBlock = lastBlock;
                     if (lastBlock.timestamp - timestamp < -30 * 60) {
-                        throw new Error("Last block of chain \"" + extraParams.chain + "\" is further than 30 minutes into the past. Provider is \"" + ((_b = (_a = provider) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.url) + "\"");
+                        throw new Error("Last block of chain \"" + chain + "\" is further than 30 minutes into the past. Provider is \"" + ((_d = (_c = provider) === null || _c === void 0 ? void 0 : _c.connection) === null || _d === void 0 ? void 0 : _d.url) + "\"");
                     }
                     if (Math.abs(lastBlock.timestamp - timestamp) < 60) {
                         // Short-circuit in case we are trying to get the current block
@@ -161,44 +170,54 @@ function lookupBlock(timestamp, extraParams) {
                                 timestamp: lastBlock.timestamp
                             }];
                     }
-                    high = lastBlock.number;
-                    low = (_d = intialBlocks[(_c = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _c !== void 0 ? _c : "ethereum"]) !== null && _d !== void 0 ? _d : 0;
                     block = void 0;
-                    blockPrecision = extraParams.chain === 'ethereum' ? 20 : 200;
                     i = 0;
                     time = Date.now();
-                    _f.label = 2;
-                case 2:
-                    ++i;
-                    mid = Math.floor((high + low) / 2);
-                    return [4 /*yield*/, getBlock(provider, mid, extraParams.chain)];
+                    allowedTimeRange = 15 * 60 // how much imprecision is allowed (15 minutes now)
+                    ;
+                    imprecision = void 0;
+                    getPrecision_1 = function (block) { return block.timestamp - timestamp > 0 ? block.timestamp - timestamp : timestamp - block.timestamp; };
+                    _f.label = 3;
                 case 3:
-                    block = _f.sent();
-                    if (block.timestamp < timestamp) {
-                        low = mid + 1;
-                    }
-                    else {
-                        high = mid - 1;
-                    }
-                    _f.label = 4;
+                    ++i;
+                    blockDiff = highBlock.number - lowBlock.number;
+                    timeDiff = highBlock.timestamp - lowBlock.timestamp;
+                    avgBlockTime = timeDiff / blockDiff;
+                    closeBlock = Math.floor(lowBlock.number + (timestamp - lowBlock.timestamp) / avgBlockTime);
+                    midBlock = Math.floor((lowBlock.number + highBlock.number) / 2);
+                    return [4 /*yield*/, Promise.all([
+                            getBlock(provider, closeBlock, chain),
+                            getBlock(provider, midBlock, chain),
+                        ])];
                 case 4:
-                    if (high - low > blockPrecision) return [3 /*break*/, 2];
+                    blocks = _f.sent();
+                    blocks.push(highBlock, lowBlock);
+                    blocks.sort(function (a, b) { return getPrecision_1(a) - getPrecision_1(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_1(block);
                     _f.label = 5;
                 case 5:
+                    if (imprecision > allowedTimeRange) return [3 /*break*/, 3];
+                    _f.label = 6;
+                case 6:
                     if (process.env.LLAMA_DEBUG_MODE)
-                        console.log(extraParams.chain, i, (block.timestamp - timestamp) / 60, (Date.now() - time) / 1000, 'block: ', block.number);
-                    if (Math.abs(block.timestamp - timestamp) > 3600) {
+                        console.log("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 [2 /*return*/, {
                             block: block.number,
                             timestamp: block.timestamp
                         }];
-                case 6:
+                case 7:
                     e_1 = _f.sent();
                     console.log(e_1);
-                    throw new Error("Couldn't find block height for chain " + ((_e = extraParams.chain) !== null && _e !== void 0 ? _e : "ethereum") + ", RPC node rugged");
-                case 7: return [2 /*return*/];
+                    throw new Error("Couldn't find block height for chain " + chain + ", RPC node rugged");
+                case 8: return [2 /*return*/];
             }
         });
     });

package/package.json

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