@actuallyfair/verifier 0.0.1 → 0.0.3

package/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish Package
+
+on:
+  push:
+    branches:
+      - "master"
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install protoc
+        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
+
+      - run: npm ci
+      - run: npm publish

package/dist/cli/context-codec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/context-codec.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 readStdin() {
+    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) {
+    if (args.length > 0) {
+        return args.join(" ").trim();
+    }
+    if (process.stdin.isTTY) {
+        return "";
+    }
+    const data = await readStdin();
+    return data.trim();
+}
+function usage(mode) {
+    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) {
+    for (const line of usage(mode)) {
+        console.error(line);
+    }
+}
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function main() {
+    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_1.Context.decode(bytes);
+            const json = context_1.Context.toJSON(message);
+            process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
+            return;
+        }
+        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`);
+    }
+    catch (error) {
+        console.error(`Failed to ${modeRaw} context: ${errorMessage(error)}`);
+        process.exit(1);
+    }
+}
+void main();

package/dist/compute-wager.d.ts

@@ -1,6 +1,8 @@
 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 +13,13 @@ export declare function computeFairCoinTossOutcome(sig: Uint8Array, w: FairCoinT
 };
 export declare function computeCrashResult(vxSignature: Uint8Array, gameHash: Uint8Array, // This is the hash of the next from the hash chain
 houseEdge?: number): number;
-export declare function computeCrashDiceResult(sig: Uint8Array, 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(vxSignature: Uint8Array, bet: MultiRoulette): number | undefined;
 export declare function computeMineLocations(vxSignature: Uint8Array, revealedCells: Set<number>, // tiles we know are safe
 cells: number, // how many cells in total
@@ -25,4 +33,10 @@ export declare function computePinkoPossibilityIndexFromPath(path: PlinkoPath):
 export declare function computePlinkoPath(vxSignature: Uint8Array, possibilities: number): PlinkoPath;
 export declare function computePlinkoPascalsProbabilities(rowNumber: number): number[];
 export declare function computePlinkoHouseEdge(possibilities: number[]): number;
+export type PlinkoResult = {
+    slot: number;
+    multiplier: number;
+    win: boolean;
+};
+export declare function computePlinkoResult(hash: Uint8Array, clientSeed: string, bet: Plinko): PlinkoResult;
 export {};

package/dist/compute-wager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computePlinkoHouseEdge = exports.computePlinkoPascalsProbabilities = exports.computePlinkoPath = exports.computePinkoPossibilityIndexFromPath = exports.computeMinesMultiplier = exports.computeMineLocations = exports.computeMultiRouletteResult = exports.computeCrashDiceResult = exports.computeCrashResult = exports.computeFairCoinTossOutcome = exports.computeFairCoinTossResult = void 0;
+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;
 const sha256_1 = require("@noble/hashes/sha256");
 const hmac_1 = require("@noble/hashes/hmac");
 const utils_1 = require("@noble/curves/abstract/utils");
@@ -46,10 +46,21 @@ houseEdge = 0) {
     return doComputeCrashResult((0, hmac_1.hmac)(sha256_1.sha256, vxSignature, gameHash), houseEdge);
 }
 exports.computeCrashResult = computeCrashResult;
-function computeCrashDiceResult(sig, houseEdge) {
-    return doComputeCrashResult((0, sha256_1.sha256)(sig), houseEdge);
+function computeCrashDiceResult(hash, clientSeed) {
+    const rollHash = hmacSha256(hash, clientSeed);
+    return multiplierFromHash(rollHash);
 }
 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(vxSignature, bet) {
     const hash = (0, sha256_1.sha256)(vxSignature);
@@ -190,3 +201,52 @@ function computePlinkoHouseEdge(possibilities) {
     return ev;
 }
 exports.computePlinkoHouseEdge = computePlinkoHouseEdge;
+function computePlinkoResult(hash, clientSeed, bet) {
+    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,
+    };
+}
+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.");
+    }
+    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) {
+    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, roll) {
+    let cumulative = 0;
+    for (let i = 0; i < probabilities.length; i += 1) {
+        cumulative += probabilities[i];
+        if (roll <= cumulative) {
+            return i;
+        }
+    }
+    return probabilities.length - 1;
+}

package/dist/generated/context/index.d.ts

@@ -16,25 +16,10 @@ export interface Context {
     mines?: Mines | undefined;
     tower?: Tower | undefined;
     plinko?: Plinko | undefined;
-}
-export interface PosthashContext {
     init?: PosthashInit | undefined;
-    dice?: PosthashDice | undefined;
-    plinko?: PosthashPlinko | undefined;
 }
 export interface PosthashInit {
 }
-export interface PosthashDice {
-    target: number;
-    clientSeed: string;
-    hashchainServerHash: Uint8Array;
-}
-export interface PosthashPlinko {
-    rows: number;
-    riskLevel: string;
-    clientSeed: string;
-    hashchainServerHash: Uint8Array;
-}
 export declare const Context: {
     encode(message: Context, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): Context;
@@ -121,6 +106,7 @@ export declare const Context: {
             } | undefined;
             possibilities?: number[] | undefined;
         } | undefined;
+        init?: {} | undefined;
     } & {
         fairCoinToss?: ({
             playerChoice?: import("./fair-coin-toss").FairCoinToss_Choice | undefined;
@@ -374,7 +360,8 @@ export declare const Context: {
             } & { [K_22 in Exclude<keyof I["plinko"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
             possibilities?: (number[] & number[] & { [K_23 in Exclude<keyof I["plinko"]["possibilities"], keyof number[]>]: never; }) | undefined;
         } & { [K_24 in Exclude<keyof I["plinko"], keyof Plinko>]: never; }) | undefined;
-    } & { [K_25 in Exclude<keyof I, keyof Context>]: never; }>(base?: I | undefined): Context;
+        init?: ({} & {} & { [K_25 in Exclude<keyof I["init"], never>]: never; }) | undefined;
+    } & { [K_26 in Exclude<keyof I, keyof Context>]: never; }>(base?: I | undefined): Context;
     fromPartial<I_1 extends {
         fairCoinToss?: {
             playerChoice?: import("./fair-coin-toss").FairCoinToss_Choice | undefined;
@@ -456,17 +443,18 @@ export declare const Context: {
             } | undefined;
             possibilities?: number[] | undefined;
         } | undefined;
+        init?: {} | undefined;
     } & {
         fairCoinToss?: ({
             playerChoice?: import("./fair-coin-toss").FairCoinToss_Choice | undefined;
         } & {
             playerChoice?: import("./fair-coin-toss").FairCoinToss_Choice | undefined;
-        } & { [K_26 in Exclude<keyof I_1["fairCoinToss"], "playerChoice">]: never; }) | undefined;
+        } & { [K_27 in Exclude<keyof I_1["fairCoinToss"], "playerChoice">]: never; }) | undefined;
         crash?: ({
             houseEdge?: number | undefined;
         } & {
             houseEdge?: number | undefined;
-        } & { [K_27 in Exclude<keyof I_1["crash"], "houseEdge">]: never; }) | undefined;
+        } & { [K_28 in Exclude<keyof I_1["crash"], "houseEdge">]: never; }) | undefined;
         hilo?: ({
             start?: {
                 amount?: {
@@ -493,17 +481,17 @@ export declare const Context: {
                 } & {
                     currency?: import("../currency").Currency | undefined;
                     value?: number | undefined;
-                } & { [K_28 in Exclude<keyof I_1["hilo"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+                } & { [K_29 in Exclude<keyof I_1["hilo"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
                 startingCard?: import("./hilo").Card | undefined;
-            } & { [K_29 in Exclude<keyof I_1["hilo"]["start"], keyof import("./hilo").HiLoStart>]: never; }) | undefined;
+            } & { [K_30 in Exclude<keyof I_1["hilo"]["start"], keyof import("./hilo").HiLoStart>]: never; }) | undefined;
             move?: ({
                 playerChoice?: import("./hilo").HiLoMove_Choice | undefined;
                 moveIndex?: number | undefined;
             } & {
                 playerChoice?: import("./hilo").HiLoMove_Choice | undefined;
                 moveIndex?: number | undefined;
-            } & { [K_30 in Exclude<keyof I_1["hilo"]["move"], keyof import("./hilo").HiLoMove>]: never; }) | undefined;
-        } & { [K_31 in Exclude<keyof I_1["hilo"], keyof HiLo>]: never; }) | undefined;
+            } & { [K_31 in Exclude<keyof I_1["hilo"]["move"], keyof import("./hilo").HiLoMove>]: never; }) | undefined;
+        } & { [K_32 in Exclude<keyof I_1["hilo"], keyof HiLo>]: never; }) | undefined;
         crashDice?: ({
             amount?: {
                 currency?: import("../currency").Currency | undefined;
@@ -518,10 +506,10 @@ export declare const Context: {
             } & {
                 currency?: import("../currency").Currency | undefined;
                 value?: number | undefined;
-            } & { [K_32 in Exclude<keyof I_1["crashDice"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+            } & { [K_33 in Exclude<keyof I_1["crashDice"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
             target?: number | undefined;
             houseEdge?: number | undefined;
-        } & { [K_33 in Exclude<keyof I_1["crashDice"], keyof CrashDice>]: never; }) | undefined;
+        } & { [K_34 in Exclude<keyof I_1["crashDice"], keyof CrashDice>]: never; }) | undefined;
         multiRoulette?: ({
             outcomes?: {
                 multiplier?: number | undefined;
@@ -581,8 +569,8 @@ export declare const Context: {
                     } & {
                         currency?: import("../currency").Currency | undefined;
                         value?: number | undefined;
-                    } & { [K_34 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"][number]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
-                } & { [K_35 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"][number], keyof import("./multi-roulette").MultiRoulette_Bet>]: never; })[] & { [K_36 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"], keyof {
+                    } & { [K_35 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"][number]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+                } & { [K_36 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"][number], keyof import("./multi-roulette").MultiRoulette_Bet>]: never; })[] & { [K_37 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number]["bets"], keyof {
                     uname?: string | undefined;
                     amount?: {
                         currency?: import("../currency").Currency | undefined;
@@ -590,7 +578,7 @@ export declare const Context: {
                     } | undefined;
                 }[]>]: never; }) | undefined;
                 name?: string | undefined;
-            } & { [K_37 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number], keyof import("./multi-roulette").MultiRoulette_Outcome>]: never; })[] & { [K_38 in Exclude<keyof I_1["multiRoulette"]["outcomes"], keyof {
+            } & { [K_38 in Exclude<keyof I_1["multiRoulette"]["outcomes"][number], keyof import("./multi-roulette").MultiRoulette_Outcome>]: never; })[] & { [K_39 in Exclude<keyof I_1["multiRoulette"]["outcomes"], keyof {
                 multiplier?: number | undefined;
                 probability?: number | undefined;
                 bets?: {
@@ -602,7 +590,7 @@ export declare const Context: {
                 }[] | undefined;
                 name?: string | undefined;
             }[]>]: never; }) | undefined;
-        } & { [K_39 in Exclude<keyof I_1["multiRoulette"], "outcomes">]: never; }) | undefined;
+        } & { [K_40 in Exclude<keyof I_1["multiRoulette"], "outcomes">]: never; }) | undefined;
         mines?: ({
             start?: {
                 amount?: {
@@ -635,19 +623,19 @@ export declare const Context: {
                 } & {
                     currency?: import("../currency").Currency | undefined;
                     value?: number | undefined;
-                } & { [K_40 in Exclude<keyof I_1["mines"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+                } & { [K_41 in Exclude<keyof I_1["mines"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
                 cells?: number | undefined;
                 mines?: number | undefined;
                 cellLineBreak?: number | undefined;
                 houseEdge?: number | undefined;
-            } & { [K_41 in Exclude<keyof I_1["mines"]["start"], keyof import("./mines").MinesStart>]: never; }) | undefined;
+            } & { [K_42 in Exclude<keyof I_1["mines"]["start"], keyof import("./mines").MinesStart>]: never; }) | undefined;
             move?: ({
                 cell?: number | undefined;
             } & {
                 cell?: number | undefined;
-            } & { [K_42 in Exclude<keyof I_1["mines"]["move"], "cell">]: never; }) | undefined;
+            } & { [K_43 in Exclude<keyof I_1["mines"]["move"], "cell">]: never; }) | undefined;
             cashout?: boolean | undefined;
-        } & { [K_43 in Exclude<keyof I_1["mines"], keyof Mines>]: never; }) | undefined;
+        } & { [K_44 in Exclude<keyof I_1["mines"], keyof Mines>]: never; }) | undefined;
         tower?: ({
             start?: {
                 amount?: {
@@ -680,19 +668,19 @@ export declare const Context: {
                 } & {
                     currency?: import("../currency").Currency | undefined;
                     value?: number | undefined;
-                } & { [K_44 in Exclude<keyof I_1["tower"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+                } & { [K_45 in Exclude<keyof I_1["tower"]["start"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
                 levels?: number | undefined;
                 choicesPerLevel?: number | undefined;
                 minesPerLevel?: number | undefined;
                 houseEdge?: number | undefined;
-            } & { [K_45 in Exclude<keyof I_1["tower"]["start"], keyof import("./tower").TowerStart>]: never; }) | undefined;
+            } & { [K_46 in Exclude<keyof I_1["tower"]["start"], keyof import("./tower").TowerStart>]: never; }) | undefined;
             move?: ({
                 choice?: number | undefined;
             } & {
                 choice?: number | undefined;
-            } & { [K_46 in Exclude<keyof I_1["tower"]["move"], "choice">]: never; }) | undefined;
+            } & { [K_47 in Exclude<keyof I_1["tower"]["move"], "choice">]: never; }) | undefined;
             cashout?: boolean | undefined;
-        } & { [K_47 in Exclude<keyof I_1["tower"], keyof Tower>]: never; }) | undefined;
+        } & { [K_48 in Exclude<keyof I_1["tower"], keyof Tower>]: never; }) | undefined;
         plinko?: ({
             amount?: {
                 currency?: import("../currency").Currency | undefined;
@@ -706,88 +694,11 @@ export declare const Context: {
             } & {
                 currency?: import("../currency").Currency | undefined;
                 value?: number | undefined;
-            } & { [K_48 in Exclude<keyof I_1["plinko"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
-            possibilities?: (number[] & number[] & { [K_49 in Exclude<keyof I_1["plinko"]["possibilities"], keyof number[]>]: never; }) | undefined;
-        } & { [K_50 in Exclude<keyof I_1["plinko"], keyof Plinko>]: never; }) | undefined;
-    } & { [K_51 in Exclude<keyof I_1, keyof Context>]: never; }>(object: I_1): Context;
-};
-export declare const PosthashContext: {
-    encode(message: PosthashContext, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): PosthashContext;
-    fromJSON(object: any): PosthashContext;
-    toJSON(message: PosthashContext): unknown;
-    create<I extends {
-        init?: {} | undefined;
-        dice?: {
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } | undefined;
-        plinko?: {
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } | undefined;
-    } & {
-        init?: ({} & {} & { [K in Exclude<keyof I["init"], never>]: never; }) | undefined;
-        dice?: ({
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & {
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & { [K_1 in Exclude<keyof I["dice"], keyof PosthashDice>]: never; }) | undefined;
-        plinko?: ({
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & {
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & { [K_2 in Exclude<keyof I["plinko"], keyof PosthashPlinko>]: never; }) | undefined;
-    } & { [K_3 in Exclude<keyof I, keyof PosthashContext>]: never; }>(base?: I | undefined): PosthashContext;
-    fromPartial<I_1 extends {
-        init?: {} | undefined;
-        dice?: {
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } | undefined;
-        plinko?: {
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } | undefined;
-    } & {
-        init?: ({} & {} & { [K_4 in Exclude<keyof I_1["init"], never>]: never; }) | undefined;
-        dice?: ({
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & {
-            target?: number | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & { [K_5 in Exclude<keyof I_1["dice"], keyof PosthashDice>]: never; }) | undefined;
-        plinko?: ({
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & {
-            rows?: number | undefined;
-            riskLevel?: string | undefined;
-            clientSeed?: string | undefined;
-            hashchainServerHash?: Uint8Array | undefined;
-        } & { [K_6 in Exclude<keyof I_1["plinko"], keyof PosthashPlinko>]: never; }) | undefined;
-    } & { [K_7 in Exclude<keyof I_1, keyof PosthashContext>]: never; }>(object: I_1): PosthashContext;
+            } & { [K_49 in Exclude<keyof I_1["plinko"]["amount"], keyof import("../amount").Amount>]: never; }) | undefined;
+            possibilities?: (number[] & number[] & { [K_50 in Exclude<keyof I_1["plinko"]["possibilities"], keyof number[]>]: never; }) | undefined;
+        } & { [K_51 in Exclude<keyof I_1["plinko"], keyof Plinko>]: never; }) | undefined;
+        init?: ({} & {} & { [K_52 in Exclude<keyof I_1["init"], never>]: never; }) | undefined;
+    } & { [K_53 in Exclude<keyof I_1, keyof Context>]: never; }>(object: I_1): Context;
 };
 export declare const PosthashInit: {
     encode(_: PosthashInit, writer?: _m0.Writer): _m0.Writer;
@@ -797,55 +708,3 @@ export declare const PosthashInit: {
     create<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(base?: I | undefined): PosthashInit;
     fromPartial<I_1 extends {} & {} & { [K_1 in Exclude<keyof I_1, never>]: never; }>(_: I_1): PosthashInit;
 };
-export declare const PosthashDice: {
-    encode(message: PosthashDice, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): PosthashDice;
-    fromJSON(object: any): PosthashDice;
-    toJSON(message: PosthashDice): unknown;
-    create<I extends {
-        target?: number | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & {
-        target?: number | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & { [K in Exclude<keyof I, keyof PosthashDice>]: never; }>(base?: I | undefined): PosthashDice;
-    fromPartial<I_1 extends {
-        target?: number | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & {
-        target?: number | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & { [K_1 in Exclude<keyof I_1, keyof PosthashDice>]: never; }>(object: I_1): PosthashDice;
-};
-export declare const PosthashPlinko: {
-    encode(message: PosthashPlinko, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): PosthashPlinko;
-    fromJSON(object: any): PosthashPlinko;
-    toJSON(message: PosthashPlinko): unknown;
-    create<I extends {
-        rows?: number | undefined;
-        riskLevel?: string | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & {
-        rows?: number | undefined;
-        riskLevel?: string | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & { [K in Exclude<keyof I, keyof PosthashPlinko>]: never; }>(base?: I | undefined): PosthashPlinko;
-    fromPartial<I_1 extends {
-        rows?: number | undefined;
-        riskLevel?: string | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & {
-        rows?: number | undefined;
-        riskLevel?: string | undefined;
-        clientSeed?: string | undefined;
-        hashchainServerHash?: Uint8Array | undefined;
-    } & { [K_1 in Exclude<keyof I_1, keyof PosthashPlinko>]: never; }>(object: I_1): PosthashPlinko;
-};