impermax-sdk 2.1.52 → 2.1.54

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

@@ -1,6 +1,6 @@
-import { Address, Networks } from '../../config/types';
-import { OffchainAccountBorrowable } from './lendingPool';
-import OffchainAccountVault from './vault';
+import { Address, Networks } from "../../config/types";
+import OffchainAccountLendingPool from "./lendingPool";
+import OffchainAccountVault from "./vault";
 import OffchainMultichain from "../offchainMultichain";
 import OffchainAccount from "./offchainAccount";
 import OffchainLeveragedPosition from "./lendingPool/offchainLeveragedPosition";
@@ -13,11 +13,13 @@ export declare enum SupplyPositionsOrderBy {
     TVL = 0
 }
 export interface SupplyPositionsParams {
+    networks?: Array<Networks>;
 }
 export declare enum VaultPositionsOrderBy {
     TVL = 0
 }
 export interface VaultPositionsParams {
+    networks?: Array<Networks>;
 }
 export default class OffchainMultichainAccount {
     readonly offchainMultichain: OffchainMultichain;
@@ -27,8 +29,9 @@ export default class OffchainMultichainAccount {
     getAccountAddress: () => string;
     getOffchainAccount(network: Networks): OffchainAccount;
     getLeveragedPositions(params?: LeveragedPositionsParams, orderBy?: LeveragedPositionsOrderBy): Promise<Array<OffchainLeveragedPosition>>;
-    getSupplyPositions(params?: SupplyPositionsParams, orderBy?: SupplyPositionsOrderBy): Promise<Array<OffchainAccountBorrowable>>;
+    getSupplyPositions(params?: SupplyPositionsParams, orderBy?: SupplyPositionsOrderBy): Promise<Array<OffchainAccountLendingPool>>;
     getVaultPositions(params?: VaultPositionsParams, orderBy?: VaultPositionsOrderBy): Promise<Array<OffchainAccountVault>>;
     getTotalBalanceUSD(): Promise<number>;
+    getVaultsBalanceUSD(): Promise<number>;
     getNetAPR(): Promise<number>;
 }

package/lib/offchain/account/offchainMultichainAccount.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultPositionsOrderBy = exports.SupplyPositionsOrderBy = exports.LeveragedPositionsOrderBy = void 0;
+const types_1 = require("../../config/types");
 var LeveragedPositionsOrderBy;
 (function (LeveragedPositionsOrderBy) {
     LeveragedPositionsOrderBy[LeveragedPositionsOrderBy["TVL"] = 0] = "TVL";
@@ -30,7 +31,9 @@ class OffchainMultichainAccount {
         this.accountAddress = account;
     }
     getOffchainAccount(network) {
-        return this.offchainMultichain.getOffchain(network).getAccount(this.accountAddress);
+        return this.offchainMultichain
+            .getOffchain(network)
+            .getAccount(this.accountAddress);
     }
     // Positions
     getLeveragedPositions(params = {}, orderBy = LeveragedPositionsOrderBy.TVL) {
@@ -39,22 +42,67 @@ class OffchainMultichainAccount {
             return [];
         });
     }
+    // Easier to return the lending pool object instead of borrowable?
     getSupplyPositions(params = {}, orderBy = SupplyPositionsOrderBy.TVL) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO FILL WITH FAKE DATA
-            return [];
+            const allNetworks = params.networks || Object.values(types_1.Networks);
+            // Get user supply positions in each network
+            const networkPromises = allNetworks.map((network) => __awaiter(this, void 0, void 0, function* () {
+                const offchainAccount = this.getOffchainAccount(network);
+                const userData = yield offchainAccount.getUserData();
+                if (!userData)
+                    return [];
+                const positions = [];
+                // Get network positions in each factory
+                const supplyPositions = yield offchainAccount.getSupplyPositions();
+                for (const factory in supplyPositions) {
+                    const poolsOfFactory = supplyPositions[factory];
+                    for (const poolAddress of poolsOfFactory) {
+                        positions.push(offchainAccount.getLendingPool(factory, poolAddress));
+                    }
+                }
+                return Promise.all(positions);
+            }));
+            const results = yield Promise.all(networkPromises);
+            return results.flat();
         });
     }
     getVaultPositions(params = {}, orderBy = VaultPositionsOrderBy.TVL) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO FILL WITH FAKE DATA
-            return [];
+            const allNetworks = params.networks || Object.values(types_1.Networks);
+            const networksWithVaults = allNetworks.filter((network) => this.offchainMultichain.networkHasVault(network));
+            // Get user positions in each network
+            const networkPromises = networksWithVaults.map((network) => __awaiter(this, void 0, void 0, function* () {
+                const offchainAccount = this.getOffchainAccount(network);
+                const vaultsUserData = yield offchainAccount.getVaultsUserData();
+                if (!vaultsUserData)
+                    return [];
+                const vaultPromises = [];
+                // Get network positions in each vault type
+                for (const vaultType in vaultsUserData) {
+                    const vaultsOfType = vaultsUserData[vaultType];
+                    for (const address in vaultsOfType) {
+                        vaultPromises.push(offchainAccount.getVault(address));
+                    }
+                }
+                return Promise.all(vaultPromises);
+            }));
+            const results = yield Promise.all(networkPromises);
+            return results.flat();
         });
     }
     // Account stats
     getTotalBalanceUSD() {
         return __awaiter(this, void 0, void 0, function* () {
-            return 10;
+            // TODO: Markets
+            return this.getVaultsBalanceUSD();
+        });
+    }
+    getVaultsBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vaultPositions = yield this.getVaultPositions();
+            const depositedValue = yield Promise.all(vaultPositions.map((i) => i.getValue()));
+            return depositedValue.reduce((acc, val) => acc + val, 0);
         });
     }
     getNetAPR() {

package/lib/offchain/offchainMultichain.d.ts

@@ -8,6 +8,8 @@ import OffchainLendingPool from "./lendingPool";
 import { LendingPoolVersion } from "./lendingPool/offchainLendingPool";
 import OffchainAPRHelper from "./offchainAPRHelper";
 import OffchainPriceHelper from "./offchainPriceHelper";
+import OffchainMultichainAccount from "./account/offchainMultichainAccount";
+import { AddressIndex } from "../config/types";
 export declare enum SortDirection {
     ASC = "asc",
     DESC = "desc"
@@ -50,8 +52,8 @@ export default class OffchainMultichain {
     protected offchains: NetworkIndex<Offchain>;
     protected aprHelper: OffchainAPRHelper;
     protected priceHelper: OffchainPriceHelper;
-    private lendingPoolsInitialized;
     protected lendingPools: OffchainLendingPool[];
+    protected multichainAccounts: AddressIndex<OffchainMultichainAccount>;
     private constructor();
     static get instance(): OffchainMultichain;
     getOffchain(network: Networks, whitelist?: FactoryIndex<Address[]>): Offchain;
@@ -60,4 +62,5 @@ export default class OffchainMultichain {
     getVaultList(params?: VaultListParams): Promise<Array<OffchainVault>>;
     networkHasVault(network: Networks): boolean;
     getLendingPoolList(params?: LendingPoolListParams): Promise<Array<OffchainLendingPool>>;
+    getMultichainAccount(accountAddress: Address): OffchainMultichainAccount;
 }

package/lib/offchain/offchainMultichain.js

@@ -30,6 +30,7 @@ const offchain_1 = __importDefault(require("./offchain"));
 const subgraphs_1 = require("../config/subgraphs");
 const offchainAPRHelper_1 = __importDefault(require("./offchainAPRHelper"));
 const offchainPriceHelper_1 = __importDefault(require("./offchainPriceHelper"));
+const offchainMultichainAccount_1 = __importDefault(require("./account/offchainMultichainAccount"));
 // For vaults and pools
 var SortDirection;
 (function (SortDirection) {
@@ -54,8 +55,8 @@ var LendingPoolListOrderBy;
 // singleton class
 class OffchainMultichain {
     constructor() {
-        this.lendingPoolsInitialized = null;
         this.lendingPools = [];
+        this.multichainAccounts = {};
         // Initialize empty
         this.offchains = {};
         this.aprHelper = new offchainAPRHelper_1.default(this);
@@ -128,6 +129,15 @@ class OffchainMultichain {
             return results.flat();
         });
     }
+    /*--------------------------------------------------------*
+     *                    Account
+     *--------------------------------------------------------*/
+    getMultichainAccount(accountAddress) {
+        if (!this.multichainAccounts[accountAddress]) {
+            this.multichainAccounts[accountAddress] = new offchainMultichainAccount_1.default(this, accountAddress);
+        }
+        return this.multichainAccounts[accountAddress];
+    }
 }
 exports.default = OffchainMultichain;
 _a = OffchainMultichain;

package/package.json

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