impermax-sdk 2.1.413 → 2.1.415

package/lib/offchain/offchain.js

@@ -148,8 +148,6 @@ class Offchain {
         this.whitelistData = null;
         this.solidexHelper.cleanCache();
         this.configManager.cleanCache();
-        this.getPriceHelper().cleanCache();
-        this.getAPRHelper().cleanCache();
         this.borrowersList = null;
         this.userNewlyEarnedFeesData = {};
         this.xibexUsersData = {};

package/lib/offchain/offchainMultichain.d.ts

@@ -14,14 +14,7 @@ import { AddressIndex } from "../config/types";
 import OffchainAccount from "./account/offchainAccount";
 import { PairState } from '../config/whitelist';
 import { LlamaTvlChart } from './offchainAPRHelper';
-type TokenData = {
-    token: `${Networks}:${Address}`;
-    id: Address;
-    symbol: string;
-    name: string;
-    decimals: number;
-    chainId: number;
-};
+import { Token } from "./offchainPriceHelper";
 export declare enum SortDirection {
     ASC = "asc",
     DESC = "desc"
@@ -93,6 +86,5 @@ export default class OffchainMultichain {
         totalCollateralUSD: number;
     }>;
     getImpermaxTvlChart(network?: Networks): Promise<LlamaTvlChart>;
-    getNetworkTokens(networks?: Networks[]): Promise<TokenData[]>;
+    getNetworkTokens(networks?: Networks[]): Promise<Token[]>;
 }
-export {};

package/lib/offchain/offchainMultichain.js

@@ -256,71 +256,21 @@ class OffchainMultichain {
         return impermaxTvlChart;
     }
     async getNetworkTokens(networks) {
-        const allNetworks = networks || Object.values(types_1.Networks);
-        const tokenMap = new Map();
-        const networkPromises = allNetworks.map(async (network) => {
-            try {
-                const offchain = this.getOffchain(network);
-                const lendingPoolsData = await offchain.getLendingPoolsData();
-                const chainId = offchain.chainId;
-                // Go through each factory
-                const factoryPromises = Object.entries(lendingPoolsData).map(async ([factory, pools]) => {
-                    // Go through each pool in the factory
-                    const poolPromises = Object.keys(pools).map(async (poolId) => {
-                        try {
-                            const lendingPool = await offchain.getLendingPool(factory, poolId);
-                            if (!lendingPool)
-                                return [];
-                            // Get borrowables
-                            const [borrowableA, borrowableB] = await Promise.all([lendingPool.getBorrowableA(), lendingPool.getBorrowableB()]);
-                            // Get underlyings
-                            const tokenPromises = [borrowableA, borrowableB].map(async (borrowable) => {
-                                try {
-                                    const [address, symbol, name, decimals] = await Promise.all([
-                                        borrowable.getUnderlyingAddress(),
-                                        borrowable.getSymbol(),
-                                        borrowable.getName(),
-                                        borrowable.getDecimals(),
-                                    ]);
-                                    if (!address)
-                                        return null;
-                                    return {
-                                        token: `${network}:${address}`,
-                                        id: address,
-                                        symbol,
-                                        name,
-                                        decimals,
-                                        chainId,
-                                    };
-                                }
-                                catch (error) {
-                                    console.error(`Error getting token details for borrowable in pool ${poolId}:`, error);
-                                    return null;
-                                }
-                            });
-                            const tokens = await Promise.all(tokenPromises);
-                            return tokens.filter((token) => token !== null);
-                        }
-                        catch (error) {
-                            console.error(`Error processing pool ${poolId} in factory ${factory} on ${network}:`, error);
-                            return [];
-                        }
-                    });
-                    const poolResults = await Promise.all(poolPromises);
-                    return poolResults.flat();
-                });
-                const factoryResults = await Promise.all(factoryPromises);
-                const networkTokens = factoryResults.flat();
-                networkTokens.forEach(tokenData => tokenMap.set(tokenData.token, tokenData));
-                return networkTokens;
-            }
-            catch (error) {
-                console.error(`Error processing network ${network}:`, error);
-                return [];
-            }
-        });
-        await Promise.all(networkPromises);
-        return Array.from(tokenMap.values());
+        const lendingPools = await this.getLendingPoolList({ networks });
+        const tokenSet = new Set();
+        await Promise.all(lendingPools.map(async (pool) => {
+            const network = pool.getOffchain().network;
+            const [borrowableA, borrowableB] = await Promise.all([
+                pool.getBorrowableA(),
+                pool.getBorrowableB()
+            ]);
+            const addresses = await Promise.all([
+                borrowableA.getUnderlyingAddress(),
+                borrowableB.getUnderlyingAddress()
+            ]);
+            addresses.forEach(addr => tokenSet.add(`${network}:${addr}`));
+        }));
+        return Array.from(tokenSet);
     }
 }
 exports.default = OffchainMultichain;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impermax-sdk",
-  "version": "2.1.413",
+  "version": "2.1.415",
   "description": "",
   "main": "./lib/index.js",
   "module": "./lib/index.js",