impermax-sdk 1.2.112 → 2.1.0

package/lib/offchain/account/lendingPool/offchainLeveragedPosition.d.ts

@@ -0,0 +1,25 @@
+import OffchainAccountLendingPool from "./index";
+export default class OffchainLeveragedPosition {
+    private readonly lendingPool;
+    private readonly TOKEN_ID;
+    constructor(lendingPool: OffchainAccountLendingPool, TOKEN_ID: number);
+    isLiquidated(): Promise<boolean>;
+    getLeverage(): Promise<number>;
+    getAPR(): Promise<number>;
+    getDepositedA(): Promise<number>;
+    getDepositedB(): Promise<number>;
+    getDepositedAUSD(): Promise<number>;
+    getDepositedBUSD(): Promise<number>;
+    getBorrowedA(): Promise<number>;
+    getBorrowedB(): Promise<number>;
+    getBorrowedAUSD(): Promise<number>;
+    getBorrowedBUSD(): Promise<number>;
+    getExposureA(): Promise<number>;
+    getExposureB(): Promise<number>;
+    getExposureAUSD(): Promise<number>;
+    getExposureBUSD(): Promise<number>;
+    getValueUSD(): Promise<number>;
+    getLiquidationRange(): Promise<[number, number]>;
+    getFee(): Promise<number>;
+    getPriceRange(): Promise<[number, number]>;
+}

package/lib/offchain/account/lendingPool/offchainLeveragedPosition.js

@@ -0,0 +1,116 @@
+"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 OffchainLeveragedPosition {
+    constructor(lendingPool, TOKEN_ID) {
+        this.lendingPool = lendingPool;
+        this.TOKEN_ID = TOKEN_ID;
+    }
+    // TODO
+    // Common properties
+    isLiquidated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    getLeverage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getDepositedA() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getDepositedB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getDepositedAUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getDepositedBUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getBorrowedA() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getBorrowedB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getBorrowedAUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getBorrowedBUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    getExposureA() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getDepositedA()) - (yield this.getBorrowedA());
+        });
+    }
+    getExposureB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getDepositedB()) - (yield this.getBorrowedB());
+        });
+    }
+    getExposureAUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getDepositedAUSD()) - (yield this.getBorrowedAUSD());
+        });
+    }
+    getExposureBUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getDepositedBUSD()) - (yield this.getBorrowedBUSD());
+        });
+    }
+    getValueUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getExposureAUSD()) + (yield this.getExposureBUSD());
+        });
+    }
+    getLiquidationRange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [1, 10];
+        });
+    }
+    // V3 properties
+    getFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0.001;
+        });
+    }
+    getPriceRange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [1, 10];
+        });
+    }
+}
+exports.default = OffchainLeveragedPosition;

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

@@ -1,22 +1,22 @@
 import Offchain from '../index';
 import { Address, AddressIndex, Factory, FactoryIndex } from '../../config/types';
 import OffchainAccountLendingPool from './lendingPool';
-import OffchainAccountLendingVault from './offchainAccountLendingVault';
-import { LendingVaultPosition, UserData } from '../offchainTypes';
+import OffchainAccountVault from './vault/offchainAccountVault';
+import { VaultPosition, UserData } from '../offchainTypes';
 export default class OffchainAccount {
     private readonly offchain;
     private readonly accountAddress;
     private lendingPools;
-    private lendingVaults;
+    private vaults;
     constructor(offchain: Offchain, account: Address);
-    getOnchain: () => Offchain;
+    getOffchain: () => Offchain;
     getAccountAddress: () => string;
     private initializeLendingPool;
     getLendingPool(factory: Factory, pair: Address): Promise<OffchainAccountLendingPool>;
     private initializeLendingVault;
-    getLendingVault(vaultAddress: Address): Promise<OffchainAccountLendingVault>;
+    getLendingVault(vaultAddress: Address): Promise<OffchainAccountVault>;
     getUserData(): Promise<FactoryIndex<UserData> | null>;
-    getLendingVaultsUserData(): Promise<AddressIndex<LendingVaultPosition> | null>;
+    getLendingVaultsUserData(): Promise<AddressIndex<VaultPosition> | null>;
     getBorrowPositions(): Promise<FactoryIndex<Address[]>>;
     getSupplyPositions(): Promise<FactoryIndex<Address[]>>;
     getLendingVaultsSuppliedUSD(): Promise<number>;

package/lib/offchain/account/offchainAccount.js

@@ -13,15 +13,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const lendingPool_1 = __importDefault(require("./lendingPool"));
-const offchainAccountLendingVault_1 = __importDefault(require("./offchainAccountLendingVault"));
+const offchainAccountVault_1 = __importDefault(require("./vault/offchainAccountVault"));
 class OffchainAccount {
     constructor(offchain, account) {
-        this.getOnchain = () => this.offchain;
+        this.getOffchain = () => this.offchain;
         this.getAccountAddress = () => this.accountAddress;
         this.offchain = offchain;
         this.accountAddress = account;
         this.lendingPools = {};
-        this.lendingVaults = {};
+        this.vaults = {};
     }
     initializeLendingPool(factory, pair) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -42,14 +42,14 @@ class OffchainAccount {
     initializeLendingVault(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             const lendingVault = yield this.offchain.getLendingVault(vaultAddress);
-            return new offchainAccountLendingVault_1.default(this, lendingVault);
+            return new offchainAccountVault_1.default(this, lendingVault);
         });
     }
     getLendingVault(vaultAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.lendingVaults[vaultAddress])
-                this.lendingVaults[vaultAddress] = this.initializeLendingVault(vaultAddress);
-            return this.lendingVaults[vaultAddress];
+            if (!this.vaults[vaultAddress])
+                this.vaults[vaultAddress] = this.initializeLendingVault(vaultAddress);
+            return this.vaults[vaultAddress];
         });
     }
     getUserData() {

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

@@ -0,0 +1,34 @@
+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";
+export declare enum LeveragedPositionsOrderBy {
+    TVL = 0
+}
+export interface LeveragedPositionsParams {
+}
+export declare enum SupplyPositionsOrderBy {
+    TVL = 0
+}
+export interface SupplyPositionsParams {
+}
+export declare enum VaultPositionsOrderBy {
+    TVL = 0
+}
+export interface VaultPositionsParams {
+}
+export default class OffchainMultichainAccount {
+    readonly offchainMultichain: OffchainMultichain;
+    readonly accountAddress: Address;
+    constructor(offchainMultichain: OffchainMultichain, account: Address);
+    getOffchainMultichain: () => OffchainMultichain;
+    getAccountAddress: () => string;
+    getOffchainAccount(network: Networks): OffchainAccount;
+    getLeveragedPositions(params?: LeveragedPositionsParams, orderBy?: LeveragedPositionsOrderBy): Promise<Array<OffchainLeveragedPosition>>;
+    getSupplyPositions(params?: SupplyPositionsParams, orderBy?: SupplyPositionsOrderBy): Promise<Array<OffchainAccountBorrowable>>;
+    getVaultPositions(params?: VaultPositionsParams, orderBy?: VaultPositionsOrderBy): Promise<Array<OffchainAccountVault>>;
+    getTotalBalanceUSD(): Promise<number>;
+    getNetAPR(): Promise<number>;
+}

package/lib/offchain/account/offchainMultichainAccount.js

@@ -0,0 +1,66 @@
+"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 });
+exports.VaultPositionsOrderBy = exports.SupplyPositionsOrderBy = exports.LeveragedPositionsOrderBy = void 0;
+var LeveragedPositionsOrderBy;
+(function (LeveragedPositionsOrderBy) {
+    LeveragedPositionsOrderBy[LeveragedPositionsOrderBy["TVL"] = 0] = "TVL";
+})(LeveragedPositionsOrderBy = exports.LeveragedPositionsOrderBy || (exports.LeveragedPositionsOrderBy = {}));
+var SupplyPositionsOrderBy;
+(function (SupplyPositionsOrderBy) {
+    SupplyPositionsOrderBy[SupplyPositionsOrderBy["TVL"] = 0] = "TVL";
+})(SupplyPositionsOrderBy = exports.SupplyPositionsOrderBy || (exports.SupplyPositionsOrderBy = {}));
+var VaultPositionsOrderBy;
+(function (VaultPositionsOrderBy) {
+    VaultPositionsOrderBy[VaultPositionsOrderBy["TVL"] = 0] = "TVL";
+})(VaultPositionsOrderBy = exports.VaultPositionsOrderBy || (exports.VaultPositionsOrderBy = {}));
+class OffchainMultichainAccount {
+    constructor(offchainMultichain, account) {
+        this.getOffchainMultichain = () => this.offchainMultichain;
+        this.getAccountAddress = () => this.accountAddress;
+        this.offchainMultichain = offchainMultichain;
+        this.accountAddress = account;
+    }
+    getOffchainAccount(network) {
+        return this.offchainMultichain.getOffchain(network).getAccount(this.accountAddress);
+    }
+    // Positions
+    getLeveragedPositions(params = {}, orderBy = LeveragedPositionsOrderBy.TVL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO FILL WITH FAKE DATA
+            return [];
+        });
+    }
+    getSupplyPositions(params = {}, orderBy = SupplyPositionsOrderBy.TVL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO FILL WITH FAKE DATA
+            return [];
+        });
+    }
+    getVaultPositions(params = {}, orderBy = VaultPositionsOrderBy.TVL) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO FILL WITH FAKE DATA
+            return [];
+        });
+    }
+    // Account stats
+    getTotalBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 10;
+        });
+    }
+    getNetAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+}
+exports.default = OffchainMultichainAccount;

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

@@ -0,0 +1,3 @@
+import OffchainAccountVault from './offchainAccountVault';
+export {};
+export default OffchainAccountVault;

package/lib/offchain/account/vault/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const offchainAccountVault_1 = __importDefault(require("./offchainAccountVault"));
+exports.default = offchainAccountVault_1.default;

package/lib/offchain/account/vault/offchainAccountVault.d.ts

@@ -0,0 +1,16 @@
+import OffchainAccount from '../index';
+import OffchainAccountPoolToken from '../offchainAccountPoolToken';
+import OffchainVault from '../../vault/offchainVault';
+import { VaultPosition } from '../../offchainTypes';
+export default class OffchainAccountVault extends OffchainAccountPoolToken {
+    private readonly account;
+    protected readonly poolToken: OffchainVault;
+    constructor(account: OffchainAccount, vault: OffchainVault);
+    getAccount: () => OffchainAccount;
+    getPoolToken: () => OffchainVault;
+    private getVaultAddress;
+    getVaultPosition(): Promise<VaultPosition | undefined>;
+    getAmount(): Promise<number>;
+    getEarnings(): Promise<number>;
+    getEarningsUSD(): Promise<number>;
+}

package/lib/offchain/account/{offchainAccountLendingVault.js → vault/offchainAccountVault.js}

@@ -12,17 +12,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const offchainAccountPoolToken_1 = __importDefault(require("./offchainAccountPoolToken"));
-class OffchainAccountLendingVault extends offchainAccountPoolToken_1.default {
-    constructor(account, lendingVault) {
+const offchainAccountPoolToken_1 = __importDefault(require("../offchainAccountPoolToken"));
+class OffchainAccountVault extends offchainAccountPoolToken_1.default {
+    constructor(account, vault) {
         super();
         this.getAccount = () => this.account;
         this.getPoolToken = () => this.poolToken;
         this.getVaultAddress = () => this.poolToken.getVaultAddress();
         this.account = account;
-        this.poolToken = lendingVault;
+        this.poolToken = vault;
     }
-    getLendingVaultPosition() {
+    getVaultPosition() {
         return __awaiter(this, void 0, void 0, function* () {
             const lendingVaultsUserData = yield this.account.getLendingVaultsUserData();
             if (!lendingVaultsUserData)
@@ -32,23 +32,23 @@ class OffchainAccountLendingVault extends offchainAccountPoolToken_1.default {
     }
     getAmount() {
         return __awaiter(this, void 0, void 0, function* () {
-            const lendingVaultPosition = yield this.getLendingVaultPosition();
-            if (!lendingVaultPosition)
+            const vaultPosition = yield this.getVaultPosition();
+            if (!vaultPosition)
                 return 0;
             const exchangeRate = yield this.poolToken.getCurrentExchangeRate();
-            const tokenBalance = parseFloat(lendingVaultPosition.tokenBalance);
+            const tokenBalance = parseFloat(vaultPosition.tokenBalance);
             return tokenBalance * exchangeRate;
         });
     }
     getEarnings() {
         return __awaiter(this, void 0, void 0, function* () {
-            const lendingVaultPosition = yield this.getLendingVaultPosition();
-            if (!lendingVaultPosition)
+            const vaultPosition = yield this.getVaultPosition();
+            if (!vaultPosition)
                 return 0;
             const exchangeRate = yield this.poolToken.getCurrentExchangeRate();
-            const tokenBalance = parseFloat(lendingVaultPosition.tokenBalance);
-            const cumulativeEarnings = parseFloat(lendingVaultPosition.cumulativeEarnings);
-            const lastExchangeRate = parseFloat(lendingVaultPosition.lastExchangeRate);
+            const tokenBalance = parseFloat(vaultPosition.tokenBalance);
+            const cumulativeEarnings = parseFloat(vaultPosition.cumulativeEarnings);
+            const lastExchangeRate = parseFloat(vaultPosition.lastExchangeRate);
             const newEarnings = (exchangeRate - lastExchangeRate) * tokenBalance;
             return cumulativeEarnings + newEarnings;
         });
@@ -61,4 +61,4 @@ class OffchainAccountLendingVault extends offchainAccountPoolToken_1.default {
         });
     }
 }
-exports.default = OffchainAccountLendingVault;
+exports.default = OffchainAccountVault;

package/lib/offchain/index.d.ts

@@ -6,9 +6,10 @@ import OffchainSolidexHelper from "./offchainSolidexHelper";
 import OffchainAccount from "./account";
 import * as account from "./account";
 import * as configManager from "./configManager";
-import OffchainLendingVault from './offchainLendingVault';
+import * as vault from "./vault";
 import OffchainPoolToken from "./offchainPoolToken";
 import Offchain from './offchain';
 import OffchainConfigManager from "./configManager";
-export { account, lendingPool, configManager, OffchainAccount, OffchainLendingPool, OffchainConfigManager, OffchainPoolToken, OffchainLendingVault, OffchainSolidexHelper, OffchainPriceHelper, OffchainAPRHelper };
+import OffchainMultichain from "./offchainMultichain";
+export { account, lendingPool, vault, configManager, OffchainMultichain, OffchainAccount, OffchainLendingPool, OffchainConfigManager, OffchainPoolToken, OffchainSolidexHelper, OffchainPriceHelper, OffchainAPRHelper };
 export default Offchain;

package/lib/offchain/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OffchainAPRHelper = exports.OffchainPriceHelper = exports.OffchainSolidexHelper = exports.OffchainLendingVault = exports.OffchainPoolToken = exports.OffchainConfigManager = exports.OffchainLendingPool = exports.OffchainAccount = exports.configManager = exports.lendingPool = exports.account = void 0;
+exports.OffchainAPRHelper = exports.OffchainPriceHelper = exports.OffchainSolidexHelper = exports.OffchainPoolToken = exports.OffchainConfigManager = exports.OffchainLendingPool = exports.OffchainAccount = exports.OffchainMultichain = exports.configManager = exports.vault = exports.lendingPool = exports.account = void 0;
 const lendingPool_1 = __importDefault(require("./lendingPool"));
 exports.OffchainLendingPool = lendingPool_1.default;
 const lendingPool = __importStar(require("./lendingPool"));
@@ -43,11 +43,13 @@ const account = __importStar(require("./account"));
 exports.account = account;
 const configManager = __importStar(require("./configManager"));
 exports.configManager = configManager;
-const offchainLendingVault_1 = __importDefault(require("./offchainLendingVault"));
-exports.OffchainLendingVault = offchainLendingVault_1.default;
+const vault = __importStar(require("./vault"));
+exports.vault = vault;
 const offchainPoolToken_1 = __importDefault(require("./offchainPoolToken"));
 exports.OffchainPoolToken = offchainPoolToken_1.default;
 const offchain_1 = __importDefault(require("./offchain"));
 const configManager_1 = __importDefault(require("./configManager"));
 exports.OffchainConfigManager = configManager_1.default;
+const offchainMultichain_1 = __importDefault(require("./offchainMultichain"));
+exports.OffchainMultichain = offchainMultichain_1.default;
 exports.default = offchain_1.default;

package/lib/offchain/lendingPool/offchainCollateral.d.ts

@@ -14,6 +14,7 @@ export default class OffchainCollateral extends OffchainPoolToken {
     getSymbol(): Promise<string>;
     getDecimals(): Promise<number>;
     getUnderlyingAddress(): Promise<Address>;
+    getTWAP(): Promise<number>;
     getTokenPriceFast(fallback?: boolean): Promise<number>;
     getTokenPriceAccurate(): Promise<number>;
 }

package/lib/offchain/lendingPool/offchainCollateral.js

@@ -54,6 +54,12 @@ class OffchainCollateral extends offchainPoolToken_1.default {
             return this.lendingPool.getPairAddress();
         });
     }
+    getTWAP() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO
+            return 1;
+        });
+    }
     // Token price getters
     getTokenPriceFast(fallback = true) {
         const _super = Object.create(null, {

package/lib/offchain/lendingPool/offchainLendingPool.d.ts

@@ -1,11 +1,16 @@
 import Offchain from '../index';
-import { Address, Factory, PoolTokenType, WhitelistState } from '../../config/types';
+import { Address, Borrowable, Factory, PoolTokenType, WhitelistState } from '../../config/types';
 import OffchainCollateral from './offchainCollateral';
 import OffchainBorrowable from './offchainBorrowable';
 import OffchainPoolToken from '../offchainPoolToken';
 import { LendingPoolData, LendingPoolPastData } from '../offchainTypes';
 import { Farms } from '../../config/farms';
 import { Amms } from '../../config/amms';
+export declare enum LendingPoolVersion {
+    V1 = 0,
+    V2 = 1,
+    V3 = 2
+}
 export default class OffchainLendingPool {
     private readonly offchain;
     private readonly factory;
@@ -16,6 +21,7 @@ export default class OffchainLendingPool {
     getFactory: () => Factory;
     getPairAddress: () => string;
     getPoolToken(poolTokenType: PoolTokenType): OffchainPoolToken;
+    getBorrowable: (borrowable: Borrowable) => OffchainBorrowable;
     getBorrowableA: () => OffchainBorrowable;
     getBorrowableB: () => OffchainBorrowable;
     getCollateral: () => OffchainCollateral;
@@ -44,4 +50,11 @@ export default class OffchainLendingPool {
     getKinkMultiplier(): 2 | 5;
     getTotalBorrowsUSD(): Promise<number>;
     getTotalAPR(): Promise<number>;
+    getTVL(): Promise<number>;
+    isDeprecated(): Promise<boolean>;
+    isBlacklisted(): Promise<boolean>;
+    isStable(): Promise<boolean>;
+    isLowTVL(): Promise<boolean>;
+    isHighTVL(): Promise<boolean>;
+    getLendingPoolVersion(): Promise<LendingPoolVersion>;
 }

package/lib/offchain/lendingPool/offchainLendingPool.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LendingPoolVersion = void 0;
 const types_1 = require("../../config/types");
 const offchainCollateral_1 = __importDefault(require("./offchainCollateral"));
 const offchainBorrowable_1 = __importDefault(require("./offchainBorrowable"));
@@ -19,11 +20,18 @@ const farms_1 = require("../../config/farms");
 const utils_1 = require("../../utils");
 const amms_1 = require("../../config/amms");
 const factories_1 = require("../../config/factories");
+var LendingPoolVersion;
+(function (LendingPoolVersion) {
+    LendingPoolVersion[LendingPoolVersion["V1"] = 0] = "V1";
+    LendingPoolVersion[LendingPoolVersion["V2"] = 1] = "V2";
+    LendingPoolVersion[LendingPoolVersion["V3"] = 2] = "V3";
+})(LendingPoolVersion = exports.LendingPoolVersion || (exports.LendingPoolVersion = {}));
 class OffchainLendingPool {
     constructor(offchain, factory, pairAddress) {
         this.getOffchain = () => this.offchain;
         this.getFactory = () => this.factory;
         this.getPairAddress = () => this.pairAddress;
+        this.getBorrowable = (borrowable) => borrowable == types_1.Borrowable.A ? this.getBorrowableA() : this.getBorrowableB();
         // Shortcuts
         this.getBorrowableA = () => this.poolTokens[types_1.PoolTokenType.BorrowableA];
         this.getBorrowableB = () => this.poolTokens[types_1.PoolTokenType.BorrowableB];
@@ -226,5 +234,44 @@ class OffchainLendingPool {
             return uniswapAPR + stakingAPR;
         });
     }
+    getTVL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO
+            return 1;
+        });
+    }
+    // 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;
+        });
+    }
+    isLowTVL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    isHighTVL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    // Versions Specfics
+    getLendingPoolVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO
+            return LendingPoolVersion.V2;
+        });
+    }
 }
 exports.default = OffchainLendingPool;

package/lib/offchain/offchain.d.ts

@@ -6,8 +6,8 @@ import OffchainSolidexHelper from "./offchainSolidexHelper";
 import OffchainAccount from "./account";
 import OffchainEndpointManager from './offchainEndpointManager';
 import { Address, AddressIndex, Factory, FactoryIndex, LendingPoolIndex, Networks, WhitelistState } from '../config/types';
-import { LendingPoolData, LendingVaultData, LendingVaultPosition, TvlData, UserData, XimxData } from './offchainTypes';
-import OffchainLendingVault from './offchainLendingVault';
+import { LendingPoolData, LendingVaultData, VaultPosition, TvlData, UserData, XimxData } from './offchainTypes';
+import OffchainVault from './vault/offchainVault';
 import OffchainConfigManager from './configManager';
 import { LlamaTvlChart } from './offchainAPRHelper';
 export interface OffchainCfg {
@@ -15,12 +15,14 @@ export interface OffchainCfg {
     chainId: number;
     whitelistedPairs?: FactoryIndex<Address[]>;
 }
+import OffchainMultichain from "./offchainMultichain";
 export default class Offchain {
+    readonly offchainMultichain: OffchainMultichain;
     readonly network: Networks;
     readonly chainId: number;
     readonly whitelistedPairs: FactoryIndex<Address[]>;
     protected lendingPools: LendingPoolIndex<OffchainLendingPool>;
-    protected lendingVaults: AddressIndex<OffchainLendingVault>;
+    protected vaults: AddressIndex<OffchainVault>;
     protected accounts: AddressIndex<OffchainAccount>;
     protected priceHelper: OffchainPriceHelper;
     protected aprHelper: OffchainAPRHelper;
@@ -32,30 +34,21 @@ export default class Offchain {
     };
     protected lendingVaultsData: Promise<AddressIndex<LendingVaultData>> | null;
     protected lendingVaultsUsersData: {
-        [key in Address]?: Promise<AddressIndex<LendingVaultPosition> | null>;
+        [key in Address]?: Promise<AddressIndex<VaultPosition> | null>;
     };
     protected tvlData: Promise<TvlData> | null;
     protected ximxData: Promise<XimxData> | null;
     protected whitelistData: Promise<LendingPoolIndex<WhitelistState>> | null;
     protected endpointManager: OffchainEndpointManager;
-    constructor(cfg: OffchainCfg);
+    constructor(offchainMultichain: OffchainMultichain, network: Networks);
     cleanCache(): void;
     getLendingPool(factory: Factory, pairAddress: Address): Promise<OffchainLendingPool>;
-    getLendingVault(vaultAddress: Address): Promise<OffchainLendingVault>;
+    getLendingVault(vaultAddress: Address): Promise<OffchainVault>;
     getAccount(accountAddress: Address): OffchainAccount;
     getPriceHelper: () => OffchainPriceHelper;
     getSolidexHelper: () => OffchainSolidexHelper;
     getConfigManager: () => OffchainConfigManager;
     getAPRHelper: () => OffchainAPRHelper;
-    /**
-     * TODO
-     * Potrei organizzare in:
-     * - lendingPoolData
-     * - usersData
-     * - tvlData
-     * - ximxData
-     * - lendingVaultData
-     */
     apolloFetcher: typeof initializer.apolloFetcher;
     protected fetchLendingPools: typeof initializer.fetchLendingPools;
     protected fetchLendingPoolsPast: typeof initializer.fetchLendingPoolsPast;