@defillama/sdk 5.0.236 → 5.0.238

package/build/util/LlamaProvider.js

@@ -270,6 +270,8 @@ const httpRPC = {
         });
         if (error)
             throw error;
+        if (!result)
+            throw new Error(`block ${params[0]} not found`); // pruned or not yet synced, let callers recognise it
         result.number = parseInt(result.number);
         result.timestamp = parseInt(result.timestamp);
         return result;

package/build/util/blocks.js

@@ -130,6 +130,116 @@ const intialBlocks = {
     terra: 4724001,
     crab: 4969901
 };
+// pruned nodes don't serve old blocks, we find the earliest available block per chain and remember it for this process
+const earliestAvailableBlock = {};
+const prunedBlockBuffer = 1000; // pruning keeps moving forward, so stay a bit ahead of the reported height
+// known formats:
+//   sei:                    "requested height 150022713 has been pruned; earliest available is 229666772"
+//   sei (pre evm):          "EVM is only supported from block 79123881 onwards"
+//   publicnode:             "pruned history unavailable: requested 100, earliest available 51000000"
+//   cosmos/tendermint/evm:  "height 100 is not available, lowest height is 47180386" (often in error.data)
+// both patterns need a block/height/available word next to the number, so unrelated numbers in error pages don't match
+const earliestBlockPatterns = [
+    /(?:earliest|lowest|oldest)\s+(?:available\s+(?:block\s+|height\s+)?|(?:block|height)\s+)(?:number\s+)?(?:is\s+|:\s*|=\s*)?#?(\d+)/i,
+    /(?:supported|available)\s+(?:from|since|after)\s+(?:block|height)\s+#?(\d+)/i,
+];
+// the node's message sits in different fields depending on who wrapped the error (ethers, axios, formError, llamaRPCError)
+const errorMessageFields = ['message', 'shortMessage', 'reason', 'data', '_underlyingError', 'error', 'info', 'response', 'errors'];
+function getErrorText(e, depth = 0) {
+    if (typeof e === 'string')
+        return e;
+    if (!e || typeof e !== 'object' || depth > 5)
+        return ''; // llamaRPCError: errors[i].error.message sits 4 deep
+    if (Array.isArray(e))
+        return e.map(i => getErrorText(i, depth + 1)).filter(Boolean).join(' ');
+    return errorMessageFields
+        .map(key => getErrorText(e[key], depth + 1))
+        .filter(Boolean)
+        .join(' ');
+}
+function getEarliestAvailableFromError(e, requested) {
+    const text = getErrorText(e);
+    const found = earliestBlockPatterns
+        .map(pattern => { var _a; return (_a = text.match(pattern)) === null || _a === void 0 ? void 0 : _a[1]; })
+        .filter(Boolean)
+        .map(Number)
+        .filter(block => block > requested);
+    return found.length ? Math.max(...found) : undefined;
+}
+// true only when the node says the block doesn't exist for it, transient errors (timeouts, 429s) are not pruning
+function isMissingBlockError(e) {
+    const text = getErrorText(e);
+    return /Can't get block of chain|not found|not available|pruned|missing trie node|does not have this data|unknown block|no block/i.test(text);
+}
+// last resort for nodes that return null/not found without telling where the history starts
+async function searchEarliestAvailableBlock(low, chain) {
+    const { number: latest } = await (0, exports.getLatestBlock)(chain);
+    let hi = latest - prunedBlockBuffer;
+    if (hi <= low || !(await isBlockAvailable(hi)))
+        return; // node is broken, not pruned
+    while (hi - low > prunedBlockBuffer) {
+        const mid = Math.floor((low + hi) / 2);
+        if (await isBlockAvailable(mid))
+            hi = mid;
+        else
+            low = mid;
+    }
+    return hi;
+    // we only get here after the node confirmed pruning, so a failure in the pruned region is most likely pruning too
+    // (sei answers "method handler crashed" for blocks just above its reported horizon); retry once to rule out a blip
+    async function isBlockAvailable(block, retry = true) {
+        try {
+            await fetchBlockFromProvider(block, chain);
+            return true;
+        }
+        catch (e) {
+            const earliest = getEarliestAvailableFromError(e, block);
+            if (earliest)
+                low = Math.max(low, earliest - 1); // node told us, skip ahead
+            else if (!isMissingBlockError(e) && retry)
+                return isBlockAvailable(block, false);
+            return false;
+        }
+    }
+}
+// fetches the given block, or the earliest available block if the node has pruned it
+async function fetchAvailableBlock(low, chain) {
+    var _a, _b;
+    low = Math.max(low, (_a = earliestAvailableBlock[chain]) !== null && _a !== void 0 ? _a : 0); // already known to be pruned, don't ask again
+    let originalError;
+    // a few hops: sei first reports the evm start block, then the pruned height
+    for (let i = 0; i < 3; i++) {
+        try {
+            return await fetchBlockFromProvider(low, chain);
+        }
+        catch (e) {
+            originalError = originalError !== null && originalError !== void 0 ? originalError : e;
+            const earliest = getEarliestAvailableFromError(e, low);
+            if (!earliest)
+                break;
+            low = earliestAvailableBlock[chain] = earliest + prunedBlockBuffer;
+            (0, debugLog_1.debugLog)(`chain: ${chain} block is pruned, using earliest available block ${low}`);
+        }
+    }
+    // only search when the node says the block is missing, anything else is a transient failure
+    if (!isMissingBlockError(originalError))
+        throw originalError;
+    // parallel probes can all land in the pruned range, run a single search per chain
+    if (!earliestBlockSearches[chain]) {
+        earliestBlockSearches[chain] = searchEarliestAvailableBlock(low, chain)
+            .catch(() => undefined)
+            .finally(() => delete earliestBlockSearches[chain]);
+    }
+    const earliest = await earliestBlockSearches[chain];
+    if (!earliest)
+        throw originalError;
+    if (((_b = earliestAvailableBlock[chain]) !== null && _b !== void 0 ? _b : 0) < earliest + prunedBlockBuffer) {
+        earliestAvailableBlock[chain] = earliest + prunedBlockBuffer;
+        (0, debugLog_1.debugLog)(`chain: ${chain} block is pruned, found earliest available block ${earliestAvailableBlock[chain]} by searching`);
+    }
+    return fetchBlockFromProvider(earliestAvailableBlock[chain], chain);
+}
+const earliestBlockSearches = {};
 let lastBlockCacheSave = Date.now();
 const blockCacheSaveInterval = 1000 * 60 * 5; // 5 minutes 
 const { data: blockTimeCache, saveCacheFile: saveBlockCacheFile } = (0, cache_1.getTempLocalCache)({ file: 'BlockCache-v1.json', defaultData: {}, clearAfter: cache_1.ONE_WEEK, returnWithSaveFunction: true });
@@ -152,23 +262,97 @@ function getChainLimiter(chain) {
         return (0, p_limit_1.default)((0, env_1.getParallelGetBlocksLimit)(chain));
     }
 }
+// concurrent lookups for the same chain & timestamp share one search
+const inflightLookups = {};
 async function lookupBlock(timestamp, extraParams) {
-    const { chain = "ethereum" } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
-    const limiter = getChainLimiter(chain);
-    return limiter(() => _lookupBlock(timestamp, extraParams));
+    const { chain = "ethereum", allowedTimeRange, acceptableBlockImprecision } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
+    if (timestamp > Date.now() / 1000)
+        throw new Error(`Requesting for block in the future ${timestamp} is in the future, current time is ${Math.floor(Date.now() / 1000)}`);
+    const key = [chain, timestamp, allowedTimeRange, acceptableBlockImprecision].join(':');
+    if (!inflightLookups[key]) {
+        const limiter = getChainLimiter(chain);
+        inflightLookups[key] = lookupBlockFromService(timestamp, extraParams)
+            .then(block => block !== null && block !== void 0 ? block : limiter(() => _lookupBlock(timestamp, extraParams)))
+            .finally(() => delete inflightLookups[key]);
+    }
+    return inflightLookups[key];
+}
+const blockServiceRoundSeconds = 300; // the service's default route rounds timestamps down to this
+const blockServiceTimeout = 5000;
+const blockServiceMaxFailures = 3;
+const blockServicePauseDuration = 1000 * 60 * 5; // after repeated failures, go straight to the local search for a while
+let blockServiceFailures = 0;
+let blockServicePausedUntil = 0;
+// ask the block-service when BLOCK_SERVICE_URL is set, any failure falls back to the local search
+async function lookupBlockFromService(timestamp, extraParams) {
+    var _a;
+    const serviceUrl = (0, env_1.getBlockServiceUrl)();
+    if (!serviceUrl || Date.now() < blockServicePausedUntil)
+        return;
+    const { chain = "ethereum", allowedTimeRange = 5 * 60 } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
+    if (chain === 'waves')
+        return;
+    const route = allowedTimeRange >= blockServiceRoundSeconds ? '' : '/precise';
+    try {
+        const { block, timestamp: blockTimestamp } = await (0, common_1.fetchJson)(`${serviceUrl}/block/${chain}/${timestamp}${route}`, { timeout: blockServiceTimeout });
+        if (!Number.isInteger(block) || !Number.isInteger(blockTimestamp))
+            throw new Error('bad response');
+        // same guard as the local search: a wildly off answer is worse than no answer
+        if (blockTimestamp > timestamp || timestamp - blockTimestamp > 3600)
+            throw new Error(`block ${block} (${blockTimestamp}) is too far from ${timestamp}`);
+        blockServiceFailures = 0;
+        addBlockToCache(chain, { number: block, timestamp: blockTimestamp });
+        return { block, number: block, timestamp: blockTimestamp };
+    }
+    catch (e) {
+        if (++blockServiceFailures >= blockServiceMaxFailures) {
+            blockServicePausedUntil = Date.now() + blockServicePauseDuration;
+            blockServiceFailures = 0;
+        }
+        (0, debugLog_1.debugLog)(`block-service lookup failed for ${chain} ${timestamp}, falling back to local search: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+    }
+}
+function getChainBlockTimeCache(chain) {
+    if (!blockTimeCache[chain])
+        blockTimeCache[chain] = {};
+    return blockTimeCache[chain];
+}
+function addBlockToCache(chain, block) {
+    const { number, timestamp } = block;
+    getChainBlockTimeCache(chain)[number] = { number, timestamp, };
+    // save the block cache every 5 minutes
+    if (Date.now() - lastBlockCacheSave > blockCacheSaveInterval) {
+        lastBlockCacheSave = Date.now();
+        saveBlockCacheFile();
+    }
 }
 const earliestAvailableBlockRange = {
     nibiru: 4 * 1e5, // nibiru hold only the last 400k block data
     evmos: 2 * 1e5,
 };
+// block time measured over the most recent blocks, a far better predictor of the near past than the all time average
+const blockTimeSampleSize = 10000;
+const blockTimeCacheDuration = 1000 * 60 * 60; // 1 hour
+const recentBlockTimes = {};
+async function getRecentBlockTime(chain, anchor, floor, onBlock) {
+    const cached = recentBlockTimes[chain];
+    if (cached && Date.now() - cached.updatedAt < blockTimeCacheDuration)
+        return cached.blockTime;
+    const sample = await fetchAvailableBlock(Math.max(floor, anchor.number - blockTimeSampleSize), chain);
+    if (sample.number >= anchor.number)
+        return 2; // pruning horizon is above the anchor, nothing to measure, rough guess, don't cache
+    onBlock(sample);
+    const blockTime = (anchor.timestamp - sample.timestamp) / (anchor.number - sample.number);
+    if (!(blockTime > 0) || !isFinite(blockTime))
+        return 2; // not enough history to measure, rough guess, don't cache
+    recentBlockTimes[chain] = { blockTime, updatedAt: Date.now() };
+    return blockTime;
+}
 async function _lookupBlock(timestamp, extraParams) {
     var _a, _b;
     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";
     let time = Date.now();
-    if (timestamp > time / 1000) {
-        throw new Error(`Requesting for block in the future ${timestamp} is in the future, current time is ${Math.floor(time / 1000)}`);
-    }
     if (chain === 'waves') {
         const api = `https://nodes.wavesnodes.com/blocks/heightByTimestamp/${timestamp}`;
         const data = await (0, common_1.fetchJson)(api);
@@ -178,100 +362,124 @@ async function _lookupBlock(timestamp, extraParams) {
             number: +data.height,
         };
     }
-    let low = (_b = intialBlocks[chain]) !== null && _b !== void 0 ? _b : 100;
-    let envLowValue = process.env[`${chain.toUpperCase()}_BLOCK_LOW`];
-    if (envLowValue)
-        low = parseInt(envLowValue);
-    let lowBlock = getLowBlock();
-    let highBlock = getHighBlock();
-    if ((lowBlock === null || lowBlock === void 0 ? void 0 : lowBlock.number) < low)
-        lowBlock = undefined;
-    let block;
-    let i = 0;
-    let blockImprecision;
-    let imprecision;
+    const maxCalls = 30;
+    let calls = 0;
+    let lowBlock; // closest known block at or before the timestamp
+    let highBlock; // closest known block after the timestamp
+    let bestBlock;
+    let blockTime;
+    let lastBracketWidth = Infinity;
     try {
-        let firstBlock, lastBlock;
-        if (!!earliestAvailableBlockRange[chain]) {
-            lastBlock = await (0, exports.getLatestBlock)(chain);
-            let firstBlockNum = lastBlock.number - earliestAvailableBlockRange[chain];
-            firstBlock = await fetchBlockFromProvider(firstBlockNum, chain);
-        }
-        else {
-            [lastBlock, firstBlock] = await Promise.all([
-                highBlock ? highBlock : (0, exports.getLatestBlock)(chain),
-                lowBlock ? lowBlock : fetchBlockFromProvider(low, chain),
-            ]);
-        }
-        lowBlock = firstBlock;
-        if (!highBlock)
-            highBlock = lastBlock;
-        if (Math.abs(highBlock.timestamp - timestamp) < 60 * 5) {
-            // Short-circuit in case we are trying to get the current block
-            return {
-                block: highBlock.number,
-                number: highBlock.number,
-                timestamp: highBlock.timestamp
-            };
+        let floor = getFloorBlock();
+        const cachedLow = getLowBlock();
+        if (cachedLow && cachedLow.number >= floor)
+            updateBounds(cachedLow, false);
+        const cachedHigh = getHighBlock();
+        if (cachedHigh)
+            updateBounds(cachedHigh, false);
+        // anchor on the chain head unless the cache already has a block after the timestamp
+        if (!highBlock || earliestAvailableBlockRange[chain]) {
+            const head = await (0, exports.getLatestBlock)(chain);
+            // Short-circuit in case we are trying to get the current block, or the rpc head lags behind the requested time
+            if (Math.abs(head.timestamp - timestamp) < 60 * 5 || head.timestamp <= timestamp)
+                return { block: head.number, number: head.number, timestamp: head.timestamp };
+            floor = getFloorBlock(head);
+            if (!highBlock || head.number < highBlock.number)
+                updateBounds(head, false);
         }
-        updateBlock();
-        while (imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision && i < 50) { // 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);
+        while (!isPreciseEnough() && calls < maxCalls) {
+            floor = Math.max(floor, (_b = earliestAvailableBlock[chain]) !== null && _b !== void 0 ? _b : 0);
+            if (lowBlock && lowBlock.number < floor)
+                lowBlock = undefined; // pruned away, guesses below the floor would just repeat the horizon block
+            let guesses;
+            if (lowBlock) {
+                // bracketed: interpolate between the bounds, bisect when the previous step didn't at least halve the bracket
+                const width = highBlock.number - lowBlock.number;
+                if (width <= 1)
+                    break;
+                let guess = lowBlock.number + Math.round((timestamp - lowBlock.timestamp) * width / (highBlock.timestamp - lowBlock.timestamp));
+                if (width > lastBracketWidth / 2)
+                    guess = Math.floor((lowBlock.number + highBlock.number) / 2);
+                lastBracketWidth = width;
+                guesses = [clamp(guess, lowBlock.number + 1, highBlock.number - 1)];
+            }
+            else {
+                // only an upper bound: extrapolate back from it using the recent block time
+                if (highBlock.number <= floor)
+                    break; // requested time is before the available history
+                if (!blockTime) {
+                    const recentBlockTime = await getRecentBlockTime(chain, highBlock, floor, block => { calls++; updateBounds(block); });
+                    blockTime = blockTime !== null && blockTime !== void 0 ? blockTime : recentBlockTime; // updateBounds may have set a more local slope meanwhile, keep that
+                }
+                if (lowBlock)
+                    continue; // the block time sample already bracketed the timestamp
+                const guess = clamp(Math.round(highBlock.number - (highBlock.timestamp - timestamp) / blockTime), floor, highBlock.number - 1);
+                // probe around the guess too, so a slightly off block time still brackets the timestamp in one round trip
+                const spread = Math.max(acceptableBlockImprecision, Math.round((highBlock.number - guess) * 0.02));
+                guesses = [...new Set([guess - spread, guess, guess + spread].map(b => clamp(b, floor, highBlock.number - 1)))];
+            }
+            const blocks = await Promise.all(guesses.map(b => fetchAvailableBlock(b, chain)));
+            calls += blocks.length;
+            blocks.forEach(block => updateBounds(block));
         }
-        if (i > 2 && env_1.ENV_CONSTANTS.GET_BLOCK_STATS)
-            (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 (Math.abs(block.timestamp - timestamp) > 3600
+        if (calls > 2 && env_1.ENV_CONSTANTS.GET_BLOCK_STATS)
+            (0, debugLog_1.debugLog)(`chain: ${chain} block: ${bestBlock.number} #calls: ${calls} imprecision: ${Number(getImprecision(bestBlock) / 60).toFixed(2)} (min) Time Taken: ${Number((Date.now() - time) / 1000).toFixed(2)} (in sec)`);
+        if (getImprecision(bestBlock) > 3600
             && chain !== "bsc" // this check is there because bsc halted the chain for few days
             && !(0, env_1.shouldSkipBlockValidation)(chain)) {
+            if (!lowBlock && highBlock.number <= floor)
+                throw new Error(`Requested timestamp ${timestamp} (${new Date(timestamp * 1000).toISOString()}) is before the earliest available block ${highBlock.number} (${new Date(highBlock.timestamp * 1000).toISOString()}) of ${chain}`);
             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
+            number: bestBlock.number,
+            block: bestBlock.number,
+            timestamp: bestBlock.timestamp
         };
     }
     catch (e) {
         throw (0, common_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, lowBlock);
-        highBlock = blocks.filter(i => i.timestamp > timestamp).reduce((highestBlock, block) => (highestBlock.timestamp - timestamp) < (block.timestamp - timestamp) ? highestBlock : block, highBlock);
-        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 getFloorBlock(head) {
+        var _a, _b;
+        let floor = (_a = intialBlocks[chain]) !== null && _a !== void 0 ? _a : 100;
+        const envLowValue = process.env[`${chain.toUpperCase()}_BLOCK_LOW`];
+        if (envLowValue)
+            floor = parseInt(envLowValue);
+        floor = Math.max(floor, (_b = earliestAvailableBlock[chain]) !== null && _b !== void 0 ? _b : 0);
+        if (head && earliestAvailableBlockRange[chain])
+            floor = Math.max(floor, head.number - earliestAvailableBlockRange[chain]);
+        return floor;
+    }
+    function getImprecision(block) {
+        return Math.abs(block.timestamp - timestamp);
     }
-    function getChainBlockTimeCache(chain) {
-        if (!blockTimeCache[chain])
-            blockTimeCache[chain] = {};
-        return blockTimeCache[chain];
+    function isPreciseEnough() {
+        if (bestBlock && getImprecision(bestBlock) <= allowedTimeRange)
+            return true;
+        return !!lowBlock && !!highBlock && highBlock.number - lowBlock.number <= acceptableBlockImprecision;
     }
-    function addBlockToCache(block) {
-        const { number, timestamp } = block;
-        getChainBlockTimeCache(chain)[block.number] = { number, timestamp, };
-        // save the block cache every 5 minutes
-        if (Date.now() - lastBlockCacheSave > blockCacheSaveInterval) {
-            lastBlockCacheSave = Date.now();
-            saveBlockCacheFile();
+    function updateBounds(block, saveToCache = true) {
+        if (saveToCache)
+            addBlockToCache(chain, block);
+        if (block.timestamp <= timestamp) {
+            if (!lowBlock || block.number > lowBlock.number)
+                lowBlock = block;
         }
+        else if (!highBlock || block.number < highBlock.number) {
+            // while unbracketed, the slope between consecutive upper bounds is the most local block time we have
+            if (highBlock && !lowBlock) {
+                const localBlockTime = (highBlock.timestamp - block.timestamp) / (highBlock.number - block.number);
+                if (localBlockTime > 0)
+                    blockTime = localBlockTime;
+            }
+            highBlock = block;
+        }
+        if (!bestBlock || getImprecision(block) < getImprecision(bestBlock))
+            bestBlock = block;
+    }
+    function clamp(value, min, max) {
+        return Math.min(Math.max(value, min), max);
     }
     function getLowBlock() {
         return Object.values(getChainBlockTimeCache(chain))