impermax-sdk 2.1.129 → 2.1.130

package/lib/onchain/account/lendingPool/nftlp/onchainAccountNftlpUniswapV3.js

@@ -76,8 +76,8 @@ class OnchainAccountNftlpUniswapV3 extends onchainAccountNftlp_1.default {
     }
     createNewPositionObject(fee, priceA, priceB, lockStateChange = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new uniswapV3Position_1.default(1, // fake liquidity for math
-            0, 0, yield this.getNftlp().getMarketPrice(), yield this.getNftlp().getOraclePrice(), priceA, priceB, yield this.getLendingPool().getSafetyMargin(), yield this.getLendingPool().getLiquidationPenalty(), lockStateChange);
+            // TODO check for priceA/priceB sanity
+            return new uniswapV3Position_1.default(0, 0, 0, yield this.getNftlp().getMarketPrice(), yield this.getNftlp().getOraclePrice(), priceA, priceB, yield this.getLendingPool().getSafetyMargin(), yield this.getLendingPool().getLiquidationPenalty(), lockStateChange);
         });
     }
     getPositionObject(tokenId) {

package/lib/onchain/interactions/lendingPool/nftlp/onchainInteractionsNftlpUniswapV3.js

@@ -72,7 +72,7 @@ class OnchainInteractionsNftlpUniswapV3 extends onchainInteractionsNftlp_1.defau
                 throw new Error("Opposite depositADelta and depositBDelta signs");
             const router = this.getUniswapV3Router();
             const actionsGetter = this.getActionsGetter();
-            const optimalLiquidity = positionObject.getOptimalLiquidityAtMarketPrice(depositADelta, depositBDelta);
+            const optimalLiquidity = positionObject.getOptimalLiquidity(depositADelta, depositBDelta);
             depositADelta = optimalLiquidity.amountX;
             depositBDelta = optimalLiquidity.amountY;
             // slightly increase repayAmount if we are repaying 100%

package/lib/utils/nftlpMath/uniswapV3Position.d.ts

@@ -14,15 +14,37 @@ export default class UniswapV3Position {
     liquidationPenalty: number;
     constructor(_liquidity: number, _debtX: number, _debtY: number, _marketPrice: number, _oraclePrice: number, _priceA: number, _priceB: number, _safetyMargin: number, _liquidationPenalty: number, _lockStateChange: boolean);
     private checkLock;
+    /**
+     * PRIVATE
+     */
+    private getRealXGivenLiquidityAndPrice;
+    private getRealYGivenLiquidityAndPrice;
+    private getRealXGivenLiquidity;
+    private getRealYGivenLiquidity;
+    private getRealXGivenPrice;
+    private getRealYGivenPrice;
+    private getLiquidity;
+    /**
+     * PUBLIC SETTERS
+     */
     setLiquidity(_liquidity: number): void;
+    setRealX(amountX: number): void;
+    setRealY(amountY: number): void;
     setDebtX(_debtX: number): void;
     setDebtY(_debtY: number): void;
-    private getVirtualX;
-    private getVirtualY;
-    getRealX(price: number): number;
-    getRealY(price: number): number;
-    getLiquidity(price: number, amountX: number, amountY: number): number;
-    getOptimalLiquidityAtMarketPrice(amountX: number, amountY: number): {
+    /**
+     * PUBLIC GETTERS
+     */
+    getRealX(): number;
+    getRealY(): number;
+    getNetX(): number;
+    getNetY(): number;
+    getLiquidationRange(): {
+        priceA: number;
+        priceB: number;
+    };
+    leverage(): void;
+    getOptimalLiquidity(amountX: number, amountY: number): {
         liquidity: number;
         amountX: number;
         amountY: number;

package/lib/utils/nftlpMath/uniswapV3Position.js

@@ -1,5 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+function getVirtualX(liquidity, price) {
+    return liquidity / Math.sqrt(price);
+}
+function getVirtualY(liquidity, price) {
+    return liquidity * Math.sqrt(price);
+}
+function getRealX(liquidity, price, priceA, priceB) {
+    const surplusX = getVirtualX(liquidity, priceB);
+    const virtualX = getVirtualX(liquidity, Math.max(price, priceA));
+    return Math.max(virtualX - surplusX, 0);
+}
+function getRealY(liquidity, price, priceA, priceB) {
+    const surplusY = getVirtualY(liquidity, priceA);
+    const virtualY = getVirtualY(liquidity, Math.min(price, priceB));
+    return Math.max(virtualY - surplusY, 0);
+}
 class UniswapV3Position {
     // TODO add fee logic
     constructor(_liquidity, _debtX, _debtY, _marketPrice, _oraclePrice, _priceA, _priceB, _safetyMargin, _liquidationPenalty, _lockStateChange) {
@@ -18,10 +34,53 @@ class UniswapV3Position {
         if (this.lockStateChange)
             throw Error("Can't change state of original position object");
     }
+    /**
+     * PRIVATE
+     */
+    getRealXGivenLiquidityAndPrice(liquidity, price) {
+        return getRealX(liquidity, price, this.priceA, this.priceB);
+    }
+    getRealYGivenLiquidityAndPrice(liquidity, price) {
+        return getRealY(liquidity, price, this.priceA, this.priceB);
+    }
+    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);
+    }
+    getLiquidity(price, amountX, amountY) {
+        if (amountX == 0) {
+            return amountY / Math.sqrt(price);
+        }
+        if (amountY == 0) {
+            return amountX * Math.sqrt(price);
+        }
+        return amountX / (1 / Math.sqrt(price) - 1 / Math.sqrt(this.priceB));
+    }
+    /**
+     * PUBLIC SETTERS
+     */
     setLiquidity(_liquidity) {
         this.checkLock();
         this.liquidity = _liquidity;
     }
+    setRealX(amountX) {
+        this.checkLock();
+        const { liquidity } = this.getOptimalLiquidity(amountX, Infinity);
+        this.liquidity = liquidity;
+    }
+    setRealY(amountY) {
+        this.checkLock();
+        const { liquidity } = this.getOptimalLiquidity(Infinity, amountY);
+        this.liquidity = liquidity;
+    }
     setDebtX(_debtX) {
         this.checkLock();
         this.debtX = _debtX;
@@ -30,40 +89,38 @@ class UniswapV3Position {
         this.checkLock();
         this.debtY = _debtY;
     }
-    getVirtualX(price) {
-        return this.liquidity / Math.sqrt(price);
+    /**
+     * PUBLIC GETTERS
+     */
+    getRealX() {
+        return this.getRealXGivenLiquidityAndPrice(this.liquidity, this.marketPrice);
     }
-    getVirtualY(price) {
-        return this.liquidity * Math.sqrt(price);
+    getRealY() {
+        return this.getRealYGivenLiquidityAndPrice(this.liquidity, this.marketPrice);
     }
-    getRealX(price) {
-        const surplusX = this.getVirtualX(this.priceB);
-        const virtualX = this.getVirtualX(Math.max(price, this.priceA));
-        return Math.max(virtualX - surplusX, 0);
+    getNetX() {
+        return this.getRealX() - this.debtX;
     }
-    getRealY(price) {
-        const surplusY = this.getVirtualY(this.priceA);
-        const virtualY = this.getVirtualY(Math.min(price, this.priceB));
-        return Math.max(virtualY - surplusY, 0);
+    getNetY() {
+        return this.getRealY() - this.debtY;
     }
-    getLiquidity(price, amountX, amountY) {
-        if (amountX == 0) {
-            return amountY / Math.sqrt(price);
-        }
-        if (amountY == 0) {
-            return amountX * Math.sqrt(price);
-        }
-        return amountX / (1 / Math.sqrt(price) - 1 / Math.sqrt(this.priceB));
+    getLiquidationRange() {
+        // TODO
+        return {
+            priceA: 0,
+            priceB: Infinity,
+        };
+    }
+    leverage() {
     }
     // amountX and amountY are expected to have the same sign
-    getOptimalLiquidityAtMarketPrice(amountX, amountY) {
-        let liquidity;
+    getOptimalLiquidity(amountX, amountY) {
         if (amountX != 0 && amountY != 0) {
-            const sampleX = this.getRealX(this.marketPrice);
-            const sampleY = this.getRealY(this.marketPrice);
+            const sampleX = this.getRealXGivenLiquidity(1);
+            const sampleY = this.getRealYGivenLiquidity(1);
             if (sampleX == 0)
                 amountX = 0;
-            else if (sampleX == 0)
+            else if (sampleY == 0)
                 amountY = 0;
             else {
                 if (Math.abs(amountX) / sampleX > Math.abs(amountY) / sampleY)
@@ -72,7 +129,7 @@ class UniswapV3Position {
                     amountY = amountX / sampleX * sampleY;
             }
         }
-        liquidity = this.getLiquidity(this.marketPrice, amountX, amountY);
+        const liquidity = this.getLiquidity(this.marketPrice, amountX, amountY);
         return { liquidity, amountX, amountY };
     }
 }

package/package.json

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