@defillama/sdk 5.0.240 → 5.0.244

package/build/util/indexerSql.d.ts

@@ -0,0 +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>, options?: IndexerSqlOptions): Promise<T[]>;
+/** Gateway-oriented name; queryClickhouse remains available for existing consumers. */
+export declare const queryIndexerSql: typeof queryClickhouse;

package/build/util/indexerSql.js

@@ -0,0 +1,102 @@
+"use strict";
+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"));
+const http_1 = __importDefault(require("http"));
+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 getSqlConfig() {
+    const v4Endpoint = (0, env_1.getEnvValue)("LLAMA_INDEXER_V4_ENDPOINT");
+    return {
+        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"),
+    };
+}
+// 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 = getSqlConfig();
+    return !!(c.endpoint && c.user && c.password);
+}
+async function queryClickhouse(sql, params, settings, options = {}) {
+    var _a, _b;
+    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 url = new URL(endpoint);
+    const search = url.searchParams;
+    search.set("default_format", "JSONEachRow");
+    for (const [name, value] of Object.entries(params !== null && params !== void 0 ? params : {})) {
+        search.set(`param_${name}`, serializeQueryParameter(value));
+    }
+    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(url.toString(), sql, {
+            auth: { username: user, password },
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+            responseType: "text",
+            transformResponse: (d) => d,
+            // The gateway owns execution deadlines. Callers can still cancel a request.
+            timeout: 0,
+            signal: options.signal,
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+            httpAgent,
+            httpsAgent,
+        });
+    }
+    catch (e) {
+        const status = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status;
+        const body = typeof ((_b = e === null || e === void 0 ? void 0 : e.response) === null || _b === void 0 ? void 0 : _b.data) === "string" ? e.response.data.slice(0, 500) : "";
+        throw new Error(`indexer /sql query failed${status ? ` (HTTP ${status})` : ""}: ${body || (e === null || e === void 0 ? void 0 : e.message) || e}`);
+    }
+    return parseJsonEachRow(res.data);
+}
+function parseJsonEachRow(text) {
+    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/internal-cache.d.ts

@@ -0,0 +1,11 @@
+export declare function getCache(options: CacheOptions): any;
+export declare function setCache(options: CacheOptions): void;
+export declare function saveCache(): void;
+export declare function startCache(_cache?: {}): void;
+export declare function retriveCache(): any;
+export type CacheOptions = {
+    address: string;
+    abi: string;
+    chain?: string;
+    value?: any;
+};

package/build/util/internal-cache.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCache = getCache;
+exports.setCache = setCache;
+exports.saveCache = saveCache;
+exports.startCache = startCache;
+exports.retriveCache = retriveCache;
+const fs = __importStar(require("fs"));
+const env_1 = require("./env");
+// const cacheFile = __dirname + '/../../../sc-cache1.json'
+const cacheFile = env_1.ENV_CONSTANTS.INTERNAL_SDK_CACHE_FILE;
+let cache = {};
+// if (cacheFile) cache = require(cacheFile) // disabled for now
+function getCache(options) {
+    let { address, abi, chain = "ethereum" } = options;
+    if (!address)
+        return;
+    address = address.slice(2).toLowerCase();
+    if (!cache[chain])
+        cache[chain] = {};
+    if (!cache[chain][abi])
+        cache[chain][abi] = {};
+    return cache[chain][abi][address];
+}
+function setCache(options) {
+    let { address, abi, chain = "ethereum", value } = options;
+    if (!address)
+        return;
+    address = address.slice(2).toLowerCase();
+    if (!cache[chain])
+        cache[chain] = {};
+    if (!cache[chain][abi])
+        cache[chain][abi] = {};
+    cache[chain][abi][address] = value;
+}
+function saveCache() {
+    fs.writeFileSync(cacheFile || './cache.json', JSON.stringify(cache));
+}
+function startCache(_cache = {}) {
+    cache = _cache;
+}
+function retriveCache() {
+    return cache;
+}

package/build/util/logs.d.ts

@@ -0,0 +1,58 @@
+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;
+    keys?: string[];
+    fromBlock?: number;
+    toBlock?: number;
+    topics?: (string | null)[];
+    extraTopics?: string[];
+    chain?: string;
+    eventAbi?: string | any;
+    fromTimestamp?: number;
+    toTimestamp?: number;
+    skipCache?: boolean;
+    skipCacheRead?: boolean;
+    entireLog?: boolean;
+    cacheInCloud?: boolean;
+    onlyArgs?: boolean;
+    targets?: Address[];
+    flatten?: boolean;
+    skipIndexer?: boolean;
+    onlyIndexer?: boolean;
+    debugMode?: boolean;
+    noTarget?: boolean;
+    parseLog?: boolean;
+    processor?: (logs: any[]) => Promise<void> | void;
+    maxBlockRange?: number;
+    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[];
+    metadata: {
+        fromBlock: number;
+        toBlock: number;
+    };
+};
+export default getLogs;
+type GetLogsParamsResponse = {
+    chain: string;
+    fromBlock: number;
+    toBlock: number;
+    target?: Address;
+    topic: string;
+    iface?: Interface;
+    transformLog: (log: any) => any;
+    topics?: (string | null)[];
+    topic1?: string;
+    topic2?: string;
+    topic3?: string;
+};
+export declare function getLogParams(options: GetLogsOptions | IndexerGetLogsOptions, isIndexerCall?: boolean): Promise<GetLogsParamsResponse>;

package/build/util/logs.decode.shared.d.ts

@@ -0,0 +1,8 @@
+import { ethers, Interface } from "ethers";
+export declare function padTopic32(t: string): `0x${string}`;
+export declare function normalizeLog(log: any, isIndexerCall?: boolean): boolean;
+export declare function normalizeValueByType(value: any, type: string): any;
+export declare function convertTopicsToViemFormat(topics: any[]): [`0x${string}`, ...(`0x${string}`[] | [])] | [];
+export declare function enrichEthersArgsWithNamedProperties(ethersArgs: any, event: ethers.EventFragment | null, iface: Interface): any;
+export declare function buildEthersCompatibleArgs(decodedArgs: any, eventInputs: readonly ethers.ParamType[], normalizeFn?: (value: any, type: string) => any): any;
+export declare function createViemFastPathBatchDecoder(eventAbi: string | any): ((logs: any[]) => Promise<any[]>) | null;

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

@@ -0,0 +1,289 @@
+"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) {
+    var _a, _b, _c, _d;
+    if (isIndexerCall || log.source) {
+        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)
+            .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;
+    }
+}