@defillama/sdk 2.3.120 → 2.3.122

package/build/util/index.js

@@ -139,28 +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 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) {
+        var chain, low, lowBlock, highBlock, provider, _e, lastBlock, firstBlock, block, i, time, allowedTimeRange, acceptableBlockImprecision, blockImprecision, imprecision, getPrecision_1, blockDiff, timeDiff, avgBlockTime, closeBlock, midBlock, blocks, e_1;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
-                    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;
+                    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:
-                    _g.trys.push([1, 7, , 8]);
-                    provider = getExtraProvider(extraParams.chain);
+                    _f.trys.push([1, 7, , 8]);
+                    provider = getExtraProvider(chain);
                     return [4 /*yield*/, Promise.all([
-                            getBlock(provider, "latest", extraParams.chain),
-                            getBlock(provider, low, extraParams.chain),
+                            getBlock(provider, "latest", chain),
+                            getBlock(provider, low, chain),
                         ])];
                 case 2:
-                    _f = _g.sent(), lastBlock = _f[0], firstBlock = _f[1];
+                    _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 \"" + ((_d = (_c = provider) === null || _c === void 0 ? void 0 : _c.connection) === null || _d === void 0 ? void 0 : _d.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
@@ -174,32 +175,40 @@ function lookupBlock(timestamp, extraParams) {
                     time = Date.now();
                     allowedTimeRange = 15 * 60 // how much imprecision is allowed (15 minutes now)
                     ;
+                    acceptableBlockImprecision = chain === 'ethereum' ? 20 : 200;
+                    blockImprecision = void 0;
                     imprecision = void 0;
-                    _g.label = 3;
+                    getPrecision_1 = function (block) { return block.timestamp - timestamp > 0 ? block.timestamp - timestamp : timestamp - block.timestamp; };
+                    _f.label = 3;
                 case 3:
                     ++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)];
+                    midBlock = Math.floor((lowBlock.number + highBlock.number) / 2);
+                    return [4 /*yield*/, Promise.all([
+                            getBlock(provider, closeBlock, chain),
+                            getBlock(provider, midBlock, chain),
+                        ])];
                 case 4:
-                    block = _g.sent();
-                    if (block.timestamp < timestamp)
-                        lowBlock = block;
-                    else
-                        highBlock = block;
-                    imprecision = block.timestamp - timestamp;
-                    if (imprecision < 0)
-                        imprecision *= -1;
-                    _g.label = 5;
+                    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);
+                    blockImprecision = highBlock.number - lowBlock.number;
+                    _f.label = 5;
                 case 5:
-                    if (imprecision > allowedTimeRange) return [3 /*break*/, 3];
-                    _g.label = 6;
+                    if (imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision) return [3 /*break*/, 3];
+                    _f.label = 6;
                 case 6:
                     if (process.env.LLAMA_DEBUG_MODE)
-                        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
+                        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");
                     }
@@ -208,9 +217,9 @@ function lookupBlock(timestamp, extraParams) {
                             timestamp: block.timestamp
                         }];
                 case 7:
-                    e_1 = _g.sent();
+                    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");
+                    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.120",
+  "version": "2.3.122",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {