impermax-sdk 2.1.261 → 2.1.263

package/lib/utils/position/genericPosition.d.ts

@@ -0,0 +1,134 @@
+import Position from "./interface";
+export interface GenericPositionParams {
+    liquidity: number;
+    debtX: number;
+    debtY: number;
+    marketPrice: number;
+    oraclePrice: number;
+    safetyMargin: number;
+    liquidationPenalty: number;
+    availableToBorrowX?: number;
+    availableToBorrowY?: number;
+    lockStateChange?: boolean;
+}
+export declare abstract class GenericPosition implements Position {
+    lockStateChange: boolean;
+    state: number;
+    /**
+     * NOTICE all values inside this class are normalized (no decimals or mantissa to take into account)
+     */
+    /**
+     * TODO: Cache for initialRealX, intialCollateralValue, etc...
+     */
+    liquidity: number;
+    debtX: number;
+    debtY: number;
+    initialLiquidity: number;
+    initialDebtX: number;
+    initialDebtY: number;
+    marketPrice: number;
+    oraclePrice: number;
+    safetyMargin: number;
+    liquidationPenalty: number;
+    availableToBorrowX: number;
+    availableToBorrowY: number;
+    constructor(params: GenericPositionParams);
+    protected checkLock(): void;
+    /**
+     * protected SETTERS
+     */
+    protected abstract setLiquidity(liquidity: number): any;
+    protected setRealXRealY(amountX: number, amountY: number): void;
+    protected setRealX(amountX: number): void;
+    protected setRealY(amountY: number): void;
+    protected setDebtX(_debtX: number): void;
+    protected setDebtY(_debtY: number): void;
+    /**
+     * protected GETTERS
+     */
+    protected abstract getRealXGivenLiquidityAndPrice(liquidity: number, price: number): any;
+    protected abstract getRealYGivenLiquidityAndPrice(liquidity: number, price: number): any;
+    protected getRealXGivenLiquidity(liquidity: number): any;
+    protected getRealYGivenLiquidity(liquidity: number): any;
+    protected getRealXGivenPrice(price: number): any;
+    protected getRealYGivenPrice(price: number): any;
+    protected getRealX(): any;
+    protected getRealY(): any;
+    protected getInitialRealX(): any;
+    protected getInitialRealY(): any;
+    protected getValueGivenPriceAndAmounts(price: number, amountX: number, amountY: number): number;
+    protected getValueGivenAmounts(amountX: number, amountY: number): number;
+    protected getAmountXGivenValue(value: number): number;
+    protected getAmountYGivenValue(value: number): number;
+    protected getInitialDebtValue(): number;
+    protected getDebtValueGivenPrice(price: number): number;
+    protected getInitialCollateralValue(): number;
+    protected getCollateralValueGivenPrice(price: number): number;
+    protected getCollateralValueGivenPriceAndDeltaLeverage(price: number, deltaX: number, deltaY: number): number;
+    protected getUsableCollateralValueGivenPrice(price: number): number;
+    protected getUsableCollateralValueGivenPriceAndDeltaLeverage(price: number, deltaX: number, deltaY: number): number;
+    protected getInitialEquityValue(): number;
+    protected getEquityValueGivenPrice(price: number): number;
+    protected getDebtValue(): number;
+    protected getCollateralValue(): number;
+    protected getEquityValue(): number;
+    protected hasEnoughLiquidityGivenPriceAndDebt(price: number, debtX: number, debtY: number): boolean;
+    protected hasEnoughUsableLiquidityGivenPriceAndDebt(price: number, debtX: number, debtY: number): boolean;
+    protected hasEnoughUsableLiquidityGivenPriceAndDeltaLeverage(price: number, deltaX: number, deltaY: number): boolean;
+    protected isLiquidatableGivenPriceAndDebt(price: number, debtX: number, debtY: number): boolean;
+    protected isLiquidatableGivenPriceAndDeltaLeverage(price: number, deltaX: number, deltaY: number): boolean;
+    protected isLiquidatableGivenDebt(debtX: number, debtY: number): boolean;
+    protected isLiquidatableGivenDeltaLeverage(deltaX: number, deltaY: number): boolean;
+    protected isLiquidatableGivenPrice(price: number): boolean;
+    protected isUnderwaterGivenPrice(price: number): boolean;
+    protected getLiquidationPriceInRange(lowPrice: number, highPrice: number, lowIsLiquidatable: boolean, highIsLiquidatable: boolean): number | undefined;
+    protected getMaxDeltaDebtInRange(lowDeltaX: number, lowDeltaY: number, highDeltaX: number, highDeltaY: number): [number, number];
+    protected getMaxDeltaLeverageInRange(lowDeltaX: number, lowDeltaY: number, highDeltaX: number, highDeltaY: number): [number, number];
+    protected getMinLeverageInRange(lowLeverage: number, highLeverage: number): number;
+    /**
+     * 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;
+    /**
+     * PUBLIC GETTERS
+     */
+    getInitialDepositedX(): any;
+    getInitialDepositedY(): any;
+    getDepositedX(): any;
+    getDepositedY(): any;
+    getNetX(): number;
+    getNetY(): number;
+    isLiquidatable(): boolean;
+    isUnderwater(): boolean;
+    getLiquidationRange(): {
+        priceA: number;
+        priceB: number;
+    } | undefined;
+    getInitialLeverage(): number;
+    getLeverage(): number;
+    abstract getOptimalLiquidity(amountX: number, amountY: number): any;
+    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 GenericPosition;

package/lib/utils/position/genericPosition.js

@@ -0,0 +1,468 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericPosition = void 0;
+const LOWEST_PRICE = 1 / 1e18;
+const HIGHEST_PRICE = 1e18;
+class GenericPosition {
+    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;
+    }
+    checkLock() {
+        if (this.lockStateChange)
+            throw Error("Can't change state of original position object");
+        else
+            this.state++;
+    }
+    setRealXRealY(amountX, amountY) {
+        if (Number.isNaN(amountX))
+            return;
+        if (Number.isNaN(amountY))
+            return;
+        this.checkLock();
+        const { liquidity } = this.getOptimalLiquidity(amountX, amountY);
+        this.setLiquidity(liquidity);
+    }
+    setRealX(amountX) {
+        if (Number.isNaN(amountX))
+            return;
+        this.checkLock();
+        const { liquidity } = this.getOptimalLiquidity(amountX, Infinity);
+        this.setLiquidity(liquidity);
+    }
+    setRealY(amountY) {
+        if (Number.isNaN(amountY))
+            return;
+        this.checkLock();
+        const { liquidity } = this.getOptimalLiquidity(Infinity, amountY);
+        this.setLiquidity(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;
+    }
+    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));
+    }
+    getUsableCollateralValueGivenPrice(price) {
+        return this.getCollateralValueGivenPrice(price);
+    }
+    getUsableCollateralValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
+        return this.getCollateralValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY);
+    }
+    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);
+    }
+    hasEnoughLiquidityGivenPriceAndDebt(price, debtX, debtY) {
+        const debtValue = this.getValueGivenPriceAndAmounts(price, debtX, debtY);
+        const collateralValue = this.getCollateralValueGivenPrice(price);
+        const collateralNeeded = debtValue * this.liquidationPenalty;
+        return collateralValue >= collateralNeeded;
+    }
+    hasEnoughUsableLiquidityGivenPriceAndDebt(price, debtX, debtY) {
+        const debtValue = this.getValueGivenPriceAndAmounts(price, debtX, debtY);
+        const collateralValue = this.getUsableCollateralValueGivenPrice(price);
+        const collateralNeeded = debtValue * this.liquidationPenalty;
+        return collateralValue >= collateralNeeded;
+    }
+    hasEnoughUsableLiquidityGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
+        const debtValue = this.getDebtValueGivenPrice(price) + this.getValueGivenPriceAndAmounts(price, deltaX, deltaY);
+        const collateralValue = this.getUsableCollateralValueGivenPriceAndDeltaLeverage(price, deltaX, deltaY);
+        const collateralNeeded = debtValue * this.liquidationPenalty;
+        return collateralValue >= collateralNeeded;
+    }
+    isLiquidatableGivenPriceAndDebt(price, debtX, debtY) {
+        return !this.hasEnoughUsableLiquidityGivenPriceAndDebt(price / this.safetyMargin, debtX, debtY)
+            || !this.hasEnoughUsableLiquidityGivenPriceAndDebt(price * this.safetyMargin, debtX, debtY);
+    }
+    isLiquidatableGivenPriceAndDeltaLeverage(price, deltaX, deltaY) {
+        return !this.hasEnoughUsableLiquidityGivenPriceAndDeltaLeverage(price / this.safetyMargin, deltaX, deltaY)
+            || !this.hasEnoughUsableLiquidityGivenPriceAndDeltaLeverage(price * this.safetyMargin, deltaX, deltaY);
+    }
+    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.hasEnoughLiquidityGivenPriceAndDebt(price, this.debtX, this.debtY);
+    }
+    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) {
+        const percentageToRemove = amount / this.getInitialDepositedX();
+        this.setLiquidity(this.initialLiquidity * (1 - percentageToRemove));
+    }
+    withdrawY(amount) {
+        const percentageToRemove = amount / this.getInitialDepositedY();
+        this.setLiquidity(this.initialLiquidity * (1 - percentageToRemove));
+    }
+    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));
+    }
+    /**
+     * 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;
+    }
+    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 = depositedX - this.getInitialDepositedX();
+        const additionalDepositY = depositedY - this.getInitialDepositedY();
+        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.GenericPosition = GenericPosition;
+exports.default = GenericPosition;