@reserve-protocol/dtf-rebalance-lib 0.2.9 → 0.2.11

package/dist/open-auction.js

@@ -1,14 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOpenAuction = exports.getTargetBasket = exports.AuctionRound = void 0;
-const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const utils_1 = require("./utils");
 const numbers_1 = require("./numbers");
 const types_1 = require("./types");
-// Create a local Decimal constructor with custom precision
-const Decimal = decimal_js_light_1.default.clone({ precision: 100 });
 // Call `getOpenAuction()` to get the current auction round
 var AuctionRound;
 (function (AuctionRound) {
@@ -32,10 +27,10 @@ const getTargetBasket = (_initialWeights, _prices, _decimals) => {
         throw new Error("length mismatch");
     }
     const vals = _initialWeights.map((initialWeight, i) => {
-        const price = new Decimal(_prices[i]);
-        const decimalScale = new Decimal(`1e${_decimals[i]}`);
+        const price = new utils_1.Decimal(_prices[i]);
+        const decimalScale = new utils_1.Decimal(`1e${_decimals[i]}`);
         // {USD/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27 * {USD/wholeTok}
-        return new Decimal(initialWeight.spot.toString()).div(decimalScale).mul(price).div(numbers_1.D9d);
+        return new utils_1.Decimal(initialWeight.spot.toString()).div(decimalScale).mul(price).div(numbers_1.D9d);
     });
     const totalValue = vals.reduce((a, b) => a.add(b));
     // D18{1} = {USD/wholeBU} / {USD/wholeBU} * D18
@@ -76,33 +71,33 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     }
     // ================================================================
     // {wholeShare} = {share} / {share/wholeShare}
-    const supply = new Decimal(_supply.toString()).div(numbers_1.D18d);
+    const supply = new utils_1.Decimal(_supply.toString()).div(numbers_1.D18d);
     // {1} = D18{1} / D18
-    const targetBasket = _targetBasket.map((a) => new Decimal(a.toString()).div(numbers_1.D18d));
+    const targetBasket = _targetBasket.map((a) => new utils_1.Decimal(a.toString()).div(numbers_1.D18d));
     // {USD/wholeTok}
-    const prices = _prices.map((a) => new Decimal(a));
+    const prices = _prices.map((a) => new utils_1.Decimal(a));
     for (let i = 0; i < prices.length; i++) {
         if (prices[i].eq(numbers_1.ZERO)) {
             throw new Error(`missing price for token ${rebalance.tokens[i]}`);
         }
     }
     // {1}
-    const priceError = _priceError.map((a) => new Decimal(a.toString()));
+    const priceError = _priceError.map((a) => new utils_1.Decimal(a.toString()));
     // {tok/wholeTok}
-    const decimalScale = _decimals.map((a) => new Decimal(`1e${a}`));
+    const decimalScale = _decimals.map((a) => new utils_1.Decimal(`1e${a}`));
     // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-    const initialFolio = _initialFolio.map((c, i) => new Decimal(c.toString()).div(decimalScale[i]));
+    const initialFolio = _initialFolio.map((c, i) => new utils_1.Decimal(c.toString()).div(decimalScale[i]));
     // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-    const folio = _folio.map((c, i) => new Decimal(c.toString()).div(decimalScale[i]));
+    const folio = _folio.map((c, i) => new utils_1.Decimal(c.toString()).div(decimalScale[i]));
     // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
     let weightRanges = rebalance.weights.map((range, i) => {
         return {
-            low: new Decimal(range.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            spot: new Decimal(range.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            high: new Decimal(range.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            low: new utils_1.Decimal(range.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            spot: new utils_1.Decimal(range.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            high: new utils_1.Decimal(range.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
         };
     });
-    const finalStageAt = new Decimal(_finalStageAt.toString());
+    const finalStageAt = new utils_1.Decimal(_finalStageAt.toString());
     // ================================================================
     // calculate ideal spot limit, the actual BU<->share ratio
     // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
@@ -150,7 +145,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // ================================================================
     // calculate progressions
     // {wholeBU/wholeShare} = D18{BU/share} / D18
-    const prevSpotLimit = new Decimal(rebalance.limits.spot.toString()).div(numbers_1.D18d);
+    const prevSpotLimit = new utils_1.Decimal(rebalance.limits.spot.toString()).div(numbers_1.D18d);
     // {wholeTok/wholeBU} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
     const expectedBalances = weightRanges.map((weightRange) => weightRange.spot.mul(prevSpotLimit));
     // {1} = {USD/wholeShare} / {USD/wholeShare}
@@ -181,6 +176,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         .reduce((a, b) => a.add(b))
         .div(shareValue);
     if (progression < initialProgression) {
+        if (debug) {
+            console.log("progression < initialProgression", progression.toString(), initialProgression.toString());
+        }
         progression = initialProgression; // don't go backwards
     }
     // {1} = {1} / {1}
@@ -275,9 +273,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // get new weights, constrained by extremes
     // {wholeBU/wholeShare} = D18{BU/share} / D18
     const actualLimits = {
-        low: new Decimal(newLimits.low.toString()).div(numbers_1.D18d),
-        spot: new Decimal(newLimits.spot.toString()).div(numbers_1.D18d),
-        high: new Decimal(newLimits.high.toString()).div(numbers_1.D18d),
+        low: new utils_1.Decimal(newLimits.low.toString()).div(numbers_1.D18d),
+        spot: new utils_1.Decimal(newLimits.spot.toString()).div(numbers_1.D18d),
+        high: new utils_1.Decimal(newLimits.high.toString()).div(numbers_1.D18d),
     };
     // D27{tok/BU}
     const newWeights = rebalance.weights.map((weightRange, i) => {
@@ -369,9 +367,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
     weightRanges = newWeights.map((range, i) => {
         return {
-            low: new Decimal(range.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            spot: new Decimal(range.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            high: new Decimal(range.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            low: new utils_1.Decimal(range.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            spot: new utils_1.Decimal(range.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            high: new utils_1.Decimal(range.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
         };
     });
     // {USD}
@@ -386,10 +384,10 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         const sellDownTo = weightRanges[i].high.mul(actualLimits.high);
         if (folio[i].lt(buyUpTo)) {
             // {USD} = {wholeTok/wholeShare} * {USD/wholeTok} * {wholeShare}
-            const tokenDeficitValue = deficitValue.add(buyUpTo.sub(folio[i]).mul(prices[i]).mul(supply));
+            const tokenDeficitValue = buyUpTo.sub(folio[i]).mul(prices[i]).mul(supply);
             // $1 minimum
             if (tokenDeficitValue.gte(numbers_1.ONE)) {
-                deficitValue = tokenDeficitValue;
+                deficitValue = deficitValue.add(tokenDeficitValue);
                 deficitTokens.push(token);
             }
         }

package/dist/start-rebalance.js

@@ -1,13 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStartRebalance = void 0;
-const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const utils_1 = require("./utils");
 const numbers_1 = require("./numbers");
-// Create a local Decimal constructor with custom precision
-const Decimal = decimal_js_light_1.default.clone({ precision: 100 });
 /**
  * Get the arguments needed to call startRebalance
  *
@@ -28,19 +23,19 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
         console.log("getStartRebalance", _supply, tokens, _folio, decimals, _targetBasket, _prices, _priceError, weightControl);
     }
     // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-    const folio = _folio.map((c, i) => new Decimal(c.toString()).div(new Decimal(`1e${decimals[i]}`)));
+    const folio = _folio.map((c, i) => new utils_1.Decimal(c.toString()).div(new utils_1.Decimal(`1e${decimals[i]}`)));
     // convert price number inputs to bigints
     // {USD/wholeTok}
-    const prices = _prices.map((a) => new Decimal(a.toString()));
+    const prices = _prices.map((a) => new utils_1.Decimal(a.toString()));
     for (let i = 0; i < prices.length; i++) {
         if (prices[i].eq(numbers_1.ZERO)) {
             throw new Error(`missing price for token ${tokens[i]}`);
         }
     }
     // {1} = D18{1} / D18
-    const targetBasket = _targetBasket.map((a) => new Decimal(a.toString()).div(numbers_1.D18d));
+    const targetBasket = _targetBasket.map((a) => new utils_1.Decimal(a.toString()).div(numbers_1.D18d));
     // {1}
-    const priceError = _priceError.map((a) => new Decimal(a.toString()));
+    const priceError = _priceError.map((a) => new utils_1.Decimal(a.toString()));
     // ================================================================
     const newWeights = [];
     const newPrices = [];
@@ -62,7 +57,7 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
         // {wholeTok/wholeShare} = {1} * {USD/wholeShare} / {USD/wholeTok}
         const spotWeight = targetBasket[i].mul(dtfPrice).div(prices[i]);
         // D27{tok/share}{wholeShare/wholeTok} = D27 * {tok/wholeTok} / {share/wholeShare}
-        const limitMultiplier = numbers_1.D27d.mul(new Decimal(`1e${decimals[i]}`)).div(numbers_1.D18d);
+        const limitMultiplier = numbers_1.D27d.mul(new utils_1.Decimal(`1e${decimals[i]}`)).div(numbers_1.D18d);
         if (debug) {
             console.log("limitMultiplier", limitMultiplier.toString());
         }
@@ -88,7 +83,7 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
         }
         // === newPrices ===
         // D27{wholeTok/tok} = D27 / {tok/wholeTok}
-        const priceMultiplier = numbers_1.D27d.div(new Decimal(`1e${decimals[i]}`));
+        const priceMultiplier = numbers_1.D27d.div(new utils_1.Decimal(`1e${decimals[i]}`));
         // {USD/wholeTok} = {USD/wholeTok} * {1}
         const lowPrice = prices[i].mul(numbers_1.ONE.sub(priceError[i]));
         const highPrice = prices[i].mul(numbers_1.ONE.add(priceError[i]));

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
+import DecimalLight from "decimal.js-light";
+export declare const Decimal: typeof DecimalLight;
 /**
  * This function can be used to get a basket distribution EITHER from a set of historical basket weights
  * or from a set of current balances. Make sure to use prices from the right time.

package/dist/utils.js

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBasketDistribution = void 0;
+exports.getBasketDistribution = exports.Decimal = void 0;
 const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
 const numbers_1 = require("./numbers");
 // Create a local Decimal constructor with custom precision
-const Decimal = decimal_js_light_1.default.clone({ precision: 100 });
+exports.Decimal = decimal_js_light_1.default.clone({ precision: 100 });
 /**
  * This function can be used to get a basket distribution EITHER from a set of historical basket weights
  * or from a set of current balances. Make sure to use prices from the right time.
@@ -18,15 +18,13 @@ const Decimal = decimal_js_light_1.default.clone({ precision: 100 });
  * @returns D18{1} Current basket, total will be around 1e18 but not exactly
  */
 const getBasketDistribution = (_bals, _prices, decimals) => {
-    const decimalScale = decimals.map((d) => new Decimal(`1e${d}`));
+    const decimalScale = decimals.map((d) => new exports.Decimal(`1e${d}`));
     // {wholeTok} = {tok} / {tok/wholeTok}
-    const bals = _bals.map((bal, i) => new Decimal(bal.toString()).div(decimalScale[i]));
+    const bals = _bals.map((bal, i) => new exports.Decimal(bal.toString()).div(decimalScale[i]));
     // {USD/wholeTok} = {USD/wholeTok}
-    const prices = _prices.map((a) => new Decimal(a.toString()));
+    const prices = _prices.map((a) => new exports.Decimal(a.toString()));
     // {USD} = {wholeTok} * {USD/wholeTok}
-    const totalValue = bals
-        .map((bal, i) => bal.mul(prices[i]))
-        .reduce((a, b) => a.add(b));
+    const totalValue = bals.map((bal, i) => bal.mul(prices[i])).reduce((a, b) => a.add(b));
     // D18{1} = {wholeTok} * {USD/wholeTok} / {USD}
     return bals.map((bal, i) => (0, numbers_1.bn)(bal.mul(prices[i]).div(totalValue).mul(numbers_1.D18d)));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reserve-protocol/dtf-rebalance-lib",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Rebalancing library for DTFs in typescript",
   "main": "dist/index.js",
   "module": "dist/index.js",