impermax-sdk 2.1.511 → 2.1.513

package/lib/offchain/offchain.d.ts

@@ -3,7 +3,7 @@ import OffchainLendingPool from './lendingPool';
 import OffchainSolidexHelper from './offchainSolidexHelper';
 import OffchainAccount from './account';
 import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex, Networks, WhitelistState, Extension } from '../config/types';
-import { LendingPoolData, VaultData, VaultPosition, TvlData, UserData, XIbexData, NftlpData, PoolChart, NewlyEarnedFees, NftlpStats, XIbexUserData, NewlyEarnedReward } from './offchainTypes';
+import { LendingPoolData, VaultData, VaultPosition, TvlData, UserData, XIbexData, NftlpData, PoolChart, NewlyEarnedFees, NftlpStats, XIbexUserData, NewlyEarnedReward, NetworkTokenData } from './offchainTypes';
 import OffchainVault from './vault/offchainVault';
 import OffchainConfigManager from './configManager';
 import { PairState } from '../config/whitelist';
@@ -121,4 +121,5 @@ export default class Offchain {
     protected fetchNftlpsData: typeof initializer.fetchNftlpsData;
     protected initializeNftlpsData: typeof initializer.initializeNftlpsData;
     getPairsList(factory: Factory, state?: PairState): Address[];
+    getNetworkTokens(): Promise<NetworkTokenData[]>;
 }

package/lib/offchain/offchain.js

@@ -205,5 +205,67 @@ class Offchain {
             pairs.push(...blacklisted);
         return pairs.map(i => i.toLowerCase());
     }
+    async getNetworkTokens() {
+        const tokenMap = new Map();
+        try {
+            const lendingPoolsData = await this.getLendingPoolsData();
+            // 1. Go through each factory
+            const factoryPromises = Object.entries(lendingPoolsData).map(async ([factory, pools]) => {
+                // 2. Go through each pool in the factory
+                const poolPromises = Object.keys(pools).map(async (poolId) => {
+                    try {
+                        const lendingPool = await this.getLendingPool(factory, poolId);
+                        if (!lendingPool)
+                            return [];
+                        // 3. Get both borrowables borrowables from this pool
+                        const [borrowableA, borrowableB] = await Promise.all([lendingPool.getBorrowableA(), lendingPool.getBorrowableB()]);
+                        // 4. Get underlying tokens from both borrowables
+                        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: `${this.network}:${address}`,
+                                    id: address,
+                                    symbol,
+                                    name,
+                                    decimals,
+                                    chainId: this.chainId,
+                                };
+                            }
+                            catch (error) {
+                                console.error(`Error getting token details for borrowable in pool ${poolId}:`, error);
+                                return null;
+                            }
+                        });
+                        // The token's data like symbol etc.
+                        const tokens = await Promise.all(tokenPromises);
+                        return tokens.filter((token) => token !== null);
+                    }
+                    catch (error) {
+                        console.error(`Error processing pool ${poolId} in factory ${factory} on ${this.network}:`, error);
+                        return [];
+                    }
+                });
+                const poolResults = await Promise.all(poolPromises);
+                return poolResults.flat();
+            });
+            const factoryResults = await Promise.all(factoryPromises);
+            const networkTokens = factoryResults.flat();
+            // Need to put then in a set to return unique tokens
+            networkTokens.forEach(tokenData => tokenMap.set(tokenData.token, tokenData));
+            return Array.from(tokenMap.values());
+        }
+        catch (error) {
+            console.error(`Error processing network ${this.network}:`, error);
+            return [];
+        }
+    }
 }
 exports.default = Offchain;

package/lib/offchain/offchainMultichain.d.ts

@@ -14,7 +14,7 @@ import { AddressIndex } from "../config/types";
 import OffchainAccount from "./account/offchainAccount";
 import { PairState } from '../config/whitelist';
 import { LlamaTvlChart } from './offchainAPRHelper';
-import { Token } from "./offchainPriceHelper";
+import { NetworkTokenData } from "./offchainTypes";
 export declare enum SortDirection {
     ASC = "asc",
     DESC = "desc"
@@ -105,6 +105,6 @@ export default class OffchainMultichain {
      */
     getTvlData(params?: MultichainTvlParams): Promise<MultichainTvlData>;
     getImpermaxTvlChart(network?: Networks): Promise<LlamaTvlChart>;
-    getNetworkTokens(networks?: Networks[]): Promise<Token[]>;
+    getNetworkTokens(networks?: Networks[]): Promise<NetworkTokenData[]>;
 }
 export {};

package/lib/offchain/offchainMultichain.js

@@ -296,21 +296,19 @@ class OffchainMultichain {
     // ERC20 TOKENS
     //
     async getNetworkTokens(networks) {
-        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);
+        const allNetworks = networks || Object.values(types_1.Networks);
+        const networkPromises = allNetworks.map(async (network) => {
+            try {
+                const offchain = this.getOffchain(network);
+                return await offchain.getNetworkTokens();
+            }
+            catch (error) {
+                console.error(`Error processing network ${network}:`, error);
+                return [];
+            }
+        });
+        const results = await Promise.all(networkPromises);
+        return results.flat();
     }
 }
 exports.default = OffchainMultichain;

package/lib/offchain/offchainTypes.d.ts

@@ -1,4 +1,4 @@
-import { Address, AddressIndex, PoolTokenType, ProposalState, WhitelistState, VaultType, Extension, Factory, Borrowable } from '../config/types';
+import { Address, AddressIndex, PoolTokenType, ProposalState, WhitelistState, VaultType, Extension, Factory, Borrowable, Networks } from '../config/types';
 import { Amms } from '../config/amms';
 export declare const isV3Factory: (factory: string) => boolean;
 export interface TokenData {
@@ -14,6 +14,14 @@ export interface PoolTokenData {
     exchangeRate: string;
     totalBalanceUSD: string;
 }
+export type NetworkTokenData = {
+    token: `${Networks}:${Address}`;
+    id: Address;
+    symbol: string;
+    name: string;
+    decimals: number;
+    chainId: number;
+};
 export interface BorrowableData extends PoolTokenData {
     underlying: TokenData;
     totalBorrows: string;

package/lib/offchain/queries/apis/ponder/index.js

@@ -50,7 +50,6 @@ class PonderQueryBuilder {
       borrowIndex
       accrualTimestamp 
       exchangeRate 
-      borrowTracker
       debtCeiling
     }`;
         const collateralStr = `{

package/package.json

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