@actuallyfair/verifier 0.0.5 → 0.0.7

package/src/compute-wager.ts

@@ -14,12 +14,61 @@ import {
 import { bytesToHex } from "@noble/hashes/utils";
 import { CrashDice } from "./generated/context/crash-dice";
 import { MultiRoulette } from "./generated/context/multi-roulette";
-import { getDuelPlinkoPayoutsFromEnum } from "./duel-plinko-payouts";
-import { Plinko } from "./generated/context/plinko";
 
-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;
@@ -28,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;
 
@@ -41,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)
@@ -61,11 +113,11 @@ function doComputeCrashResult(hash: Uint8Array, houseEdge: number) {
 }
 
 export function computeCrashResult(
-  vxSignature: Uint8Array,
+  hash: Uint8Array,
   gameHash: Uint8Array, // This is the hash of the next from the hash chain
   houseEdge: number = 0
 ) {
-  return doComputeCrashResult(hmac(sha256, vxSignature, gameHash), houseEdge);
+  return doComputeCrashResult(hmac(sha256, hash, gameHash), houseEdge);
 }
 
 export type CrashDiceOutcome = {
@@ -74,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 {
@@ -94,15 +154,24 @@ 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(
-  vxSignature: Uint8Array,
+  randomSource: RandomSource,
   bet: MultiRoulette
 ) {
-  const hash = sha256(vxSignature);
+  const seedHash = sha256(randomSource);
 
   const nBits = 52;
-  const hashHex = bytesToHex(hash);
+  const hashHex = bytesToHex(seedHash);
   const seed = hashHex.slice(0, nBits / 4);
   const n = Number.parseInt(seed, 16);
 
@@ -119,7 +188,7 @@ export function computeMultiRouletteResult(
 }
 
 export function computeMineLocations(
-  vxSignature: 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
@@ -136,7 +205,7 @@ export function computeMineLocations(
       break;
     }
 
-    let mineIndex = Number(bytesToNumberBE(vxSignature) % BigInt(cellsLeft));
+    let mineIndex = Number(bytesToNumberBE(randomSource) % BigInt(cellsLeft));
     let adjustedIndex = 0;
 
     for (let i = 0; i < cells; i++) {
@@ -211,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(
-  vxSignature: Uint8Array,
+  randomSource: RandomSource,
   possibilities: number
 ): PlinkoPath {
   if (
@@ -221,9 +290,9 @@ export function computePlinkoPath(
   ) {
     throw new Error("invalid possibilities ");
   }
-  const hash = sha256(vxSignature);
+  const pathHash = sha256(randomSource);
 
-  let n = bytesToNumberBE(hash);
+  let n = bytesToNumberBE(pathHash);
 
   let ret: ("L" | "R")[] = [];
   for (let i = 0; i < possibilities - 1; i++) {
@@ -259,12 +328,12 @@ export function computePlinkoPascalsProbabilities(rowNumber: number) {
   return lastRow.map((v) => v / sum);
 }
 
-export function computePlinkoHouseEdge(possibilities: number[]) {
-  const odds = computePlinkoPascalsProbabilities(possibilities.length);
+export function computePlinkoHouseEdge(payouts: number[]) {
+  const odds = computePlinkoPascalsProbabilities(payouts.length);
 
   let ev = 1; // you start off by betting everything
-  for (let i = 0; i < possibilities.length; i++) {
-    ev -= possibilities[i] * odds[i];
+  for (let i = 0; i < payouts.length; i++) {
+    ev -= payouts[i] * odds[i];
   }
   return ev;
 }
@@ -272,44 +341,34 @@ export function computePlinkoHouseEdge(possibilities: number[]) {
 export type PlinkoResult = {
   slot: number;
   multiplier: number;
-  win: boolean;
 };
 
-export function computePlinkoResult(
-  hash: Uint8Array,
-  clientSeed: string,
-  bet: Plinko
+export function computePlinkoResultFromRandomSource(
+  randomSource: RandomSource,
+  payouts: number[]
 ): PlinkoResult {
-  const possibilities = resolvePlinkoPayouts(bet);
-  if (possibilities.length < 2) {
+  if (payouts.length < 2) {
     throw new Error("invalid possibilities ");
   }
 
-  const probabilities = computePlinkoPascalsProbabilities(possibilities.length);
-  const rollHash = hmacSha256(hash, clientSeed);
-  const roll = uniformFromHash(rollHash);
+  const probabilities = computePlinkoPascalsProbabilities(payouts.length);
+  const roll = uniformFromHash(randomSource);
   const slot = pickSlot(probabilities, roll);
-  const multiplier = possibilities[slot] ?? 0;
+  const multiplier = payouts[slot] ?? 0;
 
   return {
     slot,
     multiplier,
-    win: multiplier >= 1,
   };
 }
 
-function resolvePlinkoPayouts(bet: Plinko): number[] {
-  const payouts = bet.payouts;
-  if (!payouts) {
-    return [];
-  }
-  if (payouts.duel) {
-    return getDuelPlinkoPayoutsFromEnum(payouts.duel.rows, payouts.duel.risk);
-  }
-  if (payouts.custom) {
-    return payouts.custom.possibilities;
-  }
-  return [];
+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 {
@@ -317,24 +376,37 @@ function hmacSha256(key: Uint8Array, message: string): Uint8Array {
   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;
 }