@defillama/sdk 5.0.142 → 5.0.144

package/build/util/LlamaProvider.js

@@ -183,8 +183,11 @@ exports.setProvider = setProvider;
 function getProvider(chain = "ethereum", _getArchivalNode = false) {
     var _a, _b;
     const rpcKey = chain === 'tron' ? 'tron_evm' : chain;
-    if (exports.providers[chain])
-        return exports.providers[chain];
+    let chainKey = chain;
+    if ((0, env_1.getEnvValue)('HISTORICAL'))
+        chainKey = chain + '_historical';
+    if (exports.providers[chainKey])
+        return exports.providers[chainKey];
     const pList = buildProviders !== null && buildProviders !== void 0 ? buildProviders : providers_json_1.default;
     // use RPC from env variable if set else use RPC from providers.json
     let rpcList = (0, env_1.getChainRPCs)(rpcKey, (_a = pList[chain]) === null || _a === void 0 ? void 0 : _a.rpc);
@@ -193,9 +196,9 @@ function getProvider(chain = "ethereum", _getArchivalNode = false) {
         // @ts-ignore (throwing error here would alter function behavior and have side effects)
         return null;
     }
-    if (!exports.providers[chain])
-        exports.providers[chain] = createProvider(chain, rpcList, (_b = providers_json_1.default[chain]) === null || _b === void 0 ? void 0 : _b.chainId, archivalRPCList);
-    return exports.providers[chain];
+    if (!exports.providers[chainKey])
+        exports.providers[chainKey] = createProvider(chain, rpcList, (_b = providers_json_1.default[chain]) === null || _b === void 0 ? void 0 : _b.chainId, archivalRPCList);
+    return exports.providers[chainKey];
 }
 exports.getProvider = getProvider;
 function toHex(n) {

package/build/util/blocks.js

@@ -65,7 +65,7 @@ async function getBlockNumber(chain, timestamp) {
     return (await getBlock(chain, timestamp)).block;
 }
 exports.getBlockNumber = getBlockNumber;
-const refreshInterval = 1000 * 60 * 1; // 5 minutes
+const refreshInterval = 1000 * 60 * 1; // 1 minute
 function getCurrentChainBlock(chain = 'ethereum') {
     const { timestamp, } = currentChainBlockCache[chain] || {};
     const currentTimestamp = Date.now();
@@ -131,7 +131,9 @@ const intialBlocks = {
     terra: 4724001,
     crab: 4969901
 };
-const blockTimeCache = (0, cache_1.getTempLocalCache)({ file: 'BlockCache.json', defaultData: {} });
+let lastBlockCacheSave = Date.now();
+const blockCacheSaveInterval = 1000 * 60 * 5; // 5 minutes 
+const { data: blockTimeCache, saveCacheFile: saveBlockCacheFile } = (0, cache_1.getTempLocalCache)({ file: 'BlockCache.json', defaultData: {}, clearAfter: cache_1.ONE_WEEK, returnWithSaveFunction: true });
 function validateCurrentBlock(block, chain = 'ethereum') {
     const provider = getExtraProvider(chain);
     const now = Math.floor(Date.now() / 1000);
@@ -158,6 +160,10 @@ async function _lookupBlock(timestamp, extraParams) {
     var _a, _b;
     const { allowedTimeRange = 5 * 60, acceptableBlockImprecision = 10 } = extraParams !== null && extraParams !== void 0 ? extraParams : {};
     const chain = (_a = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _a !== void 0 ? _a : "ethereum";
+    let time = Date.now();
+    if (timestamp > time / 1000) {
+        throw new Error(`Requesting for block in the future ${timestamp} is in the future, current time is ${Math.floor(time / 1000)}`);
+    }
     if (chain === 'waves') {
         const api = `https://nodes.wavesnodes.com/blocks/heightByTimestamp/${timestamp}`;
         const { data } = await (0, axios_1.default)(api);
@@ -177,29 +183,29 @@ async function _lookupBlock(timestamp, extraParams) {
         lowBlock = undefined;
     let block;
     let i = 0;
-    let time = Date.now();
     let blockImprecision;
     let imprecision;
     try {
         let firstBlock, lastBlock;
-        if (['evmos'].includes(chain)) {
+        if (['evmos', 'nibiru'].includes(chain)) {
             lastBlock = await (0, exports.getLatestBlock)(chain);
             let firstBlockNum = lastBlock.number;
             switch (chain) {
-                default: firstBlockNum -= 2 * 1e5; // evmos hold only the last 200k block data
+                case 'nibiru': firstBlockNum -= 4 * 1e5; // nibiru hold only the last 400k block data
+                case 'evmos': firstBlockNum -= 2 * 1e5; // evmos hold only the last 200k block data
             }
             firstBlock = await fetchBlockFromProvider(firstBlockNum, chain);
         }
         else {
             [lastBlock, firstBlock] = await Promise.all([
-                (0, exports.getLatestBlock)(chain),
+                highBlock ? highBlock : (0, exports.getLatestBlock)(chain),
                 lowBlock ? lowBlock : fetchBlockFromProvider(low, chain),
             ]);
         }
         lowBlock = firstBlock;
         if (!highBlock)
             highBlock = lastBlock;
-        if (Math.abs(highBlock.timestamp - timestamp) < 60 * 30) {
+        if (Math.abs(highBlock.timestamp - timestamp) < 60 * 5) {
             // Short-circuit in case we are trying to get the current block
             return {
                 block: highBlock.number,
@@ -208,7 +214,7 @@ async function _lookupBlock(timestamp, extraParams) {
             };
         }
         updateBlock();
-        while (imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision) { // We lose some precision (max ~15 minutes) but reduce #calls needed 
+        while (imprecision > allowedTimeRange && blockImprecision > acceptableBlockImprecision && i < 50) { // We lose some precision (max ~15 minutes) but reduce #calls needed 
             ++i;
             const blockDiff = highBlock.number - lowBlock.number;
             const timeDiff = highBlock.timestamp - lowBlock.timestamp;
@@ -244,8 +250,8 @@ async function _lookupBlock(timestamp, extraParams) {
         blocks.sort((a, b) => getPrecision(a) - getPrecision(b));
         block = blocks[0];
         // find the closest upper and lower bound between 4 points
-        lowBlock = blocks.filter(i => i.timestamp < timestamp).reduce((lowestBlock, block) => (timestamp - lowestBlock.timestamp) < (timestamp - block.timestamp) ? lowestBlock : block);
-        highBlock = blocks.filter(i => i.timestamp > timestamp).reduce((highestBlock, block) => (highestBlock.timestamp - timestamp) < (block.timestamp - timestamp) ? highestBlock : block);
+        lowBlock = blocks.filter(i => i.timestamp < timestamp).reduce((lowestBlock, block) => (timestamp - lowestBlock.timestamp) < (timestamp - block.timestamp) ? lowestBlock : block, lowBlock);
+        highBlock = blocks.filter(i => i.timestamp > timestamp).reduce((highestBlock, block) => (highestBlock.timestamp - timestamp) < (block.timestamp - timestamp) ? highestBlock : block, highBlock);
         imprecision = getPrecision(block);
         blockImprecision = highBlock.number - lowBlock.number;
         // debugLog(`chain: ${chain} block: ${block.number} #calls: ${i} imprecision: ${Number((imprecision)/60).toFixed(2)} (min) block diff: ${blockImprecision} Time Taken: ${Number((Date.now()-time)/1000).toFixed(2)} (in sec)`)
@@ -258,6 +264,11 @@ async function _lookupBlock(timestamp, extraParams) {
     function addBlockToCache(block) {
         const { number, timestamp } = block;
         getChainBlockTimeCache(chain)[block.number] = { number, timestamp, };
+        // save the block cache every 5 minutes
+        if (Date.now() - lastBlockCacheSave > blockCacheSaveInterval) {
+            lastBlockCacheSave = Date.now();
+            saveBlockCacheFile();
+        }
     }
     function getLowBlock() {
         return Object.values(getChainBlockTimeCache(chain))
@@ -276,4 +287,4 @@ async function getTimestamp(height, chain) {
     return block.timestamp;
 }
 exports.getTimestamp = getTimestamp;
-const currentChainBlockCache = (0, cache_1.getTempLocalCache)({ file: 'currentChainBlockCache.json', defaultData: {} });
+const currentChainBlockCache = {};

package/build/util/cache.d.ts

@@ -13,11 +13,16 @@ interface ReadCacheOptions {
 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 getTempLocalCache({ file, defaultData, clearAfter }: {
+export declare const ONE_WEEK: number;
+export declare function getTempLocalCache({ file, defaultData, clearAfter, returnWithSaveFunction }: {
     file: string;
     defaultData?: any;
     clearAfter?: number;
-}): any;
+    returnWithSaveFunction?: boolean;
+}): any | ({
+    data: any;
+    saveCacheFile: () => void;
+});
 export declare function deleteCache(file: string): Promise<void>;
 export declare function readExpiringJsonCache(file: string): Promise<any>;
 export declare function writeExpiringJsonCache(file: string, data: any, { expireAfter, // cache for 1 day by default

package/build/util/cache.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeExpiringJsonCache = exports.readExpiringJsonCache = exports.deleteCache = exports.getTempLocalCache = exports.compressCache = exports.parseCache = exports.writeCache = exports.readCache = exports.currentVersion = void 0;
+exports.writeExpiringJsonCache = exports.readExpiringJsonCache = exports.deleteCache = exports.getTempLocalCache = exports.ONE_WEEK = exports.compressCache = exports.parseCache = exports.writeCache = exports.readCache = exports.currentVersion = void 0;
 const debugLog_1 = require("./debugLog");
 const r2_1 = require("./r2");
 const zlib_1 = require("zlib");
@@ -122,14 +122,13 @@ exports.compressCache = compressCache;
 function isSameData(data1, data2) {
     return JSON.stringify(data1) === JSON.stringify(data2);
 }
-const ONE_WEEK = 1000 * 60 * 60 * 24 * 7;
-function getTempLocalCache({ file, defaultData = {}, clearAfter = ONE_WEEK }) {
-    let cache = defaultData;
+exports.ONE_WEEK = 1000 * 60 * 60 * 24 * 7;
+function getTempLocalCache({ file, defaultData = {}, clearAfter = exports.ONE_WEEK, returnWithSaveFunction = false }) {
     const now = Math.floor(Date.now() / 1e3);
     let emptyFile = { created: now, data: defaultData };
     let fileData = emptyFile;
     const filePath = getFilePath(file);
-    let saveCacheFlag = false;
+    let saveCacheFlag = false; // to ensure that we save only once on exit
     createSubPath(path.dirname(filePath)); // create folder if not exists, this is async but we don't care
     try {
         const data = _fs.readFileSync(filePath);
@@ -139,15 +138,28 @@ function getTempLocalCache({ file, defaultData = {}, clearAfter = ONE_WEEK }) {
     }
     catch (error) { }
     // save cache on exit
-    process.on('exit', saveCache);
-    process.on('SIGTERM', saveCache);
-    process.on('SIGINT', saveCache);
+    process.on('exit', _save);
+    process.on('SIGTERM', _save);
+    process.on('SIGINT', _save);
+    if (returnWithSaveFunction) {
+        return {
+            data: fileData.data,
+            saveCacheFile: () => saveCache(true)
+        };
+    }
     return fileData.data;
-    function saveCache() {
-        if (saveCacheFlag)
-            return;
-        saveCacheFlag = true;
+    function _save() {
+        saveCache();
+    }
+    function saveCache(skipCacheFlagCheck = false) {
+        if (!skipCacheFlagCheck) {
+            if (saveCacheFlag)
+                return;
+            saveCacheFlag = true;
+        }
         try {
+            if (!skipCacheFlagCheck)
+                (0, debugLog_1.debugLog)('Saving cache to file:', filePath);
             removePromisesAndFunctions(fileData);
             _fs.writeFileSync(filePath, JSON.stringify(fileData));
         }

package/build/util/elastic.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addErrorLog = exports.addRuntimeLog = exports.addDebugLog = exports.writeLog = exports.getClient = void 0;
 const elasticsearch_1 = require("@elastic/elasticsearch");
 const env_1 = require("./env");
+const debugLog_1 = require("./debugLog");
 let _client;
 function getClient() {
     if (_client)
@@ -41,7 +42,7 @@ async function writeLog(index, log) {
         await client.index({ index, body: log });
     }
     catch (error) {
-        console.error(error);
+        (0, debugLog_1.debugLog)((error === null || error === void 0 ? void 0 : error.message) || 'Error writing log to Elasticsearch');
     }
 }
 exports.writeLog = writeLog;

package/build/util/transactions.d.ts

@@ -5,7 +5,7 @@ export interface GetTransactionOptions {
     transaction_hashes?: string[];
     limit?: number | 'all';
     offset?: number;
-    chain: string;
+    chain?: string;
     all?: boolean;
     debugMode?: boolean;
     transactionType?: 'from' | 'to' | 'all';

package/build/util/updateProviderList.js

@@ -115,6 +115,7 @@ const chainShortNameMapping = {
     ontology: 'OntologyMainnet',
     occ: 'edu_chain',
     hyperliquid: 'hyper_evm',
+    nibiru: 'cataclysm_1',
     elsm: 'ely',
 };
 async function filterForWorkingRPCs(rpc, chain, chainId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defillama/sdk",
-  "version": "5.0.142",
+  "version": "5.0.144",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {