@reserve-protocol/dtf-rebalance-lib 0.0.4 → 0.0.5

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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);

package/dist/numbers.d.ts

@@ -0,0 +1,11 @@
+import Decimal from 'decimal.js-light';
+export declare const D27n: bigint;
+export declare const D18n: bigint;
+export declare const D9n: bigint;
+export declare const D27d: Decimal;
+export declare const D18d: Decimal;
+export declare const D9d: Decimal;
+export declare const ZERO: Decimal;
+export declare const ONE: Decimal;
+export declare const TWO: Decimal;
+export declare const bn: (str: string | Decimal) => bigint;

package/dist/numbers.js

@@ -0,0 +1,20 @@
+"use strict";
+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.ZERO = exports.D9d = exports.D18d = exports.D27d = exports.D9n = exports.D18n = exports.D27n = void 0;
+const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+exports.D27n = 10n ** 27n;
+exports.D18n = 10n ** 18n;
+exports.D9n = 10n ** 9n;
+exports.D27d = new decimal_js_light_1.default('1e27');
+exports.D18d = new decimal_js_light_1.default('1e18');
+exports.D9d = new decimal_js_light_1.default('1e9');
+exports.ZERO = new decimal_js_light_1.default('0');
+exports.ONE = new decimal_js_light_1.default('1');
+exports.TWO = new decimal_js_light_1.default('2');
+const bn = (str) => {
+    return BigInt(new decimal_js_light_1.default(str).toFixed(0));
+};
+exports.bn = bn;

package/dist/open-auction.d.ts

@@ -0,0 +1,50 @@
+import { PriceRange, Rebalance, RebalanceLimits, WeightRange } from './types';
+export declare enum AuctionRound {
+    EJECT = 0,
+    PROGRESS = 1,
+    FINAL = 2
+}
+/**
+ * Useful metrics to use to visualize things
+ *
+ * @param initialProgression {1} The progression the Folio had when the auction was first proposed
+ * @param absoluteProgression {1} The progression of the auction on an absolute scale
+ * @param relativeProgression {1} The relative progression of the auction
+ * @param target {1} The target of the auction on an absolute scale
+ * @param auctionSize {USD} The total value on sale in the auction
+ * @param surplusTokens The list of tokens in surplus
+ * @param deficitTokens The list of tokens in deficit
+ */
+export interface AuctionMetrics {
+    round: AuctionRound;
+    initialProgression: number;
+    absoluteProgression: number;
+    relativeProgression: number;
+    target: number;
+    auctionSize: number;
+    surplusTokens: string[];
+    deficitTokens: string[];
+}
+export interface OpenAuctionArgs {
+    rebalanceNonce: bigint;
+    tokens: string[];
+    newWeights: WeightRange[];
+    newPrices: PriceRange[];
+    newLimits: RebalanceLimits;
+}
+/**
+ * Get the values needed to call `folio.openAuction()` as the AUCTION_LAUNCHER
+ *
+ * Non-AUCTION_LAUNCHERs should use `folio.openAuctionUnrestricted()`
+ *
+ * @param rebalance The result of calling folio.getRebalance()
+ * @param _supply {share} The totalSupply() of the basket, today
+ * @param _initialFolio D18{tok/share} Initial balances per share, e.g result of folio.toAssets(1e18, 0) at time rebalance was first proposed
+ * @param _targetBasket D18{1} Result of calling `getTargetBasket()`
+ * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0)
+ * @param _decimals Decimals of each token
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @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];

package/dist/open-auction.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenAuction = exports.AuctionRound = void 0;
+const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const numbers_1 = require("./numbers");
+const types_1 = require("./types");
+// Call `getOpenAuction()` to get the current auction round
+var AuctionRound;
+(function (AuctionRound) {
+    AuctionRound[AuctionRound["EJECT"] = 0] = "EJECT";
+    AuctionRound[AuctionRound["PROGRESS"] = 1] = "PROGRESS";
+    AuctionRound[AuctionRound["FINAL"] = 2] = "FINAL";
+})(AuctionRound || (exports.AuctionRound = AuctionRound = {}));
+/**
+ * Generator for the `targetBasket` parameter
+ *
+ * Depending on the usecase, pass either:
+ * - TRACKING: CURRENT prices
+ * - NATIVE: HISTORICAL prices
+ *
+ * @param _initialWeights D27{tok/BU} The initial historical weights emitted in the RebalanceStarted event
+ * @param _prices {USD/wholeTok} either CURRENT or HISTORICAL prices
+ * @returns D18{1} The target basket
+ */
+const getTargetBasket = (_initialWeights, _prices, _decimals) => {
+    if (_initialWeights.length != _prices.length) {
+        throw new Error('length mismatch');
+    }
+    const vals = _initialWeights.map((initialWeight, i) => {
+        const price = new decimal_js_light_1.default(_prices[i]);
+        const decimalScale = new decimal_js_light_1.default(`1e${_decimals[i]}`);
+        // {USD/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27 * {USD/wholeTok}
+        return new decimal_js_light_1.default(initialWeight.spot.toString())
+            .mul(numbers_1.D18d)
+            .div(decimalScale)
+            .div(numbers_1.D27d)
+            .mul(price);
+    });
+    const totalValue = vals.reduce((a, b) => a.add(b));
+    // D18{1} = {USD/wholeBU} / {USD/wholeBU} * D18
+    return vals.map((val) => (0, numbers_1.bn)(val.div(totalValue).mul(numbers_1.D18d)));
+};
+/**
+ * Get the values needed to call `folio.openAuction()` as the AUCTION_LAUNCHER
+ *
+ * Non-AUCTION_LAUNCHERs should use `folio.openAuctionUnrestricted()`
+ *
+ * @param rebalance The result of calling folio.getRebalance()
+ * @param _supply {share} The totalSupply() of the basket, today
+ * @param _initialFolio D18{tok/share} Initial balances per share, e.g result of folio.toAssets(1e18, 0) at time rebalance was first proposed
+ * @param _targetBasket D18{1} Result of calling `getTargetBasket()`
+ * @param _folio D18{tok/share} Current ratio of token per share, e.g result of folio.toAssets(1e18, 0)
+ * @param _decimals Decimals of each token
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @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) => {
+    if (rebalance.tokens.length != _targetBasket.length ||
+        _targetBasket.length != _folio.length ||
+        _folio.length != _decimals.length ||
+        _decimals.length != _prices.length ||
+        _prices.length != _priceError.length) {
+        throw new Error('length mismatch');
+    }
+    if (_finalStageAt >= 1) {
+        throw new Error('finalStageAt must be less than 1');
+    }
+    // ================================================================
+    // {wholeShare} = {share} / {share/wholeShare}
+    const supply = new decimal_js_light_1.default(_supply.toString()).div(numbers_1.D18d);
+    // {1} = D18{1} / D18
+    const targetBasket = _targetBasket.map((a) => new decimal_js_light_1.default(a.toString()).div(numbers_1.D18d));
+    // {USD/wholeTok}
+    const prices = _prices.map((a) => new decimal_js_light_1.default(a));
+    for (let i = 0; i < prices.length; i++) {
+        if (prices[i].eq(numbers_1.ZERO)) {
+            throw new Error(`missing price for token ${rebalance.tokens[i]}`);
+        }
+    }
+    // {1}
+    const priceError = _priceError.map((a) => new decimal_js_light_1.default(a.toString()));
+    // {tok/wholeTok}
+    const decimalScale = _decimals.map((a) => new decimal_js_light_1.default(`1e${a}`));
+    // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
+    const initialFolio = _initialFolio.map((c, i) => new decimal_js_light_1.default(c.toString()).div(decimalScale[i]));
+    // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
+    const folio = _folio.map((c, i) => new decimal_js_light_1.default(c.toString()).div(decimalScale[i]));
+    // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
+    let weightRanges = rebalance.weights.map((range, i) => {
+        return {
+            low: new decimal_js_light_1.default(range.low.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+            spot: new decimal_js_light_1.default(range.spot.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+            high: new decimal_js_light_1.default(range.high.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+        };
+    });
+    const finalStageAt = new decimal_js_light_1.default(_finalStageAt.toString());
+    // ================================================================
+    // calculate ideal spot limit, the actual BU<->share ratio
+    // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
+    const shareValue = folio
+        .map((f, i) => f.mul(prices[i]))
+        .reduce((a, b) => a.add(b));
+    // {USD/wholeBU} = {wholeTok/wholeBU} * {USD/wholeTok}
+    const buValue = weightRanges
+        .map((weightRange, i) => weightRange.spot.mul(prices[i]))
+        .reduce((a, b) => a.add(b));
+    // ================================================================
+    // calculate rebalanceTarget
+    const ejectionIndices = [];
+    for (let i = 0; i < rebalance.weights.length; i++) {
+        if (rebalance.weights[i].spot == 0n) {
+            ejectionIndices.push(i);
+        }
+    }
+    // {1} = {wholeTok/wholeShare} * {USD/wholeTok} / {USD/wholeShare}
+    const portionBeingEjected = ejectionIndices
+        .map((i) => folio[i].mul(prices[i]))
+        .reduce((a, b) => a.add(b), numbers_1.ZERO)
+        .div(shareValue);
+    // {1} = {USD/wholeShare} / {USD/wholeShare}
+    let progression = folio
+        .map((actualBalance, i) => {
+        // {wholeTok/wholeShare} = {USD/wholeShare} * {1} / {USD/wholeTok}
+        const balanceExpected = shareValue.mul(targetBasket[i]).div(prices[i]);
+        // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
+        const balanceInBU = balanceExpected.gt(actualBalance)
+            ? actualBalance
+            : balanceExpected;
+        // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
+        return balanceInBU.mul(prices[i]);
+    })
+        .reduce((a, b) => a.add(b))
+        .div(shareValue);
+    // {1} = {USD/wholeShare} / {USD/wholeShare}
+    const initialProgression = initialFolio
+        .map((initialBalance, i) => {
+        // {wholeTok/wholeShare} = {USD/wholeShare} * {1} / {USD/wholeTok}
+        const balanceExpected = shareValue.mul(targetBasket[i]).div(prices[i]);
+        // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
+        const balanceInBU = balanceExpected.gt(initialBalance)
+            ? initialBalance
+            : balanceExpected;
+        // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
+        return balanceInBU.mul(prices[i]);
+    })
+        .reduce((a, b) => a.add(b))
+        .div(shareValue);
+    if (progression < initialProgression) {
+        progression = initialProgression; // don't go backwards
+    }
+    // {1} = {1} / {1}
+    const relativeProgression = initialProgression.eq(numbers_1.ONE)
+        ? numbers_1.ONE
+        : progression.sub(initialProgression).div(numbers_1.ONE.sub(initialProgression));
+    let rebalanceTarget = numbers_1.ONE;
+    let round = 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.5)); // set rebalanceTarget to 50% more than needed, to ensure ejection completes
+        if (rebalanceTarget.gt(numbers_1.ONE)) {
+            rebalanceTarget = numbers_1.ONE;
+        }
+    }
+    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 = finalStageAt;
+    }
+    // {1}
+    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)),
+        spot: (0, numbers_1.bn)(spotLimit.mul(numbers_1.D18d)),
+        high: (0, numbers_1.bn)(spotLimit.add(spotLimit.mul(delta)).mul(numbers_1.D18d)),
+    };
+    // low
+    if (newLimits.low < rebalance.limits.low) {
+        newLimits.low = rebalance.limits.low;
+    }
+    if (newLimits.low > rebalance.limits.high) {
+        newLimits.low = rebalance.limits.high;
+    }
+    // spot
+    if (newLimits.spot < rebalance.limits.low) {
+        newLimits.spot = rebalance.limits.low;
+    }
+    if (newLimits.spot > rebalance.limits.high) {
+        newLimits.spot = rebalance.limits.high;
+    }
+    // high
+    if (newLimits.high < rebalance.limits.low) {
+        newLimits.high = rebalance.limits.low;
+    }
+    if (newLimits.high > rebalance.limits.high) {
+        newLimits.high = rebalance.limits.high;
+    }
+    // ================================================================
+    // get new weights, constrained by extremes
+    // {wholeBU/wholeShare} = D18{BU/share} / D18
+    const actualLimits = {
+        low: new decimal_js_light_1.default(newLimits.low.toString()).div(numbers_1.D18d),
+        spot: new decimal_js_light_1.default(newLimits.spot.toString()).div(numbers_1.D18d),
+        high: new decimal_js_light_1.default(newLimits.high.toString()).div(numbers_1.D18d),
+    };
+    // D27{tok/BU}
+    const newWeights = rebalance.weights.map((weightRange, 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}
+        const newWeightsD27 = {
+            low: (0, numbers_1.bn)(idealWeight
+                .mul(rebalanceTarget.div(actualLimits.low.div(actualLimits.spot))) // add remaining delta into weight
+                .mul(numbers_1.D27d)
+                .mul(decimalScale[i])
+                .div(numbers_1.D18d)),
+            spot: (0, numbers_1.bn)(idealWeight.mul(numbers_1.D27d).mul(decimalScale[i]).div(numbers_1.D18d)),
+            high: (0, numbers_1.bn)(idealWeight
+                .mul(numbers_1.ONE.add(delta).div(actualLimits.high.div(actualLimits.spot))) // add remaining delta into weight
+                .mul(numbers_1.D27d)
+                .mul(decimalScale[i])
+                .div(numbers_1.D18d)),
+        };
+        if (newWeightsD27.low < weightRange.low) {
+            newWeightsD27.low = weightRange.low;
+        }
+        else if (newWeightsD27.low > weightRange.high) {
+            newWeightsD27.low = weightRange.high;
+        }
+        if (newWeightsD27.spot < weightRange.low) {
+            newWeightsD27.spot = weightRange.low;
+        }
+        else if (newWeightsD27.spot > weightRange.high) {
+            newWeightsD27.spot = weightRange.high;
+        }
+        if (newWeightsD27.high < weightRange.low) {
+            newWeightsD27.high = weightRange.low;
+        }
+        else if (newWeightsD27.high > weightRange.high) {
+            newWeightsD27.high = weightRange.high;
+        }
+        return newWeightsD27;
+    });
+    // ================================================================
+    // get new prices, constrained by extremes
+    // D27{USD/tok}
+    const newPrices = rebalance.initialPrices.map((initialPrice, i) => {
+        // revert if price out of bounds
+        const spotPrice = (0, numbers_1.bn)(prices[i].mul(numbers_1.D27d).div(decimalScale[i]));
+        if (spotPrice < initialPrice.low || spotPrice > initialPrice.high) {
+            throw new Error('spot price out of bounds! auction launcher MUST closeRebalance to prevent loss!');
+        }
+        if (rebalance.priceControl == types_1.PriceControl.NONE) {
+            return initialPrice;
+        }
+        // D27{USD/tok} = {USD/wholeTok} * D27 / {tok/wholeTok}
+        const pricesD27 = {
+            low: (0, numbers_1.bn)(prices[i].mul(numbers_1.ONE.sub(priceError[i])).mul(numbers_1.D27d).div(decimalScale[i])),
+            high: (0, numbers_1.bn)(prices[i].div(numbers_1.ONE.sub(priceError[i])).mul(numbers_1.D27d).div(decimalScale[i])),
+        };
+        // low
+        if (pricesD27.low < initialPrice.low) {
+            pricesD27.low = initialPrice.low;
+        }
+        if (pricesD27.low > initialPrice.high) {
+            pricesD27.low = initialPrice.high;
+        }
+        // high
+        if (pricesD27.high < initialPrice.low) {
+            pricesD27.high = initialPrice.low;
+        }
+        if (pricesD27.high > initialPrice.high) {
+            pricesD27.high = initialPrice.high;
+        }
+        if (pricesD27.low == pricesD27.high) {
+            throw new Error('no price range');
+        }
+        return pricesD27;
+    });
+    // ================================================================
+    // calculate metrics
+    // {USD} = {1} * {USD/wholeShare} * {wholeShare}
+    const valueBeingTraded = rebalanceTarget
+        .sub(progression)
+        .mul(shareValue)
+        .mul(supply);
+    const surplusTokens = [];
+    const deficitTokens = [];
+    // update Decimal weightRanges
+    // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
+    weightRanges = newWeights.map((range, i) => {
+        return {
+            low: new decimal_js_light_1.default(range.low.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+            spot: new decimal_js_light_1.default(range.spot.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+            high: new decimal_js_light_1.default(range.high.toString())
+                .mul(numbers_1.D18d)
+                .div(decimalScale[i])
+                .div(numbers_1.D27d),
+        };
+    });
+    rebalance.tokens.forEach((token, i) => {
+        // {wholeTok/wholeShare} = {wholeTok/wholeBU} * {wholeBU/wholeShare}
+        const buyUpTo = weightRanges[i].low.mul(actualLimits.low);
+        const sellDownTo = weightRanges[i].high.mul(actualLimits.high);
+        if (folio[i].lt(buyUpTo)) {
+            deficitTokens.push(token);
+        }
+        else if (folio[i].gt(sellDownTo)) {
+            surplusTokens.push(token);
+        }
+    });
+    return [
+        {
+            rebalanceNonce: rebalance.nonce,
+            tokens: rebalance.tokens, // full set of tokens, not pruned to the active buy/sells
+            newWeights: newWeights,
+            newPrices: newPrices,
+            newLimits: newLimits,
+        },
+        {
+            round: round,
+            initialProgression: initialProgression.toNumber(),
+            absoluteProgression: progression.toNumber(),
+            relativeProgression: relativeProgression.toNumber(),
+            target: rebalanceTarget.toNumber(),
+            auctionSize: valueBeingTraded.toNumber(),
+            surplusTokens: surplusTokens,
+            deficitTokens: deficitTokens,
+        },
+    ];
+};
+exports.getOpenAuction = getOpenAuction;

package/dist/start-rebalance.d.ts

@@ -0,0 +1,21 @@
+import { PriceRange, RebalanceLimits, WeightRange } from './types';
+export interface StartRebalanceArgsPartial {
+    weights: WeightRange[];
+    prices: PriceRange[];
+    limits: RebalanceLimits;
+}
+/**
+ * Get the arguments needed to call startRebalance
+ *
+ * The `tokens` argument should be paired with the two return values and passed to `startRebalance()`
+ *
+ * @param _supply {share}
+ * @param tokens Addresses of tokens in the basket
+ * @param decimals Decimals of each token
+ * @param _targetBasket D18{1} Ideal basket
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @param _priceError {1} Price error per token to use in the rebalanc; should be larger than price error during openAuction
+ * @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;

package/dist/start-rebalance.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStartRebalance = void 0;
+const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const numbers_1 = require("./numbers");
+/**
+ * Get the arguments needed to call startRebalance
+ *
+ * The `tokens` argument should be paired with the two return values and passed to `startRebalance()`
+ *
+ * @param _supply {share}
+ * @param tokens Addresses of tokens in the basket
+ * @param decimals Decimals of each token
+ * @param _targetBasket D18{1} Ideal basket
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token
+ * @param _priceError {1} Price error per token to use in the rebalanc; should be larger than price error during openAuction
+ * @param _dtfPrice {USD/wholeShare} DTF price
+ * @param weightControl TRACKING=false, NATIVE=true
+ */
+const 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()));
+    for (let i = 0; i < prices.length; i++) {
+        if (prices[i].eq(numbers_1.ZERO)) {
+            throw new Error(`missing price for token ${tokens[i]}`);
+        }
+    }
+    // {USD/wholeShare}
+    const dtfPrice = new decimal_js_light_1.default(_dtfPrice);
+    // {1} = D18{1} / D18
+    const targetBasket = _targetBasket.map((a) => new decimal_js_light_1.default(a.toString()).div(numbers_1.D18d));
+    // {1}
+    const priceError = _priceError.map((a) => new decimal_js_light_1.default(a.toString()));
+    // ================================================================
+    const newWeights = [];
+    const newPrices = [];
+    const newLimits = {
+        low: (0, numbers_1.bn)('1e18'),
+        spot: (0, numbers_1.bn)('1e18'),
+        high: (0, numbers_1.bn)('1e18'),
+    };
+    // ================================================================
+    for (let i = 0; i < tokens.length; i++) {
+        if (priceError[i].gte(numbers_1.ONE)) {
+            throw new Error('cannot defer prices');
+        }
+        // === newWeights ===
+        // {wholeTok/wholeShare} = {1} * {USD/wholeShare} / {USD/wholeTok}
+        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 (!weightControl) {
+            // D27{tok/BU} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
+            newWeights.push({
+                low: (0, numbers_1.bn)(spotWeight.mul(limitMultiplier)),
+                spot: (0, numbers_1.bn)(spotWeight.mul(limitMultiplier)),
+                high: (0, numbers_1.bn)(spotWeight.mul(limitMultiplier)),
+            });
+        }
+        else {
+            // NATIVE case
+            // {wholeTok/wholeShare} = {wholeTok/wholeShare} / {1}
+            const lowWeight = spotWeight.mul(numbers_1.ONE.div(numbers_1.ONE.add(priceError[i])));
+            const highWeight = spotWeight.mul(numbers_1.ONE.add(priceError[i]));
+            // D27{tok/share} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
+            newWeights.push({
+                low: (0, numbers_1.bn)(lowWeight.mul(limitMultiplier)),
+                spot: (0, numbers_1.bn)(spotWeight.mul(limitMultiplier)),
+                high: (0, numbers_1.bn)(highWeight.mul(limitMultiplier)),
+            });
+        }
+        // === newPrices ===
+        // D27{wholeTok/tok} = D27 / {tok/wholeTok}
+        const priceMultiplier = numbers_1.D27d.div(new decimal_js_light_1.default(`1e${decimals[i]}`));
+        // {USD/wholeTok} = {USD/wholeTok} * {1}
+        const lowPrice = prices[i].mul(numbers_1.ONE.sub(priceError[i]));
+        const highPrice = prices[i].mul(numbers_1.ONE.add(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)),
+        });
+    }
+    // update low/high for tracking DTFs
+    if (!weightControl) {
+        // sum of dot product of targetBasket and priceError
+        const totalPortion = targetBasket
+            .map((portion, i) => portion.mul(priceError[i]))
+            .reduce((a, b) => a.add(b));
+        if (totalPortion.gte(numbers_1.ONE)) {
+            throw new Error('totalPortion > 1');
+        }
+        // D18{BU/share} = {1} * D18 * {BU/share}
+        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));
+    }
+    return {
+        weights: newWeights,
+        prices: newPrices,
+        limits: newLimits,
+    };
+};
+exports.getStartRebalance = getStartRebalance;

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+export declare enum PriceControl {
+    NONE = 0,
+    PARTIAL = 1,
+    ATOMIC_SWAP = 2
+}
+export interface RebalanceLimits {
+    low: bigint;
+    spot: bigint;
+    high: bigint;
+}
+export interface WeightRange {
+    low: bigint;
+    spot: bigint;
+    high: bigint;
+}
+export interface PriceRange {
+    low: bigint;
+    high: bigint;
+}
+export interface Rebalance {
+    nonce: bigint;
+    tokens: string[];
+    weights: WeightRange[];
+    initialPrices: PriceRange[];
+    inRebalance: boolean[];
+    limits: RebalanceLimits;
+    startedAt: bigint;
+    restrictedUntil: bigint;
+    availableUntil: bigint;
+    priceControl: PriceControl;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceControl = void 0;
+var PriceControl;
+(function (PriceControl) {
+    PriceControl[PriceControl["NONE"] = 0] = "NONE";
+    PriceControl[PriceControl["PARTIAL"] = 1] = "PARTIAL";
+    PriceControl[PriceControl["ATOMIC_SWAP"] = 2] = "ATOMIC_SWAP";
+})(PriceControl || (exports.PriceControl = PriceControl = {}));

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This function can be used to get a basket distribution EITHER from a set of historical basket weights
+ * or from a set of current balances. Make sure to use prices from the right time.
+ *
+ * @param _bals {tok} Current balances; or previous historical weights
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token; or previous historical prices
+ * @param decimals Decimals of each token
+ * @returns D18{1} Current basket, total will be around 1e18 but not exactly
+ */
+export declare const getBasketDistribution: (_bals: bigint[], _prices: number[], decimals: bigint[]) => bigint[];

package/dist/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBasketDistribution = void 0;
+const decimal_js_light_1 = __importDefault(require("decimal.js-light"));
+const numbers_1 = require("./numbers");
+/**
+ * This function can be used to get a basket distribution EITHER from a set of historical basket weights
+ * or from a set of current balances. Make sure to use prices from the right time.
+ *
+ * @param _bals {tok} Current balances; or previous historical weights
+ * @param _prices {USD/wholeTok} USD prices for each *whole* token; or previous historical prices
+ * @param decimals Decimals of each token
+ * @returns D18{1} Current basket, total will be around 1e18 but not exactly
+ */
+const getBasketDistribution = (_bals, _prices, decimals) => {
+    const decimalScale = decimals.map((d) => new decimal_js_light_1.default(`1e${d}`));
+    // {wholeTok} = {tok} / {tok/wholeTok}
+    const bals = _bals.map((bal, i) => new decimal_js_light_1.default(bal.toString()).div(decimalScale[i]));
+    // {USD/wholeTok} = {USD/wholeTok}
+    const prices = _prices.map((a) => new decimal_js_light_1.default(a.toString()));
+    // {USD} = {wholeTok} * {USD/wholeTok}
+    const totalValue = bals
+        .map((bal, i) => bal.mul(prices[i]))
+        .reduce((a, b) => a.add(b));
+    // D18{1} = {wholeTok} * {USD/wholeTok} / {USD}
+    return bals.map((bal, i) => (0, numbers_1.bn)(bal.mul(prices[i]).div(totalValue).mul(numbers_1.D18d)));
+};
+exports.getBasketDistribution = getBasketDistribution;

package/package.json

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