@reserve-protocol/dtf-rebalance-lib 0.0.1

package/src/start-rebalance.ts

@@ -0,0 +1,150 @@
+import Decimal from 'decimal.js-light'
+
+import { bn, D18d, D27d, ONE, ZERO } from './numbers'
+
+import { PriceRange, RebalanceLimits, WeightRange } from './types'
+
+// Partial set of the args needed to call `startRebalance()`
+export interface StartRebalanceArgsPartial {
+  // tokens: string[]
+  weights: WeightRange[]
+  prices: PriceRange[]
+  limits: RebalanceLimits
+  // auctionLauncherWindow: bigint
+  // ttl: bigint
+}
+
+/**
+ * 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 const getStartRebalance = (
+  _supply: bigint,
+  tokens: string[],
+  decimals: bigint[],
+  _targetBasket: bigint[],
+  _prices: number[],
+  _priceError: number[],
+  _dtfPrice: number,
+  weightControl: boolean
+): StartRebalanceArgsPartial => {
+  // convert price number inputs to bigints
+
+  // {USD/wholeTok}
+  const prices = _prices.map((a) => new Decimal(a.toString()))
+  for (let i = 0; i < prices.length; i++) {
+    if (prices[i].eq(ZERO)) {
+      throw new Error(`missing price for token ${tokens[i]}`)
+    }
+  }
+
+  // {USD/wholeShare}
+  const dtfPrice = new Decimal(_dtfPrice)
+
+  // {1} = D18{1} / D18
+  const targetBasket = _targetBasket.map((a) =>
+    new Decimal(a.toString()).div(D18d)
+  )
+
+  // {1}
+  const priceError = _priceError.map((a) => new Decimal(a.toString()))
+
+  // ================================================================
+
+  const newWeights: WeightRange[] = []
+  const newPrices: PriceRange[] = []
+  const newLimits: RebalanceLimits = {
+    low: bn('1e18'),
+    spot: bn('1e18'),
+    high: bn('1e18'),
+  }
+
+  // ================================================================
+
+  for (let i = 0; i < tokens.length; i++) {
+    if (priceError[i].gte(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 = D27d.mul(new Decimal(`1e${decimals[i]}`)).div(D18d)
+
+    if (!weightControl) {
+      // D27{tok/BU} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
+      newWeights.push({
+        low: bn(spotWeight.mul(limitMultiplier)),
+        spot: bn(spotWeight.mul(limitMultiplier)),
+        high: bn(spotWeight.mul(limitMultiplier)),
+      })
+    } else {
+      // NATIVE case
+
+      // {wholeTok/wholeShare} = {wholeTok/wholeShare} / {1}
+      const lowWeight = spotWeight.mul(ONE.div(ONE.add(priceError[i])))
+      const highWeight = spotWeight.mul(ONE.add(priceError[i]))
+
+
+      // D27{tok/share} = {wholeTok/wholeShare} * D27{tok/share}{wholeShare/wholeTok} / {BU/share}
+      newWeights.push({
+        low: bn(lowWeight.mul(limitMultiplier)),
+        spot: bn(spotWeight.mul(limitMultiplier)),
+        high: bn(highWeight.mul(limitMultiplier)),
+      })
+    }
+
+    // === newPrices ===
+
+    // D27{wholeTok/tok} = D27 / {tok/wholeTok}
+    const priceMultiplier = D27d.div(new Decimal(`1e${decimals[i]}`))
+
+    // {USD/wholeTok} = {USD/wholeTok} * {1}
+    const lowPrice = prices[i].mul(ONE.sub(priceError[i]))
+    const highPrice = prices[i].mul(ONE.add(priceError[i]))
+
+
+    // D27{USD/tok} = {USD/wholeTok} * D27{wholeTok/tok}
+    newPrices.push({
+      low: bn(lowPrice.mul(priceMultiplier)),
+      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))
+
+    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))
+  }
+
+  return {
+    weights: newWeights,
+    prices: newPrices,
+    limits: newLimits,
+  }
+}

package/src/types.ts

@@ -0,0 +1,35 @@
+export enum PriceControl {
+  NONE = 0,
+  PARTIAL = 1,
+  ATOMIC_SWAP = 2,
+}
+
+export interface RebalanceLimits {
+  low: bigint // D18{BU/share}
+  spot: bigint // D18{BU/share}
+  high: bigint // D18{BU/share}
+}
+
+export interface WeightRange {
+  low: bigint // D27{tok/BU}
+  spot: bigint // D27{tok/BU}
+  high: bigint // D27{tok/BU}
+}
+
+export interface PriceRange {
+  low: bigint // D27{USD/tok}
+  high: bigint // D27{USD/tok}
+}
+
+export interface Rebalance {
+  nonce: bigint
+  tokens: string[]
+  weights: WeightRange[]
+  initialPrices: PriceRange[]
+  inRebalance: boolean[]
+  limits: RebalanceLimits
+  startedAt: bigint
+  restrictedUntil: bigint
+  availableUntil: bigint
+  priceControl: PriceControl
+}

package/src/utils.ts

@@ -0,0 +1,36 @@
+import Decimal from 'decimal.js-light'
+
+import { bn, D18d } from './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
+ */
+export const getBasketDistribution = (
+  _bals: bigint[],
+  _prices: number[],
+  decimals: bigint[]
+): bigint[] => {
+  const decimalScale = decimals.map((d) => new Decimal(`1e${d}`))
+
+  // {wholeTok} = {tok} / {tok/wholeTok}
+  const bals = _bals.map((bal, i) =>
+    new Decimal(bal.toString()).div(decimalScale[i])
+  )
+
+  // {USD/wholeTok} = {USD/wholeTok}
+  const prices = _prices.map((a) => new Decimal(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) => bn(bal.mul(prices[i]).div(totalValue).mul(D18d)))
+}