@reserve-protocol/dtf-rebalance-lib 0.2.17 → 0.3.0

package/dist/open-auction.d.ts

@@ -45,7 +45,7 @@ export interface OpenAuctionArgs {
  * @param _prices {USD/wholeTok} either CURRENT or HISTORICAL prices
  * @returns D18{1} The target basket
  */
-export declare const getTargetBasket: (_initialWeights: WeightRange[], _prices: number[], _decimals: bigint[]) => bigint[];
+export declare const getTargetBasket: (_initialWeights: WeightRange[], _prices: number[], _decimals: bigint[], debug?: boolean) => bigint[];
 /**
  * Get the values needed to call `folio.openAuction()` as the AUCTION_LAUNCHER
  *

package/dist/open-auction.js

@@ -22,8 +22,13 @@ var AuctionRound;
  * @param _prices {USD/wholeTok} either CURRENT or HISTORICAL prices
  * @returns D18{1} The target basket
  */
-const getTargetBasket = (_initialWeights, _prices, _decimals) => {
-    console.log("getTargetBasket", _initialWeights, _prices, _decimals);
+const getTargetBasket = (_initialWeights, _prices, _decimals, debug) => {
+    if (debug === undefined) {
+        debug = true;
+    }
+    if (debug) {
+        console.log("getTargetBasket", _initialWeights, _prices, _decimals);
+    }
     if (_initialWeights.length != _prices.length) {
         throw new Error("length mismatch");
     }
@@ -79,7 +84,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     // {1} = D18{1} / D18
     const targetBasket = _targetBasket.map((a) => new utils_1.Decimal(a.toString()).div(numbers_1.D18d));
     // {USD/wholeTok}
-    const prices = _prices.map((a) => new utils_1.Decimal(a));
+    const prices = _prices.map((a) => new utils_1.Decimal(a.toString()));
     for (let i = 0; i < prices.length; i++) {
         if (prices[i].lte(numbers_1.ZERO)) {
             throw new Error(`missing price for token ${rebalance.tokens[i]}`);
@@ -148,10 +153,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,6 +174,7 @@ 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) => {
@@ -188,7 +198,7 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     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());
@@ -209,6 +219,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
@@ -236,8 +248,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)),
@@ -287,7 +297,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])),
@@ -325,20 +335,20 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     }
     // ================================================================
     // get new prices, constrained by extremes
-    // D27{USD/tok}
+    // D27{nanoUSD/tok}
     const newPrices = rebalance.initialPrices.map((initialPrice, i) => {
-        // revert if price out of bounds
-        const spotPrice = (0, numbers_1.bn)(prices[i].div(decimalScale[i]).mul(numbers_1.D27d));
+        // {nanoUSD/tok} = {USD/wholeTok} * {nanoUSD/USD} / {tok/wholeTok} * D27
+        const spotPrice = (0, numbers_1.bn)(prices[i].mul(numbers_1.D9d).div(decimalScale[i]).mul(numbers_1.D27d));
         if (spotPrice < initialPrice.low || spotPrice > initialPrice.high) {
             throw new Error(`spot price ${spotPrice.toString()} out of bounds relative to initial range [${initialPrice.low.toString()}, ${initialPrice.high.toString()}]! auction launcher MUST closeRebalance to prevent loss!`);
         }
         if (rebalance.priceControl == types_1.PriceControl.NONE) {
             return initialPrice;
         }
-        // D27{USD/tok} = {USD/wholeTok} * D27 / {tok/wholeTok}
+        // D27{nanoUSD/tok} = {USD/wholeTok} * {nanoUSD/USD} / {tok/wholeTok} * D27
         const pricesD27 = {
-            low: (0, numbers_1.bn)(prices[i].mul(numbers_1.ONE.sub(priceError[i])).div(decimalScale[i]).mul(numbers_1.D27d)),
-            high: (0, numbers_1.bn)(prices[i].div(numbers_1.ONE.sub(priceError[i])).div(decimalScale[i]).mul(numbers_1.D27d)),
+            low: (0, numbers_1.bn)(prices[i].mul(numbers_1.ONE.sub(priceError[i])).mul(numbers_1.D9d).div(decimalScale[i]).mul(numbers_1.D27d)),
+            high: (0, numbers_1.bn)(prices[i].div(numbers_1.ONE.sub(priceError[i])).mul(numbers_1.D9d).div(decimalScale[i]).mul(numbers_1.D27d)),
         };
         // low
         if (pricesD27.low < initialPrice.low) {
@@ -420,7 +430,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/dist/start-rebalance.js

@@ -84,14 +84,11 @@ const getStartRebalance = (_supply, tokens, _folio, decimals, _targetBasket, _pr
         // === newPrices ===
         // D27{wholeTok/tok} = D27 / {tok/wholeTok}
         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]));
-        // {USD/wholeTok} = {USD/wholeTok} / {1}
-        const highPrice = prices[i].div(numbers_1.ONE.sub(priceError[i]));
-        // D27{USD/tok} = {USD/wholeTok} * D27{wholeTok/tok}
         newPrices.push({
-            low: (0, numbers_1.bn)(lowPrice.mul(priceMultiplier)),
-            high: (0, numbers_1.bn)(highPrice.mul(priceMultiplier)),
+            // D27{nanoUSD/tok} = {USD/wholeTok} * {1} * D27{wholeTok/tok} * {nanoUSD/USD}
+            low: (0, numbers_1.bn)(prices[i].mul(numbers_1.ONE.sub(priceError[i])).mul(priceMultiplier).mul(numbers_1.D9d)),
+            // D27{nanoUSD/tok} = {USD/wholeTok} / {1} * D27{wholeTok/tok} * {nanoUSD/USD}
+            high: (0, numbers_1.bn)(prices[i].div(numbers_1.ONE.sub(priceError[i])).mul(priceMultiplier).mul(numbers_1.D9d)),
         });
     }
     // update low/high for tracking DTFs

package/package.json

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