impermax-sdk 2.1.558 → 2.1.560

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

@@ -3,4 +3,6 @@ import { RawUserData, UserData } from "../../../offchainTypes";
 import Offchain from "../../../offchain";
 export declare function getUserData(this: Offchain, account: Address): Promise<FactoryIndex<UserData> | null>;
 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>>;
+export declare function fetchAllUsersData(this: Offchain): Promise<Record<Address, FactoryIndex<RawUserData>>>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchUserData = exports.initializeUserData = exports.getUserData = void 0;
+exports.fetchAllUsersData = exports.fetchUserData = exports.initializeAllUsersData = exports.initializeUserData = exports.getUserData = void 0;
 const subgraphs_1 = require("../../../../config/subgraphs");
 const types_1 = require("../../../../config/types");
 const offchainTypes_1 = require("../../../offchainTypes");
@@ -22,6 +22,7 @@ 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);
@@ -72,10 +73,55 @@ async function initializeUserData(account) {
     return result;
 }
 exports.initializeUserData = initializeUserData;
+// Initialize all users data
+// NOTE: Only v3 atm as we test
+async function initializeAllUsersData() {
+    const allUserData = await this.fetchAllUsersData();
+    const result = {};
+    for (const userAddress in allUserData) {
+        const userData = allUserData[userAddress];
+        result[userAddress] = {};
+        for (const factory in userData) {
+            if (!(0, offchainTypes_1.isV3Factory)(factory))
+                continue;
+            const userDataOfFactory = userData[factory];
+            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
+            for (const supplyPosition of userDataOfFactory.supplyPositions) {
+                const lendingPoolId = supplyPosition.borrowable.lendingPool.id;
+                const underlyingId = supplyPosition.borrowable.underlying.id;
+                const lendingPool = await this.getLendingPool(factory, lendingPoolId);
+                if (!lendingPool) {
+                    console.error("Can't resolve supplyPosition because lendingPool is null. Lending pool:", lendingPoolId, this.network);
+                    continue;
+                }
+                const borrowableA = lendingPool.getBorrowableA();
+                const addressA = await borrowableA.getUnderlyingAddress();
+                const poolTokenType = underlyingId === addressA
+                    ? types_1.PoolTokenType.BorrowableA
+                    : types_1.PoolTokenType.BorrowableB;
+                if (!(lendingPoolId in result[userAddress][factory].supplyPositions)) {
+                    result[userAddress][factory].supplyPositions[lendingPoolId] = {};
+                }
+                result[userAddress][factory].supplyPositions[lendingPoolId][poolTokenType] = supplyPosition;
+            }
+        }
+    }
+    return result;
+}
+exports.initializeAllUsersData = initializeAllUsersData;
 /*--------------------------------------------------------------------------*
  *                               Fetchers                                   *
  *--------------------------------------------------------------------------*/
-// User Data
+// Fetch single user data
 async function fetchUserData(account) {
     const positions = {};
     for (const factory in subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network]) {
@@ -95,3 +141,31 @@ async function fetchUserData(account) {
     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]) {
+        if (!(0, offchainTypes_1.isV3Factory)(factory))
+            continue;
+        const subgraphs = subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network][factory];
+        const result = await this.getEndpointManager().fetch(subgraphs, this.network, (queryBuilder) => queryBuilder.usersQuery(this.network, factory));
+        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])
+                allUserData[userAddress] = {};
+            allUserData[userAddress][factory] = {
+                positions: user.positions,
+                supplyPositions: user.supplyPositions,
+                collateralPositions: user.collateralPositions,
+                borrowPositions: user.borrowPositions, // Undefined if V3
+            };
+        }
+    }
+    return allUserData;
+}
+exports.fetchAllUsersData = fetchAllUsersData;

package/lib/offchain/lendingPool/offchainLendingPool.d.ts

@@ -69,6 +69,7 @@ export default abstract class OffchainLendingPool {
     isStableFactory(): boolean;
     private normalizeTokenSymbol;
     isStablePair(): Promise<boolean>;
+    showInverted(): Promise<boolean>;
     getLendingPoolVersion(): LendingPoolVersion;
     getTotalBorrowsUSD(): Promise<number>;
     private initializeLendingPoolAddresses;

package/lib/offchain/lendingPool/offchainLendingPool.js

@@ -179,6 +179,16 @@ class OffchainLendingPool {
         return (stables.includes(symbol0) && stables.includes(symbol1)) ||
             (symbol0.slice(-3) === symbol1.slice(-3));
     }
+    async showInverted() {
+        let [stables, token0, token1] = await Promise.all([
+            this.getOffchain().getAPRHelper().getAllStablecoins(),
+            this.getBorrowableA().getSymbol(),
+            this.getBorrowableB().getSymbol(),
+        ]);
+        const symbol0 = this.normalizeTokenSymbol(token0);
+        const symbol1 = this.normalizeTokenSymbol(token1);
+        return stables.includes(symbol0) && !stables.includes(symbol1);
+    }
     // Versions Specfics
     getLendingPoolVersion() {
         const factoryType = Number(this.factory);

package/lib/offchain/offchain.d.ts

@@ -105,6 +105,8 @@ export default class Offchain {
     protected fetchUserData: typeof initializer.fetchUserData;
     protected initializeUserData: typeof initializer.initializeUserData;
     getUserData: typeof initializer.getUserData;
+    fetchAllUsersData: typeof initializer.fetchAllUsersData;
+    initializeAllUsersData: typeof initializer.initializeAllUsersData;
     protected initializeXIbexData: typeof initializer.initializeXIbexData;
     getXIbexData: typeof initializer.getXIbexData;
     getXIbexUserData: typeof initializer.getXIbexUserData;

package/lib/offchain/offchain.js

@@ -86,6 +86,8 @@ class Offchain {
         this.fetchUserData = initializer.fetchUserData;
         this.initializeUserData = initializer.initializeUserData;
         this.getUserData = initializer.getUserData;
+        this.fetchAllUsersData = initializer.fetchAllUsersData;
+        this.initializeAllUsersData = initializer.initializeAllUsersData;
         this.initializeXIbexData = initializer.initializeXIbexData;
         this.getXIbexData = initializer.getXIbexData;
         this.getXIbexUserData = initializer.getXIbexUserData;

package/lib/offchain/offchainMultichain.d.ts

@@ -94,6 +94,10 @@ export default class OffchainMultichain {
     private filterVersion;
     getMultichainAccount(accountAddress: Address): OffchainMultichainAccount;
     getMultichainBorrowersList(params?: BorrowersListParams): Promise<OffchainAccount[]>;
+    /**
+      * TODO:  Get all borrowers positions across networks.
+     */
+    getAllBorrowerPositions(params?: BorrowersListParams): Promise<any>;
     getActiveAmms(params?: LendingPoolListParams): Promise<Amms[]>;
     /** Gets TVL from defillama */
     getDefillamaTvlData(params?: MultichainTvlParams): Promise<MultichainTvlData>;

package/lib/offchain/offchainMultichain.js

@@ -189,6 +189,18 @@ class OffchainMultichain {
         const allBorrowers = await Promise.all(networkPromises);
         return [...new Set(allBorrowers.flat())];
     }
+    /**
+      * TODO:  Get all borrowers positions across networks.
+     */
+    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 offchain = this.getOffchain(network);
+            // TODO: Get all users data and return position objects
+            //const allUsersData = await offchain.initializeAllUsersData();
+        });
+    }
     /*--------------------------------------------------------*
      *                 Whitelisted AMMs list
      *--------------------------------------------------------*/

package/lib/offchain/queries/apis/ponder/index.d.ts

@@ -6,8 +6,10 @@ export declare class PonderQueryBuilder implements IQueryBuilder {
     getBlockNumber(response: any, network: Networks): number;
     lendingPoolsV3Query(factory: Factory, addressesFilter: Address[], network: Networks): DocumentNode;
     userQueryV3(account: Address, network: Networks, factory: Factory): DocumentNode;
+    usersQueryV3(network: Networks, factory: Factory): DocumentNode;
     lendingPoolsQuery(factory: Factory, addressesFilter: Address[], network: Networks): DocumentNode;
     userQuery(account: Address, network: Networks, factory: Factory): DocumentNode;
+    usersQuery(network: Networks, factory: Factory): DocumentNode;
     tvlQuery(): DocumentNode;
     vaultsQuery(vaultType: VaultType, addressesFilter: Address[]): DocumentNode;
     vaultsUserQuery(account: Address): DocumentNode;

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

@@ -89,19 +89,19 @@ class PonderQueryBuilder {
       user(id: "${account.toLowerCase()}") {
         id
         positions(limit: 1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}" }) {
-          items { 
+          items {
             id
             tokenId
             lendingPool {
               id
-              nftlp { 
+              nftlp {
                 factory
               }
             }
             borrowPositions {
               items {
                 borrowBalance
-                borrowIndex 
+                borrowIndex
                 cumulativeBorrows
                 borrowable {
                   id
@@ -135,6 +135,60 @@ 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"}) {
+        items {
+          id
+          positions(limit: 1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}" }) {
+            items {
+              id
+              tokenId
+              lendingPool {
+                id
+                nftlp {
+                  factory
+                }
+              }
+              borrowPositions {
+                items {
+                  borrowBalance
+                  borrowIndex
+                  cumulativeBorrows
+                  borrowable {
+                    id
+                    underlying {
+                      id
+                    }
+                  }
+                }
+              }
+            }
+          }
+          supplyPositions(where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}" }) {
+            items {
+              balance
+              cumulativeEarnings
+              lastExchangeRate
+              borrowable {
+                id
+                underlying {
+                  id
+                }
+                lendingPool {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+      _meta {
+        status
+      }
+    }`;
+    }
     /*-----------------------------*
      *   2. Lending pools
      *-----------------------------*/
@@ -237,7 +291,7 @@ class PonderQueryBuilder {
         return (0, graphql_tag_1.default) `{
       user(id: "${account.toLowerCase()}") {
         collateralPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", balance_not: "0"}) {
-          items { 
+          items {
             balance
             collateral {
               lendingPool {
@@ -247,7 +301,7 @@ class PonderQueryBuilder {
           }
         }
         supplyPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", balance_not: "0"}) {
-          items { 
+          items {
             balance
             cumulativeEarnings
             lastExchangeRate
@@ -262,7 +316,7 @@ class PonderQueryBuilder {
           }
         }
         borrowPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", borrowBalance_not: "0"}) {
-          items { 
+          items {
             borrowBalance
             borrowIndex
             borrowable {
@@ -281,6 +335,60 @@ class PonderQueryBuilder {
       }
     }`;
     }
+    // Get all users V2 positions from network factory, no address filter
+    usersQuery(network, factory) {
+        if (factory === types_1.Factory.V3)
+            return this.usersQueryV3(network, factory);
+        return (0, graphql_tag_1.default) `{
+      users(limit: 1000, where: {id_not: "0x0000000000000000000000000000000000000000"}) {
+        items {
+          id
+          collateralPositions(limit:1000, where: { factoryId: "${impermax_factories_1.IMPERMAX_FACTORY[network][factory]}", balance_not: "0"}) {
+            items {
+              balance
+              collateral {
+                lendingPool {
+                  id
+                }
+              }
+            }
+          }
+          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
+              borrowIndex
+              borrowable {
+                underlying {
+                  id
+                }
+                lendingPool {
+                  id
+                }
+              }
+            }
+          }
+        }
+      }
+      _meta {
+        status
+      }
+    }`;
+    }
     tvlQuery() {
         return (0, graphql_tag_1.default) `
       {
@@ -554,6 +662,7 @@ class PonderQueryBuilder {
     /*-----------------------------*
      *   List of Borrowers V2 & V3
      *-----------------------------*/
+    // NOTE: THese are deprecated and should not be used, instead use `usersQuery` and `usersQueryV3`
     borrowersListQuery(factory) {
         if (factory === types_1.Factory.V3)
             return this.borrowersListQueryV3();

package/lib/offchain/queries/apis/thegraph/index.d.ts

@@ -5,8 +5,10 @@ export declare class TheGraphQueryBuilder implements IQueryBuilder {
     getBlockNumber(response: any, network: Networks): number;
     lendingPoolsV3Query(factory: Factory, addressesFilter: Address[]): import("graphql").DocumentNode;
     userQueryV3(account: Address, network: Networks, factory: Factory): import("graphql").DocumentNode;
+    usersQueryV3(network: Networks, factory: Factory): import("graphql").DocumentNode;
     lendingPoolsQuery(factory: Factory, addressesFilter: Address[]): import("graphql").DocumentNode;
     userQuery(account: Address, network: Networks, factory: Factory): import("graphql").DocumentNode;
+    usersQuery(network: Networks, factory: Factory): import("graphql").DocumentNode;
     tvlQuery(): import("graphql").DocumentNode;
     nftlpsQuery(extension: Extension, network: Networks): import("graphql").DocumentNode;
     nftlpPositionQuery(extension: Extension, positionIds: string[]): import("graphql").DocumentNode;

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

@@ -7,8 +7,6 @@ exports.TheGraphQueryBuilder = void 0;
 const graphql_tag_1 = __importDefault(require("graphql-tag"));
 const types_1 = require("../../../../config/types");
 const factories_1 = require("../../../../config/factories");
-// TODO: Might need to separate Vaults query based on vault type, maybe not.
-// TODO: nftlpAeroCLPositions subgraph, nftlpAeroCLPositionsQuery not used atm
 class TheGraphQueryBuilder {
     /*-----------------------------*
      *   1. API Health
@@ -95,13 +93,65 @@ class TheGraphQueryBuilder {
           tokenId
           lendingPool {
             id
-            nftlp { 
+            nftlp {
               factory
             }
           }
           borrowPositions(first: 1000) {
             borrowBalance
-            borrowIndex 
+            borrowIndex
+            cumulativeBorrows
+            borrowable {
+              id
+              underlying {
+                id
+              }
+            }
+          }
+        }
+        supplyPositions(first: 1000) {
+          balance
+          cumulativeEarnings
+          lastExchangeRate
+          borrowable {
+            id
+            underlying {
+              id
+            }
+            lendingPool {
+              id
+            }
+          }
+        }
+      }
+      _meta {
+        block {
+          number
+        }
+        hasIndexingErrors
+      }
+    }`;
+    }
+    // Get all users V3 positions from network factory, no address filter
+    usersQueryV3(network, factory) {
+        // Shh
+        network;
+        factory;
+        return (0, graphql_tag_1.default) `{
+      users(first: 1000, where: { borrowPositions_: { borrowBalance_gt: "0", id_not: "0x0000000000000000000000000000000000000000" } }) {
+        id
+        positions(first: 1000) {
+          id
+          tokenId
+          lendingPool {
+            id
+            nftlp {
+              factory
+            }
+          }
+          borrowPositions(first: 1000, where: {borrowBalance_gt: "0"}) {
+            borrowBalance
+            borrowIndex
             cumulativeBorrows
             borrowable {
               id
@@ -277,6 +327,58 @@ class TheGraphQueryBuilder {
       }
     }`;
     }
+    // Get all users V2 positions from network factory, no address filter
+    usersQuery(network, factory) {
+        if (factory === types_1.Factory.V3)
+            return this.usersQueryV3(network, factory);
+        // Shh
+        network;
+        factory;
+        return (0, graphql_tag_1.default) `{
+      users(first: 1000, where: { borrowPositions_: { borrowBalance_gt: "0", id_not: "0x0000000000000000000000000000000000000000" } }) {
+        id
+        collateralPositions(first: 1000, where: { balance_gt: "0" }) {
+          balance
+          collateral {
+            lendingPool {
+              id
+            }
+          }
+        }
+        supplyPositions(first:1000, where: { balance_gt: "0" }) {
+          balance
+          lastExchangeRate
+          cumulativeEarnings
+          borrowable {
+            underlying {
+              id
+            }
+            lendingPool {
+              id
+            }
+          }
+        }
+        borrowPositions(first:1000, where: { borrowBalance_gt: "0" }) {
+          borrowBalance
+          borrowIndex
+          borrowable {
+            underlying {
+              id
+            }
+            lendingPool {
+              id
+            }
+          }
+        }
+      }
+      _meta {
+        block {
+          number
+        }
+        hasIndexingErrors
+      }
+    }`;
+    }
     tvlQuery() {
         return (0, graphql_tag_1.default) `{
       impermaxFactories(first: 1) {
@@ -620,7 +722,7 @@ class TheGraphQueryBuilder {
     /*-----------------------------*
      *   List of Borrowers V2 & V3
      *-----------------------------*/
-    // TODO: thegraph borrowersListQueryV3
+    // NOTE: THese are deprecated and should not be used, instead use `usersQuery` and `usersQueryV3`
     borrowersListQuery(factory) {
         if (factory === types_1.Factory.V3)
             return this.borrowersListQueryV3();

package/lib/offchain/queries/interfaces/query-builder.d.ts

@@ -5,8 +5,10 @@ export interface IQueryBuilder {
     getBlockNumber: (response: any, network: Networks) => number;
     lendingPoolsV3Query(factory: Factory, addressesFilter: Address[], network: Networks): DocumentNode;
     userQueryV3(account: Address, network: Networks, factory: Factory): DocumentNode;
+    usersQueryV3(network: Networks, factory: Factory): DocumentNode;
     lendingPoolsQuery(factory: Factory, addressesFilter: Address[] | undefined, network: Networks): DocumentNode;
     userQuery(account: Address, network: Networks, factory: Factory): DocumentNode;
+    usersQuery(network: Networks, factory: Factory): DocumentNode;
     tvlQuery(): DocumentNode;
     nftlpsQuery(extension: Extension, network: Networks): DocumentNode;
     nftlpPositionQuery(extension: Extension, positionIds: string[]): DocumentNode;

package/package.json

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