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

package/dist/open-auction.d.ts

@@ -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

@@ -55,8 +55,8 @@ 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) {
+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 ||
@@ -101,13 +101,20 @@ 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])).reduce((a, b) => a.add(b));
+    const shareValue = folio
+        .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) {
+    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
     const ejectionIndices = [];
@@ -118,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}
@@ -154,39 +163,44 @@ 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) {
+    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) || numbers_1.ONE.sub(rebalanceTarget).lt(1e-4)) {
-        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) {
+    if (debug) {
+        console.log("round", round);
         console.log("rebalanceTarget", rebalanceTarget.toString());
     }
     // {1}
@@ -201,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) {
@@ -228,7 +252,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     if (newLimits.high > rebalance.limits.high) {
         newLimits.high = rebalance.limits.high;
     }
-    if (logging) {
+    if (debug) {
         console.log("newLimits", newLimits);
     }
     // ================================================================
@@ -257,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;
@@ -283,7 +317,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
         return newWeightsD27;
     });
-    if (logging) {
+    if (debug) {
         console.log("newWeights", newWeights);
     }
     // ================================================================
@@ -322,7 +356,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
         return pricesD27;
     });
-    if (logging) {
+    if (debug) {
         console.log("newPrices", newPrices);
     }
     // ================================================================
@@ -344,19 +378,31 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         // {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.3",
+  "version": "0.1.4",
   "description": "Rebalancing library for DTFs in typescript",
   "main": "dist/index.js",
   "module": "dist/index.js",