@defillama/sdk 5.0.240 → 5.0.244

package/build/util/logs.js

@@ -0,0 +1,432 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBufferedToBlock = getBufferedToBlock;
+exports.getLogs = getLogs;
+exports.maxLogsForStorage = maxLogsForStorage;
+exports.trimCachesForStorage = trimCachesForStorage;
+exports.toFilterTopic = toFilterTopic;
+exports.getLogParams = getLogParams;
+const ethers_1 = require("ethers");
+const _1 = require(".");
+const blocks_1 = require("./blocks");
+const cache_1 = require("./cache");
+const debugLog_1 = require("./debugLog");
+const indexer_1 = require("./indexer");
+const promisePool_1 = __importDefault(require("./promisePool"));
+const env_1 = require("./env");
+const common_1 = require("./common");
+const logs_decode_shared_1 = require("./logs.decode.shared");
+const currentVersion = "v3";
+const BLOCK_BUFFER = 10;
+// widen the fetched range forward by BLOCK_BUFFER, without asking for blocks the chain does not
+// have yet and without ever returning less than the caller asked for
+function getBufferedToBlock(toBlock, head, buffer = BLOCK_BUFFER) {
+    const buffered = toBlock + buffer;
+    if (head === undefined)
+        return buffered;
+    return Math.min(buffered, Math.max(toBlock, head));
+}
+/* -------------------------------------------------------------------------- */
+/*                                   getLogs                                  */
+/* -------------------------------------------------------------------------- */
+async function getLogs(options) {
+    let { target, skipCache = false, skipCacheRead = false, cacheInCloud = false, keys = [], targets, flatten = true, skipIndexer = false, onlyIndexer = false, debugMode = false, processor, maxBlockRange, } = options;
+    const { fromBlock, toBlock, topics, topic, transformLog, chain } = await getLogParams(options, false);
+    /* ----------------------------- Indexer path ----------------------------- */
+    // If the caller demands indexer only but it is disabled, fail fast
+    if (onlyIndexer && !(0, indexer_1.isIndexerEnabled)(chain))
+        throw new Error("onlyIndexer is true, but indexer is not enabled");
+    if (!skipIndexer && (0, indexer_1.isIndexerEnabled)(chain)) {
+        try {
+            const response = await (0, indexer_1.getLogs)({
+                ...options,
+                all: true, // internal service – always fetch full set
+            });
+            return response;
+        }
+        catch (e) {
+            (0, debugLog_1.debugLog)("Error in indexer getLogs", e.message);
+            // If caller insisted on indexer only, propagate the error
+            if (onlyIndexer)
+                throw e;
+            // Otherwise continue with RPC fallback
+        }
+    }
+    if (!debugMode)
+        debugMode = debugLog_1.DEBUG_LEVEL2 && !!env_1.ENV_CONSTANTS.GET_LOGS_DEBUG;
+    /* ----------------------- Split by maxBlockRange ------------------------- */
+    const blockRange = toBlock - fromBlock;
+    if (maxBlockRange && blockRange > maxBlockRange) {
+        const results = [];
+        for (let currentFromBlock = fromBlock; currentFromBlock <= toBlock; currentFromBlock += maxBlockRange) {
+            const currentToBlock = Math.min(currentFromBlock + maxBlockRange - 1, toBlock);
+            const chunk = await getLogs({
+                ...options,
+                fromBlock: currentFromBlock,
+                toBlock: currentToBlock,
+            });
+            results.push(chunk);
+        }
+        return flatten ? results.flat() : results;
+    }
+    /* ------------------------ Multi-target parallel ------------------------- */
+    if (targets === null || targets === void 0 ? void 0 : targets.length) {
+        const baseOpts = { ...options, fromBlock, toBlock, skipIndexer: true };
+        delete baseOpts.targets;
+        const jobs = targets.map((address, idx) => ({ idx, address }));
+        const proc = async (job) => {
+            const logs = await getLogs({ ...baseOpts, target: job.address });
+            return { idx: job.idx, logs };
+        };
+        const results = await (0, promisePool_1.default)({ items: jobs, concurrency: 5, processor: proc });
+        const ordered = new Array(targets.length);
+        for (const { idx, logs } of results)
+            ordered[idx] = logs;
+        return flatten ? ordered.flat() : ordered;
+    }
+    /* ----------------------------- RPC fallback ----------------------------- */
+    if (chain === "tron")
+        target = (0, common_1.tronToEvmAddress)(target);
+    let caches = (await _getCache());
+    const firstRun = !caches.length;
+    if (firstRun || skipCacheRead) {
+        await addLogsToCache(fromBlock, toBlock);
+    }
+    else {
+        // try to fill gaps compared to what is already cached
+        let _from = fromBlock;
+        let _to = toBlock;
+        const firstCache = caches[0];
+        const lastCache = caches[caches.length - 1];
+        for (const c of caches) {
+            const { fromBlock: cStart, toBlock: cEnd } = c.metadata;
+            if (_to < firstCache.metadata.fromBlock || _from > lastCache.metadata.toBlock) {
+                await addLogsToCache(_from, _to);
+                break;
+            }
+            if (_from >= cEnd)
+                continue;
+            if (_from <= cStart) {
+                await addLogsToCache(_from, Math.min(_to, cStart - 1));
+            }
+            if (_to <= cEnd) {
+                _from = cEnd;
+                break;
+            }
+            _from = cEnd;
+        }
+        if (_from < _to)
+            await addLogsToCache(_from, _to);
+    }
+    /* ---------------------------- Return result ----------------------------- */
+    let out = [];
+    for (const c of caches) {
+        const { fromBlock: cStart, toBlock: cEnd } = c.metadata;
+        if (fromBlock > cEnd || toBlock < cStart)
+            continue;
+        const filtered = c.logs
+            .filter((i) => i.blockNumber >= fromBlock && i.blockNumber <= toBlock)
+            .map(transformLog);
+        if (processor)
+            await processor(filtered);
+        // Always include filtered logs in the return value, even when a processor is provided
+        out = out.concat(filtered); // use concat instead of ... to avoid running into issues with large arrays (RangeError: Maximum call stack size exceeded)
+    }
+    return out;
+    /* ----------------------------------------------------------------------- */
+    /*                         Internal helper functions                       */
+    /* ----------------------------------------------------------------------- */
+    async function addLogsToCache(fromBlock, toBlock) {
+        const dbgKey = `getLogs-${chain}-${topic}-${target}_${Math.random()}-${fromBlock}-${toBlock}`;
+        if (debugMode)
+            (0, debugLog_1.debugLog)("adding logs to cache:", fromBlock, toBlock);
+        if (fromBlock > toBlock)
+            return;
+        fromBlock = Math.max(fromBlock - BLOCK_BUFFER, 0); // avoid negative block
+        // the forward buffer must not run past the chain head. Several RPCs reject a range that ends
+        // beyond their latest block outright, and since every RPC in the pool rejects it the whole call
+        // fails. If the head cannot be read (halted chain, provider error) keep the previous behaviour.
+        let head;
+        try {
+            head = await (0, blocks_1.getBlockNumber)(chain);
+        }
+        catch (e) { }
+        toBlock = getBufferedToBlock(toBlock, head);
+        if (debugMode)
+            console.time(dbgKey);
+        const { output: newLogs } = await (0, _1.getLogs)({
+            chain,
+            target: target,
+            topic: topic,
+            keys,
+            topics,
+            fromBlock,
+            toBlock,
+        });
+        if (debugMode) {
+            console.timeEnd(dbgKey);
+            (0, debugLog_1.debugLog)("Logs pulled", chain, target, newLogs.length);
+        }
+        caches.push({ logs: newLogs, metadata: { fromBlock, toBlock } });
+        caches.sort((a, b) => a.metadata.fromBlock - b.metadata.fromBlock);
+        // merge overlapping ranges
+        const merged = [caches[0]];
+        caches.slice(1).forEach((c) => {
+            const last = merged[merged.length - 1];
+            if (last.metadata.toBlock + 1 >= c.metadata.fromBlock) {
+                last.metadata.toBlock = Math.max(last.metadata.toBlock, c.metadata.toBlock);
+                last.logs = dedupLogs(last.logs, c.logs);
+            }
+            else
+                merged.push(c);
+        });
+        caches = merged;
+        if (!skipCache) {
+            let storeCaches = caches;
+            let randomLogLength = 0;
+            const totalLogCount = caches.reduce((acc, c) => {
+                if (c.logs.length)
+                    randomLogLength = JSON.stringify(c.logs[0]).length;
+                return acc + c.logs.length;
+            }, 0);
+            const fileSizeInMB = (totalLogCount * randomLogLength) / (1024 * 1024);
+            if (fileSizeInMB > 300) { // if cache size is larger than ~300MB, trim it down
+                const maxLogs = maxLogsForStorage(randomLogLength);
+                console.log(`getLogs: large cache size detected ${totalLogCount} logs size: ${fileSizeInMB}MB, retaining only the latest ${maxLogs} logs to limit memory usage target=${target} topic=${topic} fromBlock=${fromBlock} toBlock=${toBlock}`);
+                storeCaches = trimCachesForStorage(storeCaches, maxLogs);
+            }
+            // we are skipping compression by default, so reads & writes are faster
+            await (0, cache_1.writeCache)(getFile(), { caches: storeCaches, version: currentVersion }, { skipR2CacheWrite: !cacheInCloud, skipCompression: !cacheInCloud });
+        }
+    }
+    function dedupLogs(...arr) {
+        const seen = new Set();
+        return arr.flat().filter((i) => {
+            var _a;
+            const key = `${i.transactionHash}-${(_a = i.logIndex) !== null && _a !== void 0 ? _a : i.index}`;
+            if (!(i.hasOwnProperty("logIndex") ||
+                i.hasOwnProperty("index")) ||
+                !i.hasOwnProperty("transactionHash")) {
+                (0, debugLog_1.debugLog)("Missing crucial field", i);
+                throw new Error("Missing crucial field: logIndex/index");
+            }
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    async function _getCache() {
+        const key = getFile();
+        const def = [];
+        if (skipCache)
+            return def;
+        let cache = await (0, cache_1.readCache)(key, { skipR2Cache: !cacheInCloud, skipCompression: !cacheInCloud, });
+        if (!cache.caches || !cache.caches.length || cache.version !== currentVersion)
+            return def;
+        return cache.caches;
+    }
+    function getFile() {
+        var _a;
+        let extraKey = topics === null || topics === void 0 ? void 0 : topics.join("-").toLowerCase();
+        if (!extraKey)
+            throw new Error("extraKey is required");
+        if (keys.length)
+            extraKey += "-" + keys.join("-").toLowerCase();
+        let file = `${(_a = target === null || target === void 0 ? void 0 : target.toLowerCase()) !== null && _a !== void 0 ? _a : null}-${extraKey}`;
+        const normalKeyLength = '0x27e5cb712334e101b3c232eb0be198baaa595f5f-0xe8137aa901976cc8eaf1cef5dec491873faadc99d9720ccaec95673294a9d7c5-uncompressed'.length;
+        // sometimes, there is a lot of topics and we hit the file name length limit
+        if (file.length > normalKeyLength)
+            file = (0, common_1.getHash)(file);
+        return `event-logs/${chain}/${file}`;
+    }
+}
+/* -------------------------------------------------------------------------- */
+/*                           Utility helpers exported                         */
+/* -------------------------------------------------------------------------- */
+// the log count that fits the same byte budget the size check uses, so a wide log trims before the flat cap
+function maxLogsForStorage(bytesPerLog, cap = 200000, budgetMB = 300) {
+    if (!bytesPerLog || bytesPerLog < 1)
+        return cap;
+    return Math.max(1, Math.min(cap, Math.floor((budgetMB * 1024 * 1024) / bytesPerLog)));
+}
+// keeps the newest range and at most maxLogs of its logs, narrowing the metadata to match what is kept
+function trimCachesForStorage(caches, maxLogs = 200000) {
+    if (!caches.length)
+        return caches;
+    let trimmed = caches;
+    if (caches.length > 1) {
+        let cacheWithLatestFromBlock = caches[0];
+        for (const c of caches) {
+            if (c.metadata.fromBlock > cacheWithLatestFromBlock.metadata.fromBlock) {
+                cacheWithLatestFromBlock = c;
+            }
+        }
+        trimmed = [cacheWithLatestFromBlock];
+    }
+    return trimmed.map(c => {
+        const clone = { logs: c.logs, metadata: JSON.parse(JSON.stringify(c.metadata)) };
+        if (c.logs.length > maxLogs) {
+            const sorted = [...c.logs].sort((a, b) => b.blockNumber - a.blockNumber);
+            clone.logs = sorted.slice(0, maxLogs);
+            clone.metadata.fromBlock = clone.logs[clone.logs.length - 1].blockNumber;
+        }
+        return clone;
+    });
+}
+function toFilterTopic(topic) {
+    if (topic.startsWith("0x"))
+        return topic;
+    const fragment = ethers_1.EventFragment.from(topic);
+    return (0, ethers_1.id)(fragment.format());
+}
+exports.default = getLogs;
+async function getLogParams(options, isIndexerCall = false) {
+    let { target, chain = "ethereum", fromBlock, toBlock, fromTimestamp, toTimestamp, eventAbi, topic, topics, extraTopics, entireLog = false, onlyArgs = false, targets = [], noTarget = false, parseLog = false, allowParseFailure = false, processor, flatten = false, } = options;
+    let parseLogWasImplicit = false;
+    let parseFailureWarned = false;
+    if (eventAbi && !Object.prototype.hasOwnProperty.call(options, "parseLog")) {
+        parseLog = true;
+        parseLogWasImplicit = true;
+    }
+    // keep raw log if entireLog=true
+    if (entireLog)
+        onlyArgs = false;
+    if (processor && targets.length > 1 && !flatten)
+        throw new Error("processor is not supported with multiple targets when flatten=false");
+    if (!fromBlock && !fromTimestamp)
+        throw new Error("fromBlock or fromTimestamp is required");
+    if (!toBlock && !toTimestamp)
+        throw new Error("toBlock or toTimestamp is required");
+    if (!fromBlock)
+        fromBlock = await (0, blocks_1.getBlockNumber)(chain, fromTimestamp);
+    if (!toBlock)
+        toBlock = await (0, blocks_1.getBlockNumber)(chain, toTimestamp);
+    if (!fromBlock || !toBlock)
+        throw new Error("fromBlock and toBlock must be > 0");
+    if (!noTarget && !target && !targets.length)
+        throw new Error('target|targets is required or set the flag "noTarget" to true');
+    let iface;
+    let event = null;
+    if (eventAbi) {
+        iface = new ethers_1.Interface([eventAbi]);
+        const fragments = iface.fragments.filter(f => f.type === 'event');
+        if (fragments.length > 0) {
+            event = fragments[0];
+        }
+    }
+    if (!(topics === null || topics === void 0 ? void 0 : topics.length)) {
+        if (topic)
+            topic = toFilterTopic(topic);
+        else if (eventAbi)
+            topic = toFilterTopic(eventAbi);
+        else
+            throw new Error("eventAbi | topic | topics are required");
+        topics = [topic];
+        if (extraTopics)
+            topics.push(...extraTopics);
+    }
+    if (topics === null || topics === void 0 ? void 0 : topics.length)
+        topic = topics[0];
+    function transformLog(log) {
+        // normalize indexer payload
+        if (isIndexerCall) {
+            log.address = log.source;
+            // Preserve logIndex/index if already set by normalizeLog, otherwise set from log_index
+            if (log.logIndex === undefined && log.index === undefined) {
+                log.logIndex = log.log_index;
+                log.index = log.log_index;
+            }
+            log.transactionHash = log.transaction_hash;
+            log.blockNumber = parseInt(log.block_number);
+            // Ensure topics are properly formatted
+            const topics = [log.topic0, log.topic1, log.topic2, log.topic3]
+                .filter(Boolean)
+                .map(logs_decode_shared_1.padTopic32);
+            // Ensure first topic (event signature) is present
+            if (!topics[0]) {
+                return log;
+            }
+            log.topics = topics;
+            // Store original topics for later use
+            log._originalTopics = {
+                topic0: log.topic0,
+                topic1: log.topic1,
+                topic2: log.topic2,
+                topic3: log.topic3
+            };
+            // Store original transaction hash
+            log._originalTransactionHash = log.transaction_hash;
+            // Only delete fields that are not needed for parsing
+            [
+                "chain",
+                "log_index",
+            ].forEach((k) => delete log[k]);
+        }
+        if (log.blockNumber === undefined && log.block_number !== undefined)
+            log.blockNumber = parseInt(log.block_number);
+        if ((entireLog && !parseLog) || !iface) {
+            return log;
+        }
+        // Restore topics if they were lost
+        if (!log.topics && log._originalTopics) {
+            log.topics = [log._originalTopics.topic0, log._originalTopics.topic1, log._originalTopics.topic2, log._originalTopics.topic3]
+                .filter(Boolean)
+                .map(logs_decode_shared_1.padTopic32);
+        }
+        // Restore transaction hash if it was lost
+        if (!log.transactionHash && log._originalTransactionHash) {
+            log.transactionHash = log._originalTransactionHash;
+        }
+        let parsed = null;
+        if (!iface) {
+            log.args = undefined;
+        }
+        else {
+            const parseFailureTolerated = allowParseFailure || (entireLog && parseLogWasImplicit);
+            try {
+                parsed = iface.parseLog(log);
+            }
+            catch (e) {
+                if (!parseFailureTolerated)
+                    throw e;
+                parsed = null;
+            }
+            if (!parsed && !parseFailureTolerated)
+                throw new Error(`Failed to parse log: ${JSON.stringify(log.transactionHash)}`);
+            // keep tolerated failures visible (once per call)
+            if (!parsed && !allowParseFailure && !parseFailureWarned) {
+                parseFailureWarned = true;
+                console.warn(`[sdk.getLogs] some logs did not decode against the provided eventAbi and were returned without .args ` +
+                    `(chain=${chain}, topic0=${topic}, firstTx=${log.transactionHash}). ` +
+                    `Pass parseLog: true to make this an error, or allowParseFailure: true to silence this warning.`);
+            }
+            // Enrich args with named properties to match Viem output structure
+            if ((parsed === null || parsed === void 0 ? void 0 : parsed.args) && event && iface) {
+                log.args = (0, logs_decode_shared_1.enrichEthersArgsWithNamedProperties)(parsed.args, event, iface);
+            }
+            else {
+                log.args = parsed === null || parsed === void 0 ? void 0 : parsed.args;
+            }
+        }
+        if (entireLog)
+            log.parsedLog = parsed;
+        return onlyArgs ? log.args : log;
+    }
+    return {
+        chain,
+        fromBlock,
+        toBlock,
+        target,
+        topic: topic,
+        topic1: topics[1],
+        topic2: topics[2],
+        topic3: topics[3],
+        iface,
+        transformLog,
+        topics,
+    };
+}

package/build/util/promisePool.d.ts

@@ -0,0 +1,8 @@
+export default function runInPromisePool(params: {
+    items: any[];
+    concurrency: number;
+    processor: any;
+    permitFailure?: boolean;
+    withMetadata?: boolean;
+}): Promise<any>;
+export { runInPromisePool };

package/build/util/promisePool.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runInPromisePool;
+exports.runInPromisePool = runInPromisePool;
+const promise_pool_1 = require("@supercharge/promise-pool");
+const common_1 = require("./common");
+async function runInPromisePool(params) {
+    const errors = [];
+    const { results, } = await promise_pool_1.PromisePool
+        .withConcurrency(params.concurrency)
+        .for(params.items)
+        .process(async (item, i) => {
+        try {
+            if (errors.length && !params.permitFailure)
+                throw new Error('Aborting, previous errors in promise pool');
+            const res = await params.processor(item, i);
+            return [res, i];
+        }
+        catch (e) {
+            errors.push(e);
+            return [undefined, i];
+        }
+    });
+    if (errors.length && !params.permitFailure)
+        throw (0, common_1.formError)(null, { promisePoolErrors: errors });
+    // Preserve order of results
+    const flatResults = results.sort((a, b) => a[1] - b[1]).map((i => i[0]));
+    if (params.withMetadata)
+        return { results: flatResults, errors };
+    return flatResults;
+}

package/build/util/r2.d.ts

@@ -0,0 +1,4 @@
+export declare function storeR2JSONString(filename: string, body: string | Buffer): Promise<any>;
+export declare function getR2JSONString(filename: string, { throwErrorOnFail }?: {
+    throwErrorOnFail?: boolean | undefined;
+}): Promise<any>;

package/build/util/r2.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeR2JSONString = storeR2JSONString;
+exports.getR2JSONString = getR2JSONString;
+const env_1 = require("./env");
+const common_1 = require("./common");
+const { S3Client, PutObjectCommand, GetObjectCommand, } = require("@aws-sdk/client-s3");
+const { R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY } = env_1.ENV_CONSTANTS;
+const datasetBucket = "defillama-datasets";
+const publicBucketUrl = "https://defillama-datasets.llama.fi";
+let R2;
+if (R2_ENDPOINT && R2_ACCESS_KEY_ID && R2_SECRET_ACCESS_KEY) {
+    R2 = new S3Client({
+        region: "auto",
+        endpoint: "https://" + R2_ENDPOINT,
+        credentials: {
+            accessKeyId: R2_ACCESS_KEY_ID,
+            secretAccessKey: R2_SECRET_ACCESS_KEY,
+        },
+    });
+}
+const getKey = (filename) => filename.replace(/(:|'|#)/g, '/');
+async function storeR2JSONString(filename, body) {
+    if (typeof body !== 'string')
+        body = body.toString('base64');
+    if (!R2)
+        return;
+    const command = new PutObjectCommand({
+        Bucket: datasetBucket,
+        Key: getKey(filename),
+        Body: body,
+        ContentType: "application/json",
+    });
+    return R2.send(command);
+}
+async function getR2JSONString(filename, { throwErrorOnFail = false } = {}) {
+    try {
+        if (!R2)
+            return await _fetchData();
+        const command = new GetObjectCommand({ Bucket: datasetBucket, Key: getKey(filename), });
+        const { Body } = await R2.send(command);
+        return await Body.transformToString();
+    }
+    catch (e) {
+        if (throwErrorOnFail)
+            throw e;
+        return {};
+    }
+    async function _fetchData() {
+        return (0, common_1.fetchJson)(`${publicBucketUrl}/${filename}`);
+    }
+}

package/build/util/removeRedundantRPCs.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/removeRedundantRPCs.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const providers_json_1 = __importDefault(require("../providers.json"));
+const fs_1 = __importDefault(require("fs"));
+const generalUtil_1 = require("../generalUtil");
+const providerList = providers_json_1.default;
+async function getChainData() {
+    try {
+        const chainData = await (0, generalUtil_1.fetchJson)('https://chainlist.org/rpcs.json');
+        return chainData;
+    }
+    catch (e) {
+        console.log('Failed to fetch chainlist.org, falling back to local copy');
+        // https://unpkg.com/@defillama/sdk@latest/build/providers.json
+        return require(__dirname + '/chainlistOrgCache.json');
+    }
+}
+async function main() {
+    let chainData = await getChainData();
+    const providerIDMap = {};
+    Object.values(chainData).forEach((i) => providerIDMap[i.chainId] = {
+        ...i,
+        rpc: new Set(i.rpc.map((j) => j.url))
+    });
+    Object.entries(providerList).forEach(([key, data]) => {
+        const chainListdata = providerIDMap[data.chainId];
+        if (!chainListdata)
+            return;
+        data.rpc = data.rpc.filter((i) => {
+            if (i.endsWith('/'))
+                i = i.slice(0, -1);
+            if (chainListdata.rpc.has(i)) {
+                console.log(`Removing rpc ${i} from ${key} as it is already in chainlist`);
+                return false;
+            }
+            return true;
+        });
+        if (!data.rpc.length && chainListdata.shortName === key) {
+            delete providerList[key];
+            console.log(`Removing ${key} as it has no rpcs left`);
+            return;
+        }
+    });
+    fs_1.default.writeFileSync(__dirname + '/../providers.json', JSON.stringify(providers_json_1.default, null, 2));
+}
+main();

package/build/util/transactions.d.ts

@@ -0,0 +1,35 @@
+export interface GetTransactionOptions {
+    addresses?: string[];
+    from_block?: number;
+    to_block?: number;
+    transaction_hashes?: string[];
+    limit?: number | 'all';
+    offset?: number;
+    chain?: string;
+    all?: boolean;
+    debugMode?: boolean;
+    transactionType?: 'from' | 'to' | 'all';
+}
+export declare function getTransactions(params: GetTransactionOptions): Promise<{
+    hash: any;
+    blockNumber: number;
+    transactionIndex: number;
+    from: any;
+    to: any;
+    value: any;
+    gasPrice: any;
+    gas: any;
+    input: any;
+    nonce: number;
+    data: any;
+    type: any;
+    maxFeePerGas: any;
+    maxPriorityFeePerGas: any;
+    baseFeePerGas: any;
+    effectiveGasPrice: any;
+    gasUsed: any;
+    cumulativeGasUsed: any;
+    status: number;
+    contractCreated: any;
+    timestamp: any;
+}[] | null>;

package/build/util/transactions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactions = getTransactions;
+const debugLog_1 = require("./debugLog");
+const indexer_1 = require("./indexer");
+async function getTransactions(params) {
+    const { chain } = params;
+    if (!(0, indexer_1.isIndexer2Enabled)(chain)) {
+        throw new Error(`Indexer v2 not available for chain ${chain}`);
+    }
+    try {
+        const response = await (0, indexer_1.getTransactions)(params);
+        if (response)
+            return response;
+    }
+    catch (e) {
+        let message = e === null || e === void 0 ? void 0 : e.message;
+        (0, debugLog_1.debugLog)('Error in indexer getTransactions', message);
+        throw e;
+    }
+    return null;
+}

package/build/util/updateChainLabels.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/updateChainLabels.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chainUtils_1 = require("./chainUtils");
+// pulls latest chain key <-> label mappings and dead chain list from the llama api and writes them to chainUtils/data.json
+(0, chainUtils_1.updateChainLabels)();

package/build/util/updateProviderList.d.ts

@@ -0,0 +1 @@
+export {};