shufflecom-calculations 3.3.12 → 3.3.14

package/lib/utils/chain-currency-display.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChainLabel = exports.getCurrencyLabel = void 0;
 const CURRENCY_DISPLAY_LABEL = {
-    MATIC: 'POL'
+    MATIC: 'POL',
+    TON: 'GRAM',
 };
 const getCurrencyLabel = (currency) => {
     var _a;
@@ -10,7 +11,8 @@ const getCurrencyLabel = (currency) => {
 };
 exports.getCurrencyLabel = getCurrencyLabel;
 const CHAIN_DISPLAY_LABEL = {
-    MATIC_POLYGON: 'POLYGON'
+    MATIC_POLYGON: 'POLYGON',
+    TON: 'GRAM',
 };
 const getChainLabel = (chain) => {
     var _a;

package/lib/utils/chain-currency-display.js.map

@@ -1 +1 @@
-{"version":3,"file":"chain-currency-display.js","sourceRoot":"","sources":["../../src/utils/chain-currency-display.ts"],"names":[],"mappings":";;;AAGA,MAAM,sBAAsB,GAAsC;IAChE,KAAK,EAAE,KAAK;CACb,CAAA;AAGM,MAAM,gBAAgB,GAAG,CAAC,QAA2B,EAAU,EAAE;;IACtE,OAAO,MAAA,sBAAsB,CAAC,QAAQ,CAAC,mCAAI,QAAQ,CAAC;AACtD,CAAC,CAAA;AAFY,QAAA,gBAAgB,oBAE5B;AAED,MAAM,mBAAmB,GAAmC;IAC1D,aAAa,EAAE,SAAS;CACzB,CAAA;AAEM,MAAM,aAAa,GAAG,CAAC,KAAqB,EAAU,EAAE;;IAC7D,OAAO,MAAA,mBAAmB,CAAC,KAAK,CAAC,mCAAI,KAAK,CAAC;AAC7C,CAAC,CAAA;AAFY,QAAA,aAAa,iBAEzB"}
+{"version":3,"file":"chain-currency-display.js","sourceRoot":"","sources":["../../src/utils/chain-currency-display.ts"],"names":[],"mappings":";;;AAGA,MAAM,sBAAsB,GAAsC;IAChE,KAAK,EAAE,KAAK;IACZ,GAAG,EAAE,MAAM;CACZ,CAAA;AAGM,MAAM,gBAAgB,GAAG,CAAC,QAA2B,EAAU,EAAE;;IACtE,OAAO,MAAA,sBAAsB,CAAC,QAAQ,CAAC,mCAAI,QAAQ,CAAC;AACtD,CAAC,CAAA;AAFY,QAAA,gBAAgB,oBAE5B;AAED,MAAM,mBAAmB,GAAmC;IAC1D,aAAa,EAAE,SAAS;IACxB,GAAG,EAAE,MAAM;CACZ,CAAA;AAEM,MAAM,aAAa,GAAG,CAAC,KAAqB,EAAU,EAAE;;IAC7D,OAAO,MAAA,mBAAmB,CAAC,KAAK,CAAC,mCAAI,KAAK,CAAC;AAC7C,CAAC,CAAA;AAFY,QAAA,aAAa,iBAEzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shufflecom-calculations",
-  "version": "3.3.12",
+  "version": "3.3.14",
   "description": "",
   "types": "lib/index.d.ts",
   "main": "lib/index.js",
@@ -14,5 +14,5 @@
   },
   "author": "",
   "license": "ISC",
-  "gitHead": "72c940719346f25366185d52c9742917410bffa7"
+  "gitHead": "1ee974fa20540765a0bed2a70ca07123b065937d"
 }

package/src/games/coinflip/coinflip-classic-progressive.spec.ts

@@ -0,0 +1,251 @@
+import BigNumber from 'bignumber.js';
+import { FixedSequenceRng } from '../fixed-rng';
+import {
+  CoinflipClassicProgressive,
+  CoinflipProgressiveCashoutAction,
+  CoinflipProgressiveCoinSelectionAction,
+  CoinflipProgressiveStartAction,
+} from './coinflip-classic-progressive';
+import { CoinSide, MAX_FLIPS } from './constants';
+
+const EDGE_BPS = 200;
+
+const getCoinRngValue = (side: CoinSide) => (side === CoinSide.HEADS ? 0 : 1);
+
+const startAction = (): CoinflipProgressiveStartAction => ({ phase: 'START' });
+const winAction = (side: CoinSide): CoinflipProgressiveCoinSelectionAction => ({
+  phase: 'COIN_SELECTION',
+  selectedSide: side,
+  flipResult: side,
+  multiplier: new BigNumber(0),
+});
+const cashoutAction = (multiplier = 1.96): CoinflipProgressiveCashoutAction => ({
+  phase: 'CASHOUT',
+  multiplier: new BigNumber(multiplier),
+});
+
+const gameWithWins = (wins: number) =>
+  CoinflipClassicProgressive.fromActions([startAction(), ...Array.from({ length: wins }, () => winAction(CoinSide.HEADS))]);
+
+describe('CoinflipClassicProgressive.createAction', () => {
+  it('returns a START action', () => {
+    expect(CoinflipClassicProgressive.createAction()).toEqual({ phase: 'START' });
+  });
+});
+
+describe('CoinflipClassicProgressive.fromActions', () => {
+  describe('empty history', () => {
+    it('returns a game with flipsRevealed = 0', () => {
+      const game = CoinflipClassicProgressive.fromActions([]);
+      expect(game.canCashout()).toBe(false);
+    });
+  });
+
+  describe('valid histories', () => {
+    it('a start-only history cannot be cashed out', () => {
+      expect(CoinflipClassicProgressive.fromActions([startAction()]).canCashout()).toBe(false);
+    });
+
+    it('accumulates winning actions into cashout eligibility', () => {
+      expect(gameWithWins(3).canCashout()).toBe(true);
+    });
+
+    it('accepts flips won on different sides', () => {
+      const game = CoinflipClassicProgressive.fromActions([startAction(), winAction(CoinSide.HEADS), winAction(CoinSide.TAILS)]);
+      expect(game.canCashout()).toBe(true);
+    });
+
+    it('throws when reconstructed from an already cashed-out history', () => {
+      expect(() =>
+        CoinflipClassicProgressive.fromActions([startAction(), winAction(CoinSide.HEADS), winAction(CoinSide.HEADS), cashoutAction(3.92)]),
+      ).toThrow('An active game cannot have a CASHOUT action');
+    });
+  });
+
+  describe('validation errors', () => {
+    it('throws when the first action is not START', () => {
+      expect(() => CoinflipClassicProgressive.fromActions([winAction(CoinSide.HEADS)])).toThrow('First action must be START');
+    });
+
+    it('throws when a START action appears after the first position', () => {
+      expect(() => CoinflipClassicProgressive.fromActions([startAction(), winAction(CoinSide.HEADS), startAction()])).toThrow(
+        'START action can only appear as the first action',
+      );
+    });
+
+    it('throws when a COIN_SELECTION has mismatched flipResult', () => {
+      const badWinAction: CoinflipProgressiveCoinSelectionAction = {
+        phase: 'COIN_SELECTION',
+        selectedSide: CoinSide.HEADS,
+        flipResult: CoinSide.TAILS,
+        multiplier: new BigNumber(0),
+      };
+      expect(() => CoinflipClassicProgressive.fromActions([startAction(), badWinAction])).toThrow(
+        'COIN_SELECTION must have matching flipResult and selectedSide',
+      );
+    });
+
+    it('throws when CASHOUT appears before any wins', () => {
+      expect(() => CoinflipClassicProgressive.fromActions([startAction(), cashoutAction()])).toThrow('An active game cannot have a CASHOUT action');
+    });
+
+    it('throws when the history contains more than MAX_FLIPS flips', () => {
+      const tooManyWins = Array.from({ length: MAX_FLIPS + 1 }, () => winAction(CoinSide.HEADS));
+      expect(() => CoinflipClassicProgressive.fromActions([startAction(), ...tooManyWins])).toThrow(
+        `Reconstructed flipsRevealed (${MAX_FLIPS + 1}) exceeds MAX_FLIPS (${MAX_FLIPS})`,
+      );
+    });
+  });
+});
+
+describe('CoinflipClassicProgressive.next', () => {
+  it('a winning first flip pays 1.96x and keeps the game open', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS)]);
+    expect(gameWithWins(0).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1.96),
+      isWin: true,
+      isComplete: false,
+      gameAction: {
+        phase: 'COIN_SELECTION',
+        selectedSide: CoinSide.HEADS,
+        flipResult: CoinSide.HEADS,
+        multiplier: new BigNumber(1.96),
+      },
+    });
+  });
+
+  it('a losing flip zeroes the multiplier and completes the game', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.TAILS)]);
+    expect(gameWithWins(0).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(0),
+      isWin: false,
+      isComplete: true,
+      gameAction: {
+        phase: 'COIN_SELECTION',
+        selectedSide: CoinSide.HEADS,
+        flipResult: CoinSide.TAILS,
+        multiplier: new BigNumber(0),
+      },
+    });
+  });
+
+  it('a loss deep into a streak still pays zero', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS)]);
+    expect(gameWithWins(5).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(0),
+      isWin: false,
+      isComplete: true,
+      gameAction: { flipResult: CoinSide.TAILS },
+    });
+  });
+
+  it('reveals the last drawn value as the new flip', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.TAILS), getCoinRngValue(CoinSide.TAILS), getCoinRngValue(CoinSide.HEADS)]);
+    expect(gameWithWins(2).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(7.84),
+      gameAction: { flipResult: CoinSide.HEADS },
+    });
+  });
+
+  it('allows switching sides between flips', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS)]);
+    const game = CoinflipClassicProgressive.fromActions([startAction(), winAction(CoinSide.HEADS)]);
+    expect(game.next(CoinSide.TAILS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(3.92),
+      isWin: true,
+      gameAction: { selectedSide: CoinSide.TAILS, flipResult: CoinSide.TAILS },
+    });
+  });
+
+  it('a win on the final flip completes the game at the top multiplier', () => {
+    const rng = new FixedSequenceRng(Array(MAX_FLIPS).fill(CoinSide.HEADS).map(getCoinRngValue));
+    expect(gameWithWins(MAX_FLIPS - 1).next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1027604.48),
+      isWin: true,
+      isComplete: true,
+    });
+  });
+
+  it('works from an empty history (no start action persisted)', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS)]);
+    const game = CoinflipClassicProgressive.fromActions([]);
+    expect(game.next(CoinSide.HEADS, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1.96),
+      isWin: true,
+      isComplete: false,
+      gameAction: { phase: 'COIN_SELECTION', selectedSide: CoinSide.HEADS, flipResult: CoinSide.HEADS },
+    });
+  });
+
+  it('throws when MAX_FLIPS are already revealed', () => {
+    const rng = new FixedSequenceRng(Array(MAX_FLIPS + 1).fill(CoinSide.HEADS).map(getCoinRngValue));
+    expect(() => gameWithWins(MAX_FLIPS).next(CoinSide.HEADS, rng, EDGE_BPS)).toThrow();
+  });
+});
+
+describe('CoinflipClassicProgressive.cashout', () => {
+  it.each([
+    [1, 1.96],
+    [2, 3.92],
+    [3, 7.84],
+    [MAX_FLIPS, 1027604.48],
+  ])('cashing out after %i wins pays %fx', (wins, expected) => {
+    expect(gameWithWins(wins).cashout(EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(expected),
+      gameAction: {
+        phase: 'CASHOUT',
+        multiplier: new BigNumber(expected),
+      },
+    });
+  });
+
+  it('throws with zero revealed flips', () => {
+    expect(() => gameWithWins(0).cashout(EDGE_BPS)).toThrow();
+  });
+});
+
+describe('CoinflipClassicProgressive.autobet', () => {
+  it('wins and pays the N-flip classic multiplier when all sides match', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS)]);
+    expect(CoinflipClassicProgressive.autobet([CoinSide.HEADS, CoinSide.HEADS, CoinSide.TAILS], rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(7.84),
+      selectedSides: [CoinSide.HEADS, CoinSide.HEADS, CoinSide.TAILS],
+      flipResults: [CoinSide.HEADS, CoinSide.HEADS, CoinSide.TAILS],
+    });
+  });
+
+  it('loses with zero multiplier when a flip mismatches', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS), getCoinRngValue(CoinSide.HEADS)]);
+    expect(CoinflipClassicProgressive.autobet([CoinSide.HEADS, CoinSide.HEADS, CoinSide.HEADS], rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(0),
+    });
+  });
+
+  it('pads flipResults to full length even after an early loss', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS), getCoinRngValue(CoinSide.HEADS)]);
+    const { flipResults } = CoinflipClassicProgressive.autobet([CoinSide.HEADS, CoinSide.HEADS, CoinSide.HEADS], rng, EDGE_BPS);
+    expect(flipResults).toHaveLength(3);
+    expect(flipResults).toEqual([CoinSide.HEADS, CoinSide.TAILS, CoinSide.HEADS]);
+  });
+
+  it('uses the same provably-fair RNG scheme as manual next() — flip i uses value at index i', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS), getCoinRngValue(CoinSide.TAILS), getCoinRngValue(CoinSide.HEADS)]);
+    const { flipResults } = CoinflipClassicProgressive.autobet([CoinSide.HEADS, CoinSide.TAILS, CoinSide.HEADS], rng, EDGE_BPS);
+    expect(flipResults).toEqual([CoinSide.HEADS, CoinSide.TAILS, CoinSide.HEADS]);
+  });
+
+  it('a single-flip autobet matches classic payout', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS)]);
+    expect(CoinflipClassicProgressive.autobet([CoinSide.HEADS], rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1.96),
+      flipResults: [CoinSide.HEADS],
+    });
+  });
+
+  it('all MAX_FLIPS correct pays the top multiplier', () => {
+    const rng = new FixedSequenceRng(Array(MAX_FLIPS).fill(CoinSide.HEADS).map(getCoinRngValue));
+    const { multiplier, flipResults } = CoinflipClassicProgressive.autobet(Array(MAX_FLIPS).fill(CoinSide.HEADS), rng, EDGE_BPS);
+    expect(multiplier).toEqual(new BigNumber(1027604.48));
+    expect(flipResults).toHaveLength(MAX_FLIPS);
+  });
+});

package/src/games/coinflip/coinflip-classic-progressive.ts

@@ -0,0 +1,108 @@
+import BigNumber from 'bignumber.js';
+import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { CoinflipRules } from './coinflip-rules';
+import { CoinSide, MAX_FLIPS } from './constants';
+
+export interface CoinflipProgressiveStartAction {
+  phase: 'START';
+}
+
+export interface CoinflipProgressiveCoinSelectionAction {
+  phase: 'COIN_SELECTION';
+  selectedSide: CoinSide;
+  flipResult: CoinSide;
+  multiplier: BigNumber;
+}
+
+export interface CoinflipProgressiveCashoutAction {
+  phase: 'CASHOUT';
+  multiplier: BigNumber;
+}
+
+export type CoinflipClassicProgressiveGameAction =
+  | CoinflipProgressiveStartAction
+  | CoinflipProgressiveCoinSelectionAction
+  | CoinflipProgressiveCashoutAction;
+
+export interface CoinflipClassicProgressiveNextResult {
+  multiplier: BigNumber;
+  gameAction: CoinflipProgressiveCoinSelectionAction;
+  isWin: boolean;
+  isComplete: boolean;
+}
+
+export interface CoinflipClassicProgressiveGameResult {
+  multiplier: BigNumber;
+  gameAction: CoinflipProgressiveCashoutAction;
+}
+
+export interface CoinflipClassicProgressiveAutoBetResult {
+  multiplier: BigNumber;
+  selectedSides: CoinSide[];
+  flipResults: CoinSide[];
+}
+
+export class CoinflipClassicProgressive {
+  private constructor(private readonly flipsRevealed: number) {}
+
+  public static createAction(): CoinflipProgressiveStartAction {
+    return { phase: 'START' };
+  }
+
+  public static fromActions(gameActions: CoinflipClassicProgressiveGameAction[]): CoinflipClassicProgressive {
+    if (gameActions.length === 0) {
+      return new CoinflipClassicProgressive(0);
+    }
+
+    const flipsRevealed = CoinflipRules.validateActiveProgressiveClassicGame(gameActions);
+    return new CoinflipClassicProgressive(flipsRevealed);
+  }
+
+  public canCashout(): boolean {
+    return this.flipsRevealed > 0;
+  }
+
+  public next(selectedSide: CoinSide, generator: RandomNumberGenerator, edge: number): CoinflipClassicProgressiveNextResult {
+    const newFlip = CoinflipRules.getFlipResultAtPosition(generator, this.flipsRevealed + 1);
+    const isWin = CoinflipRules.isFlipWin(selectedSide, newFlip);
+
+    const revealedAfter = isWin ? this.flipsRevealed + 1 : this.flipsRevealed;
+    const isComplete = !isWin || revealedAfter >= MAX_FLIPS;
+    const multiplier = isWin ? CoinflipRules.calculateClassicMultiplier(revealedAfter, edge) : BigNumber(0);
+
+    return {
+      multiplier,
+      gameAction: {
+        phase: 'COIN_SELECTION',
+        selectedSide,
+        flipResult: newFlip,
+        multiplier,
+      },
+      isWin,
+      isComplete,
+    };
+  }
+
+  public static autobet(selectedSides: CoinSide[], generator: RandomNumberGenerator, edge: number): CoinflipClassicProgressiveAutoBetResult {
+    const pairs = selectedSides.map((selectedSide, i) => {
+      return { selectedSide, result: CoinflipRules.getFlipResultAtPosition(generator, i + 1) };
+    });
+
+    const won = CoinflipRules.countSuccessfulFlips(pairs) === selectedSides.length;
+    const multiplier = won ? CoinflipRules.calculateClassicMultiplier(selectedSides.length, edge) : BigNumber(0);
+    return { multiplier, selectedSides, flipResults: pairs.map(p => p.result) };
+  }
+
+  public cashout(edge: number): CoinflipClassicProgressiveGameResult {
+    if (!this.canCashout()) {
+      throw new Error('cashout called with no flips revealed');
+    }
+
+    const multiplier = CoinflipRules.calculateClassicMultiplier(this.flipsRevealed, edge);
+
+    return {
+      multiplier,
+      gameAction: { phase: 'CASHOUT', multiplier },
+    };
+  }
+}

package/src/games/coinflip/coinflip-classic.spec.ts

@@ -0,0 +1,46 @@
+import BigNumber from 'bignumber.js';
+import { FixedSequenceRng } from '../fixed-rng';
+import { CoinflipClassic } from './coinflip-classic';
+import { CoinSide } from './constants';
+
+const EDGE_BPS = 200;
+
+const getCoinRngValue = (side: CoinSide) => (side === CoinSide.HEADS ? 0 : 1);
+
+describe('CoinflipClassic.resolve', () => {
+  it('matching flip wins 1.96x', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.HEADS)]);
+    expect(CoinflipClassic.resolve({ selectedSide: CoinSide.HEADS }, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1.96),
+      action: {
+        selectedSide: CoinSide.HEADS,
+        flipResult: CoinSide.HEADS,
+        multiplier: new BigNumber(1.96),
+      },
+    });
+  });
+
+  it('wins on tails when tails is selected', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.TAILS)]);
+    expect(CoinflipClassic.resolve({ selectedSide: CoinSide.TAILS }, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(1.96),
+      action: {
+        selectedSide: CoinSide.TAILS,
+        flipResult: CoinSide.TAILS,
+        multiplier: new BigNumber(1.96),
+      },
+    });
+  });
+
+  it('mismatched flip loses with zero multiplier', () => {
+    const rng = new FixedSequenceRng([getCoinRngValue(CoinSide.TAILS)]);
+    expect(CoinflipClassic.resolve({ selectedSide: CoinSide.HEADS }, rng, EDGE_BPS)).toMatchObject({
+      multiplier: new BigNumber(0),
+      action: {
+        selectedSide: CoinSide.HEADS,
+        flipResult: CoinSide.TAILS,
+        multiplier: new BigNumber(0),
+      },
+    });
+  });
+});

package/src/games/coinflip/coinflip-classic.ts

@@ -0,0 +1,37 @@
+import BigNumber from 'bignumber.js';
+import { RandomNumberGenerator } from '../random-number-generator.interface';
+import { CoinflipRules } from './coinflip-rules';
+import { CoinSide } from './constants';
+
+export interface CoinflipClassicConfig {
+  selectedSide: CoinSide;
+}
+
+export interface CoinflipClassicAction {
+  selectedSide: CoinSide;
+  flipResult: CoinSide;
+  multiplier: BigNumber;
+}
+
+export interface CoinflipClassicGameResult {
+  multiplier: BigNumber;
+  action: CoinflipClassicAction;
+}
+
+export class CoinflipClassic {
+  public static resolve(config: CoinflipClassicConfig, generator: RandomNumberGenerator, edge: number): CoinflipClassicGameResult {
+    const flip = CoinflipRules.getFlipResultAtPosition(generator, 1);
+    const isWin = CoinflipRules.isFlipWin(config.selectedSide, flip);
+
+    const multiplier = isWin ? CoinflipRules.calculateClassicMultiplier(1, edge) : BigNumber(0);
+
+    return {
+      multiplier,
+      action: {
+        selectedSide: config.selectedSide,
+        flipResult: flip,
+        multiplier,
+      },
+    };
+  }
+}

package/src/games/coinflip/coinflip-ev.spec.ts

@@ -0,0 +1,60 @@
+import BigNumber from 'bignumber.js';
+import { CoinflipRules } from './coinflip-rules';
+import { MAX_FLIPS } from './constants';
+
+const EDGE_BPS = 200;
+const EXPECTED_EV = 1 - EDGE_BPS / 10000;
+
+// successCounts[n][k] = number of n-flip outcomes with exactly k successes (row n of Pascal's triangle).
+// Built once by brute-force enumeration, independent of the nCr formula under test.
+function buildSuccessCounts(maxFlips: number): number[][] {
+  const counts: number[][] = [];
+  for (let n = 0; n <= maxFlips; n++) {
+    const histogram = new Array<number>(n + 1).fill(0);
+    const total = 2 ** n;
+    for (let outcome = 0; outcome < total; outcome++) {
+      const successes = outcome
+        .toString(2)
+        .split('')
+        .filter(bit => bit === '1').length;
+      histogram[successes]++;
+    }
+    counts[n] = histogram;
+  }
+  return counts;
+}
+
+const SUCCESS_COUNTS = buildSuccessCounts(MAX_FLIPS);
+
+describe('CoinflipRules.calculateClassicMultiplier empirical EV', () => {
+  for (let flips = 1; flips <= MAX_FLIPS; flips++) {
+    it(`n=${flips}: EV across all 2^${flips} outcomes equals 1 - edge`, () => {
+      const total = 2 ** flips;
+      const wins = SUCCESS_COUNTS[flips][flips];
+
+      const multiplier = CoinflipRules.calculateClassicMultiplier(flips, EDGE_BPS);
+      const ev = BigNumber(wins).dividedBy(total).multipliedBy(multiplier);
+
+      expect(ev.toNumber()).toBeCloseTo(EXPECTED_EV, 10);
+    });
+  }
+});
+
+describe('CoinflipRules.calculateTargetMultiplier empirical EV', () => {
+  for (let flips = 1; flips <= MAX_FLIPS; flips++) {
+    for (let minSuccesses = 1; minSuccesses <= flips; minSuccesses++) {
+      it(`n=${flips} minSuccesses=${minSuccesses}: EV equals 1 - edge`, () => {
+        const total = 2 ** flips;
+        let wins = 0;
+        for (let k = minSuccesses; k <= flips; k++) {
+          wins += SUCCESS_COUNTS[flips][k];
+        }
+
+        const multiplier = CoinflipRules.calculateTargetMultiplier(flips, minSuccesses, EDGE_BPS);
+        const ev = BigNumber(wins).dividedBy(total).multipliedBy(multiplier);
+
+        expect(ev.toNumber()).toBeCloseTo(EXPECTED_EV, 10);
+      });
+    }
+  }
+});