@actuallyfair/verifier 0.0.1 → 0.0.3

package/dist/generated/context/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PosthashPlinko = exports.PosthashDice = exports.PosthashInit = exports.PosthashContext = exports.Context = void 0;
+exports.PosthashInit = exports.Context = void 0;
 /* eslint-disable */
 const minimal_1 = __importDefault(require("protobufjs/minimal"));
 const crash_1 = require("./crash");
@@ -24,6 +24,7 @@ function createBaseContext() {
         mines: undefined,
         tower: undefined,
         plinko: undefined,
+        init: undefined,
     };
 }
 exports.Context = {
@@ -52,6 +53,9 @@ exports.Context = {
         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();
+        }
         return writer;
     },
     decode(input, length) {
@@ -109,6 +113,12 @@ exports.Context = {
                     }
                     message.plinko = plinko_1.Plinko.decode(reader, reader.uint32());
                     continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.init = exports.PosthashInit.decode(reader, reader.uint32());
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -127,6 +137,7 @@ exports.Context = {
             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) {
@@ -155,6 +166,9 @@ exports.Context = {
         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) {
@@ -178,92 +192,9 @@ exports.Context = {
         message.plinko = (object.plinko !== undefined && object.plinko !== null)
             ? plinko_1.Plinko.fromPartial(object.plinko)
             : undefined;
-        return message;
-    },
-};
-function createBasePosthashContext() {
-    return { init: undefined, dice: undefined, plinko: undefined };
-}
-exports.PosthashContext = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.init !== undefined) {
-            exports.PosthashInit.encode(message.init, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.dice !== undefined) {
-            exports.PosthashDice.encode(message.dice, writer.uint32(18).fork()).ldelim();
-        }
-        if (message.plinko !== undefined) {
-            exports.PosthashPlinko.encode(message.plinko, writer.uint32(26).fork()).ldelim();
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBasePosthashContext();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 10) {
-                        break;
-                    }
-                    message.init = exports.PosthashInit.decode(reader, reader.uint32());
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.dice = exports.PosthashDice.decode(reader, reader.uint32());
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.plinko = exports.PosthashPlinko.decode(reader, reader.uint32());
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            init: isSet(object.init) ? exports.PosthashInit.fromJSON(object.init) : undefined,
-            dice: isSet(object.dice) ? exports.PosthashDice.fromJSON(object.dice) : undefined,
-            plinko: isSet(object.plinko) ? exports.PosthashPlinko.fromJSON(object.plinko) : undefined,
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.init !== undefined) {
-            obj.init = exports.PosthashInit.toJSON(message.init);
-        }
-        if (message.dice !== undefined) {
-            obj.dice = exports.PosthashDice.toJSON(message.dice);
-        }
-        if (message.plinko !== undefined) {
-            obj.plinko = exports.PosthashPlinko.toJSON(message.plinko);
-        }
-        return obj;
-    },
-    create(base) {
-        return exports.PosthashContext.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBasePosthashContext();
         message.init = (object.init !== undefined && object.init !== null)
             ? exports.PosthashInit.fromPartial(object.init)
             : undefined;
-        message.dice = (object.dice !== undefined && object.dice !== null)
-            ? exports.PosthashDice.fromPartial(object.dice)
-            : undefined;
-        message.plinko = (object.plinko !== undefined && object.plinko !== null)
-            ? exports.PosthashPlinko.fromPartial(object.plinko)
-            : undefined;
         return message;
     },
 };
@@ -304,209 +235,6 @@ exports.PosthashInit = {
         return message;
     },
 };
-function createBasePosthashDice() {
-    return { target: 0, clientSeed: "", hashchainServerHash: new Uint8Array(0) };
-}
-exports.PosthashDice = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.target !== 0) {
-            writer.uint32(9).double(message.target);
-        }
-        if (message.clientSeed !== "") {
-            writer.uint32(18).string(message.clientSeed);
-        }
-        if (message.hashchainServerHash.length !== 0) {
-            writer.uint32(26).bytes(message.hashchainServerHash);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBasePosthashDice();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 9) {
-                        break;
-                    }
-                    message.target = reader.double();
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.clientSeed = reader.string();
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.hashchainServerHash = reader.bytes();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            target: isSet(object.target) ? globalThis.Number(object.target) : 0,
-            clientSeed: isSet(object.clientSeed) ? globalThis.String(object.clientSeed) : "",
-            hashchainServerHash: isSet(object.hashchainServerHash)
-                ? bytesFromBase64(object.hashchainServerHash)
-                : new Uint8Array(0),
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.target !== 0) {
-            obj.target = message.target;
-        }
-        if (message.clientSeed !== "") {
-            obj.clientSeed = message.clientSeed;
-        }
-        if (message.hashchainServerHash.length !== 0) {
-            obj.hashchainServerHash = base64FromBytes(message.hashchainServerHash);
-        }
-        return obj;
-    },
-    create(base) {
-        return exports.PosthashDice.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBasePosthashDice();
-        message.target = object.target ?? 0;
-        message.clientSeed = object.clientSeed ?? "";
-        message.hashchainServerHash = object.hashchainServerHash ?? new Uint8Array(0);
-        return message;
-    },
-};
-function createBasePosthashPlinko() {
-    return { rows: 0, riskLevel: "", clientSeed: "", hashchainServerHash: new Uint8Array(0) };
-}
-exports.PosthashPlinko = {
-    encode(message, writer = minimal_1.default.Writer.create()) {
-        if (message.rows !== 0) {
-            writer.uint32(8).uint32(message.rows);
-        }
-        if (message.riskLevel !== "") {
-            writer.uint32(18).string(message.riskLevel);
-        }
-        if (message.clientSeed !== "") {
-            writer.uint32(26).string(message.clientSeed);
-        }
-        if (message.hashchainServerHash.length !== 0) {
-            writer.uint32(34).bytes(message.hashchainServerHash);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBasePosthashPlinko();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 8) {
-                        break;
-                    }
-                    message.rows = reader.uint32();
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.riskLevel = reader.string();
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.clientSeed = reader.string();
-                    continue;
-                case 4:
-                    if (tag !== 34) {
-                        break;
-                    }
-                    message.hashchainServerHash = reader.bytes();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-    fromJSON(object) {
-        return {
-            rows: isSet(object.rows) ? globalThis.Number(object.rows) : 0,
-            riskLevel: isSet(object.riskLevel) ? globalThis.String(object.riskLevel) : "",
-            clientSeed: isSet(object.clientSeed) ? globalThis.String(object.clientSeed) : "",
-            hashchainServerHash: isSet(object.hashchainServerHash)
-                ? bytesFromBase64(object.hashchainServerHash)
-                : new Uint8Array(0),
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.rows !== 0) {
-            obj.rows = Math.round(message.rows);
-        }
-        if (message.riskLevel !== "") {
-            obj.riskLevel = message.riskLevel;
-        }
-        if (message.clientSeed !== "") {
-            obj.clientSeed = message.clientSeed;
-        }
-        if (message.hashchainServerHash.length !== 0) {
-            obj.hashchainServerHash = base64FromBytes(message.hashchainServerHash);
-        }
-        return obj;
-    },
-    create(base) {
-        return exports.PosthashPlinko.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBasePosthashPlinko();
-        message.rows = object.rows ?? 0;
-        message.riskLevel = object.riskLevel ?? "";
-        message.clientSeed = object.clientSeed ?? "";
-        message.hashchainServerHash = object.hashchainServerHash ?? new Uint8Array(0);
-        return message;
-    },
-};
-function bytesFromBase64(b64) {
-    if (globalThis.Buffer) {
-        return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-    }
-    else {
-        const bin = globalThis.atob(b64);
-        const arr = new Uint8Array(bin.length);
-        for (let i = 0; i < bin.length; ++i) {
-            arr[i] = bin.charCodeAt(i);
-        }
-        return arr;
-    }
-}
-function base64FromBytes(arr) {
-    if (globalThis.Buffer) {
-        return globalThis.Buffer.from(arr).toString("base64");
-    }
-    else {
-        const bin = [];
-        arr.forEach((byte) => {
-            bin.push(globalThis.String.fromCharCode(byte));
-        });
-        return globalThis.btoa(bin.join(""));
-    }
-}
 function isSet(value) {
     return value !== null && value !== undefined;
 }

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@actuallyfair/verifier",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "clean": "rm -rf dist && mkdir dist && rm -rf src/generated && mkdir src/generated",
     "build": "npm run clean && npm run generate && tsc",
-    "generate": "protoc --proto_path=./protobuf --plugin=./node_modules/.bin/protoc-gen-ts_proto  --ts_proto_opt=esModuleInterop=true --ts_proto_opt=exportCommonSymbols=false --ts_proto_out=./src/generated ./protobuf/context/index.proto ./protobuf/currency.proto",
+    "generate": "protoc --proto_path=./protobuf --plugin=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_opt=esModuleInterop=true --ts_proto_opt=exportCommonSymbols=false --ts_proto_out=./src/generated ./protobuf/context/*.proto ./protobuf/amount.proto ./protobuf/currency.proto",
+    "decode": "tsx ./src/cli/context-codec.ts decode",
+    "encode": "tsx ./src/cli/context-codec.ts encode",
     "prepublishOnly": "npm run build"
   },
   "publishConfig": {

package/protobuf/context/index.proto

@@ -4,9 +4,9 @@ import "context/fair-coin-toss.proto";
 import "context/crash.proto";
 import "context/hilo.proto";
 import "context/crash-dice.proto";
+import "context/multi-roulette.proto";
 import "context/mines.proto";
 import "context/tower.proto";
-import "context/multi-roulette.proto";
 import "context/plinko.proto";
 
 message Context {
@@ -19,28 +19,8 @@ message Context {
     Mines mines = 6;
     Tower tower = 7;
     Plinko plinko = 8;
-  }
-}
-
-message PosthashContext {
-  oneof payload {
-    PosthashInit init = 1;
-    PosthashDice dice = 2;
-    PosthashPlinko plinko = 3;
+    PosthashInit init = 9;
   }
 }
 
 message PosthashInit {}
-
-message PosthashDice {
-  double target = 1;
-  string client_seed = 2;
-  bytes hashchain_server_hash = 3;
-}
-
-message PosthashPlinko {
-  uint32 rows = 1;
-  string risk_level = 2;
-  string client_seed = 3;
-  bytes hashchain_server_hash = 4;
-}

package/src/cli/context-codec.ts

@@ -0,0 +1,103 @@
+import { Context } from "../generated/context";
+
+type Mode = "decode" | "encode";
+
+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 readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function readInput(args: string[]): Promise<string> {
+  if (args.length > 0) {
+    return args.join(" ").trim();
+  }
+
+  if (process.stdin.isTTY) {
+    return "";
+  }
+
+  const data = await readStdin();
+  return data.trim();
+}
+
+function usage(mode?: Mode): string[] {
+  if (mode === "decode") {
+    return ["Usage: npm run decode -- <base64>", "       cat context.b64 | npm run decode"];
+  }
+  if (mode === "encode") {
+    return ["Usage: npm run encode -- '<json>'", "       cat context.json | npm run encode"];
+  }
+  return [
+    "Usage: npm run decode -- <base64>",
+    "       npm run encode -- '<json>'",
+    "       cat context.b64 | npm run decode",
+    "       cat context.json | npm run encode",
+  ];
+}
+
+function printUsage(mode?: Mode): void {
+  for (const line of usage(mode)) {
+    console.error(line);
+  }
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+async function main(): Promise<void> {
+  const [modeRaw, ...rest] = process.argv.slice(2);
+  if (!isMode(modeRaw)) {
+    printUsage();
+    process.exit(1);
+    return;
+  }
+
+  const input = await readInput(rest);
+  if (!input) {
+    printUsage(modeRaw);
+    process.exit(1);
+    return;
+  }
+
+  try {
+    if (modeRaw === "decode") {
+      const base64 = normalizeBase64(input);
+      const bytes = Buffer.from(base64, "base64");
+      const message = Context.decode(bytes);
+      const json = Context.toJSON(message);
+      process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
+      return;
+    }
+
+    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`);
+  } catch (error) {
+    console.error(`Failed to ${modeRaw} context: ${errorMessage(error)}`);
+    process.exit(1);
+  }
+}
+
+void main();

package/src/compute-wager.ts

@@ -12,7 +12,9 @@ import {
   FairCoinToss_Choice,
 } from "./generated/context/fair-coin-toss";
 import { bytesToHex } from "@noble/hashes/utils";
+import { CrashDice } from "./generated/context/crash-dice";
 import { MultiRoulette } from "./generated/context/multi-roulette";
+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
@@ -65,8 +67,30 @@ export function computeCrashResult(
   return doComputeCrashResult(hmac(sha256, vxSignature, gameHash), houseEdge);
 }
 
-export function computeCrashDiceResult(sig: Uint8Array, houseEdge: number) {
-  return doComputeCrashResult(sha256(sig), houseEdge);
+export type CrashDiceOutcome = {
+  multiplier: number;
+  target: number;
+  win: boolean;
+};
+
+export function computeCrashDiceResult(hash: Uint8Array, clientSeed: string) {
+  const rollHash = hmacSha256(hash, clientSeed);
+  return multiplierFromHash(rollHash);
+}
+
+export function computeCrashDiceOutcome(
+  hash: Uint8Array,
+  clientSeed: string,
+  bet: CrashDice
+): CrashDiceOutcome {
+  const multiplier = computeCrashDiceResult(hash, clientSeed);
+  const target = bet.target;
+
+  return {
+    multiplier,
+    target,
+    win: multiplier >= target,
+  };
 }
 
 // returns the index of which roulette outcome was picked
@@ -243,3 +267,69 @@ export function computePlinkoHouseEdge(possibilities: number[]) {
   }
   return ev;
 }
+
+export type PlinkoResult = {
+  slot: number;
+  multiplier: number;
+  win: boolean;
+};
+
+export function computePlinkoResult(
+  hash: Uint8Array,
+  clientSeed: string,
+  bet: Plinko
+): PlinkoResult {
+  const possibilities = bet.possibilities;
+  if (possibilities.length < 2) {
+    throw new Error("invalid possibilities ");
+  }
+
+  const probabilities = computePlinkoPascalsProbabilities(possibilities.length);
+  const rollHash = hmacSha256(hash, clientSeed);
+  const roll = uniformFromHash(rollHash);
+  const slot = pickSlot(probabilities, roll);
+  const multiplier = possibilities[slot] ?? 0;
+
+  return {
+    slot,
+    multiplier,
+    win: multiplier >= 1,
+  };
+}
+
+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.");
+  }
+
+  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 uniformFromHash(hash: Uint8Array): number {
+  if (hash.length < 4) {
+    throw new Error("Hash must be at least 4 bytes.");
+  }
+  const value = (hash[0] << 24) | (hash[1] << 16) | (hash[2] << 8) | hash[3];
+  const normalized = value >>> 0;
+  return normalized / 2 ** 32;
+}
+
+function pickSlot(probabilities: number[], roll: number): number {
+  let cumulative = 0;
+  for (let i = 0; i < probabilities.length; i += 1) {
+    cumulative += probabilities[i];
+    if (roll <= cumulative) {
+      return i;
+    }
+  }
+  return probabilities.length - 1;
+}