impermax-sdk 2.1.512 → 2.1.514

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/onchain/onchain.d.ts

@@ -8,7 +8,7 @@ import OnchainInteractions from './interactions';
 import { OnchainConfig } from './onchainTypes';
 import OnchainConfigManager from './configManager';
 import OnchainPermitHelper from "./onchainPermitHelper";
-import Multicall from '@dopex-io/web3-multicall';
+import OnchainMulticall from './onchainMulticall';
 import OnchainStakingModule from './staking/onchainStakingModule';
 export default class Onchain {
     readonly network: Networks;
@@ -26,7 +26,7 @@ export default class Onchain {
     protected lendingVaults: AddressIndex<OnchainLendingVault>;
     protected accounts: AddressIndex<OnchainAccount>;
     protected interactions: AddressIndex<OnchainInteractions>;
-    multicall: Multicall;
+    multicall: OnchainMulticall;
     protected stakingModule: OnchainStakingModule;
     constructor(cfg: OnchainConfig);
     cleanCache(): void;

package/lib/onchain/onchain.js

@@ -12,6 +12,7 @@ const interactions_1 = __importDefault(require("./interactions"));
 const configManager_1 = __importDefault(require("./configManager"));
 const onchainPermitHelper_1 = __importDefault(require("./onchainPermitHelper"));
 const web3_multicall_1 = __importDefault(require("@dopex-io/web3-multicall"));
+const onchainMulticall_1 = __importDefault(require("./onchainMulticall"));
 const onchainStakingModule_1 = __importDefault(require("./staking/onchainStakingModule"));
 class Onchain {
     constructor(cfg) {
@@ -34,11 +35,13 @@ class Onchain {
         this.accounts = {};
         this.lendingVaults = {};
         this.interactions = {};
-        this.multicall = new web3_multicall_1.default({
+        const multicall = new web3_multicall_1.default({
             chainId: cfg.chainId,
             provider: cfg.web3,
             multicallAddress: "0xcA11bde05977b3631167028862bE2a173976CA11"
         });
+        // Using default settings, See OnchainMulticall constructor
+        this.multicall = new onchainMulticall_1.default(multicall);
     }
     cleanCache() {
         for (const factory in this.factories) {

package/lib/onchain/onchainMulticall.d.ts

@@ -0,0 +1,37 @@
+import Multicall from '@dopex-io/web3-multicall';
+interface MulticallConfig {
+    /** Max amount of transactions per multicall call */
+    batchSize: number;
+    /** Time in ms to wait before sending (0 still gets all from current event loop which is probably enough on most cases) */
+    timeWindow: number;
+}
+/**
+ * Similar to https://github.com/greg-schrammel/multicall-provider but for web3.js
+ *
+ * Example usage:
+ *
+ * const underlyingAddress = await this.getOnchain().multicall.call(poolToken.methods.underlying());
+ *
+ * Do not use call() when passing method! ie:
+ *  wrong: onchain.multicall.call(poolToken.methods.underlying().call()):
+ *  right: onchain.multicall.call(poolToken.methods.underlying())
+ *
+ * How it works:
+ * 1. onchainLendingVault: `onchain.multicall.call(methods.exchangeRate())` - adds to queue, timeoutId is null, sets timer to `timeWindow`
+ * 2. onchainPoolToken   : `onchain.multicall.call(methods.totalSupply())`  - adds to queue, clears old timer, sets new timer to `timeWindow`
+ * 3. onchainBorrowable  : `onchain.multicall.call(methods.underlying())`   - adds to queue, clears old timer, sets new timer to `timeWindow`
+ * ...
+ * 4. Process all when either `timeWindow` expires OR `batchSize` is reached
+ */
+export default class OnchainMulticall {
+    private multicall;
+    private config;
+    private queue;
+    private timeoutId;
+    private isProcessing;
+    constructor(multicall: Multicall, config?: MulticallConfig);
+    getEthBalance(address: string): any;
+    call<T = any>(contractMethod: any): Promise<T>;
+    private processBatch;
+}
+export {};

package/lib/onchain/onchainMulticall.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Similar to https://github.com/greg-schrammel/multicall-provider but for web3.js
+ *
+ * Example usage:
+ *
+ * const underlyingAddress = await this.getOnchain().multicall.call(poolToken.methods.underlying());
+ *
+ * Do not use call() when passing method! ie:
+ *  wrong: onchain.multicall.call(poolToken.methods.underlying().call()):
+ *  right: onchain.multicall.call(poolToken.methods.underlying())
+ *
+ * How it works:
+ * 1. onchainLendingVault: `onchain.multicall.call(methods.exchangeRate())` - adds to queue, timeoutId is null, sets timer to `timeWindow`
+ * 2. onchainPoolToken   : `onchain.multicall.call(methods.totalSupply())`  - adds to queue, clears old timer, sets new timer to `timeWindow`
+ * 3. onchainBorrowable  : `onchain.multicall.call(methods.underlying())`   - adds to queue, clears old timer, sets new timer to `timeWindow`
+ * ...
+ * 4. Process all when either `timeWindow` expires OR `batchSize` is reached
+ */
+class OnchainMulticall {
+    constructor(multicall, config = { batchSize: 25, timeWindow: 0 }) {
+        this.queue = [];
+        this.timeoutId = null;
+        this.isProcessing = false;
+        this.multicall = multicall;
+        this.config = config;
+    }
+    getEthBalance(address) {
+        return this.multicall.getEthBalance(address);
+    }
+    async call(contractMethod) {
+        return new Promise((resolve, reject) => {
+            const queuedCall = { contractMethod, resolve, reject };
+            this.queue.push(queuedCall);
+            if (this.timeoutId)
+                clearTimeout(this.timeoutId);
+            this.timeoutId = setTimeout(() => this.processBatch(), this.config.timeWindow);
+            if (this.queue.length >= this.config.batchSize) {
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                // Process all in next event loop
+                if (!this.isProcessing)
+                    setTimeout(() => this.processBatch(), 0);
+            }
+        });
+    }
+    // TODO: Test fallback in case of multicall failure
+    async processBatch() {
+        if (this.isProcessing || this.queue.length === 0)
+            return;
+        this.isProcessing = true;
+        this.timeoutId = null;
+        const batch = this.queue.splice(0, Math.min(this.config.batchSize, this.queue.length));
+        try {
+            const contractMethods = batch.map(call => call.contractMethod);
+            // console.log("Multicall methods: ", contractMethods)
+            const results = await this.multicall.aggregate(contractMethods);
+            for (let i = 0; i < batch.length; i++) {
+                const call = batch[i];
+                const result = results[i];
+                call.resolve(result);
+            }
+        }
+        catch (error) {
+            console.log('Multicall failed, using fallback call: ', error);
+            for (const call of batch) {
+                try {
+                    const result = await call.contractMethod.call();
+                    call.resolve(result);
+                }
+                catch (singleCallError) {
+                    call.reject(new Error(`Individual call failed: ${singleCallError.message}`));
+                }
+            }
+        }
+        this.isProcessing = false;
+        // Execute again until queue is empty
+        if (this.queue.length > 0)
+            setTimeout(() => this.processBatch(), 0);
+    }
+}
+exports.default = OnchainMulticall;

package/package.json

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