@reserve-protocol/dtf-rebalance-lib 0.0.10 → 0.0.12

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) => [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, logging?: boolean) => [OpenAuctionArgs, AuctionMetrics];

package/dist/open-auction.js

@@ -59,7 +59,10 @@ 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 = 0.9) => {
+const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket = [], _folio, _decimals, _prices, _priceError, _finalStageAt, logging = false) => {
+    if (logging) {
+        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 ||
@@ -118,6 +121,10 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     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());
+    }
     // ================================================================
     // calculate rebalanceTarget
     const ejectionIndices = [];
@@ -184,6 +191,14 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
             throw new Error('something has gone very wrong');
         }
     }
+    if (logging) {
+        console.log('rebalanceTarget', rebalanceTarget.toString());
+        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());
+    }
     // {1}
     const delta = numbers_1.ONE.sub(rebalanceTarget);
     // ================================================================
@@ -217,6 +232,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
     if (newLimits.high > rebalance.limits.high) {
         newLimits.high = rebalance.limits.high;
     }
+    if (logging) {
+        console.log('newLimits', newLimits);
+    }
     // ================================================================
     // get new weights, constrained by extremes
     // {wholeBU/wholeShare} = D18{BU/share} / D18
@@ -266,6 +284,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
         return newWeightsD27;
     });
+    if (logging) {
+        console.log('newWeights', newWeights);
+    }
     // ================================================================
     // get new prices, constrained by extremes
     // D27{USD/tok}
@@ -302,6 +323,9 @@ const getOpenAuction = (rebalance, _supply, _initialFolio = [], _targetBasket =
         }
         return pricesD27;
     });
+    if (logging) {
+        console.log('newPrices', newPrices);
+    }
     // ================================================================
     // calculate metrics
     // {USD} = {1} * {USD/wholeShare} * {wholeShare}

package/dist/start-rebalance.d.ts

@@ -18,4 +18,4 @@ export interface StartRebalanceArgsPartial {
  * @param _dtfPrice {USD/wholeShare} DTF price
  * @param weightControl TRACKING=false, NATIVE=true
  */
-export declare const getStartRebalance: (_supply: bigint, tokens: string[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], _dtfPrice: number, weightControl: boolean) => StartRebalanceArgsPartial;
+export declare const getStartRebalance: (_supply: bigint, tokens: string[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], _dtfPrice: number, weightControl: boolean, logging?: boolean) => StartRebalanceArgsPartial;

package/dist/start-rebalance.js

@@ -20,7 +20,10 @@ const numbers_1 = require("./numbers");
  * @param _dtfPrice {USD/wholeShare} DTF price
  * @param weightControl TRACKING=false, NATIVE=true
  */
-const getStartRebalance = (_supply, tokens, decimals, _targetBasket, _prices, _priceError, _dtfPrice, weightControl) => {
+const getStartRebalance = (_supply, tokens, decimals, _targetBasket, _prices, _priceError, _dtfPrice, weightControl, logging = false) => {
+    if (logging) {
+        console.log('getStartRebalance', _supply, tokens, decimals, _targetBasket, _prices, _priceError, _dtfPrice, weightControl);
+    }
     // convert price number inputs to bigints
     // {USD/wholeTok}
     const prices = _prices.map((a) => new decimal_js_light_1.default(a.toString()));
@@ -53,6 +56,9 @@ const getStartRebalance = (_supply, tokens, decimals, _targetBasket, _prices, _p
         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 (!weightControl) {
             // D27{tok/BU} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
             newWeights.push({
@@ -98,6 +104,11 @@ const getStartRebalance = (_supply, tokens, decimals, _targetBasket, _prices, _p
         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) {
+        console.log("newWeights", newWeights);
+        console.log('newPrices', newPrices);
+        console.log('newLimits', newLimits);
+    }
     return {
         weights: newWeights,
         prices: newPrices,

package/package.json

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

package/src/open-auction.ts

@@ -110,8 +110,12 @@ export const getOpenAuction = (
   _decimals: bigint[],
   _prices: number[],
   _priceError: number[],
-  _finalStageAt: number = 0.9
+  _finalStageAt: number,
+  logging: boolean = false
 ): [OpenAuctionArgs, AuctionMetrics] => {
+  if (logging) {
+    console.log('getOpenAuction', rebalance, _supply, _initialFolio, _targetBasket, _folio, _decimals, _prices, _priceError, _finalStageAt)
+  }
 
   if (
     rebalance.tokens.length != _targetBasket.length ||
@@ -196,6 +200,10 @@ export const getOpenAuction = (
     .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())
+  }
 
   // ================================================================
 
@@ -252,20 +260,20 @@ export const getOpenAuction = (
   if (progression < initialProgression) {
     progression = initialProgression // don't go backwards
   }
-
+  
   
   // {1} = {1} / {1}
   const relativeProgression = initialProgression.eq(ONE)
-    ? ONE
-    : progression.sub(initialProgression).div(ONE.sub(initialProgression))
-
+  ? ONE
+  : progression.sub(initialProgression).div(ONE.sub(initialProgression))
+  
   let rebalanceTarget = ONE
   let round: AuctionRound = AuctionRound.FINAL
-
+  
   // make it an eject auction if there is 1 bps or more of value to eject
   if (portionBeingEjected.gte(1e-4)) {
     round = AuctionRound.EJECT
-
+    
     rebalanceTarget = progression.add(portionBeingEjected.mul(1.2)) // set rebalanceTarget to 20% more than needed to ensure ejection completes
     if (rebalanceTarget.gt(ONE)) {
       rebalanceTarget = ONE
@@ -273,12 +281,21 @@ export const getOpenAuction = (
   } 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
     round = AuctionRound.PROGRESS
-
+    
     rebalanceTarget = initialProgression.add(ONE.sub(initialProgression).mul(finalStageAt))
     if (rebalanceTarget.gte(ONE)) {
       throw new Error('something has gone very wrong')
     }
   }
+  
+  if (logging) {
+    console.log('rebalanceTarget', rebalanceTarget.toString())
+    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())
+  }
 
   // {1}
   const delta = ONE.sub(rebalanceTarget)
@@ -322,6 +339,10 @@ export const getOpenAuction = (
     newLimits.high = rebalance.limits.high
   }
 
+  if (logging) {
+    console.log('newLimits', newLimits)
+  }
+
   // ================================================================
 
   // get new weights, constrained by extremes
@@ -381,6 +402,10 @@ export const getOpenAuction = (
     return newWeightsD27
   })
 
+  if (logging) {
+    console.log('newWeights', newWeights)
+  }
+
   // ================================================================
 
   // get new prices, constrained by extremes
@@ -432,6 +457,10 @@ export const getOpenAuction = (
     return pricesD27
   })
 
+  if (logging) {
+    console.log('newPrices', newPrices)
+  }
+
   // ================================================================
 
   // calculate metrics

package/src/start-rebalance.ts

@@ -36,8 +36,13 @@ export const getStartRebalance = (
   _prices: number[],
   _priceError: number[],
   _dtfPrice: number,
-  weightControl: boolean
+  weightControl: boolean,
+  logging: boolean = false
 ): StartRebalanceArgsPartial => {
+  if (logging) {
+    console.log('getStartRebalance', _supply, tokens, decimals, _targetBasket, _prices, _priceError, _dtfPrice, weightControl)
+  }
+
   // convert price number inputs to bigints
 
   // {USD/wholeTok}
@@ -86,6 +91,10 @@ export const getStartRebalance = (
     // D27{tok/share}{wholeShare/wholeTok} = D27 * {tok/wholeTok} / {share/wholeShare}
     const limitMultiplier = D27d.mul(new Decimal(`1e${decimals[i]}`)).div(D18d)
 
+    if (logging) {
+      console.log('limitMultiplier', limitMultiplier.toString())
+    }
+
     if (!weightControl) {
       // D27{tok/BU} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
       newWeights.push({
@@ -125,22 +134,28 @@ export const getStartRebalance = (
       high: bn(highPrice.mul(priceMultiplier)),
     })
   }
-
+  
   // update low/high for tracking DTFs
   if (!weightControl) {
     // sum of dot product of targetBasket and priceError
     const totalPortion = targetBasket
-      .map((portion: Decimal, i: number) => portion.mul(priceError[i]))
-      .reduce((a: Decimal, b: Decimal) => a.add(b))
-
+    .map((portion: Decimal, i: number) => portion.mul(priceError[i]))
+    .reduce((a: Decimal, b: Decimal) => a.add(b))
+    
     if (totalPortion.gte(ONE)) {
       throw new Error('totalPortion > 1')
     }
-
+    
     // D18{BU/share} = {1} * D18 * {BU/share}
     newLimits.low = bn(ONE.div(ONE.add(totalPortion)).mul(D18d))
     newLimits.high = bn(ONE.add(totalPortion).mul(D18d))
   }
+  
+  if (logging) {
+    console.log("newWeights", newWeights)
+    console.log('newPrices', newPrices)
+    console.log('newLimits', newLimits)
+  }
 
   return {
     weights: newWeights,