@reserve-protocol/dtf-rebalance-lib 0.1.2 → 0.1.4

package/dist/open-auction.d.ts

@@ -1,4 +1,4 @@
-import { PriceRange, Rebalance, RebalanceLimits, WeightRange } from './types';
+import { PriceRange, Rebalance, RebalanceLimits, WeightRange } from "./types";
 export declare enum AuctionRound {
     EJECT = 0,
     PROGRESS = 1,
@@ -59,4 +59,4 @@ export declare const getTargetBasket: (_initialWeights: WeightRange[], _prices:
  * @param _priceError {1} Price error to use for each token during auction pricing; should be smaller than price error during startRebalance
  * @param _finalStageAt {1} The % rebalanced from the initial Folio to determine when is the final stage of the rebalance
  */
-export declare const getOpenAuction: (rebalance: Rebalance, _supply: bigint, _initialFolio: bigint[] | undefined, _targetBasket: bigint[] | undefined, _folio: bigint[], _decimals: bigint[], _prices: number[], _priceError: number[], _finalStageAt: number, logging?: boolean) => [OpenAuctionArgs, AuctionMetrics];
+export declare const getOpenAuction: (rebalance: Rebalance, _supply: bigint, _initialFolio: bigint[] | undefined, _targetBasket: bigint[] | undefined, _folio: bigint[], _decimals: bigint[], _prices: number[], _priceError: number[], _finalStageAt: number, debug?: boolean) => [OpenAuctionArgs, AuctionMetrics];

package/dist/open-auction.js

@@ -27,17 +27,13 @@ var AuctionRound;
  */
 const getTargetBasket = (_initialWeights, _prices, _decimals) => {
     if (_initialWeights.length != _prices.length) {
-        throw new Error('length mismatch');
+        throw new Error("length mismatch");
     }
     const vals = _initialWeights.map((initialWeight, i) => {
         const price = new decimal_js_light_1.default(_prices[i]);
         const decimalScale = new decimal_js_light_1.default(`1e${_decimals[i]}`);
         // {USD/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27 * {USD/wholeTok}
-        return new decimal_js_light_1.default(initialWeight.spot.toString())
-            .mul(numbers_1.D18d)
-            .div(decimalScale)
-            .div(numbers_1.D27d)
-            .mul(price);
+        return new decimal_js_light_1.default(initialWeight.spot.toString()).mul(numbers_1.D18d).div(decimalScale).div(numbers_1.D27d).mul(price);
     });
     const totalValue = vals.reduce((a, b) => a.add(b));
     // D18{1} = {USD/wholeBU} / {USD/wholeBU} * D18
@@ -59,19 +55,19 @@ exports.getTargetBasket = getTargetBasket;
  * @param _priceError {1} Price error to use for each token during auction pricing; should be smaller than price error during startRebalance
  * @param _finalStageAt {1} The % rebalanced from the initial Folio to determine when is the final stage of the rebalance
  */
-const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket = [], _folio, _decimals, _prices, _priceError, _finalStageAt, logging) => {
-    if (logging) {
-        console.log('getOpenAuction', rebalance, _supply, _initialFolio, _targetBasket, _folio, _decimals, _prices, _priceError, _finalStageAt);
+const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket = [], _folio, _decimals, _prices, _priceError, _finalStageAt, debug) => {
+    if (debug) {
+        console.log("getOpenAuction", rebalance, _supply, _initialFolio, _targetBasket, _folio, _decimals, _prices, _priceError, _finalStageAt);
     }
     if (rebalance.tokens.length != _targetBasket.length ||
         _targetBasket.length != _folio.length ||
         _folio.length != _decimals.length ||
         _decimals.length != _prices.length ||
         _prices.length != _priceError.length) {
-        throw new Error('length mismatch');
+        throw new Error("length mismatch");
     }
     if (_finalStageAt > 1) {
-        throw new Error('finalStageAt must be less than 1');
+        throw new Error("finalStageAt must be less than 1");
     }
     // ================================================================
     // {wholeShare} = {share} / {share/wholeShare}
@@ -96,18 +92,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
     let weightRanges = rebalance.weights.map((range, i) => {
         return {
-            low: new decimal_js_light_1.default(range.low.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
-            spot: new decimal_js_light_1.default(range.spot.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
-            high: new decimal_js_light_1.default(range.high.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
+            low: new decimal_js_light_1.default(range.low.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
+            spot: new decimal_js_light_1.default(range.spot.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
+            high: new decimal_js_light_1.default(range.high.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
         };
     });
     const finalStageAt = new decimal_js_light_1.default(_finalStageAt.toString());
@@ -115,15 +102,18 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // calculate ideal spot limit, the actual BU<->share ratio
     // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
     const shareValue = folio
-        .map((f, i) => f.mul(prices[i]))
+        .map((f, i) => {
+        return rebalance.inRebalance[i] ? f.mul(prices[i]) : numbers_1.ZERO;
+    })
         .reduce((a, b) => a.add(b));
     // {USD/wholeBU} = {wholeTok/wholeBU} * {USD/wholeTok}
-    const buValue = weightRanges
-        .map((weightRange, i) => weightRange.spot.mul(prices[i]))
-        .reduce((a, b) => a.add(b));
-    if (logging) {
-        console.log('shareValue', shareValue.toString());
-        console.log('buValue', buValue.toString());
+    const buValue = weightRanges.map((weightRange, i) => weightRange.spot.mul(prices[i])).reduce((a, b) => a.add(b));
+    if (debug) {
+        console.log("shareValue", shareValue.toString());
+        console.log("buValue", buValue.toString());
+    }
+    if (buValue.div(shareValue).gt(10) || shareValue.div(buValue).gt(100)) {
+        throw new Error("buValue and shareValue are too different");
     }
     // ================================================================
     // calculate rebalanceTarget
@@ -135,7 +125,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     }
     // {1} = {wholeTok/wholeShare} * {USD/wholeTok} / {USD/wholeShare}
     const portionBeingEjected = ejectionIndices
-        .map((i) => folio[i].mul(prices[i]))
+        .map((i) => {
+        return rebalance.inRebalance[i] ? folio[i].mul(prices[i]) : numbers_1.ZERO;
+    })
         .reduce((a, b) => a.add(b), numbers_1.ZERO)
         .div(shareValue);
     // {1} = {USD/wholeShare} / {USD/wholeShare}
@@ -144,9 +136,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         // {wholeTok/wholeShare} = {USD/wholeShare} * {1} / {USD/wholeTok}
         const balanceExpected = shareValue.mul(targetBasket[i]).div(prices[i]);
         // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
-        const balanceInBU = balanceExpected.gt(actualBalance)
-            ? actualBalance
-            : balanceExpected;
+        const balanceInBU = balanceExpected.gt(actualBalance) ? actualBalance : balanceExpected;
         // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
         return balanceInBU.mul(prices[i]);
     })
@@ -158,9 +148,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         // {wholeTok/wholeShare} = {USD/wholeShare} * {1} / {USD/wholeTok}
         const balanceExpected = shareValue.mul(targetBasket[i]).div(prices[i]);
         // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
-        const balanceInBU = balanceExpected.gt(initialBalance)
-            ? initialBalance
-            : balanceExpected;
+        const balanceInBU = balanceExpected.gt(initialBalance) ? initialBalance : balanceExpected;
         // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
         return balanceInBU.mul(prices[i]);
     })
@@ -175,40 +163,45 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         : progression.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
     let rebalanceTarget = numbers_1.ONE;
     let round = AuctionRound.FINAL;
-    if (logging) {
-        console.log('initialProgression', initialProgression.toString());
-        console.log('progression', progression.toString());
-        console.log('relativeProgression', relativeProgression.toString());
-        console.log('portionBeingEjected', portionBeingEjected.toString());
-        console.log('finalStageAt', finalStageAt.toString());
+    if (debug) {
+        console.log("initialProgression", initialProgression.toString());
+        console.log("progression", progression.toString());
+        console.log("relativeProgression", relativeProgression.toString());
+        console.log("portionBeingEjected", portionBeingEjected.toString());
+        console.log("finalStageAt", finalStageAt.toString());
     }
-    // make it an eject auction if there is 1 bps or more of value to eject
-    if (portionBeingEjected.gte(1e-4)) {
-        round = AuctionRound.EJECT;
-        if (relativeProgression.lt(finalStageAt.sub(0.02))) {
-            rebalanceTarget = progression.add(portionBeingEjected.mul(1.1)); // set rebalanceTarget to 10% more than needed to ensure ejection completes
-            // do not finish trading yet
-            if (rebalanceTarget.gte(numbers_1.ONE)) {
-                rebalanceTarget = initialProgression.add(numbers_1.ONE.sub(initialProgression).mul(finalStageAt));
-            }
-        }
-    }
-    else if (relativeProgression.lt(finalStageAt.sub(0.02))) {
-        // wiggle room to prevent having to re-run an auction at the same stage after price movement
+    // approach finalStageAt first
+    if (progression.lt(0.99) && relativeProgression.lt(finalStageAt.sub(0.02))) {
         round = AuctionRound.PROGRESS;
         rebalanceTarget = initialProgression.add(numbers_1.ONE.sub(initialProgression).mul(finalStageAt));
+        if (numbers_1.ONE.sub(rebalanceTarget).lt(0.99)) {
+            rebalanceTarget = numbers_1.ONE;
+        }
         if (rebalanceTarget.eq(numbers_1.ONE)) {
             round = AuctionRound.FINAL;
         }
     }
-    if (rebalanceTarget.gt(numbers_1.ONE)) {
-        throw new Error('something has gone very wrong');
+    // EJECT
+    if (portionBeingEjected.gt(0)) {
+        round = AuctionRound.EJECT;
+        // if the ejections are everything that's left, keep the finalStageAt targeting from above
+        if (progression.add(portionBeingEjected).lt(numbers_1.ONE)) {
+            // else: get rid of all the dust
+            let ejectionTarget = progression.add(portionBeingEjected.mul(1.02)); // buy 2% extra
+            if (ejectionTarget.gt(numbers_1.ONE)) {
+                ejectionTarget = numbers_1.ONE;
+            }
+            if (ejectionTarget.gt(rebalanceTarget)) {
+                rebalanceTarget = ejectionTarget;
+            }
+        }
     }
-    if (rebalanceTarget.lt(progression)) {
-        rebalanceTarget = numbers_1.ONE;
+    if (rebalanceTarget.lte(numbers_1.ZERO) || rebalanceTarget.gt(numbers_1.ONE)) {
+        throw new Error("something has gone very wrong");
     }
-    if (logging) {
-        console.log('rebalanceTarget', rebalanceTarget.toString());
+    if (debug) {
+        console.log("round", round);
+        console.log("rebalanceTarget", rebalanceTarget.toString());
     }
     // {1}
     const delta = numbers_1.ONE.sub(rebalanceTarget);
@@ -222,11 +215,21 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         spot: (0, numbers_1.bn)(spotLimit.mul(numbers_1.D18d)),
         high: (0, numbers_1.bn)(spotLimit.add(spotLimit.mul(delta)).mul(numbers_1.D18d)),
     };
-    if (round == AuctionRound.EJECT && rebalanceTarget.eq(numbers_1.ONE)) {
-        // aim 1% higher if executed permissonlessly
-        newLimits.spot += newLimits.spot * 1n / 100n;
+    // hold some surpluses aside if ejecting
+    if (round == AuctionRound.EJECT) {
+        // buy 0.1% more
+        newLimits.low += newLimits.low / 1000n;
+        // aim 1% higher
+        newLimits.spot += newLimits.spot / 100n;
         // leave 10% room to increase low in the future if ejection leaves dust behind
-        newLimits.high += newLimits.high * 10n / 100n;
+        newLimits.high += newLimits.high / 10n;
+    }
+    else if (round == AuctionRound.FINAL && progression.gt(0.999)) {
+        // if it's the final round and we're within 0.1%, buy 10% more than we need to
+        const delta = (0, numbers_1.bn)(numbers_1.ONE.sub(progression).mul(numbers_1.D18d).div(10));
+        newLimits.low += (newLimits.low * delta) / 10n ** 18n;
+        newLimits.spot += (newLimits.spot * delta) / 10n ** 18n;
+        newLimits.high += (newLimits.high * delta) / 10n ** 18n;
     }
     // low
     if (newLimits.low < rebalance.limits.low) {
@@ -249,8 +252,8 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     if (newLimits.high > rebalance.limits.high) {
         newLimits.high = rebalance.limits.high;
     }
-    if (logging) {
-        console.log('newLimits', newLimits);
+    if (debug) {
+        console.log("newLimits", newLimits);
     }
     // ================================================================
     // get new weights, constrained by extremes
@@ -263,10 +266,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // D27{tok/BU}
     const newWeights = rebalance.weights.map((weightRange, i) => {
         // {wholeTok/wholeBU} = {USD/wholeShare} * {1} / {wholeBU/wholeShare} / {USD/wholeTok}
-        const idealWeight = shareValue
-            .mul(targetBasket[i])
-            .div(actualLimits.spot)
-            .div(prices[i]);
+        const idealWeight = shareValue.mul(targetBasket[i]).div(actualLimits.spot).div(prices[i]);
         // D27{tok/BU} = {wholeTok/wholeBU} * D27 * {tok/wholeTok} / {BU/wholeBU}
         const newWeightsD27 = {
             low: (0, numbers_1.bn)(idealWeight
@@ -281,11 +281,21 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
                 .mul(decimalScale[i])
                 .div(numbers_1.D18d)),
         };
-        if (round == AuctionRound.EJECT && rebalanceTarget.eq(numbers_1.ONE)) {
-            // aim 1% higher if executed permissonlessly
-            newWeightsD27.spot += newWeightsD27.spot * 1n / 100n;
+        // hold some surpluses aside if ejecting
+        if (round == AuctionRound.EJECT) {
+            // buy 0.1% more
+            newWeightsD27.low += newWeightsD27.low / 1000n;
+            // aim 1% higher
+            newWeightsD27.spot += newWeightsD27.spot / 100n;
             // leave 10% room to increase low in the future if ejection leaves dust behind
-            newWeightsD27.high += newWeightsD27.high * 10n / 100n;
+            newWeightsD27.high += newWeightsD27.high / 10n;
+        }
+        else if (round == AuctionRound.FINAL && progression.gt(0.999)) {
+            // if it's the final round and we're within 0.1%, buy 10% more than we need to
+            const delta = (0, numbers_1.bn)(numbers_1.ONE.sub(progression).mul(numbers_1.D18d).div(10));
+            newWeightsD27.low += (newWeightsD27.low * delta) / 10n ** 18n;
+            newWeightsD27.spot += (newWeightsD27.spot * delta) / 10n ** 18n;
+            newWeightsD27.high += (newWeightsD27.high * delta) / 10n ** 18n;
         }
         if (newWeightsD27.low < weightRange.low) {
             newWeightsD27.low = weightRange.low;
@@ -307,8 +317,8 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
         return newWeightsD27;
     });
-    if (logging) {
-        console.log('newWeights', newWeights);
+    if (debug) {
+        console.log("newWeights", newWeights);
     }
     // ================================================================
     // get new prices, constrained by extremes
@@ -317,7 +327,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         // revert if price out of bounds
         const spotPrice = (0, numbers_1.bn)(prices[i].mul(numbers_1.D27d).div(decimalScale[i]));
         if (spotPrice < initialPrice.low || spotPrice > initialPrice.high) {
-            throw new Error('spot price out of bounds! auction launcher MUST closeRebalance to prevent loss!');
+            throw new Error("spot price out of bounds! auction launcher MUST closeRebalance to prevent loss!");
         }
         if (rebalance.priceControl == types_1.PriceControl.NONE) {
             return initialPrice;
@@ -342,57 +352,57 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
             pricesD27.high = initialPrice.high;
         }
         if (pricesD27.low == pricesD27.high && priceError[i].gt(numbers_1.ZERO)) {
-            throw new Error('no price range');
+            throw new Error("no price range");
         }
         return pricesD27;
     });
-    if (logging) {
-        console.log('newPrices', newPrices);
+    if (debug) {
+        console.log("newPrices", newPrices);
     }
     // ================================================================
     // calculate metrics
     // {USD} = {1} * {USD/wholeShare} * {wholeShare}
-    const valueBeingTraded = rebalanceTarget
-        .sub(progression)
-        .mul(shareValue)
-        .mul(supply);
+    const valueBeingTraded = rebalanceTarget.sub(progression).mul(shareValue).mul(supply);
     const surplusTokens = [];
     const deficitTokens = [];
     // update Decimal weightRanges
     // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
     weightRanges = newWeights.map((range, i) => {
         return {
-            low: new decimal_js_light_1.default(range.low.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
-            spot: new decimal_js_light_1.default(range.spot.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
-            high: new decimal_js_light_1.default(range.high.toString())
-                .mul(numbers_1.D18d)
-                .div(decimalScale[i])
-                .div(numbers_1.D27d),
+            low: new decimal_js_light_1.default(range.low.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
+            spot: new decimal_js_light_1.default(range.spot.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
+            high: new decimal_js_light_1.default(range.high.toString()).mul(numbers_1.D18d).div(decimalScale[i]).div(numbers_1.D27d),
         };
     });
     rebalance.tokens.forEach((token, i) => {
         // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
         const buyUpTo = weightRanges[i].low.mul(actualLimits.low);
         const sellDownTo = weightRanges[i].high.mul(actualLimits.high);
-        if (folio[i].lt(buyUpTo)) {
+        if (rebalance.inRebalance[i] && folio[i].lt(buyUpTo)) {
             deficitTokens.push(token);
         }
-        else if (folio[i].gt(sellDownTo)) {
+        else if (rebalance.inRebalance[i] && folio[i].gt(sellDownTo)) {
             surplusTokens.push(token);
         }
     });
+    // ================================================================
+    // only return tokens that are in the rebalance
+    const returnTokens = [];
+    const returnWeights = [];
+    const returnPrices = [];
+    for (let i = 0; i < rebalance.tokens.length; i++) {
+        if (rebalance.inRebalance[i]) {
+            returnTokens.push(rebalance.tokens[i]);
+            returnWeights.push(newWeights[i]);
+            returnPrices.push(newPrices[i]);
+        }
+    }
     return [
         {
             rebalanceNonce: rebalance.nonce,
-            tokens: rebalance.tokens, // full set of tokens, not pruned to the active buy/sells
-            newWeights: newWeights,
-            newPrices: newPrices,
+            tokens: returnTokens,
+            newWeights: returnWeights,
+            newPrices: returnPrices,
             newLimits: newLimits,
         },
         {

package/dist/start-rebalance.d.ts

@@ -1,4 +1,4 @@
-import { PriceRange, RebalanceLimits, WeightRange } from './types';
+import { PriceRange, RebalanceLimits, WeightRange } from "./types";
 export interface StartRebalanceArgsPartial {
     weights: WeightRange[];
     prices: PriceRange[];
@@ -19,4 +19,4 @@ export interface StartRebalanceArgsPartial {
  * @param _dtfPrice {USD/wholeShare} DTF price
  * @param weightControl TRACKING=false, NATIVE=true
  */
-export declare const getStartRebalance: (_supply: bigint, tokens: string[], _folio: bigint[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], weightControl: boolean, logging?: boolean) => StartRebalanceArgsPartial;
+export declare const getStartRebalance: (_supply: bigint, tokens: string[], _folio: bigint[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], weightControl: boolean, debug?: boolean) => StartRebalanceArgsPartial;

package/dist/start-rebalance.js

@@ -21,9 +21,9 @@ const numbers_1 = require("./numbers");
  * @param _dtfPrice {USD/wholeShare} DTF price
  * @param weightControl TRACKING=false, NATIVE=true
  */
-const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _prices, _priceError, weightControl, logging) => {
-    if (logging) {
-        console.log('getStartRebalance', _supply, tokens, _folio, decimals, _targetBasket, _prices, _priceError, weightControl);
+const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _prices, _priceError, weightControl, debug) => {
+    if (debug) {
+        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_js_light_1.default(c.toString()).div(new decimal_js_light_1.default(`1e${decimals[i]}`)));
@@ -43,24 +43,26 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
     const newWeights = [];
     const newPrices = [];
     const newLimits = {
-        low: (0, numbers_1.bn)('1e18'),
-        spot: (0, numbers_1.bn)('1e18'),
-        high: (0, numbers_1.bn)('1e18'),
+        low: (0, numbers_1.bn)("1e18"),
+        spot: (0, numbers_1.bn)("1e18"),
+        high: (0, numbers_1.bn)("1e18"),
     };
     // ================================================================
     for (let i = 0; i < tokens.length; i++) {
         if (priceError[i].gte(numbers_1.ONE)) {
-            throw new Error('cannot defer prices');
+            throw new Error("cannot defer prices");
         }
         // === newWeights ===
         // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
-        const dtfPrice = folio.map((f, i) => f.mul(prices[i])).reduce((a, b) => a.add(b));
+        const dtfPrice = folio
+            .map((f, i) => f.mul(prices[i]))
+            .reduce((a, b) => a.add(b));
         // {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_js_light_1.default(`1e${decimals[i]}`)).div(numbers_1.D18d);
-        if (logging) {
-            console.log('limitMultiplier', limitMultiplier.toString());
+        if (debug) {
+            console.log("limitMultiplier", limitMultiplier.toString());
         }
         if (!weightControl) {
             // D27{tok/BU} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
@@ -101,16 +103,16 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
             .map((portion, i) => portion.mul(priceError[i]))
             .reduce((a, b) => a.add(b));
         if (totalPortion.gte(numbers_1.ONE)) {
-            throw new Error('totalPortion > 1');
+            throw new Error("totalPortion > 1");
         }
         // D18{BU/share} = {1} * D18 * {BU/share}
         newLimits.low = (0, numbers_1.bn)(numbers_1.ONE.div(numbers_1.ONE.add(totalPortion)).mul(numbers_1.D18d));
         newLimits.high = (0, numbers_1.bn)(numbers_1.ONE.add(totalPortion).mul(numbers_1.D18d));
     }
-    if (logging) {
+    if (debug) {
         console.log("newWeights", newWeights);
-        console.log('newPrices', newPrices);
-        console.log('newLimits', newLimits);
+        console.log("newPrices", newPrices);
+        console.log("newLimits", newLimits);
     }
     return {
         weights: newWeights,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reserve-protocol/dtf-rebalance-lib",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Rebalancing library for DTFs in typescript",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -17,7 +17,7 @@
     "prepublishOnly": "npm run build",
     "test": "npm run test:unit && npm run test:e2e",
     "test:unit": "node --test --require ts-node/register test/unit/*.test.ts",
-    "test:e2e": "hardhat test --bail"
+    "test:e2e": "hardhat test test/e2e/*.test.ts --bail"
   },
   "publishConfig": {
     "access": "public"