impermax-sdk 2.1.261 → 2.1.262

package/lib/utils/position/uniswapV2/index.d.ts

@@ -1,4 +1,4 @@
-import Position from "../interface";
+import GenericPosition from "../genericPosition";
 export interface UniswapV2PositionParams {
     liquidity: number;
     debtX: number;
@@ -11,121 +11,25 @@ export interface UniswapV2PositionParams {
     availableToBorrowY?: number;
     lockStateChange?: boolean;
 }
-export declare class UniswapV2Position implements Position {
-    lockStateChange: boolean;
-    state: number;
-    /**
-     * NOTICE all values inside this class are normalized (no decimals or mantissa to take into account)
-     */
-    liquidity: number;
-    debtX: number;
-    debtY: number;
-    initialLiquidity: number;
-    initialDebtX: number;
-    initialDebtY: number;
-    marketPrice: number;
-    oraclePrice: number;
-    safetyMargin: number;
-    liquidationPenalty: number;
-    availableToBorrowX: number;
-    availableToBorrowY: number;
+export declare class UniswapV2Position extends GenericPosition {
     constructor(params: UniswapV2PositionParams);
-    private checkLock;
+    protected checkLock(): void;
     /**
-     * PRIVATE SETTERS
+     * protected SETTERS
      */
-    private setRealXRealY;
-    private setRealX;
-    private setRealY;
-    private setDebtX;
-    private setDebtY;
+    protected setLiquidity(liquidity: number): void;
     /**
-     * PRIVATE GETTERS
+     * protected GETTERS
      */
-    private getRealXGivenLiquidityAndPrice;
-    private getRealYGivenLiquidityAndPrice;
-    private getRealXGivenLiquidity;
-    private getRealYGivenLiquidity;
-    private getRealXGivenPrice;
-    private getRealYGivenPrice;
-    private getRealX;
-    private getRealY;
-    private getInitialRealX;
-    private getInitialRealY;
-    private getValueGivenPriceAndAmounts;
-    private getValueGivenAmounts;
-    private getAmountXGivenValue;
-    private getAmountYGivenValue;
-    private getInitialDebtValue;
-    private getDebtValueGivenPrice;
-    private getInitialCollateralValue;
-    private getCollateralValueGivenPrice;
-    private getCollateralValueGivenPriceAndDeltaLeverage;
-    private getInitialEquityValue;
-    private getEquityValueGivenPrice;
-    private getDebtValue;
-    private getCollateralValue;
-    private getEquityValue;
-    private getLiquidityPostLiquidationValueGivenPriceAndDebt;
-    private getLiquidityPostLiquidationValueGivenPriceAndDeltaLeverage;
-    private isLiquidatableGivenPriceAndDebt;
-    private isLiquidatableGivenPriceAndDeltaLeverage;
-    private isLiquidatableGivenDebt;
-    private isLiquidatableGivenDeltaLeverage;
-    private isLiquidatableGivenPrice;
-    private isUnderwaterGivenPrice;
-    private getLiquidationPriceInRange;
-    private getMaxDeltaDebtInRange;
-    private getMaxDeltaLeverageInRange;
-    private getMinLeverageInRange;
-    /**
-     * PUBLIC SETTERS
-     */
-    depositX(amount: number): void;
-    depositY(amount: number): void;
-    withdrawX(amount: number): void;
-    withdrawY(amount: number): void;
-    borrowX(amount: number): void;
-    borrowY(amount: number): void;
-    repayX(amount: number): void;
-    repayY(amount: number): void;
+    protected getRealXGivenLiquidityAndPrice(liquidity: number, price: number): number;
+    protected getRealYGivenLiquidityAndPrice(liquidity: number, price: number): number;
     /**
      * PUBLIC GETTERS
      */
-    getInitialDepositedX(): number;
-    getInitialDepositedY(): number;
-    getDepositedX(): number;
-    getDepositedY(): number;
-    getNetX(): number;
-    getNetY(): number;
-    isLiquidatable(): boolean;
-    isUnderwater(): boolean;
-    getLiquidationRange(): {
-        priceA: number;
-        priceB: number;
-    } | undefined;
-    getInitialLeverage(): number;
-    getLeverage(): number;
     getOptimalLiquidity(amountX: number, amountY: number): {
         liquidity: number;
         amountX: number;
         amountY: number;
     };
-    getOptimalWithdraw(amountX: number, amountY: number, withdrawAtLeast?: boolean): {
-        amountX: number;
-        amountY: number;
-    };
-    getOptimalWithdrawForDeleverage(targetLeverage: number): {
-        amountX: number;
-        amountY: number;
-    } | null;
-    getMaxLeverage(): number;
-    getMinLeverage(): number;
-    getMaxWithdrawable(): {
-        amountX: number;
-        amountY: number;
-    };
-    getMaxBorrowableX(): number;
-    getMaxBorrowableY(): number;
 }
 export default UniswapV2Position;

package/lib/utils/position/uniswapV2/index.js

@@ -1,30 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV2Position = void 0;
-function getRealX(liquidity, price) {
-    return liquidity / Math.sqrt(price);
-}
-function getRealY(liquidity, price) {
-    return liquidity * Math.sqrt(price);
-}
-const LOWEST_PRICE = 1 / 1e18;
-const HIGHEST_PRICE = 1e18;
-class UniswapV2Position {
+const genericPosition_1 = __importDefault(require("../genericPosition"));
+class UniswapV2Position extends genericPosition_1.default {
     constructor(params) {
-        this.liquidity = params.liquidity;
-        this.debtX = params.debtX;
-        this.debtY = params.debtY;
-        this.initialLiquidity = params.liquidity;
-        this.initialDebtX = params.debtX;
-        this.initialDebtY = params.debtY;
-        this.marketPrice = params.marketPrice;
-        this.oraclePrice = params.oraclePrice;
-        this.safetyMargin = params.safetyMargin;
-        this.liquidationPenalty = params.liquidationPenalty;
-        this.availableToBorrowX = params.availableToBorrowX ?? 0;
-        this.availableToBorrowY = params.availableToBorrowY ?? 0;
-        this.lockStateChange = params.lockStateChange ?? true;
-        this.state = 0;
+        super(params);
     }
     checkLock() {
         if (this.lockStateChange)
@@ -33,297 +16,23 @@ class UniswapV2Position {
             this.state++;
     }
     /**
-     * PRIVATE SETTERS
+     * protected SETTERS
      */
-    setRealXRealY(amountX, amountY) {
-        if (Number.isNaN(amountX))
-            return;
-        if (Number.isNaN(amountY))
-            return;
-        this.checkLock();
-        const { liquidity } = this.getOptimalLiquidity(amountX, amountY);
-        this.liquidity = liquidity;
-    }
-    setRealX(amountX) {
-        if (Number.isNaN(amountX))
-            return;
-        this.checkLock();
-        const { liquidity } = this.getOptimalLiquidity(amountX, Infinity);
-        this.liquidity = liquidity;
-    }
-    setRealY(amountY) {
-        if (Number.isNaN(amountY))
-            return;
-        this.checkLock();
-        const { liquidity } = this.getOptimalLiquidity(Infinity, amountY);
+    setLiquidity(liquidity) {
         this.liquidity = liquidity;
     }
-    setDebtX(_debtX) {
-        if (Number.isNaN(_debtX))
-            return;
-        this.checkLock();
-        this.debtX = _debtX;
-    }
-    setDebtY(_debtY) {
-        if (Number.isNaN(_debtY))
-            return;
-        this.checkLock();
-        this.debtY = _debtY;
-    }
     /**
-     * PRIVATE GETTERS
+     * protected GETTERS
      */
     getRealXGivenLiquidityAndPrice(liquidity, price) {
-        return getRealX(liquidity, price);
+        return liquidity / Math.sqrt(price);
     }
     getRealYGivenLiquidityAndPrice(liquidity, price) {
-        return getRealY(liquidity, price);
-    }
-    getRealXGivenLiquidity(liquidity) {
-        return this.getRealXGivenLiquidityAndPrice(liquidity, this.marketPrice);
-    }
-    getRealYGivenLiquidity(liquidity) {
-        return this.getRealYGivenLiquidityAndPrice(liquidity, this.marketPrice);
-    }
-    getRealXGivenPrice(price) {
-        return this.getRealXGivenLiquidityAndPrice(this.liquidity, price);
-    }
-    getRealYGivenPrice(price) {
-        return this.getRealYGivenLiquidityAndPrice(this.liquidity, price);
-    }
-    getRealX() {
-        return this.getRealXGivenLiquidityAndPrice(this.liquidity, this.marketPrice);
-    }
-    getRealY() {
-        return this.getRealYGivenLiquidityAndPrice(this.liquidity, this.marketPrice);
-    }
-    getInitialRealX() {
-        return this.getRealXGivenLiquidityAndPrice(this.initialLiquidity, this.marketPrice);
-    }
-    getInitialRealY() {
-        return this.getRealYGivenLiquidityAndPrice(this.initialLiquidity, this.marketPrice);
-    }
-    getValueGivenPriceAndAmounts(price, amountX, amountY) {
-        return amountX * price + amountY;
-    }
-    getValueGivenAmounts(amountX, amountY) {
-        return amountX * this.marketPrice + amountY;
-    }
-    getAmountXGivenValue(value) {
-        return value / this.marketPrice;
-    }
-    getAmountYGivenValue(value) {
-        return value;
-    }
-    getInitialDebtValue() {
-        return this.getValueGivenAmounts(this.initialDebtX, this.initialDebtY);
-    }
-    getDebtValueGivenPrice(price) {
-        return this.getValueGivenPriceAndAmounts(price, this.debtX, this.debtY);
-    }
-    getInitialCollateralValue() {
-        return this.getValueGivenAmounts(this.getInitialRealX(), this.getInitialRealY());
-    }
-    getCollateralValueGivenPrice(price) {
-        return this.getValueGivenPriceAndAmounts(price, this.getRealXGivenPrice(price), this.getRealYGivenPrice(price));
-    }
-    getCollateralValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
-        const { liquidity } = this.getOptimalLiquidity(deltaX, deltaY);
-        return this.getValueGivenPriceAndAmounts(price, this.getRealXGivenLiquidityAndPrice(this.liquidity + liquidity, price), this.getRealYGivenLiquidityAndPrice(this.liquidity + liquidity, price));
-    }
-    getInitialEquityValue() {
-        return this.getInitialCollateralValue() - this.getInitialDebtValue();
-    }
-    getEquityValueGivenPrice(price) {
-        return this.getCollateralValueGivenPrice(price) - this.getDebtValueGivenPrice(price);
-    }
-    getDebtValue() {
-        return this.getDebtValueGivenPrice(this.marketPrice);
-    }
-    getCollateralValue() {
-        return this.getCollateralValueGivenPrice(this.marketPrice);
-    }
-    getEquityValue() {
-        return this.getEquityValueGivenPrice(this.marketPrice);
-    }
-    getLiquidityPostLiquidationValueGivenPriceAndDebt(price, debtX, debtY) {
-        const debtValue = this.getValueGivenPriceAndAmounts(price, debtX, debtY);
-        const collateralValue = this.getCollateralValueGivenPrice(price);
-        const collateralNeeded = debtValue * this.liquidationPenalty;
-        return collateralValue - collateralNeeded;
-    }
-    getLiquidityPostLiquidationValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
-        const debtValue = this.getDebtValueGivenPrice(price) + this.getValueGivenPriceAndAmounts(price, deltaX, deltaY);
-        const collateralValue = this.getCollateralValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY);
-        const collateralNeeded = debtValue * this.liquidationPenalty;
-        return collateralValue - collateralNeeded;
-    }
-    isLiquidatableGivenPriceAndDebt(price, debtX, debtY) {
-        return this.getLiquidityPostLiquidationValueGivenPriceAndDebt(price / this.safetyMargin, debtX, debtY) < 0
-            || this.getLiquidityPostLiquidationValueGivenPriceAndDebt(price * this.safetyMargin, debtX, debtY) < 0;
-    }
-    isLiquidatableGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
-        return this.getLiquidityPostLiquidationValueGivenPriceAndDeltaLeverage(price / this.safetyMargin, deltaX, deltaY) < 0
-            || this.getLiquidityPostLiquidationValueGivenPriceAndDeltaLeverage(price * this.safetyMargin, deltaX, deltaY) < 0;
-    }
-    isLiquidatableGivenDebt(debtX, debtY) {
-        return this.isLiquidatableGivenPriceAndDebt(this.marketPrice, debtX, debtY);
-    }
-    isLiquidatableGivenDeltaLeverage(deltaX, deltaY) {
-        return this.isLiquidatableGivenPriceAndDeltaLeverage(this.marketPrice, deltaX, deltaY);
-    }
-    isLiquidatableGivenPrice(price) {
-        return this.isLiquidatableGivenPriceAndDebt(price, this.debtX, this.debtY);
-    }
-    isUnderwaterGivenPrice(price) {
-        return this.getLiquidityPostLiquidationValueGivenPriceAndDebt(price, this.debtX, this.debtY) < 0;
-    }
-    getLiquidationPriceInRange(lowPrice, highPrice, lowIsLiquidatable, highIsLiquidatable) {
-        if (lowIsLiquidatable == highIsLiquidatable)
-            return undefined;
-        const avgPrice = Math.sqrt(lowPrice * highPrice);
-        if (lowPrice / highPrice > 0.9999)
-            return avgPrice;
-        const avgIsLiquidatable = this.isLiquidatableGivenPrice(avgPrice);
-        return this.getLiquidationPriceInRange(lowPrice, avgPrice, lowIsLiquidatable, avgIsLiquidatable)
-            ?? this.getLiquidationPriceInRange(avgPrice, highPrice, avgIsLiquidatable, highIsLiquidatable);
-    }
-    getMaxDeltaDebtInRange(lowDeltaX, lowDeltaY, highDeltaX, highDeltaY) {
-        if (Number.isNaN(lowDeltaX) || Number.isNaN(lowDeltaY) || Number.isNaN(highDeltaX) || Number.isNaN(highDeltaY))
-            return [0, 0];
-        if (highDeltaX == 0 && highDeltaY == 0)
-            return [0, 0];
-        if (Math.abs(highDeltaX / lowDeltaX) < 1.001 || Math.abs(highDeltaY / lowDeltaY) < 1.001)
-            return [lowDeltaX, lowDeltaY];
-        const avgDeltaX = (lowDeltaX + highDeltaX) / 2;
-        const avgDeltaY = (lowDeltaY + highDeltaY) / 2;
-        if (this.isLiquidatableGivenDebt(this.debtX + avgDeltaX, this.debtY + avgDeltaY))
-            return this.getMaxDeltaDebtInRange(lowDeltaX, lowDeltaY, avgDeltaX, avgDeltaY);
-        else
-            return this.getMaxDeltaDebtInRange(avgDeltaX, avgDeltaY, highDeltaX, highDeltaY);
-    }
-    getMaxDeltaLeverageInRange(lowDeltaX, lowDeltaY, highDeltaX, highDeltaY) {
-        if (Number.isNaN(lowDeltaX) || Number.isNaN(lowDeltaY) || Number.isNaN(highDeltaX) || Number.isNaN(highDeltaY))
-            return [0, 0];
-        if (highDeltaX == 0 && highDeltaY == 0)
-            return [0, 0];
-        if (Math.abs(highDeltaX / lowDeltaX) < 1.001 || Math.abs(highDeltaY / lowDeltaY) < 1.001)
-            return [lowDeltaX, lowDeltaY];
-        const avgDeltaX = (lowDeltaX + highDeltaX) / 2;
-        const avgDeltaY = (lowDeltaY + highDeltaY) / 2;
-        if (this.isLiquidatableGivenDeltaLeverage(avgDeltaX, avgDeltaY))
-            return this.getMaxDeltaLeverageInRange(lowDeltaX, lowDeltaY, avgDeltaX, avgDeltaY);
-        else
-            return this.getMaxDeltaLeverageInRange(avgDeltaX, avgDeltaY, highDeltaX, highDeltaY);
-    }
-    getMinLeverageInRange(lowLeverage, highLeverage) {
-        if (highLeverage / lowLeverage < 1.001)
-            return highLeverage;
-        const avgLeverage = (lowLeverage + highLeverage) / 2;
-        if (this.getOptimalWithdrawForDeleverage(avgLeverage) !== null)
-            return this.getMinLeverageInRange(lowLeverage, avgLeverage);
-        else
-            return this.getMinLeverageInRange(avgLeverage, highLeverage);
-    }
-    /**
-     * PUBLIC SETTERS
-     */
-    depositX(amount) {
-        this.setRealX(this.getInitialRealX() + amount);
-    }
-    depositY(amount) {
-        this.setRealY(this.getInitialRealY() + amount);
-    }
-    withdrawX(amount) {
-        this.setRealX(Math.max(this.getInitialRealX() - amount, 0));
-    }
-    withdrawY(amount) {
-        this.setRealY(Math.max(this.getInitialRealY() - amount, 0));
-    }
-    borrowX(amount) {
-        if (amount > this.availableToBorrowX) {
-            throw new Error("Trying to borrow more than available liquidity");
-        }
-        else {
-            this.setDebtX(this.initialDebtX + amount);
-        }
-    }
-    borrowY(amount) {
-        if (amount > this.availableToBorrowY) {
-            throw new Error("Trying to borrow more than available liquidity");
-        }
-        else {
-            this.setDebtY(this.initialDebtY + amount);
-        }
-    }
-    repayX(amount) {
-        this.setDebtX(Math.max(this.initialDebtX - amount, 0));
-    }
-    repayY(amount) {
-        this.setDebtY(Math.max(this.initialDebtY - amount, 0));
+        return liquidity * Math.sqrt(price);
     }
     /**
      * PUBLIC GETTERS
      */
-    getInitialDepositedX() {
-        return this.getInitialRealX();
-    }
-    getInitialDepositedY() {
-        return this.getInitialRealY();
-    }
-    getDepositedX() {
-        return this.getRealX();
-    }
-    getDepositedY() {
-        return this.getRealY();
-    }
-    getNetX() {
-        return this.getDepositedX() - this.debtX;
-    }
-    getNetY() {
-        return this.getDepositedY() - this.debtY;
-    }
-    isLiquidatable() {
-        return this.isLiquidatableGivenPrice(this.oraclePrice);
-    }
-    isUnderwater() {
-        return this.isUnderwaterGivenPrice(this.marketPrice);
-    }
-    getLiquidationRange() {
-        const isLiquidatable = this.isLiquidatable();
-        if (isLiquidatable)
-            return undefined;
-        if (this.marketPrice < LOWEST_PRICE || this.marketPrice > HIGHEST_PRICE)
-            return undefined;
-        const lowIsLiquidatable = this.isLiquidatableGivenPrice(LOWEST_PRICE);
-        const highIsLiquidatable = this.isLiquidatableGivenPrice(HIGHEST_PRICE);
-        const priceA = this.getLiquidationPriceInRange(LOWEST_PRICE, this.marketPrice, lowIsLiquidatable, isLiquidatable);
-        const priceB = this.getLiquidationPriceInRange(this.marketPrice, HIGHEST_PRICE, isLiquidatable, highIsLiquidatable);
-        return {
-            priceA: priceA && priceA > LOWEST_PRICE ? priceA : 0,
-            priceB: priceB && priceB < HIGHEST_PRICE ? priceB : Infinity,
-        };
-    }
-    getInitialLeverage() {
-        const leverage = this.getInitialCollateralValue() / this.getInitialEquityValue();
-        if (!leverage)
-            return 1;
-        if (Number.isNaN(leverage))
-            return 1;
-        if (leverage < 1)
-            return 1;
-        return leverage;
-    }
-    getLeverage() {
-        const leverage = this.getCollateralValue() / this.getEquityValue();
-        if (!leverage)
-            return 1;
-        if (Number.isNaN(leverage))
-            return 1;
-        if (leverage < 1)
-            return 1;
-        return leverage;
-    }
     // amountX and amountY are expected to have the same sign
     getOptimalLiquidity(amountX, amountY) {
         amountX = Number.isNaN(amountX) ? 0 : amountX ?? 0;
@@ -337,149 +46,6 @@ class UniswapV2Position {
             amountY: this.getRealYGivenLiquidity(liquidity),
         };
     }
-    getOptimalWithdraw(amountX, amountY, withdrawAtLeast = true) {
-        let percentageToRemove;
-        const percentageToRemoveX = amountX / this.getInitialDepositedX();
-        const percentageToRemoveY = amountY / this.getInitialDepositedY();
-        // Withdraw at least amountX and amountY
-        if (withdrawAtLeast)
-            percentageToRemove = Math.min(Math.max(percentageToRemoveX, percentageToRemoveY), 1);
-        // Withdraw at most amountX and amountY
-        else
-            percentageToRemove = Math.min(Math.min(percentageToRemoveX, percentageToRemoveY), 1);
-        percentageToRemove = percentageToRemove && !Number.isNaN(percentageToRemove) ? percentageToRemove : 0;
-        return {
-            amountX: this.getInitialDepositedX() * percentageToRemove,
-            amountY: this.getInitialDepositedY() * percentageToRemove,
-        };
-    }
-    getOptimalWithdrawForDeleverage(targetLeverage) {
-        // 1. If target leverage out of range
-        if (!(targetLeverage >= 1 && targetLeverage < this.getInitialLeverage())) {
-            return null;
-        }
-        // 2. If target leverage is achievable through a straight deleverage
-        const maxStraightDeleverage = this.getOptimalWithdraw(this.initialDebtX, this.initialDebtY, false);
-        const maxStraightDeleverageValue = this.getValueGivenAmounts(maxStraightDeleverage.amountX, maxStraightDeleverage.amountY);
-        const minStraightLeverage = (this.getInitialCollateralValue() - maxStraightDeleverageValue) / this.getInitialEquityValue();
-        if (targetLeverage >= minStraightLeverage) {
-            const desiredCollateralValue = targetLeverage * this.getInitialEquityValue();
-            const desiredValue = this.getInitialCollateralValue() - desiredCollateralValue;
-            const ratio = desiredValue / maxStraightDeleverageValue;
-            return {
-                amountX: maxStraightDeleverage.amountX * ratio,
-                amountY: maxStraightDeleverage.amountY * ratio,
-            };
-        }
-        // 3. Deleveraging will result in withdrawing
-        const debtValue = this.getInitialDebtValue() - maxStraightDeleverageValue;
-        const collateralValue = this.getInitialCollateralValue() - maxStraightDeleverageValue;
-        let repayRatio;
-        if (this.initialDebtX == maxStraightDeleverage.amountX) {
-            repayRatio = this.getValueGivenAmounts(0, this.getInitialDepositedY()) / this.getInitialCollateralValue();
-        }
-        else {
-            repayRatio = this.getValueGivenAmounts(this.getInitialDepositedX(), 0) / this.getInitialCollateralValue();
-        }
-        const deltaValue = (collateralValue * (targetLeverage - 1) - debtValue * targetLeverage) / (targetLeverage * (1 - repayRatio) - 1);
-        // Proof:
-        // leverage = newCollateral / (newCollateral - newDebt)
-        // newCollateral = collateral - delta
-        // newDebt = debt - delta * repayRatio;
-        // ((collateral - delta) - (debt - delta * repayRatio)) * leverage = (collateral - delta)
-        // (collateral - delta - debt + delta * repayRatio) * leverage - collateral = - delta
-        // collateral * leverage - delta * leverage - debt * leverage + delta * repayRatio * leverage - collateral = - delta
-        // collateral * leverage - debt * leverage - collateral = - delta + delta * leverage - delta * repayRatio * leverage
-        // collateral * (leverage-1) - debt * leverage = delta * (leverage - repayRatio * leverage - 1)
-        // collateral * (leverage-1) - debt * leverage = delta * (leverage * (1-repayRatio) - 1)
-        // (collateral * (leverage-1) - debt * leverage) / (leverage * (1-repayRatio) - 1) = delta
-        // 4. Return amounts if the leverage is achievable
-        if (deltaValue < 0 || deltaValue > collateralValue)
-            return null;
-        const percentageToRemove = (deltaValue + maxStraightDeleverageValue) / this.getInitialCollateralValue();
-        return {
-            amountX: this.getInitialDepositedX() * percentageToRemove,
-            amountY: this.getInitialDepositedY() * percentageToRemove,
-        };
-    }
-    getMaxLeverage() {
-        const currentLeverage = this.getLeverage();
-        if (this.isLiquidatable())
-            return currentLeverage;
-        const highLeverage = 100; // we assume the position is liquidatable with this leverage
-        let setLiquidityToZero = false;
-        if (this.liquidity === 0) {
-            this.liquidity = 0.000001;
-            setLiquidityToZero = true;
-        }
-        const realX = this.getRealX();
-        const realY = this.getRealY();
-        let maxDeltaX = realX * highLeverage / currentLeverage;
-        let maxDeltaY = realY * highLeverage / currentLeverage;
-        const actualAvailableToBorrowX = this.availableToBorrowX - (this.debtX - this.initialDebtX);
-        const actualAvailableToBorrowY = this.availableToBorrowY - (this.debtY - this.initialDebtY);
-        if (maxDeltaX > actualAvailableToBorrowX) {
-            maxDeltaY *= actualAvailableToBorrowX / maxDeltaX;
-            maxDeltaX = actualAvailableToBorrowX;
-        }
-        if (maxDeltaY > actualAvailableToBorrowY) {
-            maxDeltaX *= actualAvailableToBorrowY / maxDeltaY;
-            maxDeltaY = actualAvailableToBorrowY;
-        }
-        const [deltaX, deltaY] = this.getMaxDeltaLeverageInRange(0, 0, maxDeltaX, maxDeltaY);
-        const collateralValue = this.getCollateralValue();
-        const additionalValue = this.getValueGivenAmounts(deltaX, deltaY);
-        if (setLiquidityToZero)
-            this.liquidity = 0;
-        return (collateralValue + additionalValue) / collateralValue * currentLeverage;
-    }
-    getMinLeverage() {
-        const depositedX = this.getDepositedX();
-        const depositedY = this.getDepositedY();
-        const ratioX = this.debtX === 0 ? Infinity : depositedX / this.debtX;
-        const ratioY = this.debtY === 0 ? Infinity : depositedY / this.debtY;
-        if (ratioX >= 1 && ratioY >= 1)
-            return 0;
-        return this.getMinLeverageInRange(1, this.getInitialLeverage());
-    }
-    getMaxWithdrawable() {
-        const depositedX = this.getDepositedX();
-        const depositedY = this.getDepositedY();
-        const additionalDepositX = this.getRealX() - this.getInitialRealX();
-        const additionalDepositY = this.getRealY() - this.getInitialRealY();
-        let percentage = 0;
-        if (!this.isLiquidatable()) {
-            if (this.debtX == 0 && this.debtY == 0) {
-                percentage = 1;
-            }
-            else {
-                const highRatio = this.getEquityValue() / this.getDebtValue();
-                const [deltaDebtX, deltaDebtY] = this.getMaxDeltaDebtInRange(0, 0, this.debtX * highRatio, this.debtY * highRatio);
-                const ratio = this.debtX > 0 ? deltaDebtX / this.debtX : deltaDebtY / this.debtY;
-                percentage = 1 / (1 / ratio + 1);
-            }
-        }
-        return {
-            amountX: depositedX * percentage - additionalDepositX,
-            amountY: depositedY * percentage - additionalDepositY,
-        };
-    }
-    getMaxBorrowableX() {
-        if (this.isLiquidatable())
-            return 0;
-        const equityValue = this.getEquityValue();
-        const highDebtX = this.getAmountXGivenValue(equityValue);
-        const [debtX,] = this.getMaxDeltaDebtInRange(0, 0, highDebtX, 0);
-        return Math.min(debtX + this.debtX - this.initialDebtX, this.availableToBorrowX);
-    }
-    getMaxBorrowableY() {
-        if (this.isLiquidatable())
-            return 0;
-        const equityValue = this.getEquityValue();
-        const highDebtY = this.getAmountYGivenValue(equityValue);
-        const [, debtY] = this.getMaxDeltaDebtInRange(0, 0, 0, highDebtY);
-        return Math.min(debtY + this.debtY - this.initialDebtY, this.availableToBorrowY);
-    }
 }
 exports.UniswapV2Position = UniswapV2Position;
 exports.default = UniswapV2Position;