@defillama/sdk 4.0.76 → 4.0.78

package/build/util/cosmos.js

@@ -0,0 +1,124 @@
+"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.getCosmosProvider = exports.getCosmosBlock = exports.isCosmosChain = void 0;
+var node_fetch_1 = __importDefault(require("node-fetch"));
+// where to find chain info
+// https://proxy.atomscan.com/chains.json
+// https://cosmos-chain.directory/chains/cosmoshub
+// https://cosmos-chain.directory/chains
+var endPoints = {
+    crescent: "https://mainnet.crescent.network:1317",
+    osmosis: "https://osmosis-api.polkachu.com",
+    cosmos: "https://cosmoshub-lcd.stakely.io",
+    kujira: "https://kuji-api.kleomedes.network",
+    comdex: "https://rest.comdex.one",
+    terra: "https://terra-classic-lcd.publicnode.com",
+    terra2: "https://terra-lcd.publicnode.com",
+    umee: "https://umee-api.polkachu.com",
+    orai: "https://lcd.orai.io",
+    juno: "https://juno.api.m.stavr.tech",
+    cronos: "https://rest.mainnet.crypto.org",
+    chihuahua: "https://rest.cosmos.directory/chihuahua",
+    stargaze: "https://rest.stargaze-apis.com",
+    quicksilver: "https://rest.cosmos.directory/quicksilver",
+    persistence: "https://rest.cosmos.directory/persistence",
+    secret: "https://lcd.secret.express",
+    // chihuahua: "https://api.chihuahua.wtf",
+    injective: "https://sentry.lcd.injective.network:443",
+    migaloo: "https://migaloo-api.polkachu.com",
+    fxcore: "https://fx-rest.functionx.io",
+    xpla: "https://dimension-lcd.xpla.dev",
+    neutron: "https://rest-kralum.neutron-1.neutron.org",
+    quasar: "https://quasar-api.polkachu.com",
+    gravitybridge: "https://gravitychain.io:1317",
+    sei: "https://sei-api.polkachu.com",
+    aura: "https://lcd.aura.network",
+    archway: "https://api.mainnet.archway.io",
+    sifchain: "https://sifchain-api.polkachu.com",
+    nolus: "https://pirin-cl.nolus.network:1317",
+    bostrom: "https://lcd.bostrom.cybernode.ai"
+};
+var ibcChains = ['ibc', 'terra', 'terra2', 'crescent', 'osmosis', 'kujira', 'stargaze', 'juno', 'injective', 'cosmos', 'comdex', 'umee', 'orai', 'persistence', 'fxcore', 'neutron', 'quasar', 'chihuahua', 'sei', 'archway', 'migaloo', 'secret', 'aura', 'xpla', 'bostrom'];
+var isCosmosChain = function (chain) { return ibcChains.includes(chain) || !!endPoints[chain]; };
+exports.isCosmosChain = isCosmosChain;
+function getCosmosBlock(block, chain) {
+    var _a;
+    if (block === void 0) { block = 'latest'; }
+    if (chain === void 0) { chain = 'cosmos'; }
+    return __awaiter(this, void 0, void 0, function () {
+        var endPoint, data, _b, height, time, e_1, message;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    endPoint = process.env[chain.toUpperCase() + '_RPC'] || endPoints[chain] || 'https://rest.cosmos.directory/' + chain;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, (0, node_fetch_1.default)("".concat(endPoint, "/blocks/").concat(block))];
+                case 2:
+                    data = _c.sent();
+                    return [4 /*yield*/, data.json()];
+                case 3:
+                    _b = (_c.sent()).block.header, height = _b.height, time = _b.time;
+                    return [2 /*return*/, {
+                            number: Number(height),
+                            timestamp: Math.floor(Date.parse(time) / 1000),
+                        }];
+                case 4:
+                    e_1 = _c.sent();
+                    message = "Error fetchin cosmos block -\n       chain: ".concat(chain, ", block: ").concat(block, ", endPoint: ").concat(endPoint, ", error: ").concat((_a = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) !== null && _a !== void 0 ? _a : JSON.stringify(e_1));
+                    throw new Error(message);
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.getCosmosBlock = getCosmosBlock;
+function getCosmosProvider(chain) {
+    return {
+        getBlock: function (block) {
+            if (block === void 0) { block = 'latest'; }
+            return getCosmosBlock(block, chain);
+        }
+    };
+}
+exports.getCosmosProvider = getCosmosProvider;

package/build/util/index.d.ts

@@ -2,19 +2,9 @@ import { Chain } from "../general";
 import type { Address } from "../types";
 import type { Log } from "@ethersproject/abstract-provider";
 import runInPromisePoolOrig from "./promisePool";
+export { getLatestBlock, getTimestamp, lookupBlock, } from "./blocks";
 export declare const runInPromisePool: typeof runInPromisePoolOrig;
 export declare function sliceIntoChunks(arr: any[], chunkSize?: number): any[][];
-interface TimestampBlock {
-    number: number;
-    timestamp: number;
-}
-export declare function getLatestBlock(chain: string): Promise<TimestampBlock>;
-export declare function lookupBlock(timestamp: number, extraParams?: {
-    chain?: Chain | "terra" | "kava" | "algorand";
-}): Promise<{
-    timestamp: number;
-    block: number;
-}>;
 export declare function getLogs(params: {
     target: Address;
     topic: string;
@@ -28,7 +18,6 @@ export declare function getLogs(params: {
 } | {
     output: Log[];
 }>;
-export declare function getTimestamp(height: number, chain: Chain): Promise<number>;
 export declare function normalizeAddress(address: string): string;
 export declare function normalizePrefixes(address: string): string;
 export declare function normalizeBalances(balances: {
@@ -36,4 +25,3 @@ export declare function normalizeBalances(balances: {
 }): {
     [address: string]: string;
 };
-export {};

package/build/util/index.js

@@ -50,13 +50,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeBalances = exports.normalizePrefixes = exports.normalizeAddress = exports.getTimestamp = exports.getLogs = exports.lookupBlock = exports.getLatestBlock = exports.sliceIntoChunks = exports.runInPromisePool = void 0;
+exports.normalizeBalances = exports.normalizePrefixes = exports.normalizeAddress = exports.getLogs = exports.sliceIntoChunks = exports.runInPromisePool = exports.lookupBlock = exports.getTimestamp = exports.getLatestBlock = void 0;
 var general_1 = require("../general");
-var node_fetch_1 = __importDefault(require("node-fetch"));
 var ethers_1 = require("ethers");
 var generalUtil_1 = require("../generalUtil");
 var debugLog_1 = require("./debugLog");
 var promisePool_1 = __importDefault(require("./promisePool"));
+var blocks_1 = require("./blocks");
+Object.defineProperty(exports, "getLatestBlock", { enumerable: true, get: function () { return blocks_1.getLatestBlock; } });
+Object.defineProperty(exports, "getTimestamp", { enumerable: true, get: function () { return blocks_1.getTimestamp; } });
+Object.defineProperty(exports, "lookupBlock", { enumerable: true, get: function () { return blocks_1.lookupBlock; } });
 exports.runInPromisePool = promisePool_1.default;
 function sliceIntoChunks(arr, chunkSize) {
     if (chunkSize === void 0) { chunkSize = 100; }
@@ -68,264 +71,13 @@ function sliceIntoChunks(arr, chunkSize) {
     return res;
 }
 exports.sliceIntoChunks = sliceIntoChunks;
-var terraBlockProvider = {
-    getBlock: function (height) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, (0, node_fetch_1.default)("https://lcd.terra.dev/blocks/".concat(height))
-                    .then(function (res) { return res.json(); })
-                    .then(function (block) { return ({
-                    number: Number(block.block.header.height),
-                    timestamp: Math.round(Date.parse(block.block.header.time) / 1000),
-                }); })];
-        });
-    }); }
-};
-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 getBlock(provider, height, chain) {
-    return __awaiter(this, void 0, void 0, function () {
-        var block;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: 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 === "terra") {
-        return terraBlockProvider;
-    }
-    else if (chain === "algorand") {
-        return algorandBlockProvider;
-    }
-    return (0, general_1.getProvider)(chain);
-}
-function getLatestBlock(chain) {
-    return __awaiter(this, void 0, void 0, function () {
-        var provider;
-        return __generator(this, function (_a) {
-            provider = getExtraProvider(chain);
-            return [2 /*return*/, getBlock(provider, "latest", chain)];
-        });
-    });
-}
-exports.getLatestBlock = getLatestBlock;
-var intialBlocks = {
-    terra: 4724001,
-    crab: 4969901
-};
-var 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(blockscoutEndpoints[chain], "/api?module=block&action=getblocknobytime&timestamp=").concat(timestamp, "&closest=before");
-                    return [4 /*yield*/, (0, node_fetch_1.default)(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
-                        }];
-            }
-        });
-    });
-}
-var blockTimeCache = {};
-function lookupBlock(timestamp, extraParams) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    if (extraParams === void 0) { extraParams = {}; }
-    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) {
-            getChainBlockTimeCache(chain)[block.number] = block;
-        }
-        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 chain, response, e_1, api, res, data, low, lowBlock, highBlock, block, i, time, allowedTimeRange, acceptableBlockImprecision, blockImprecision, imprecision, firstBlock, lastBlock, provider, firstBlockNum, blockDiff, timeDiff, avgBlockTime, closeBlock, midBlock, blocks, e_2;
-        var _j;
-        return __generator(this, function (_k) {
-            switch (_k.label) {
-                case 0:
-                    chain = (_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum";
-                    if (!blockscoutEndpoints[chain]) return [3 /*break*/, 4];
-                    _k.label = 1;
-                case 1:
-                    _k.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, getBlockscoutBlock(timestamp, chain)];
-                case 2:
-                    response = _k.sent();
-                    return [2 /*return*/, response];
-                case 3:
-                    e_1 = _k.sent();
-                    (0, debugLog_1.debugLog)('error fetching block from blockscout', e_1);
-                    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 = _k.sent();
-                    return [4 /*yield*/, res.json()];
-                case 6:
-                    data = _k.sent();
-                    return [2 /*return*/, {
-                            timestamp: timestamp,
-                            block: +data.height
-                        }];
-                case 7:
-                    low = (_b = intialBlocks[chain]) !== null && _b !== void 0 ? _b : 100;
-                    lowBlock = getLowBlock();
-                    highBlock = getHighBlock();
-                    i = 0;
-                    time = Date.now();
-                    allowedTimeRange = 15 * 60 // how much imprecision is allowed (15 minutes now)
-                    ;
-                    acceptableBlockImprecision = chain === 'ethereum' ? 20 : 200;
-                    _k.label = 8;
-                case 8:
-                    _k.trys.push([8, 17, , 18]);
-                    firstBlock = void 0, lastBlock = void 0;
-                    provider = getExtraProvider(chain);
-                    if (!['evmos'].includes(chain)) return [3 /*break*/, 11];
-                    return [4 /*yield*/, getBlock(provider, "latest", chain)];
-                case 9:
-                    lastBlock = _k.sent();
-                    firstBlockNum = lastBlock.number;
-                    switch (chain) {
-                        default: firstBlockNum -= 2 * 1e5; // evmos hold only the last 200k block data
-                    }
-                    return [4 /*yield*/, getBlock(provider, firstBlockNum, chain)];
-                case 10:
-                    firstBlock = _k.sent();
-                    return [3 /*break*/, 13];
-                case 11: return [4 /*yield*/, Promise.all([
-                        getBlock(provider, "latest", chain),
-                        lowBlock ? lowBlock : getBlock(provider, low, chain),
-                    ])];
-                case 12:
-                    _j = _k.sent(), lastBlock = _j[0], firstBlock = _j[1];
-                    _k.label = 13;
-                case 13:
-                    lowBlock = firstBlock;
-                    if (!highBlock)
-                        highBlock = lastBlock;
-                    if (lastBlock.timestamp - timestamp < -30 * 60) {
-                        throw new Error("Last block of chain \"".concat(chain, "\" is further than 30 minutes into the past. Provider is \"").concat((_d = (_c = provider === null || provider === void 0 ? void 0 : provider.connection) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : (_h = (_g = (_f = ((_e = provider === null || provider === void 0 ? void 0 : provider.providerConfigs) !== null && _e !== void 0 ? _e : [])[0]) === null || _f === void 0 ? void 0 : _f.provider) === null || _g === void 0 ? void 0 : _g.connection) === null || _h === void 0 ? void 0 : _h.url, "\""));
-                    }
-                    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,
-                                timestamp: highBlock.timestamp
-                            }];
-                    }
-                    updateBlock();
-                    _k.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([
-                            getBlock(provider, closeBlock, chain),
-                            getBlock(provider, midBlock, chain),
-                        ])];
-                case 15:
-                    blocks = _k.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*/, {
-                            block: block.number,
-                            timestamp: block.timestamp
-                        }];
-                case 17:
-                    e_2 = _k.sent();
-                    throw (0, generalUtil_1.formError)(e_2);
-                case 18: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.lookupBlock = lookupBlock;
 // SMALL INCOMPATIBILITY: On the old API we don't return ids but we should
 function getLogs(params) {
-    var _a;
+    var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function () {
-        var filter, logs, blockSpread, currentBlock, nextBlock, partLogs, e_3;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var filter, logs, blockSpread, currentBlock, nextBlock, logParams, partLogs, e_1, isBlockSpreadError, error;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     if (params.toBlock === undefined || params.fromBlock === undefined) {
                         throw new Error("toBlock and fromBlock need to be defined in all calls to getLogs");
@@ -339,28 +91,33 @@ function getLogs(params) {
                     logs = [];
                     blockSpread = params.toBlock - params.fromBlock;
                     currentBlock = params.fromBlock;
-                    _b.label = 1;
+                    _d.label = 1;
                 case 1:
                     if (!(currentBlock < params.toBlock)) return [3 /*break*/, 6];
                     nextBlock = Math.min(params.toBlock, currentBlock + blockSpread);
-                    _b.label = 2;
+                    logParams = __assign(__assign({}, filter), { fromBlock: currentBlock, toBlock: nextBlock });
+                    _d.label = 2;
                 case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, (0, general_1.getProvider)(params.chain, true).getLogs(__assign(__assign({}, filter), { fromBlock: currentBlock, toBlock: nextBlock }))];
+                    _d.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, (0, general_1.getProvider)(params.chain, true).getLogs(logParams)];
                 case 3:
-                    partLogs = _b.sent();
+                    partLogs = _d.sent();
                     logs = logs.concat(partLogs);
                     currentBlock = nextBlock;
                     return [3 /*break*/, 5];
                 case 4:
-                    e_3 = _b.sent();
-                    if (blockSpread >= 2e3) {
+                    e_1 = _d.sent();
+                    (0, debugLog_1.debugLog)("Error fetching logs for chain ".concat(params.chain, " blockSpread: ").concat(blockSpread, ". ").concat((0, generalUtil_1.formError)(e_1)));
+                    isBlockSpreadError = (_c = (_b = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _b === void 0 ? void 0 : _b.includes) === null || _c === void 0 ? void 0 : _c.call(_b, "block range");
+                    if (isBlockSpreadError && blockSpread >= 2e3) {
                         // We got too many results
                         // We could chop it up into 2K block spreads as that is guaranteed to always return but then we'll have to make a lot of queries (easily >1000), so instead we'll keep dividing the block spread by two until we make it
                         blockSpread = Math.floor(blockSpread / 2);
                     }
                     else {
-                        throw e_3;
+                        error = (0, generalUtil_1.formError)(e_1);
+                        error.message = "[chain: ".concat(params.chain, "] ").concat(error === null || error === void 0 ? void 0 : error.message, " params: ").concat(JSON.stringify(logParams));
+                        throw e_1;
                     }
                     return [3 /*break*/, 5];
                 case 5: return [3 /*break*/, 1];
@@ -381,22 +138,6 @@ function getLogs(params) {
     });
 }
 exports.getLogs = getLogs;
-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;
 function normalizeAddress(address) {
     // sol amd tezos case sensitive so no normalising
     var prefix = address.substring(0, address.indexOf(":"));

package/package.json

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