@actuallyfair/verifier 0.0.6 → 0.0.8

package/dist/cli/context-codec.js

@@ -4,10 +4,18 @@ const context_1 = require("../generated/context");
 function isMode(value) {
     return value === "decode" || value === "encode";
 }
-function normalizeBase64(input) {
-    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) {
+    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() {
     return new Promise((resolve, reject) => {
@@ -32,15 +40,15 @@ async function readInput(args) {
 }
 function usage(mode) {
     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",
     ];
 }
@@ -70,8 +78,8 @@ async function main() {
     }
     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_1.Context.decode(bytes);
             const json = context_1.Context.toJSON(message);
             process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
@@ -80,7 +88,7 @@ async function main() {
         const parsed = JSON.parse(input);
         const message = context_1.Context.fromJSON(parsed);
         const encoded = context_1.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)}`);

package/dist/compute-wager.d.ts

@@ -1,9 +1,18 @@
 import { Currency } from "./generated/currency";
 import { FairCoinToss, FairCoinToss_Choice } from "./generated/context/fair-coin-toss";
-import { CrashDice } from "./generated/context/crash-dice";
 import { MultiRoulette } from "./generated/context/multi-roulette";
-export declare function computeFairCoinTossResult(sig: Uint8Array): FairCoinToss_Choice.HEADS | FairCoinToss_Choice.TAILS;
-export declare function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinToss): {
+export type CompressedSeed = number;
+export type RandomSource = Uint8Array;
+export declare function splitHelixHash(hash: Uint8Array): {
+    lhs: Uint8Array;
+    rhs: Uint8Array;
+};
+export declare function computeCompressedSeed(clientSeed: string, lhsHash: Uint8Array): CompressedSeed;
+export declare function computeCompressedSeedFromGameHash(clientSeed: string, gameHash: Uint8Array): CompressedSeed;
+export declare function computeRandomSourceFromCompressedSeed(compressedSeed: CompressedSeed, rhsHash: Uint8Array): RandomSource;
+export declare function computeRandomSource(clientSeed: string, gameHash: Uint8Array): RandomSource;
+export declare function computeFairCoinTossResult(randomSource: RandomSource): FairCoinToss_Choice.HEADS | FairCoinToss_Choice.TAILS;
+export declare function computeFairCoinTossOutcome(randomSource: RandomSource, w: FairCoinToss): {
     result: FairCoinToss_Choice;
     playerProfit: {
         currency: Currency;
@@ -12,15 +21,9 @@ export declare function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinT
 };
 export declare function computeCrashResult(hash: Uint8Array, gameHash: Uint8Array, // This is the hash of the next from the hash chain
 houseEdge?: number): number;
-export type CrashDiceOutcome = {
-    multiplier: number;
-    target: number;
-    win: boolean;
-};
-export declare function computeCrashDiceResult(hash: Uint8Array, clientSeed: string): number;
-export declare function computeCrashDiceOutcome(hash: Uint8Array, clientSeed: string, bet: CrashDice): CrashDiceOutcome;
-export declare function computeMultiRouletteResult(hash: Uint8Array, bet: MultiRoulette): number | undefined;
-export declare function computeMineLocations(hash: Uint8Array, revealedCells: Set<number>, // tiles we know are safe
+export declare function computeCrashDiceResult(randomSource: RandomSource, houseEdge: number): number;
+export declare function computeMultiRouletteResult(randomSource: RandomSource, bet: MultiRoulette): number | undefined;
+export declare function computeMineLocations(randomSource: RandomSource, revealedCells: Set<number>, // tiles we know are safe
 cells: number, // how many cells in total
 mines: number): Set<number>;
 export declare function computeMinesMultiplier(mines: number, // how many mines in the game
@@ -29,12 +32,13 @@ turn: number, // which turn they have finished
 houseEdge?: number): number;
 type PlinkoPath = ("L" | "R")[];
 export declare function computePinkoPossibilityIndexFromPath(path: PlinkoPath): number;
-export declare function computePlinkoPath(hash: Uint8Array, possibilities: number): PlinkoPath;
+export declare function computePlinkoPath(randomSource: RandomSource, possibilities: number): PlinkoPath;
 export declare function computePlinkoPascalsProbabilities(rowNumber: number): number[];
 export declare function computePlinkoHouseEdge(payouts: number[]): number;
 export type PlinkoResult = {
     slot: number;
     multiplier: number;
 };
+export declare function computePlinkoResultFromRandomSource(randomSource: RandomSource, payouts: number[]): PlinkoResult;
 export declare function computePlinkoResult(hash: Uint8Array, clientSeed: string, payouts: number[]): PlinkoResult;
 export {};

package/dist/compute-wager.js

@@ -1,15 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computePlinkoResult = exports.computePlinkoHouseEdge = exports.computePlinkoPascalsProbabilities = exports.computePlinkoPath = exports.computePinkoPossibilityIndexFromPath = exports.computeMinesMultiplier = exports.computeMineLocations = exports.computeMultiRouletteResult = exports.computeCrashDiceOutcome = exports.computeCrashDiceResult = exports.computeCrashResult = exports.computeFairCoinTossOutcome = exports.computeFairCoinTossResult = void 0;
+exports.computePlinkoResult = exports.computePlinkoResultFromRandomSource = exports.computePlinkoHouseEdge = exports.computePlinkoPascalsProbabilities = exports.computePlinkoPath = exports.computePinkoPossibilityIndexFromPath = exports.computeMinesMultiplier = exports.computeMineLocations = exports.computeMultiRouletteResult = exports.computeCrashDiceResult = exports.computeCrashResult = exports.computeFairCoinTossOutcome = exports.computeFairCoinTossResult = exports.computeRandomSource = exports.computeRandomSourceFromCompressedSeed = exports.computeCompressedSeedFromGameHash = exports.computeCompressedSeed = exports.splitHelixHash = void 0;
 const sha256_1 = require("@noble/hashes/sha256");
 const hmac_1 = require("@noble/hashes/hmac");
 const utils_1 = require("@noble/curves/abstract/utils");
 const currency_1 = require("./generated/currency");
 const fair_coin_toss_1 = require("./generated/context/fair-coin-toss");
 const utils_2 = require("@noble/hashes/utils");
-function computeFairCoinTossResult(sig) {
-    // We're going to hash the signature just to really be sure its fairly distributed
-    const hash = (0, sha256_1.sha256)(sig);
+function splitHelixHash(hash) {
+    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),
+    };
+}
+exports.splitHelixHash = splitHelixHash;
+function computeCompressedSeed(clientSeed, lhsHash) {
+    const seedHash = hmacSha256(lhsHash, clientSeed);
+    return u32FromHash(seedHash);
+}
+exports.computeCompressedSeed = computeCompressedSeed;
+function computeCompressedSeedFromGameHash(clientSeed, gameHash) {
+    const { lhs } = splitHelixHash(gameHash);
+    return computeCompressedSeed(clientSeed, lhs);
+}
+exports.computeCompressedSeedFromGameHash = computeCompressedSeedFromGameHash;
+function computeRandomSourceFromCompressedSeed(compressedSeed, rhsHash) {
+    const seedBytes = u32ToBytes(compressedSeed);
+    return hmacSha256Bytes(rhsHash, seedBytes);
+}
+exports.computeRandomSourceFromCompressedSeed = computeRandomSourceFromCompressedSeed;
+function computeRandomSource(clientSeed, gameHash) {
+    const { lhs, rhs } = splitHelixHash(gameHash);
+    const compressedSeed = computeCompressedSeed(clientSeed, lhs);
+    return computeRandomSourceFromCompressedSeed(compressedSeed, rhs);
+}
+exports.computeRandomSource = computeRandomSource;
+function computeFairCoinTossResult(randomSource) {
+    // We're going to hash the random source just to really be sure its fairly distributed
+    const hash = (0, sha256_1.sha256)(randomSource);
     const result = hash[0] % 2;
     if (result == 0) {
         return fair_coin_toss_1.FairCoinToss_Choice.HEADS;
@@ -19,8 +51,8 @@ function computeFairCoinTossResult(sig) {
     }
 }
 exports.computeFairCoinTossResult = computeFairCoinTossResult;
-function computeFairCoinTossOutcome(sig, w) {
-    const result = computeFairCoinTossResult(sig);
+function computeFairCoinTossOutcome(randomSource, w) {
+    const result = computeFairCoinTossResult(randomSource);
     const win = w.playerChoice === result;
     const profit = win ? 1 : -1;
     return {
@@ -29,10 +61,10 @@ function computeFairCoinTossOutcome(sig, w) {
     };
 }
 exports.computeFairCoinTossOutcome = computeFairCoinTossOutcome;
-function doComputeCrashResult(hash, houseEdge) {
+function doComputeCrashResult(randomSource, houseEdge) {
     const nBits = 52;
-    const hashHex = (0, utils_2.bytesToHex)(hash);
-    const seed = hashHex.slice(0, nBits / 4);
+    const randomSourceHex = (0, utils_2.bytesToHex)(randomSource);
+    const seed = randomSourceHex.slice(0, nBits / 4);
     const r = Number.parseInt(seed, 16);
     let X = r / 2 ** nBits; // uniformly distributed in [0; 1)
     let Y = 1 - X; // Now it's uniformly distributed in (0; 1], so it's safe to divide by it
@@ -46,24 +78,17 @@ houseEdge = 0) {
     return doComputeCrashResult((0, hmac_1.hmac)(sha256_1.sha256, hash, gameHash), houseEdge);
 }
 exports.computeCrashResult = computeCrashResult;
-function computeCrashDiceResult(hash, clientSeed) {
-    const rollHash = hmacSha256(hash, clientSeed);
-    return multiplierFromHash(rollHash);
+function computeCrashDiceResult(randomSource, houseEdge) {
+    const normalized = u32FromHash(randomSource);
+    const max = 2 ** 32;
+    let result = ((1 - houseEdge) * max) / (max - normalized);
+    result = Math.floor(result * 100) / 100;
+    return Math.max(1, result);
 }
 exports.computeCrashDiceResult = computeCrashDiceResult;
-function computeCrashDiceOutcome(hash, clientSeed, bet) {
-    const multiplier = computeCrashDiceResult(hash, clientSeed);
-    const target = bet.target;
-    return {
-        multiplier,
-        target,
-        win: multiplier >= target,
-    };
-}
-exports.computeCrashDiceOutcome = computeCrashDiceOutcome;
 // returns the index of which roulette outcome was picked
-function computeMultiRouletteResult(hash, bet) {
-    const seedHash = (0, sha256_1.sha256)(hash);
+function computeMultiRouletteResult(randomSource, bet) {
+    const seedHash = (0, sha256_1.sha256)(randomSource);
     const nBits = 52;
     const hashHex = (0, utils_2.bytesToHex)(seedHash);
     const seed = hashHex.slice(0, nBits / 4);
@@ -78,7 +103,7 @@ function computeMultiRouletteResult(hash, bet) {
     }
 }
 exports.computeMultiRouletteResult = computeMultiRouletteResult;
-function computeMineLocations(hash, revealedCells, // tiles we know are safe
+function computeMineLocations(randomSource, revealedCells, // tiles we know are safe
 cells, // how many cells in total
 mines // how many mines there are going to be in total
 ) {
@@ -89,7 +114,7 @@ mines // how many mines there are going to be in total
             console.warn("Trying to place more mines than there are available locations.");
             break;
         }
-        let mineIndex = Number((0, utils_1.bytesToNumberBE)(hash) % BigInt(cellsLeft));
+        let mineIndex = Number((0, utils_1.bytesToNumberBE)(randomSource) % BigInt(cellsLeft));
         let adjustedIndex = 0;
         for (let i = 0; i < cells; i++) {
             if (revealedCells.has(i) || mineLocations.has(i))
@@ -151,13 +176,13 @@ function computePinkoPossibilityIndexFromPath(path) {
 exports.computePinkoPossibilityIndexFromPath = computePinkoPossibilityIndexFromPath;
 // return a path (saying 'L' or 'R', where 'L' means go left, and 'R' means going right)
 //  of possibilities-1 length
-function computePlinkoPath(hash, possibilities) {
+function computePlinkoPath(randomSource, possibilities) {
     if (!Number.isSafeInteger(possibilities) ||
         possibilities < 2 ||
         possibilities > 256) {
         throw new Error("invalid possibilities ");
     }
-    const pathHash = (0, sha256_1.sha256)(hash);
+    const pathHash = (0, sha256_1.sha256)(randomSource);
     let n = (0, utils_1.bytesToNumberBE)(pathHash);
     let ret = [];
     for (let i = 0; i < possibilities - 1; i++) {
@@ -201,13 +226,12 @@ function computePlinkoHouseEdge(payouts) {
     return ev;
 }
 exports.computePlinkoHouseEdge = computePlinkoHouseEdge;
-function computePlinkoResult(hash, clientSeed, payouts) {
+function computePlinkoResultFromRandomSource(randomSource, payouts) {
     if (payouts.length < 2) {
         throw new Error("invalid possibilities ");
     }
     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;
     return {
@@ -215,27 +239,42 @@ function computePlinkoResult(hash, clientSeed, payouts) {
         multiplier,
     };
 }
+exports.computePlinkoResultFromRandomSource = computePlinkoResultFromRandomSource;
+function computePlinkoResult(hash, clientSeed, payouts) {
+    const randomSource = computeRandomSource(clientSeed, hash);
+    return computePlinkoResultFromRandomSource(randomSource, payouts);
+}
 exports.computePlinkoResult = computePlinkoResult;
 function hmacSha256(key, message) {
     const data = new TextEncoder().encode(message);
     return (0, hmac_1.hmac)(sha256_1.sha256, key, data);
 }
-function multiplierFromHash(hash) {
-    if (hash.length < 4) {
-        throw new Error("Hash must be at least 4 bytes.");
+function hmacSha256Bytes(key, message) {
+    return (0, hmac_1.hmac)(sha256_1.sha256, key, message);
+}
+function u32FromHash(randomSource) {
+    if (randomSource.length < 4) {
+        throw new Error("Random source must be at least 4 bytes.");
     }
-    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;
+    return (((randomSource[0] << 24) |
+        (randomSource[1] << 16) |
+        (randomSource[2] << 8) |
+        randomSource[3]) >>>
+        0);
 }
-function uniformFromHash(hash) {
-    if (hash.length < 4) {
-        throw new Error("Hash must be at least 4 bytes.");
+function u32ToBytes(value) {
+    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) {
+    const normalized = u32FromHash(randomSource);
     return normalized / 2 ** 32;
 }
 function pickSlot(probabilities, roll) {