@reserve-protocol/dtf-rebalance-lib 0.0.1 → 0.0.3

package/test/rebalancing.test.ts

@@ -1,1448 +0,0 @@
-import { bn } from '../src/numbers'
-import {
-  PriceControl,
-  PriceRange,
-  RebalanceLimits,
-  Rebalance,
-  WeightRange,
-} from '../src/types'
-import { getBasketDistribution } from '../src/utils'
-import { OpenAuctionArgs, getOpenAuction } from '../src/open-auction'
-import { getStartRebalance } from '../src/start-rebalance'
-import { describe, it, beforeEach } from 'node:test'
-import { strict as assert } from 'node:assert'
-
-const PRECISION = bn('1e3') // 1-part-in-1000
-
-const assertApproxEq = (
-  a: bigint,
-  b: bigint,
-  precision: bigint = PRECISION
-) => {
-  const delta = a > b ? a - b : b - a
-  // console.log('assertApproxEq', a.toString(), b.toString()) // Keep for debugging if necessary
-  assert(a >= b / precision, `Expected ${a} to be >= ${b / precision}`) // Ensure a is not far below b
-  assert(delta <= b / precision, `Expected delta ${delta} to be <= ${b / precision}`) // Ensure difference is small relative to b
-  // A more robust check might be delta <= max(abs(a), abs(b)) / precision, or handle b=0
-  if (b !== 0n) {
-    assert(delta <= (a > b ? a : b) / precision, `Expected delta ${delta} to be <= ${(a > b ? a : b) / precision}`) // Compare delta to the larger of a or b
-  } else {
-    assert(delta <= precision, `Expected delta ${delta} to be <= ${precision}`) // If b is 0, delta must be small
-  }
-}
-
-const assertRangesEqual = (a: WeightRange, b: WeightRange) => {
-  assertApproxEq(a.low, b.low)
-  assertApproxEq(a.spot, b.spot)
-  assertApproxEq(a.high, b.high)
-}
-
-const assertPricesEqual = (a: PriceRange, b: PriceRange) => {
-  assertApproxEq(a.low, b.low)
-  assertApproxEq(a.high, b.high)
-}
-
-const assertRebalanceLimitsEqual = (
-  a: RebalanceLimits,
-  b: RebalanceLimits,
-  precision: bigint = PRECISION
-) => {
-  assertApproxEq(a.low, b.low, precision)
-  assertApproxEq(a.spot, b.spot, precision)
-  assertApproxEq(a.high, b.high, precision)
-}
-
-const assertOpenAuctionArgsEqual = (
-  a: OpenAuctionArgs,
-  b: OpenAuctionArgs,
-  precision: bigint = PRECISION
-) => {
-  assert.equal(a.rebalanceNonce, b.rebalanceNonce)
-  assert.deepEqual(a.tokens, b.tokens)
-
-  assert.equal(a.newWeights.length, b.newWeights.length)
-  for (let i = 0; i < a.newWeights.length; i++) {
-    assertRangesEqual(a.newWeights[i], b.newWeights[i])
-  }
-
-  assert.equal(a.newPrices.length, b.newPrices.length)
-  for (let i = 0; i < a.newPrices.length; i++) {
-    // assertPricesEqual uses its own default precision, which is fine.
-    assertPricesEqual(a.newPrices[i], b.newPrices[i])
-  }
-
-  assertRebalanceLimitsEqual(a.newLimits, b.newLimits, precision)
-}
-
-describe('NATIVE DTFs', () => {
-  const supply = bn('1e21') // 1000 supply
-  const auctionPriceError = [0.01, 0.01, 0.01] // Smaller price error for getOpenAuction
-  const finalStageAtForTest = 0.95 // Standard finalStageAt
-
-  // Common expected prices for tokens [USDC (6dec), DAI (18dec), USDT (6dec)]
-  // when market prices are [1,1,1], auctionPriceError is [0.01,0.01,0.01], and priceControl=true,
-  // and initialPrices allow this range.
-  const defaultExpectedPrices_USDC_DAI_USDT: PriceRange[] = [
-    { low: bn('9.9e20'), high: bn('1.01e21') }, // USDC (D27 from $1, 6dec)
-    { low: bn('9.9e8'), high: bn('1.01e9') }, // DAI (D27 from $1, 18dec)
-    { low: bn('9.9e20'), high: bn('1.01e21') }, // USDT (D27 from $1, 6dec)
-  ]
-
-  describe('Rebalancing from 100% USDC to 0% USDC, 50% DAI, 50% USDT', () => {
-    const tokens = ['USDC', 'DAI', 'USDT']
-    const decimalsS1 = [bn('6'), bn('18'), bn('6')]
-    const initialMarketPricesS1 = [1, 1, 1]
-    const priceErrorStartRebalanceS1 = [0.1, 0.1, 0.1]
-    const dtfPriceS1 = 1
-    const initialFolioS1 = [bn('1e6'), bn('0'), bn('0')] // Represents 1 USDC, 0 DAI, 0 USDT per share (approx value)
-    const targetBasketS1 = [bn('0'), bn('0.5e18'), bn('0.5e18')]
-    // Folio representing mid-progress for ejection tests: ~20% USDC, ~40% DAI, ~40% USDT by value
-    const folioMidProgressS1 = [bn('0.2e6'), bn('0.4e18'), bn('0.4e6')]
-    // Folio representing near completion for ejection tests: ~1% USDC, ~49.5% DAI, ~49.5% USDT by value
-    const folioNearCompletionS1 = [bn('0.01e6'), bn('0.495e18'), bn('0.495e6')]
-    // Folio for Step 6 (negligible ejection, high relative progression): USDC almost gone, DAI/USDT balanced
-    const folioTrueMidS1_ActuallyHighProg = [
-      bn('0.00001e6'),
-      bn('0.2e18'),
-      bn('0.2e6'),
-    ]
-    // Folio for Step 7: shareValue ~1.0. USDC negligible. DAI 0.8 val, USDT 0.2 val.
-    // InitialProg=0. Progression for this folio = (min(0.8,0.5)+min(0.2,0.5))/1.0 = (0.5+0.2)/1.0 = 0.7.
-    // relativeProgression = 0.7 < 0.93 -> delta=0.05.
-    const folioStep7S1_varied_weights = [
-      bn('0.00001e6'),
-      bn('0.8e18'),
-      bn('0.2e6'),
-    ]
-
-    let mockRebalanceBaseS1: Omit<Rebalance, 'priceControl'>
-    let initialWeightsS1: WeightRange[],
-      initialPricesS1: PriceRange[],
-      initialLimitsS1: RebalanceLimits
-
-    beforeEach(() => {
-      const { weights, prices, limits } = getStartRebalance(
-        supply,
-        tokens,
-        decimalsS1,
-        targetBasketS1,
-        initialMarketPricesS1,
-        priceErrorStartRebalanceS1,
-        dtfPriceS1,
-        true // weightControl: true for NATIVE-style
-      )
-      initialWeightsS1 = weights
-      initialPricesS1 = prices
-      initialLimitsS1 = limits
-      mockRebalanceBaseS1 = {
-        nonce: 1n,
-        tokens: tokens,
-        weights: initialWeightsS1, // These are the NATIVE rebalance.weights used for clamping
-        initialPrices: initialPricesS1,
-        inRebalance: tokens.map(() => true),
-        limits: initialLimitsS1, // NATIVE limits are {1e18, 1e18, 1e18}, crucial for newLimits clamping
-        startedAt: 0n,
-        restrictedUntil: 0n,
-        availableUntil: 0n,
-      }
-    })
-
-    it('Step 0: Verifies initial setup from getStartRebalance', () => {
-      assert.equal(initialWeightsS1.length, 3)
-      assert.equal(initialPricesS1.length, 3)
-      assertRangesEqual(initialWeightsS1[0], {
-        low: bn('0'),
-        spot: bn('0'),
-        high: bn('0'),
-      }) // USDC
-      assertRangesEqual(initialWeightsS1[1], {
-        low: bn('454545454545454545454545455'), // 0.5 / 1.1 * 1e27
-        spot: bn('500000000000000000000000000'), // 0.5 * 1e27
-        high: bn('550000000000000000000000000'), // 0.5 * 1.1 * 1e27
-      }) // DAI
-      assertRangesEqual(initialWeightsS1[2], {
-        low: bn('454545454545455'), // 0.5 / 1.1 * 1e15
-        spot: bn('500000000000000'), // 0.5 * 1e15
-        high: bn('550000000000000'), // 0.5 * 1.1 * 1e15
-      }) // USDT
-      assertRebalanceLimitsEqual(initialLimitsS1, {
-        low: bn('1e18'),
-        spot: bn('1e18'),
-        high: bn('1e18'),
-      })
-    })
-
-    it('Step 1: Ejection Phase (initial folio, priceControl=true, prices=[1,1,1])', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        initialFolioS1,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0],
-          {
-            low: initialWeightsS1[1].spot,
-            spot: initialWeightsS1[1].spot,
-            high: initialWeightsS1[1].spot,
-          },
-          {
-            low: initialWeightsS1[2].spot,
-            spot: initialWeightsS1[2].spot,
-            high: initialWeightsS1[2].spot,
-          },
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 2: Ejection Phase (mid-progress folio with USDC to eject)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        folioMidProgressS1,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0],
-          {
-            low: initialWeightsS1[1].spot,
-            spot: initialWeightsS1[1].spot,
-            high: initialWeightsS1[1].spot,
-          },
-          {
-            low: initialWeightsS1[2].spot,
-            spot: initialWeightsS1[2].spot,
-            high: initialWeightsS1[2].spot,
-          },
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 3: Ejection Phase (near-completion folio with USDC to eject)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        folioNearCompletionS1,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0],
-          {
-            low: initialWeightsS1[1].spot,
-            spot: initialWeightsS1[1].spot,
-            high: initialWeightsS1[1].spot,
-          },
-          {
-            low: initialWeightsS1[2].spot,
-            spot: initialWeightsS1[2].spot,
-            high: initialWeightsS1[2].spot,
-          },
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 4: Ejection Phase (initial folio, priceControl=false, prices=[1,1,1])', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.NONE,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        initialFolioS1,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0],
-          {
-            low: initialWeightsS1[1].spot,
-            spot: initialWeightsS1[1].spot,
-            high: initialWeightsS1[1].spot,
-          },
-          {
-            low: initialWeightsS1[2].spot,
-            spot: initialWeightsS1[2].spot,
-            high: initialWeightsS1[2].spot,
-          },
-        ],
-        newPrices: initialPricesS1, // from mockRebalance due to priceControl=false
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 5: Ejection Phase (initial folio, USDC Price Loss 0.9, priceControl=true)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const pricesS1_loss = [0.9, 1, 1]
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        initialFolioS1,
-        decimalsS1,
-        pricesS1_loss,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      const expectedNewPricesLoss: PriceRange[] = [
-        { low: bn('9e20'), high: bn('9.09e20') },
-        { low: bn('9.9e8'), high: bn('1.01e9') },
-        { low: bn('9.9e20'), high: bn('1.01e21') },
-      ]
-      // Ideal spots for DAI/USDT scaled by 0.9 (due to USDC price drop impacting shareValue for idealWeight calc)
-      // DAI idealSpot was 5e26, now 5e26*0.9 = 4.5e26. USDT idealSpot was 5e14, now 5e14*0.9 = 4.5e14.
-      // Delta is 0 (ejection). So newWeights low/spot/high are these new ideal spots, clamped by rebalance.weights.
-      // The new ideal spots (4.5e26, 4.5e14) are exactly the .low of their respective rebalance.weights, so clamping to .low results in this value.
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0], // USDC target 0
-          { low: bn('454545454545454545454545455'), spot: bn('454545454545454545454545455'), high: bn('454545454545454545454545455') },
-          { low: bn('454545454545455'), spot: bn('454545454545455'), high: bn('454545454545455') },
-        ],
-        newPrices: expectedNewPricesLoss,
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 6: Test Case: Negligible Ejection, High Relative Progression -> Delta=0', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        folioTrueMidS1_ActuallyHighProg,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0],
-          {
-            low: initialWeightsS1[1].low,
-            spot: initialWeightsS1[1].low,
-            high: initialWeightsS1[1].low,
-          },
-          {
-            low: initialWeightsS1[2].low,
-            spot: initialWeightsS1[2].low,
-            high: initialWeightsS1[2].low,
-          },
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS1,
-      })
-    })
-
-    it('Step 7: NATIVE Mid-Rebalance (Multi-Asset Target, Negligible Ejection, Low Relative Progression -> Varied Weights)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS1,
-        priceControl: PriceControl.PARTIAL,
-      }
-      // Using folioStep7S1_varied_weights: shareValue ~1.0, relativeProgression ~0.7 -> delta=0.05.
-      // ideal_DAI/USDT_whole_spot ~0.5 (since shareValue*0.5 = 0.5).
-      // This ideal_spot is same as initialWeightsS1[i].spot_whole.
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS1,
-        targetBasketS1,
-        folioStep7S1_varied_weights,
-        decimalsS1,
-        initialMarketPricesS1,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 1n,
-        tokens: tokens,
-        newWeights: [
-          initialWeightsS1[0], // USDC target 0
-          // DAI: ideal_whole=0.5. calc_low=0.475, calc_spot=0.5, calc_high=0.525.
-          // initialWeight_DAI (whole): low=0.45, spot=0.5, high=~0.555. All calculated values are within this range.
-          { low: bn('4.75e26'), spot: bn('5e26'), high: bn('5.25e26') },
-          // USDT: ideal_whole=0.5. calc_low=0.475, calc_spot=0.5, calc_high=0.525.
-          // initialWeight_USDT (whole): low=0.45, spot=0.5, high=~0.555. All calculated values are within this range.
-          { low: bn('4.75e14'), spot: bn('5e14'), high: bn('5.25e14') },
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS1, // newLimits will be clamped to initial flat NATIVE limits
-      })
-    })
-  })
-
-  describe('Rebalancing from 0% USDC, 50% DAI, 50% USDT to 100% USDC', () => {
-    const tokens = ['USDC', 'DAI', 'USDT']
-    const decimalsS2 = [bn('6'), bn('18'), bn('6')]
-    const initialMarketPricesS2 = [1, 1, 1]
-    const priceErrorStartRebalanceS2 = [0.1, 0.1, 0.1]
-    const dtfPriceS2 = 1
-    // initialFolioS2: approx 0 USDC, 0.5 DAI val, 0.5 USDT val (total val 1 USD for 1 share)
-    const initialFolioS2 = [bn('0'), bn('0.5e18'), bn('0.5e6')]
-    const targetBasketS2 = [bn('1e18'), bn('0'), bn('0')] // Target 100% USDC
-    // Folio for mid-progress ejection tests: ~40% USDC, ~30% DAI, ~30% USDT by value
-    const folioMidProgressS2 = [bn('0.4e6'), bn('0.3e18'), bn('0.3e6')]
-    // Folio for near completion ejection tests: ~98% USDC, ~1% DAI, ~1% USDT by value
-    const folioTrulyNearCompletionS2 = [
-      bn('0.98e6'),
-      bn('0.01e18'),
-      bn('0.01e6'),
-    ]
-    // Folio for Step 6 (negligible ejection, high relative progression): DAI/USDT almost gone
-    const folioTrueMidS2_ActuallyHighProg = [
-      bn('0.4e6'),
-      bn('0.00001e18'),
-      bn('0.00001e6'),
-    ]
-
-    let mockRebalanceBaseS2: Omit<Rebalance, 'priceControl'>
-    let initialWeightsS2: WeightRange[],
-      initialPricesS2: PriceRange[],
-      initialLimitsS2: RebalanceLimits
-
-    beforeEach(() => {
-      const { weights, prices, limits } = getStartRebalance(
-        supply,
-        tokens,
-        decimalsS2,
-        targetBasketS2,
-        initialMarketPricesS2,
-        priceErrorStartRebalanceS2,
-        dtfPriceS2,
-        true
-      )
-      initialWeightsS2 = weights
-      initialPricesS2 = prices
-      initialLimitsS2 = limits
-      mockRebalanceBaseS2 = {
-        nonce: 2n, // Different nonce for this scenario suite
-        tokens: tokens,
-        weights: initialWeightsS2,
-        initialPrices: initialPricesS2,
-        inRebalance: tokens.map(() => true),
-        limits: initialLimitsS2,
-        startedAt: 0n,
-        restrictedUntil: 0n,
-        availableUntil: 0n,
-      }
-    })
-
-    it('Step 0: Verifies initial setup from getStartRebalance', () => {
-      assert.equal(initialWeightsS2.length, 3)
-      // USDC target 100%
-      assertRangesEqual(initialWeightsS2[0], {
-        low: bn('909090909090909'), // 1.0 / 1.1 * 1e15
-        spot: bn('1000000000000000'), // 1.0 * 1e15
-        high: bn('1100000000000000'), // 1.0 * 1.1 * 1e15
-      })
-      assertRangesEqual(initialWeightsS2[1], {
-        low: bn('0'),
-        spot: bn('0'),
-        high: bn('0'),
-      }) // DAI target 0%
-      assertRangesEqual(initialWeightsS2[2], {
-        low: bn('0'),
-        spot: bn('0'),
-        high: bn('0'),
-      }) // USDT target 0%
-      assertRebalanceLimitsEqual(initialLimitsS2, {
-        low: bn('1e18'),
-        spot: bn('1e18'),
-        high: bn('1e18'),
-      })
-    })
-
-    it('Step 1: Ejection Phase (initial folio, priceControl=true, prices=[1,1,1])', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        initialFolioS2,
-        decimalsS2,
-        initialMarketPricesS2,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          {
-            low: initialWeightsS2[0].spot,
-            spot: initialWeightsS2[0].spot,
-            high: initialWeightsS2[0].spot,
-          },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS2,
-      })
-    })
-
-    it('Step 2: Ejection Phase (mid-progress folio with DAI/USDT to eject)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        folioMidProgressS2,
-        decimalsS2,
-        initialMarketPricesS2,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          {
-            low: initialWeightsS2[0].spot,
-            spot: initialWeightsS2[0].spot,
-            high: initialWeightsS2[0].spot,
-          },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS2,
-      })
-    })
-
-    it('Step 3: Ejection Phase (near-completion folio with DAI/USDT to eject)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        folioTrulyNearCompletionS2,
-        decimalsS2,
-        initialMarketPricesS2,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          {
-            low: initialWeightsS2[0].spot,
-            spot: initialWeightsS2[0].spot,
-            high: initialWeightsS2[0].spot,
-          },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS2,
-      })
-    })
-
-    it('Step 4: Ejection Phase (initial folio, USDC Price Drop 0.9 - Gain for Buyer, priceControl=true)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const pricesS2_USDCdrop = [0.9, 1, 1] // USDC price drops, good for us as we target USDC
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        initialFolioS2,
-        decimalsS2,
-        pricesS2_USDCdrop,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      // Expected: rebalanceTarget=1, delta=0. idealWeight for USDC changes due to its price drop.
-      // shareValue (of initialFolioS2) = 0.5*1 (DAI) + 0.5*1 (USDT) = 1 (approx, using scaled folio values)
-      // idealSpotWeight_USDC = shareValue * targetBasket_USDC[0] / actualLimits.spot / prices_USDC[0.9]
-      // idealSpot_USDC_D27 was 1e15 at price 1. At price 0.9, idealSpot_D27 becomes 1e15 / 0.9 = 1.111...e15.
-      const expectedNewPricesGainUSDC: PriceRange[] = [
-        { low: bn('9e20'), high: bn('9.09e20') },
-        { low: bn('9.9e8'), high: bn('1.01e9') },
-        { low: bn('9.9e20'), high: bn('1.01e21') },
-      ]
-      // This new ideal spot (1.111...e15) is clamped by initialWeightsS2[0].high (1.11111e15).
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          {
-            low: bn('1100000000000000'),
-            spot: bn('1100000000000000'),
-            high: bn('1100000000000000'),
-          },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: expectedNewPricesGainUSDC,
-        newLimits: initialLimitsS2,
-      })
-    })
-
-    it('Step 5: Ejection Phase (initial folio, USDC Price Rise 1.1 - Loss for Buyer, priceControl=true)', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const pricesS2_USDCrise = [1.1, 1, 1]
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        initialFolioS2,
-        decimalsS2,
-        pricesS2_USDCrise,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      // Expected: rebalanceTarget=1, delta=0. idealWeight for USDC changes.
-      // idealSpot_USDC_D27 was 1e15 at price 1. At price 1.1, idealSpot_D27 becomes 1e15 / 1.1 = 9.09091e14.
-      const expectedNewPricesLossUSDC: PriceRange[] = [
-        { low: bn('1.089e21'), high: bn('1.1e21') },
-        { low: bn('9.9e8'), high: bn('1.01e9') },
-        { low: bn('9.9e20'), high: bn('1.01e21') },
-      ]
-      // This new ideal spot (9.09091e14) is clamped by initialWeightsS2[0].low (9e14), so becomes 9.09091e14.
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          {
-            low: bn('909090909090909'),
-            spot: bn('909090909090909'),
-            high: bn('909090909090909'),
-          },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: expectedNewPricesLossUSDC,
-        newLimits: initialLimitsS2,
-      })
-    })
-
-    it('Step 6: Test Case: Negligible Ejection, High Relative Progression (Single Target Asset) -> Delta=0', () => {
-      const mockRebalance: Rebalance = {
-        ...mockRebalanceBaseS2,
-        priceControl: PriceControl.PARTIAL,
-      }
-      const [openAuctionArgs] = getOpenAuction(
-        mockRebalance,
-        supply,
-        initialFolioS2,
-        targetBasketS2,
-        folioTrueMidS2_ActuallyHighProg,
-        decimalsS2,
-        initialMarketPricesS2,
-        auctionPriceError,
-        finalStageAtForTest
-      )
-      assertOpenAuctionArgsEqual(openAuctionArgs, {
-        rebalanceNonce: 2n,
-        tokens: tokens,
-        newWeights: [
-          { low: bn('909090909090909'), spot: bn('909090909090909'), high: bn('909090909090909') },
-          initialWeightsS2[1],
-          initialWeightsS2[2],
-        ],
-        newPrices: defaultExpectedPrices_USDC_DAI_USDT,
-        newLimits: initialLimitsS2,
-      })
-    })
-  })
-
-  it('volatiles: [75%, 25%]', () => {
-    const tokens = ['USDC', 'ETH']
-    const decimals = [bn('6'), bn('18')]
-    const prices = [1, 3000]
-    const priceError = [0.1, 0.1]
-    const targetBasket = [bn('0.75e18'), bn('0.25e18')]
-    const {
-      weights: newWeights,
-      prices: newPricesResult, // renamed to avoid clash
-      limits: newLimitsResult, // renamed
-    } = getStartRebalance(
-      supply,
-      tokens,
-      decimals,
-      targetBasket,
-      prices,
-      priceError,
-      1, // dtfPrice
-      true // weightControl: true
-    )
-    assert.equal(newWeights.length, 2)
-    assert.equal(newPricesResult.length, 2)
-
-    assertRangesEqual(newWeights[0], {
-      // USDC
-      low: bn('681818181818182'), // 0.75 / 1.1 * 1e15
-      spot: bn('750000000000000'), // 0.75 * 1e15
-      high: bn('825000000000000'), // 0.75 * 1.1 * 1e15
-    })
-    assertRangesEqual(newWeights[1], {
-      // ETH
-      low: bn('75757575757575757575758'), // (0.25/3000) / 1.1 * 1e27
-      spot: bn('83333333333333333333333'), // (0.25/3000) * 1e27
-      high: bn('91666666666666666666667'), // (0.25/3000) * 1.1 * 1e27
-    })
-
-    assertPricesEqual(newPricesResult[0], {
-      low: bn('9e20'), // 1 * 0.9 * 1e21
-      high: bn('1100000000000000000000'), // 1 * 1.1 * 1e21
-    })
-    assertPricesEqual(newPricesResult[1], {
-      low: bn('2700000000000'), // 3000 * 0.9 * 1e9
-      high: bn('3300000000000'), // 3000 * 1.1 * 1e9
-    })
-    assertRebalanceLimitsEqual(newLimitsResult, {
-      low: bn('1e18'),
-      spot: bn('1e18'),
-      high: bn('1e18'),
-    })
-  })
-
-  it('volatiles: fuzz', () => {
-    for (let i = 0; i < 100; i++) {
-      // Reduced iterations for faster tests
-      const tokensList = [
-        ['USDC', 'DAI', 'WETH', 'WBTC'],
-        ['SOL', 'BONK'],
-      ]
-      const currentTokens = tokensList[i % tokensList.length]
-
-      const decimalsMap: { [key: string]: bigint } = {
-        USDC: bn('6'),
-        DAI: bn('18'),
-        WETH: bn('18'),
-        WBTC: bn('8'),
-        SOL: bn('9'),
-        BONK: bn('5'),
-      }
-      const currentDecimals = currentTokens.map((t) => decimalsMap[t])
-
-      const bals = currentTokens.map(
-        (_) => bn(Math.round(Math.random() * 1e20).toString()) // Reduced scale
-      )
-      const prices = currentTokens.map((_) =>
-        Math.max(0.01, Math.random() * 1e4)
-      ) // Ensure positive prices
-      const priceError = currentTokens.map((_) =>
-        Math.max(0.001, Math.min(0.5, Math.random() * 0.2))
-      ) // Realistic price error 0.001 to 0.2
-
-      const targetBasket = getBasketDistribution(bals, prices, currentDecimals)
-
-      const {
-        weights: newWeights,
-        prices: newPricesResult,
-        limits: newLimitsResult,
-      } = getStartRebalance(
-        supply,
-        currentTokens,
-        currentDecimals,
-        targetBasket,
-        prices,
-        priceError,
-        prices[0] || 1, // dtfPrice, use first token's price or 1
-        true // weightControl: true
-      )
-      assert.equal(newWeights.length, currentTokens.length)
-      assert.equal(newPricesResult.length, currentTokens.length)
-      assert(newLimitsResult !== undefined, 'newLimitsResult should be defined')
-    }
-  })
-})
-
-describe('TRACKING DTF Rebalance: USDC -> DAI/USDT Sequence', () => {
-  const supply = bn('1e21') // 1000 supply
-  const tokens = ['USDC', 'DAI', 'USDT']
-  const decimals = [bn('6'), bn('18'), bn('6')]
-  const initialMarketPrices = [1, 1, 1]
-  const priceErrorStartRebalance = [0.1, 0.1, 0.1] // For getStartRebalance limits
-  const dtfPrice = 1
-  const targetBasketUSDCtoDAIUST = [bn('0'), bn('5e17'), bn('5e17')] // Target 0% USDC, 50% DAI, 50% USDT
-  const auctionPriceErrorSmall = [0.01, 0.01, 0.01] // For getOpenAuction price calcs
-  const finalStageAtForTest = 0.95 // Standard finalStageAt
-
-  // Step 0: getStartRebalance for TRACKING DTF
-  const _folioUSDCStart = [bn('1e6'), bn('0'), bn('0')] // 100% USDC, use as initialFolio for this sequence
-
-  const {
-    weights: initialWeightsTracking,
-    prices: initialPricesTracking,
-    limits: initialLimitsTracking,
-  } = getStartRebalance(
-    supply,
-    tokens,
-    decimals,
-    targetBasketUSDCtoDAIUST,
-    initialMarketPrices,
-    priceErrorStartRebalance,
-    dtfPrice,
-    false // weightControl: false for TRACKING-style weights and limits
-  )
-
-  it('Step 0: Verifies initial setup from getStartRebalance (TRACKING)', () => {
-    // totalPortion = (0*0.1) + (0.5*0.1) + (0.5*0.1) = 0.1
-    // expectedLowLimit = (1 / (1 + 0.1)) * 1e18 = (1/1.1) * 1e18
-    // expectedHighLimit = (1 + 0.1) * 1e18 = 1.1 * 1e18
-    assertRebalanceLimitsEqual(initialLimitsTracking, {
-      low: bn('909090909090909091'), // (1/1.1) * 1e18
-      spot: bn('1000000000000000000'),
-      high: bn('1100000000000000000'), // 1.1 * 1e18
-    })
-
-    // For TRACKING, weights low/spot/high are identical
-    assertRangesEqual(initialWeightsTracking[0], {
-      low: bn('0'),
-      spot: bn('0'),
-      high: bn('0'),
-    }) // USDC
-    assertRangesEqual(initialWeightsTracking[1], {
-      low: bn('5e26'),
-      spot: bn('5e26'),
-      high: bn('5e26'),
-    }) // DAI
-    assertRangesEqual(initialWeightsTracking[2], {
-      low: bn('5e14'),
-      spot: bn('5e14'),
-      high: bn('5e14'),
-    }) // USDT
-
-    // Prices are same as NATIVE calculation initially
-    assertPricesEqual(initialPricesTracking[0], {
-      low: bn('9e20'), // 1 * 0.9 * 1e21
-      high: bn('1100000000000000000000'), // 1 * 1.1 * 1e21
-    })
-    assertPricesEqual(initialPricesTracking[1], {
-      low: bn('900000000'), // 1 * 0.9 * 1e9
-      high: bn('1100000000'), // 1 * 1.1 * 1e9
-    })
-    assertPricesEqual(initialPricesTracking[2], {
-      low: bn('9e20'), // 1 * 0.9 * 1e21
-      high: bn('1100000000000000000000'), // 1 * 1.1 * 1e21
-    })
-  })
-
-  const mockRebalanceBase: Omit<Rebalance, 'priceControl'> = {
-    nonce: 2n, // Different nonce for this suite
-    tokens: tokens,
-    weights: initialWeightsTracking,
-    initialPrices: initialPricesTracking,
-    inRebalance: tokens.map(() => true),
-    limits: initialLimitsTracking,
-    startedAt: 0n,
-    restrictedUntil: 0n,
-    availableUntil: 0n,
-  }
-
-  it('Step 1: Auction for Ejection Phase', () => {
-    const _folio1 = _folioUSDCStart // 100% USDC, needs ejection
-    const currentMarketPrices1 = [1, 1, 1]
-    const mockRebalance1: Rebalance = {
-      ...mockRebalanceBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-
-    const [openAuctionArgs1] = getOpenAuction(
-      mockRebalance1,
-      supply,
-      _folioUSDCStart, // _initialFolio
-      targetBasketUSDCtoDAIUST,
-      _folio1, // current _folio
-      decimals,
-      currentMarketPrices1,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-    // Expected: buyTarget=1 (ejection). idealSpotLimit=1. limitDelta=0.
-    // newLimits before clamp: {1e18,1e18,1e18}. After initialLimitsTracking clamp: {1e18,1e18,1e18}
-    assertRebalanceLimitsEqual(openAuctionArgs1.newLimits, {
-      low: bn('1e18'),
-      spot: bn('1e18'),
-      high: bn('1e18'),
-    })
-    // For TRACKING, newWeights from getOpenAuction are clamped to initialWeightsTracking.spot values
-    assert.deepEqual(openAuctionArgs1.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-
-    const expectedNewPrices1: PriceRange[] = [
-      { low: bn('9.9e20'), high: bn('1.01e21') }, // USDC
-      { low: bn('9.9e8'), high: bn('1.01e9') }, // DAI
-      { low: bn('9.9e20'), high: bn('1.01e21') }, // USDT
-    ]
-    assertPricesEqual(openAuctionArgs1.newPrices[0], expectedNewPrices1[0])
-    assertPricesEqual(openAuctionArgs1.newPrices[1], expectedNewPrices1[1])
-    assertPricesEqual(openAuctionArgs1.newPrices[2], expectedNewPrices1[2])
-  })
-
-  it('Step 2: Auction for Mid-Rebalance (progression < finalStageAt)', () => {
-    // Folio: 0 USDC, 0.3 DAI (whole), 0.7 USDT (whole). shareValue = 1.
-    // targetBasketDec = [0, 0.5, 0.5]. prices = [1,1,1].
-    // DAI: expectedInBU = 1*0.5/1 = 0.5. actual = 0.3. balanceInBU = 0.3. value = 0.3.
-    // USDT: expectedInBU = 1*0.5/1 = 0.5. actual = 0.7. balanceInBU = 0.5. value = 0.5.
-    // progression = (0.3+0.5)/1 = 0.8. initialProgression (from _folioUSDCStart) = 0.
-    // relativeProgression = (0.8 - 0) / (1 - 0) = 0.8.
-    // finalStageAt = 0.95. threshold = 0.95 - 0.02 = 0.93. 0.8 < 0.93 is TRUE.
-    const _folio2 = [bn('0'), bn('3e17'), bn('7e5')] // Corresponds to 0.3 DAI, 0.7 USDT, total value $1
-    const currentMarketPrices2 = [1, 1, 1]
-    const mockRebalance2: Rebalance = {
-      ...mockRebalanceBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-
-    const [openAuctionArgs2] = getOpenAuction(
-      mockRebalance2,
-      supply,
-      _folioUSDCStart, // _initialFolio
-      targetBasketUSDCtoDAIUST,
-      _folio2, // current _folio
-      decimals,
-      currentMarketPrices2,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-
-    // Expected: buyTarget=0.95 (finalStageAt). idealSpotLimit=1. limitDelta=0.05.
-    // newLimits pre-clamp: low=0.95e18, spot=1e18, high=1.05e18.
-    // Clamped by initialLimitsTracking (9e17,1e18,1.11111e18):
-    // low=max(0.95e18,9e17)=9.5e17. spot=1e18. high=min(1.05e18,1.11111e18)=1.05e18.
-    assertRebalanceLimitsEqual(openAuctionArgs2.newLimits, {
-      low: bn('9.5e17'),
-      spot: bn('1e18'),
-      high: bn('1.05e18'),
-    })
-    assert.deepEqual(openAuctionArgs2.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    // Prices same as step 1 if market prices didn't change
-    assertPricesEqual(openAuctionArgs2.newPrices[0], {
-      low: bn('9.9e20'),
-      high: bn('1.01e21'),
-    })
-    assertPricesEqual(openAuctionArgs2.newPrices[1], {
-      low: bn('9.9e8'),
-      high: bn('1.01e9'),
-    })
-    assertPricesEqual(openAuctionArgs2.newPrices[2], {
-      low: bn('9.9e20'),
-      high: bn('1.01e21'),
-    })
-  })
-
-  it('Step 3: Auction for Trading to Completion (progression >= finalStageAt)', () => {
-    // Folio: 0 USDC, 0.48 DAI (whole), 0.52 USDT (whole). shareValue = 1.
-    // DAI: exp=0.5, actual=0.48, inBU=0.48. USDT: exp=0.5, actual=0.52, inBU=0.5.
-    // progression = (0.48+0.5)/1 = 0.98. initialProgression = 0.
-    // relativeProgression = (0.98 - 0) / (1-0) = 0.98.
-    // finalStageAt = 0.95. threshold = 0.95 - 0.02 = 0.93. 0.98 < 0.93 is FALSE.
-    const _folio3 = [bn('0'), bn('4.8e17'), bn('5.2e5')] // Corresponds to 0.48 DAI, 0.52 USDT, total value $1
-    const currentMarketPrices3 = [1, 1, 1]
-    const mockRebalance3: Rebalance = {
-      ...mockRebalanceBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-
-    const [openAuctionArgs3] = getOpenAuction(
-      mockRebalance3,
-      supply,
-      _folioUSDCStart, // _initialFolio
-      targetBasketUSDCtoDAIUST,
-      _folio3, // current _folio
-      decimals,
-      currentMarketPrices3,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-
-    // Expected: buyTarget=1. idealSpotLimit=1. limitDelta=0.
-    // newLimits pre-clamp: low=1e18, spot=1e18, high=1e18.
-    // Clamped by initialLimitsTracking (9e17,1e18,1.11111e18) -> no change.
-    assertRebalanceLimitsEqual(openAuctionArgs3.newLimits, {
-      low: bn('1e18'),
-      spot: bn('1e18'),
-      high: bn('1e18'),
-    })
-    assert.deepEqual(openAuctionArgs3.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    // Prices same as step 1 if market prices didn't change
-    assertPricesEqual(openAuctionArgs3.newPrices[0], {
-      low: bn('9.9e20'),
-      high: bn('1.01e21'),
-    })
-    assertPricesEqual(openAuctionArgs3.newPrices[1], {
-      low: bn('9.9e8'),
-      high: bn('1.01e9'),
-    })
-    assertPricesEqual(openAuctionArgs3.newPrices[2], {
-      low: bn('9.9e20'),
-      high: bn('1.01e21'),
-    })
-  })
-})
-
-describe('Hybrid Rebalance Scenario (Manually Constructed Rebalance Object)', () => {
-  const supply = bn('1e21')
-  const tokens = ['USDC', 'DAI', 'USDT']
-  const decimals = [bn('6'), bn('18'), bn('6')]
-  const auctionPriceErrorSmall = [0.01, 0.01, 0.01]
-  const finalStageAtForTest = 0.95
-  const targetBasketHybrid = [bn('0'), bn('5e17'), bn('5e17')]
-  const hybridWeights: WeightRange[] = [
-    { low: bn('0'), spot: bn('0'), high: bn('0') },
-    { low: bn('4.5e26'), spot: bn('5e26'), high: bn('5.55556e26') },
-    { low: bn('4.5e14'), spot: bn('5e14'), high: bn('5.55556e14') },
-  ]
-  const hybridInitialPrices: PriceRange[] = [
-    { low: bn('9e20'), high: bn('1.11111e21') },
-    { low: bn('9e8'), high: bn('1.11111e9') },
-    { low: bn('9e20'), high: bn('1.11111e21') },
-  ]
-  const hybridLimits_veryWide: RebalanceLimits = {
-    low: bn('1'),
-    spot: bn('1e18'),
-    high: bn('1e36'),
-  }
-  const mockRebalanceHybridBase: Omit<Rebalance, 'priceControl'> = {
-    nonce: 3n,
-    tokens: tokens,
-    weights: hybridWeights,
-    initialPrices: hybridInitialPrices,
-    limits: hybridLimits_veryWide,
-    inRebalance: tokens.map(() => true),
-    startedAt: 0n,
-    restrictedUntil: 0n,
-    availableUntil: 0n,
-  }
-  const currentMarketPrices_Hybrid = [1, 1, 1] // Defined for this scope
-
-  const defaultPricesHybridScope: PriceRange[] = [
-    { low: bn('9.9e20'), high: bn('1.01e21') }, // USDC
-    { low: bn('9.9e8'), high: bn('1.01e9') }, // DAI
-    { low: bn('9.9e20'), high: bn('1.01e21') }, // USDT
-  ]
-
-  it('Hybrid Scenario 1: Mid-Rebalance (progression < finalStageAt)', () => {
-    const _folio = [bn('0'), bn('3e17'), bn('7e5')]
-    const mockRebalanceHybrid: Rebalance = {
-      ...mockRebalanceHybridBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-    const [openAuctionArgs] = getOpenAuction(
-      mockRebalanceHybrid,
-      supply,
-      _folio,
-      targetBasketHybrid,
-      _folio,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-    assertRebalanceLimitsEqual(openAuctionArgs.newLimits, {
-      low: bn('9.5e17'),
-      spot: bn('1e18'),
-      high: bn('1.05e18'),
-    })
-    assert.deepEqual(openAuctionArgs.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    assertPricesEqual(openAuctionArgs.newPrices[0], defaultPricesHybridScope[0])
-    assertPricesEqual(openAuctionArgs.newPrices[1], defaultPricesHybridScope[1])
-    assertPricesEqual(openAuctionArgs.newPrices[2], defaultPricesHybridScope[2])
-  })
-
-  it('Hybrid Scenario 2: Near Completion (progression >= finalStageAt)', () => {
-    const _folio = [bn('0'), bn('4.8e17'), bn('5.2e5')]
-    const mockRebalanceHybrid: Rebalance = {
-      ...mockRebalanceHybridBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-    const [openAuctionArgs] = getOpenAuction(
-      mockRebalanceHybrid,
-      supply,
-      _folio,
-      targetBasketHybrid,
-      _folio,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-    assertRebalanceLimitsEqual(openAuctionArgs.newLimits, {
-      low: bn('9.5e17'),
-      spot: bn('1e18'),
-      high: bn('1.05e18'),
-    })
-    assert.deepEqual(openAuctionArgs.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    assertPricesEqual(openAuctionArgs.newPrices[0], defaultPricesHybridScope[0])
-    assertPricesEqual(openAuctionArgs.newPrices[1], defaultPricesHybridScope[1])
-    assertPricesEqual(openAuctionArgs.newPrices[2], defaultPricesHybridScope[2])
-  })
-
-  it('Hybrid Scenario 3: Custom finalStageAt (0.8) - Round 1 & Round 2', () => {
-    const finalStageAtCustom = 0.8
-    const mockRebalanceHybridCustom: Rebalance = {
-      ...mockRebalanceHybridBase,
-      priceControl: PriceControl.PARTIAL,
-    }
-    const _folioRound1 = [bn('0'), bn('2e17'), bn('8e5')]
-    const [openAuctionArgsCustomRound1] = getOpenAuction(
-      mockRebalanceHybridCustom,
-      supply,
-      _folioRound1,
-      targetBasketHybrid,
-      _folioRound1,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtCustom
-    )
-    assertRebalanceLimitsEqual(openAuctionArgsCustomRound1.newLimits, {
-      low: bn('8e17'),
-      spot: bn('1e18'),
-      high: bn('1.2e18'),
-    })
-    assert.deepEqual(openAuctionArgsCustomRound1.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    assertPricesEqual(
-      openAuctionArgsCustomRound1.newPrices[0],
-      defaultPricesHybridScope[0]
-    )
-    assertPricesEqual(
-      openAuctionArgsCustomRound1.newPrices[1],
-      defaultPricesHybridScope[1]
-    )
-    assertPricesEqual(
-      openAuctionArgsCustomRound1.newPrices[2],
-      defaultPricesHybridScope[2]
-    )
-
-    const _folioRound2 = [bn('0'), bn('4e17'), bn('6e5')]
-    const [openAuctionArgsCustomRound2] = getOpenAuction(
-      mockRebalanceHybridCustom,
-      supply,
-      _folioRound1,
-      targetBasketHybrid,
-      _folioRound2,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtCustom
-    )
-    assertRebalanceLimitsEqual(openAuctionArgsCustomRound2.newLimits, {
-      low: bn('8e17'),
-      spot: bn('1e18'),
-      high: bn('1.2e18'),
-    })
-    assert.deepEqual(openAuctionArgsCustomRound2.newWeights, [
-      { low: bn('0'), spot: bn('0'), high: bn('0') },
-      { low: bn('5e26'), spot: bn('5e26'), high: bn('5e26') },
-      { low: bn('5e14'), spot: bn('5e14'), high: bn('5e14') },
-    ])
-    assertPricesEqual(
-      openAuctionArgsCustomRound2.newPrices[0],
-      defaultPricesHybridScope[0]
-    )
-    assertPricesEqual(
-      openAuctionArgsCustomRound2.newPrices[1],
-      defaultPricesHybridScope[1]
-    )
-    assertPricesEqual(
-      openAuctionArgsCustomRound2.newPrices[2],
-      defaultPricesHybridScope[2]
-    )
-  })
-
-  it('Hybrid Scenario 4: Delta split between Limits and Weights', () => {
-    const _folioForS4 = [bn('0'), bn('2e17'), bn('8e5')] // 0 USDC, 0.2 DAI val, 0.8 USDT val; shareVal=1.0
-    const scenario4Limits: RebalanceLimits = {
-      low: bn('0.98e18'),
-      spot: bn('1e18'),
-      high: bn('1.02e18'),
-    }
-    const mockRebalanceHybrid4: Rebalance = {
-      ...mockRebalanceHybridBase,
-      nonce: 4n,
-      limits: scenario4Limits,
-      priceControl: PriceControl.PARTIAL,
-    }
-    const [openAuctionArgs] = getOpenAuction(
-      mockRebalanceHybrid4,
-      supply,
-      _folioForS4,
-      targetBasketHybrid,
-      _folioForS4,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-
-    assertRebalanceLimitsEqual(openAuctionArgs.newLimits, scenario4Limits)
-    assertPricesEqual(openAuctionArgs.newPrices[0], defaultPricesHybridScope[0])
-    assertPricesEqual(openAuctionArgs.newPrices[1], defaultPricesHybridScope[1])
-    assertPricesEqual(openAuctionArgs.newPrices[2], defaultPricesHybridScope[2])
-
-    const spotDAI_D27 = hybridWeights[1].spot // bn('5e26')
-    const spotUSDT_D27 = hybridWeights[2].spot // bn('5e14')
-
-    assert.equal(openAuctionArgs.newWeights.length, 3)
-    assertRangesEqual(openAuctionArgs.newWeights[0], hybridWeights[0])
-    assertRangesEqual(openAuctionArgs.newWeights[1], {
-      low: bn('4.847e26'),
-      spot: spotDAI_D27,
-      high: bn('5.147e26'),
-    })
-    assertRangesEqual(openAuctionArgs.newWeights[2], {
-      low: bn('4.847e14'),
-      spot: spotUSDT_D27,
-      high: bn('5.147e14'),
-    })
-  })
-
-  it('Hybrid Scenario 5: Already Balanced Folio (rebalanceTarget=1, delta=0)', () => {
-    const _folioAlreadyBalancedAndShareValue1 = [bn('0'), bn('5e17'), bn('5e5')]
-    const mockRebalanceHybrid5: Rebalance = {
-      ...mockRebalanceHybridBase,
-      nonce: 5n,
-      priceControl: PriceControl.PARTIAL,
-    }
-    const [openAuctionArgs] = getOpenAuction(
-      mockRebalanceHybrid5,
-      supply,
-      _folioAlreadyBalancedAndShareValue1,
-      targetBasketHybrid,
-      _folioAlreadyBalancedAndShareValue1,
-      decimals,
-      currentMarketPrices_Hybrid,
-      auctionPriceErrorSmall,
-      finalStageAtForTest
-    )
-
-    assertRebalanceLimitsEqual(openAuctionArgs.newLimits, {
-      low: bn('1e18'),
-      spot: bn('1e18'),
-      high: bn('1e18'),
-    })
-
-    assertPricesEqual(openAuctionArgs.newPrices[0], defaultPricesHybridScope[0])
-    assertPricesEqual(openAuctionArgs.newPrices[1], defaultPricesHybridScope[1])
-    assertPricesEqual(openAuctionArgs.newPrices[2], defaultPricesHybridScope[2])
-
-    // For USDT (index 2), hybridWeights[2].spot is bn('5e14').
-    // As deduced, all components of openAuctionArgs.newWeights[2] should also be bn('5e14').
-    // Making the assertion explicit with hardcoded values to test exactness.
-    assert.equal(openAuctionArgs.newWeights.length, 3)
-    assertRangesEqual(openAuctionArgs.newWeights[0], hybridWeights[0]) // USDC {0,0,0}
-    assertRangesEqual(openAuctionArgs.newWeights[1], {
-      low: hybridWeights[1].spot,
-      spot: hybridWeights[1].spot,
-      high: hybridWeights[1].spot,
-    })
-    assertRangesEqual(openAuctionArgs.newWeights[2], {
-      low: bn('5e14'),
-      spot: bn('5e14'),
-      high: bn('5e14'),
-    })
-  })
-})
-
-describe('Price Edge Cases in getOpenAuction', () => {
-  const supply = bn('1e21')
-  const tokens = ['USDC', 'DAI']
-  const decimals = [bn('6'), bn('18')]
-  const auctionPriceErrorSmall = [0.01, 0.01]
-  const targetBasketSimple = [bn('5e17'), bn('5e17')] // 50% USDC, 50% DAI
-  const folioSimple = [bn('5e5'), bn('5e17')] // Example folio, value $1
-
-  it('should throw "spot price out of bounds!" when market price is outside initial price bounds', () => {
-    // Set up narrow initial price bounds that are below the market price
-    const initialPricesNarrowUSDC: PriceRange[] = [
-      { low: bn('8e20'), high: bn('8.5e20') }, // USDC: Range 0.8 - 0.85 USD
-      { low: bn('9e8'), high: bn('1.11111e9') }, // DAI: Normal range
-    ]
-
-    const mockRebalanceEdge: Rebalance = {
-      nonce: 4n,
-      tokens: tokens,
-      weights: [
-        { low: bn('4.5e14'), spot: bn('5e14'), high: bn('5.5e14') },
-        { low: bn('4.5e26'), spot: bn('5e26'), high: bn('5.5e26') },
-      ],
-      initialPrices: initialPricesNarrowUSDC,
-      inRebalance: tokens.map(() => true),
-      limits: { low: bn('1'), spot: bn('1e18'), high: bn('1e36') }, // Wide limits
-      startedAt: 0n,
-      restrictedUntil: 0n,
-      availableUntil: 0n,
-      priceControl: PriceControl.PARTIAL,
-    }
-
-    // Market price is $1.0, but initial bounds are only 0.8-0.85
-    // spotPrice = 1.0 * 1e27 / 1e6 = 1e21
-    // initialPrice.high = 8.5e20
-    // Since 1e21 > 8.5e20, this triggers "spot price out of bounds!"
-    const currentMarketPrices = [1.0, 1.0] // USDC at $1.0 is above the 0.8-0.85 range
-
-    assert.throws(() => {
-      getOpenAuction(
-        mockRebalanceEdge,
-        supply,
-        folioSimple, // _initialFolio
-        targetBasketSimple,
-        folioSimple, // current _folio
-        decimals,
-        currentMarketPrices,
-        auctionPriceErrorSmall,
-        0.95
-      )
-    }, {
-      message: 'spot price out of bounds! auction launcher MUST closeRebalance to prevent loss!'
-    })
-  })
-
-  it('should throw "no price range" when price clamping results in identical low and high prices', () => {
-    // Set up initial price bounds where low == high (degenerate range)
-    const initialPricesSameValue: PriceRange[] = [
-      { low: bn('1e21'), high: bn('1e21') }, // USDC: Exactly $1.0 (no range)
-      { low: bn('9e8'), high: bn('1.11111e9') }, // DAI: Normal range
-    ]
-
-    const mockRebalanceEdge: Rebalance = {
-      nonce: 5n,
-      tokens: tokens,
-      weights: [
-        { low: bn('4.5e14'), spot: bn('5e14'), high: bn('5.5e14') },
-        { low: bn('4.5e26'), spot: bn('5e26'), high: bn('5.5e26') },
-      ],
-      initialPrices: initialPricesSameValue,
-      inRebalance: tokens.map(() => true),
-      limits: { low: bn('1'), spot: bn('1e18'), high: bn('1e36') }, // Wide limits
-      startedAt: 0n,
-      restrictedUntil: 0n,
-      availableUntil: 0n,
-      priceControl: PriceControl.PARTIAL,
-    }
-
-    // Market price is $1.0, which matches the initial price bounds exactly
-    // spotPrice = 1.0 * 1e27 / 1e6 = 1e21 == initialPrice.low == initialPrice.high ✓
-    // But when we calculate pricesD27 with price error:
-    // pricesD27.low = 1.0 * 0.99 * 1e27 / 1e6 = 9.9e20, gets clamped to 1e21
-    // pricesD27.high = 1.0 / 0.99 * 1e27 / 1e6 ≈ 1.0101e21, gets clamped to 1e21
-    // Result: pricesD27.low == pricesD27.high == 1e21, triggering "no price range"
-    const currentMarketPrices = [1.0, 1.0]
-
-    assert.throws(() => {
-      getOpenAuction(
-        mockRebalanceEdge,
-        supply,
-        folioSimple, // _initialFolio
-        targetBasketSimple,
-        folioSimple, // current _folio
-        decimals,
-        currentMarketPrices,
-        auctionPriceErrorSmall,
-        0.95
-      )
-    }, {
-      message: 'no price range'
-    })
-  })
-})