impermax-sdk 1.2.112 → 2.0.0

package/lib/onchain/account/lendingPool/onchainAccountCollateralV2.js

@@ -0,0 +1,99 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const onchainTypes_1 = require("../../onchainTypes");
+const onchainAccountPoolToken_1 = __importDefault(require("../onchainAccountPoolToken"));
+class OnchainAccountCollateralV2 extends onchainAccountPoolToken_1.default {
+    constructor(lendingPool) {
+        super();
+        this.collateralCache = {};
+        this.getLendingPool = () => this.lendingPool;
+        this.getPoolToken = () => this.poolToken;
+        this.getCollateral = () => this.poolToken;
+        this.getAccount = () => this.lendingPool.getAccount();
+        this.getInteractionsCollateral = this.getInteractionsPoolToken;
+        this.getOffchainAccountCollateral = this.getOffchainAccountPoolToken;
+        this.lendingPool = lendingPool;
+        this.poolToken = lendingPool.getLendingPool().getCollateral();
+    }
+    getInteractionsPoolToken() {
+        return this.lendingPool.getInteractionsLendingPool().getCollateral();
+    }
+    getOffchainAccountPoolToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const offchainAccountLendingPool = yield this.lendingPool.getOffchainAccountLendingPool();
+            return offchainAccountLendingPool.getCollateral();
+        });
+    }
+    cleanCache() {
+        super.cleanCache();
+        this.collateralCache = {};
+    }
+    fixStakedLPExchangeRate(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stakedLPExchangeRate = yield this.poolToken.getLendingPool().getStakedLPExchangeRate();
+            return (yield n) / stakedLPExchangeRate;
+        });
+    }
+    getAvailableBalanceUSD() {
+        const _super = Object.create(null, {
+            getAvailableBalanceUSD: { get: () => super.getAvailableBalanceUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getAvailableBalanceUSD.call(this));
+        });
+    }
+    getDepositedUSD() {
+        const _super = Object.create(null, {
+            getDepositedUSD: { get: () => super.getDepositedUSD }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fixStakedLPExchangeRate(_super.getDepositedUSD.call(this));
+        });
+    }
+    // Max Withdrawable
+    // binary search approach
+    getMaxWithdrawable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collateralAmount = yield this.getDeposited();
+            const twapPrice = yield this.lendingPool.getLendingPool().getTWAPPrice();
+            const [liqPriceA, liqPriceB] = yield this.lendingPool.getLiquidationPrices(onchainTypes_1.NO_CHANGES);
+            // start search
+            let withdrawAmount = collateralAmount;
+            let withdrawAmountPrev = 0;
+            let bestAmount = 0;
+            for (let i = 0; i < 1000; i++) {
+                const jump = Math.abs(withdrawAmount - withdrawAmountPrev) / 2;
+                if (jump / collateralAmount < 0.000001)
+                    break;
+                withdrawAmountPrev = withdrawAmount;
+                const changeCollateral = -1 * Math.min(withdrawAmount, collateralAmount);
+                const changeBorrowedA = 0;
+                const changeBorrowedB = 0;
+                const changes = { changeCollateral, changeBorrowedA, changeBorrowedB };
+                const [liqPriceA, liqPriceB] = yield this.lendingPool.getLiquidationPrices(changes);
+                if (liqPriceA * this.getUiMargin() > twapPrice || liqPriceB / this.getUiMargin() < twapPrice)
+                    withdrawAmount -= jump;
+                else {
+                    bestAmount = withdrawAmount;
+                    withdrawAmount += jump;
+                    if (withdrawAmount > collateralAmount)
+                        break;
+                }
+            }
+            return bestAmount * this.getDust();
+        });
+    }
+}
+exports.default = OnchainAccountCollateralV2;

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

@@ -0,0 +1,18 @@
+import OffchainAccountCollateral from '../../../offchain/account/lendingPool/offchainAccountCollateral';
+import OnchainAccountCollateral from "./onchainAccountCollateral";
+import { OnchainCollateralV3 } from "../../impermaxFactory/lendingPool";
+import OnchainAccountLendingPoolV3 from "./onchainAccountLendingPoolV3";
+import { OnchainInteractionsCollateralV3 } from "../../interactions/lendingPool";
+export default class OnchainAccountCollateralV3 extends OnchainAccountCollateral {
+    protected readonly lendingPool: OnchainAccountLendingPoolV3;
+    protected readonly collateral: OnchainCollateralV3;
+    protected collateralCache: {};
+    constructor(lendingPool: OnchainAccountLendingPoolV3);
+    getLendingPool: () => OnchainAccountLendingPoolV3;
+    getCollateral: () => OnchainCollateralV3;
+    getAccount: () => import("..").default;
+    getInteractionsCollateral(): OnchainInteractionsCollateralV3;
+    getOffchainAccountCollateral(): Promise<OffchainAccountCollateral>;
+    cleanCache(): void;
+    getDepositedUSD(): Promise<number>;
+}

package/lib/onchain/account/lendingPool/onchainAccountCollateralV3.js

@@ -0,0 +1,44 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const onchainAccountCollateral_1 = __importDefault(require("./onchainAccountCollateral"));
+class OnchainAccountCollateralV3 extends onchainAccountCollateral_1.default {
+    constructor(lendingPool) {
+        super();
+        this.collateralCache = {};
+        this.getLendingPool = () => this.lendingPool;
+        this.getCollateral = () => this.collateral;
+        this.getAccount = () => this.lendingPool.getAccount();
+        this.lendingPool = lendingPool;
+        this.collateral = lendingPool.getLendingPool().getCollateral();
+    }
+    getInteractionsCollateral() {
+        return this.lendingPool.getInteractionsLendingPool().getCollateral();
+    }
+    getOffchainAccountCollateral() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const offchainAccountLendingPool = yield this.lendingPool.getOffchainAccountLendingPool();
+            return offchainAccountLendingPool.getCollateral();
+        });
+    }
+    cleanCache() {
+        this.collateralCache = {};
+    }
+    getDepositedUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 0;
+        });
+    }
+}
+exports.default = OnchainAccountCollateralV3;

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

@@ -1,57 +1,42 @@
-import OnchainAccount from '../index';
-import { PoolTokenType } from '../../../config/types';
-import OnchainAccountCollateral from './onchainAccountCollateral';
-import OnchainAccountBorrowable from './onchainAccountBorrowable';
-import { Changes, PendingRewardUI } from '../../onchainTypes';
-import OnchainLendingPool from '../../impermaxFactory/lendingPool';
-import OnchainAccountPoolToken from '../onchainAccountPoolToken';
-import OnchainInteractionsLendingPool from '../../interactions/lendingPool';
-import OffchainAccountLendingPool from '../../../offchain/account/lendingPool';
-export default class OnchainAccountLendingPool {
-    private readonly account;
-    private readonly lendingPool;
-    private readonly poolTokens;
-    private cache;
-    constructor(account: OnchainAccount, lendingPool: OnchainLendingPool);
-    getAccount: () => OnchainAccount;
-    getLendingPool: () => OnchainLendingPool;
-    getPoolToken(poolTokenType: PoolTokenType): OnchainAccountPoolToken;
-    getInteractionsLendingPool(): OnchainInteractionsLendingPool;
-    getOffchainAccountLendingPool(): Promise<OffchainAccountLendingPool>;
-    cleanCache(): void;
-    getBorrowableA: () => OnchainAccountBorrowable;
-    getBorrowableB: () => OnchainAccountBorrowable;
-    getCollateral: () => OnchainAccountCollateral;
-    private getFactory;
-    private getPairAddress;
-    getSafetyMargin: () => Promise<number>;
-    getLiquidationPenalty: () => Promise<number>;
-    getUiMargin: () => number;
-    getBalanceUSD(): Promise<number>;
-    getSuppliedUSD(): Promise<number>;
-    getDebtUSD(): Promise<number>;
-    getEquityUSD(): Promise<number>;
-    getLPEquityUSD(): Promise<number>;
-    getLPEquity(): Promise<number>;
-    getAccountAPR(): Promise<number>;
-    getValuesFromPrice(changes: Changes, priceA: number, priceB: number): Promise<{
-        valueCollateral: number;
-        valueA: number;
-        valueB: number;
-    }>;
-    getValues(changes: Changes): Promise<{
-        valueCollateral: number;
-        valueA: number;
-        valueB: number;
-    }>;
-    getMarketValues(changes: Changes): Promise<{
-        valueCollateral: number;
-        valueA: number;
-        valueB: number;
-    }>;
-    getLeverage(changes?: Changes): Promise<number>;
-    getLiquidationPrices(changes?: Changes): Promise<number[]>;
-    getMaxLeverage(): Promise<number>;
-    getMaxDeleverage(slippage: number): Promise<number>;
-    getAvailableReward(): Promise<PendingRewardUI[]>;
-}
+import OnchainAccount from '../index';
+import { Borrowable } from '../../../config/types';
+import OnchainAccountCollateral from './onchainAccountCollateral';
+import OnchainAccountBorrowable from './onchainAccountBorrowable';
+import { PendingRewardUI } from '../../onchainTypes';
+import OnchainLendingPool from '../../impermaxFactory/lendingPool';
+import OnchainInteractionsLendingPool from '../../interactions/lendingPool';
+import OffchainAccountLendingPool from '../../../offchain/account/lendingPool';
+export default abstract class OnchainAccountLendingPool {
+    protected readonly account: OnchainAccount;
+    protected readonly lendingPool: OnchainLendingPool;
+    protected readonly collateral: OnchainAccountCollateral;
+    protected readonly borrowables: {
+        [Borrowable.A]: OnchainAccountBorrowable;
+        [Borrowable.B]: OnchainAccountBorrowable;
+    };
+    protected cache: {};
+    protected abstract getNewCollateralObject(): OnchainAccountCollateral;
+    protected abstract getNewBorrowableObject(borrowable: Borrowable): OnchainAccountBorrowable;
+    constructor(account: OnchainAccount, lendingPool: OnchainLendingPool);
+    cleanCache(): void;
+    getAccount: () => OnchainAccount;
+    getLendingPool: () => OnchainLendingPool;
+    getBorrowable: (borrowable: Borrowable) => OnchainAccountBorrowable;
+    getBorrowableA: () => OnchainAccountBorrowable;
+    getBorrowableB: () => OnchainAccountBorrowable;
+    getCollateral: () => OnchainAccountCollateral;
+    protected getFactory: () => import("../../../config/types").Factory;
+    protected getId: () => string;
+    getSafetyMargin: () => Promise<number>;
+    getLiquidationPenalty: () => Promise<number>;
+    getUiMargin: () => number;
+    getInteractionsLendingPool(): OnchainInteractionsLendingPool;
+    getOffchainAccountLendingPool(): Promise<OffchainAccountLendingPool>;
+    getBalanceUSD(): Promise<number>;
+    getSuppliedUSD(): Promise<number>;
+    getDebtUSD(): Promise<number>;
+    getEquityUSD(): Promise<number>;
+    getLPEquityUSD(): Promise<number>;
+    getAccountAPR(): Promise<number>;
+    getAvailableReward(): Promise<PendingRewardUI[]>;
+}