@defillama/sdk 5.0.240 → 5.0.244

package/build/util/blocks.js

@@ -0,0 +1,500 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestBlock = exports.chainsForBlocks = void 0;
+exports.getChainBlocks = getChainBlocks;
+exports.getBlocks = getBlocks;
+exports.getCurrentBlocks = getCurrentBlocks;
+exports.getBlock = getBlock;
+exports.getBlockNumber = getBlockNumber;
+exports.getCurrentChainBlock = getCurrentChainBlock;
+exports.lookupBlock = lookupBlock;
+exports.getTimestamp = getTimestamp;
+const general_1 = require("../general");
+const common_1 = require("./common");
+const debugLog_1 = require("./debugLog");
+const cosmos_1 = require("./cosmos");
+const cache_1 = require("./cache");
+const p_limit_1 = __importDefault(require("p-limit"));
+const env_1 = require("./env");
+const defaultChains = ["avax", "bsc", "polygon", "arbitrum"];
+exports.chainsForBlocks = defaultChains;
+const blockRetries = 3;
+async function getChainBlocks(timestamp, chains = defaultChains) {
+    const chainBlocks = {};
+    const setBlock = async (chain) => chainBlocks[chain] = await getBlockNumber(chain, timestamp);
+    await Promise.all(chains.map(setBlock));
+    return chainBlocks;
+}
+async function getBlocks(timestamp, chains = undefined) {
+    chains = chains === null || chains === void 0 ? void 0 : chains.filter(i => i !== 'ethereum');
+    const [ethBlock, chainBlocks] = await Promise.all([getBlockNumber('ethereum', timestamp), getChainBlocks(timestamp, chains)]);
+    chainBlocks['ethereum'] = ethBlock;
+    return {
+        ethereumBlock: ethBlock,
+        chainBlocks,
+    };
+}
+async function getCurrentBlocks(chains = undefined) {
+    if (chains)
+        chains = chains.filter(i => i !== "ethereum");
+    const block = await getBlock('ethereum');
+    const chainBlocks = await getChainBlocks(undefined, chains);
+    chainBlocks['ethereum'] = block.block;
+    return {
+        timestamp: block.timestamp,
+        ethereumBlock: block.block,
+        chainBlocks,
+    };
+}
+async function getBlock(chain, timestamp, options = {}) {
+    if (!timestamp)
+        return getCurrentChainBlock(chain);
+    let error;
+    for (let i = 0; i < blockRetries; i++) {
+        try {
+            let res = await lookupBlock(timestamp, { ...options, chain, });
+            return res;
+        }
+        catch (e) {
+            error = e;
+        }
+    }
+    throw error;
+}
+async function getBlockNumber(chain, timestamp) {
+    return (await getBlock(chain, timestamp)).block;
+}
+const refreshInterval = 1000 * 60 * 1; // 1 minute
+function getCurrentChainBlock(chain = 'ethereum') {
+    const { timestamp, } = currentChainBlockCache[chain] || {};
+    const currentTimestamp = Date.now();
+    if (!timestamp || currentTimestamp - timestamp > refreshInterval) {
+        currentChainBlockCache[chain] = {
+            timestamp: currentTimestamp,
+            promise: _getCurrentChainBlock()
+        };
+    }
+    return currentChainBlockCache[chain].promise;
+    async function _getCurrentChainBlock() {
+        var _a, _b;
+        try {
+            const provider = getExtraProvider(chain);
+            const { number, timestamp, } = await provider.getBlock('latest');
+            const response = { block: number, timestamp, number };
+            validateCurrentBlock(response, chain);
+            currentChainBlockCache[chain] = { timestamp: currentTimestamp, promise: response };
+            return response; // we are interested only in these fields
+        }
+        catch (e) {
+            delete currentChainBlockCache[chain];
+            if ((_b = (_a = e === null || e === void 0 ? void 0 : e.message) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, "Last block of chain"))
+                throw e;
+            throw (0, common_1.formError)(e);
+        }
+    }
+}
+const algorandBlockProvider = {
+    getBlock: async (height) => {
+        if (height !== 'latest')
+            return (0, common_1.fetchJson)(`https://algoindexer.algoexplorerapi.io/v2/blocks/${height}`)
+                .then((block) => ({
+                number: block.round,
+                timestamp: block.timestamp
+            }));
+        return (0, common_1.fetchJson)('https://algoindexer.algoexplorerapi.io/health')
+            .then((block) => algorandBlockProvider.getBlock(block.round));
+    }
+};
+async function fetchBlockFromProvider(height, chain) {
+    const provider = getExtraProvider(chain !== null && chain !== void 0 ? chain : "ethereum");
+    const block = await provider.getBlock(height);
+    if (block === null) {
+        throw new Error(`Can't get block of chain ${chain !== null && chain !== void 0 ? chain : "ethereum"}`);
+    }
+    return block;
+}
+function getExtraProvider(chain = "ethereum") {
+    if ((0, cosmos_1.isCosmosChain)(chain)) // maybe check if it is also an evm chain?
+        return (0, cosmos_1.getCosmosProvider)(chain);
+    if (chain === "algorand")
+        return algorandBlockProvider;
+    return (0, general_1.getProvider)(chain);
+}
+exports.getLatestBlock = getCurrentChainBlock;
+const intialBlocks = {
+    planq: 14000000,
+    sei: 150023881,
+    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 });
+function validateCurrentBlock(block, chain = 'ethereum') {
+    // sometimes the chain is halted or facing issues, so we skip the validation for those chains
+    if ((0, env_1.shouldSkipBlockValidation)(chain))
+        return;
+    const provider = getExtraProvider(chain);
+    const now = Math.floor(Date.now() / 1000);
+    const minutesDiff = Math.floor((now - block.timestamp) / 60);
+    if (minutesDiff > 60)
+        throw new Error(`Last block for ${chain} is ${minutesDiff} minutes behind (${new Date(block.timestamp * 1000)}). Provider is "${(0, common_1.getProviderUrl)(provider)}"`);
+}
+const chainLimiters = {};
+function getChainLimiter(chain) {
+    if (!chainLimiters[chain])
+        chainLimiters[chain] = createLimiter(chain);
+    return chainLimiters[chain];
+    function createLimiter(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", 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 (chain === 'waves') {
+        const api = `https://nodes.wavesnodes.com/blocks/heightByTimestamp/${timestamp * 1000}`;
+        const data = await (0, common_1.fetchJson)(api);
+        return {
+            timestamp,
+            block: +data.height,
+            number: +data.height,
+        };
+    }
+    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 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);
+        }
+        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 (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: bestBlock.number,
+            block: bestBlock.number,
+            timestamp: bestBlock.timestamp
+        };
+    }
+    catch (e) {
+        throw (0, common_1.formError)(e);
+    }
+    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 isPreciseEnough() {
+        if (bestBlock && getImprecision(bestBlock) <= allowedTimeRange)
+            return true;
+        return !!lowBlock && !!highBlock && highBlock.number - lowBlock.number <= acceptableBlockImprecision;
+    }
+    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))
+            .filter(i => i.timestamp < timestamp)
+            .sort((a, b) => b.timestamp - a.timestamp)[0];
+    }
+    function getHighBlock() {
+        return Object.values(getChainBlockTimeCache(chain))
+            .filter(i => i.timestamp > timestamp)
+            .sort((a, b) => a.timestamp - b.timestamp)[0];
+    }
+}
+async function getTimestamp(height, chain) {
+    const provider = getExtraProvider(chain);
+    const block = await provider.getBlock(height);
+    return block.timestamp;
+}
+const currentChainBlockCache = {};

package/build/util/cache.d.ts

@@ -0,0 +1,45 @@
+export declare const currentVersion = "zlib-1.0";
+export declare function readCache(file: string, options?: ReadCacheOptions): Promise<any>;
+interface WriteCacheOptions {
+    skipR2CacheWrite?: boolean;
+    alreadyCompressed?: boolean;
+    skipCompression?: boolean;
+}
+interface ReadCacheOptions {
+    checkIfRecent?: boolean;
+    readFromR2Cache?: boolean;
+    skipR2Cache?: boolean;
+    skipCompression?: boolean;
+}
+export declare function writeCache(file: string, data: any, options?: WriteCacheOptions): Promise<string | undefined>;
+export declare function parseCache(dataString: string | Buffer, options?: ReadCacheOptions): Promise<any>;
+export declare function compressCache(data: any, options?: WriteCacheOptions): Promise<string | Buffer<ArrayBufferLike>>;
+export declare const ONE_WEEK: number;
+export declare function getTempLocalCache({ file, defaultData, clearAfter, returnWithSaveFunction }: {
+    file: string;
+    defaultData?: any;
+    clearAfter?: number;
+    returnWithSaveFunction?: boolean;
+}): any | ({
+    data: any;
+    saveCacheFile: () => void;
+});
+export declare function deleteCache(file: string): Promise<void>;
+export declare function readExpiringJsonCache(file: string): Promise<any>;
+export declare function writeExpiringJsonCache(file: string, data: any, { expireAfter, // cache for 1 day by default
+expiryTimestamp, }?: {
+    expireAfter?: number;
+    expiryTimestamp?: number;
+}): Promise<void>;
+export declare function cachedFetch({ key, endpoint, postData, fetcher, fetchOptions, errorOnNoCache, cacheMaxAge, writeCacheOptions, readCacheOptions, }: {
+    key: string;
+    endpoint?: string;
+    postData?: any;
+    fetcher?: () => Promise<any>;
+    fetchOptions?: any;
+    errorOnNoCache?: boolean;
+    cacheMaxAge?: number;
+    writeCacheOptions?: WriteCacheOptions;
+    readCacheOptions?: ReadCacheOptions;
+}): Promise<any>;
+export {};