@defillama/sdk 2.3.119 → 2.3.120

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

@@ -142,17 +142,25 @@ function lookupBlock(timestamp, extraParams) {
     var _a, _b, _c, _d, _e;
     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;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var low, lowBlock, highBlock, provider, _f, lastBlock, firstBlock, block, i, time, allowedTimeRange, imprecision, blockDiff, timeDiff, avgBlockTime, closeBlock, e_1;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
                 case 0:
-                    _f.trys.push([0, 6, , 7]);
-                    provider = getExtraProvider(extraParams.chain);
-                    return [4 /*yield*/, getBlock(provider, "latest", extraParams.chain)];
+                    low = (_b = intialBlocks[(_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum"]) !== null && _b !== void 0 ? _b : 100;
+                    _g.label = 1;
                 case 1:
-                    lastBlock = _f.sent();
+                    _g.trys.push([1, 7, , 8]);
+                    provider = getExtraProvider(extraParams.chain);
+                    return [4 /*yield*/, Promise.all([
+                            getBlock(provider, "latest", extraParams.chain),
+                            getBlock(provider, low, extraParams.chain),
+                        ])];
+                case 2:
+                    _f = _g.sent(), lastBlock = _f[0], firstBlock = _f[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 \"" + extraParams.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 +169,49 @@ 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;
+                    _g.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);
+                    return [4 /*yield*/, getBlock(provider, closeBlock, extraParams.chain)];
                 case 4:
-                    if (high - low > blockPrecision) return [3 /*break*/, 2];
-                    _f.label = 5;
+                    block = _g.sent();
+                    if (block.timestamp < timestamp)
+                        lowBlock = block;
+                    else
+                        highBlock = block;
+                    imprecision = block.timestamp - timestamp;
+                    if (imprecision < 0)
+                        imprecision *= -1;
+                    _g.label = 5;
                 case 5:
+                    if (imprecision > allowedTimeRange) return [3 /*break*/, 3];
+                    _g.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: " + extraParams.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 (extraParams.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:
-                    e_1 = _f.sent();
+                case 7:
+                    e_1 = _g.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*/];
+                case 8: return [2 /*return*/];
             }
         });
     });

package/package.json

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