shufflecom-calculations 6.10.0 → 6.12.0

package/src/games/rollercoaster/rollercoaster-rules.spec.ts

@@ -1,348 +0,0 @@
-import BigNumber from 'bignumber.js';
-import {
-  ROLLERCOASTER_MIN_TAKE_PROFIT_MULTIPLIER,
-  ROLLERCOASTER_ROUND_DURATION_MS,
-  ROLLERCOASTER_ROUND_TICK_COUNT,
-  ROLLERCOASTER_TICK_DURATION_MS,
-} from './constants';
-import { RollercoasterBetTerminalReason, RollercoasterDirection, RollercoasterOpenBetState, RollercoasterRules } from './rollercoaster-rules';
-
-const number = (value: BigNumber.Value) => new BigNumber(value);
-
-function openBet(overrides: Partial<RollercoasterOpenBetState> = {}): RollercoasterOpenBetState {
-  const direction = overrides.direction ?? RollercoasterDirection.UP;
-  const entryPrice = overrides.entryPrice ?? number(100);
-  const leverage = overrides.leverage ?? number(10);
-  return {
-    direction,
-    amount: number(100),
-    leverage,
-    entryPrice,
-    entryTick: 0,
-    bustPrice: RollercoasterRules.bustPrice(entryPrice, leverage, direction),
-    takeProfitMultiplier: null,
-    ...overrides,
-  };
-}
-
-describe('RollercoasterRules', () => {
-  describe('bustPrice', () => {
-    it('sits below entry for UP and above entry for DOWN, offset by entry / leverage', () => {
-      expect(RollercoasterRules.bustPrice(number(100), number(10), RollercoasterDirection.UP)).toBigNumberEqual(90);
-      expect(RollercoasterRules.bustPrice(number(100), number(10), RollercoasterDirection.DOWN)).toBigNumberEqual(110);
-    });
-  });
-
-  describe('position', () => {
-    it('is wager × leverage, negated for DOWN', () => {
-      expect(RollercoasterRules.position(number(100), number(10), RollercoasterDirection.UP)).toBigNumberEqual(1_000);
-      expect(RollercoasterRules.position(number(100), number(10), RollercoasterDirection.DOWN)).toBigNumberEqual(-1_000);
-    });
-  });
-
-  describe('impliedPriceForMultiplier', () => {
-    it('inverts multiplierAtPrice without depending on amount', () => {
-      const bet = openBet({ amount: number(0), leverage: number(10) });
-
-      const impliedPrice = RollercoasterRules.impliedPriceForMultiplier(bet, number(1.5));
-
-      expect(RollercoasterRules.multiplierAtPrice(bet, impliedPrice)).toBigNumberEqual(1.5);
-    });
-
-    it('moves in the opposite price direction for DOWN bets', () => {
-      const bet = openBet({ direction: RollercoasterDirection.DOWN, leverage: number(10) });
-
-      expect(RollercoasterRules.impliedPriceForMultiplier(bet, number(1.5))).toBigNumberEqual(95);
-    });
-  });
-
-  describe('isValidTakeProfitMultiplier', () => {
-    it('requires the multiplier to exceed the configured floor', () => {
-      expect(RollercoasterRules.isValidTakeProfitMultiplier(ROLLERCOASTER_MIN_TAKE_PROFIT_MULTIPLIER)).toBe(false);
-      expect(RollercoasterRules.isValidTakeProfitMultiplier(ROLLERCOASTER_MIN_TAKE_PROFIT_MULTIPLIER.plus('0.01'))).toBe(true);
-    });
-  });
-
-  describe('isTakeProfitFarEnoughFromEntry / isTakeProfitFarEnoughFromBust', () => {
-    it('rejects an implied price too close to entry or too close to bust', () => {
-      const entryPrice = number(100);
-      const bustPrice = number(90);
-
-      expect(RollercoasterRules.isTakeProfitFarEnoughFromEntry(entryPrice, number('100.0001'))).toBe(false);
-      expect(RollercoasterRules.isTakeProfitFarEnoughFromEntry(entryPrice, number(110))).toBe(true);
-
-      expect(RollercoasterRules.isTakeProfitFarEnoughFromBust(entryPrice, bustPrice, number('90.0001'))).toBe(false);
-      expect(RollercoasterRules.isTakeProfitFarEnoughFromBust(entryPrice, bustPrice, number(110))).toBe(true);
-    });
-  });
-
-  describe('isBustPriceDistinctFromEntry', () => {
-    it('is false only when bust collides with entry at the internal precision', () => {
-      expect(RollercoasterRules.isBustPriceDistinctFromEntry(number(100), number(100))).toBe(false);
-      expect(RollercoasterRules.isBustPriceDistinctFromEntry(number(100), number('99.99999999999'))).toBe(false);
-      expect(RollercoasterRules.isBustPriceDistinctFromEntry(number(100), number(90))).toBe(true);
-    });
-  });
-
-  describe('isFinalTick', () => {
-    it('is true only once the active tick reaches the last valid index', () => {
-      expect(RollercoasterRules.isFinalTick(ROLLERCOASTER_ROUND_TICK_COUNT - 2)).toBe(false);
-      expect(RollercoasterRules.isFinalTick(ROLLERCOASTER_ROUND_TICK_COUNT - 1)).toBe(true);
-    });
-  });
-
-  describe('isClientTickWithinMaxLag', () => {
-    it('allows up to the max stale ticks and rejects beyond it', () => {
-      expect(RollercoasterRules.isClientTickWithinMaxLag(100, 90)).toBe(true);
-      expect(RollercoasterRules.isClientTickWithinMaxLag(100, 89)).toBe(false);
-    });
-  });
-
-  describe('getScheduledRoundId / getScheduledRoundStartTime', () => {
-    it('round-trips a scheduled instant back to the same round id', () => {
-      const epochMs = 0;
-      const roundId = 42;
-      const startTime = RollercoasterRules.getScheduledRoundStartTime(roundId, epochMs);
-
-      expect(RollercoasterRules.getScheduledRoundId(startTime, epochMs)).toBe(roundId);
-      expect(startTime.getTime()).toBe(roundId * ROLLERCOASTER_ROUND_DURATION_MS);
-    });
-  });
-
-  describe('tickAtOrAfter / tickBefore / tickStartTime', () => {
-    const startedAtMs = 1_000_000;
-
-    it('round-trips a tick through its start time', () => {
-      const startTime = RollercoasterRules.tickStartTime(startedAtMs, 7);
-
-      expect(startTime.getTime()).toBe(startedAtMs + 7 * ROLLERCOASTER_TICK_DURATION_MS);
-      expect(RollercoasterRules.tickAtOrAfter(startedAtMs, startTime.getTime())).toBe(7);
-      expect(RollercoasterRules.tickBefore(startedAtMs, startTime.getTime())).toBe(6);
-    });
-
-    it('puts an exact tick boundary on the boundary tick, not the one before it', () => {
-      const boundaryMs = startedAtMs + 3 * ROLLERCOASTER_TICK_DURATION_MS;
-
-      expect(RollercoasterRules.tickAtOrAfter(startedAtMs, boundaryMs)).toBe(3);
-      expect(RollercoasterRules.tickBefore(startedAtMs, boundaryMs)).toBe(2);
-    });
-
-    it('maps an instant inside a tick window to that tick as the last tick started before it', () => {
-      const insideMs = startedAtMs + 3 * ROLLERCOASTER_TICK_DURATION_MS + 1;
-
-      expect(RollercoasterRules.tickBefore(startedAtMs, insideMs)).toBe(3);
-      expect(RollercoasterRules.tickAtOrAfter(startedAtMs, insideMs)).toBe(4);
-    });
-  });
-
-  describe('hasReachedTargetPrice', () => {
-    it('is inclusive of an exact match, in the direction of profit', () => {
-      expect(RollercoasterRules.hasReachedTargetPrice(RollercoasterDirection.UP, number(110), number(110))).toBe(true);
-      expect(RollercoasterRules.hasReachedTargetPrice(RollercoasterDirection.UP, number(109), number(110))).toBe(false);
-      expect(RollercoasterRules.hasReachedTargetPrice(RollercoasterDirection.DOWN, number(90), number(90))).toBe(true);
-      expect(RollercoasterRules.hasReachedTargetPrice(RollercoasterDirection.DOWN, number(91), number(90))).toBe(false);
-    });
-  });
-
-  describe('hasReachedBust', () => {
-    it('is inclusive of an exact match, in the direction of loss', () => {
-      expect(RollercoasterRules.hasReachedBust(RollercoasterDirection.UP, number(90), number(90))).toBe(true);
-      expect(RollercoasterRules.hasReachedBust(RollercoasterDirection.UP, number(91), number(90))).toBe(false);
-      expect(RollercoasterRules.hasReachedBust(RollercoasterDirection.DOWN, number(110), number(110))).toBe(true);
-      expect(RollercoasterRules.hasReachedBust(RollercoasterDirection.DOWN, number(109), number(110))).toBe(false);
-    });
-  });
-
-  describe('multiplierAtPrice', () => {
-    it('is 1 at entry and floors at zero once loss would exceed the wager', () => {
-      const bet = openBet({ entryPrice: number(100), leverage: number(10), direction: RollercoasterDirection.UP });
-
-      expect(RollercoasterRules.multiplierAtPrice(bet, number(100))).toBigNumberEqual(1);
-      expect(RollercoasterRules.multiplierAtPrice(bet, number(80))).toBigNumberEqual(0);
-    });
-  });
-
-  describe('grossPayoutAtPrice', () => {
-    it('scales pnl by leverage and floors at zero, matching direction', () => {
-      const bet = openBet({ direction: RollercoasterDirection.UP, leverage: number(10) });
-
-      expect(RollercoasterRules.grossPayoutAtPrice(bet, number(110))).toBigNumberEqual(200);
-      expect(RollercoasterRules.grossPayoutAtPrice(bet, number(80))).toBigNumberEqual(0);
-    });
-  });
-
-  describe('evaluateTriggers', () => {
-    it('does not fire when price stays between bust and the caps', () => {
-      const bet = openBet();
-
-      expect(RollercoasterRules.evaluateTriggers(bet, number(100), number(1_000))).toEqual({ fired: false });
-    });
-
-    it('fires LIQUIDATION once price reaches bust', () => {
-      const bet = openBet();
-
-      expect(RollercoasterRules.evaluateTriggers(bet, bet.bustPrice, number(1_000))).toEqual({
-        fired: true,
-        reason: { kind: RollercoasterBetTerminalReason.LIQUIDATION },
-      });
-    });
-
-    it('fires TAKE_PROFIT once price reaches the TP-implied price', () => {
-      const takeProfitMultiplier = number('1.5');
-      const bet = openBet({ takeProfitMultiplier });
-      const impliedPrice = RollercoasterRules.impliedPriceForMultiplier(bet, takeProfitMultiplier);
-
-      expect(RollercoasterRules.evaluateTriggers(bet, impliedPrice, number(1_000))).toEqual({
-        fired: true,
-        reason: { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier },
-      });
-    });
-
-    it('fires MAX_PAYOUT once the gross payout reaches the live cap, even overshooting it', () => {
-      const bet = openBet({ leverage: number(100) });
-      const cap = number(150);
-
-      // At price 101 the gross payout (200) overshoots the cap (150) — MAX_PAYOUT still fires,
-      // and the caller settles at this real tick price regardless, not a price back-solved from the cap.
-      expect(RollercoasterRules.evaluateTriggers(bet, number(101), cap)).toEqual({
-        fired: true,
-        reason: { kind: RollercoasterBetTerminalReason.MAX_PAYOUT, appliedCap: cap },
-      });
-    });
-
-    // A take-profit is the one reason whose payout is a fixed wager × multiplier rather than
-    // something derived from the tick price, so it is also the one reason that can promise more
-    // than the live cap allows. The cap is read fresh every batch, so it can be lowered under an
-    // already-agreed take-profit; nothing downstream re-checks it, making this the only place the
-    // ceiling can be enforced.
-    it('fires MAX_PAYOUT instead of TAKE_PROFIT when the agreed take-profit payout exceeds the live cap', () => {
-      const takeProfitMultiplier = number(3);
-      const bet = openBet({ takeProfitMultiplier });
-      const cap = number(250);
-      // Wager 100 × 3 = 300, above the cap of 250.
-      const impliedPrice = RollercoasterRules.impliedPriceForMultiplier(bet, takeProfitMultiplier);
-
-      const reason = { kind: RollercoasterBetTerminalReason.MAX_PAYOUT, appliedCap: cap } as const;
-
-      expect(RollercoasterRules.evaluateTriggers(bet, impliedPrice, cap)).toEqual({ fired: true, reason });
-      expect(RollercoasterRules.grossPayoutForReason(bet, reason, impliedPrice)).toBigNumberEqual(250);
-    });
-
-    // The mirror of the case above, and the reason the cap cannot simply be checked before the
-    // take-profit: MAX_PAYOUT pays exactly the cap, so firing it on a take-profit that sits under
-    // the cap would pay MORE than the multiplier the player agreed to, not less.
-    it('still fires TAKE_PROFIT when the tick price overshoots the cap but the agreed payout does not', () => {
-      const takeProfitMultiplier = number(2);
-      const bet = openBet({ takeProfitMultiplier });
-      const cap = number(250);
-      // One tick jumps to 130, well past the TP-implied 110: the price-derived payout there is 400
-      // and clears the cap, but the agreed take-profit payout is only 100 × 2 = 200, under it.
-      const reason = { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier } as const;
-
-      expect(RollercoasterRules.evaluateTriggers(bet, number(130), cap)).toEqual({ fired: true, reason });
-      expect(RollercoasterRules.grossPayoutForReason(bet, reason, number(130))).toBigNumberEqual(200);
-    });
-
-    it('fires TAKE_PROFIT, not MAX_PAYOUT, when the agreed take-profit payout exactly equals the live cap', () => {
-      const takeProfitMultiplier = number('1.1');
-      const bet = openBet({ takeProfitMultiplier });
-      const cap = bet.amount.multipliedBy(takeProfitMultiplier);
-      const impliedPrice = RollercoasterRules.impliedPriceForMultiplier(bet, takeProfitMultiplier);
-
-      expect(RollercoasterRules.evaluateTriggers(bet, impliedPrice, cap)).toEqual({
-        fired: true,
-        reason: { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier },
-      });
-    });
-
-    it('throws if take profit and liquidation would fire on the same tick', () => {
-      // A degenerate takeProfitMultiplier of 0 pushes the TP-implied price down to coincide
-      // exactly with bust — evaluateTriggers doesn't itself validate the multiplier, so this
-      // "unreachable" collision is only actually prevented by isValidTakeProfitMultiplier upstream.
-      const bet = openBet({ takeProfitMultiplier: number(0) });
-
-      expect(() => RollercoasterRules.evaluateTriggers(bet, bet.bustPrice, number(1_000))).toThrow(
-        'RollercoasterRules.evaluateTriggers: take profit and liquidation both fired',
-      );
-    });
-  });
-
-  describe('grossPayoutForReason', () => {
-    const bet = openBet({ leverage: number(10) });
-
-    it('TAKE_PROFIT credits wager × multiplier exactly, ignoring price', () => {
-      const takeProfitMultiplier = number('1.5');
-
-      expect(
-        RollercoasterRules.grossPayoutForReason(bet, { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier }, number(999)),
-      ).toBigNumberEqual(150);
-    });
-
-    it('LIQUIDATION is exact zero regardless of price', () => {
-      expect(RollercoasterRules.grossPayoutForReason(bet, { kind: RollercoasterBetTerminalReason.LIQUIDATION }, number(999))).toBigNumberEqual(0);
-    });
-
-    it('MAX_PAYOUT is exactly the applied cap, ignoring price', () => {
-      const appliedCap = number(150);
-
-      expect(
-        RollercoasterRules.grossPayoutForReason(bet, { kind: RollercoasterBetTerminalReason.MAX_PAYOUT, appliedCap }, number(999)),
-      ).toBigNumberEqual(150);
-    });
-
-    it('CASHOUT and ROUND_END fall back to the price-derived gross payout', () => {
-      const priceDerivedPayout = RollercoasterRules.grossPayoutAtPrice(bet, number(110));
-
-      expect(RollercoasterRules.grossPayoutForReason(bet, { kind: RollercoasterBetTerminalReason.CASHOUT }, number(110))).toBigNumberEqual(
-        priceDerivedPayout,
-      );
-      expect(RollercoasterRules.grossPayoutForReason(bet, { kind: RollercoasterBetTerminalReason.ROUND_END }, number(110))).toBigNumberEqual(
-        priceDerivedPayout,
-      );
-    });
-  });
-
-  describe('multiplierForReason', () => {
-    it('TAKE_PROFIT returns the agreed multiplier, ignoring price', () => {
-      const bet = openBet();
-      const takeProfitMultiplier = number('1.5');
-
-      expect(
-        RollercoasterRules.multiplierForReason(bet, { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier }, number(999)),
-      ).toBigNumberEqual(takeProfitMultiplier);
-    });
-
-    it.each([
-      [RollercoasterDirection.UP, number(101)],
-      [RollercoasterDirection.DOWN, number(99)],
-    ])('every other reason falls back to the price-derived multiplier, independently of wager (%s)', (direction, price) => {
-      const bet = openBet({ direction, amount: number(0) });
-
-      expect(RollercoasterRules.multiplierForReason(bet, { kind: RollercoasterBetTerminalReason.CASHOUT }, price)).toBigNumberEqual(1.1);
-      expect(RollercoasterRules.multiplierForReason(bet, { kind: RollercoasterBetTerminalReason.LIQUIDATION }, price)).toBigNumberEqual(1.1);
-    });
-  });
-
-  describe('netPayout', () => {
-    const wager = number(100);
-
-    it('passes losses and breakeven payouts through untaxed', () => {
-      expect(RollercoasterRules.netPayout(number(90), wager)).toBigNumberEqual(90);
-      expect(RollercoasterRules.netPayout(number(0), wager)).toBigNumberEqual(0);
-      expect(RollercoasterRules.netPayout(wager, wager)).toBigNumberEqual(wager);
-    });
-
-    it('taxes only the profit portion at 5%, never the wager', () => {
-      // gross 101 = wager + 1 profit; only the 1 is taxed, so net = 100 + 0.95 = 100.95
-      expect(RollercoasterRules.netPayout(number(101), wager)).toBigNumberEqual('100.95');
-      // gross 200 = wager + 100 profit; net = 100 + 95 = 195
-      expect(RollercoasterRules.netPayout(number(200), wager)).toBigNumberEqual(195);
-    });
-
-    it('never drops a nominal win below the wager, however small the gross profit is', () => {
-      const net = RollercoasterRules.netPayout(number('100.01'), wager);
-
-      expect(net).toBigNumberGreaterThan(wager);
-    });
-  });
-});

package/src/games/rollercoaster/rollercoaster-rules.ts

@@ -1,217 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { calculatePayoutBN } from '../../utils/calculate-payout';
-import {
-  ROLLERCOASTER_INTERNAL_PRICE_DECIMAL_PLACES,
-  ROLLERCOASTER_MAX_STALE_CLIENT_TICKS,
-  ROLLERCOASTER_MIN_TAKE_PROFIT_MULTIPLIER,
-  ROLLERCOASTER_PROFIT_FEE_RATE,
-  ROLLERCOASTER_ROUND_DURATION_MS,
-  ROLLERCOASTER_ROUND_TICK_COUNT,
-  ROLLERCOASTER_TICK_DURATION_MS,
-  ROLLERCOASTER_TP_MIN_PROXIMITY_TO_BUST,
-  ROLLERCOASTER_TP_MIN_PROXIMITY_TO_ENTRY,
-} from './constants';
-
-export enum RollercoasterDirection {
-  UP = 'UP',
-  DOWN = 'DOWN',
-}
-
-export enum RollercoasterBetTerminalReason {
-  CASHOUT = 'CASHOUT',
-  TAKE_PROFIT = 'TAKE_PROFIT',
-  LIQUIDATION = 'LIQUIDATION',
-  MAX_PAYOUT = 'MAX_PAYOUT',
-  ROUND_END = 'ROUND_END',
-}
-
-export interface RollercoasterOpenBetState {
-  readonly direction: RollercoasterDirection;
-  readonly amount: BigNumber;
-  readonly leverage: BigNumber;
-  readonly entryPrice: BigNumber;
-  readonly entryTick: number;
-  readonly bustPrice: BigNumber;
-  readonly takeProfitMultiplier: BigNumber | null;
-}
-
-export interface RollercoasterTerminalBetState extends RollercoasterOpenBetState {
-  readonly terminalReason: RollercoasterBetTerminalReason;
-  readonly terminalTick: number;
-  readonly terminalPrice: BigNumber;
-  readonly multiplier: BigNumber;
-  readonly grossPayout: BigNumber;
-  readonly netPayout: BigNumber;
-}
-
-export type RollercoasterSettlementReason =
-  | { kind: RollercoasterBetTerminalReason.CASHOUT }
-  | { kind: RollercoasterBetTerminalReason.TAKE_PROFIT; takeProfitMultiplier: BigNumber }
-  | { kind: RollercoasterBetTerminalReason.LIQUIDATION }
-  | { kind: RollercoasterBetTerminalReason.MAX_PAYOUT; appliedCap: BigNumber }
-  | { kind: RollercoasterBetTerminalReason.ROUND_END };
-
-export type RollercoasterTriggerOutcome = { fired: false } | { fired: true; reason: RollercoasterSettlementReason };
-
-export class RollercoasterRules {
-  static bustPrice(entryPrice: BigNumber, leverage: BigNumber, direction: RollercoasterDirection): BigNumber {
-    const offset = entryPrice.dividedBy(leverage);
-    return direction === RollercoasterDirection.UP ? entryPrice.minus(offset) : entryPrice.plus(offset);
-  }
-
-  static position(amount: BigNumber, leverage: BigNumber, direction: RollercoasterDirection): BigNumber {
-    const magnitude = amount.multipliedBy(leverage);
-    return direction === RollercoasterDirection.UP ? magnitude : magnitude.negated();
-  }
-
-  static impliedPriceForMultiplier(
-    bet: Pick<RollercoasterOpenBetState, 'leverage' | 'entryPrice' | 'direction'>,
-    targetMultiplier: BigNumber,
-  ): BigNumber {
-    const directionSign = bet.direction === RollercoasterDirection.UP ? 1 : -1;
-    const multiplierDelta = targetMultiplier.minus(1);
-    const priceChange = BigNumber(directionSign).multipliedBy(multiplierDelta).dividedBy(bet.leverage);
-    return bet.entryPrice.multipliedBy(BigNumber(1).plus(priceChange));
-  }
-
-  static isValidTakeProfitMultiplier(takeProfitMultiplier: BigNumber): boolean {
-    return takeProfitMultiplier.isGreaterThan(ROLLERCOASTER_MIN_TAKE_PROFIT_MULTIPLIER);
-  }
-
-  static isTakeProfitFarEnoughFromEntry(entryPrice: BigNumber, takeProfitImpliedPrice: BigNumber): boolean {
-    return takeProfitImpliedPrice.minus(entryPrice).abs().dividedBy(entryPrice).isGreaterThanOrEqualTo(ROLLERCOASTER_TP_MIN_PROXIMITY_TO_ENTRY);
-  }
-
-  static isTakeProfitFarEnoughFromBust(entryPrice: BigNumber, bustPrice: BigNumber, takeProfitImpliedPrice: BigNumber): boolean {
-    return takeProfitImpliedPrice.minus(bustPrice).abs().dividedBy(entryPrice).isGreaterThanOrEqualTo(ROLLERCOASTER_TP_MIN_PROXIMITY_TO_BUST);
-  }
-
-  static isBustPriceDistinctFromEntry(entryPrice: BigNumber, bustPrice: BigNumber): boolean {
-    return !entryPrice
-      .decimalPlaces(ROLLERCOASTER_INTERNAL_PRICE_DECIMAL_PLACES)
-      .isEqualTo(bustPrice.decimalPlaces(ROLLERCOASTER_INTERNAL_PRICE_DECIMAL_PLACES));
-  }
-
-  static isFinalTick(activeTick: number): boolean {
-    return activeTick >= ROLLERCOASTER_ROUND_TICK_COUNT - 1;
-  }
-
-  static isClientTickWithinMaxLag(activeTick: number, lastSeenTick: number): boolean {
-    return activeTick - lastSeenTick <= ROLLERCOASTER_MAX_STALE_CLIENT_TICKS;
-  }
-
-  static getScheduledRoundId(now: Date, epochMs: number): number {
-    return Math.floor((now.getTime() - epochMs) / ROLLERCOASTER_ROUND_DURATION_MS);
-  }
-
-  static getScheduledRoundStartTime(roundId: number, epochMs: number): Date {
-    return new Date(epochMs + roundId * ROLLERCOASTER_ROUND_DURATION_MS);
-  }
-
-  // Tick N occupies [startedAt + N * ROLLERCOASTER_TICK_DURATION_MS, startedAt + (N + 1) * ROLLERCOASTER_TICK_DURATION_MS).
-  // tickAtOrAfter is the first tick starting at or after the instant; tickBefore is the last tick
-  // starting strictly before it. The two differ only on an exact tick boundary, which is the whole
-  // reason both exist rather than one caller-local `Math.ceil(...) - 1`.
-  static tickAtOrAfter(startedAtMs: number, atMs: number): number {
-    return Math.ceil((atMs - startedAtMs) / ROLLERCOASTER_TICK_DURATION_MS);
-  }
-
-  static tickBefore(startedAtMs: number, atMs: number): number {
-    return RollercoasterRules.tickAtOrAfter(startedAtMs, atMs) - 1;
-  }
-
-  static tickStartTime(startedAtMs: number, tick: number): Date {
-    return new Date(startedAtMs + tick * ROLLERCOASTER_TICK_DURATION_MS);
-  }
-
-  static hasReachedTargetPrice(direction: RollercoasterDirection, currentPrice: BigNumber, targetPrice: BigNumber): boolean {
-    return direction === RollercoasterDirection.UP ? currentPrice.isGreaterThanOrEqualTo(targetPrice) : currentPrice.isLessThanOrEqualTo(targetPrice);
-  }
-
-  static hasReachedBust(direction: RollercoasterDirection, price: BigNumber, bustPrice: BigNumber): boolean {
-    return direction === RollercoasterDirection.UP ? price.isLessThanOrEqualTo(bustPrice) : price.isGreaterThanOrEqualTo(bustPrice);
-  }
-
-  static evaluateTriggers(bet: RollercoasterOpenBetState, tickPrice: BigNumber, liveMaxPayoutCap: BigNumber): RollercoasterTriggerOutcome {
-    const hitBust = RollercoasterRules.hasReachedBust(bet.direction, tickPrice, bet.bustPrice);
-
-    if (bet.takeProfitMultiplier != null) {
-      const takeProfitMultiplier = bet.takeProfitMultiplier;
-      const hitTakeProfit = RollercoasterRules.hasReachedTargetPrice(
-        bet.direction,
-        tickPrice,
-        RollercoasterRules.impliedPriceForMultiplier(bet, takeProfitMultiplier),
-      );
-      if (hitTakeProfit && hitBust) {
-        throw new Error('RollercoasterRules.evaluateTriggers: take profit and liquidation both fired');
-      }
-
-      if (hitTakeProfit) {
-        const reason = { kind: RollercoasterBetTerminalReason.TAKE_PROFIT, takeProfitMultiplier } as const;
-        // A take-profit is the one reason whose payout is a fixed wager × multiplier rather than
-        // something the tick price bounds, and the cap is read live every batch — so it can be
-        // lowered under an already-agreed multiplier. Nothing downstream re-checks it.
-        if (RollercoasterRules.grossPayoutForReason(bet, reason, tickPrice).isGreaterThan(liveMaxPayoutCap)) {
-          return { fired: true, reason: { kind: RollercoasterBetTerminalReason.MAX_PAYOUT, appliedCap: liveMaxPayoutCap } };
-        }
-        return { fired: true, reason };
-      }
-    }
-
-    if (hitBust) {
-      return { fired: true, reason: { kind: RollercoasterBetTerminalReason.LIQUIDATION } };
-    }
-
-    if (RollercoasterRules.grossPayoutAtPrice(bet, tickPrice).isGreaterThanOrEqualTo(liveMaxPayoutCap)) {
-      return { fired: true, reason: { kind: RollercoasterBetTerminalReason.MAX_PAYOUT, appliedCap: liveMaxPayoutCap } };
-    }
-    return { fired: false };
-  }
-
-  static multiplierAtPrice(bet: RollercoasterOpenBetState, price: BigNumber): BigNumber {
-    const directionSign = bet.direction === RollercoasterDirection.UP ? 1 : -1;
-    const percentagePriceChange = price.minus(bet.entryPrice).dividedBy(bet.entryPrice);
-    const leveragedPriceChange = BigNumber(directionSign).multipliedBy(bet.leverage).multipliedBy(percentagePriceChange);
-
-    const multiplier = BigNumber(1).plus(leveragedPriceChange);
-    return BigNumber.maximum(0, multiplier);
-  }
-
-  static grossPayoutAtPrice(bet: RollercoasterOpenBetState, price: BigNumber): BigNumber {
-    const position = RollercoasterRules.position(bet.amount, bet.leverage, bet.direction);
-    const pnl = position.multipliedBy(price.minus(bet.entryPrice)).dividedBy(bet.entryPrice);
-    return BigNumber.maximum(0, bet.amount.plus(pnl));
-  }
-
-  static grossPayoutForReason(bet: RollercoasterOpenBetState, reason: RollercoasterSettlementReason, price: BigNumber): BigNumber {
-    switch (reason.kind) {
-      case RollercoasterBetTerminalReason.TAKE_PROFIT:
-        return calculatePayoutBN(bet.amount, reason.takeProfitMultiplier);
-      case RollercoasterBetTerminalReason.LIQUIDATION:
-        return BigNumber(0);
-      case RollercoasterBetTerminalReason.MAX_PAYOUT:
-        return reason.appliedCap;
-      case RollercoasterBetTerminalReason.CASHOUT:
-      case RollercoasterBetTerminalReason.ROUND_END:
-        return RollercoasterRules.grossPayoutAtPrice(bet, price);
-      default:
-        reason satisfies never;
-        throw new Error(`RollercoasterRules.grossPayoutForReason: unhandled reason`);
-    }
-  }
-
-  static multiplierForReason(bet: RollercoasterOpenBetState, reason: RollercoasterSettlementReason, price: BigNumber): BigNumber {
-    if (reason.kind === RollercoasterBetTerminalReason.TAKE_PROFIT) {
-      return reason.takeProfitMultiplier;
-    }
-    return RollercoasterRules.multiplierAtPrice(bet, price);
-  }
-
-  static netPayout(grossPayout: BigNumber, amount: BigNumber): BigNumber {
-    if (grossPayout.lte(amount)) {
-      return grossPayout;
-    }
-    const profit = grossPayout.minus(amount);
-    return amount.plus(profit.multipliedBy(BigNumber(1).minus(ROLLERCOASTER_PROFIT_FEE_RATE)));
-  }
-}