@actuallyfair/verifier 0.0.6 → 0.0.7

package/dist/generated/context/index.js

@@ -16,45 +16,49 @@ const plinko_1 = require("./plinko");
 const tower_1 = require("./tower");
 function createBaseContext() {
     return {
+        compressedSeed: 0,
+        init: undefined,
+        plinko: undefined,
+        crashDice: undefined,
         fairCoinToss: undefined,
         crash: undefined,
         hilo: undefined,
-        crashDice: undefined,
         multiRoulette: undefined,
         mines: undefined,
         tower: undefined,
-        plinko: undefined,
-        init: undefined,
     };
 }
 exports.Context = {
     encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.fairCoinToss !== undefined) {
-            fair_coin_toss_1.FairCoinToss.encode(message.fairCoinToss, writer.uint32(10).fork()).ldelim();
+        if (message.compressedSeed !== 0) {
+            writer.uint32(13).fixed32(message.compressedSeed);
         }
-        if (message.crash !== undefined) {
-            crash_1.Crash.encode(message.crash, writer.uint32(18).fork()).ldelim();
+        if (message.init !== undefined) {
+            exports.PosthashInit.encode(message.init, writer.uint32(18).fork()).ldelim();
         }
-        if (message.hilo !== undefined) {
-            hilo_1.HiLo.encode(message.hilo, writer.uint32(26).fork()).ldelim();
+        if (message.plinko !== undefined) {
+            plinko_1.Plinko.encode(message.plinko, writer.uint32(26).fork()).ldelim();
         }
         if (message.crashDice !== undefined) {
             crash_dice_1.CrashDice.encode(message.crashDice, writer.uint32(34).fork()).ldelim();
         }
+        if (message.fairCoinToss !== undefined) {
+            fair_coin_toss_1.FairCoinToss.encode(message.fairCoinToss, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.crash !== undefined) {
+            crash_1.Crash.encode(message.crash, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.hilo !== undefined) {
+            hilo_1.HiLo.encode(message.hilo, writer.uint32(58).fork()).ldelim();
+        }
         if (message.multiRoulette !== undefined) {
-            multi_roulette_1.MultiRoulette.encode(message.multiRoulette, writer.uint32(42).fork()).ldelim();
+            multi_roulette_1.MultiRoulette.encode(message.multiRoulette, writer.uint32(66).fork()).ldelim();
         }
         if (message.mines !== undefined) {
-            mines_1.Mines.encode(message.mines, writer.uint32(50).fork()).ldelim();
+            mines_1.Mines.encode(message.mines, writer.uint32(74).fork()).ldelim();
         }
         if (message.tower !== undefined) {
-            tower_1.Tower.encode(message.tower, writer.uint32(58).fork()).ldelim();
-        }
-        if (message.plinko !== undefined) {
-            plinko_1.Plinko.encode(message.plinko, writer.uint32(66).fork()).ldelim();
-        }
-        if (message.init !== undefined) {
-            exports.PosthashInit.encode(message.init, writer.uint32(74).fork()).ldelim();
+            tower_1.Tower.encode(message.tower, writer.uint32(82).fork()).ldelim();
         }
         return writer;
     },
@@ -66,22 +70,22 @@ exports.Context = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag !== 10) {
+                    if (tag !== 13) {
                         break;
                     }
-                    message.fairCoinToss = fair_coin_toss_1.FairCoinToss.decode(reader, reader.uint32());
+                    message.compressedSeed = reader.fixed32();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.crash = crash_1.Crash.decode(reader, reader.uint32());
+                    message.init = exports.PosthashInit.decode(reader, reader.uint32());
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.hilo = hilo_1.HiLo.decode(reader, reader.uint32());
+                    message.plinko = plinko_1.Plinko.decode(reader, reader.uint32());
                     continue;
                 case 4:
                     if (tag !== 34) {
@@ -93,31 +97,37 @@ exports.Context = {
                     if (tag !== 42) {
                         break;
                     }
-                    message.multiRoulette = multi_roulette_1.MultiRoulette.decode(reader, reader.uint32());
+                    message.fairCoinToss = fair_coin_toss_1.FairCoinToss.decode(reader, reader.uint32());
                     continue;
                 case 6:
                     if (tag !== 50) {
                         break;
                     }
-                    message.mines = mines_1.Mines.decode(reader, reader.uint32());
+                    message.crash = crash_1.Crash.decode(reader, reader.uint32());
                     continue;
                 case 7:
                     if (tag !== 58) {
                         break;
                     }
-                    message.tower = tower_1.Tower.decode(reader, reader.uint32());
+                    message.hilo = hilo_1.HiLo.decode(reader, reader.uint32());
                     continue;
                 case 8:
                     if (tag !== 66) {
                         break;
                     }
-                    message.plinko = plinko_1.Plinko.decode(reader, reader.uint32());
+                    message.multiRoulette = multi_roulette_1.MultiRoulette.decode(reader, reader.uint32());
                     continue;
                 case 9:
                     if (tag !== 74) {
                         break;
                     }
-                    message.init = exports.PosthashInit.decode(reader, reader.uint32());
+                    message.mines = mines_1.Mines.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.tower = tower_1.Tower.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -129,19 +139,32 @@ exports.Context = {
     },
     fromJSON(object) {
         return {
+            compressedSeed: isSet(object.compressedSeed) ? globalThis.Number(object.compressedSeed) : 0,
+            init: isSet(object.init) ? exports.PosthashInit.fromJSON(object.init) : undefined,
+            plinko: isSet(object.plinko) ? plinko_1.Plinko.fromJSON(object.plinko) : undefined,
+            crashDice: isSet(object.crashDice) ? crash_dice_1.CrashDice.fromJSON(object.crashDice) : undefined,
             fairCoinToss: isSet(object.fairCoinToss) ? fair_coin_toss_1.FairCoinToss.fromJSON(object.fairCoinToss) : undefined,
             crash: isSet(object.crash) ? crash_1.Crash.fromJSON(object.crash) : undefined,
             hilo: isSet(object.hilo) ? hilo_1.HiLo.fromJSON(object.hilo) : undefined,
-            crashDice: isSet(object.crashDice) ? crash_dice_1.CrashDice.fromJSON(object.crashDice) : undefined,
             multiRoulette: isSet(object.multiRoulette) ? multi_roulette_1.MultiRoulette.fromJSON(object.multiRoulette) : undefined,
             mines: isSet(object.mines) ? mines_1.Mines.fromJSON(object.mines) : undefined,
             tower: isSet(object.tower) ? tower_1.Tower.fromJSON(object.tower) : undefined,
-            plinko: isSet(object.plinko) ? plinko_1.Plinko.fromJSON(object.plinko) : undefined,
-            init: isSet(object.init) ? exports.PosthashInit.fromJSON(object.init) : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
+        if (message.compressedSeed !== 0) {
+            obj.compressedSeed = Math.round(message.compressedSeed);
+        }
+        if (message.init !== undefined) {
+            obj.init = exports.PosthashInit.toJSON(message.init);
+        }
+        if (message.plinko !== undefined) {
+            obj.plinko = plinko_1.Plinko.toJSON(message.plinko);
+        }
+        if (message.crashDice !== undefined) {
+            obj.crashDice = crash_dice_1.CrashDice.toJSON(message.crashDice);
+        }
         if (message.fairCoinToss !== undefined) {
             obj.fairCoinToss = fair_coin_toss_1.FairCoinToss.toJSON(message.fairCoinToss);
         }
@@ -151,9 +174,6 @@ exports.Context = {
         if (message.hilo !== undefined) {
             obj.hilo = hilo_1.HiLo.toJSON(message.hilo);
         }
-        if (message.crashDice !== undefined) {
-            obj.crashDice = crash_dice_1.CrashDice.toJSON(message.crashDice);
-        }
         if (message.multiRoulette !== undefined) {
             obj.multiRoulette = multi_roulette_1.MultiRoulette.toJSON(message.multiRoulette);
         }
@@ -163,12 +183,6 @@ exports.Context = {
         if (message.tower !== undefined) {
             obj.tower = tower_1.Tower.toJSON(message.tower);
         }
-        if (message.plinko !== undefined) {
-            obj.plinko = plinko_1.Plinko.toJSON(message.plinko);
-        }
-        if (message.init !== undefined) {
-            obj.init = exports.PosthashInit.toJSON(message.init);
-        }
         return obj;
     },
     create(base) {
@@ -176,25 +190,26 @@ exports.Context = {
     },
     fromPartial(object) {
         const message = createBaseContext();
+        message.compressedSeed = object.compressedSeed ?? 0;
+        message.init = (object.init !== undefined && object.init !== null)
+            ? exports.PosthashInit.fromPartial(object.init)
+            : undefined;
+        message.plinko = (object.plinko !== undefined && object.plinko !== null)
+            ? plinko_1.Plinko.fromPartial(object.plinko)
+            : undefined;
+        message.crashDice = (object.crashDice !== undefined && object.crashDice !== null)
+            ? crash_dice_1.CrashDice.fromPartial(object.crashDice)
+            : undefined;
         message.fairCoinToss = (object.fairCoinToss !== undefined && object.fairCoinToss !== null)
             ? fair_coin_toss_1.FairCoinToss.fromPartial(object.fairCoinToss)
             : undefined;
         message.crash = (object.crash !== undefined && object.crash !== null) ? crash_1.Crash.fromPartial(object.crash) : undefined;
         message.hilo = (object.hilo !== undefined && object.hilo !== null) ? hilo_1.HiLo.fromPartial(object.hilo) : undefined;
-        message.crashDice = (object.crashDice !== undefined && object.crashDice !== null)
-            ? crash_dice_1.CrashDice.fromPartial(object.crashDice)
-            : undefined;
         message.multiRoulette = (object.multiRoulette !== undefined && object.multiRoulette !== null)
             ? multi_roulette_1.MultiRoulette.fromPartial(object.multiRoulette)
             : undefined;
         message.mines = (object.mines !== undefined && object.mines !== null) ? mines_1.Mines.fromPartial(object.mines) : undefined;
         message.tower = (object.tower !== undefined && object.tower !== null) ? tower_1.Tower.fromPartial(object.tower) : undefined;
-        message.plinko = (object.plinko !== undefined && object.plinko !== null)
-            ? plinko_1.Plinko.fromPartial(object.plinko)
-            : undefined;
-        message.init = (object.init !== undefined && object.init !== null)
-            ? exports.PosthashInit.fromPartial(object.init)
-            : undefined;
         return message;
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actuallyfair/verifier",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/protobuf/context/index.proto

@@ -10,16 +10,18 @@ import "context/tower.proto";
 import "context/plinko.proto";
 
 message Context {
+  fixed32 compressed_seed = 1;
   oneof context_type {
-    FairCoinToss fair_coin_toss = 1;
-    Crash crash = 2;
-    HiLo hilo = 3;
+    PosthashInit init = 2;
+    Plinko plinko = 3;
     CrashDice crash_dice = 4;
-    MultiRoulette multi_roulette = 5;
-    Mines mines = 6;
-    Tower tower = 7;
-    Plinko plinko = 8;
-    PosthashInit init = 9;
+
+    FairCoinToss fair_coin_toss = 5;
+    Crash crash = 6;
+    HiLo hilo = 7;
+    MultiRoulette multi_roulette = 8;
+    Mines mines = 9;
+    Tower tower = 10;
   }
 }
 

package/src/cli/context-codec.ts

@@ -6,10 +6,18 @@ function isMode(value: string | undefined): value is Mode {
   return value === "decode" || value === "encode";
 }
 
-function normalizeBase64(input: string): string {
-  const cleaned = input.replace(/\s+/g, "").replace(/-/g, "+").replace(/_/g, "/");
-  const padding = cleaned.length % 4;
-  return padding === 0 ? cleaned : `${cleaned}${"=".repeat(4 - padding)}`;
+function normalizeHex(input: string): string {
+  const cleaned = input.replace(/\s+/g, "").replace(/^0x/i, "");
+  if (!cleaned) {
+    return cleaned;
+  }
+  if (cleaned.length % 2 !== 0) {
+    throw new Error("Hex input must have an even length.");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(cleaned)) {
+    throw new Error("Hex input contains non-hex characters.");
+  }
+  return cleaned;
 }
 
 function readStdin(): Promise<string> {
@@ -39,15 +47,15 @@ async function readInput(args: string[]): Promise<string> {
 
 function usage(mode?: Mode): string[] {
   if (mode === "decode") {
-    return ["Usage: npm run decode -- <base64>", "       cat context.b64 | npm run decode"];
+    return ["Usage: npm run decode -- <hex>", "       cat context.hex | npm run decode"];
   }
   if (mode === "encode") {
     return ["Usage: npm run encode -- '<json>'", "       cat context.json | npm run encode"];
   }
   return [
-    "Usage: npm run decode -- <base64>",
+    "Usage: npm run decode -- <hex>",
     "       npm run encode -- '<json>'",
-    "       cat context.b64 | npm run decode",
+    "       cat context.hex | npm run decode",
     "       cat context.json | npm run encode",
   ];
 }
@@ -82,8 +90,8 @@ async function main(): Promise<void> {
 
   try {
     if (modeRaw === "decode") {
-      const base64 = normalizeBase64(input);
-      const bytes = Buffer.from(base64, "base64");
+      const hex = normalizeHex(input);
+      const bytes = Buffer.from(hex, "hex");
       const message = Context.decode(bytes);
       const json = Context.toJSON(message);
       process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
@@ -93,7 +101,7 @@ async function main(): Promise<void> {
     const parsed = JSON.parse(input) as unknown;
     const message = Context.fromJSON(parsed);
     const encoded = Context.encode(message).finish();
-    process.stdout.write(`${Buffer.from(encoded).toString("base64")}\n`);
+    process.stdout.write(`${Buffer.from(encoded).toString("hex")}\n`);
   } catch (error) {
     console.error(`Failed to ${modeRaw} context: ${errorMessage(error)}`);
     process.exit(1);

package/src/compute-wager.ts

@@ -15,9 +15,60 @@ import { bytesToHex } from "@noble/hashes/utils";
 import { CrashDice } from "./generated/context/crash-dice";
 import { MultiRoulette } from "./generated/context/multi-roulette";
 
-export function computeFairCoinTossResult(sig: Uint8Array) {
-  // We're going to hash the signature just to really be sure its fairly distributed
-  const hash = sha256(sig);
+export type CompressedSeed = number;
+export type RandomSource = Uint8Array;
+
+export function splitHelixHash(hash: Uint8Array): {
+  lhs: Uint8Array;
+  rhs: Uint8Array;
+} {
+  if (hash.length % 2 !== 0) {
+    throw new Error("Helix hash input must have an even number of bytes.");
+  }
+
+  const mid = hash.length >>> 1;
+  return {
+    lhs: hash.subarray(0, mid),
+    rhs: hash.subarray(mid),
+  };
+}
+
+export function computeCompressedSeed(
+  clientSeed: string,
+  lhsHash: Uint8Array
+): CompressedSeed {
+  const seedHash = hmacSha256(lhsHash, clientSeed);
+  return u32FromHash(seedHash);
+}
+
+export function computeCompressedSeedFromGameHash(
+  clientSeed: string,
+  gameHash: Uint8Array
+): CompressedSeed {
+  const { lhs } = splitHelixHash(gameHash);
+  return computeCompressedSeed(clientSeed, lhs);
+}
+
+export function computeRandomSourceFromCompressedSeed(
+  compressedSeed: CompressedSeed,
+  rhsHash: Uint8Array
+): RandomSource {
+  const seedBytes = u32ToBytes(compressedSeed);
+  return hmacSha256Bytes(rhsHash, seedBytes);
+}
+
+export function computeRandomSource(
+  clientSeed: string,
+  gameHash: Uint8Array
+): RandomSource {
+  const { lhs, rhs } = splitHelixHash(gameHash);
+  const compressedSeed = computeCompressedSeed(clientSeed, lhs);
+  return computeRandomSourceFromCompressedSeed(compressedSeed, rhs);
+}
+
+export function computeFairCoinTossResult(randomSource: RandomSource) {
+  // We're going to hash the random source just to really be sure its fairly distributed
+  const hash = sha256(randomSource);
   const result = hash[0] % 2;
   if (result == 0) {
     return FairCoinToss_Choice.HEADS;
@@ -26,8 +77,11 @@ export function computeFairCoinTossResult(sig: Uint8Array) {
   }
 }
 
-export function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinToss) {
-  const result = computeFairCoinTossResult(sig);
+export function computeFairCoinTossOutcome(
+  randomSource: RandomSource,
+  w: FairCoinToss
+) {
+  const result = computeFairCoinTossResult(randomSource);
 
   const win = w.playerChoice === result;
 
@@ -39,11 +93,11 @@ export function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinToss) {
   };
 }
 
-function doComputeCrashResult(hash: Uint8Array, houseEdge: number) {
+function doComputeCrashResult(randomSource: RandomSource, houseEdge: number) {
   const nBits = 52;
-  const hashHex = bytesToHex(hash);
+  const randomSourceHex = bytesToHex(randomSource);
 
-  const seed = hashHex.slice(0, nBits / 4);
+  const seed = randomSourceHex.slice(0, nBits / 4);
   const r = Number.parseInt(seed, 16);
 
   let X = r / 2 ** nBits; // uniformly distributed in [0; 1)
@@ -72,17 +126,25 @@ export type CrashDiceOutcome = {
   win: boolean;
 };
 
+export function computeCrashDiceResultFromRandomSource(
+  randomSource: RandomSource
+) {
+  const normalized = u32FromHash(randomSource);
+  const max = 2 ** 32;
+  const multiplierTimes100 = Math.floor((100 * max) / (max - normalized));
+  return multiplierTimes100 / 100;
+}
+
 export function computeCrashDiceResult(hash: Uint8Array, clientSeed: string) {
-  const rollHash = hmacSha256(hash, clientSeed);
-  return multiplierFromHash(rollHash);
+  const randomSource = computeRandomSource(clientSeed, hash);
+  return computeCrashDiceResultFromRandomSource(randomSource);
 }
 
-export function computeCrashDiceOutcome(
-  hash: Uint8Array,
-  clientSeed: string,
+export function computeCrashDiceOutcomeFromRandomSource(
+  randomSource: RandomSource,
   bet: CrashDice
 ): CrashDiceOutcome {
-  const multiplier = computeCrashDiceResult(hash, clientSeed);
+  const multiplier = computeCrashDiceResultFromRandomSource(randomSource);
   const target = bet.target;
 
   return {
@@ -92,12 +154,21 @@ export function computeCrashDiceOutcome(
   };
 }
 
+export function computeCrashDiceOutcome(
+  hash: Uint8Array,
+  clientSeed: string,
+  bet: CrashDice
+): CrashDiceOutcome {
+  const randomSource = computeRandomSource(clientSeed, hash);
+  return computeCrashDiceOutcomeFromRandomSource(randomSource, bet);
+}
+
 // returns the index of which roulette outcome was picked
 export function computeMultiRouletteResult(
-  hash: Uint8Array,
+  randomSource: RandomSource,
   bet: MultiRoulette
 ) {
-  const seedHash = sha256(hash);
+  const seedHash = sha256(randomSource);
 
   const nBits = 52;
   const hashHex = bytesToHex(seedHash);
@@ -117,7 +188,7 @@ export function computeMultiRouletteResult(
 }
 
 export function computeMineLocations(
-  hash: Uint8Array,
+  randomSource: RandomSource,
   revealedCells: Set<number>, // tiles we know are safe
   cells: number, // how many cells in total
   mines: number // how many mines there are going to be in total
@@ -134,7 +205,7 @@ export function computeMineLocations(
       break;
     }
 
-    let mineIndex = Number(bytesToNumberBE(hash) % BigInt(cellsLeft));
+    let mineIndex = Number(bytesToNumberBE(randomSource) % BigInt(cellsLeft));
     let adjustedIndex = 0;
 
     for (let i = 0; i < cells; i++) {
@@ -209,7 +280,7 @@ export function computePinkoPossibilityIndexFromPath(path: PlinkoPath) {
 // return a path (saying 'L' or 'R', where 'L' means go left, and 'R' means going right)
 //  of possibilities-1 length
 export function computePlinkoPath(
-  hash: Uint8Array,
+  randomSource: RandomSource,
   possibilities: number
 ): PlinkoPath {
   if (
@@ -219,7 +290,7 @@ export function computePlinkoPath(
   ) {
     throw new Error("invalid possibilities ");
   }
-  const pathHash = sha256(hash);
+  const pathHash = sha256(randomSource);
 
   let n = bytesToNumberBE(pathHash);
 
@@ -272,9 +343,8 @@ export type PlinkoResult = {
   multiplier: number;
 };
 
-export function computePlinkoResult(
-  hash: Uint8Array,
-  clientSeed: string,
+export function computePlinkoResultFromRandomSource(
+  randomSource: RandomSource,
   payouts: number[]
 ): PlinkoResult {
   if (payouts.length < 2) {
@@ -282,8 +352,7 @@ export function computePlinkoResult(
   }
 
   const probabilities = computePlinkoPascalsProbabilities(payouts.length);
-  const rollHash = hmacSha256(hash, clientSeed);
-  const roll = uniformFromHash(rollHash);
+  const roll = uniformFromHash(randomSource);
   const slot = pickSlot(probabilities, roll);
   const multiplier = payouts[slot] ?? 0;
 
@@ -293,29 +362,51 @@ export function computePlinkoResult(
   };
 }
 
+export function computePlinkoResult(
+  hash: Uint8Array,
+  clientSeed: string,
+  payouts: number[]
+): PlinkoResult {
+  const randomSource = computeRandomSource(clientSeed, hash);
+  return computePlinkoResultFromRandomSource(randomSource, payouts);
+}
+
 function hmacSha256(key: Uint8Array, message: string): Uint8Array {
   const data = new TextEncoder().encode(message);
   return hmac(sha256, key, data);
 }
 
-function multiplierFromHash(hash: Uint8Array): number {
-  if (hash.length < 4) {
-    throw new Error("Hash must be at least 4 bytes.");
-  }
+function hmacSha256Bytes(key: Uint8Array, message: Uint8Array): Uint8Array {
+  return hmac(sha256, key, message);
+}
 
-  const value = (hash[0] << 24) | (hash[1] << 16) | (hash[2] << 8) | hash[3];
-  const normalized = value >>> 0;
-  const max = 2 ** 32;
-  const multiplierTimes100 = Math.floor((100 * max) / (max - normalized));
-  return multiplierTimes100 / 100;
+function u32FromHash(randomSource: RandomSource): number {
+  if (randomSource.length < 4) {
+    throw new Error("Random source must be at least 4 bytes.");
+  }
+  return (
+    ((randomSource[0] << 24) |
+      (randomSource[1] << 16) |
+      (randomSource[2] << 8) |
+      randomSource[3]) >>>
+    0
+  );
 }
 
-function uniformFromHash(hash: Uint8Array): number {
-  if (hash.length < 4) {
-    throw new Error("Hash must be at least 4 bytes.");
+function u32ToBytes(value: number): Uint8Array {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
+    throw new Error("Value must be a 32-bit unsigned integer.");
   }
-  const value = (hash[0] << 24) | (hash[1] << 16) | (hash[2] << 8) | hash[3];
-  const normalized = value >>> 0;
+  const buffer = new Uint8Array(4);
+  buffer[0] = (value >>> 24) & 0xff;
+  buffer[1] = (value >>> 16) & 0xff;
+  buffer[2] = (value >>> 8) & 0xff;
+  buffer[3] = value & 0xff;
+  return buffer;
+}
+
+function uniformFromHash(randomSource: RandomSource): number {
+  const normalized = u32FromHash(randomSource);
   return normalized / 2 ** 32;
 }