@defillama/sdk 5.0.236 → 5.0.240

package/build/util/blocks.js

@@ -1,292 +0,0 @@
-"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
-};
-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));
-    }
-}
-async function lookupBlock(timestamp, extraParams) {
-    const { chain = "ethereum" } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
-    const limiter = getChainLimiter(chain);
-    return limiter(() => _lookupBlock(timestamp, extraParams));
-}
-const earliestAvailableBlockRange = {
-    nibiru: 4 * 1e5, // nibiru hold only the last 400k block data
-    evmos: 2 * 1e5,
-};
-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);
-        return {
-            timestamp,
-            block: +data.height,
-            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;
-    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
-            };
-        }
-        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);
-        }
-        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
-            && chain !== "bsc" // this check is there because bsc halted the chain for few days
-            && !(0, env_1.shouldSkipBlockValidation)(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
-        };
-    }
-    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 getChainBlockTimeCache(chain) {
-        if (!blockTimeCache[chain])
-            blockTimeCache[chain] = {};
-        return blockTimeCache[chain];
-    }
-    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 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

@@ -1,45 +0,0 @@
-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 {};

package/build/util/cache.js

@@ -1,309 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ONE_WEEK = exports.currentVersion = void 0;
-exports.readCache = readCache;
-exports.writeCache = writeCache;
-exports.parseCache = parseCache;
-exports.compressCache = compressCache;
-exports.getTempLocalCache = getTempLocalCache;
-exports.deleteCache = deleteCache;
-exports.readExpiringJsonCache = readExpiringJsonCache;
-exports.writeExpiringJsonCache = writeExpiringJsonCache;
-exports.cachedFetch = cachedFetch;
-const debugLog_1 = require("./debugLog");
-const r2_1 = require("./r2");
-const zlib_1 = require("zlib");
-const util_1 = require("util");
-const env_1 = require("./env");
-const common_1 = require("./common");
-const brotliOptions = {
-    [zlib_1.constants.BROTLI_PARAM_MODE]: zlib_1.constants.BROTLI_MODE_TEXT,
-    [zlib_1.constants.BROTLI_PARAM_QUALITY]: zlib_1.constants.BROTLI_MAX_QUALITY,
-};
-function zipAsync(data) {
-    return (0, util_1.promisify)(zlib_1.brotliCompress)(data, brotliOptions);
-}
-function unzipAsync(data) {
-    return (0, util_1.promisify)(zlib_1.brotliDecompress)(data, brotliOptions).then(r => r.toString());
-}
-const _fs = require('fs');
-const fs = _fs.promises;
-const path = require('path');
-const foldersCreated = {};
-exports.currentVersion = 'zlib-1.0';
-function getCacheRootFolder() {
-    const defaultCacheRootFolder = path.join(__dirname, 'local_cache');
-    return path.join((0, env_1.getEnvCacheFolder)(defaultCacheRootFolder), exports.currentVersion);
-}
-function getFilePath(file) {
-    return path.join(getCacheRootFolder(), file);
-}
-async function createSubPath(folderPath) {
-    const datRoot = getCacheRootFolder();
-    folderPath = folderPath.replace(datRoot, '');
-    if (foldersCreated[folderPath])
-        return;
-    try {
-        await fs.mkdir(path.join(datRoot, folderPath), { recursive: true });
-    }
-    catch (error) {
-        // sdk.log('Error creating folder path:', error)
-    }
-    foldersCreated[folderPath] = true;
-}
-const ONE_DAY_IN_MS = 1000 * 60 * 60 * 24;
-async function readCache(file, options = {}) {
-    if (options.skipCompression)
-        file = `${file}-uncompressed`;
-    try {
-        const data = await readFile();
-        return await parseCache(data, options);
-    }
-    catch (error) {
-        // debugLog('Error reading cache:', error)
-        return {};
-    }
-    async function readFile() {
-        var _a;
-        try {
-            const data = await readDataFromLocal((_a = options.readFromR2Cache) !== null && _a !== void 0 ? _a : false);
-            return data;
-        }
-        catch (error) {
-            // debugLog('Error reading cache:', error)
-            return readDataFromR2();
-        }
-    }
-    async function readDataFromLocal(readFromR2Cache) {
-        const filePath = getFilePath(file);
-        if (options.checkIfRecent) {
-            const stats = await fs.stat(filePath);
-            if (Date.now() - stats.mtimeMs > ONE_DAY_IN_MS)
-                throw new Error('File too old, read from R2 instead');
-        }
-        if (readFromR2Cache)
-            throw new Error('Read from R2 cache');
-        const data = await fs.readFile(filePath);
-        return data;
-    }
-    async function readDataFromR2() {
-        var _a;
-        if (options.skipR2Cache)
-            return;
-        try {
-            const r2Data = await (0, r2_1.getR2JSONString)(exports.currentVersion + '/' + file, { throwErrorOnFail: (_a = options.readFromR2Cache) !== null && _a !== void 0 ? _a : false });
-            if (r2Data) {
-                // `file` already carries the `-uncompressed` suffix (added above), so omit skipCompression here to avoid writeCache appending it again
-                await writeCache(file, r2Data, { alreadyCompressed: true, skipR2CacheWrite: true });
-                return r2Data;
-            }
-        }
-        catch (error) {
-            if (options.readFromR2Cache) {
-                // if we were forced to read from R2 cache, try reading from local cache if R2 fails
-                try {
-                    const data = await readDataFromLocal(false);
-                    return data;
-                }
-                catch (_e) { }
-            }
-            return {};
-        }
-    }
-}
-async function writeCache(file, data, options = {}) {
-    try {
-        const fileData = options.alreadyCompressed ? data : await compressCache(data, options);
-        if (!data || (typeof data === 'string' && data.length < 20) || fileData.length < 20) {
-            (0, debugLog_1.debugLog)('Data too small to cache: ', file);
-            return;
-        }
-        if (!options.skipCompression && isSameData(data, await readCache(file, { skipR2Cache: true, skipCompression: options.skipCompression, })))
-            return;
-        if (options.skipCompression)
-            file = `${file}-uncompressed`;
-        const filePath = getFilePath(file);
-        await createSubPath(path.dirname(filePath));
-        await fs.writeFile(filePath, fileData);
-        if (!options.skipR2CacheWrite) {
-            await (0, r2_1.storeR2JSONString)(exports.currentVersion + '/' + file, fileData);
-        }
-        return fileData;
-    }
-    catch (error) {
-        if (typeof data === 'object' && data !== null && Object.keys(data).length === 0)
-            return;
-        (0, debugLog_1.debugLog)('Error writing cache:', error);
-    }
-}
-async function parseCache(dataString, options = {}) {
-    var _a;
-    let dataBuffer;
-    if (typeof dataString === 'string')
-        dataBuffer = Buffer.from(dataString, 'base64');
-    else {
-        dataBuffer = dataString;
-        dataString = dataBuffer.toString('utf8');
-    }
-    let decompressed;
-    let _unzipAsync = (str) => options.skipCompression ? dataString : unzipAsync(str); // if skipCompression is true, we don't decompress the data
-    try {
-        decompressed = await _unzipAsync((_a = dataBuffer) !== null && _a !== void 0 ? _a : dataString);
-    }
-    catch (e) {
-        // dataString = dataString.toString('utf8')
-        const convertedDataString = Buffer.from(dataString, 'base64');
-        decompressed = await _unzipAsync(convertedDataString);
-    }
-    return JSON.parse(decompressed).llamaWrapped;
-}
-async function compressCache(data, options = {}) {
-    const dataString = JSON.stringify({ version: exports.currentVersion, llamaWrapped: data });
-    if (options.skipCompression)
-        return dataString;
-    const comressedCache = await zipAsync(dataString);
-    return comressedCache;
-}
-function isSameData(data1, data2) {
-    return JSON.stringify(data1) === JSON.stringify(data2);
-}
-exports.ONE_WEEK = 1000 * 60 * 60 * 24 * 7;
-function getTempLocalCache({ file, defaultData = {}, clearAfter = exports.ONE_WEEK, returnWithSaveFunction = false }) {
-    const now = Math.floor(Date.now() / 1e3);
-    let emptyFile = { created: now, data: defaultData };
-    let fileData = emptyFile;
-    const filePath = getFilePath(file);
-    let saveCacheFlag = false; // to ensure that we save only once on exit
-    createSubPath(path.dirname(filePath)); // create folder if not exists, this is async but we don't care
-    try {
-        const data = _fs.readFileSync(filePath);
-        fileData = JSON.parse(data.toString());
-        if (now - fileData.created > clearAfter)
-            fileData = emptyFile; // clear cache
-    }
-    catch (error) { }
-    // save cache on exit
-    process.on('exit', _save);
-    process.on('SIGTERM', _save);
-    process.on('SIGINT', _save);
-    if (returnWithSaveFunction) {
-        return {
-            data: fileData.data,
-            saveCacheFile: () => saveCache(true)
-        };
-    }
-    return fileData.data;
-    function _save() {
-        saveCache(false);
-    }
-    function saveCache(skipCacheFlagCheck = false) {
-        if (!skipCacheFlagCheck) {
-            if (saveCacheFlag)
-                return;
-            saveCacheFlag = true;
-        }
-        try {
-            // debugLog('Saving cache to file:', filePath)
-            removePromisesAndFunctions(fileData);
-            _fs.writeFileSync(filePath, JSON.stringify(fileData));
-        }
-        catch (error) {
-            try {
-                (0, debugLog_1.debugLog)('Error saving cache:', error === null || error === void 0 ? void 0 : error.toString());
-            }
-            catch (error) { }
-        }
-    }
-    function removePromisesAndFunctions(data) {
-        if (typeof data === 'object') {
-            for (const key in data) {
-                if (typeof data[key] === 'function')
-                    delete data[key];
-                if (data[key] instanceof Promise)
-                    delete data[key];
-                else
-                    removePromisesAndFunctions(data[key]);
-            }
-        }
-    }
-}
-// this removes data only from the file cache, not from the R2 cache
-async function deleteCache(file) {
-    const filePath = getFilePath(file);
-    await fs.unlink(filePath).catch(() => {
-        // ignore errors
-    });
-}
-async function readExpiringJsonCache(file) {
-    const options = { readFromR2Cache: false, skipR2Cache: true, skipCompression: true };
-    file = 'expiring/' + file;
-    const data = await readCache(file, options);
-    if (!data || Object.keys(data).length === 0)
-        return null;
-    if (data.expiryTimestamp < (Date.now() / 1e3)) {
-        await deleteCache(`${file}-uncompressed`);
-        return null;
-    }
-    return data.data;
-}
-async function writeExpiringJsonCache(file, data, { expireAfter = 60 * 60 * 24, // cache for 1 day by default
-expiryTimestamp, } = {}) {
-    file = 'expiring/' + file;
-    if (!expiryTimestamp)
-        expiryTimestamp = Math.floor(Date.now() / 1e3) + expireAfter;
-    const options = { skipR2CacheWrite: true, skipCompression: true };
-    await writeCache(file, { data, expiryTimestamp }, options);
-}
-async function cachedFetch({ key, endpoint, postData, fetcher, fetchOptions, errorOnNoCache = true, cacheMaxAge = 0, writeCacheOptions = {
-    skipCompression: true,
-    skipR2CacheWrite: true,
-}, readCacheOptions = {
-    skipCompression: true,
-    skipR2Cache: true,
-}, }) {
-    if (!key) {
-        if (!endpoint || postData || fetcher)
-            throw new Error('Key is required for cachedFetch');
-        key = (0, common_1.getHash)(endpoint);
-    }
-    const fileKey = 'cached-fetch/' + key;
-    // check local cache first
-    if (cacheMaxAge > 0) {
-        try {
-            const filePath = getFilePath(readCacheOptions.skipCompression ? `${fileKey}-uncompressed` : fileKey);
-            const stats = await fs.stat(filePath);
-            if (Date.now() - stats.mtimeMs < cacheMaxAge) {
-                const cachedData = await readCache(fileKey, readCacheOptions);
-                if (cachedData && Object.keys(cachedData).length > 0)
-                    return cachedData;
-            }
-        }
-        catch (error) {
-            // cache miss or stat error, proceed to fetch
-        }
-    }
-    try {
-        let data;
-        if (fetcher)
-            data = await fetcher();
-        else {
-            if (!endpoint)
-                throw new Error('Either fetcher or endpoint is required for cachedFetch');
-            if (postData)
-                data = await (0, common_1.postJson)(endpoint, postData, fetchOptions);
-            else
-                data = await (0, common_1.fetchJson)(endpoint, fetchOptions);
-        }
-        await writeCache(fileKey, data, writeCacheOptions);
-        return data;
-    }
-    catch (error) {
-        const errorMessage = (0, common_1.formError)(error).message;
-        (0, debugLog_1.debugLog)('Error in cachedFetch:', errorMessage);
-        // if fetch fails, read from cache (regardless of age)
-        const cachedData = await readCache(fileKey, readCacheOptions);
-        if (!cachedData && errorOnNoCache)
-            throw new Error('Fetch failed and no cache available');
-        return cachedData;
-    }
-}