impermax-sdk 1.1.59 → 1.1.61

package/lib/abis/contracts/ICollateral.json

@@ -713,6 +713,26 @@
             "stateMutability": "nonpayable",
             "type": "function"
         },
+        {
+            "constant": false,
+            "inputs": [],
+            "name": "geReserves",
+            "outputs": [
+                {
+                    "internalType": "uint112",
+                    "name": "reserve0",
+                    "type": "uint112"
+                },
+                {
+                    "internalType": "uint112",
+                    "name": "reserve1",
+                    "type": "uint112"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
         {
             "constant": false,
             "inputs": [],

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

@@ -2,7 +2,7 @@ import OnchainAccount from '../index';
 import { PoolTokenType } from '../../../config/types';
 import OnchainAccountCollateral from './onchainAccountCollateral';
 import OnchainAccountBorrowable from './onchainAccountBorrowable';
-import { Changes, PendingRewardUI, Values } from '../../onchainTypes';
+import { Changes, PendingRewardUI } from '../../onchainTypes';
 import OnchainLendingPool from '../../impermaxFactory/lendingPool';
 import OnchainAccountPoolToken from '../onchainAccountPoolToken';
 import OnchainInteractionsLendingPool from '../../interactions/lendingPool';
@@ -50,10 +50,7 @@ export default class OnchainAccountLendingPool {
         valueB: number;
     }>;
     getLeverage(changes?: Changes): Promise<number>;
-    getLiquidationPriceSwingsGivenValues(values: Values): Promise<[number, number]>;
-    getLiquidationPricesGivenValues(values: Values): Promise<[number, number]>;
-    getLiquidationPriceSwings(changes?: Changes): Promise<[number, number]>;
-    getLiquidationPrices(changes?: Changes): Promise<[number, number]>;
+    getLiquidationPrices(changes?: Changes): Promise<number[]>;
     getMaxLeverage(): Promise<number>;
     getMaxDeleverage(slippage: number): Promise<number>;
     getAvailableReward(): Promise<PendingRewardUI[]>;

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

@@ -16,6 +16,8 @@ const types_1 = require("../../../config/types");
 const onchainAccountCollateral_1 = __importDefault(require("./onchainAccountCollateral"));
 const onchainAccountBorrowable_1 = __importDefault(require("./onchainAccountBorrowable"));
 const onchainTypes_1 = require("../../onchainTypes");
+const factories_1 = require("../../../config/factories");
+const lliquidity_math_1 = require("../../../utils/lliquidity-math");
 class OnchainAccountLendingPool {
     constructor(account, lendingPool) {
         this.cache = {};
@@ -155,46 +157,62 @@ class OnchainAccountLendingPool {
         });
     }
     // Liquidation Threshold
-    getLiquidationPriceSwingsGivenValues(values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!values)
-                return [Infinity, Infinity];
-            const { valueCollateral, valueA, valueB } = values;
-            if (valueA + valueB == 0)
-                return [Infinity, Infinity];
-            const safetyMargin = yield this.getSafetyMargin();
-            const liquidationPenalty = yield this.getLiquidationPenalty();
-            const actualCollateral = valueCollateral / liquidationPenalty;
-            const rad = Math.sqrt(Math.pow(actualCollateral, 2) - 4 * valueA * valueB);
-            if (!rad)
-                return [0, 0];
-            const t = (actualCollateral + rad) / (2 * Math.sqrt(safetyMargin));
-            let priceSwingA = Math.pow((t / valueA), 2);
-            let priceSwingB = Math.pow((t / valueB), 2);
-            return [priceSwingA, priceSwingB];
-        });
+    /*public async getLiquidationPriceSwingsGivenValues(values: Values) : Promise<[number, number]> {
+      if (!values) return [Infinity, Infinity];
+      const { valueCollateral, valueA, valueB } = values;
+      if (valueA + valueB == 0) return [Infinity, Infinity];
+      const safetyMargin = await this.getSafetyMargin();
+      const liquidationPenalty = await this.getLiquidationPenalty();
+      const actualCollateral = valueCollateral / liquidationPenalty;
+      const rad = Math.sqrt(actualCollateral ** 2 - 4 * valueA * valueB);
+      if (!rad) return [0, 0];
+      const t = (actualCollateral + rad) / (2 * Math.sqrt(safetyMargin));
+      let priceSwingA = (t / valueA) ** 2;
+      let priceSwingB = (t / valueB) ** 2;
+      return [priceSwingA, priceSwingB];
     }
-    getLiquidationPricesGivenValues(values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentPrice = yield this.lendingPool.getTWAPPrice();
-            const [priceSwingA, priceSwingB] = yield this.getLiquidationPriceSwingsGivenValues(values);
-            return !this.account.getOnchain().priceInverted ? [currentPrice / priceSwingB, currentPrice * priceSwingA] : [currentPrice / priceSwingA, currentPrice * priceSwingB];
-        });
+    public async getLiquidationPricesGivenValues(values: Values) : Promise<[number, number]> {
+      const currentPrice = await this.lendingPool.getTWAPPrice();
+      const [priceSwingA, priceSwingB] = await this.getLiquidationPriceSwingsGivenValues(values);
+      return !this.account.getOnchain().priceInverted ? [currentPrice / priceSwingB, currentPrice * priceSwingA] : [currentPrice / priceSwingA, currentPrice * priceSwingB];
     }
-    getLiquidationPriceSwings(changes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!changes)
-                changes = onchainTypes_1.NO_CHANGES;
-            const values = yield this.getValues(changes);
-            return this.getLiquidationPriceSwingsGivenValues(values);
-        });
+    public async getLiquidationPriceSwings(changes?: Changes) {
+      if (!changes) changes = NO_CHANGES;
+      const values = await this.getValues(changes);
+      return this.getLiquidationPriceSwingsGivenValues(values);
     }
+    public async getLiquidationPrices(changes?: Changes) {
+      if (!changes) changes = NO_CHANGES;
+      const values = await this.getValues(changes);
+      return this.getLiquidationPricesGivenValues(values);
+    }*/
     getLiquidationPrices(changes) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!changes)
                 changes = onchainTypes_1.NO_CHANGES;
-            const values = yield this.getValues(changes);
-            return this.getLiquidationPricesGivenValues(values);
+            const collateralAmount = (yield this.getCollateral().getDeposited()) + changes.changeCollateral;
+            const debtA = (yield this.getBorrowableA().getBorrowed()) + changes.changeBorrowedA;
+            const debtB = (yield this.getBorrowableB().getBorrowed()) + changes.changeBorrowedB;
+            const safetyMargin = yield this.getSafetyMargin();
+            const liquidationPenalty = yield this.getLiquidationPenalty();
+            const actualCollateral = collateralAmount / liquidationPenalty;
+            const reservesRatio = yield this.lendingPool.getReservesValueRatio();
+            const [priceA, priceB] = yield this.lendingPool.getPriceDenomLP();
+            const collateralA = actualCollateral * reservesRatio / (1 + reservesRatio) / priceA;
+            const collateralB = actualCollateral / (1 + reservesRatio) / priceB;
+            let priceSwingA, priceSwingB;
+            if (factories_1.STABLE_FACTORIES.includes(this.lendingPool.getImpermaxFactory().getFactory())) {
+                priceSwingA = (0, lliquidity_math_1.solidlyStable_getLiquidatableXPriceDecrease)(collateralA, collateralB, debtA, debtB) * safetyMargin;
+                priceSwingB = (0, lliquidity_math_1.solidlyStable_getLiquidatableXPriceDecrease)(collateralB, collateralA, debtB, debtA) * safetyMargin;
+            }
+            else {
+                priceSwingA = (0, lliquidity_math_1.uniswapV2_getLiquidatableXPriceDecrease)(collateralA, collateralB, debtA, debtB) * safetyMargin;
+                priceSwingB = (0, lliquidity_math_1.uniswapV2_getLiquidatableXPriceDecrease)(collateralB, collateralA, debtB, debtA) * safetyMargin;
+            }
+            const currentPrice = yield this.lendingPool.getTWAPPrice();
+            return !this.account.getOnchain().priceInverted
+                ? [currentPrice * priceSwingA, currentPrice / priceSwingB]
+                : [currentPrice * priceSwingB, currentPrice / priceSwingA];
         });
     }
     // Max Leverage

package/lib/onchain/impermaxFactory/lendingPool/onchainLendingPool.d.ts

@@ -39,6 +39,8 @@ export default class OnchainLendingPool {
     getPriceDenomLP(): Promise<[number, number]>;
     getMarketPriceDenomLP(): Promise<[number, number]>;
     getMarketPrice(): Promise<number>;
+    private initializeReservesValueRatio;
+    getReservesValueRatio(): Promise<number>;
     private initializeTWAPPrice;
     getTWAPPrice(): Promise<number>;
     private initializeStakedLPExchangeRate;

package/lib/onchain/impermaxFactory/lendingPool/onchainLendingPool.js

@@ -16,7 +16,7 @@ const types_1 = require("../../../config/types");
 const onchainCollateral_1 = __importDefault(require("./onchainCollateral"));
 const onchainBorrowable_1 = __importDefault(require("./onchainBorrowable"));
 const factories_1 = require("../../../config/factories");
-const price_from_reserves_1 = require("../../../utils/price-from-reserves");
+const lliquidity_math_1 = require("../../../utils/lliquidity-math");
 class OnchainLendingPool {
     constructor(impermaxFactory, pairAddress) {
         this.cache = {};
@@ -182,12 +182,98 @@ class OnchainLendingPool {
             const [reserve0, reserve1] = yield this.getReserves();
             const priceInverted = this.impermaxFactory.getOnchain().priceInverted;
             if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory()))
-                return (0, price_from_reserves_1.getPriceFromReservesSolidlyStable)(reserve0, reserve1, priceInverted);
+                return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1, priceInverted);
             else
-                return (0, price_from_reserves_1.getPriceFromReservesUniswapV2)(reserve0, reserve1, priceInverted);
+                return (0, lliquidity_math_1.uniswapV2_getPriceFromReserves)(reserve0, reserve1, priceInverted);
+        });
+    }
+    /*
+      // TWAP Reserves
+      // NON VA BENE, voglio tornare le riserve dello stakedLPToken o di tutto? DIPORCO
+      private async initializeTWAPReserves() : Promise<[number, number] | null> {
+        try {
+          const collateral = await this.getCollateral().getPoolToken();
+          const decimalsA = await this.getBorrowableA().getDecimals();
+          const decimalsB = await this.getBorrowableB().getDecimals();
+    
+          if (STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+            const { reserve0, reserve1 } = await collateral.methods.getReserves().call();
+            return [
+              reserve0 / Math.pow(10, decimalsA),
+              reserve1 / Math.pow(10, decimalsB)
+            ];
+          }
+    
+          const [reserve0, reserve1] = await this.getReserves();
+          const currentPrice = uniswapV2_getPriceFromReserves(reserve0, reserve1);
+          let TWAPprice;
+          if (SOLIDEX_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+            TWAPprice = await collateral.methods.getTwapPrice112x112().call();
+          } else {
+            TWAPprice = (await this.impermaxFactory.getSimpleUniswapOracle().methods.getResult(this.pairAddress).call()).price;
+          }
+          TWAPprice = TWAPprice / 2**112 * Math.pow(10, decimalsA) / Math.pow(10, decimalsB);
+    
+          const adj = Math.sqrt(currentPrice / TWAPprice);
+          return [
+            reserve0 * adj,
+            reserve1 / adj,
+          ]
+        }
+        catch (e) {
+          // Oracle is not initialized yet
+          return null;
+        }
+      }
+      public async getTWAPReserves() : Promise<[number, number] | null> {
+        if (!this.cache.TWAPReserves) this.cache.TWAPReserves = this.initializeTWAPReserves();
+        return this.cache.TWAPReserves;
+      }
+    
+      // TWAP Price
+      private async initializeTWAPPrice() : Promise<number> {
+        const TWAPReserves = await this.getTWAPReserves();
+        if (!TWAPReserves) return 0;
+        const reserve0 = TWAPReserves[0];
+        const reserve1 = TWAPReserves[1];
+    
+        if (STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+          return solidlyStable_getPriceFromReserves(reserve0, reserve1);
+        } else {
+          return uniswapV2_getPriceFromReserves(reserve0, reserve1);
+        }
+      }*/
+    // Value of reserveA / reserveB
+    initializeReservesValueRatio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+                const collateral = yield this.getCollateral().getPoolToken();
+                const decimalsA = yield this.getBorrowableA().getDecimals();
+                const decimalsB = yield this.getBorrowableB().getDecimals();
+                const { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
+                const [price0, price1] = yield this.getPriceDenomLP();
+                return twapReserve0 * price0 / (twapReserve1 * price1);
+            }
+            else {
+                return 1;
+            }
+        });
+    }
+    getReservesValueRatio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+                const collateral = yield this.getCollateral().getPoolToken();
+                const decimalsA = yield this.getBorrowableA().getDecimals();
+                const decimalsB = yield this.getBorrowableB().getDecimals();
+                const { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
+                const [price0, price1] = yield this.getPriceDenomLP();
+                return twapReserve0 * price0 / (twapReserve1 * price1);
+            }
+            else {
+                return 1;
+            }
         });
     }
-    // TWAP Price
     initializeTWAPPrice() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -196,7 +282,7 @@ class OnchainLendingPool {
                 const decimalsB = yield this.getBorrowableB().getDecimals();
                 if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
                     const { twapReserve0, twapReserve1 } = yield collateral.methods.getTwapReserves().call();
-                    return (0, price_from_reserves_1.getPriceFromReservesSolidlyStable)(twapReserve0 / Math.pow(10, decimalsA), twapReserve1 / Math.pow(10, decimalsB));
+                    return (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(twapReserve0 / Math.pow(10, decimalsA), twapReserve1 / Math.pow(10, decimalsB));
                 }
                 let price;
                 if (factories_1.SOLIDEX_FACTORIES.includes(this.impermaxFactory.getFactory())) {

package/lib/onchain/interactions/lendingPool/onchainInteractionsLendingPool.js

@@ -55,6 +55,7 @@ class OnchainInteractionsLendingPool {
             const currentLeverage = yield accountLendingPool.getLeverage();
             const collateralValue = yield accountLendingPool.getCollateral().getDeposited();
             const changeCollateralValue = (collateralValue * leverage / currentLeverage - collateralValue) * adjustFactor;
+            // TODO wrong methodology, it's better to use the reserve ratio
             const valueForEach = changeCollateralValue / 2;
             const bAmountA = priceA > 0 ? valueForEach / priceA : 0;
             const bAmountB = priceB > 0 ? valueForEach / priceB : 0;

package/lib/utils/lliquidity-math.d.ts

@@ -0,0 +1,25 @@
+export declare function uniswapV2_getPriceFromReserves(x: number, y: number, priceInverted?: boolean): number;
+/**
+ * Find liquidation threshold given X/Y price decrease
+ * Returns a price ratio in the [0,1] range
+ */
+export declare function uniswapV2_getLiquidatableXPriceDecrease(x0: number, y0: number, debtX: number, debtY: number): number;
+/**
+ * Calculate X/Y price
+ */
+export declare function solidlyStable_getPriceFromReserves(x: number, y: number, priceInverted?: boolean): number;
+export declare function solidlyStable_k(x: number, y: number): number;
+/**
+ * Calculate output from reserves y given input from x
+ */
+export declare function solidlyStable_yOut(xIn: number, x0: number, y0: number): number;
+export declare function solidlyStable_getEquityValue(x: number, y: number, debtX: number, debtY: number): number;
+/**
+ * Find xIn input amount that would bring the equity to negative
+ */
+export declare function solidlyStable_getXInMargin(x0: number, y0: number, debtX: number, debtY: number): number;
+/**
+ * Find liquidation threshold given X/Y price decrease
+ * Returns a price ratio in the [0,1] range
+ */
+export declare function solidlyStable_getLiquidatableXPriceDecrease(x0: number, y0: number, debtX: number, debtY: number): number;

package/lib/utils/lliquidity-math.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solidlyStable_getLiquidatableXPriceDecrease = exports.solidlyStable_getXInMargin = exports.solidlyStable_getEquityValue = exports.solidlyStable_yOut = exports.solidlyStable_k = exports.solidlyStable_getPriceFromReserves = exports.uniswapV2_getLiquidatableXPriceDecrease = exports.uniswapV2_getPriceFromReserves = void 0;
+/**
+ * Calculate X/Y price
+ */
+const assert = require("assert");
+function uniswapV2_getPriceFromReserves(x, y, priceInverted = false) {
+    const price = y / x;
+    return !priceInverted ? price : 1 / price;
+}
+exports.uniswapV2_getPriceFromReserves = uniswapV2_getPriceFromReserves;
+/**
+ * Find liquidation threshold given X/Y price decrease
+ * Returns a price ratio in the [0,1] range
+ */
+function uniswapV2_getLiquidatableXPriceDecrease(x0, y0, debtX, debtY) {
+    const k = x0 * y0;
+    const x = k / debtY * (1 + Math.sqrt(1 - debtY * debtX / k));
+    if (x <= x0)
+        return 1;
+    if (x == Infinity)
+        return 0;
+    const y = k / x;
+    const price0 = uniswapV2_getPriceFromReserves(x0, y0);
+    const price = uniswapV2_getPriceFromReserves(x, y);
+    assert(price < price0, "Assertion error: uniswapV2_getLiquidatableXPriceDecrease price >= price0");
+    return price / price0;
+}
+exports.uniswapV2_getLiquidatableXPriceDecrease = uniswapV2_getLiquidatableXPriceDecrease;
+/**
+ * Calculate X/Y price
+ */
+function solidlyStable_getPriceFromReserves(x, y, priceInverted = false) {
+    const N = 3 * Math.pow(x, 2) * y + Math.pow(y, 3);
+    const D = 3 * Math.pow(y, 2) * x + Math.pow(x, 3);
+    const price = N / D;
+    return !priceInverted ? price : 1 / price;
+}
+exports.solidlyStable_getPriceFromReserves = solidlyStable_getPriceFromReserves;
+function solidlyStable_k(x, y) {
+    return Math.pow(x, 3) * y + Math.pow(y, 3) * x;
+}
+exports.solidlyStable_k = solidlyStable_k;
+/**
+ * Calculate output from reserves y given input from x
+ */
+function solidlyStable_yOut(xIn, x0, y0) {
+    const k0 = solidlyStable_k(x0, y0);
+    const x = x0 + xIn;
+    let y = y0;
+    // search for new y
+    for (let i = 0; i < 16; i++) {
+        const yPrev = y;
+        const k = solidlyStable_k(x, y);
+        const d = 3 * x * Math.pow(y, 2) + Math.pow(x, 3);
+        if (k < k0) {
+            const dy = (k0 - k) / d;
+            y = y + dy;
+        }
+        else {
+            const dy = (k - k0) / d;
+            y = y - dy;
+        }
+        if (Math.abs((y - yPrev) / y) < 1e-10) {
+            break;
+        }
+    }
+    return y0 - y;
+}
+exports.solidlyStable_yOut = solidlyStable_yOut;
+function solidlyStable_getEquityValue(x, y, debtX, debtY) {
+    const price = solidlyStable_getPriceFromReserves(x, y);
+    const lpValue = x * price + y;
+    const debtValue = debtX * price + debtY;
+    return lpValue - debtValue;
+}
+exports.solidlyStable_getEquityValue = solidlyStable_getEquityValue;
+/**
+ * Find xIn input amount that would bring the equity to negative
+ */
+function solidlyStable_getXInMargin(x0, y0, debtX, debtY) {
+    if (solidlyStable_getEquityValue(x0, y0, debtX, debtY) < 0)
+        return 0;
+    const STARTING_POINT = x0 * 1e9;
+    let xIn = STARTING_POINT;
+    let xInPrev = 0;
+    // binary search for xIn
+    for (let i = 0; i < 1000; i++) {
+        const x = x0 + xIn;
+        const y = y0 - solidlyStable_yOut(xIn, x0, y0);
+        const jump = Math.abs(xIn - xInPrev);
+        if (Math.abs(jump / x0) < 1e-10)
+            break;
+        xInPrev = xIn;
+        if (solidlyStable_getEquityValue(x, y, debtX, debtY) < 0)
+            xIn -= jump;
+        else {
+            if (xIn == STARTING_POINT)
+                return Infinity;
+            xIn += jump;
+        }
+    }
+    return xIn;
+}
+exports.solidlyStable_getXInMargin = solidlyStable_getXInMargin;
+/**
+ * Find liquidation threshold given X/Y price decrease
+ * Returns a price ratio in the [0,1] range
+ */
+function solidlyStable_getLiquidatableXPriceDecrease(x0, y0, debtX, debtY) {
+    const xIn = solidlyStable_getXInMargin(x0, y0, debtX, debtY);
+    if (xIn == 0)
+        return 1;
+    if (xIn == Infinity)
+        return 0;
+    const x = x0 + xIn;
+    const y = y0 - solidlyStable_yOut(xIn, x0, y0);
+    const price0 = solidlyStable_getPriceFromReserves(x0, y0);
+    const price = solidlyStable_getPriceFromReserves(x, y);
+    assert(price < price0, "Assertion error: solidlyStable_getLiquidatableXPriceDecrease price >= price0");
+    return price / price0;
+}
+exports.solidlyStable_getLiquidatableXPriceDecrease = solidlyStable_getLiquidatableXPriceDecrease;

package/lib/utils/price-from-reserves.js

@@ -11,10 +11,9 @@ function getPriceFromReservesUniswapV2(x, y, priceInverted = true) {
 }
 exports.getPriceFromReservesUniswapV2 = getPriceFromReservesUniswapV2;
 function getPriceFromReservesSolidlyStable(x, y, priceInverted = false) {
-    const N = 3 * x ^ 2 * y + y ^ 3;
-    const D = 3 * y ^ 2 * x + x ^ 3;
+    const N = 3 * Math.pow(x, 2) * y + Math.pow(y, 3);
+    const D = 3 * Math.pow(y, 2) * x + Math.pow(x, 3);
     const price = N / D;
-    console.log(x, y, price);
     return !priceInverted ? price : 1 / price;
 }
 exports.getPriceFromReservesSolidlyStable = getPriceFromReservesSolidlyStable;

package/package.json

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