impermax-sdk 2.1.566 → 2.1.568

package/lib/config/private-api.d.ts

@@ -1,6 +1,7 @@
 import { NetworkVaultTypeIndex, NetworkFactoryIndex, NetworkExtensionIndex } from "./types";
 /** Single endpoint for all factory subgraph token prices */
 export declare const PRICE_AGGREGATOR_API_URL = "https://price-aggregator-production.up.railway.app/api/tokens";
+/** Single endpoint to get NFTLP collateral TVL across all networks */
 /**
  * Private API Endpoints which we might need to use in future for non-core
  * things (ie. charts, leaderboards, etc.). The app must function well

package/lib/config/private-api.js

@@ -5,6 +5,8 @@ exports.POSITIONS_AGGREGATOR_API_URL = exports.NFTLP_API = exports.IMPERMAX_VAUL
 const types_1 = require("./types");
 /** Single endpoint for all factory subgraph token prices */
 exports.PRICE_AGGREGATOR_API_URL = "https://price-aggregator-production.up.railway.app/api/tokens";
+/** Single endpoint to get NFTLP collateral TVL across all networks */
+//export const POSITIONS_AGGREGATOR_API_URL = "https://positions-aggregator-production.up.railway.app/api/";
 /**
  * Private API Endpoints which we might need to use in future for non-core
  * things (ie. charts, leaderboards, etc.). The app must function well

package/lib/offchain/initializer/user/userLendingPool/index.d.ts

@@ -2,6 +2,7 @@ import { Address, FactoryIndex } from "../../../../config/types";
 import { RawUserData, UserData } from "../../../offchainTypes";
 import Offchain from "../../../offchain";
 export declare function getUserData(this: Offchain, account: Address): Promise<FactoryIndex<UserData> | null>;
+export declare function getAllUsersData(this: Offchain): Promise<Record<Address, FactoryIndex<UserData>>>;
 export declare function initializeUserData(this: Offchain, account: Address): Promise<FactoryIndex<UserData> | null>;
 export declare function initializeAllUsersData(this: Offchain): Promise<Record<Address, FactoryIndex<UserData>>>;
 export declare function fetchUserData(this: Offchain, account: Address): Promise<FactoryIndex<RawUserData>>;

package/lib/offchain/initializer/user/userLendingPool/index.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchAllUsersData = exports.fetchUserData = exports.initializeAllUsersData = exports.initializeUserData = exports.getUserData = void 0;
+exports.fetchAllUsersData = exports.fetchUserData = exports.initializeAllUsersData = exports.initializeUserData = exports.getAllUsersData = exports.getUserData = void 0;
 const subgraphs_1 = require("../../../../config/subgraphs");
 const types_1 = require("../../../../config/types");
 const offchainTypes_1 = require("../../../offchainTypes");
 const positionsV2_1 = require("./positionsV2");
 const positionsV3_1 = require("./positionsV3");
+// Functions for getting single user data and all users data as they need slightly diff logic
 /*--------------------------------------------------------------------------*
  *                                Getters                                   *
  *--------------------------------------------------------------------------*/
@@ -15,6 +16,12 @@ async function getUserData(account) {
     return this.usersData[account];
 }
 exports.getUserData = getUserData;
+async function getAllUsersData() {
+    if (!this.allUsersData)
+        this.allUsersData = this.initializeAllUsersData();
+    return this.allUsersData;
+}
+exports.getAllUsersData = getAllUsersData;
 /*--------------------------------------------------------------------------*
  *                            Initializers                                  *
  *--------------------------------------------------------------------------*/
@@ -22,7 +29,6 @@ exports.getUserData = getUserData;
 // For collateralPositions/borrowPositions we separate into:
 //   - `initializeV2Positions` for V2
 //   - `initializeV3Positions` for V3
-// Initialize single user data
 async function initializeUserData(account) {
     const result = {};
     const userData = await this.fetchUserData(account);
@@ -38,17 +44,14 @@ async function initializeUserData(account) {
         };
         // Get collateral/borrow positions for V2/V3
         if ((0, offchainTypes_1.isV3Factory)(factory)) {
-            // TODO: V3 pair filter (nftlp)
             const v3Data = await (0, positionsV3_1.initializeV3Positions)(this, factory, userDataOfFactory);
             result[factory].positions = v3Data.positions;
         }
         else {
-            // Pass filtered pairs
             const v2Data = await (0, positionsV2_1.initializeV2Positions)(this, factory, userDataOfFactory, []);
             result[factory].collateralPositions = v2Data.collateralPositions;
             result[factory].borrowPositions = v2Data.borrowPositions;
         }
-        // Supply positions is same for v2 and v3
         for (const supplyPosition of userDataOfFactory.supplyPositions) {
             const lendingPoolId = supplyPosition.borrowable.lendingPool.id;
             // Don't include supply positions if lending pool is not in pair list
@@ -64,39 +67,66 @@ async function initializeUserData(account) {
             const poolTokenType = underlyingId === addressA
                 ? types_1.PoolTokenType.BorrowableA
                 : types_1.PoolTokenType.BorrowableB;
-            if (!(lendingPoolId in result[factory].supplyPositions)) {
+            if (!(lendingPoolId in result[factory].supplyPositions))
                 result[factory].supplyPositions[lendingPoolId] = {};
-            }
             result[factory].supplyPositions[lendingPoolId][poolTokenType] = supplyPosition;
         }
     }
     return result;
 }
 exports.initializeUserData = initializeUserData;
-// Initialize all users data
-// NOTE: Only v3 atm as we test
+// Similar to `initializeUserData`, but loop also through addresses instead of just factory
 async function initializeAllUsersData() {
-    const allUserData = await this.fetchAllUsersData();
+    const allUsersData = await this.fetchAllUsersData();
     const result = {};
-    for (const userAddress in allUserData) {
-        const userData = allUserData[userAddress];
+    const allV3UserData = {};
+    // Borrow positions
+    for (const userAddress in allUsersData) {
+        const userData = allUsersData[userAddress];
         result[userAddress] = {};
+        // 2. Loop through factory (atm only v3 as we test)
         for (const factory in userData) {
             if (!(0, offchainTypes_1.isV3Factory)(factory))
                 continue;
             const userDataOfFactory = userData[factory];
+            if (!userDataOfFactory.positions || userDataOfFactory.positions.length === 0)
+                continue;
             result[userAddress][factory] = {
                 positions: {},
                 collateralPositions: {},
                 supplyPositions: {},
                 borrowPositions: {},
             };
-            // Get V3 positions only
-            const v3Data = await (0, positionsV3_1.initializeV3Positions)(this, factory, userDataOfFactory);
-            result[userAddress][factory].positions = v3Data.positions;
-            // Supply positions is same for v2 and v3
+            allV3UserData[userAddress] = userDataOfFactory;
+        }
+    }
+    const positions = await (0, positionsV3_1.initializeV3PositionsAll)(this, allV3UserData);
+    for (const userAddress in positions) {
+        for (const factory in allUsersData[userAddress]) {
+            if (!(0, offchainTypes_1.isV3Factory)(factory))
+                continue;
+            result[userAddress][factory].positions = positions[userAddress];
+        }
+    }
+    // Supply positions
+    for (const userAddress in allUsersData) {
+        const userData = allUsersData[userAddress];
+        for (const factory in userData) {
+            if (!(0, offchainTypes_1.isV3Factory)(factory))
+                continue;
+            const userDataOfFactory = userData[factory];
+            if (!result[userAddress][factory]) {
+                result[userAddress][factory] = {
+                    positions: {},
+                    collateralPositions: {},
+                    supplyPositions: {},
+                    borrowPositions: {},
+                };
+            }
             for (const supplyPosition of userDataOfFactory.supplyPositions) {
                 const lendingPoolId = supplyPosition.borrowable.lendingPool.id;
+                // Don't include supply positions if lending pool is not in pair list
+                // if (pairs.length > 0 && !pairs.includes(lendingPoolId)) continue
                 const underlyingId = supplyPosition.borrowable.underlying.id;
                 const lendingPool = await this.getLendingPool(factory, lendingPoolId);
                 if (!lendingPool) {
@@ -108,25 +138,28 @@ async function initializeAllUsersData() {
                 const poolTokenType = underlyingId === addressA
                     ? types_1.PoolTokenType.BorrowableA
                     : types_1.PoolTokenType.BorrowableB;
-                if (!(lendingPoolId in result[userAddress][factory].supplyPositions)) {
+                if (!(lendingPoolId in result[userAddress][factory].supplyPositions))
                     result[userAddress][factory].supplyPositions[lendingPoolId] = {};
-                }
                 result[userAddress][factory].supplyPositions[lendingPoolId][poolTokenType] = supplyPosition;
             }
         }
     }
+    // Cache result into usersData so we don't make any more api calls when calling account methods
+    for (const userAddress in result) {
+        this.usersData[userAddress] = Promise.resolve(result[userAddress]);
+    }
     return result;
 }
 exports.initializeAllUsersData = initializeAllUsersData;
 /*--------------------------------------------------------------------------*
  *                               Fetchers                                   *
  *--------------------------------------------------------------------------*/
-// Fetch single user data
+// - fetchUserData  - Gets data for single user
+// - fetchUsersData - Gets data of all users (doesn't use address filter in the queries) 
 async function fetchUserData(account) {
     const positions = {};
     for (const factory in subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network]) {
         const subgraphs = subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network][factory];
-        // Decides for v3 query internally
         const result = await this.getEndpointManager().fetch(subgraphs, this.network, (queryBuilder) => queryBuilder.userQuery(account, this.network, factory));
         if (!result || !result.data?.user)
             continue;
@@ -135,14 +168,12 @@ async function fetchUserData(account) {
             positions: user.positions,
             supplyPositions: user.supplyPositions,
             collateralPositions: user.collateralPositions,
-            borrowPositions: user.borrowPositions, // Undefined if V3
+            borrowPositions: user.borrowPositions,
         };
     }
     return positions;
 }
 exports.fetchUserData = fetchUserData;
-// Fetch all users data
-// NOTE: Only v3 atm as we test
 async function fetchAllUsersData() {
     const allUserData = {};
     for (const factory in subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network]) {
@@ -153,7 +184,6 @@ async function fetchAllUsersData() {
         if (!result || !result.data?.users)
             continue;
         const users = result.data.users;
-        // Process each user and group by user address
         for (const user of users) {
             const userAddress = user.id;
             if (!allUserData[userAddress])
@@ -162,7 +192,7 @@ async function fetchAllUsersData() {
                 positions: user.positions,
                 supplyPositions: user.supplyPositions,
                 collateralPositions: user.collateralPositions,
-                borrowPositions: user.borrowPositions, // Undefined if V3
+                borrowPositions: user.borrowPositions,
             };
         }
     }

package/lib/offchain/initializer/user/userLendingPool/positionsV3.d.ts

@@ -1,4 +1,4 @@
-import { AddressIndex, Factory } from "../../../../config/types";
+import { Address, AddressIndex, Factory } from "../../../../config/types";
 import { NftlpPosition, RawV3UserData } from "../../../offchainTypes";
 import Offchain from "../../../offchain";
 /**
@@ -31,3 +31,7 @@ import Offchain from "../../../offchain";
 export declare function initializeV3Positions(offchain: Offchain, factory: Factory, rawUserData: RawV3UserData): Promise<{
     positions: AddressIndex<NftlpPosition[]>;
 }>;
+/**
+ * Same as initializeV3Positions but returns positions indexed by user address
+ */
+export declare function initializeV3PositionsAll(offchain: Offchain, allUserData: Record<Address, RawV3UserData>): Promise<Record<Address, AddressIndex<NftlpPosition[]>>>;

package/lib/offchain/initializer/user/userLendingPool/positionsV3.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeV3Positions = void 0;
+exports.initializeV3PositionsAll = exports.initializeV3Positions = void 0;
 const nftlp_1 = require("../../../../config/nftlp");
 /**
 * At this point we have all Collateral Positions (V3 NFTLP positions) of a user
@@ -78,3 +78,59 @@ async function initializeV3Positions(offchain, factory, rawUserData) {
     return { positions };
 }
 exports.initializeV3Positions = initializeV3Positions;
+/**
+ * Same as initializeV3Positions but returns positions indexed by user address
+ */
+async function initializeV3PositionsAll(offchain, allUserData) {
+    // userAddress -> lendingPoolId -> NftlpPosition[]
+    const result = {};
+    for (const userAddress in allUserData) {
+        result[userAddress] = {};
+    }
+    const dexPositions = {};
+    const positionMap = new Map();
+    // 1. Get all positions from all users and group by NFTLP factory
+    for (const userAddress in allUserData) {
+        const rawUserData = allUserData[userAddress];
+        for (const position of rawUserData.positions) {
+            const factoryId = position.lendingPool.nftlp.factory;
+            const lendingPoolId = position.lendingPool.id;
+            if (!result[userAddress][lendingPoolId])
+                result[userAddress][lendingPoolId] = [];
+            if (!dexPositions[factoryId])
+                dexPositions[factoryId] = [];
+            // Group position with its factory
+            dexPositions[factoryId].push(position.id);
+            // Cache position and user address
+            positionMap.set(position.id, { position, lendingPoolId, userAddress });
+        }
+    }
+    // 2. Get all unique NFTLP factories across all users
+    const nftlpFactories = Object.keys(dexPositions);
+    // 3. Get unique position data from dex subgraph
+    for (const nftlpFactory of nftlpFactories) {
+        const dex = (0, nftlp_1.getNftlpDex)(offchain.network, nftlpFactory);
+        if (dex === undefined) {
+            console.warn(`Unknown DEX for NFTLP factory ${nftlpFactory} on ${offchain.network}`);
+            continue;
+        }
+        const endpoints = (0, nftlp_1.getNftlpSubgraph)(offchain.network, dex);
+        if (!endpoints?.length) {
+            console.warn(`No NFTLP endpoints found for ${dex} on ${offchain.network}`);
+            continue;
+        }
+        const nftlpData = await offchain.getEndpointManager().fetch(endpoints, offchain.network, (queryBuilder) => queryBuilder.nftlpPositionQuery(dex, dexPositions[nftlpFactory]));
+        if (!nftlpData || !nftlpData.data?.nftlpPositions)
+            continue;
+        // 4. Now need to map the position to the user address
+        for (const nftlp of nftlpData.data.nftlpPositions) {
+            const positionInfo = positionMap.get(nftlp.id);
+            if (positionInfo) {
+                const { position, lendingPoolId, userAddress } = positionInfo;
+                result[userAddress][lendingPoolId].push({ ...position, dex, nftlp });
+            }
+        }
+    }
+    return result;
+}
+exports.initializeV3PositionsAll = initializeV3PositionsAll;

package/lib/offchain/offchain.d.ts

@@ -53,6 +53,7 @@ export default class Offchain {
     protected xibexUsersData: {
         [key in Address]?: Promise<XIbexUserData | null>;
     };
+    protected allUsersData: Promise<Record<Address, FactoryIndex<UserData>>> | null;
     protected extensionChartsData: {
         [key in Extension]?: Promise<AddressIndex<PoolChart[]>>;
     };
@@ -105,6 +106,7 @@ export default class Offchain {
     protected fetchUserData: typeof initializer.fetchUserData;
     protected initializeUserData: typeof initializer.initializeUserData;
     getUserData: typeof initializer.getUserData;
+    getAllUsersData: typeof initializer.getAllUsersData;
     fetchAllUsersData: typeof initializer.fetchAllUsersData;
     initializeAllUsersData: typeof initializer.initializeAllUsersData;
     protected initializeXIbexData: typeof initializer.initializeXIbexData;

package/lib/offchain/offchain.js

@@ -86,6 +86,7 @@ class Offchain {
         this.fetchUserData = initializer.fetchUserData;
         this.initializeUserData = initializer.initializeUserData;
         this.getUserData = initializer.getUserData;
+        this.getAllUsersData = initializer.getAllUsersData;
         this.fetchAllUsersData = initializer.fetchAllUsersData;
         this.initializeAllUsersData = initializer.initializeAllUsersData;
         this.initializeXIbexData = initializer.initializeXIbexData;
@@ -164,6 +165,7 @@ class Offchain {
         this.xibexUsersData = {};
         this.vaultsLinkToBorrowable = {};
         this.stakingModule?.cleanCache();
+        this.allUsersData = null;
         for (const address in this.accounts) {
             await this.accounts[address].cleanCache();
         }

package/lib/offchain/offchainMultichain.d.ts

@@ -15,6 +15,7 @@ import OffchainAccount from "./account/offchainAccount";
 import { PairState } from '../config/whitelist';
 import { LlamaTvlChart } from './offchainAPRHelper';
 import { NetworkTokenData } from "./offchainTypes";
+import { OffchainAccountLendingPool } from "./account";
 export declare enum SortDirection {
     ASC = "asc",
     DESC = "desc"
@@ -95,9 +96,13 @@ export default class OffchainMultichain {
     getMultichainAccount(accountAddress: Address): OffchainMultichainAccount;
     getMultichainBorrowersList(params?: BorrowersListParams): Promise<OffchainAccount[]>;
     /**
-      * TODO:  Get all borrowers positions across networks.
+     * Get all borrower positions for V3
      */
-    getAllBorrowerPositions(params?: BorrowersListParams): Promise<any>;
+    getAllBorrowerPositions(params?: BorrowersListParams): Promise<OffchainAccountLendingPool[][]>;
+    /**
+     * Get all lender (supply) positions for V3
+     */
+    getAllLenderPositions(params?: BorrowersListParams): Promise<OffchainAccountLendingPool[][]>;
     getActiveAmms(params?: LendingPoolListParams): Promise<Amms[]>;
     /** Gets TVL from defillama */
     getDefillamaTvlData(params?: MultichainTvlParams): Promise<MultichainTvlData>;

package/lib/offchain/offchainMultichain.js

@@ -190,16 +190,46 @@ class OffchainMultichain {
         return [...new Set(allBorrowers.flat())];
     }
     /**
-      * TODO:  Get all borrowers positions across networks.
+     * Get all borrower positions for V3
      */
     async getAllBorrowerPositions(params = {}) {
         const allNetworks = params.networks || Object.values(types_1.Networks);
-        // Fetch all users data for each network in parallel
         const networkPromises = allNetworks.map(async (network) => {
+            const networkPositions = [];
             const offchain = this.getOffchain(network);
-            // TODO: Get all users data and return position objects
-            //const allUsersData = await offchain.initializeAllUsersData();
+            const allUsersData = await offchain.getAllUsersData();
+            for (const user of Object.keys(allUsersData)) {
+                const account = this.getMultichainAccount(user);
+                const nftlpPositions = await account.getNftlpPositions({ networks: [network] });
+                if (nftlpPositions.length > 0) {
+                    networkPositions.push(nftlpPositions);
+                }
+            }
+            return networkPositions;
         });
+        const results = await Promise.all(networkPromises);
+        return results.flat();
+    }
+    /**
+     * Get all lender (supply) positions for V3
+     */
+    async getAllLenderPositions(params = {}) {
+        const allNetworks = params.networks || Object.values(types_1.Networks);
+        const networkPromises = allNetworks.map(async (network) => {
+            const networkPositions = [];
+            const offchain = this.getOffchain(network);
+            const allUsersData = await offchain.getAllUsersData();
+            for (const user of Object.keys(allUsersData)) {
+                const account = this.getMultichainAccount(user);
+                const supplyPositions = await account.getSupplyPositions({ networks: [network] });
+                if (supplyPositions.length > 0) {
+                    networkPositions.push(supplyPositions);
+                }
+            }
+            return networkPositions;
+        });
+        const results = await Promise.all(networkPromises);
+        return results.flat();
     }
     /*--------------------------------------------------------*
      *                 Whitelisted AMMs list

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

@@ -138,7 +138,7 @@ class PonderQueryBuilder {
     // Get all users V3 positions from network factory, no address filter
     usersQueryV3(network, factory) {
         return (0, graphql_tag_1.default) `{
-      users(limit: 1000, where: {id_not: "0x0000000000000000000000000000000000000000"}) {
+      users(limit: 1000, where: { id_not: "0x0000000000000000000000000000000000000000" }) {
         items {
           id
           positions(limit: 1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}" }) {
@@ -151,7 +151,7 @@ class PonderQueryBuilder {
                   factory
                 }
               }
-              borrowPositions {
+              borrowPositions(where: { borrowBalance_not: "0" }) {
                 items {
                   borrowBalance
                   borrowIndex
@@ -353,21 +353,6 @@ class PonderQueryBuilder {
               }
             }
           }
-          supplyPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", balance_not: "0"}) {
-            items {
-              balance
-              cumulativeEarnings
-              lastExchangeRate
-              borrowable {
-                underlying {
-                  id
-                }
-                lendingPool {
-                  id
-                }
-              }
-            }
-          }
           borrowPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", borrowBalance_not: "0"}) {
             items {
               borrowBalance

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

@@ -138,7 +138,7 @@ class TheGraphQueryBuilder {
         network;
         factory;
         return (0, graphql_tag_1.default) `{
-      users(first: 1000, where: { borrowPositions_: { borrowBalance_gt: "0", id_not: "0x0000000000000000000000000000000000000000" } }) {
+      users(first: 1000, where: { id_not: "0x0000000000000000000000000000000000000000" } ) {
         id
         positions(first: 1000) {
           id
@@ -345,19 +345,6 @@ class TheGraphQueryBuilder {
             }
           }
         }
-        supplyPositions(first:1000, where: { balance_gt: "0" }) {
-          balance
-          lastExchangeRate
-          cumulativeEarnings
-          borrowable {
-            underlying {
-              id
-            }
-            lendingPool {
-              id
-            }
-          }
-        }
         borrowPositions(first:1000, where: { borrowBalance_gt: "0" }) {
           borrowBalance
           borrowIndex

package/lib/onchain/onchain.d.ts

@@ -31,7 +31,7 @@ export default class Onchain {
     multicall: OnchainMulticall;
     protected stakingModule: OnchainStakingModule;
     constructor(cfg: OnchainConfig);
-    cleanCache(): void;
+    cleanCache(): Promise<void>;
     setPriceInverted(priceInverted: boolean): void;
     getOffchain: () => Offchain;
     getContractHelper: () => OnchainContractsHelper;

package/lib/onchain/onchain.js

@@ -46,7 +46,7 @@ class Onchain {
         // Using default settings, See OnchainMulticall constructor
         this.multicall = new onchainMulticall_1.default(multicall);
     }
-    cleanCache() {
+    async cleanCache() {
         for (const factory in this.factories) {
             this.factories[factory].cleanCache();
         }
@@ -54,10 +54,10 @@ class Onchain {
             this.lendingVaults[address].cleanCache();
         }
         for (const address in this.accounts) {
-            this.accounts[address].cleanCache();
+            await this.accounts[address].cleanCache();
         }
         for (const address in this.interactions) {
-            this.interactions[address].cleanCache();
+            await this.interactions[address].cleanCache();
         }
         this.stakingModule?.cleanCache();
     }

package/package.json

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