@defillama/sdk 5.0.185 → 5.0.188

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

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padTopic32 = padTopic32;
+exports.normalizeLog = normalizeLog;
+exports.normalizeValueByType = normalizeValueByType;
+exports.convertTopicsToViemFormat = convertTopicsToViemFormat;
+exports.enrichEthersArgsWithNamedProperties = enrichEthersArgsWithNamedProperties;
+exports.buildEthersCompatibleArgs = buildEthersCompatibleArgs;
+exports.createViemFastPathBatchDecoder = createViemFastPathBatchDecoder;
+const ethers_1 = require("ethers");
+const viem_1 = require("viem");
+function padTopic32(t) {
+    if (!t)
+        return '0x';
+    // Early return if already 32 bytes (0x + 64 hex chars)
+    if (t.startsWith('0x') && t.length === 66)
+        return t;
+    const hex = t.startsWith('0x') ? t.slice(2) : t;
+    return ('0x' + hex.padStart(64, '0'));
+}
+function normalizeLog(log, isIndexerCall = false) {
+    if (isIndexerCall || log.source) {
+        log.address = log.source;
+        log.logIndex = log.log_index;
+        log.index = log.log_index;
+        log.transactionHash = log.transaction_hash;
+        log.blockNumber = parseInt(log.block_number || log.blockNumber || 0);
+        const topics = [log.topic0, log.topic1, log.topic2, log.topic3]
+            .filter(Boolean)
+            .map(padTopic32);
+        if (!topics[0])
+            return false;
+        log.topics = topics;
+        log._originalTopics = {
+            topic0: log.topic0,
+            topic1: log.topic1,
+            topic2: log.topic2,
+            topic3: log.topic3
+        };
+        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);
+    // 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(padTopic32);
+    }
+    // Restore transaction hash if it was lost
+    if (!log.transactionHash && log._originalTransactionHash) {
+        log.transactionHash = log._originalTransactionHash;
+    }
+    return true;
+}
+/**
+ * Normalize value type according to Solidity type to match Ethers format
+ * Ethers returns small int types (int24, uint24, uint16, etc.) as strings to avoid JS precision issues
+ */
+const smallIntPattern = /^u?int(8|16|24)$/;
+function normalizeValueByType(value, type) {
+    if (value === null || value === undefined)
+        return value;
+    // Ethers formats small integer types as strings
+    if (smallIntPattern.test(type)) {
+        if (typeof value === 'number') {
+            return value.toString();
+        }
+        else if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    }
+    return value;
+}
+function convertTopicsToViemFormat(topics) {
+    if (!topics || topics.length === 0 || topics[0] === null) {
+        return [];
+    }
+    const filteredTopics = [];
+    for (let t = 0; t < topics.length; t++) {
+        if (topics[t] !== null) {
+            filteredTopics.push(topics[t]);
+        }
+    }
+    // Create tuple type for Viem (required format)
+    return filteredTopics.length > 0
+        ? [filteredTopics[0], ...filteredTopics.slice(1)]
+        : [];
+}
+// Enrich Ethers args with named properties to match Viem output structure
+function enrichEthersArgsWithNamedProperties(ethersArgs, event, iface) {
+    if (!ethersArgs || !event || !event.inputs) {
+        return ethersArgs;
+    }
+    // Create a new args object with named properties
+    const enrichedArgs = Object.create(null);
+    // Copy all existing properties (numeric and named if present)
+    for (const key in ethersArgs) {
+        if (ethersArgs.hasOwnProperty && !ethersArgs.hasOwnProperty(key))
+            continue;
+        enrichedArgs[key] = ethersArgs[key];
+    }
+    // Ensure named properties are present
+    const inputs = event.inputs;
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        const value = ethersArgs[i];
+        if (value !== undefined && value !== null) {
+            if (input.name && !(input.name in enrichedArgs)) {
+                enrichedArgs[input.name] = value;
+            }
+            enrichedArgs[i] = value;
+        }
+    }
+    if (typeof ethersArgs.length === 'number') {
+        enrichedArgs.length = ethersArgs.length;
+    }
+    return enrichedArgs;
+}
+function buildEthersCompatibleArgs(decodedArgs, eventInputs, normalizeFn = normalizeValueByType) {
+    var _a, _b;
+    if (!decodedArgs) {
+        const args = Object.create(null);
+        args.length = eventInputs.length;
+        return args;
+    }
+    const args = Object.create(null);
+    args.length = eventInputs.length;
+    try {
+        if (Array.isArray(decodedArgs)) {
+            const len = Math.min(decodedArgs.length, eventInputs.length);
+            for (let i = 0; i < len; i++) {
+                const input = eventInputs[i];
+                const value = decodedArgs[i];
+                if (value !== undefined && value !== null) {
+                    const normalizedValue = normalizeFn(value, input.type);
+                    if (input.name)
+                        args[input.name] = normalizedValue;
+                    args[i] = normalizedValue;
+                }
+            }
+            return args;
+        }
+        if (typeof decodedArgs === 'object') {
+            const inputCount = eventInputs.length;
+            for (let i = 0; i < inputCount; i++) {
+                const input = eventInputs[i];
+                const value = (_b = (_a = decodedArgs[input.name]) !== null && _a !== void 0 ? _a : decodedArgs[i]) !== null && _b !== void 0 ? _b : null;
+                if (value !== undefined && value !== null) {
+                    const normalizedValue = normalizeFn(value, input.type);
+                    if (input.name)
+                        args[input.name] = normalizedValue;
+                    args[i] = normalizedValue;
+                }
+            }
+            return args;
+        }
+    }
+    catch (e) {
+        // Fallback: minimal object creation
+        if (Array.isArray(decodedArgs)) {
+            const len = decodedArgs.length;
+            for (let i = 0; i < len; i++) {
+                args[i] = decodedArgs[i];
+            }
+            args.length = len;
+        }
+        else if (typeof decodedArgs === 'object') {
+            Object.assign(args, decodedArgs);
+        }
+    }
+    return args;
+}
+function createViemFastPathBatchDecoder(eventAbi) {
+    try {
+        // Parse ABI once
+        const ev = (0, viem_1.parseAbiItem)(eventAbi);
+        if (!ev || ev.type !== 'event')
+            return null;
+        const inputs = ev.inputs || [];
+        const indexed = [];
+        const nonIndexed = [];
+        for (const inp of inputs) {
+            if (inp.indexed) {
+                indexed.push(inp);
+            }
+            else {
+                nonIndexed.push(inp);
+            }
+        }
+        const nonIndexedTypes = nonIndexed.map(i => ({ type: i.type }));
+        return async function decodeBatchViemFast(logs) {
+            var _a, _b;
+            const out = new Array(logs.length);
+            for (let i = 0; i < logs.length; i++) {
+                const l = logs[i];
+                try {
+                    const logData = l.data || l.data_field || '0x';
+                    const decodedNon = nonIndexed.length && logData && logData !== '0x'
+                        ? (0, viem_1.decodeAbiParameters)(nonIndexedTypes, logData)
+                        : [];
+                    const args = Object.create(null);
+                    args.length = inputs.length;
+                    let topicIdx = 1; // topics[0] = event signature
+                    let nonIndexedIdx = 0;
+                    for (let j = 0; j < inputs.length; j++) {
+                        const inp = inputs[j];
+                        let value;
+                        if (inp.indexed) {
+                            if (topicIdx < (((_a = l.topics) === null || _a === void 0 ? void 0 : _a.length) || 0)) {
+                                value = l.topics[topicIdx];
+                                topicIdx++;
+                            }
+                            else {
+                                value = null;
+                            }
+                        }
+                        else {
+                            value = (_b = decodedNon[nonIndexedIdx]) !== null && _b !== void 0 ? _b : null;
+                            nonIndexedIdx++;
+                        }
+                        let normalizedValue = null;
+                        if (value !== null && value !== undefined) {
+                            // For indexed addresses, Ethers extracts the address from the padded topic
+                            // Topics are 32 bytes padded, but Ethers returns addresses as normal 20-byte addresses
+                            // Ethers uses getAddress() which converts to checksum format
+                            if (inp.type === 'address' && inp.indexed && typeof value === 'string') {
+                                let addressStr;
+                                if (value.startsWith('0x') && value.length === 66) {
+                                    // Topic is 32 bytes padded, extract the address (last 20 bytes = 40 hex chars)
+                                    addressStr = '0x' + value.slice(-40);
+                                }
+                                else if (value.startsWith('0x') && value.length === 42) {
+                                    addressStr = value;
+                                }
+                                else {
+                                    // Fallback: try to extract address from topic
+                                    const hex = value.startsWith('0x') ? value.slice(2) : value;
+                                    if (hex.length >= 40) {
+                                        addressStr = '0x' + hex.slice(-40);
+                                    }
+                                    else {
+                                        addressStr = value;
+                                    }
+                                }
+                                // Use ethers.getAddress to convert to checksum format (like Ethers does)
+                                try {
+                                    normalizedValue = ethers_1.ethers.getAddress(addressStr);
+                                }
+                                catch {
+                                    // Fallback if getAddress fails
+                                    normalizedValue = addressStr.toLowerCase();
+                                }
+                            }
+                            else {
+                                // For other types, use normal normalization
+                                normalizedValue = normalizeValueByType(value, inp.type);
+                            }
+                        }
+                        // Always assign both numeric index and named property (even if value is null/undefined)
+                        // This matches Ethers behavior where all args are present in the args object
+                        args[j] = normalizedValue;
+                        if (inp.name) {
+                            args[inp.name] = normalizedValue;
+                        }
+                    }
+                    out[i] = args;
+                }
+                catch (e) {
+                    // Fallback: return empty args on decode error
+                    const args = Object.create(null);
+                    args.length = inputs.length;
+                    out[i] = args;
+                }
+            }
+            return out;
+        };
+    }
+    catch (e) {
+        return null;
+    }
+}

package/build/util/logs.js

@@ -15,6 +15,7 @@ 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";
 /* -------------------------------------------------------------------------- */
 /*                                   getLogs                                  */
@@ -277,8 +278,14 @@ async function getLogParams(options, isIndexerCall = false) {
     if (!noTarget && !target && !targets.length)
         throw new Error('target|targets is required or set the flag "noTarget" to true');
     let iface;
-    if (eventAbi)
+    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);
@@ -296,19 +303,17 @@ async function getLogParams(options, isIndexerCall = false) {
         // normalize indexer payload
         if (isIndexerCall) {
             log.address = log.source;
-            log.logIndex = log.log_index;
-            log.index = log.log_index;
+            // 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((t) => {
-                if (!t)
-                    return null;
-                const topic = t.startsWith("0x") ? t : `0x${t}`;
-                return ethers_1.ethers.zeroPadValue(topic, 32);
-            });
+                .map(logs_decode_shared_1.padTopic32);
             // Ensure first topic (event signature) is present
             if (!topics[0]) {
                 return log;
@@ -338,21 +343,28 @@ async function getLogParams(options, isIndexerCall = false) {
         if (!log.topics && log._originalTopics) {
             log.topics = [log._originalTopics.topic0, log._originalTopics.topic1, log._originalTopics.topic2, log._originalTopics.topic3]
                 .filter(Boolean)
-                .map((t) => {
-                if (!t)
-                    return null;
-                const topic = t.startsWith("0x") ? t : `0x${t}`;
-                return ethers_1.ethers.zeroPadValue(topic, 32);
-            });
+                .map(logs_decode_shared_1.padTopic32);
         }
         // Restore transaction hash if it was lost
         if (!log.transactionHash && log._originalTransactionHash) {
             log.transactionHash = log._originalTransactionHash;
         }
-        const parsed = iface.parseLog(log);
-        if (!parsed && !allowParseFailure)
-            throw new Error(`Failed to parse log: ${JSON.stringify(log.transactionHash)}`);
-        log.args = parsed === null || parsed === void 0 ? void 0 : parsed.args;
+        let parsed = null;
+        if (!iface) {
+            log.args = undefined;
+        }
+        else {
+            parsed = iface.parseLog(log);
+            if (!parsed && !allowParseFailure)
+                throw new Error(`Failed to parse log: ${JSON.stringify(log.transactionHash)}`);
+            // 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;

package/build/util/updateProviderList.js

@@ -8,6 +8,8 @@ const fs_1 = __importDefault(require("fs"));
 const debugLog_1 = require("./debugLog");
 const promise_pool_1 = __importDefault(require("@supercharge/promise-pool"));
 const generalUtil_1 = require("../generalUtil");
+const concurrentCheckChains = +(process.env.SDK_BUILD_CONCURRENT_CHAINS || 7);
+const chainRemovalThreshold = +(process.env.SDK_BUILD_CHAIN_REMOVAL_THRESHOLD || 20);
 const providerList = providers_json_1.default;
 async function getChainData() {
     try {
@@ -26,17 +28,52 @@ async function getChainData() {
 }
 async function main() {
     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);
     chainData = chainData
         .filter((i) => i.rpc.length)
         // .filter((i: any) => !i.status || (i.status === 'active' || i.status === 'incubating'))
-        .filter((i) => i.shortName);
+        .filter((i) => i.shortName)
+        .filter((i) => {
+        if (currentChainsSet.has(i.shortName))
+            return true;
+        const bannedKeys = ['sepolia', 'test', 'goerli', 'devnet', 'holesky',];
+        const bannedRPCKeys = ['sepolia', 'goerli', 'devnet', 'holesky'];
+        const isTestnetKey = bannedKeys.some((j) => i.shortName.includes(j));
+        const hasTestnetRPC = i.rpc.some((rpc) => bannedRPCKeys.some((k) => rpc === null || rpc === void 0 ? void 0 : rpc.url.includes(k)));
+        if (isTestnetKey || hasTestnetRPC)
+            console.log(`Excluding testnet chain ${i.name} (${i.shortName})`);
+        return !isTestnetKey && !hasTestnetRPC;
+    });
+    // trim/remove mainnet|-mainnet|_mainnet from short names, preliminary rpc filtering
+    const rpcFilterRegex = /(wss\:|ws\:|terminet\.io|huobichain\.com|getblock\.io|bitstack\.com|nodereal.io\/v1|pokt\.network|histori\.xyz|chainstacklabs\.com|owlracle\.info|blastapi\.io)/;
+    chainData.forEach((i) => {
+        if (currentChainsSet.has(i.shortName)) {
+            // keep the short name as is
+        }
+        if (i.shortName.endsWith('-mainnet'))
+            i.shortName = i.shortName.slice(0, -8);
+        else if (i.shortName.endsWith('_mainnet'))
+            i.shortName = i.shortName.slice(0, -8);
+        else if (i.shortName.endsWith('mainnet'))
+            i.shortName = i.shortName.slice(0, -7);
+        i.rpc = i.rpc.filter((j) => {
+            if (!j.url)
+                return false;
+            if (rpcFilterRegex.test(j.url)) {
+                console.log(`Removing blacklisted rpc ${j.url} from ${i.name}`);
+                return false; // remove anything with blacklisted words
+            }
+            return true;
+        });
+    });
     // shuffle the array
     chainData.sort(() => Math.random() - 0.5);
     await promise_pool_1.default
-        .withConcurrency(5)
+        .withConcurrency(concurrentCheckChains)
         .for(chainData)
         .process(async (i) => {
         var _a, _b;
@@ -63,16 +100,12 @@ async function main() {
         }
     });
     Object.entries(providerList).forEach(([key, i]) => {
-        if (key.includes('testnet')) {
-            delete providerList[key];
-            return;
-        }
+        i.rpc.forEach((j) => {
+            if (filterRPCs([j]).length === 0) {
+                (0, debugLog_1.debugLog)(`Removing rpc ${j} from ${key}`);
+            }
+        });
         i.rpc = Array.from(new Set(filterRPCs(i.rpc)));
-        if (key.endsWith('-mainnet') || key.endsWith('_mainnet')) {
-            const shortName = key.slice(0, -8);
-            if (!providerList[shortName])
-                providerList[shortName] = i;
-        }
     });
     Object.keys(providerList).forEach((i) => {
         if (!providerList[i].rpc.length)
@@ -84,25 +117,34 @@ async function main() {
         providerList[key] = providerList[shorName];
     }
     const droppedChains = Object.keys(oldProviders).filter(oldChain => providerList[oldChain] === undefined);
-    if (droppedChains.length > 20) {
-        throw new Error(`Following chains used to be included but is not anymore, can the devs fix please?\n${droppedChains.join('\n')}`);
+    if (droppedChains.length > chainRemovalThreshold) {
+        throw new Error(`Following chains used to be included but is not anymore, can the devs fix please?\n${droppedChains.join(', ')}`);
     }
     delete providerList.bitcoin; // what were they smoking?
+    const rpcCount = Object.values(providerList).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);
+    console.log('Final provider list:');
+    console.log('Chain count:', Object.keys(providerList).length);
+    console.log('Dropped chain count:', droppedChains.length);
+    console.log('RPC count:', rpcCount);
+    console.log('Dropped chains:', droppedChains.join(', '));
     fs_1.default.writeFileSync(__dirname + '/../providers.json', JSON.stringify(providerList));
 }
 const blacklist = [
     'https://eth.api.onfinality.io/public'
 ];
+// this is stricter filtering used only when chain has more than 10 rpcs
 function filterRPCs(rpc) {
     return rpc.filter((i) => {
         if (blacklist.includes(i))
             return false; // remove rpcs returning bad block heights etc
         if (i.endsWith('/demo'))
             return false; // remove demo rpc
+        if (!i.startsWith('http'))
+            return false; // remove demo rpc
         if (i.includes('$'))
             return false; // remove anything where api key is injected
         // reject websocket, http, testnet, devnet, and anything with '='
-        if (/(wss\:|ws\:|http\:|test|devnet|terminet\.io|huobichain\.com|getblock\.io|bitstack\.com|nodereal.io\/v1|pokt\.network|ankr\.com|histori\.xyz|chainstacklabs\.com|owlracle\.info\=)/.test(i))
+        if (/(wss\:|ws\:|http\:|test|devnet|terminet\.io|huobichain\.com|getblock\.io|bitstack\.com|nodereal.io\/v1|pokt\.network|ankr\.com|histori\.xyz|chainstacklabs\.com|owlracle\.info|blastapi\.io|\=)/.test(i))
             return false; // remove anything with blacklisted words
         return true;
     }).map((i) => {
@@ -127,6 +169,8 @@ const chainShortNameMapping = {
     elsm: 'ely',
     tac: 'tacchain',
     xone: 'xoc',
+    hydragon: 'hydra',
+    camp: 'campmainnet',
 };
 async function filterForWorkingRPCs(rpc, chain, chainId) {
     if (rpc.length < 10)
@@ -143,11 +187,12 @@ async function filterForWorkingRPCs(rpc, chain, chainId) {
                 timeout: 30000
             });
             if (data.result)
-                return i;
+                return true;
         }
         catch (e) {
-            console.log(chain, e === null || e === void 0 ? void 0 : e.message);
+            console.log('ignoring bad rpc', chain, e === null || e === void 0 ? void 0 : e.message);
         }
+        return false;
     }));
     return rpc.filter((_i, index) => promises[index]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defillama/sdk",
-  "version": "5.0.185",
+  "version": "5.0.188",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {
@@ -34,10 +34,13 @@
     "axios": "^1.6.5",
     "ethers": "^6.0.0",
     "p-limit": "^3.0.0",
-    "tron-format-address": "^0.1.11"
+    "stream-json": "^1.9.1",
+    "tron-format-address": "^0.1.11",
+    "viem": "^2.38.6"
   },
   "devDependencies": {
     "@types/jest": "^29.2.3",
+    "@types/stream-json": "^1.7.8",
     "jest": "^29.3.1",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",