@reserve-protocol/dtf-rebalance-lib 0.1.0 → 0.1.2

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@reserve-protocol/dtf-rebalance-lib",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Rebalancing library for DTFs in typescript",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "src",
     "LICENSE.md",
     "README.md"
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && tsc",
+    "compile": "hardhat compile",
+    "build": "npm run clean && tsc --project tsconfig.build.json",
     "prepublishOnly": "npm run build",
-    "test": "tsc --project tsconfig.test.json && node --test dist/test/*.test.js"
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "node --test --require ts-node/register test/unit/*.test.ts",
+    "test:e2e": "hardhat test --bail"
   },
   "publishConfig": {
     "access": "public"
@@ -39,6 +41,14 @@
     "decimal.js-light": "^2.5.1"
   },
   "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@openzeppelin/contracts": "^5.3.0",
+    "@reserve-protocol/reserve-index-dtf": "github:reserve-protocol/reserve-index-dtf#a240822d7a02520def5564668ac7699b0520bdae",
+    "@types/node": "^20.0.0",
+    "dotenv": "^16.5.0",
+    "hardhat": "^2.24.1",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   }
 }

package/src/index.ts

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

package/src/numbers.ts

@@ -1,17 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-export const D27n: bigint = 10n ** 27n
-export const D18n: bigint = 10n ** 18n
-export const D9n: bigint = 10n ** 9n
-
-export const D27d: Decimal = new Decimal('1e27')
-export const D18d: Decimal = new Decimal('1e18')
-export const D9d: Decimal = new Decimal('1e9')
-
-export const ZERO = new Decimal('0')
-export const ONE = new Decimal('1')
-export const TWO = new Decimal('2')
-
-export const bn = (str: string | Decimal): bigint => {
-  return BigInt(new Decimal(str).toFixed(0))
-}

package/src/open-auction.ts

@@ -1,557 +0,0 @@
-import Decimal from 'decimal.js-light'
-
-import { bn, D18d, D27d, ONE, ZERO } from './numbers'
-
-import {
-  PriceControl,
-  PriceRange,
-  Rebalance,
-  RebalanceLimits,
-  WeightRange,
-} from './types'
-
-// Call `getOpenAuction()` to get the current auction round
-export 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[]
-}
-
-// All the args needed to call `folio.openAuction()`
-export interface OpenAuctionArgs {
-  rebalanceNonce: bigint
-  tokens: string[]
-  newWeights: WeightRange[]
-  newPrices: PriceRange[]
-  newLimits: RebalanceLimits
-}
-
-/**
- * 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
- */
-export const getTargetBasket = (
-  _initialWeights: WeightRange[],
-  _prices: number[],
-  _decimals: bigint[]
-): bigint[] => {
-  if (_initialWeights.length != _prices.length) {
-    throw new Error('length mismatch')
-  }
-
-  const vals = _initialWeights.map((initialWeight: WeightRange, i: number) => {
-    const price = new Decimal(_prices[i])
-    const decimalScale = new Decimal(`1e${_decimals[i]}`)
-
-    // {USD/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27 * {USD/wholeTok}
-    return new Decimal(initialWeight.spot.toString())
-      .mul(D18d)
-      .div(decimalScale)
-      .div(D27d)
-      .mul(price)
-  })
-
-  const totalValue = vals.reduce((a, b) => a.add(b))
-
-  // D18{1} = {USD/wholeBU} / {USD/wholeBU} * D18
-  return vals.map((val) => bn(val.div(totalValue).mul(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
- */
-export const getOpenAuction = (
-  rebalance: Rebalance,
-  _supply: bigint,
-  _initialFolio: bigint[] = [],
-  _targetBasket: bigint[] = [],
-  _folio: bigint[],
-  _decimals: bigint[],
-  _prices: number[],
-  _priceError: number[],
-  _finalStageAt: number,
-  logging?: boolean
-): [OpenAuctionArgs, AuctionMetrics] => {
-  if (logging) {
-    console.log('getOpenAuction', rebalance, _supply, _initialFolio, _targetBasket, _folio, _decimals, _prices, _priceError, _finalStageAt)
-  }
-
-  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(_supply.toString()).div(D18d)
-
-  // {1} = D18{1} / D18
-  const targetBasket = _targetBasket.map((a) =>
-    new Decimal(a.toString()).div(D18d)
-  )
-
-  // {USD/wholeTok}
-  const prices = _prices.map((a) => new Decimal(a))
-  for (let i = 0; i < prices.length; i++) {
-    if (prices[i].eq(ZERO)) {
-      throw new Error(`missing price for token ${rebalance.tokens[i]}`)
-    }
-  }
-
-  // {1}
-  const priceError = _priceError.map((a) => new Decimal(a.toString()))
-
-  // {tok/wholeTok}
-  const decimalScale = _decimals.map((a) => new Decimal(`1e${a}`))
-
-  // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-  const initialFolio = _initialFolio.map((c: bigint, i: number) =>
-    new Decimal(c.toString()).div(decimalScale[i])
-  )
-
-  // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-  const folio = _folio.map((c: bigint, i: number) =>
-    new Decimal(c.toString()).div(decimalScale[i])
-  )
-
-  // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
-  let weightRanges = rebalance.weights.map((range: WeightRange, i: number) => {
-    return {
-      low: new Decimal(range.low.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(D27d),
-      spot: new Decimal(range.spot.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(D27d),
-      high: new Decimal(range.high.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(D27d),
-    }
-  })
-
-  const finalStageAt = new Decimal(_finalStageAt.toString())
-
-
-  // ================================================================
-
-  // calculate ideal spot limit, the actual BU<->share ratio
-
-  // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
-  const shareValue = folio
-    .map((f: Decimal, i: number) => 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))
-
-  if (logging) {
-    console.log('shareValue', shareValue.toString())
-    console.log('buValue', buValue.toString())
-  }
-
-  // ================================================================
-
-  // calculate rebalanceTarget
-
-  const ejectionIndices: number[] = []
-  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), 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(ONE)
-  ? ONE
-  : progression.sub(initialProgression).div(ONE.sub(initialProgression))
-  
-  let rebalanceTarget = ONE
-  let round: AuctionRound = AuctionRound.FINAL
-
-  if (logging) {
-    console.log('initialProgression', initialProgression.toString())
-    console.log('progression', progression.toString())
-    console.log('relativeProgression', relativeProgression.toString())
-    console.log('portionBeingEjected', portionBeingEjected.toString())
-    console.log('finalStageAt', finalStageAt.toString())
-  }
-  
-  // make it an eject auction if there is 1 bps or more of value to eject
-  if (portionBeingEjected.gte(1e-4)) {
-    round = AuctionRound.EJECT
-
-    if (relativeProgression.lt(finalStageAt.sub(0.02))) {
-      rebalanceTarget = progression.add(portionBeingEjected.mul(1.1)) // set rebalanceTarget to 10% more than needed to ensure ejection completes
-      
-      // do not finish trading yet
-      if (rebalanceTarget.gte(ONE)) {
-        rebalanceTarget = initialProgression.add(ONE.sub(initialProgression).mul(finalStageAt))
-      } 
-    }
-  } 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 = initialProgression.add(ONE.sub(initialProgression).mul(finalStageAt))
-      if (rebalanceTarget.eq(ONE)) {
-        round = AuctionRound.FINAL
-      }
-  }
-
-  if (rebalanceTarget.gt(ONE)) {
-    throw new Error('something has gone very wrong')
-  }
-  
-  if (rebalanceTarget.lt(progression)) {
-      rebalanceTarget = ONE
-  }
-
-  if (logging) {
-    console.log('rebalanceTarget', rebalanceTarget.toString())
-  }
-
-  // {1}
-  const delta = 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: bn(spotLimit.sub(spotLimit.mul(delta)).mul(D18d)),
-    spot: bn(spotLimit.mul(D18d)),
-    high: bn(spotLimit.add(spotLimit.mul(delta)).mul(D18d)),
-  }
-
-  if (round == AuctionRound.EJECT && rebalanceTarget.eq(ONE)) {
-    // aim 1% higher if executed permissonlessly
-    newLimits.spot += newLimits.spot * 1n / 100n
-    
-    // leave 10% room to increase low in the future if ejection leaves dust behind
-    newLimits.high += newLimits.high * 10n / 100n
-  }
-
-  // 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
-  }
-
-  if (logging) {
-    console.log('newLimits', newLimits)
-  }
-
-  // ================================================================
-
-  // get new weights, constrained by extremes
-
-  // {wholeBU/wholeShare} = D18{BU/share} / D18
-  const actualLimits = {
-    low: new Decimal(newLimits.low.toString()).div(D18d),
-    spot: new Decimal(newLimits.spot.toString()).div(D18d),
-    high: new Decimal(newLimits.high.toString()).div(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: bn(
-        idealWeight
-          .mul(rebalanceTarget.div(actualLimits.low.div(actualLimits.spot))) // add remaining delta into weight
-          .mul(D27d)
-          .mul(decimalScale[i])
-          .div(D18d)
-      ),
-      spot: bn(idealWeight.mul(D27d).mul(decimalScale[i]).div(D18d)),
-      high: bn(
-        idealWeight
-          .mul(ONE.add(delta).div(actualLimits.high.div(actualLimits.spot))) // add remaining delta into weight
-          .mul(D27d)
-          .mul(decimalScale[i])
-          .div(D18d)
-      ),
-    }
-
-    if (round == AuctionRound.EJECT && rebalanceTarget.eq(ONE)) {
-      // aim 1% higher if executed permissonlessly
-      newWeightsD27.spot += newWeightsD27.spot * 1n / 100n
-      
-      // leave 10% room to increase low in the future if ejection leaves dust behind
-      newWeightsD27.high += newWeightsD27.high * 10n / 100n
-    }
-
-    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
-  })
-
-  if (logging) {
-    console.log('newWeights', newWeights)
-  }
-
-  // ================================================================
-
-  // get new prices, constrained by extremes
-
-  
-  // D27{USD/tok}
-  const newPrices = rebalance.initialPrices.map((initialPrice, i) => {
-    // revert if price out of bounds
-    const spotPrice = bn(prices[i].mul(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 == PriceControl.NONE) {
-      return initialPrice
-    }
-
-    // D27{USD/tok} = {USD/wholeTok} * D27 / {tok/wholeTok}
-    const pricesD27 = {
-      low: bn(
-        prices[i].mul(ONE.sub(priceError[i])).mul(D27d).div(decimalScale[i])
-      ),
-      high: bn(
-        prices[i].div(ONE.sub(priceError[i])).mul(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 && priceError[i].gt(ZERO)) {
-      throw new Error('no price range')
-    }
-
-    return pricesD27
-  })
-
-  if (logging) {
-    console.log('newPrices', newPrices)
-  }
-
-  // ================================================================
-
-  // calculate metrics
-
-  // {USD} = {1} * {USD/wholeShare} * {wholeShare}
-  const valueBeingTraded = rebalanceTarget
-    .sub(progression)
-    .mul(shareValue)
-    .mul(supply)
-
-  const surplusTokens: string[] = []
-  const deficitTokens: string[] = []
-
-  // update Decimal weightRanges
-  // {wholeTok/wholeBU} = D27{tok/BU} * {BU/wholeBU} / {tok/wholeTok} / D27
-  weightRanges = newWeights.map((range, i) => {
-    return {
-      low: new Decimal(range.low.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(D27d),
-      spot: new Decimal(range.spot.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(D27d),
-      high: new Decimal(range.high.toString())
-        .mul(D18d)
-        .div(decimalScale[i])
-        .div(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,
-    },
-  ]
-}

package/src/start-rebalance.ts

@@ -1,170 +0,0 @@
-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 _folio D18{tok/share} Folio of 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[],
-  _folio: bigint[],
-  decimals: bigint[],
-  _targetBasket: bigint[],
-  _prices: number[],
-  _priceError: number[],
-  weightControl: boolean,
-  logging?: boolean
-): StartRebalanceArgsPartial => {
-  if (logging) {
-    console.log('getStartRebalance', _supply, tokens, _folio, decimals, _targetBasket, _prices, _priceError,  weightControl)
-  }
-
-  // {wholeTok/wholeShare} = D18{tok/share} * {share/wholeShare} / {tok/wholeTok} / D18
-  const folio = _folio.map((c: bigint, i: number) =>
-    new Decimal(c.toString()).div(new Decimal(`1e${decimals[i]}`))
-  )
-
-  // 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]}`)
-    }
-  }
-
-  // {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 ===
-
-    // {USD/wholeShare} = {wholeTok/wholeShare} * {USD/wholeTok}
-    const dtfPrice = folio.map((f: Decimal, i: number) => f.mul(prices[i])).reduce((a: Decimal, b: Decimal) => a.add(b))
-
-    // {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 (logging) {
-      console.log('limitMultiplier', limitMultiplier.toString())
-    }
-
-    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))
-  }
-  
-  if (logging) {
-    console.log("newWeights", newWeights)
-    console.log('newPrices', newPrices)
-    console.log('newLimits', newLimits)
-  }
-
-  return {
-    weights: newWeights,
-    prices: newPrices,
-    limits: newLimits,
-  }
-}

package/src/types.ts

@@ -1,35 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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)))
-}