impermax-sdk 1.1.70 → 1.1.72

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

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const onchainTypes_1 = require("../../onchainTypes");
 const types_1 = require("../../../config/types");
 const onchainAccountPoolToken_1 = __importDefault(require("../onchainAccountPoolToken"));
 class OnchainAccountBorrowable extends onchainAccountPoolToken_1.default {
@@ -71,19 +70,46 @@ class OnchainAccountBorrowable extends onchainAccountPoolToken_1.default {
         });
     }
     // Max OffchainBorrowable
+    /*public async getMaxBorrowable() : Promise<number> {
+      const availableCash = await this.poolToken.getTotalBalance();
+      const { valueCollateral, valueA, valueB } = await this.lendingPool.getValues(NO_CHANGES);
+      const [valueBorrowed, valueOther] = this.getPoolTokenType() == PoolTokenType.BorrowableA ? [valueA, valueB] : [valueB, valueA];
+      const safetyMargin = (await this.lendingPool.getSafetyMargin()) * this.getUiMargin();
+      const liquidationPenalty = await this.lendingPool.getLiquidationPenalty();
+      const actualCollateral = valueCollateral / liquidationPenalty;
+      const totalValueBorrowable1 = (actualCollateral * Math.sqrt(safetyMargin) - valueOther) / safetyMargin;
+      const totalValueBorrowable2 = (actualCollateral / Math.sqrt(safetyMargin) - valueOther) * safetyMargin;
+      const maxValueBorrowable = Math.min(totalValueBorrowable1, totalValueBorrowable2) - valueBorrowed;
+      const price = await this.poolToken.getMarketPriceDenomLP();
+      return Math.max(0, Math.min(availableCash, maxValueBorrowable / price));
+    }*/
+    // binary search approach
     getMaxBorrowable() {
         return __awaiter(this, void 0, void 0, function* () {
             const availableCash = yield this.poolToken.getTotalBalance();
-            const { valueCollateral, valueA, valueB } = yield this.lendingPool.getValues(onchainTypes_1.NO_CHANGES);
-            const [valueBorrowed, valueOther] = this.getPoolTokenType() == types_1.PoolTokenType.BorrowableA ? [valueA, valueB] : [valueB, valueA];
-            const safetyMargin = (yield this.lendingPool.getSafetyMargin()) * this.getUiMargin();
-            const liquidationPenalty = yield this.lendingPool.getLiquidationPenalty();
-            const actualCollateral = valueCollateral / liquidationPenalty;
-            const totalValueBorrowable1 = (actualCollateral * Math.sqrt(safetyMargin) - valueOther) / safetyMargin;
-            const totalValueBorrowable2 = (actualCollateral / Math.sqrt(safetyMargin) - valueOther) * safetyMargin;
-            const maxValueBorrowable = Math.min(totalValueBorrowable1, totalValueBorrowable2) - valueBorrowed;
-            const price = yield this.poolToken.getMarketPriceDenomLP();
-            return Math.max(0, Math.min(availableCash, maxValueBorrowable / price));
+            const twapPrice = yield this.lendingPool.getLendingPool().getTWAPPrice();
+            // start search
+            let borrowAmount = availableCash;
+            let borrowAmountPrev = 0;
+            let bestAmount = 0;
+            for (let i = 0; i < 1000; i++) {
+                const jump = Math.abs(borrowAmount - borrowAmountPrev) / 2;
+                if (jump / availableCash < 0.001)
+                    break;
+                borrowAmountPrev = borrowAmount;
+                const changeCollateral = 0;
+                const changeBorrowedA = this.getPoolTokenType() == types_1.PoolTokenType.BorrowableA ? borrowAmount * this.getUiMargin() : 0;
+                const changeBorrowedB = this.getPoolTokenType() == types_1.PoolTokenType.BorrowableB ? borrowAmount * this.getUiMargin() : 0;
+                const changes = { changeCollateral, changeBorrowedA, changeBorrowedB };
+                const [liqPriceA, liqPriceB] = yield this.lendingPool.getLiquidationPrices(changes);
+                if (liqPriceA > twapPrice || liqPriceB < twapPrice)
+                    borrowAmount -= jump;
+                else {
+                    bestAmount = borrowAmount;
+                    borrowAmount += jump;
+                }
+            }
+            return bestAmount / this.getDust();
         });
     }
     // Farming Shares

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

@@ -12,7 +12,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const onchainTypes_1 = require("../../onchainTypes");
 const onchainAccountPoolToken_1 = __importDefault(require("../onchainAccountPoolToken"));
 class OnchainAccountCollateral extends onchainAccountPoolToken_1.default {
     constructor(lendingPool) {
@@ -62,17 +61,44 @@ class OnchainAccountCollateral extends onchainAccountPoolToken_1.default {
         });
     }
     // Max Withdrawable
+    /*public async getMaxWithdrawable() : Promise<number> {
+      const deposited = await this.getDeposited();
+      const availableCash = await this.poolToken.getTotalBalance();
+      const { valueCollateral, valueA, valueB } = await this.lendingPool.getValues(NO_CHANGES);
+      const safetyMargin = (await this.lendingPool.getSafetyMargin()) * this.getUiMargin();
+      const liquidationPenalty = await this.lendingPool.getLiquidationPenalty();
+      const actualCollateral = valueCollateral / liquidationPenalty;
+      const maxWithdrawable1 = (actualCollateral - (valueA + valueB * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty / this.getDust();
+      const maxWithdrawable2 = (actualCollateral - (valueB + valueA * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty / this.getDust();
+      return Math.max(0, Math.min(deposited, availableCash, maxWithdrawable1, maxWithdrawable2));
+    }*/
+    // binary search approach
     getMaxWithdrawable() {
         return __awaiter(this, void 0, void 0, function* () {
-            const deposited = yield this.getDeposited();
-            const availableCash = yield this.poolToken.getTotalBalance();
-            const { valueCollateral, valueA, valueB } = yield this.lendingPool.getValues(onchainTypes_1.NO_CHANGES);
-            const safetyMargin = (yield this.lendingPool.getSafetyMargin()) * this.getUiMargin();
-            const liquidationPenalty = yield this.lendingPool.getLiquidationPenalty();
-            const actualCollateral = valueCollateral / liquidationPenalty;
-            const maxWithdrawable1 = (actualCollateral - (valueA + valueB * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty / this.getDust();
-            const maxWithdrawable2 = (actualCollateral - (valueB + valueA * safetyMargin) / Math.sqrt(safetyMargin)) * liquidationPenalty / this.getDust();
-            return Math.max(0, Math.min(deposited, availableCash, maxWithdrawable1, maxWithdrawable2));
+            const collateralAmount = yield this.getDeposited();
+            const twapPrice = yield this.lendingPool.getLendingPool().getTWAPPrice();
+            // start search
+            let withdrawAmount = collateralAmount;
+            let withdrawAmountPrev = 0;
+            let bestAmount = 0;
+            for (let i = 0; i < 1000; i++) {
+                const jump = Math.abs(withdrawAmount - withdrawAmountPrev) / 2;
+                if (jump / collateralAmount < 0.001)
+                    break;
+                withdrawAmountPrev = withdrawAmount;
+                const changeCollateral = -1 * withdrawAmount * this.getUiMargin();
+                const changeBorrowedA = 0;
+                const changeBorrowedB = 0;
+                const changes = { changeCollateral, changeBorrowedA, changeBorrowedB };
+                const [liqPriceA, liqPriceB] = yield this.lendingPool.getLiquidationPrices(changes);
+                if (liqPriceA > twapPrice || liqPriceB < twapPrice)
+                    withdrawAmount -= jump;
+                else {
+                    bestAmount = withdrawAmount;
+                    withdrawAmount += jump;
+                }
+            }
+            return bestAmount / this.getDust();
         });
     }
 }

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

@@ -197,10 +197,10 @@ class OnchainAccountLendingPool {
             const safetyMargin = yield this.getSafetyMargin();
             const liquidationPenalty = yield this.getLiquidationPenalty();
             const actualCollateral = collateralAmount / liquidationPenalty;
-            const reservesRatio = yield this.lendingPool.getReservesValueRatio();
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getTwapReservesWeights();
             const [priceA, priceB] = yield this.lendingPool.getPriceDenomLP();
-            const collateralA = actualCollateral * reservesRatio / (1 + reservesRatio) / priceA;
-            const collateralB = actualCollateral / (1 + reservesRatio) / priceB;
+            const collateralA = actualCollateral * reservesWeight0 / priceA;
+            const collateralB = actualCollateral * reservesWeight1 / 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;
@@ -245,14 +245,14 @@ class OnchainAccountLendingPool {
             const availableCashA = yield this.getBorrowableA().getPoolToken().getTotalBalance();
             const availableCashB = yield this.getBorrowableB().getPoolToken().getTotalBalance();
             const collateralAmount = yield this.getCollateral().getDeposited();
-            const reservesRatio = yield this.lendingPool.getReservesValueRatio();
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getMarketReservesWeights();
             //const [priceA, priceB] = await this.lendingPool.getPriceDenomLP();
-            // come posso adattare l'aggiustamento alle stable pairs?
+            //TODO come posso adattare l'aggiustamento alle stable pairs?
             const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
             const [priceATWAP,] = yield this.lendingPool.getPriceDenomLP();
             const diff = priceA > priceATWAP ? priceA / priceATWAP : priceATWAP / priceA;
-            const collateralA = collateralAmount * reservesRatio / (1 + reservesRatio) / priceA;
-            const collateralB = collateralAmount / (1 + reservesRatio) / priceB;
+            const collateralA = collateralAmount * reservesWeight0 / priceA;
+            const collateralB = collateralAmount * reservesWeight1 / priceB;
             const twapPrice = yield this.lendingPool.getTWAPPrice();
             // start search
             let addLev = 100;
@@ -260,7 +260,7 @@ class OnchainAccountLendingPool {
             let bestChanges = onchainTypes_1.NO_CHANGES;
             for (let i = 0; i < 1000; i++) {
                 const jump = Math.abs(addLev - addLevPrev) / 2;
-                if (jump < 0.001)
+                if (jump < 0.01)
                     break;
                 addLevPrev = addLev;
                 const adjustFactor = Math.pow((0, utils_1.impermanentLoss)(Math.pow(diff, 2)), addLev);
@@ -281,21 +281,30 @@ class OnchainAccountLendingPool {
                     addLev += jump;
                 }
             }
-            return yield this.getLeverage(bestChanges);
+            const maxLeverage = yield this.getLeverage(bestChanges);
+            return Math.floor(maxLeverage * 99) / 100;
         });
     }
     // Max Deleverage
     getMaxDeleverage(slippage) {
         return __awaiter(this, void 0, void 0, function* () {
             const { valueCollateral, valueA, valueB } = yield this.getMarketValues(onchainTypes_1.NO_CHANGES);
-            const minRepayPerSide = valueCollateral / 2 / Math.sqrt(slippage);
-            if (minRepayPerSide >= valueA && minRepayPerSide >= valueB) {
+            const [reservesWeight0, reservesWeight1] = yield this.lendingPool.getMarketReservesWeights();
+            const adjCollateralValue = valueCollateral / Math.sqrt(slippage);
+            const collateralValueA = valueCollateral * reservesWeight0;
+            const collateralValueB = valueCollateral * reservesWeight1;
+            if (collateralValueA >= valueA && collateralValueB >= valueB) {
                 return this.getCollateral().getDeposited();
             }
-            if (minRepayPerSide * 2 < valueA + valueB) {
+            if (adjCollateralValue < valueA + valueB) {
                 return 0;
             }
-            return Math.min(valueA, valueB) * 2 * Math.sqrt(slippage);
+            if (valueA / collateralValueA < valueB / collateralValueB) {
+                return (valueA + valueA / collateralValueA * collateralValueB) * Math.sqrt(slippage);
+            }
+            else {
+                return (valueB + valueB / collateralValueB * collateralValueA) * Math.sqrt(slippage);
+            }
         });
     }
     // Available Reward

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

@@ -39,8 +39,12 @@ export default class OnchainLendingPool {
     getPriceDenomLP(): Promise<[number, number]>;
     getMarketPriceDenomLP(): Promise<[number, number]>;
     getMarketPrice(): Promise<number>;
-    private initializeReservesValueRatio;
-    getReservesValueRatio(): Promise<number>;
+    private initializeTwapReservesValueRatio;
+    getTwapReservesValueRatio(): Promise<number>;
+    getTwapReservesWeights(): Promise<[number, number]>;
+    private initializeMarketReservesValueRatio;
+    getMarketReservesValueRatio(): Promise<number>;
+    getMarketReservesWeights(): Promise<[number, number]>;
     private initializeTWAPPrice;
     getTWAPPrice(): Promise<number>;
     private initializeStakedLPExchangeRate;

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

@@ -170,9 +170,10 @@ class OnchainLendingPool {
         return __awaiter(this, void 0, void 0, function* () {
             const [reserve0, reserve1] = yield this.getReserves();
             const totalSupply = yield this.getLPTotalSupply();
+            const [reservesWeight0, reservesWeight1] = yield this.getMarketReservesWeights();
             return [
-                totalSupply / reserve0 / 2,
-                totalSupply / reserve1 / 2,
+                totalSupply / reserve0 * reservesWeight0,
+                totalSupply / reserve1 * reservesWeight1,
             ];
         });
     }
@@ -187,64 +188,8 @@ class OnchainLendingPool {
                 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() {
+    initializeTwapReservesValueRatio() {
         return __awaiter(this, void 0, void 0, function* () {
             if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
                 const collateral = yield this.getCollateral().getPoolToken();
@@ -259,13 +204,49 @@ class OnchainLendingPool {
             }
         });
     }
-    getReservesValueRatio() {
+    getTwapReservesValueRatio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.twapReservesValueRatio)
+                this.cache.twapReservesValueRatio = this.initializeTwapReservesValueRatio();
+            return this.cache.twapReservesValueRatio;
+        });
+    }
+    getTwapReservesWeights() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const reservesRatio = yield this.getTwapReservesValueRatio();
+            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
+            const reservesWeight1 = 1 / (1 + reservesRatio);
+            return [reservesWeight0, reservesWeight1];
+        });
+    }
+    initializeMarketReservesValueRatio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (factories_1.STABLE_FACTORIES.includes(this.impermaxFactory.getFactory())) {
+                const [reserve0, reserve1] = yield this.getReserves();
+                const price = (0, lliquidity_math_1.solidlyStable_getPriceFromReserves)(reserve0, reserve1);
+                return reserve0 * price / reserve1;
+            }
+            else {
+                return 1;
+            }
+        });
+    }
+    getMarketReservesValueRatio() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cache.marketReservesValueRatio)
+                this.cache.marketReservesValueRatio = this.initializeMarketReservesValueRatio();
+            return this.cache.marketReservesValueRatio;
+        });
+    }
+    getMarketReservesWeights() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.cache.reservesValueRatio)
-                this.cache.reservesValueRatio = this.initializeReservesValueRatio();
-            return this.cache.reservesValueRatio;
+            const reservesRatio = yield this.getMarketReservesValueRatio();
+            const reservesWeight0 = reservesRatio / (1 + reservesRatio);
+            const reservesWeight1 = 1 / (1 + reservesRatio);
+            return [reservesWeight0, reservesWeight1];
         });
     }
+    // TWAP Price
     initializeTWAPPrice() {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/lib/onchain/interactions/lendingPool/onchainInteractionsLendingPool.d.ts

@@ -33,7 +33,7 @@ export default class OnchainInteractionsLendingPool {
         cAmountMin: number;
     }>;
     leverage(amountA: BigNumber, amountB: BigNumber, amountAMin: BigNumber, amountBMin: BigNumber, permitDataA: PermitData, permitDataB: PermitData, onTransactionHash: Function): Promise<any>;
-    getDeleverageAmounts(changeCollateralAmount: number, slippage: number): Promise<{
+    getDeleverageAmounts(changeCollateralValue: number, slippage: number): Promise<{
         bAmountA: number;
         bAmountB: number;
         cAmount: number;

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

@@ -55,10 +55,11 @@ 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;
+            const [reservesWeightA, reservesWeightB] = yield this.lendingPool.getMarketReservesWeights();
+            const changeValueA = changeCollateralValue * reservesWeightA;
+            const changeValueB = changeCollateralValue * reservesWeightB;
+            const bAmountA = priceA > 0 ? changeValueA / priceA : 0;
+            const bAmountB = priceB > 0 ? changeValueB / priceB : 0;
             const cAmount = changeCollateralValue ? changeCollateralValue : 0;
             return {
                 bAmountA: bAmountA,
@@ -83,17 +84,19 @@ class OnchainInteractionsLendingPool {
             return this.send(router.methods.leverage(pairAddress, amountA, amountB, amountAMin, amountBMin, account, deadline, dataA, dataB), onTransactionHash);
         });
     }
-    getDeleverageAmounts(changeCollateralAmount, slippage) {
+    getDeleverageAmounts(changeCollateralValue, slippage) {
         return __awaiter(this, void 0, void 0, function* () {
-            changeCollateralAmount = changeCollateralAmount !== null && changeCollateralAmount !== void 0 ? changeCollateralAmount : 0;
+            changeCollateralValue = changeCollateralValue !== null && changeCollateralValue !== void 0 ? changeCollateralValue : 0;
             const [priceA, priceB] = yield this.lendingPool.getMarketPriceDenomLP();
-            const valueForEach = changeCollateralAmount / 2;
-            const bAmountA = priceA > 0 ? valueForEach / priceA : 0;
-            const bAmountB = priceB > 0 ? valueForEach / priceB : 0;
+            const [reservesWeightA, reservesWeightB] = yield this.lendingPool.getMarketReservesWeights();
+            const changeValueA = changeCollateralValue * reservesWeightA;
+            const changeValueB = changeCollateralValue * reservesWeightB;
+            const bAmountA = priceA > 0 ? changeValueA / priceA : 0;
+            const bAmountB = priceB > 0 ? changeValueB / priceB : 0;
             return {
                 bAmountA: bAmountA,
                 bAmountB: bAmountB,
-                cAmount: changeCollateralAmount,
+                cAmount: changeCollateralValue,
                 bAmountAMin: bAmountA / Math.sqrt(slippage),
                 bAmountBMin: bAmountB / Math.sqrt(slippage),
             };

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

@@ -1,3 +1,6 @@
+/**
+ * Calculate X/Y price
+ */
 export declare function uniswapV2_getPriceFromReserves(x: number, y: number, priceInverted?: boolean): number;
 /**
  * Find liquidation threshold given X/Y price decrease

package/lib/utils/lliquidity-math.js

@@ -1,6 +1,9 @@
 "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
+ */
 function uniswapV2_getPriceFromReserves(x, y, priceInverted = false) {
     const price = y / x;
     return !priceInverted ? price : 1 / price;

package/package.json

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