@moneypot/hub 1.4.4 → 1.4.6

package/dist/src/db/types.d.ts

@@ -119,7 +119,6 @@ export type DbHashChain = {
     user_id: string;
     experience_id: string;
     casino_id: string;
-    client_seed: string;
     max_iterations: number;
     current_iteration: number;
     active: boolean;
@@ -136,9 +135,23 @@ export type DbHash = {
     hash_chain_id: string;
     iteration: number;
     digest: Uint8Array;
+    client_seed: string;
     metadata: Record<string, unknown>;
 };
-export type DbHubOutcome = {
+export type DbOutcome = {
     weight: number;
     profit: number;
 };
+export type DbOutcomeBet = {
+    id: string;
+    hash_id: DbHash["id"];
+    kind: string;
+    wager: number;
+    currency_key: string;
+    profit: number;
+    user_id: string;
+    casino_id: string;
+    experience_id: string;
+    outcomes: DbOutcome[];
+    outcome_idx: number;
+};

package/dist/src/hash-chain/db-hash-chain.d.ts

@@ -6,10 +6,11 @@ export declare function dbLockHubHashChain(pgClient: PgClientInTransaction, { us
     casinoId: DbCasino["id"];
     hashChainId: DbHashChain["id"];
 }): Promise<DbHashChain | null>;
-export declare function dbInsertHubHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, metadata, }: {
+export declare function dbInsertHubHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, clientSeed, metadata, }: {
     hashChainId: DbHashChain["id"];
     kind: DbHash["kind"];
     digest: DbHash["digest"];
     iteration: number;
+    clientSeed?: string;
     metadata?: DbHash["metadata"];
 }): Promise<DbHash>;

package/dist/src/hash-chain/db-hash-chain.js

@@ -1,3 +1,4 @@
+import { DbHashKind, } from "../db/types.js";
 import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
 export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
@@ -17,18 +18,20 @@ export async function dbLockHubHashChain(pgClient, { userId, experienceId, casin
         .then(maybeOneRow)
         .then((row) => row ?? null);
 }
-export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, metadata = {}, }) {
+export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, clientSeed, metadata = {}, }) {
     assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
+    assert(kind === DbHashKind.INTERMEDIATE && typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
     return pgClient
         .query(`
-    INSERT INTO hub.hash (hash_chain_id, kind, digest, iteration, metadata)
-    VALUES ($1, $2, $3, $4, $5)
+    INSERT INTO hub.hash (hash_chain_id, kind, digest, iteration, client_seed, metadata)
+    VALUES ($1, $2, $3, $4, $5, $6)
     RETURNING *
   `, [
         hashChainId,
         kind,
         digest,
         iteration,
+        clientSeed,
         metadata,
     ])
         .then(exactlyOneRow);

package/dist/src/hash-chain/plugins/hub-create-hash-chain.js

@@ -1,47 +1,31 @@
 import { context, object, sideEffect } from "@moneypot/hub/grafast";
 import { gql, makeExtendSchemaPlugin } from "@moneypot/hub/graphile";
 import { GraphQLError } from "graphql";
-import { z } from "zod";
 import { PgAdvisoryLock } from "../../pg-advisory-lock.js";
 import { exactlyOneRow, superuserPool, withPgPoolTransaction, } from "@moneypot/hub/db";
 import * as HashCommon from "../get-hash.js";
 import { DbHashKind } from "../../db/types.js";
 import * as config from "../../config.js";
-const InputSchema = z.object({
-    clientSeed: z.string(),
-});
 export const HubCreateHashChainPlugin = makeExtendSchemaPlugin((build) => {
     const hashChainTable = build.input.pgRegistry.pgResources.hub_hash_chain;
     return {
         typeDefs: gql `
-      input HubCreateHashChainInput {
-        clientSeed: String!
-      }
-
       type HubCreateHashChainPayload {
         hashChain: HubHashChain!
       }
 
       extend type Mutation {
-        hubCreateHashChain(
-          input: HubCreateHashChainInput!
-        ): HubCreateHashChainPayload!
+        hubCreateHashChain: HubCreateHashChainPayload!
       }
     `,
         plans: {
             Mutation: {
-                hubCreateHashChain: (_, { $input }) => {
+                hubCreateHashChain: () => {
                     const $identity = context().get("identity");
-                    const $hashChainId = sideEffect([$input, $identity], ([rawInput, identity]) => {
+                    const $hashChainId = sideEffect([$identity], ([identity]) => {
                         if (identity?.kind !== "user") {
                             throw new GraphQLError("Unauthorized");
                         }
-                        const result = InputSchema.safeParse(rawInput);
-                        if (!result.success) {
-                            const message = result.error.errors[0].message;
-                            throw new GraphQLError(message);
-                        }
-                        const { clientSeed } = result.data;
                         return withPgPoolTransaction(superuserPool, async (pgClient) => {
                             await PgAdvisoryLock.forNewHashChain(pgClient, {
                                 userId: identity.session.user_id,
@@ -66,18 +50,16 @@ export const HubCreateHashChainPlugin = makeExtendSchemaPlugin((build) => {
                     user_id, 
                     experience_id, 
                     casino_id, 
-                    client_seed, 
                     active, 
                     max_iteration, 
                     current_iteration
                   )
-                  VALUES ($1, $2, $3, $4, true, $5, $5)
+                  VALUES ($1, $2, $3, true, $4, $4)
                   RETURNING *
                   `, [
                                 identity.session.user_id,
                                 identity.session.experience_id,
                                 identity.session.casino_id,
-                                clientSeed,
                                 config.HASHCHAINSERVER_MAX_ITERATIONS,
                             ])
                                 .then(exactlyOneRow);

package/dist/src/pg-versions/008-outcome-bet-hash.sql

@@ -0,0 +1,54 @@
+-- Migration: Add hash_id to hub.outcome_bet table
+
+-- Step 1: Add the hash_id column (nullable initially)
+ALTER TABLE hub.outcome_bet 
+ADD COLUMN hash_id uuid REFERENCES hub.hash(id);
+
+-- Step 2: Index 
+CREATE INDEX outcome_bet_hash_id_idx ON hub.outcome_bet(hash_id);
+
+-- Step 3: Update existing rows to set hash_id based on hash_chain_id
+-- This uses a window function to assign row numbers within each hash_chain_id group
+-- ordered by the bet creation time (id)
+WITH bet_iterations AS (
+  SELECT 
+    ob.id,
+    ob.hash_chain_id,
+    hc.max_iteration,
+    -- Row number starting from 1 for each hash_chain_id group
+    -- Ordered by id (which is uuid v7, so it's time-ordered)
+    ROW_NUMBER() OVER (PARTITION BY ob.hash_chain_id ORDER BY ob.id) as bet_sequence
+  FROM hub.outcome_bet ob
+  JOIN hub.hash_chain hc ON hc.id = ob.hash_chain_id
+),
+hash_mapping AS (
+  SELECT 
+    bi.id as bet_id,
+    h.id as hash_id
+  FROM bet_iterations bi
+  JOIN hub.hash h ON 
+    h.hash_chain_id = bi.hash_chain_id AND 
+    -- Calculate the iteration: max_iteration - bet_sequence
+    h.iteration = bi.max_iteration - bi.bet_sequence
+  WHERE h.kind = 'INTERMEDIATE'
+)
+UPDATE hub.outcome_bet ob
+SET hash_id = hm.hash_id
+FROM hash_mapping hm
+WHERE ob.id = hm.bet_id;
+
+-- Step 4: Make hash_id NOT NULL after populating it
+ALTER TABLE hub.outcome_bet ALTER COLUMN hash_id SET NOT NULL;
+
+-- Step 5: Drop hash chain id
+ALTER TABLE hub.outcome_bet DROP COLUMN hash_chain_id;
+
+-- Step 5: Add client_seed column to hash table
+ALTER TABLE hub.hash ADD COLUMN client_seed text null;
+
+-- Step 6: Update hash table with client_seed from hash_chain for each outcome_bet
+UPDATE hub.hash h
+SET client_seed = hc.client_seed
+FROM hub.outcome_bet ob
+JOIN hub.hash_chain hc ON hc.id = ob.hash_chain_id
+WHERE h.id = ob.hash_id;

package/dist/src/plugins/hub-make-outcome-bet.d.ts

@@ -1,17 +1,9 @@
 import { z } from "zod";
+import { DbOutcome } from "../db/index.js";
 import { Result } from "../util.js";
-declare const OutcomeSchema: z.ZodObject<{
-    weight: z.ZodNumber;
-    profit: z.ZodNumber;
-}, "strict", z.ZodTypeAny, {
-    profit: number;
-    weight: number;
-}, {
-    profit: number;
-    weight: number;
-}>;
 declare const InputSchema: z.ZodObject<{
     kind: z.ZodString;
+    clientSeed: z.ZodString;
     wager: z.ZodNumber;
     currency: z.ZodString;
     outcomes: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
@@ -42,6 +34,7 @@ declare const InputSchema: z.ZodObject<{
     currency: string;
     hashChainId: string;
     kind: string;
+    clientSeed: string;
     wager: number;
     outcomes: {
         profit: number;
@@ -52,6 +45,7 @@ declare const InputSchema: z.ZodObject<{
     currency: string;
     hashChainId: string;
     kind: string;
+    clientSeed: string;
     wager: number;
     outcomes: {
         profit: number;
@@ -60,20 +54,20 @@ declare const InputSchema: z.ZodObject<{
     metadata?: Record<string, unknown> | undefined;
 }>;
 type Input = z.infer<typeof InputSchema>;
-type Outcome = z.infer<typeof OutcomeSchema>;
 type Metadata = NonNullable<Input["metadata"]>;
 type FinalizeMetadataData = {
     wager: number;
     currencyKey: string;
     clientSeed: string;
     hash: Uint8Array;
-    outcomes: Outcome[];
+    outcomes: DbOutcome[];
     outcomeIdx: number;
+    roll: number;
 };
 export type OutcomeBetConfig = {
     houseEdge: number;
     saveOutcomes: boolean;
-    allowLossBeyondWager: boolean;
+    allowLossBeyondWager?: boolean;
     initializeMetadataFromUntrustedUserInput?: (input: Input) => Result<Metadata, string>;
     finalizeMetadata?: (validatedMetadata: Metadata, data: FinalizeMetadataData) => Metadata;
 };

package/dist/src/plugins/hub-make-outcome-bet.js

@@ -27,6 +27,7 @@ const OutcomeSchema = z
 const InputSchema = z
     .object({
     kind: z.string(),
+    clientSeed: z.string(),
     wager: z
         .number()
         .int("Wager must be an integer")
@@ -53,7 +54,7 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .gte(0, "House edge must be >= 0")
         .lte(1, "House edge must be <= 1"),
     saveOutcomes: z.boolean(),
-    allowLossBeyondWager: z.boolean().optional().default(false),
+    allowLossBeyondWager: z.boolean().default(false),
     initializeMetadataFromUntrustedUserInput: z
         .function()
         .optional(),
@@ -77,6 +78,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           currency: String!
           outcomes: [HubOutcomeInput!]!
           hashChainId: UUID!
+          clientSeed: String!
           metadata: JSON
         }
 
@@ -230,11 +232,12 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         throw new Error(`Unknown bet hash result: ${_exhaustiveCheck}`);
                                     }
                                 }
-                                await dbInsertHubHash(pgClient, {
+                                const dbHash = await dbInsertHubHash(pgClient, {
                                     hashChainId: dbHashChain.id,
                                     kind: DbHashKind.INTERMEDIATE,
                                     digest: betHashResult.hash,
                                     iteration: betHashIteration,
+                                    clientSeed: input.clientSeed,
                                 });
                                 const result = await pgClient.query(`
                         UPDATE hub.hash_chain
@@ -246,13 +249,13 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 }
                                 const finalHash = (() => {
                                     const serverHash = betHashResult.hash;
-                                    const clientSeed = dbHashChain.client_seed;
+                                    const clientSeed = input.clientSeed;
                                     const finalHash = createHmac("sha256", serverHash)
                                         .update(clientSeed)
                                         .digest();
                                     return finalHash;
                                 })();
-                                const { outcome, outcomeIdx } = pickRandomOutcome({
+                                const { outcome, outcomeIdx, roll } = pickRandomOutcome({
                                     outcomes: input.outcomes,
                                     hash: finalHash,
                                 });
@@ -293,10 +296,11 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 const immutableData = structuredClone({
                                     wager: input.wager,
                                     currencyKey: dbCurrency.key,
-                                    clientSeed: dbHashChain.client_seed,
+                                    clientSeed: input.clientSeed,
                                     hash: betHashResult.hash,
                                     outcomes: input.outcomes,
                                     outcomeIdx,
+                                    roll,
                                 });
                                 const finalizedMetadata = betConfig.finalizeMetadata
                                     ? betConfig.finalizeMetadata(initializedMetadata, immutableData)
@@ -306,7 +310,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     wager: input.wager,
                                     profit: outcome.profit,
                                     currency_key: dbCurrency.key,
-                                    hash_chain_id: input.hashChainId,
+                                    hash_id: dbHash.id,
                                     user_id: session.user_id,
                                     casino_id: session.casino_id,
                                     experience_id: session.experience_id,
@@ -328,7 +332,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         user_id, 
                         casino_id, 
                         experience_id, 
-                        hash_chain_id,
+                        hash_id,
                         kind,
                         currency_key, 
                         wager, 
@@ -344,7 +348,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         newBet.user_id,
                                         newBet.casino_id,
                                         newBet.experience_id,
-                                        newBet.hash_chain_id,
+                                        newBet.hash_id,
                                         newBet.kind,
                                         newBet.currency_key,
                                         newBet.wager,
@@ -402,18 +406,19 @@ function pickRandomOutcome({ outcomes, hash, }) {
     }));
     const totalProb = outcomesWithProbability.reduce((sum, outcome) => sum + outcome.probability, 0);
     assert(Math.abs(totalProb - 1.0) < FLOAT_EPSILON, "Probabilities must sum to ~1");
-    const randomValue = normalizeHash(hash);
+    const roll = normalizeHash(hash);
     let cumulativeProb = 0;
     for (let i = 0; i < outcomesWithProbability.length; i++) {
         const outcome = outcomesWithProbability[i];
         cumulativeProb += outcome.probability;
-        if (randomValue <= cumulativeProb) {
-            return { outcome, outcomeIdx: i };
+        if (roll <= cumulativeProb) {
+            return { outcome, outcomeIdx: i, roll };
         }
     }
     return {
         outcome: outcomes[outcomes.length - 1],
         outcomeIdx: outcomes.length - 1,
+        roll,
     };
 }
 async function finishHashChainInBackground({ hashChainId, }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [