@reserve-protocol/dtf-rebalance-lib 0.2.16 → 0.2.18

package/dist/open-auction.d.ts

@@ -51,13 +51,13 @@ export declare const getTargetBasket: (_initialWeights: WeightRange[], _prices:
  *
  * Non-AUCTION_LAUNCHERs should use `folio.openAuctionUnrestricted()`
  *
- * @param rebalance The result of calling folio.getRebalance()
+ * @param rebalance The result of calling folio.getRebalance(), today
  * @param _supply {share} The totalSupply() of the basket, today
  * @param _initialFolio D18{tok/share} Initial balances per share, e.g result of folio.toAssets(1e18, 0) at time rebalance was first proposed
  * @param _targetBasket D18{1} Result of calling `getTargetBasket()`
- * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0)
+ * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0), today
  * @param _decimals Decimals of each token
- * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token, today
  * @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
  */

package/dist/open-auction.js

@@ -46,13 +46,13 @@ exports.getTargetBasket = getTargetBasket;
  *
  * Non-AUCTION_LAUNCHERs should use `folio.openAuctionUnrestricted()`
  *
- * @param rebalance The result of calling folio.getRebalance()
+ * @param rebalance The result of calling folio.getRebalance(), today
  * @param _supply {share} The totalSupply() of the basket, today
  * @param _initialFolio D18{tok/share} Initial balances per share, e.g result of folio.toAssets(1e18, 0) at time rebalance was first proposed
  * @param _targetBasket D18{1} Result of calling `getTargetBasket()`
- * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0)
+ * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0), today
  * @param _decimals Decimals of each token
- * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token, today
  * @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
  */
@@ -148,10 +148,14 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         .div(shareValue);
     // ================================================================
     // calculate progressions
+    // {wholeBU/wholeShare} = {USD/wholeShare} / {USD/wholeBU}
+    const spotLimit = shareValue.div(buValue);
     // {wholeBU/wholeShare} = D18{BU/share} / D18
     const prevSpotLimit = new utils_1.Decimal(rebalance.limits.spot.toString()).div(numbers_1.D18d);
+    const maxSpotLimit = spotLimit.gt(prevSpotLimit) ? spotLimit : prevSpotLimit;
     // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
-    const expectedBalances = weightRanges.map((weightRange) => weightRange.spot.mul(prevSpotLimit));
+    const expectedBalances = weightRanges.map((weightRange) => weightRange.spot.mul(maxSpotLimit));
+    // absolute scale
     // {1} = {USD/wholeShare} / {USD/wholeShare}
     let progression = folio
         .map((actualBalance, i) => {
@@ -165,11 +169,11 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     })
         .reduce((a, b) => a.add(b))
         .div(shareValue);
+    // absolute scale
     // {1} = {USD/wholeShare} / {USD/wholeShare}
     const initialProgression = initialFolio
         .map((initialBalance, i) => {
-        // make sure to include tokens that were already ejected
-        if (!rebalance.inRebalance[i] && rebalance.weights[i].spot > 0n) {
+        if (!rebalance.inRebalance[i]) {
             return numbers_1.ZERO;
         }
         // {wholeTok/wholeShare}
@@ -183,13 +187,13 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         if (debug) {
             console.log("progression < initialProgression", progression.toString(), initialProgression.toString());
         }
-        progression = initialProgression; // don't go backwards
+        progression = initialProgression; // don't go backwards, should only happen due to negligible rounding errors
     }
     // {1} = {1} / {1}
     let relativeProgression = initialProgression.eq(numbers_1.ONE)
         ? numbers_1.ONE
         : progression.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
-    let rebalanceTarget = numbers_1.ONE;
+    let rebalanceTarget = numbers_1.ONE; // absolute scale
     let round = AuctionRound.FINAL;
     if (debug) {
         console.log("initialProgression", initialProgression.toString());
@@ -210,6 +214,8 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
     }
     // EJECT
+    // TODO maybe increase threshold to nonzero value, taking into account price
+    //      currently will get stuck trying to eject tiny dust over and over
     if (portionBeingEjected.gt(0)) {
         round = AuctionRound.EJECT;
         // if the ejections are everything that's left, keep the finalStageAt targeting from above
@@ -237,8 +243,6 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     const delta = numbers_1.ONE.sub(rebalanceTarget);
     // ================================================================
     // get new limits, constrained by extremes
-    // {wholeBU/wholeShare} = {USD/wholeShare} / {USD/wholeBU}
-    const spotLimit = shareValue.div(buValue);
     // D18{BU/share} = {wholeBU/wholeShare} * D18 * {1}
     const newLimits = {
         low: (0, numbers_1.bn)(spotLimit.sub(spotLimit.mul(delta)).mul(numbers_1.D18d)),
@@ -288,7 +292,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         // D27{tok/BU} = {wholeTok/wholeBU} * D27 * {tok/wholeTok} / {BU/wholeBU}
         const newWeightsD27 = {
             low: (0, numbers_1.bn)(idealWeight
-                .mul(rebalanceTarget.div(actualLimits.low.div(actualLimits.spot))) // add remaining delta into weight
+                .mul(numbers_1.ONE.sub(delta).div(actualLimits.low.div(actualLimits.spot))) // add remaining delta into weight
                 .mul(numbers_1.D9d)
                 .mul(decimalScale[i])),
             spot: (0, numbers_1.bn)(idealWeight.mul(numbers_1.D9d).mul(decimalScale[i])),
@@ -421,7 +425,8 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     const returnWeights = [];
     const returnPrices = [];
     for (let i = 0; i < rebalance.tokens.length; i++) {
-        if (rebalance.inRebalance[i]) {
+        if (rebalance.inRebalance[i] &&
+            (surplusTokens.includes(rebalance.tokens[i]) || deficitTokens.includes(rebalance.tokens[i]))) {
             returnTokens.push(rebalance.tokens[i]);
             returnWeights.push(newWeights[i]);
             returnPrices.push(newPrices[i]);

package/package.json

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