@reserve-protocol/dtf-rebalance-lib 2.1.3 → 2.2.1

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);
     }
@@ -154,6 +151,16 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     })
         .reduce((a, b) => a.add(b), numbers_1.ZERO)
         .div(shareValue);
+    if (debug && ejectionIndices.length > 0) {
+        console.log("      Ejection calculation:");
+        console.log("        ejectionIndices:", ejectionIndices);
+        ejectionIndices.forEach(i => {
+            console.log(`        Token ${i}: assets=${_assets[i].toString()}, decimals=${_decimals[i].toString()}`);
+            console.log(`        Token ${i}: folio=${folio[i].toString()}, price=${prices[i].toString()}, value=${folio[i].mul(prices[i]).toString()}`);
+        });
+        console.log("        shareValue:", shareValue.toString());
+        console.log("        Total folio value:", folio.map((f, i) => f.mul(prices[i])).reduce((a, b) => a.add(b)).toString());
+    }
     // ================================================================
     // calculate progressions
     // {wholeBU/wholeShare} = {USD/wholeShare} / {USD/wholeBU}
@@ -163,7 +170,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 +208,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,40 +220,41 @@ 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
-        if (progression.add(portionBeingEjected).lt(numbers_1.ONE)) {
-            // else: get rid of all the dust
-            let ejectionTarget = progression.add(portionBeingEjected.mul(1.1)); // buy up to 10% extra
-            if (ejectionTarget.gt(numbers_1.ONE)) {
-                ejectionTarget = numbers_1.ONE;
-            }
-            if (ejectionTarget.gt(rebalanceTarget)) {
-                rebalanceTarget = ejectionTarget;
-            }
+        // if the ejections are mostly what's left, target JUST the ejection if that puts us at <100%
+        let ejectionTarget = progression.add(portionBeingEjected.mul(1.1)); // buy up to 10% extra
+        if (ejectionTarget.lt(numbers_1.ONE)) {
+            target = ejectionTarget;
+        }
+        if (debug) {
+            console.log("      EJECT round detected:");
+            console.log("        portionBeingEjected:", portionBeingEjected.toString());
+            console.log("        progression:", progression.toString());
+            console.log("        ejectionTarget:", ejectionTarget.toString());
+            console.log("        target:", target.toString());
         }
     }
-    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}
@@ -414,6 +422,13 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             if (tokenSurplusValue.gte(numbers_1.ONE)) {
                 surplusTokens.push(token);
                 surplusTokenSizes.push(tokenSurplusValue.toNumber());
+                if (debug && newWeights[i].spot === 0n) {
+                    console.log(`        EJECTING ${token}:`);
+                    console.log(`          assets[${i}]: ${_assets[i].toString()}`);
+                    console.log(`          sellDownTo: ${sellDownTo.toString()}`);
+                    console.log(`          surplusAmount: ${surplusAmount.toString()}`);
+                    console.log(`          surplusValue: ${tokenSurplusValue.toString()}`);
+                }
             }
         }
     });
@@ -433,7 +448,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,10 +51,10 @@ 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}
+        // {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.3",
+  "version": "2.2.1",
   "description": "Rebalancing library for DTFs in typescript",
   "main": "dist/index.js",
   "module": "dist/index.js",