impermax-sdk 2.1.51 → 2.1.53

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 { OffchainAccountBorrowable } from "./lendingPool";
+import OffchainAccountVault from "./vault";
 import OffchainMultichain from "../offchainMultichain";
 import OffchainAccount from "./offchainAccount";
 import OffchainLeveragedPosition from "./lendingPool/offchainLeveragedPosition";
@@ -18,6 +18,7 @@ export declare enum VaultPositionsOrderBy {
     TVL = 0
 }
 export interface VaultPositionsParams {
+    networks?: Array<Networks>;
 }
 export default class OffchainMultichainAccount {
     readonly offchainMultichain: OffchainMultichain;
@@ -30,5 +31,6 @@ export default class OffchainMultichainAccount {
     getSupplyPositions(params?: SupplyPositionsParams, orderBy?: SupplyPositionsOrderBy): Promise<Array<OffchainAccountBorrowable>>;
     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) {
@@ -47,14 +50,38 @@ class OffchainMultichainAccount {
     }
     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 vaults in a network
+            const networkPromises = networksWithVaults.map((network) => __awaiter(this, void 0, void 0, function* () {
+                const offchainAccount = this.getOffchainAccount(network);
+                const vaultsUserData = yield offchainAccount.getVaultsUserData();
+                const vaultPromises = [];
+                // Get user 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/lib/offchain/vault/offchainLendingVault.d.ts

@@ -9,13 +9,14 @@ export declare enum RiskLevel {
     HIGH = 2
 }
 export default class OffchainLendingVault extends OffchainVault {
+    protected vaultBorrowables: Array<VaultBorrowable> | null;
     constructor(offchain: Offchain, vaultAddress: Address);
     getRiskLevel(): Promise<RiskLevel>;
     getAvailableLiquidity(): Promise<number>;
     getAvailableLiquidityUSD(): Promise<number>;
-    getBorrowableAmm(borrowable: VaultBorrowable): Promise<Amms | null>;
-    getBorrowablesWithAmm(): Promise<Array<VaultBorrowable & {
+    getLendingVaultBorrowableAmm(borrowable: VaultBorrowable): Promise<Amms | null>;
+    getLendingVaultBorrowablesWithAmm(): Promise<Array<VaultBorrowable & {
         amm: Amms | null;
     }>>;
-    getBorrowables(): Promise<Array<VaultBorrowable>>;
+    getLendingVaultBorrowables(): Promise<Array<VaultBorrowable> | null>;
 }

package/lib/offchain/vault/offchainLendingVault.js

@@ -16,6 +16,7 @@ exports.RiskLevel = void 0;
 const types_1 = require("../../config/types");
 const offchainVault_1 = __importDefault(require("./offchainVault"));
 const amms_1 = require("../../config/amms");
+const private_api_1 = require("../../config/private-api");
 var RiskLevel;
 (function (RiskLevel) {
     RiskLevel[RiskLevel["LOW"] = 0] = "LOW";
@@ -25,6 +26,7 @@ var RiskLevel;
 class OffchainLendingVault extends offchainVault_1.default {
     constructor(offchain, vaultAddress) {
         super(offchain, vaultAddress);
+        this.vaultBorrowables = null;
         this.vaultType = types_1.VaultType.LENDING;
     }
     getRiskLevel() {
@@ -45,7 +47,7 @@ class OffchainLendingVault extends offchainVault_1.default {
             return availableLiquidity * tokenPrice;
         });
     }
-    getBorrowableAmm(borrowable) {
+    getLendingVaultBorrowableAmm(borrowable) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const lendingPoolsData = yield this.getOffchain().getLendingPoolsData();
@@ -62,22 +64,37 @@ class OffchainLendingVault extends offchainVault_1.default {
             return null;
         });
     }
-    getBorrowablesWithAmm() {
+    getLendingVaultBorrowablesWithAmm() {
         return __awaiter(this, void 0, void 0, function* () {
-            const borrowables = yield this.getBorrowables();
+            const borrowables = yield this.getLendingVaultBorrowables();
+            if (!borrowables)
+                return [];
             const borrowablesWithAmm = yield Promise.all(borrowables.map((borrowable) => __awaiter(this, void 0, void 0, function* () {
-                return (Object.assign(Object.assign({}, borrowable), { amm: yield this.getBorrowableAmm(borrowable) }));
+                return (Object.assign(Object.assign({}, borrowable), { amm: yield this.getLendingVaultBorrowableAmm(borrowable) }));
             })));
             return borrowablesWithAmm;
         });
     }
-    // See the LendingVaultData type in ../offchainTypes.ts
-    getBorrowables() {
+    // Avoid doing this through initializer and do it as-needed
+    getLendingVaultBorrowables() {
         return __awaiter(this, void 0, void 0, function* () {
-            const vaultData = (yield this.getPoolTokenData());
-            if (!vaultData.borrowables)
-                return [];
-            return vaultData.borrowables;
+            if (this.vaultBorrowables)
+                return this.vaultBorrowables;
+            const network = this.getOffchain().network;
+            const vaultAddress = this.getVaultAddress();
+            const api = private_api_1.IMPERMAX_VAULT_API[network][this.vaultType];
+            if (!api) {
+                console.log(`Missing API for ${vaultAddress} on ${network}?`);
+                return null;
+            }
+            try {
+                this.vaultBorrowables = yield fetch(api.concat(vaultAddress, '/borrowables')).then((i) => i.json());
+            }
+            catch (err) {
+                console.log(`No vault data found for ${vaultAddress} on ${network}`);
+                this.vaultBorrowables = []; // Leave empty to prevent refeteching
+            }
+            return this.vaultBorrowables;
         });
     }
 }

package/package.json

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