@reserve-protocol/dtf-rebalance-lib 2.6.4 → 3.0.0

package/dist/numbers.d.ts

@@ -3,6 +3,7 @@ import type { Decimal as DecimalType } from "decimal.js-light";
 export declare const D27n: bigint;
 export declare const D18n: bigint;
 export declare const D9n: bigint;
+export declare const D256_MAXn: bigint;
 export declare const D27d: DecimalType;
 export declare const D18d: DecimalType;
 export declare const D9d: DecimalType;

package/dist/numbers.js

@@ -3,13 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bn = exports.TWO = exports.ONE = exports.EPSILON = exports.ZERO = exports.D9d = exports.D18d = exports.D27d = exports.D9n = exports.D18n = exports.D27n = void 0;
+exports.bn = exports.TWO = exports.ONE = exports.EPSILON = exports.ZERO = exports.D9d = exports.D18d = exports.D27d = exports.D256_MAXn = exports.D9n = exports.D18n = exports.D27n = void 0;
 const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
 // Create a local Decimal constructor with custom precision
 const Decimal = decimal_js_light_1.default.clone({ precision: 100 });
 exports.D27n = 10n ** 27n;
 exports.D18n = 10n ** 18n;
 exports.D9n = 10n ** 9n;
+exports.D256_MAXn = 10n ** 256n - 1n;
 exports.D27d = new Decimal("1e27");
 exports.D18d = new Decimal("1e18");
 exports.D9d = new Decimal("1e9");

package/dist/open-auction.js

@@ -99,20 +99,22 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // {wholeTok/wholeShare} = {tok} / {tok/wholeTok} / {wholeShare}
     const folio = _assets.map((bal, i) => new utils_1.Decimal(bal.toString()).div(decimalScale[i]).div(supply));
     // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
-    let weightRanges = rebalance.weights.map((range, i) => {
+    let weightRanges = rebalance.tokens.map((params, i) => {
         return {
-            low: new utils_1.Decimal(range.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            spot: new utils_1.Decimal(range.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
-            high: new utils_1.Decimal(range.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            low: new utils_1.Decimal(params.weight.low.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            spot: new utils_1.Decimal(params.weight.spot.toString()).div(decimalScale[i]).div(numbers_1.D9d),
+            high: new utils_1.Decimal(params.weight.high.toString()).div(decimalScale[i]).div(numbers_1.D9d),
         };
     });
+    // {wholeTok} = {tok} / {tok/wholeTok}
+    const maxAuctionSizes = rebalance.tokens.map((params, i) => new utils_1.Decimal(params.maxAuctionSize.toString()).div(decimalScale[i]));
     const finalStageAt = new utils_1.Decimal(_finalStageAt.toString());
     // ================================================================
     // calculate ideal spot limit, the actual BU<->share ratio
     // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
     const shareValue = folio
         .map((f, i) => {
-        if (!rebalance.inRebalance[i]) {
+        if (!rebalance.tokens[i].inRebalance) {
             return numbers_1.ZERO;
         }
         return f.mul(prices[i]);
@@ -121,7 +123,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // {USD/wholeBU} = {wholeTok/wholeBU} * {USD/wholeTok}
     const buValue = weightRanges
         .map((weightRange, i) => {
-        if (!rebalance.inRebalance[i]) {
+        if (!rebalance.tokens[i].inRebalance) {
             return numbers_1.ZERO;
         }
         return weightRange.spot.mul(prices[i]);
@@ -139,8 +141,8 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // ================================================================
     // calculate portionBeingEjected
     const ejectionIndices = [];
-    for (let i = 0; i < rebalance.weights.length; i++) {
-        if (rebalance.inRebalance[i] && rebalance.weights[i].spot == 0n) {
+    for (let i = 0; i < rebalance.tokens.length; i++) {
+        if (rebalance.tokens[i].inRebalance && rebalance.tokens[i].weight.spot == 0n) {
             ejectionIndices.push(i);
         }
     }
@@ -161,7 +163,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // {1} = {USD/wholeShare} / {USD/wholeShare}
     const progression = folio
         .map((actualBalance, i) => {
-        if (!rebalance.inRebalance[i]) {
+        if (!rebalance.tokens[i].inRebalance) {
             return numbers_1.ZERO;
         }
         // {wholeTok/wholeShare}
@@ -175,7 +177,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // {1} = {USD/wholeShare} / {USD/wholeShare}
     let initialProgression = initialFolio
         .map((initialBalance, i) => {
-        if (!rebalance.inRebalance[i]) {
+        if (!rebalance.tokens[i].inRebalance) {
             return numbers_1.ZERO;
         }
         // {wholeTok/wholeShare}
@@ -270,7 +272,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
         high: new utils_1.Decimal(newLimits.high.toString()).div(numbers_1.D18d),
     };
     // D27{tok/BU}
-    const newWeights = rebalance.weights.map((weightRange, i) => {
+    const newWeights = rebalance.tokens.map((params, i) => {
         // {wholeTok/wholeBU} = {USD/wholeShare} * {1} / {wholeBU/wholeShare} / {USD/wholeTok}
         const idealWeight = shareValue.mul(targetBasket[i]).div(actualLimits.spot).div(prices[i]);
         // D27{tok/BU} = {wholeTok/wholeBU} * D27 * {tok/wholeTok} / {BU/wholeBU}
@@ -283,7 +285,7 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             high: 
             // hold surpluses aside if ejecting
             round == AuctionRound.EJECT
-                ? weightRange.high
+                ? params.weight.high
                 : (0, numbers_1.bn)(idealWeight
                     .mul(idealHighLimit.div(actualLimits.high)) // add the portion of `delta` we failed to propagate through to the high limit
                     .mul(numbers_1.D9d)
@@ -297,23 +299,23 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             newWeightsD27.high = newWeightsD27.spot;
         }
         // enforce in range
-        if (newWeightsD27.low < weightRange.low) {
-            newWeightsD27.low = weightRange.low;
+        if (newWeightsD27.low < params.weight.low) {
+            newWeightsD27.low = params.weight.low;
         }
-        else if (newWeightsD27.low > weightRange.high) {
-            newWeightsD27.low = weightRange.high;
+        else if (newWeightsD27.low > params.weight.high) {
+            newWeightsD27.low = params.weight.high;
         }
-        if (newWeightsD27.spot < weightRange.low) {
-            newWeightsD27.spot = weightRange.low;
+        if (newWeightsD27.spot < params.weight.low) {
+            newWeightsD27.spot = params.weight.low;
         }
-        else if (newWeightsD27.spot > weightRange.high) {
-            newWeightsD27.spot = weightRange.high;
+        else if (newWeightsD27.spot > params.weight.high) {
+            newWeightsD27.spot = params.weight.high;
         }
-        if (newWeightsD27.high < weightRange.low) {
-            newWeightsD27.high = weightRange.low;
+        if (newWeightsD27.high < params.weight.low) {
+            newWeightsD27.high = params.weight.low;
         }
-        else if (newWeightsD27.high > weightRange.high) {
-            newWeightsD27.high = weightRange.high;
+        else if (newWeightsD27.high > params.weight.high) {
+            newWeightsD27.high = params.weight.high;
         }
         return newWeightsD27;
     });
@@ -323,14 +325,14 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     // ================================================================
     // get new prices, constrained by extremes
     // D27{nanoUSD/tok}
-    const newPrices = rebalance.initialPrices.map((initialPrice, i) => {
+    const newPrices = rebalance.tokens.map((params, i) => {
         // D27{nanoUSD/tok} = {USD/wholeTok} * {nanoUSD/USD} * D27 / {tok/wholeTok}
         const spotPrice = (0, numbers_1.bn)(prices[i].mul(numbers_1.D9d).mul(numbers_1.D27d).div(decimalScale[i]));
-        if (spotPrice < initialPrice.low || spotPrice > initialPrice.high) {
-            throw new Error(`Token ${rebalance.tokens[i]}: 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 (spotPrice < params.price.low || spotPrice > params.price.high) {
+            throw new Error(`Token ${rebalance.tokens[i]}: spot price ${spotPrice.toString()} out of bounds relative to initial range [${params.price.low.toString()}, ${params.price.high.toString()}]! auction launcher MUST closeRebalance to prevent loss!`);
         }
         if (rebalance.priceControl == types_1.PriceControl.NONE) {
-            return initialPrice;
+            return params.price;
         }
         // D27{nanoUSD/tok} = {USD/wholeTok} * {nanoUSD/USD} * D27 / {tok/wholeTok}
         const pricesD27 = {
@@ -338,18 +340,18 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
             high: (0, numbers_1.bn)(prices[i].div(numbers_1.ONE.sub(priceError[i])).mul(numbers_1.D9d).mul(numbers_1.D27d).div(decimalScale[i])),
         };
         // low
-        if (pricesD27.low < initialPrice.low) {
-            pricesD27.low = initialPrice.low;
+        if (pricesD27.low < params.price.low) {
+            pricesD27.low = params.price.low;
         }
-        if (pricesD27.low > initialPrice.high) {
-            pricesD27.low = initialPrice.high;
+        if (pricesD27.low > params.price.high) {
+            pricesD27.low = params.price.high;
         }
         // high
-        if (pricesD27.high < initialPrice.low) {
-            pricesD27.high = initialPrice.low;
+        if (pricesD27.high < params.price.low) {
+            pricesD27.high = params.price.low;
         }
-        if (pricesD27.high > initialPrice.high) {
-            pricesD27.high = initialPrice.high;
+        if (pricesD27.high > params.price.high) {
+            pricesD27.high = params.price.high;
         }
         if (pricesD27.low == pricesD27.high && priceError[i].gt(numbers_1.ZERO)) {
             throw new Error("no price range");
@@ -370,11 +372,11 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
     const surplusTokenSizes = []; // {USD}
     const deficitTokens = [];
     const deficitTokenSizes = []; // {USD}
-    rebalance.tokens.forEach((token, i) => {
-        if (!rebalance.inRebalance[i]) {
+    rebalance.tokens.forEach((params, i) => {
+        if (!rebalance.tokens[i].inRebalance) {
             return;
         }
-        auctionTokens.push(token);
+        auctionTokens.push(params.token);
         auctionWeights.push(newWeights[i]);
         auctionPrices.push(newPrices[i]);
         // {tok} = D27{tok/BU} * D18{BU/share} * {share} / D18 / D27
@@ -382,21 +384,27 @@ const getOpenAuction = (rebalance, _supply, _initialSupply, _initialAssets = [],
         const sellDownTo = (newWeights[i].high * newLimits.high * _supply + (numbers_1.D18n * numbers_1.D27n - 1n)) / numbers_1.D18n / numbers_1.D27n;
         if (_assets[i] < buyUpTo) {
             // {wholeTok} = {tok} / {tok/wholeTok}
-            const deficitAmount = new utils_1.Decimal((buyUpTo - _assets[i]).toString()).div(decimalScale[i]);
+            let deficitAmount = new utils_1.Decimal((buyUpTo - _assets[i]).toString()).div(decimalScale[i]);
+            if (deficitAmount.gt(maxAuctionSizes[i])) {
+                deficitAmount = maxAuctionSizes[i];
+            }
             // {USD} = {wholeTok} * {USD/wholeTok}
             const tokenDeficitValue = deficitAmount.mul(prices[i]);
             if (tokenDeficitValue.gt(numbers_1.EPSILON)) {
-                deficitTokens.push(token);
+                deficitTokens.push(params.token);
                 deficitTokenSizes.push(tokenDeficitValue.toNumber());
             }
         }
         else if (_assets[i] > sellDownTo) {
             // {wholeTok} = {tok} / {tok/wholeTok}
-            const surplusAmount = new utils_1.Decimal((_assets[i] - sellDownTo).toString()).div(decimalScale[i]);
+            let surplusAmount = new utils_1.Decimal((_assets[i] - sellDownTo).toString()).div(decimalScale[i]);
+            if (surplusAmount.gt(maxAuctionSizes[i])) {
+                surplusAmount = maxAuctionSizes[i];
+            }
             // {USD} = {wholeTok} * {USD/wholeTok}
             const tokenSurplusValue = surplusAmount.mul(prices[i]);
             if (tokenSurplusValue.gt(numbers_1.EPSILON)) {
-                surplusTokens.push(token);
+                surplusTokens.push(params.token);
                 surplusTokenSizes.push(tokenSurplusValue.toNumber());
             }
         }

package/dist/start-rebalance.d.ts

@@ -1,7 +1,6 @@
-import { PriceRange, RebalanceLimits, WeightRange } from "./types";
+import { RebalanceLimits, TokenRebalanceParams } from "./types";
 export interface StartRebalanceArgsPartial {
-    weights: WeightRange[];
-    prices: PriceRange[];
+    tokens: TokenRebalanceParams[];
     limits: RebalanceLimits;
 }
 /**
@@ -17,7 +16,8 @@ export interface StartRebalanceArgsPartial {
  * @param _prices {USD/wholeTok} USD prices for each *whole* token
  * @param _priceError {1} Price error per token to use in the rebalance; should be larger than price error during openAuction
  * @param _dtfPrice {USD/wholeShare} DTF price
+ * @param _maxAuctionSize {USD} The maximum auction size for each token
  * @param weightControl TRACKING=false, NATIVE=true
  * @param deferWeights Whether to use the full range for weights, only possible for NATIVE DTFs
  */
-export declare const getStartRebalance: (_supply: bigint, tokens: string[], _assets: bigint[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], weightControl: boolean, deferWeights: boolean, debug?: boolean) => StartRebalanceArgsPartial;
+export declare const getStartRebalance: (_supply: bigint, tokens: string[], _assets: bigint[], decimals: bigint[], _targetBasket: bigint[], _prices: number[], _priceError: number[], _maxAuctionSizes: number[], weightControl: boolean, deferWeights: boolean, debug?: boolean) => StartRebalanceArgsPartial;

package/dist/start-rebalance.js

@@ -16,12 +16,13 @@ const numbers_1 = require("./numbers");
  * @param _prices {USD/wholeTok} USD prices for each *whole* token
  * @param _priceError {1} Price error per token to use in the rebalance; should be larger than price error during openAuction
  * @param _dtfPrice {USD/wholeShare} DTF price
+ * @param _maxAuctionSize {USD} The maximum auction size for each token
  * @param weightControl TRACKING=false, NATIVE=true
  * @param deferWeights Whether to use the full range for weights, only possible for NATIVE DTFs
  */
-const getStartRebalance = (_supply, tokens, _assets, decimals, _targetBasket, _prices, _priceError, weightControl, deferWeights, debug) => {
+const getStartRebalance = (_supply, tokens, _assets, decimals, _targetBasket, _prices, _priceError, _maxAuctionSizes, weightControl, deferWeights, debug) => {
     if (debug) {
-        console.log("getStartRebalance", _supply, tokens, _assets, decimals, _targetBasket, _prices, _priceError, weightControl, deferWeights);
+        console.log("getStartRebalance", _supply, tokens, _assets, decimals, _targetBasket, _prices, _priceError, _maxAuctionSizes, weightControl, deferWeights);
     }
     if (deferWeights && !weightControl) {
         throw new Error("deferWeights is not supported for tracking DTFs");
@@ -45,6 +46,7 @@ const getStartRebalance = (_supply, tokens, _assets, decimals, _targetBasket, _p
     // ================================================================
     const newWeights = [];
     const newPrices = [];
+    const maxAuctionSizes = [];
     const maxPriceError = new utils_1.Decimal("0.9");
     for (let i = 0; i < tokens.length; i++) {
         if (priceError[i].gt(maxPriceError)) {
@@ -110,6 +112,18 @@ const getStartRebalance = (_supply, tokens, _assets, decimals, _targetBasket, _p
             low: low,
             high: high,
         });
+        // === maxAuctionSizes ===
+        // {USD}
+        const maxAuctionSize = new utils_1.Decimal(_maxAuctionSizes[i].toString());
+        // {tok} = {USD} * {tok/wholeTok} / {USD/wholeTok}
+        let maxAuctionSizeTok = (0, numbers_1.bn)(maxAuctionSize.mul(new utils_1.Decimal(`1e${decimals[i]}`)).div(prices[i]));
+        if (maxAuctionSizeTok == 0n) {
+            throw new Error(`maxAuctionSize for token ${tokens[i]} is 0`);
+        }
+        if (maxAuctionSizeTok > numbers_1.D256_MAXn) {
+            maxAuctionSizeTok = numbers_1.D256_MAXn;
+        }
+        maxAuctionSizes.push(maxAuctionSizeTok);
     }
     // ================================================================
     // newLimits
@@ -132,8 +146,13 @@ const getStartRebalance = (_supply, tokens, _assets, decimals, _targetBasket, _p
         console.log("newLimits", newLimits);
     }
     return {
-        weights: newWeights,
-        prices: newPrices,
+        tokens: tokens.map((token, i) => ({
+            token: token,
+            weight: newWeights[i],
+            price: newPrices[i],
+            maxAuctionSize: maxAuctionSizes[i],
+            inRebalance: true,
+        })),
         limits: newLimits,
     };
 };

package/dist/types.d.ts

@@ -17,17 +17,24 @@ export interface PriceRange {
     low: bigint;
     high: bigint;
 }
-export interface Rebalance {
-    nonce: bigint;
-    tokens: string[];
-    weights: WeightRange[];
-    initialPrices: PriceRange[];
-    inRebalance: boolean[];
-    limits: RebalanceLimits;
+export interface TokenRebalanceParams {
+    token: string;
+    weight: WeightRange;
+    price: PriceRange;
+    maxAuctionSize: bigint;
+    inRebalance: boolean;
+}
+export interface RebalanceTimestamps {
     startedAt: bigint;
     restrictedUntil: bigint;
     availableUntil: bigint;
+}
+export interface Rebalance {
+    nonce: bigint;
     priceControl: PriceControl;
+    tokens: TokenRebalanceParams[];
+    limits: RebalanceLimits;
+    timestamps: RebalanceTimestamps;
 }
 export interface Folio {
     name: string;

package/package.json

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