impermax-sdk 1.0.46 → 1.1.0

package/lib/impermax-router/Account.d.ts

@@ -1,11 +1,13 @@
 import { AirdropData, PendingRewardUI } from "./types";
 import ImpermaxRouter from "./index";
 import AccountLendingPool from "./AccountLendingPool";
-import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import AccountLendingVault from './AccountLendingVault';
 export default class Account {
     router: ImpermaxRouter;
     account: Address;
     accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
+    accountLVs: AddressIndex<Promise<AccountLendingVault>>;
     cache: {
         airdropData: {
             [key in string]?: Promise<AirdropData>;
@@ -18,6 +20,8 @@ export default class Account {
     cleanCache(): Promise<void>;
     private initializeAccountLendingPool;
     getAccountLendingPool(factory: Factory, pair: Address): Promise<AccountLendingPool>;
+    private initializeAccountLendingVault;
+    getAccountLendingVault(vaultAddress: Address): Promise<AccountLendingVault>;
     getMassAvailableReward(pairs: FactoryIndex<Address[]>): Promise<LendingPoolIndex<PendingRewardUI[]>>;
     private initializeAirdropData;
     private getAirdropData;

package/lib/impermax-router/Account.js

@@ -15,12 +15,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const AccountLendingPool_1 = __importDefault(require("./AccountLendingPool"));
 const ethers_1 = require("ethers");
 const merkle_distributors_1 = require("../config/endpoints/merkle-distributors");
+const AccountLendingVault_1 = __importDefault(require("./AccountLendingVault"));
 class Account {
     constructor(router, account) {
         this.cache = { airdropData: {} };
         this.router = router;
         this.account = account;
         this.accountLLPs = {};
+        this.accountLVs = {};
         this.cache.claimableIBEX = {};
     }
     cleanCache() {
@@ -32,6 +34,9 @@ class Account {
                     (yield this.accountLLPs[factory][pairAddress]).cleanCache();
                 }
             }
+            for (const vaultAddress of Object.keys(this.accountLVs)) {
+                (yield this.accountLVs[vaultAddress]).cleanCache();
+            }
         });
     }
     initializeAccountLendingPool(factory, pair) {
@@ -49,6 +54,19 @@ class Account {
             return this.accountLLPs[factory][pair];
         });
     }
+    initializeAccountLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.router.getLendingVault(vaultAddress);
+            return new AccountLendingVault_1.default(this, lendingPool);
+        });
+    }
+    getAccountLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountLVs[vaultAddress])
+                this.accountLVs[vaultAddress] = this.initializeAccountLendingVault(vaultAddress);
+            return this.accountLVs[vaultAddress];
+        });
+    }
     // Mass Available Reward (only supports ImpermaxChef)
     getMassAvailableReward(pairs) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/impermax-router/AccountLendingVault.d.ts

@@ -0,0 +1,14 @@
+import Account from "./Account";
+import LendingVault from './LendingVault';
+export default class AccountLendingVault {
+    account: Account;
+    lendingVault: LendingVault;
+    cache: {};
+    constructor(account: Account, lendingVault: LendingVault);
+    cleanCache(): void;
+    getAvailableBalance(): Promise<number>;
+    getSuppliedTokens(): Promise<number>;
+    getSuppliedAmount(): Promise<number>;
+    getSuppliedUSD(): Promise<number>;
+    getMaxWithdrawable(): Promise<number>;
+}

package/lib/impermax-router/AccountLendingVault.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class AccountLendingVault {
+    constructor(account, lendingVault) {
+        this.cache = {};
+        this.account = account;
+        this.lendingVault = lendingVault;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    // User balance
+    getAvailableBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getSuppliedTokens() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getSuppliedAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getSuppliedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Interactions
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = AccountLendingVault;

package/lib/impermax-router/Interactions.d.ts

@@ -2,13 +2,17 @@ import { BigNumber } from "ethers";
 import Account from "./Account";
 import InteractionsLendingPool from "./InteractionsLendingPool";
 import { AirdropData, Contract } from "./types";
-import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import InteractionsLendingVault from './InteractionsLendingVault';
 export default class Interactions {
     account: Account;
     interactionsLLPs: LendingPoolIndex<Promise<InteractionsLendingPool>>;
+    interactionsLVs: AddressIndex<Promise<InteractionsLendingVault>>;
     constructor(account: Account);
     private initializeInteractionsLendingPool;
     getInteractionsLendingPool(factory: Factory, pair: Address): Promise<InteractionsLendingPool>;
+    private initializeInteractionsLendingVault;
+    getInteractionsLendingVault(vaultAddress: Address): Promise<InteractionsLendingVault>;
     send(method: any, onTransactionHash: Function, value?: BigNumber): Promise<any>;
     claimAirdrop(airdropData: AirdropData, merkleDistributor: Contract, onTransactionHash: Function): Promise<any>;
     claims(pairAddresses: FactoryIndex<Address[]>, onTransactionHash: Function): Promise<any>;

package/lib/impermax-router/Interactions.js

@@ -15,11 +15,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const InteractionsLendingPool_1 = __importDefault(require("./InteractionsLendingPool"));
 const types_1 = require("../config/types");
+const InteractionsLendingVault_1 = __importDefault(require("./InteractionsLendingVault"));
 const ZERO = ethers_1.BigNumber.from(0);
 class Interactions {
     constructor(account) {
         this.account = account;
         this.interactionsLLPs = {};
+        this.interactionsLVs = {};
     }
     initializeInteractionsLendingPool(factory, pair) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -36,6 +38,19 @@ class Interactions {
             return this.interactionsLLPs[factory][pair];
         });
     }
+    initializeInteractionsLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingVault = yield this.account.getAccountLendingVault(vaultAddress);
+            return new InteractionsLendingVault_1.default(this, lendingVault);
+        });
+    }
+    getInteractionsLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.interactionsLVs[vaultAddress])
+                this.interactionsLVs[vaultAddress] = this.initializeInteractionsLendingVault(vaultAddress);
+            return this.interactionsLVs[vaultAddress];
+        });
+    }
     send(method, onTransactionHash, value = ZERO) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/lib/impermax-router/InteractionsLendingVault.d.ts

@@ -0,0 +1,22 @@
+import Interactions from "./Interactions";
+import { BigNumber } from "ethers";
+import { ApprovalType, PermitData } from './types';
+import AccountLendingVault from './AccountLendingVault';
+export default class InteractionsLendingVault {
+    interactions: Interactions;
+    accountLendingVault: AccountLendingVault;
+    constructor(interactions: Interactions, accountLendingVault: AccountLendingVault);
+    getImpermaxRouter: () => import(".").default;
+    getLendingVault: () => import("./LendingVault").default;
+    send: (method: any, onTransactionHash: Function) => Promise<any>;
+    getOwnerSpender(): {
+        owner: string;
+        spender: string;
+    };
+    isWETH(): Promise<boolean>;
+    getAllowance(approvalType: ApprovalType): Promise<BigNumber>;
+    approve(approvalType: ApprovalType, amount: BigNumber, onTransactionHash: Function): Promise<void>;
+    getPermitData(approvalType: ApprovalType, amount: BigNumber, deadlineArg: BigNumber | null, callBack: (permitData: PermitData) => void): Promise<void>;
+    deposit(amount: BigNumber, onTransactionHash: Function): Promise<void>;
+    withdraw(tokens: BigNumber, permitData: PermitData, onTransactionHash: Function): Promise<void>;
+}

package/lib/impermax-router/InteractionsLendingVault.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+class InteractionsLendingVault {
+    constructor(interactions, accountLendingVault) {
+        // Shortcuts
+        this.getImpermaxRouter = () => this.interactions.account.router;
+        this.getLendingVault = () => this.accountLendingVault.lendingVault;
+        this.send = (method, onTransactionHash) => this.interactions.send(method, onTransactionHash);
+        this.interactions = interactions;
+        this.accountLendingVault = accountLendingVault;
+    }
+    getOwnerSpender() {
+        return {
+            owner: this.accountLendingVault.account.account,
+            spender: "TODO",
+        };
+    }
+    isWETH() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    getAllowance(approvalType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return ethers_1.BigNumber.from("0");
+        });
+    }
+    approve(approvalType, amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    getPermitData(approvalType, amount, deadlineArg, callBack) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    deposit(amount, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    withdraw(tokens, permitData, onTransactionHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+exports.default = InteractionsLendingVault;

package/lib/impermax-router/LendingVault.d.ts

@@ -0,0 +1,12 @@
+import { Address } from '../config/types';
+import ImpermaxRouter from './index';
+export default class LendingVault {
+    router: ImpermaxRouter;
+    vaultAddress: Address;
+    cache: {};
+    constructor(router: ImpermaxRouter, vaultAddress: Address);
+    cleanCache(): void;
+    getExchangeRate(): Promise<number>;
+    getAccrualTimestamp(): Promise<number>;
+    getAvailableLiquidity(): Promise<number>;
+}

package/lib/impermax-router/LendingVault.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class LendingVault {
+    constructor(router, vaultAddress) {
+        this.cache = {};
+        this.router = router;
+        this.vaultAddress = vaultAddress;
+    }
+    cleanCache() {
+        this.cache = {};
+    }
+    // ExchangeRate
+    getExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Accrue Timestamp
+    getAccrualTimestamp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Available Liquidity
+    getAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = LendingVault;

package/lib/impermax-router/index.d.ts

@@ -2,7 +2,8 @@ import { ImpermaxRouterCfg } from "./types";
 import Subgraph from "../subgraph";
 import ContractsHelper from "./ContractsHelper";
 import ImpermaxFactory from "./ImpermaxFactory";
-import { Factory, FactoryIndex, Networks } from '../config/types';
+import { Address, AddressIndex, Factory, FactoryIndex, Networks } from '../config/types';
+import LendingVault from './LendingVault';
 export default class ImpermaxRouter {
     network: Networks;
     subgraph: Subgraph;
@@ -10,6 +11,7 @@ export default class ImpermaxRouter {
     chainId: number;
     contractsHelper: ContractsHelper;
     factories: FactoryIndex<ImpermaxFactory>;
+    lendingVaults: AddressIndex<LendingVault>;
     uiMargin: number;
     dust: number;
     priceInverted: boolean;
@@ -17,4 +19,5 @@ export default class ImpermaxRouter {
     cleanCache(): void;
     setPriceInverted(priceInverted: boolean): void;
     getFactory(factory: Factory): ImpermaxFactory;
+    getLendingVault(vaultAddress: Address): LendingVault;
 }

package/lib/impermax-router/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ContractsHelper_1 = __importDefault(require("./ContractsHelper"));
 const ImpermaxFactory_1 = __importDefault(require("./ImpermaxFactory"));
+const LendingVault_1 = __importDefault(require("./LendingVault"));
 class ImpermaxRouter {
     constructor(cfg) {
         this.network = cfg.network;
@@ -13,7 +14,7 @@ class ImpermaxRouter {
         this.chainId = cfg.chainId;
         this.uiMargin = 1.1;
         this.dust = 1.000001;
-        this.priceInverted = cfg.priceInverted;
+        this.priceInverted = cfg.priceInverted ? cfg.priceInverted : false;
         this.contractsHelper = new ContractsHelper_1.default(this);
         this.factories = {};
     }
@@ -21,6 +22,9 @@ class ImpermaxRouter {
         for (const factory of Object.keys(this.factories)) {
             this.factories[factory].cleanCache();
         }
+        for (const vaultAddress of Object.keys(this.lendingVaults)) {
+            this.lendingVaults[vaultAddress].cleanCache();
+        }
     }
     setPriceInverted(priceInverted) {
         this.priceInverted = priceInverted;
@@ -30,5 +34,10 @@ class ImpermaxRouter {
             this.factories[factory] = new ImpermaxFactory_1.default(this, factory);
         return this.factories[factory];
     }
+    getLendingVault(vaultAddress) {
+        if (!this.lendingVaults[vaultAddress])
+            this.lendingVaults[vaultAddress] = new LendingVault_1.default(this, vaultAddress);
+        return this.lendingVaults[vaultAddress];
+    }
 }
 exports.default = ImpermaxRouter;

package/lib/impermax-router/types.d.ts

@@ -17,7 +17,7 @@ export interface ImpermaxRouterCfg {
     subgraph: Subgraph;
     web3: any;
     chainId: number;
-    priceInverted: boolean;
+    priceInverted?: boolean;
 }
 export interface Changes {
     changeBorrowedA: number;

package/lib/subgraph/Account.d.ts

@@ -1,15 +1,21 @@
 import Subgraph from "./index";
 import AccountLendingPool from "./AccountLendingPool";
-import { Address, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
 import { UserData } from './types';
+import AccountLendingVault from './AccountLendingVault';
 export default class Account {
     subgraph: Subgraph;
     account: Address;
     accountLLPs: LendingPoolIndex<Promise<AccountLendingPool>>;
+    accountLVs: AddressIndex<Promise<AccountLendingVault>>;
     constructor(subgraph: Subgraph, account: Address);
     private initializeAccountLendingPool;
     getAccountLendingPool(factory: Factory, pair: Address): Promise<AccountLendingPool>;
+    private initializeAccountLendingVault;
+    getAccountLendingVault(vaultAddress: Address): Promise<AccountLendingVault>;
     getUserData(): Promise<FactoryIndex<UserData>>;
     getBorrowPositions(): Promise<FactoryIndex<Address[]>>;
     getSupplyPositions(): Promise<FactoryIndex<Address[]>>;
+    getLendingVaultsSuppliedUSD(): Promise<number>;
+    getLendingVaultsEarningsUSD(): Promise<number>;
 }

package/lib/subgraph/Account.js

@@ -13,11 +13,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const AccountLendingPool_1 = __importDefault(require("./AccountLendingPool"));
+const AccountLendingVault_1 = __importDefault(require("./AccountLendingVault"));
 class Account {
     constructor(subgraph, account) {
         this.subgraph = subgraph;
         this.account = account;
         this.accountLLPs = {};
+        this.accountLVs = {};
     }
     initializeAccountLendingPool(factory, pair) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -34,6 +36,19 @@ class Account {
             return this.accountLLPs[factory][pair];
         });
     }
+    initializeAccountLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingVault = yield this.subgraph.getLendingVault(vaultAddress);
+            return new AccountLendingVault_1.default(this, lendingVault);
+        });
+    }
+    getAccountLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accountLVs[vaultAddress])
+                this.accountLVs[vaultAddress] = this.initializeAccountLendingVault(vaultAddress);
+            return this.accountLVs[vaultAddress];
+        });
+    }
     getUserData() {
         return __awaiter(this, void 0, void 0, function* () {
             return this.subgraph.getUserData(this.account);
@@ -59,5 +74,15 @@ class Account {
             return result;
         });
     }
+    getLendingVaultsSuppliedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getLendingVaultsEarningsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
 }
 exports.default = Account;

package/lib/subgraph/AccountLendingVault.d.ts

@@ -0,0 +1,11 @@
+import Account from './Account';
+import LendingVault from './LendingVault';
+export default class AccountLendingVault {
+    account: Account;
+    lendingVault: LendingVault;
+    constructor(account: Account, lendingVault: LendingVault);
+    getSuppliedAmount(): Promise<number>;
+    getSuppliedUSD(): Promise<number>;
+    getEarnings(): Promise<number>;
+    getEarningsUSD(): Promise<number>;
+}

package/lib/subgraph/AccountLendingVault.js

@@ -0,0 +1,38 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class AccountLendingVault {
+    constructor(account, lendingVault) {
+        this.account = account;
+        this.lendingVault = lendingVault;
+    }
+    getSuppliedAmount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getSuppliedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getEarnings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getEarningsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = AccountLendingVault;

package/lib/subgraph/LendingVault.d.ts

@@ -0,0 +1,23 @@
+import Subgraph from "./index";
+import { Address } from '../config/types';
+export default class LendingVault {
+    subgraph: Subgraph;
+    vaultAddress: Address;
+    constructor(subgraph: Subgraph, vaultAddress: Address);
+    getName(): Promise<string>;
+    getSymbol(): Promise<string>;
+    getDecimals(): Promise<number>;
+    getExchangeRate(): Promise<number>;
+    getUnderlyingAddress(): Promise<Address>;
+    getAccrualTimestamp(): Promise<number>;
+    getVaultSupply(): Promise<number>;
+    getCurrentVaultSupply(): Promise<number>;
+    getVaultSupplyUSD(): Promise<number>;
+    getAvailableLiquidity(): Promise<number>;
+    getCurrentAvailableLiquidity(): Promise<number>;
+    getAvailableLiquidityUSD(): Promise<number>;
+    getSupplyRate(): Promise<number>;
+    getSupplyAPR(): Promise<number>;
+    getTokenPriceFast(fallback?: boolean): Promise<number>;
+    getTokenPriceAccurate(): Promise<number>;
+}

package/lib/subgraph/LendingVault.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class LendingVault {
+    constructor(subgraph, vaultAddress) {
+        this.subgraph = subgraph;
+        this.vaultAddress = vaultAddress;
+    }
+    // Name
+    getName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "TODO";
+        });
+    }
+    // Symbol
+    getSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "TODO";
+        });
+    }
+    // Decimals
+    getDecimals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // ExchangeRate
+    getExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Underlying Address
+    getUnderlyingAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "TODO";
+        });
+    }
+    // Accrue Timestamp
+    getAccrualTimestamp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Vault Supply
+    getVaultSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getCurrentVaultSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getVaultSupplyUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    /*// Total Supply
+    async getTotalSupply() : Promise<number> {
+      return 0;
+    }
+    async getCurrentTotalSupply() : Promise<number> {
+      return 0;
+    }
+  
+    // Total Borrows
+    async getTotalBorrows() : Promise<number> {
+      return 0;
+    }
+    async getCurrentTotalBorrows() : Promise<number> {
+      return 0;
+    }
+    async getTotalBorrowsUSD() : Promise<number> {
+      return 0;
+    }*/
+    // Available Liquidity
+    getAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getCurrentAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getAvailableLiquidityUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Supply Rate
+    getSupplyRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    // Token price getters
+    getTokenPriceFast(fallback = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+    getTokenPriceAccurate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = LendingVault;

package/lib/subgraph/index.d.ts

@@ -3,8 +3,9 @@ import LendingPool from "./LendingPool";
 import PriceHelper from "./PriceHelper";
 import SolidexHelper from "./SolidexHelper";
 import Account from "./Account";
-import { Address, Factory, FactoryIndex, LendingPoolIndex, Networks } from '../config/types';
+import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex, Networks } from '../config/types';
 import { LendingPoolData, TvlData, UserData, XimxData } from './types';
+import LendingVault from './LendingVault';
 export interface SubgraphCfg {
     network: Networks;
     chainId: number;
@@ -15,6 +16,7 @@ export default class Subgraph {
     chainId: number;
     whitelistedPairs?: FactoryIndex<Address[]>;
     lendingPools: LendingPoolIndex<LendingPool>;
+    lendingVaults: AddressIndex<LendingVault>;
     accounts: {
         [key in Address]?: Account;
     };
@@ -29,6 +31,7 @@ export default class Subgraph {
     constructor(cfg: SubgraphCfg);
     cleanCache(): void;
     getLendingPool(factory: Factory, pairAddress: Address): Promise<LendingPool>;
+    getLendingVault(vaultAddress: Address): Promise<LendingVault>;
     getAccount(account: Address): Account;
     /**
      * TODO

package/lib/subgraph/index.js

@@ -39,6 +39,7 @@ const initializer = __importStar(require("./initializer"));
 const PriceHelper_1 = __importDefault(require("./PriceHelper"));
 const SolidexHelper_1 = __importDefault(require("./SolidexHelper"));
 const Account_1 = __importDefault(require("./Account"));
+const LendingVault_1 = __importDefault(require("./LendingVault"));
 class Subgraph {
     constructor(cfg) {
         /**
@@ -90,6 +91,14 @@ class Subgraph {
             return this.lendingPools[factory][pairAddress];
         });
     }
+    getLendingVault(vaultAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //await this.getLendingVaultsData(); // TODO make sure that lending vaults are initialized
+            if (!this.lendingVaults[vaultAddress])
+                this.lendingVaults[vaultAddress] = new LendingVault_1.default(this, vaultAddress);
+            return this.lendingVaults[vaultAddress];
+        });
+    }
     getAccount(account) {
         if (!this.accounts[account])
             this.accounts[account] = new Account_1.default(this, account);

package/package.json

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