impermax-sdk 2.1.239 → 2.1.240

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

@@ -37,7 +37,15 @@ class OffchainAccountCollateralV2 extends offchainAccountPoolToken_1.default {
         //if (await this.getLendingPool().getLendingPool().isStable()) {
         // TODO return stablePosition
         //} else {
-        return new position_1.UniswapV2Position(await this.getLiquidity(), await this.getLendingPool().getBorrowableA().getBorrowedAmount(), await this.getLendingPool().getBorrowableB().getBorrowedAmount(), await this.getLendingPool().getLendingPool().getMarketPrice(), await this.getLendingPool().getLendingPool().getMarketPrice(), await this.getLendingPool().getSafetyMargin(), await this.getLendingPool().getLiquidationPenalty(), lockStateChange);
+        return new position_1.UniswapV2Position({
+            liquidity: await this.getLiquidity(),
+            debtX: await this.getLendingPool().getBorrowableA().getBorrowedAmount(),
+            debtY: await this.getLendingPool().getBorrowableB().getBorrowedAmount(),
+            marketPrice: await this.getLendingPool().getLendingPool().getMarketPrice(),
+            oraclePrice: await this.getLendingPool().getLendingPool().getMarketPrice(),
+            safetyMargin: await this.getLendingPool().getSafetyMargin(),
+            liquidationPenalty: await this.getLendingPool().getLiquidationPenalty(),
+        });
         //}
     }
     async getPositionObject() {

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

@@ -37,7 +37,18 @@ class OnchainAccountCollateralV2 extends onchainAccountPoolToken_1.default {
         //if (await this.getLendingPool().getLendingPool().isStable()) {
         // TODO return stablePosition
         //} else {
-        return new position_1.UniswapV2Position(await this.getLiquidity(), await this.getLendingPool().getBorrowableA().getBorrowed(), await this.getLendingPool().getBorrowableB().getBorrowed(), await this.getLendingPool().getLendingPool().getMarketPrice(), await this.getLendingPool().getLendingPool().getTWAPPrice(), await this.getLendingPool().getSafetyMargin(), await this.getLendingPool().getLiquidationPenalty(), lockStateChange);
+        return new position_1.UniswapV2Position({
+            liquidity: await this.getLiquidity(),
+            debtX: await this.getLendingPool().getBorrowableA().getBorrowed(),
+            debtY: await this.getLendingPool().getBorrowableB().getBorrowed(),
+            marketPrice: await this.getLendingPool().getLendingPool().getMarketPrice(),
+            oraclePrice: await this.getLendingPool().getLendingPool().getTWAPPrice(),
+            safetyMargin: await this.getLendingPool().getSafetyMargin(),
+            liquidationPenalty: await this.getLendingPool().getLiquidationPenalty(),
+            availableToBorrowX: await this.getLendingPool().getLendingPool().getBorrowableA().getAvailableToBorrow(),
+            availableToBorrowY: await this.getLendingPool().getLendingPool().getBorrowableB().getAvailableToBorrow(),
+            lockStateChange,
+        });
         //}
     }
 }

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

@@ -1,4 +1,16 @@
 import type { Position } from "../interface";
+export interface UniswapV2PositionParams {
+    liquidity: number;
+    debtX: number;
+    debtY: number;
+    marketPrice: number;
+    oraclePrice: number;
+    safetyMargin: number;
+    liquidationPenalty: number;
+    availableToBorrowX?: number;
+    availableToBorrowY?: number;
+    lockStateChange?: boolean;
+}
 export declare class UniswapV2Position implements Position {
     lockStateChange: boolean;
     state: number;
@@ -15,8 +27,9 @@ export declare class UniswapV2Position implements Position {
     oraclePrice: number;
     safetyMargin: number;
     liquidationPenalty: number;
-    constructor(_liquidity: number, // lp amount fixed by exchangeRate and k
-    _debtX: number, _debtY: number, _marketPrice: number, _oraclePrice: number, _safetyMargin: number, _liquidationPenalty: number, _lockStateChange: boolean);
+    availableToBorrowX: number;
+    availableToBorrowY: number;
+    constructor(params: UniswapV2PositionParams);
     private checkLock;
     /**
      * PRIVATE SETTERS
@@ -47,18 +60,24 @@ export declare class UniswapV2Position implements Position {
     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
      */
@@ -92,6 +111,14 @@ export declare class UniswapV2Position implements Position {
         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(): {

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

@@ -10,19 +10,20 @@ function getRealY(liquidity, price) {
 const LOWEST_PRICE = 1 / 1e18;
 const HIGHEST_PRICE = 1e18;
 class UniswapV2Position {
-    constructor(_liquidity, // lp amount fixed by exchangeRate and k
-    _debtX, _debtY, _marketPrice, _oraclePrice, _safetyMargin, _liquidationPenalty, _lockStateChange) {
-        this.liquidity = _liquidity;
-        this.debtX = _debtX;
-        this.debtY = _debtY;
-        this.initialLiquidity = _liquidity;
-        this.initialDebtX = _debtX;
-        this.initialDebtY = _debtY;
-        this.marketPrice = _marketPrice;
-        this.oraclePrice = _oraclePrice;
-        this.safetyMargin = _safetyMargin;
-        this.liquidationPenalty = _liquidationPenalty;
-        this.lockStateChange = _lockStateChange;
+    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() {
@@ -126,6 +127,10 @@ class UniswapV2Position {
     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();
     }
@@ -147,13 +152,26 @@ class UniswapV2Position {
         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);
     }
@@ -184,6 +202,29 @@ class UniswapV2Position {
         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
      */
@@ -200,10 +241,20 @@ class UniswapV2Position {
         this.setRealY(Math.max(this.getInitialRealY() - amount, 0));
     }
     borrowX(amount) {
-        this.setDebtX(this.initialDebtX + amount);
+        if (amount > this.availableToBorrowX) {
+            throw new Error("Trying to borrow more than available liquidity");
+        }
+        else {
+            this.setDebtX(this.initialDebtX + amount);
+        }
     }
     borrowY(amount) {
-        this.setDebtY(this.initialDebtY + 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));
@@ -284,6 +335,71 @@ class UniswapV2Position {
             amountY: Number.isNaN(amountY) ? 0 : amountY ?? 0,
         };
     }
+    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())
@@ -296,31 +412,39 @@ class UniswapV2Position {
         }
         const realX = this.getRealX();
         const realY = this.getRealY();
-        const projectedRealX = realX * highLeverage / currentLeverage;
-        const projectedRealY = realY * highLeverage / currentLeverage;
-        const projectedDebtX = this.debtX + projectedRealX - realX;
-        const projectedDebtY = this.debtY + projectedRealY - realY;
-        const normalizedDeltaDebtX = projectedDebtX * currentLeverage / highLeverage - this.debtX;
-        const normalizedDeltaDebtY = projectedDebtY * currentLeverage / highLeverage - this.debtY;
-        const [deltaDebtX, deltaDebtY] = this.getMaxDeltaDebtInRange(0, 0, normalizedDeltaDebtX, normalizedDeltaDebtY);
+        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 debtValue = this.getValueGivenAmounts(this.debtX + deltaDebtX, this.debtY + deltaDebtY);
-        const equityValue = collateralValue - debtValue;
+        const additionalValue = this.getValueGivenAmounts(deltaX, deltaY);
         if (setLiquidityToZero)
             this.liquidity = 0;
-        return collateralValue / equityValue;
+        return (collateralValue + additionalValue) / collateralValue * currentLeverage;
     }
     getMinLeverage() {
         const depositedX = this.getDepositedX();
         const depositedY = this.getDepositedY();
-        if (depositedX >= this.debtX && depositedY >= this.debtY)
+        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;
-        // TODO binary search
-        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) {
@@ -334,8 +458,8 @@ class UniswapV2Position {
             }
         }
         return {
-            amountX: depositedX * percentage,
-            amountY: depositedY * percentage,
+            amountX: depositedX * percentage - additionalDepositX,
+            amountY: depositedY * percentage - additionalDepositY,
         };
     }
     getMaxBorrowableX() {
@@ -344,7 +468,7 @@ class UniswapV2Position {
         const equityValue = this.getEquityValue();
         const highDebtX = this.getAmountXGivenValue(equityValue);
         const [debtX,] = this.getMaxDeltaDebtInRange(0, 0, highDebtX, 0);
-        return debtX + this.debtX - this.initialDebtX;
+        return Math.min(debtX + this.debtX - this.initialDebtX, this.availableToBorrowX);
     }
     getMaxBorrowableY() {
         if (this.isLiquidatable())
@@ -352,7 +476,7 @@ class UniswapV2Position {
         const equityValue = this.getEquityValue();
         const highDebtY = this.getAmountYGivenValue(equityValue);
         const [, debtY] = this.getMaxDeltaDebtInRange(0, 0, 0, highDebtY);
-        return debtY + this.debtY - this.initialDebtY;
+        return Math.min(debtY + this.debtY - this.initialDebtY, this.availableToBorrowY);
     }
 }
 exports.UniswapV2Position = UniswapV2Position;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impermax-sdk",
-  "version": "2.1.239",
+  "version": "2.1.240",
   "description": "",
   "main": "./lib/index.js",
   "module": "./lib/index.js",