@reserve-protocol/dtf-rebalance-lib 2.1.2 → 2.2.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './types';
 export * from './numbers';
-export * from './utils';
 export * from './open-auction';
 export * from './start-rebalance';
+export * from './utils';

package/dist/index.js

@@ -16,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./numbers"), exports);
-__exportStar(require("./utils"), exports);
 __exportStar(require("./open-auction"), exports);
 __exportStar(require("./start-rebalance"), exports);
+__exportStar(require("./utils"), exports);

package/dist/open-auction.js

@@ -63,9 +63,6 @@ exports.getTargetBasket = getTargetBasket;
  * @param _finalStageAt {1} The % rebalanced from the initial Folio to determine when is the final stage of the rebalance
  */
 const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [], _targetBasket = [], _assets, _decimals, _prices, _priceError, _finalStageAt, debug) => {
-    if (debug === undefined) {
-        debug = true;
-    }
     if (debug) {
         console.log("getOpenAuction", rebalance, _supply, _initialSupply, _initialAssets, _targetBasket, _assets, _decimals, _prices, _priceError, _finalStageAt);
     }
@@ -163,7 +160,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     const maxSpotLimit = spotLimit.gt(prevSpotLimit) ? spotLimit : prevSpotLimit;
     // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
     const expectedBalances = weightRanges.map((weightRange) => weightRange.spot.mul(maxSpotLimit));
-    // absolute
+    // absoluteProgression
     // {1} = {USD/wholeShare} / {USD/wholeShare}
     let progression = folio
         .map((actualBalance, i) => {
@@ -201,7 +198,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     let relativeProgression = initialProgression.eq(numbers_1.ONE)
         ? numbers_1.ONE
         : progression.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
-    let rebalanceTarget = numbers_1.ONE; // absolute
+    let target = numbers_1.ONE; // absolute
     let round = AuctionRound.FINAL;
     if (debug) {
         console.log("initialProgression", initialProgression.toString());
@@ -213,15 +210,15 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // 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 (rebalanceTarget.gte(0.997)) {
-            rebalanceTarget = numbers_1.ONE;
+        target = initialProgression.add(numbers_1.ONE.sub(initialProgression).mul(finalStageAt));
+        if (target.gte(0.997)) {
+            target = numbers_1.ONE;
         }
-        if (rebalanceTarget.eq(numbers_1.ONE)) {
+        if (target.eq(numbers_1.ONE)) {
             round = AuctionRound.FINAL;
         }
     }
-    // EJECT
+    // EJECT -- used later to adjust weights.high and limits.high
     if (portionBeingEjected.gt(1e-5)) {
         round = AuctionRound.EJECT;
         // if the ejections are everything that's left, keep the finalStageAt targeting from above
@@ -231,22 +228,22 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             if (ejectionTarget.gt(numbers_1.ONE)) {
                 ejectionTarget = numbers_1.ONE;
             }
-            if (ejectionTarget.gt(rebalanceTarget)) {
-                rebalanceTarget = ejectionTarget;
+            if (ejectionTarget.gt(target)) {
+                target = ejectionTarget;
             }
         }
     }
-    if (rebalanceTarget.lte(numbers_1.ZERO) || rebalanceTarget.lt(initialProgression) || rebalanceTarget.gt(numbers_1.ONE)) {
+    if (target.lte(numbers_1.ZERO) || target.lt(initialProgression) || target.gt(numbers_1.ONE)) {
         throw new Error("something has gone very wrong");
     }
-    const relativeTarget = rebalanceTarget.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
+    const relativeTarget = target.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
     if (debug) {
         console.log("round", round);
-        console.log("rebalanceTarget", rebalanceTarget.toString());
+        console.log("target", target.toString());
         console.log("relativeTarget", relativeTarget.toString());
     }
     // {1}
-    const delta = numbers_1.ONE.sub(rebalanceTarget);
+    const delta = numbers_1.ONE.sub(target);
     // ================================================================
     // get new limits, constrained by extremes
     // D18{BU/share} = {wholeBU/wholeShare} * D18 * {1}
@@ -433,7 +430,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             initialProgression: initialProgression.toNumber(),
             absoluteProgression: progression.toNumber(),
             relativeProgression: relativeProgression.toNumber(),
-            target: rebalanceTarget.toNumber(),
+            target: target.toNumber(),
             relativeTarget: relativeTarget.toNumber(),
             auctionSize: auctionSize,
             surplusTokens: surplusTokens,

package/dist/types.d.ts

@@ -29,3 +29,10 @@ export interface Rebalance {
     availableUntil: bigint;
     priceControl: PriceControl;
 }
+export interface Folio {
+    name: string;
+    chainId: number;
+    folio: string;
+    proxyAdmin: string;
+    basketGovernor?: string;
+}

package/dist/utils.d.ts

@@ -20,6 +20,6 @@ export declare const getBasketDistribution: (_bals: bigint[], _prices: number[],
  * @param decimals Decimals of each token
  * @param weights Current weights from getRebalance.weights
  * @param limits Current limits from getRebalance.limits
- * @returns {1} Basket deviation
+ * @returns {1} Basket accuracy
  */
 export declare const getBasketAccuracy: (supply: bigint, _bals: bigint[], _prices: number[], decimals: bigint[], weights: WeightRange[], limits: RebalanceLimits) => number;

package/dist/utils.js

@@ -38,7 +38,7 @@ exports.getBasketDistribution = getBasketDistribution;
  * @param decimals Decimals of each token
  * @param weights Current weights from getRebalance.weights
  * @param limits Current limits from getRebalance.limits
- * @returns {1} Basket deviation
+ * @returns {1} Basket accuracy
  */
 const getBasketAccuracy = (supply, _bals, _prices, decimals, weights, limits) => {
     const decimalScale = decimals.map((d) => new exports.Decimal(`1e${d}`));
@@ -51,11 +51,11 @@ const getBasketAccuracy = (supply, _bals, _prices, decimals, weights, limits) =>
         // {tok} = D27{tok/BU} * D18{BU/share} * {share} / D27 / D18
         const expectedBal = (weights[i].spot * limits.spot * supply) / numbers_1.D27n / numbers_1.D18n;
         if (_bals[i] > expectedBal) {
-            // {USD} = {tok} * {USD/wholeTok} / {tok/wholeTok}
+            // {USD} += {tok} * {USD/wholeTok} / {tok/wholeTok}
             surplusValue = surplusValue.add(new exports.Decimal((_bals[i] - expectedBal).toString()).mul(prices[i]).div(decimalScale[i]));
-            // {USD} = {tok} * {USD/wholeTok} / {tok/wholeTok}
-            totalValue = totalValue.add(new exports.Decimal(_bals[i].toString()).mul(prices[i]).div(decimalScale[i]));
         }
+        // {USD} += {tok} * {USD/wholeTok} / {tok/wholeTok}
+        totalValue = totalValue.add(new exports.Decimal(_bals[i].toString()).mul(prices[i]).div(decimalScale[i]));
     }
     return totalValue.sub(surplusValue).div(totalValue).toNumber();
 };

package/package.json

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