@defillama/sdk 5.0.235 → 5.0.238

package/build/util/indexerSql.d.ts

@@ -1,2 +1,9 @@
+export type IndexerSqlOptions = {
+    /** Accepted for compatibility with dimension-adapters; all chains use the same gateway. */
+    chain?: string;
+    signal?: AbortSignal;
+};
 export declare function isIndexerSqlEnabled(): boolean;
-export declare function queryClickhouse<T = any>(sql: string, params?: Record<string, unknown>, settings?: Record<string, string | number>): Promise<T[]>;
+export declare function queryClickhouse<T = any>(sql: string, params?: Record<string, unknown>, settings?: Record<string, string | number>, options?: IndexerSqlOptions): Promise<T[]>;
+/** Gateway-oriented name; queryClickhouse remains available for existing consumers. */
+export declare const queryIndexerSql: typeof queryClickhouse;

package/build/util/indexerSql.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryIndexerSql = void 0;
 exports.isIndexerSqlEnabled = isIndexerSqlEnabled;
 exports.queryClickhouse = queryClickhouse;
 const axios_1 = __importDefault(require("axios"));
@@ -11,40 +12,76 @@ const https_1 = __importDefault(require("https"));
 const env_1 = require("./env");
 const httpAgent = new http_1.default.Agent({ keepAlive: true, maxSockets: 64, maxFreeSockets: 16 });
 const httpsAgent = new https_1.default.Agent({ keepAlive: true, maxSockets: 64, maxFreeSockets: 16 });
-function sqlConfig() {
+function getSqlConfig() {
+    const v4Endpoint = (0, env_1.getEnvValue)("LLAMA_INDEXER_V4_ENDPOINT");
     return {
-        endpoint: (0, env_1.getEnvValue)("LLAMA_INDEXER_SQL_ENDPOINT"),
+        endpoint: (0, env_1.getEnvValue)("LLAMA_INDEXER_SQL_ENDPOINT") || (v4Endpoint ? `${v4Endpoint.replace(/\/+$/, "")}/sql` : undefined),
         user: (0, env_1.getEnvValue)("LLAMA_INDEXER_SQL_USER"),
         password: (0, env_1.getEnvValue)("LLAMA_INDEXER_SQL_PASSWORD"),
-        timeoutMs: +(0, env_1.getEnvValue)("LLAMA_INDEXER_SQL_TIMEOUT_MS") || 180000,
     };
 }
+// ClickHouse HTTP query parameters use escaped text, not JSON. Nested strings
+// must be quoted, and UInt64/UInt256 values must never pass through Number().
+function serializeQueryParameter(value, nested = false) {
+    if (value === null || value === undefined)
+        return nested ? "NULL" : "\\N";
+    if (typeof value === "string") {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")
+            .replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+        return nested ? `'${escaped}'` : escaped;
+    }
+    if (typeof value === "boolean")
+        return nested ? (value ? "TRUE" : "FALSE") : (value ? "1" : "0");
+    if (typeof value === "number") {
+        if (Number.isNaN(value))
+            return "nan";
+        if (!Number.isFinite(value))
+            return value > 0 ? "+inf" : "-inf";
+        return String(value);
+    }
+    if (typeof value === "bigint")
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.map((v) => serializeQueryParameter(v, true)).join(",")}]`;
+    if (value instanceof Date) {
+        const seconds = String(Math.floor(value.getTime() / 1000)).padStart(10, "0");
+        return value.getUTCMilliseconds() ? `${seconds}.${String(value.getUTCMilliseconds()).padStart(3, "0")}` : seconds;
+    }
+    if (typeof value === "object") {
+        const entries = value instanceof Map ? [...value.entries()] : Object.entries(value);
+        return `{${entries.map(([k, v]) => `${serializeQueryParameter(k, true)}:${serializeQueryParameter(v, true)}`).join(",")}}`;
+    }
+    throw new Error("Unsupported SQL query parameter type");
+}
 function isIndexerSqlEnabled() {
-    const c = sqlConfig();
+    const c = getSqlConfig();
     return !!(c.endpoint && c.user && c.password);
 }
-async function queryClickhouse(sql, params, settings) {
+async function queryClickhouse(sql, params, settings, options = {}) {
     var _a, _b;
-    const { endpoint, user, password, timeoutMs } = sqlConfig();
+    const { endpoint, user, password } = getSqlConfig();
     if (!endpoint || !user || !password) {
         throw new Error("Llama indexer SQL gateway not configured (LLAMA_INDEXER_SQL_ENDPOINT/USER/PASSWORD)");
     }
-    const search = new URLSearchParams();
+    const url = new URL(endpoint);
+    const search = url.searchParams;
     search.set("default_format", "JSONEachRow");
-    for (const [k, v] of Object.entries(params !== null && params !== void 0 ? params : {})) {
-        search.set(`param_${k}`, typeof v === "object" ? JSON.stringify(v) : String(v));
+    for (const [name, value] of Object.entries(params !== null && params !== void 0 ? params : {})) {
+        search.set(`param_${name}`, serializeQueryParameter(value));
     }
-    for (const [k, v] of Object.entries(settings !== null && settings !== void 0 ? settings : {})) {
-        search.set(k, String(v));
+    for (const [name, value] of Object.entries(settings !== null && settings !== void 0 ? settings : {})) {
+        search.set(name, String(value));
     }
     let res;
     try {
-        res = await axios_1.default.post(`${endpoint}?${search.toString()}`, sql, {
+        res = await axios_1.default.post(url.toString(), sql, {
             auth: { username: user, password },
             headers: { "Content-Type": "text/plain; charset=utf-8" },
             responseType: "text",
             transformResponse: (d) => d,
-            timeout: timeoutMs,
+            // The gateway owns execution deadlines. Callers can still cancel a request.
+            timeout: 0,
+            signal: options.signal,
             maxBodyLength: Infinity,
             maxContentLength: Infinity,
             httpAgent,
@@ -59,13 +96,7 @@ async function queryClickhouse(sql, params, settings) {
     return parseJsonEachRow(res.data);
 }
 function parseJsonEachRow(text) {
-    if (!text)
-        return [];
-    const out = [];
-    for (const line of text.split("\n")) {
-        if (!line)
-            continue;
-        out.push(JSON.parse(line));
-    }
-    return out;
+    return text.split("\n").filter(line => line.trim()).map(line => JSON.parse(line));
 }
+/** Gateway-oriented name; queryClickhouse remains available for existing consumers. */
+exports.queryIndexerSql = queryClickhouse;

package/build/util/logs.d.ts

@@ -1,6 +1,7 @@
 import { EventLog, Interface } from "ethers";
 import { Address } from "../types";
 import { IndexerGetLogsOptions } from "./indexer";
+export declare function getBufferedToBlock(toBlock: number, head?: number, buffer?: number): number;
 export type GetLogsOptions = {
     target?: Address;
     topic?: string;
@@ -30,6 +31,8 @@ export type GetLogsOptions = {
     allowParseFailure?: boolean;
 };
 export declare function getLogs(options: GetLogsOptions): Promise<EventLog[] | EventLog[][] | any[]>;
+export declare function maxLogsForStorage(bytesPerLog: number, cap?: number, budgetMB?: number): number;
+export declare function trimCachesForStorage(caches: logCache[], maxLogs?: number): logCache[];
 export declare function toFilterTopic(topic: string): string;
 export type logCache = {
     logs: EventLog[];

package/build/util/logs.decode.shared.js

@@ -19,11 +19,12 @@ function padTopic32(t) {
     return ('0x' + hex.padStart(64, '0'));
 }
 function normalizeLog(log, isIndexerCall = false) {
+    var _a, _b, _c, _d;
     if (isIndexerCall || log.source) {
-        log.address = log.source;
-        log.logIndex = log.log_index;
-        log.index = log.log_index;
-        log.transactionHash = log.transaction_hash;
+        log.address = (_a = log.source) !== null && _a !== void 0 ? _a : log.address;
+        log.logIndex = (_c = (_b = log.log_index) !== null && _b !== void 0 ? _b : log.logIndex) !== null && _c !== void 0 ? _c : log.index;
+        log.index = log.logIndex;
+        log.transactionHash = (_d = log.transaction_hash) !== null && _d !== void 0 ? _d : log.transactionHash;
         log.blockNumber = parseInt(log.block_number || log.blockNumber || 0);
         const topics = [log.topic0, log.topic1, log.topic2, log.topic3]
             .filter(Boolean)

package/build/util/logs.js

@@ -3,7 +3,10 @@ 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");
@@ -17,6 +20,15 @@ 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                                  */
 /* -------------------------------------------------------------------------- */
@@ -133,8 +145,16 @@ async function getLogs(options) {
             (0, debugLog_1.debugLog)("adding logs to cache:", fromBlock, toBlock);
         if (fromBlock > toBlock)
             return;
-        fromBlock = Math.max(fromBlock - 10, 0); // avoid negative block
-        toBlock = toBlock + 10;
+        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)({
@@ -156,8 +176,8 @@ async function getLogs(options) {
         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 = c.metadata.toBlock;
+            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
@@ -174,28 +194,9 @@ async function getLogs(options) {
             }, 0);
             const fileSizeInMB = (totalLogCount * randomLogLength) / (1024 * 1024);
             if (fileSizeInMB > 300) { // if cache size is larger than ~300MB, trim it down
-                console.log(`getLogs: large cache size detected ${totalLogCount} logs size: ${fileSizeInMB}MB, retaining only the latest 200k logs to limit memory usage target=${target} topic=${topic} fromBlock=${fromBlock} toBlock=${toBlock}`);
-                // retain only the latest logs that fit within 300,000 logs
-                if (caches.length > 1) {
-                    let cacheWithLatestFromBlock = caches[0];
-                    for (const c of caches) {
-                        if (c.metadata.fromBlock > cacheWithLatestFromBlock.metadata.fromBlock) {
-                            cacheWithLatestFromBlock = c;
-                        }
-                    }
-                    storeCaches = [cacheWithLatestFromBlock];
-                }
-                storeCaches = storeCaches.map(c => {
-                    const clone = { logs: [], metadata: JSON.parse(JSON.stringify(c.metadata)) };
-                    if (c.logs.length > 200000) {
-                        // sort the logs by block number descending and keep only the latest 200k logs
-                        c.logs.sort((a, b) => b.blockNumber - a.blockNumber);
-                        clone.logs = c.logs.slice(0, 200000);
-                        const lastLog = clone.logs[clone.logs.length - 1];
-                        clone.metadata.fromBlock = lastLog.blockNumber;
-                    }
-                    return clone;
-                });
+                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 });
@@ -246,6 +247,36 @@ async function getLogs(options) {
 /* -------------------------------------------------------------------------- */
 /*                           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;

package/build/util/transactions.d.ts

@@ -10,4 +10,26 @@ export interface GetTransactionOptions {
     debugMode?: boolean;
     transactionType?: 'from' | 'to' | 'all';
 }
-export declare function getTransactions(params: GetTransactionOptions): Promise<any>;
+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/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.js

@@ -29,27 +29,19 @@ async function getChainData() {
     }
 }
 async function main() {
-    const chainKeyLabelMapCountBefore = Object.keys(chainUtils_1.chainKeyToChainLabelMap).length;
-    const chainLabelsKeyMapCountBefore = Object.keys(chainUtils_1.chainLabelsToKeyMap).length;
-    await (0, chainUtils_1.updateData)();
-    const chainKeyLabelMapCountAfter = Object.keys(chainUtils_1.chainKeyToChainLabelMap).length;
-    const chainLabelsKeyMapCountAfter = Object.keys(chainUtils_1.chainLabelsToKeyMap).length;
-    if (chainKeyLabelMapCountAfter > chainKeyLabelMapCountBefore) {
-        console.log(`Updated chainKeyToChainLabelMap: ${chainKeyLabelMapCountBefore} -> ${chainKeyLabelMapCountAfter}`);
-    }
-    if (chainLabelsKeyMapCountAfter > chainLabelsKeyMapCountBefore) {
-        console.log(`Updated chainLabelsToKeyMap: ${chainLabelsKeyMapCountBefore} -> ${chainLabelsKeyMapCountAfter}`);
-    }
-    if (chainKeyLabelMapCountAfter < chainKeyLabelMapCountBefore)
-        throw new Error('chainKeyToChainLabelMap count decreased, please investigate');
-    if (chainLabelsKeyMapCountAfter < chainLabelsKeyMapCountBefore)
-        throw new Error('chainLabelsToKeyMap count decreased, please investigate');
+    await (0, chainUtils_1.updateChainLabels)();
     const oldProviders = await (0, generalUtil_1.fetchJson)(`https://unpkg.com/@defillama/sdk@latest/build/providers.json`);
     const currentChains = await (0, generalUtil_1.fetchJson)(`https://raw.githubusercontent.com/DefiLlama/DefiLlama-Adapters/refs/heads/main/projects/helper/chains.json`);
     const currentChainsSet = new Set(currentChains);
     let chainData = await getChainData();
     const providerIDMap = {};
-    Object.values(providerList).forEach((i) => providerIDMap[i.chainId] = i.rpc);
+    const chainIdToKeyMap = {};
+    Object.entries(providerList).forEach(([key, i]) => {
+        providerIDMap[i.chainId] = i.rpc;
+        chainIdToKeyMap[i.chainId] = key;
+    });
+    const shortNameToKeyMap = {};
+    Object.entries(chainShortNameMapping).forEach(([key, shortName]) => shortNameToKeyMap[shortName] = key);
     chainData = chainData
         .filter((i) => i.rpc.length)
         // .filter((i: any) => !i.status || (i.status === 'active' || i.status === 'incubating'))
@@ -93,12 +85,39 @@ async function main() {
     });
     // shuffle the array
     chainData.sort(() => Math.random() - 0.5);
+    // chain keys this chain could end up under in providers.json
+    const getCandidateKeys = (i) => {
+        const keys = [i.shortName.toLowerCase().replace(/-/g, '_')];
+        if (chainIdToKeyMap[i.chainId])
+            keys.push(chainIdToKeyMap[i.chainId]);
+        if (shortNameToKeyMap[i.shortName])
+            keys.push(shortNameToKeyMap[i.shortName]);
+        return keys;
+    };
+    // only check rpc health for chains we track and that are not dead, the rest are only filtered statically
+    const shouldCheckRPCs = (i) => {
+        const keys = getCandidateKeys(i);
+        const isTracked = keys.some((k) => currentChainsSet.has(k));
+        const isDead = keys.some((k) => (0, chainUtils_1.isDeadChain)(k));
+        return isTracked && !isDead;
+    };
+    const skippedRPCChecks = { dead: 0, untracked: 0 };
     await promise_pool_1.default
         .withConcurrency(concurrentCheckChains)
         .for(chainData)
         .process(async (i) => {
         var _a, _b;
-        i.rpc = await filterForWorkingRPCs(i.rpc.map((j) => j.url), i.name, i.chainId);
+        const rpcs = i.rpc.map((j) => j.url);
+        if (shouldCheckRPCs(i)) {
+            i.rpc = await filterForWorkingRPCs(rpcs, i.name, i.chainId);
+        }
+        else {
+            if (getCandidateKeys(i).some((k) => (0, chainUtils_1.isDeadChain)(k)))
+                skippedRPCChecks.dead++;
+            else
+                skippedRPCChecks.untracked++;
+            i.rpc = rpcs.length < 4 ? rpcs : filterRPCs(rpcs);
+        }
         if (!i.rpc.length)
             return;
         if (providerIDMap[i.chainId]) {
@@ -158,6 +177,8 @@ async function main() {
     const rpcCountOld = Object.values(oldProviders).reduce((acc, i) => { var _a; return acc + ((_a = i === null || i === void 0 ? void 0 : i.rpc.length) !== null && _a !== void 0 ? _a : 0); }, 0);
     const newlyAddedChains = Object.keys(providerList).filter(chain => oldProviders[chain] === undefined);
     console.log('Final provider list:');
+    console.log('Skipped rpc checks (dead chains):', skippedRPCChecks.dead);
+    console.log('Skipped rpc checks (untracked chains):', skippedRPCChecks.untracked);
     console.log('Chain count:', Object.keys(providerList).length);
     console.log('Newly added chains count:', newlyAddedChains.length);
     console.log('Dropped chain count:', filteredDroppedChains.length);
@@ -238,7 +259,8 @@ async function filterForWorkingRPCs(rpc, chain, chainId) {
                 if (data.result) {
                     const returnedChainId = parseInt(data.result, 16);
                     if (returnedChainId !== chainId) {
-                        console.log(`RPC ${i} for ${chain} returned invalid chainId ${returnedChainId}, expected ${chainId}`);
+                        console.log(`RPC ${i} for ${chain} returned invalid chainId ${returnedChainId}, expected ${chainId}, skipping`);
+                        return;
                     }
                     filteredRPCs.push(i);
                 }

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@defillama/sdk",
-  "version": "5.0.235",
+  "version": "5.0.238",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {
     "start": "npm run build && node build/index.js",
     "pack-and-publish": "bash ./scripts/skipTestPatchAndPublish.sh",
     "build": "tsc",
-    "watch": "tsc --watch",
     "load-providers": "mkdir -p build && wget https://unpkg.com/@defillama/sdk@latest/build/providers.json -O build/providers.json",
     "test": "npm run load-providers && TEST_MODE=true LLAMA_DEBUG_MODE='' SDK_DEBUG='' LLAMA_DEBUG_LEVEL2=''  LLAMA_DEBUG_LEVEL3='' jest",
     "test-only": "echo 'skipped building providers.json' && TEST_MODE=true LLAMA_DEBUG_MODE='' SDK_DEBUG='' LLAMA_DEBUG_LEVEL2=''  LLAMA_DEBUG_LEVEL3='' jest",
-    "test-debug": "TEST_MODE=true jest",
-    "test-indexer": "TEST_MODE=true jest src/util/indexer.routing.test.ts src/util/indexer.test.ts src/util/indexer.v4.test.ts src/util/indexer.e2e.test.ts --runInBand",
+    "test-debug": "TEST_MODE=true JEST_VERBOSE=true jest",
+    "test-indexer": "jest --runInBand --runTestsByPath src/util/indexer.test.ts src/util/indexer.partialSync.test.ts src/util/indexer.partialSync.e2e.test.ts src/util/indexer.e2e.test.ts src/util/indexerSql.test.ts src/util/indexerSql.parity.test.ts",
+    "test-indexer-unit": "jest --runInBand --runTestsByPath src/util/indexer.test.ts src/util/indexer.partialSync.test.ts src/util/indexerSql.test.ts",
     "update-providers": "ts-node src/util/updateProviderList.ts",
+    "update-chain-labels": "ts-node src/util/updateChainLabels.ts",
     "remove-rpcs": "ts-node src/util/removeRedundantRPCs.ts",
-    "format": "prettier --write \"src/**/*.ts\"",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -23,10 +23,14 @@
     "url": "git+https://github.com/DefiLlama/defillama-sdk.git"
   },
   "author": "",
-  "license": "ISC",
   "types": "build/index.d.ts",
   "files": [
-    "build"
+    "build",
+    "!build/**/*.test.js",
+    "!build/abi/largeMulticall.d.ts",
+    "!build/abi/largeMulticall.js",
+    "!build/**/*.test.d.ts",
+    "!build/**/*.test.js.map"
   ],
   "dependencies": {
     "@aws-sdk/client-s3": "^3.400.0",
@@ -39,8 +43,17 @@
     "tron-format-address": "^0.1.11",
     "viem": "^2.38.6"
   },
+  "peerDependencies": {
+    "@solana/web3.js": ">=1.73.0"
+  },
+  "peerDependenciesMeta": {
+    "@solana/web3.js": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/jest": "^29.2.3",
+    "@types/node": "^24.8.1",
     "@types/stream-json": "^1.7.8",
     "jest": "^29.3.1",
     "ts-jest": "^29.1.1",

package/README.md

@@ -1,41 +0,0 @@
-# sdk
-
-```
-npm i
-npm run build
-npm t
-npm run format
-```
-
-### Publish
-```
-bash patchAndPublish.sh
-```
-
-### Keys
-
-```
-POLYGON_RPC="https://..."
-ETHEREUM_RPC="https://..."
-BSC_RPC="https://..."
-```
-
-### Environment variables
-
-Most settings can be overridden per chain via environment variables. The chain
-name is uppercased and used as a prefix, e.g. `ETHEREUM_RPC`, `BSC_RPC_MULTICALL_V3`.
-Every key is also resolved with an `SDK_` or `LLAMA_SDK_` prefix (checked in the
-order `LLAMA_SDK_<KEY>` → `SDK_<KEY>` → `<KEY>`), so `SDK_ETHEREUM_RPC` works too.
-
-| Variable | Description |
-| --- | --- |
-| `<CHAIN>_RPC` | RPC URL(s) for the chain (comma-separated for multiple). |
-| `<CHAIN>_RPC_MULTICALL_V3` | Address of a Multicall3 contract for the chain. Setting it enables the Multicall3 code path for that chain (even if the chain is not in the built-in registry) and uses this address. Takes precedence over the built-in registry and the deployment-block gating. |
-| `<CHAIN>_RPC_MULTICALL` | Address of a legacy (v2) multicall contract, used only when Multicall3 is not available for the chain. |
-| `<CHAIN>_MULTICALL_CHUNK_SIZE` | Max number of calls per multicall batch for the chain. |
-
-## Chain RPC PR
-
-Before putting up a PR for new chain, check if we already support it here: https://unpkg.com/@defillama/sdk@latest/build/providers.json 
-
-Everytime we publish a new sdk version, we automically pull latest list from chainlist.org and include it.