impermax-sdk 1.2.112 → 2.1.0

package/lib/offchain/offchain.js

@@ -41,23 +41,16 @@ const offchainAPRHelper_1 = __importDefault(require("./offchainAPRHelper"));
 const offchainSolidexHelper_1 = __importDefault(require("./offchainSolidexHelper"));
 const account_1 = __importDefault(require("./account"));
 const offchainEndpointManager_1 = __importDefault(require("./offchainEndpointManager"));
-const offchainLendingVault_1 = __importDefault(require("./offchainLendingVault"));
+const offchainVault_1 = __importDefault(require("./vault/offchainVault"));
 const configManager_1 = __importDefault(require("./configManager"));
+const chainId_1 = require("../config/chainId");
 class Offchain {
-    constructor(cfg) {
+    constructor(offchainMultichain, network) {
+        this.whitelistedPairs = {};
         this.getPriceHelper = () => this.priceHelper;
         this.getSolidexHelper = () => this.solidexHelper;
         this.getConfigManager = () => this.configManager;
         this.getAPRHelper = () => this.aprHelper;
-        /**
-         * TODO
-         * Potrei organizzare in:
-         * - lendingPoolData
-         * - usersData
-         * - tvlData
-         * - ximxData
-         * - lendingVaultData
-         */
         // TODO make everything protected
         // Fetchers
         this.apolloFetcher = initializer.apolloFetcher;
@@ -89,9 +82,13 @@ class Offchain {
         this.initializeWhitelistData = initializer.initializeWhitelistData;
         this.getWhitelistData = initializer.getWhitelistData;
         this.getWhitelistState = initializer.getWhitelistState;
-        this.network = cfg.network;
-        this.chainId = cfg.chainId;
-        this.whitelistedPairs = cfg.whitelistedPairs ? cfg.whitelistedPairs : {};
+        // TODO fix conflicting lines (commented)
+        //this.network = cfg.network;
+        //this.chainId = cfg.chainId;
+        //this.whitelistedPairs = cfg.whitelistedPairs ? cfg.whitelistedPairs : {};
+        this.offchainMultichain = offchainMultichain;
+        this.network = network;
+        this.chainId = chainId_1.CHAIN_IDS[network];
         this.priceHelper = new offchainPriceHelper_1.default(this);
         this.solidexHelper = new offchainSolidexHelper_1.default(this);
         this.configManager = new configManager_1.default(this);
@@ -123,11 +120,11 @@ class Offchain {
     getLendingVault(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.getLendingVaultsData(); // make sure that lending vaults are initialized
-            if (!this.lendingVaults)
-                this.lendingVaults = {};
-            if (!this.lendingVaults[vaultAddress])
-                this.lendingVaults[vaultAddress] = new offchainLendingVault_1.default(this, vaultAddress);
-            return this.lendingVaults[vaultAddress];
+            if (!this.vaults)
+                this.vaults = {};
+            if (!this.vaults[vaultAddress])
+                this.vaults[vaultAddress] = new offchainVault_1.default(this, vaultAddress);
+            return this.vaults[vaultAddress];
         });
     }
     getAccount(accountAddress) {

package/lib/offchain/offchainAPRHelper.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../config/types");
-// Map of OUR chains to the chain names used by llama in their `poolsOld`
 const LlamaChains = {
     [types_1.Networks.Ropsten]: "ropsten",
     [types_1.Networks.Mainnet]: "ethereum",

package/lib/offchain/offchainInitializer.d.ts

@@ -2,7 +2,7 @@ import { ApolloQueryResult } from "apollo-client";
 import { DocumentNode } from "graphql";
 import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex, WhitelistState } from '../config/types';
 import { Amms } from '../config/amms';
-import { LendingPoolData, LendingVaultData, LendingVaultPosition, RawUserData, TvlData, UserData, WhitelistData, XimxData } from './offchainTypes';
+import { LendingPoolData, LendingVaultData, VaultPosition, RawUserData, TvlData, UserData, WhitelistData, XimxData } from './offchainTypes';
 import Offchain from './offchain';
 export declare function apolloFetcher(subgraphUrl: string, query: DocumentNode): Promise<ApolloQueryResult<any>>;
 export declare function fetchBlockByTimestamp(this: Offchain, timestamp: number): Promise<number | null>;
@@ -47,6 +47,6 @@ export declare function getWhitelistState(this: Offchain, factory: Factory, pair
 /**
  * User Data
  */
-export declare function fetchLendingVaultsUserData(this: Offchain, account: Address): Promise<LendingVaultPosition[] | null>;
-export declare function initializeLendingVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<LendingVaultPosition> | null>;
-export declare function getLendingVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<LendingVaultPosition> | null>;
+export declare function fetchLendingVaultsUserData(this: Offchain, account: Address): Promise<VaultPosition[] | null>;
+export declare function initializeLendingVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<VaultPosition> | null>;
+export declare function getLendingVaultsUserData(this: Offchain, account: Address): Promise<AddressIndex<VaultPosition> | null>;

package/lib/offchain/offchainInitializer.js

@@ -21,7 +21,7 @@ const lendingPool_1 = __importDefault(require("./lendingPool"));
 const subgraphs_1 = require("../config/subgraphs");
 const types_1 = require("../config/types");
 const amms_1 = require("../config/amms");
-const offchainLendingVault_1 = __importDefault(require("./offchainLendingVault"));
+const offchainVault_1 = __importDefault(require("./vault/offchainVault"));
 const impermax_factories_1 = require("../config/contracts/impermax-factories");
 const SECONDS_IN_YEAR = 60 * 60 * 24 * 365;
 function apolloFetcher(subgraphUrl, query) {
@@ -674,10 +674,10 @@ function initializeLendingVaultsData() {
             lendingVaultsData[lendingVault.id] = lendingVault;
         }
         // Initialize OffchainLendingVault objects
-        this.lendingVaults = {};
+        this.vaults = {};
         for (const lendingVault of lendingVaults) {
-            this.lendingVaults[lendingVault.id] =
-                new offchainLendingVault_1.default(this, lendingVault.id);
+            this.vaults[lendingVault.id] =
+                new offchainVault_1.default(this, lendingVault.id);
         }
         return lendingVaultsData;
     });

package/lib/offchain/offchainMultichain.d.ts

@@ -0,0 +1,50 @@
+import { NetworkIndex, Networks } from '../config/types';
+import Offchain from "./offchain";
+import OffchainVault, { VaultType } from "./vault/offchainVault";
+import { Amms } from "../config/amms";
+import { Farms } from "../config/farms";
+import { RiskLevel } from "./vault/offchainLendingVault";
+import OffchainLendingPool from "./lendingPool";
+import { LendingPoolVersion } from "./lendingPool/offchainLendingPool";
+export declare enum VaultOrderBy {
+    TVL = 0,
+    APR = 1,
+    DEPOSITED = 2
+}
+export interface VaultListParams {
+    networks?: Array<Networks>;
+    type?: VaultType;
+    searchInput?: string;
+    riskLevel?: RiskLevel;
+    amm?: Array<Amms>;
+    farm?: Array<Farms>;
+    deprecated?: boolean;
+    stable?: boolean;
+    highTvl?: boolean;
+}
+export declare enum LendingPoolListOrderBy {
+    TVL = 0,
+    TOTAL_SUPPLY = 1,
+    TOTAL_BORROW = 2,
+    SUPPLY_APR = 3,
+    LEVERAGED_APR = 4
+}
+export interface LendingPoolListParams {
+    networks?: Array<Networks>;
+    version?: LendingPoolVersion;
+    searchInput?: string;
+    amm?: Array<Amms>;
+    farm?: Array<Farms>;
+    deprecated?: boolean;
+    stable?: boolean;
+    highTvl?: boolean;
+}
+export default class OffchainMultichain {
+    #private;
+    protected offchains: NetworkIndex<Offchain>;
+    private constructor();
+    static get instance(): OffchainMultichain;
+    getOffchain(network: Networks): Offchain;
+    getVaultList(params?: VaultListParams, orderBy?: VaultOrderBy): Promise<Array<OffchainVault>>;
+    getLendingPoolList(params?: LendingPoolListParams, orderBy?: LendingPoolListOrderBy): Promise<Array<OffchainLendingPool>>;
+}

package/lib/offchain/offchainMultichain.js

@@ -0,0 +1,75 @@
+"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());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _OffchainMultichain_instance;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPoolListOrderBy = exports.VaultOrderBy = void 0;
+const offchain_1 = __importDefault(require("./offchain"));
+var VaultOrderBy;
+(function (VaultOrderBy) {
+    VaultOrderBy[VaultOrderBy["TVL"] = 0] = "TVL";
+    VaultOrderBy[VaultOrderBy["APR"] = 1] = "APR";
+    VaultOrderBy[VaultOrderBy["DEPOSITED"] = 2] = "DEPOSITED";
+})(VaultOrderBy = exports.VaultOrderBy || (exports.VaultOrderBy = {}));
+var LendingPoolListOrderBy;
+(function (LendingPoolListOrderBy) {
+    LendingPoolListOrderBy[LendingPoolListOrderBy["TVL"] = 0] = "TVL";
+    LendingPoolListOrderBy[LendingPoolListOrderBy["TOTAL_SUPPLY"] = 1] = "TOTAL_SUPPLY";
+    LendingPoolListOrderBy[LendingPoolListOrderBy["TOTAL_BORROW"] = 2] = "TOTAL_BORROW";
+    LendingPoolListOrderBy[LendingPoolListOrderBy["SUPPLY_APR"] = 3] = "SUPPLY_APR";
+    LendingPoolListOrderBy[LendingPoolListOrderBy["LEVERAGED_APR"] = 4] = "LEVERAGED_APR";
+})(LendingPoolListOrderBy = exports.LendingPoolListOrderBy || (exports.LendingPoolListOrderBy = {}));
+// singleton class
+class OffchainMultichain {
+    constructor() {
+        // Initialize empty
+        this.offchains = {};
+    }
+    static get instance() {
+        if (!__classPrivateFieldGet(OffchainMultichain, _a, "f", _OffchainMultichain_instance)) {
+            __classPrivateFieldSet(OffchainMultichain, _a, new OffchainMultichain(), "f", _OffchainMultichain_instance);
+        }
+        return __classPrivateFieldGet(OffchainMultichain, _a, "f", _OffchainMultichain_instance);
+    }
+    getOffchain(network) {
+        if (!this.offchains[network])
+            this.offchains[network] = new offchain_1.default(this, network);
+        return this.offchains[network];
+    }
+    getVaultList(params = {}, orderBy = VaultOrderBy.TVL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO FILL WITH FAKE DATA
+            return [];
+        });
+    }
+    getLendingPoolList(params = {}, orderBy = LendingPoolListOrderBy.TVL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO FILL WITH FAKE DATA
+            return [];
+        });
+    }
+}
+exports.default = OffchainMultichain;
+_a = OffchainMultichain;
+_OffchainMultichain_instance = { value: void 0 };

package/lib/offchain/offchainTypes.d.ts

@@ -166,7 +166,7 @@ export interface LendingVaultData extends PoolTokenData {
     availableLiquidity: string;
     lastUpdate: string;
 }
-export interface LendingVaultPosition {
+export interface VaultPosition {
     tokenBalance: string;
     lastExchangeRate: string;
     cumulativeEarnings: string;

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

@@ -0,0 +1,6 @@
+import OffchainLeveragedVault from './offchainLeveragedVault';
+import OffchainLendingVault from './offchainLendingVault';
+import OffchainHedgedVault from './offchainHedgedVault';
+import OffchainVault from './offchainVault';
+export { OffchainLeveragedVault, OffchainLendingVault, OffchainHedgedVault, };
+export default OffchainVault;

package/lib/offchain/vault/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffchainHedgedVault = exports.OffchainLendingVault = exports.OffchainLeveragedVault = void 0;
+const offchainLeveragedVault_1 = __importDefault(require("./offchainLeveragedVault"));
+exports.OffchainLeveragedVault = offchainLeveragedVault_1.default;
+const offchainLendingVault_1 = __importDefault(require("./offchainLendingVault"));
+exports.OffchainLendingVault = offchainLendingVault_1.default;
+const offchainHedgedVault_1 = __importDefault(require("./offchainHedgedVault"));
+exports.OffchainHedgedVault = offchainHedgedVault_1.default;
+const offchainVault_1 = __importDefault(require("./offchainVault"));
+exports.default = offchainVault_1.default;

package/lib/offchain/vault/offchainHedgedVault.d.ts

@@ -0,0 +1,9 @@
+import Offchain from "../index";
+import { Address } from '../../config/types';
+import OffchainVault from "./offchainVault";
+import OffchainLendingPool from "../lendingPool";
+export default class OffchainHedgedVaultVault extends OffchainVault {
+    constructor(offchain: Offchain, vaultAddress: Address);
+    getLeverage(): Promise<number>;
+    getPair(): Promise<OffchainLendingPool>;
+}

package/lib/offchain/vault/offchainHedgedVault.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../config/types");
+const offchainVault_1 = __importStar(require("./offchainVault"));
+const lendingPool_1 = __importDefault(require("../lendingPool"));
+class OffchainHedgedVaultVault extends offchainVault_1.default {
+    constructor(offchain, vaultAddress) {
+        super(offchain, vaultAddress);
+        this.vaultType = offchainVault_1.VaultType.HEDGED;
+    }
+    getLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getPair() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new lendingPool_1.default(this.getOffchain(), types_1.Factory.V2V2, "0x");
+        });
+    }
+}
+exports.default = OffchainHedgedVaultVault;

package/lib/offchain/vault/offchainLendingVault.d.ts

@@ -0,0 +1,16 @@
+import Offchain from "../index";
+import { Address } from '../../config/types';
+import OffchainVault from "./offchainVault";
+import { OffchainBorrowable } from "../lendingPool";
+export declare enum RiskLevel {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2
+}
+export default class OffchainLendingVault extends OffchainVault {
+    constructor(offchain: Offchain, vaultAddress: Address);
+    getRiskLevel(): Promise<RiskLevel>;
+    getAvailableLiquidity(): Promise<number>;
+    getAvailableLiquidityUSD(): Promise<number>;
+    getBorrowables(): Promise<Array<OffchainBorrowable>>;
+}

package/lib/offchain/vault/offchainLendingVault.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+exports.RiskLevel = void 0;
+const offchainVault_1 = __importStar(require("./offchainVault"));
+var RiskLevel;
+(function (RiskLevel) {
+    RiskLevel[RiskLevel["LOW"] = 0] = "LOW";
+    RiskLevel[RiskLevel["MEDIUM"] = 1] = "MEDIUM";
+    RiskLevel[RiskLevel["HIGH"] = 2] = "HIGH";
+})(RiskLevel = exports.RiskLevel || (exports.RiskLevel = {}));
+class OffchainLendingVault extends offchainVault_1.default {
+    constructor(offchain, vaultAddress) {
+        super(offchain, vaultAddress);
+        this.vaultType = offchainVault_1.VaultType.LENDING;
+    }
+    getRiskLevel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RiskLevel.MEDIUM;
+        });
+    }
+    // Available Liquidity
+    getAvailableLiquidity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Math.min(yield this.getPoolTokenParamFloat("availableLiquidity"), yield this.getVaultSupply());
+        });
+    }
+    getAvailableLiquidityUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableLiquidity = yield this.getAvailableLiquidity();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return availableLiquidity * tokenPrice;
+        });
+    }
+    // Borrowables
+    getBorrowables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+}
+exports.default = OffchainLendingVault;

package/lib/offchain/vault/offchainLeveragedVault.d.ts

@@ -0,0 +1,9 @@
+import Offchain from "../index";
+import { Address } from '../../config/types';
+import OffchainVault from "./offchainVault";
+import OffchainLendingPool from "../lendingPool";
+export default class OffchainLeveragedVault extends OffchainVault {
+    constructor(offchain: Offchain, vaultAddress: Address);
+    getLeverage(): Promise<number>;
+    getPair(): Promise<OffchainLendingPool>;
+}

package/lib/offchain/vault/offchainLeveragedVault.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../config/types");
+const offchainVault_1 = __importStar(require("./offchainVault"));
+const lendingPool_1 = __importDefault(require("../lendingPool"));
+class OffchainLeveragedVault extends offchainVault_1.default {
+    constructor(offchain, vaultAddress) {
+        super(offchain, vaultAddress);
+        this.vaultType = offchainVault_1.VaultType.LEVERAGED;
+    }
+    getLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getPair() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new lendingPool_1.default(this.getOffchain(), types_1.Factory.V2V2, "0x");
+        });
+    }
+}
+exports.default = OffchainLeveragedVault;

package/lib/offchain/{offchainLendingVault.d.ts → vault/offchainVault.d.ts}

@@ -1,13 +1,20 @@
-import Offchain from "./index";
-import { Address } from '../config/types';
-import OffchainPoolToken from './offchainPoolToken';
-import { PoolTokenData } from './offchainTypes';
-export default class OffchainLendingVault extends OffchainPoolToken {
+import Offchain from "../index";
+import { Address } from '../../config/types';
+import OffchainPoolToken from '../offchainPoolToken';
+import { PoolTokenData } from '../offchainTypes';
+export declare enum VaultType {
+    LENDING = 0,
+    HEDGED = 1,
+    LEVERAGED = 2
+}
+export default class OffchainVault extends OffchainPoolToken {
     private readonly offchain;
     private readonly vaultAddress;
+    protected vaultType: VaultType;
     constructor(offchain: Offchain, vaultAddress: Address);
     getOffchain: () => Offchain;
     getVaultAddress: () => string;
+    getVaultType: () => VaultType;
     getPoolTokenData(): Promise<PoolTokenData>;
     private getTotalSupply;
     private getLastUpdate;
@@ -18,8 +25,10 @@ export default class OffchainLendingVault extends OffchainPoolToken {
     getReserveFactor(): Promise<number>;
     getSupplyRate(): Promise<number>;
     getSupplyAPR(): Promise<number>;
-    getAvailableLiquidity(): Promise<number>;
-    getAvailableLiquidityUSD(): Promise<number>;
     getTokenPriceFast(fallback?: boolean): Promise<number>;
     getTokenPriceAccurate(): Promise<number>;
+    isDeprecated(): Promise<boolean>;
+    isBlacklisted(): Promise<boolean>;
+    isStable(): Promise<boolean>;
+    isHighTVL(): Promise<boolean>;
 }

package/lib/offchain/{offchainLendingVault.js → vault/offchainVault.js}

@@ -12,13 +12,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const offchainPoolToken_1 = __importDefault(require("./offchainPoolToken"));
-const utils_1 = require("../utils");
-class OffchainLendingVault extends offchainPoolToken_1.default {
+exports.VaultType = void 0;
+const offchainPoolToken_1 = __importDefault(require("../offchainPoolToken"));
+const utils_1 = require("../../utils");
+var VaultType;
+(function (VaultType) {
+    VaultType[VaultType["LENDING"] = 0] = "LENDING";
+    VaultType[VaultType["HEDGED"] = 1] = "HEDGED";
+    VaultType[VaultType["LEVERAGED"] = 2] = "LEVERAGED";
+})(VaultType = exports.VaultType || (exports.VaultType = {}));
+class OffchainVault extends offchainPoolToken_1.default {
     constructor(offchain, vaultAddress) {
         super();
         this.getOffchain = () => this.offchain;
         this.getVaultAddress = () => this.vaultAddress;
+        this.getVaultType = () => this.vaultType;
         this.offchain = offchain;
         this.vaultAddress = vaultAddress;
     }
@@ -85,19 +93,6 @@ class OffchainLendingVault extends offchainPoolToken_1.default {
             return (0, utils_1.toAPR)(supplyRate);
         });
     }
-    // Available Liquidity
-    getAvailableLiquidity() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Math.min(yield this.getPoolTokenParamFloat("availableLiquidity"), yield this.getVaultSupply());
-        });
-    }
-    getAvailableLiquidityUSD() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const availableLiquidity = yield this.getAvailableLiquidity();
-            const tokenPrice = yield this.getTokenPriceFast();
-            return availableLiquidity * tokenPrice;
-        });
-    }
     // Token price getters
     getTokenPriceFast(fallback = true) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -110,5 +105,26 @@ class OffchainLendingVault extends offchainPoolToken_1.default {
             return this.getOffchain().getPriceHelper().getDebankTokenPrice(tokenAddress);
         });
     }
+    // Flags
+    isDeprecated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    isBlacklisted() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    isStable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    isHighTVL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
 }
-exports.default = OffchainLendingVault;
+exports.default = OffchainVault;

package/lib/onchain/account/lendingPool/index.d.ts

@@ -1,5 +1,12 @@
+import * as nftlp from './nftlp';
 import OnchainAccountBorrowable from "./onchainAccountBorrowable";
+import OnchainAccountBorrowableV2 from "./onchainAccountBorrowableV2";
+import OnchainAccountBorrowableV3 from "./onchainAccountBorrowableV3";
 import OnchainAccountCollateral from "./onchainAccountCollateral";
+import OnchainAccountCollateralV2 from "./onchainAccountCollateralV2";
+import OnchainAccountCollateralV3 from "./onchainAccountCollateralV3";
 import OnchainAccountLendingPool from './onchainAccountLendingPool';
-export { OnchainAccountBorrowable, OnchainAccountCollateral, };
+import OnchainAccountLendingPoolV2 from "./onchainAccountLendingPoolV2";
+import OnchainAccountLendingPoolV3 from "./onchainAccountLendingPoolV3";
+export { nftlp, OnchainAccountBorrowable, OnchainAccountCollateral, OnchainAccountLendingPoolV2, OnchainAccountBorrowableV2, OnchainAccountCollateralV2, OnchainAccountLendingPoolV3, OnchainAccountBorrowableV3, OnchainAccountCollateralV3, };
 export default OnchainAccountLendingPool;