@defillama/sdk 5.0.146 → 5.0.147

package/build/util/cache.d.ts

@@ -4,15 +4,17 @@ export declare function readCache(file: string, options?: ReadCacheOptions): Pro
 interface WriteCacheOptions {
     skipR2CacheWrite?: boolean;
     alreadyCompressed?: boolean;
+    skipCompression?: boolean;
 }
 interface ReadCacheOptions {
     checkIfRecent?: boolean;
     readFromR2Cache?: boolean;
     skipR2Cache?: boolean;
+    skipCompression?: boolean;
 }
 export declare function writeCache(file: string, data: any, options?: WriteCacheOptions): Promise<string | undefined>;
-export declare function parseCache(dataString: string | Buffer): Promise<any>;
-export declare function compressCache(data: any): Promise<Buffer>;
+export declare function parseCache(dataString: string | Buffer, options?: ReadCacheOptions): Promise<any>;
+export declare function compressCache(data: any, options?: WriteCacheOptions): Promise<string | Buffer>;
 export declare const ONE_WEEK: number;
 export declare function getTempLocalCache({ file, defaultData, clearAfter, returnWithSaveFunction }: {
     file: string;

package/build/util/cache.js

@@ -43,21 +43,23 @@ async function createSubPath(folderPath) {
 }
 const ONE_DAY_IN_MS = 1000 * 60 * 60 * 24;
 async function readCache(file, options = {}) {
+    if (options.skipCompression)
+        file = `${file}-uncompressed`;
     try {
-        const data = await readFile(file, options);
-        return await parseCache(data);
+        const data = await readFile();
+        return await parseCache(data, options);
     }
     catch (error) {
         // debugLog('Error reading cache:', error)
         return {};
     }
-    async function readFile(file, options = {}) {
+    async function readFile() {
         const filePath = getFilePath(file);
         try {
             if (options.checkIfRecent) {
                 const stats = await fs.stat(filePath);
                 if (Date.now() - stats.mtimeMs > ONE_DAY_IN_MS)
-                    throw new Error('File too old, read from R2 isntead');
+                    throw new Error('File too old, read from R2 instead');
             }
             if (options.readFromR2Cache)
                 throw new Error('Read from R2 cache');
@@ -70,7 +72,7 @@ async function readCache(file, options = {}) {
                 return;
             const r2Data = await (0, r2_1.getR2JSONString)(exports.currentVersion + '/' + file);
             if (r2Data) {
-                await writeCache(file, r2Data, { alreadyCompressed: true, skipR2CacheWrite: true });
+                await writeCache(file, r2Data, { alreadyCompressed: true, skipR2CacheWrite: true, skipCompression: options.skipCompression });
                 return r2Data;
             }
         }
@@ -79,13 +81,15 @@ async function readCache(file, options = {}) {
 exports.readCache = readCache;
 async function writeCache(file, data, options = {}) {
     try {
-        const fileData = options.alreadyCompressed ? data : await compressCache(data);
+        const fileData = options.alreadyCompressed ? data : await compressCache(data, options);
         if (!data || (typeof data === 'string' && data.length < 20) || fileData.length < 20) {
             (0, debugLog_1.debugLog)('Data too small to cache: ', file);
             return;
         }
-        if (isSameData(data, await readCache(file, { skipR2Cache: true })))
+        if (isSameData(data, await readCache(file, { skipR2Cache: true, skipCompression: options.skipCompression, })))
             return;
+        if (options.skipCompression)
+            file = `${file}-uncompressed`;
         const filePath = getFilePath(file);
         await createSubPath(path.dirname(filePath));
         await fs.writeFile(filePath, fileData);
@@ -99,23 +103,33 @@ async function writeCache(file, data, options = {}) {
     }
 }
 exports.writeCache = writeCache;
-async function parseCache(dataString) {
+async function parseCache(dataString, options = {}) {
+    var _a;
+    let dataBuffer;
     if (typeof dataString === 'string')
-        dataString = Buffer.from(dataString, 'base64');
+        dataBuffer = Buffer.from(dataString, 'base64');
+    else {
+        dataBuffer = dataString;
+        dataString = dataBuffer.toString('utf8');
+    }
     let decompressed;
+    let _unzipAsync = (str) => options.skipCompression ? dataString : unzipAsync(str); // if skipCompression is true, we don't decompress the data
     try {
-        decompressed = await unzipAsync(dataString);
+        decompressed = await _unzipAsync((_a = dataBuffer) !== null && _a !== void 0 ? _a : dataString);
     }
     catch (e) {
-        dataString = dataString.toString('utf8');
-        dataString = Buffer.from(dataString, 'base64');
-        decompressed = await unzipAsync(dataString);
+        // dataString = dataString.toString('utf8')
+        const convertedDataString = Buffer.from(dataString, 'base64');
+        decompressed = await _unzipAsync(convertedDataString);
     }
     return JSON.parse(decompressed).llamaWrapped;
 }
 exports.parseCache = parseCache;
-async function compressCache(data) {
-    const comressedCache = await zipAsync(JSON.stringify({ version: exports.currentVersion, llamaWrapped: data }));
+async function compressCache(data, options = {}) {
+    const dataString = JSON.stringify({ version: exports.currentVersion, llamaWrapped: data });
+    if (options.skipCompression)
+        return dataString;
+    const comressedCache = await zipAsync(dataString);
     return comressedCache;
 }
 exports.compressCache = compressCache;
@@ -207,7 +221,7 @@ expiryTimestamp, }) {
     file = 'expiring/' + file;
     if (!expiryTimestamp)
         expiryTimestamp = Math.floor(Date.now() / 1e3) + expireAfter;
-    const options = { skipR2CacheWrite: true };
+    const options = { skipR2CacheWrite: true, skipCompression: true };
     await writeCache(file, { data, expiryTimestamp }, options);
 }
 exports.writeExpiringJsonCache = writeExpiringJsonCache;

package/build/util/index.d.ts

@@ -26,3 +26,4 @@ export declare function normalizeBalances(balances: {
 }): {
     [address: string]: string;
 };
+export declare function tableToString(data: any, columns?: any): string;

package/build/util/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeBalances = exports.normalizePrefixes = exports.normalizeAddress = exports.getLogs = exports.sliceIntoChunks = exports.runInPromisePool = exports.convertToBigInt = exports.lookupBlock = exports.getTimestamp = exports.getLatestBlock = void 0;
+exports.tableToString = exports.normalizeBalances = exports.normalizePrefixes = exports.normalizeAddress = exports.getLogs = exports.sliceIntoChunks = exports.runInPromisePool = exports.convertToBigInt = exports.lookupBlock = exports.getTimestamp = exports.getLatestBlock = void 0;
 const general_1 = require("../general");
 const ethers_1 = require("ethers");
 const generalUtil_1 = require("../generalUtil");
@@ -162,3 +162,34 @@ function normalizeBalances(balances) {
     return balances;
 }
 exports.normalizeBalances = normalizeBalances;
+function tableToString(data, columns) {
+    let tableString = '';
+    if (!data || !Array.isArray(data) || data.length === 0) {
+        return '';
+    }
+    if (!columns || !Array.isArray(columns) || columns.length === 0) {
+        columns = Object.keys(data[0] || {});
+    }
+    // Add the header row
+    const headerObject = {};
+    const headerObject1 = {};
+    columns.forEach((col) => {
+        headerObject[col] = col;
+        headerObject1[col] = '---';
+    });
+    data.unshift(headerObject1);
+    data.unshift(headerObject);
+    // Calculate the maximum width for each column
+    const columnWidths = columns.map((col) => Math.max(col.length, ...data.map((row) => (row[col] !== undefined ? String(row[col]).length : 0))));
+    // Add the data rows
+    data.forEach((row) => {
+        // Format the row with padded values
+        const tableRow = columns.map((col, index) => {
+            const cell = row[col] !== undefined ? String(row[col]) : '';
+            return cell.padEnd(columnWidths[index], ' ');
+        }).join(' | ');
+        tableString += tableRow + '\n';
+    });
+    return tableString;
+}
+exports.tableToString = tableToString;

package/build/util/indexer.d.ts

@@ -6,15 +6,6 @@ declare enum TokenTypes {
     ERC20 = "erc20",
     ERC721 = "erc721"
 }
-export declare function getTokens(address: string | string[], { onlyWhitelisted, skipCacheRead, skipCache, chain, tokenType, }?: {
-    onlyWhitelisted?: boolean;
-    skipCacheRead?: boolean;
-    skipCache?: boolean;
-    chain?: string;
-    tokenType?: TokenTypes;
-}): Promise<{
-    [chain: string]: string[];
-}>;
 export type IndexerGetLogsOptions = {
     target?: Address;
     topic?: string;
@@ -37,6 +28,9 @@ export type IndexerGetLogsOptions = {
     debugMode?: boolean;
     noTarget?: boolean;
     parseLog?: boolean;
+    processor?: (logs: any[]) => Promise<void> | void;
+    maxBlockRange?: number;
+    allowParseFailure?: boolean;
 };
 export type IndexerGetTokenTransfersOptions = {
     target?: Address;
@@ -52,13 +46,22 @@ export type IndexerGetTokenTransfersOptions = {
     offset?: number;
     debugMode?: boolean;
     fromAddressFilter?: string | string[];
-    transferType?: 'in' | 'out' | 'all';
+    transferType?: "in" | "out" | "all";
     tokens?: string | string[];
     token?: string;
 };
-export declare function getLogs({ chain, topic, topics, fromBlock, toBlock, all, limit, offset, target, targets, eventAbi, entireLog, flatten, extraTopics, fromTimestamp, toTimestamp, debugMode, noTarget, parseLog, }: IndexerGetLogsOptions): Promise<any[]>;
+export declare function getTokens(address: string | string[], { onlyWhitelisted, skipCacheRead, skipCache, chain, tokenType, }?: {
+    onlyWhitelisted?: boolean;
+    skipCacheRead?: boolean;
+    skipCache?: boolean;
+    chain?: string;
+    tokenType?: TokenTypes;
+}): Promise<{
+    [chain: string]: string[];
+}>;
+export declare function getLogs(options: IndexerGetLogsOptions): Promise<any[]>;
+export declare function getTokenTransfers({ chain, fromAddressFilter, fromBlock, toBlock, all, limit, offset, target, targets, flatten, fromTimestamp, toTimestamp, debugMode, transferType, token, tokens, }: IndexerGetTokenTransfersOptions): Promise<any[]>;
+export declare function getTransactions({ chain, addresses, transaction_hashes, from_block, to_block, all, limit, offset, debugMode, transactionType, }: GetTransactionOptions): Promise<any>;
 export declare function isIndexerEnabled(chain?: string): boolean;
 export declare function isIndexer2Enabled(chain?: string): boolean;
-export declare function getTokenTransfers({ chain, fromAddressFilter, fromBlock, toBlock, all, limit, offset, target, targets, flatten, fromTimestamp, toTimestamp, debugMode, transferType, token, tokens, }: IndexerGetTokenTransfersOptions): Promise<any[]>;
-export declare function getTransactions({ chain, addresses, transaction_hashes, from_block, to_block, all, limit, offset, debugMode, transactionType }: GetTransactionOptions): Promise<any>;
 export {};