impermax-sdk 2.1.166 → 2.1.167

package/lib/offchain/account/offchainAccount.d.ts

@@ -20,7 +20,14 @@ export default class OffchainAccount {
     getBorrowPositions(): Promise<FactoryIndex<Address[]>>;
     getSupplyPositions(): Promise<FactoryIndex<Address[]>>;
     getVaultsSuppliedUSD(): Promise<number>;
+    getNftlpPositions(): Promise<FactoryIndex<Address[]>>;
     getVaultsEarningsUSD(): Promise<number>;
     getVaultsYearlyYieldUSD(): Promise<number>;
-    getNftlpPositions(): Promise<FactoryIndex<Address[]>>;
+    getVaultsDailyYieldUSD(): Promise<number>;
+    getSupplyEarningsUSD(): Promise<number>;
+    getSupplyYearlyYieldUSD(): Promise<number>;
+    getSupplyDailyYieldUSD(): Promise<number>;
+    getTotalEarningsUSD(): Promise<number>;
+    getTotalYearlyYieldUSD(): Promise<number>;
+    getTotalDailyYieldUSD(): Promise<number>;
 }

package/lib/offchain/account/offchainAccount.js

@@ -79,6 +79,29 @@ class OffchainAccount {
         }
         return suppliedUSD;
     }
+    async getNftlpPositions() {
+        const result = {};
+        const userData = await this.getUserData();
+        if (userData === null)
+            return result;
+        for (const factory in userData) {
+            // Check for V3 explicitely, not necesary since `positions` doesn't exist in v2
+            if (!(0, offchainTypes_1.isV3Factory)(factory))
+                continue;
+            result[factory] = [];
+            const collateralPositions = userData[factory].positions;
+            for (const lendingPool in collateralPositions) {
+                result[factory].push(lendingPool);
+            }
+        }
+        return result;
+    }
+    // -------------------------------
+    //          Earnings
+    // ------------------------------
+    //
+    // Vaults
+    //
     async getVaultsEarningsUSD() {
         let earningsUSD = 0;
         const vaultsUserData = await this.getVaultsUserData();
@@ -109,22 +132,83 @@ class OffchainAccount {
         }
         return yieldUSD;
     }
-    async getNftlpPositions() {
-        const result = {};
-        const userData = await this.getUserData();
-        if (userData === null)
-            return result;
-        for (const factory in userData) {
-            // Check for V3 explicitely, not necesary since `positions` doesn't exist in v2
-            if (!(0, offchainTypes_1.isV3Factory)(factory))
-                continue;
-            result[factory] = [];
-            const collateralPositions = userData[factory].positions;
-            for (const lendingPool in collateralPositions) {
-                result[factory].push(lendingPool);
+    async getVaultsDailyYieldUSD() {
+        const yearlyYield = await this.getSupplyYearlyYieldUSD();
+        return yearlyYield / 365;
+    }
+    //
+    // Borrowables
+    //
+    async getSupplyEarningsUSD() {
+        let earningsUSD = 0;
+        const positionsUserData = await this.getSupplyPositions();
+        if (!positionsUserData)
+            return 0;
+        // Get positions by factory
+        for (const factory in positionsUserData) {
+            const poolsOfFactory = positionsUserData[factory];
+            // Get pools of this factory
+            for (const poolAddress of poolsOfFactory) {
+                const pool = await this.getLendingPool(factory, poolAddress);
+                // Get earnings from both borrowables
+                const [earningsA, earningsB] = await Promise.all([
+                    pool.getBorrowableA().getEarningsUSD(),
+                    pool.getBorrowableB().getEarningsUSD()
+                ]);
+                earningsUSD += earningsA + earningsB;
             }
         }
-        return result;
+        return earningsUSD;
+    }
+    async getSupplyYearlyYieldUSD() {
+        let yieldUSD = 0;
+        const positionsUserData = await this.getSupplyPositions();
+        if (!positionsUserData)
+            return 0;
+        // Get positions by factory  
+        for (const factory in positionsUserData) {
+            const poolsOfFactory = positionsUserData[factory];
+            // Get pools of this factory
+            for (const poolAddress of poolsOfFactory) {
+                const pool = await this.getLendingPool(factory, poolAddress);
+                // Get yearly yield = value * APR
+                const [valueA, valueB, aprA, aprB] = await Promise.all([
+                    pool.getBorrowableA().getValue(),
+                    pool.getBorrowableB().getValue(),
+                    pool.getBorrowableA().getPoolToken().getSupplyAPR(),
+                    pool.getBorrowableB().getPoolToken().getSupplyAPR()
+                ]);
+                yieldUSD += valueA * aprA + valueB * aprB;
+            }
+        }
+        return yieldUSD;
+    }
+    async getSupplyDailyYieldUSD() {
+        // Daily yield is yearly yield / 365
+        const yearlyYield = await this.getSupplyYearlyYieldUSD();
+        return yearlyYield / 365;
+    }
+    // TODO: Collaterals
+    //
+    // Overview
+    //
+    async getTotalEarningsUSD() {
+        const [supplyEarnings, vaultEarnings] = await Promise.all([
+            this.getSupplyEarningsUSD(),
+            this.getVaultsEarningsUSD()
+        ]);
+        return supplyEarnings + vaultEarnings;
+    }
+    async getTotalYearlyYieldUSD() {
+        const [supplyYield, vaultYield] = await Promise.all([
+            this.getSupplyYearlyYieldUSD(),
+            this.getVaultsYearlyYieldUSD()
+        ]);
+        return supplyYield + vaultYield;
+    }
+    async getTotalDailyYieldUSD() {
+        const yearlyYield = await this.getTotalYearlyYieldUSD();
+        return yearlyYield / 365;
     }
 }
 exports.default = OffchainAccount;

package/lib/offchain/initializer/allPositionsV3.d.ts

@@ -0,0 +1,23 @@
+import { AddressIndex, Factory } from "../../config/types";
+import { NftlpPosition, BorrowPosition } from "../offchainTypes";
+import Offchain from "../../offchain";
+type PositionV3 = {
+    id: string;
+    userId: string;
+    tokenId: string;
+    lendingPool: {
+        id: string;
+        nftlp: {
+            factory: string;
+        };
+    };
+    borrowPositions: BorrowPosition[];
+};
+export declare function getAllV3PositionsData(this: Offchain, factory: Factory): Promise<AddressIndex<{
+    [key: string]: NftlpPosition[];
+}>>;
+export declare function initializeAllV3Positions(this: Offchain, factory: Factory): Promise<AddressIndex<{
+    [key: string]: NftlpPosition[];
+}>>;
+export declare function fetchAllV3Positions(this: Offchain, factory: Factory): Promise<PositionV3[]>;
+export {};

package/lib/offchain/initializer/allPositionsV3.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAllV3Positions = exports.initializeAllV3Positions = exports.getAllV3PositionsData = void 0;
+const nftlp_1 = require("../../config/nftlp");
+const subgraphs_1 = require("../../config/subgraphs");
+/*--------------------------------------------------------------------------*
+ *                                Getters                                   *
+ *--------------------------------------------------------------------------*/
+async function getAllV3PositionsData(factory) {
+    if (!this.allV3PositionsData[factory])
+        this.allV3PositionsData[factory] = this.initializeAllV3Positions(factory);
+    return this.allV3PositionsData[factory];
+}
+exports.getAllV3PositionsData = getAllV3PositionsData;
+/*--------------------------------------------------------------------------*
+ *                            Initializers                                  *
+ *--------------------------------------------------------------------------*/
+async function initializeAllV3Positions(factory) {
+    const globalPositions = await this.fetchAllV3Positions(factory);
+    const positions = {};
+    for (const position of globalPositions) {
+        const lendingPoolId = position.lendingPool.id;
+        const userAddress = position.userId;
+        const nftlpFactory = position.lendingPool.nftlp.factory;
+        // Initialize empty if need
+        if (!positions[lendingPoolId])
+            positions[lendingPoolId] = {};
+        if (!positions[lendingPoolId][userAddress])
+            positions[lendingPoolId][userAddress] = [];
+        const dex = (0, nftlp_1.getNftlpDex)(this.network, nftlpFactory);
+        if (!dex) {
+            console.warn(`Unknown DEX for NFTLP factory ${nftlpFactory} on ${this.network}`);
+            continue;
+        }
+        // Might not be needed for all positions??
+        const endpoints = (0, nftlp_1.getNftlpSubgraph)(this.network, dex);
+        if (!endpoints?.length) {
+            console.warn(`No NFTLP endpoints found for ${dex} on ${this.network}`);
+            continue;
+        }
+        const nftlpData = await this.getEndpointManager().fetch(endpoints, this.network, (queryBuilder) => queryBuilder.nftlpPositionQuery(lendingPoolId, position.tokenId));
+        // Create final position object
+        const nftlpPosition = { ...position, dex, nftlp: nftlpData.data.nftlpPositions?.[0] };
+        // Add to results
+        positions[lendingPoolId][userAddress].push(nftlpPosition);
+    }
+    return positions;
+}
+exports.initializeAllV3Positions = initializeAllV3Positions;
+/*--------------------------------------------------------------------------*
+ *                                Fetchers                                  *
+ *--------------------------------------------------------------------------*/
+// Same as user/positionsV3
+async function fetchAllV3Positions(factory) {
+    const subgraphs = subgraphs_1.IMPERMAX_SUBGRAPH_URL[this.network][factory];
+    if (!subgraphs?.length) {
+        console.warn(`No subgraphs found for factory ${factory} on ${this.network}`);
+        return [];
+    }
+    const allPositionsData = await this.getEndpointManager().fetch(subgraphs, this.network, (queryBuilder) => queryBuilder.allPositionsV3Query());
+    return allPositionsData?.data?.positions || [];
+}
+exports.fetchAllV3Positions = fetchAllV3Positions;

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

@@ -3,6 +3,7 @@ export * from './blocks';
 export * from './lendingPools';
 export * from './lendingPoolsPast';
 export * from './vaults';
+export * from './allPositionsV3';
 export * from './user';
 export * from './whitelist';
 export * from './staking';

package/lib/offchain/initializer/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./blocks"), exports);
 __exportStar(require("./lendingPools"), exports);
 __exportStar(require("./lendingPoolsPast"), exports);
 __exportStar(require("./vaults"), exports);
+__exportStar(require("./allPositionsV3"), exports);
 __exportStar(require("./user"), exports);
 __exportStar(require("./whitelist"), exports);
 __exportStar(require("./staking"), exports);

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

@@ -48,19 +48,7 @@ async function initializeV3Positions(offchain, factory, rawUserData) {
         }
         // 3. Fetch NFTLP Position from endpoint/endpoints
         const nftlpData = await offchain.getEndpointManager().fetch(endpoints, offchain.network, (queryBuilder) => queryBuilder.nftlpPositionQuery(lendingPoolId, position.tokenId));
-        // NOTE: Is there a better way? Ordered by borrowable address, and UniswapV3
-        //       orders by token0 < token1
-        // Sort borrow positions 
-        const sortedBorrowPositions = position.borrowPositions.sort((a, b) => BigInt(a.borrowable.underlying.id) < BigInt(b.borrowable.underlying.id)
-            ? -1
-            : 1);
-        // Combine everything
-        const nftlpPosition = {
-            ...position,
-            dex,
-            borrowPositions: sortedBorrowPositions,
-            nftlp: nftlpData.data.nftlpPositions[0] || undefined,
-        };
+        const nftlpPosition = { ...position, dex, nftlp: nftlpData.data.nftlpPositions?.[0] };
         positions[lendingPoolId].push(nftlpPosition);
     }
     return { positions };

package/lib/offchain/initializer/user/vaults.d.ts

@@ -1,9 +1,6 @@
 import { Address, AddressIndex } from "../../../config/types";
 import { VaultPosition } from "../../offchainTypes";
 import Offchain from "../../offchain";
-/**
- * User Data
- */
-export declare function fetchVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<VaultPosition[]>>;
-export declare function initializeVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<AddressIndex<VaultPosition>>>;
 export declare function getVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<AddressIndex<VaultPosition>>>;
+export declare function initializeVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<AddressIndex<VaultPosition>>>;
+export declare function fetchVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<VaultPosition[]>>;

package/lib/offchain/initializer/user/vaults.js

@@ -1,10 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVaultsUserData = exports.initializeVaultsUserData = exports.fetchVaultsUserData = void 0;
+exports.fetchVaultsUserData = exports.initializeVaultsUserData = exports.getVaultsUserData = void 0;
 const subgraphs_1 = require("../../../config/subgraphs");
-/**
- * User Data
- */
+/*--------------------------------------------------------------------------*
+ *                                Getters                                   *
+ *--------------------------------------------------------------------------*/
+async function getVaultsUserData(account) {
+    if (!(account in this.vaultsUsersData))
+        this.vaultsUsersData[account] = this.initializeVaultsUserData(account);
+    return (await this.vaultsUsersData[account]) || {};
+}
+exports.getVaultsUserData = getVaultsUserData;
+/*--------------------------------------------------------------------------*
+ *                            Initializers                                  *
+ *--------------------------------------------------------------------------*/
+async function initializeVaultsUserData(account) {
+    const userVaultData = await this.fetchVaultsUserData(account);
+    const result = {};
+    for (const vaultType in userVaultData) {
+        const positions = userVaultData[vaultType];
+        if (!positions)
+            continue;
+        result[vaultType] = {};
+        for (const position of positions) {
+            result[vaultType][position.lendingVault.id] = position;
+        }
+    }
+    return result;
+}
+exports.initializeVaultsUserData = initializeVaultsUserData;
+/*--------------------------------------------------------------------------*
+ *                               Fetchers                                   *
+ *--------------------------------------------------------------------------*/
 async function fetchVaultsUserData(account) {
     const calls = [];
     let vaultType;
@@ -36,24 +63,3 @@ async function fetchVaultsUserData(account) {
     return userVaultData;
 }
 exports.fetchVaultsUserData = fetchVaultsUserData;
-async function initializeVaultsUserData(account) {
-    const userVaultData = await this.fetchVaultsUserData(account);
-    const result = {};
-    for (const vaultType in userVaultData) {
-        const positions = userVaultData[vaultType];
-        if (!positions)
-            continue;
-        result[vaultType] = {};
-        for (const position of positions) {
-            result[vaultType][position.lendingVault.id] = position;
-        }
-    }
-    return result;
-}
-exports.initializeVaultsUserData = initializeVaultsUserData;
-async function getVaultsUserData(account) {
-    if (!(account in this.vaultsUsersData))
-        this.vaultsUsersData[account] = this.initializeVaultsUserData(account);
-    return (await this.vaultsUsersData[account]) || {};
-}
-exports.getVaultsUserData = getVaultsUserData;

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, VaultType } from '../config/types';
-import { LendingPoolData, VaultData, VaultPosition, TvlData, UserData, XimxData, VaultBorrowable } from './offchainTypes';
+import { LendingPoolData, VaultData, VaultPosition, TvlData, UserData, XimxData, VaultBorrowable, NftlpPosition } from './offchainTypes';
 import OffchainVault from './vault/offchainVault';
 import OffchainConfigManager from './configManager';
 import { LlamaTvlChart } from './offchainAPRHelper';
@@ -40,6 +40,11 @@ export default class Offchain {
     protected vaultBorrowablesData: {
         [key in VaultType]?: Promise<AddressIndex<VaultBorrowable[]>>;
     };
+    protected allV3PositionsData: {
+        [key in Factory]?: Promise<AddressIndex<{
+            [key: string]: NftlpPosition[];
+        }>>;
+    };
     constructor(offchainMultichain: OffchainMultichain, network: Networks, whitelist?: FactoryIndex<Address[]>);
     cleanCache(): void;
     getLendingPool(factory: Factory, pairAddress: Address): Promise<OffchainLendingPool>;
@@ -81,6 +86,9 @@ export default class Offchain {
     protected initializeVaultsUserData: typeof initializer.initializeVaultsUserData;
     protected fetchVaultBorrowables: typeof initializer.fetchVaultBorrowables;
     getVaultBorrowables: typeof initializer.getVaultBorrowables;
+    protected fetchAllV3Positions: typeof initializer.fetchAllV3Positions;
+    protected initializeAllV3Positions: typeof initializer.initializeAllV3Positions;
+    getAllV3PositionsData: typeof initializer.getAllV3PositionsData;
     /**
      * DATA GETTERS
      */

package/lib/offchain/offchain.js

@@ -35,6 +35,7 @@ const chainId_1 = require("../config/chainId");
 class Offchain {
     constructor(offchainMultichain, network, whitelist) {
         this.whitelistedPairs = {};
+        this.allV3PositionsData = {};
         this.getSolidexHelper = () => this.solidexHelper;
         this.getConfigManager = () => this.configManager;
         // Multichain, 1 instance
@@ -80,6 +81,9 @@ class Offchain {
         this.initializeVaultsUserData = initializer.initializeVaultsUserData;
         this.fetchVaultBorrowables = initializer.fetchVaultBorrowables;
         this.getVaultBorrowables = initializer.getVaultBorrowables;
+        this.fetchAllV3Positions = initializer.fetchAllV3Positions;
+        this.initializeAllV3Positions = initializer.initializeAllV3Positions;
+        this.getAllV3PositionsData = initializer.getAllV3PositionsData;
         // TODO fix conflicting lines (commented)
         //this.network = cfg.network;
         //this.chainId = cfg.chainId;
@@ -109,6 +113,7 @@ class Offchain {
         this.configManager.cleanCache();
         this.getPriceHelper().cleanCache();
         this.getAPRHelper().cleanCache();
+        this.allV3PositionsData = {};
     }
     async getLendingPool(factory, pairAddress) {
         await this.getLendingPoolsData(); // make sure that lending pools are initialized

package/package.json

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