@defillama/sdk 5.0.187 → 5.0.192

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;
+    }
+    const inputs = event.inputs;
+    const length = typeof ethersArgs.length === 'number' ? ethersArgs.length : inputs.length;
+    const enrichedArgs = new Array(length);
+    for (let i = 0; i < length; i++) {
+        if (i in ethersArgs) {
+            enrichedArgs[i] = ethersArgs[i];
+        }
+    }
+    for (const key in ethersArgs) {
+        if (!Object.prototype.hasOwnProperty.call(ethersArgs, key))
+            continue;
+        if (!/^\d+$/.test(key)) {
+            enrichedArgs[key] = ethersArgs[key];
+        }
+    }
+    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;
+            }
+            if (!(i in enrichedArgs)) {
+                enrichedArgs[i] = value;
+            }
+        }
+    }
+    return enrichedArgs;
+}
+function buildEthersCompatibleArgs(decodedArgs, eventInputs, normalizeFn = normalizeValueByType) {
+    var _a, _b;
+    if (!decodedArgs) {
+        const args = new Array(eventInputs.length);
+        return args;
+    }
+    const args = new Array(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 = new Array(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 = new Array(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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defillama/sdk",
-  "version": "5.0.187",
+  "version": "5.0.192",
   "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",