@actuallyfair/verifier 0.0.5 → 0.0.6

package/dist/compute-wager.d.ts

@@ -2,7 +2,6 @@ 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";
-import { Plinko } from "./generated/context/plinko";
 export declare function computeFairCoinTossResult(sig: Uint8Array): FairCoinToss_Choice.HEADS | FairCoinToss_Choice.TAILS;
 export declare function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinToss): {
     result: FairCoinToss_Choice;
@@ -11,7 +10,7 @@ export declare function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinT
         amount: number;
     };
 };
-export declare function computeCrashResult(vxSignature: Uint8Array, gameHash: Uint8Array, // This is the hash of the next from the hash chain
+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;
@@ -20,8 +19,8 @@ export type CrashDiceOutcome = {
 };
 export declare function computeCrashDiceResult(hash: Uint8Array, clientSeed: string): number;
 export declare function computeCrashDiceOutcome(hash: Uint8Array, clientSeed: string, bet: CrashDice): CrashDiceOutcome;
-export declare function computeMultiRouletteResult(vxSignature: Uint8Array, bet: MultiRoulette): number | undefined;
-export declare function computeMineLocations(vxSignature: Uint8Array, revealedCells: Set<number>, // tiles we know are safe
+export declare function computeMultiRouletteResult(hash: Uint8Array, bet: MultiRoulette): number | undefined;
+export declare function computeMineLocations(hash: Uint8Array, 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
@@ -30,13 +29,12 @@ 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(vxSignature: Uint8Array, possibilities: number): PlinkoPath;
+export declare function computePlinkoPath(hash: Uint8Array, possibilities: number): PlinkoPath;
 export declare function computePlinkoPascalsProbabilities(rowNumber: number): number[];
-export declare function computePlinkoHouseEdge(possibilities: number[]): number;
+export declare function computePlinkoHouseEdge(payouts: number[]): number;
 export type PlinkoResult = {
     slot: number;
     multiplier: number;
-    win: boolean;
 };
-export declare function computePlinkoResult(hash: Uint8Array, clientSeed: string, bet: Plinko): PlinkoResult;
+export declare function computePlinkoResult(hash: Uint8Array, clientSeed: string, payouts: number[]): PlinkoResult;
 export {};

package/dist/compute-wager.js

@@ -7,7 +7,6 @@ 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");
-const duel_plinko_payouts_1 = require("./duel-plinko-payouts");
 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);
@@ -42,9 +41,9 @@ function doComputeCrashResult(hash, houseEdge) {
     result = Math.max(1, result);
     return result;
 }
-function computeCrashResult(vxSignature, gameHash, // This is the hash of the next from the hash chain
+function computeCrashResult(hash, gameHash, // This is the hash of the next from the hash chain
 houseEdge = 0) {
-    return doComputeCrashResult((0, hmac_1.hmac)(sha256_1.sha256, vxSignature, gameHash), houseEdge);
+    return doComputeCrashResult((0, hmac_1.hmac)(sha256_1.sha256, hash, gameHash), houseEdge);
 }
 exports.computeCrashResult = computeCrashResult;
 function computeCrashDiceResult(hash, clientSeed) {
@@ -63,10 +62,10 @@ function computeCrashDiceOutcome(hash, clientSeed, bet) {
 }
 exports.computeCrashDiceOutcome = computeCrashDiceOutcome;
 // returns the index of which roulette outcome was picked
-function computeMultiRouletteResult(vxSignature, bet) {
-    const hash = (0, sha256_1.sha256)(vxSignature);
+function computeMultiRouletteResult(hash, bet) {
+    const seedHash = (0, sha256_1.sha256)(hash);
     const nBits = 52;
-    const hashHex = (0, utils_2.bytesToHex)(hash);
+    const hashHex = (0, utils_2.bytesToHex)(seedHash);
     const seed = hashHex.slice(0, nBits / 4);
     const n = Number.parseInt(seed, 16);
     const v = n / 2 ** nBits; // uniform in [0; 1)
@@ -79,7 +78,7 @@ function computeMultiRouletteResult(vxSignature, bet) {
     }
 }
 exports.computeMultiRouletteResult = computeMultiRouletteResult;
-function computeMineLocations(vxSignature, revealedCells, // tiles we know are safe
+function computeMineLocations(hash, revealedCells, // tiles we know are safe
 cells, // how many cells in total
 mines // how many mines there are going to be in total
 ) {
@@ -90,7 +89,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)(vxSignature) % BigInt(cellsLeft));
+        let mineIndex = Number((0, utils_1.bytesToNumberBE)(hash) % BigInt(cellsLeft));
         let adjustedIndex = 0;
         for (let i = 0; i < cells; i++) {
             if (revealedCells.has(i) || mineLocations.has(i))
@@ -152,14 +151,14 @@ 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(vxSignature, possibilities) {
+function computePlinkoPath(hash, possibilities) {
     if (!Number.isSafeInteger(possibilities) ||
         possibilities < 2 ||
         possibilities > 256) {
         throw new Error("invalid possibilities ");
     }
-    const hash = (0, sha256_1.sha256)(vxSignature);
-    let n = (0, utils_1.bytesToNumberBE)(hash);
+    const pathHash = (0, sha256_1.sha256)(hash);
+    let n = (0, utils_1.bytesToNumberBE)(pathHash);
     let ret = [];
     for (let i = 0; i < possibilities - 1; i++) {
         ret.push(n % 2n == 0n ? "R" : "L");
@@ -193,45 +192,30 @@ function computePlinkoPascalsProbabilities(rowNumber) {
     return lastRow.map((v) => v / sum);
 }
 exports.computePlinkoPascalsProbabilities = computePlinkoPascalsProbabilities;
-function computePlinkoHouseEdge(possibilities) {
-    const odds = computePlinkoPascalsProbabilities(possibilities.length);
+function computePlinkoHouseEdge(payouts) {
+    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;
 }
 exports.computePlinkoHouseEdge = computePlinkoHouseEdge;
-function computePlinkoResult(hash, clientSeed, bet) {
-    const possibilities = resolvePlinkoPayouts(bet);
-    if (possibilities.length < 2) {
+function computePlinkoResult(hash, clientSeed, payouts) {
+    if (payouts.length < 2) {
         throw new Error("invalid possibilities ");
     }
-    const probabilities = computePlinkoPascalsProbabilities(possibilities.length);
+    const probabilities = computePlinkoPascalsProbabilities(payouts.length);
     const rollHash = hmacSha256(hash, clientSeed);
     const roll = uniformFromHash(rollHash);
     const slot = pickSlot(probabilities, roll);
-    const multiplier = possibilities[slot] ?? 0;
+    const multiplier = payouts[slot] ?? 0;
     return {
         slot,
         multiplier,
-        win: multiplier >= 1,
     };
 }
 exports.computePlinkoResult = computePlinkoResult;
-function resolvePlinkoPayouts(bet) {
-    const payouts = bet.payouts;
-    if (!payouts) {
-        return [];
-    }
-    if (payouts.duel) {
-        return (0, duel_plinko_payouts_1.getDuelPlinkoPayoutsFromEnum)(payouts.duel.rows, payouts.duel.risk);
-    }
-    if (payouts.custom) {
-        return payouts.custom.possibilities;
-    }
-    return [];
-}
 function hmacSha256(key, message) {
     const data = new TextEncoder().encode(message);
     return (0, hmac_1.hmac)(sha256_1.sha256, key, data);

package/dist/duel-plinko-payouts.d.ts

@@ -1,14 +1,18 @@
-import { DuelPlinkoRisk } from "./generated/context/plinko";
-export declare const DUEL_PLINKO_RISK_KEYS: readonly ["low", "medium", "high"];
-export type DuelPlinkoRiskKey = (typeof DUEL_PLINKO_RISK_KEYS)[number];
-export declare const DUEL_PLINKO_PAYOUTS: Record<number, Record<DuelPlinkoRiskKey, number[]>>;
-export declare const DUEL_PLINKO_ROWS: {
+import { PlinkoPayoutTable } from "./generated/context/plinko";
+export declare const PLINKO_RISK_KEYS: readonly ["low", "medium", "high"];
+export type PlinkoRiskKey = (typeof PLINKO_RISK_KEYS)[number];
+export declare const PLINKO_PAYOUT_TABLE_KEYS: readonly ["duel_8_low", "duel_8_medium", "duel_8_high", "duel_9_low", "duel_9_medium", "duel_9_high", "duel_10_low", "duel_10_medium", "duel_10_high", "duel_11_low", "duel_11_medium", "duel_11_high", "duel_12_low", "duel_12_medium", "duel_12_high", "duel_13_low", "duel_13_medium", "duel_13_high", "duel_14_low", "duel_14_medium", "duel_14_high", "duel_15_low", "duel_15_medium", "duel_15_high", "duel_16_low", "duel_16_medium", "duel_16_high"];
+export type PlinkoPayoutTableKey = (typeof PLINKO_PAYOUT_TABLE_KEYS)[number];
+export declare const PLINKO_PAYOUT_TABLES: Record<PlinkoPayoutTableKey, number[]>;
+export declare const PLINKO_ROWS: {
     readonly min: number;
     readonly max: number;
 };
-export declare function getDuelPlinkoPayouts(rows: number, risk: DuelPlinkoRiskKey): number[];
-export declare function isDuelPlinkoRiskKey(value: string): value is DuelPlinkoRiskKey;
-export declare function isDuelPlinkoRows(rows: number): boolean;
-export declare function duelPlinkoRiskToEnum(value: DuelPlinkoRiskKey): DuelPlinkoRisk;
-export declare function duelPlinkoRiskFromEnum(value: DuelPlinkoRisk): DuelPlinkoRiskKey | null;
-export declare function getDuelPlinkoPayoutsFromEnum(rows: number, risk: DuelPlinkoRisk): number[];
+export declare function isPlinkoRiskKey(value: string): value is PlinkoRiskKey;
+export declare function isPlinkoRows(rows: number): boolean;
+export declare function getPlinkoPayoutTableKey(rows: number, risk: PlinkoRiskKey): PlinkoPayoutTableKey | null;
+export declare function getPlinkoPayouts(key: PlinkoPayoutTableKey): number[];
+export declare function isPlinkoPayoutTableKey(value: string): value is PlinkoPayoutTableKey;
+export declare function plinkoPayoutTableToEnum(value: PlinkoPayoutTableKey): PlinkoPayoutTable;
+export declare function plinkoPayoutTableFromEnum(value: PlinkoPayoutTable): PlinkoPayoutTableKey | null;
+export declare function getPlinkoPayoutsFromEnum(value: PlinkoPayoutTable): number[];