@moneypot/hub 1.4.4 → 1.4.5

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;

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-move-client-seed.sql

@@ -0,0 +1,9 @@
+alter table hub.outcome_bet add column client_seed text;
+
+update hub.outcome_bet 
+set client_seed = hash_chain.client_seed 
+from hub.hash_chain where outcome_bet.hash_chain_id = hash_chain.id;
+
+alter table hub.outcome_bet alter column client_seed set not null;
+
+alter table hub.hash_chain drop column client_seed;

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

@@ -12,6 +12,7 @@ declare const OutcomeSchema: z.ZodObject<{
 }>;
 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 +43,7 @@ declare const InputSchema: z.ZodObject<{
     currency: string;
     hashChainId: string;
     kind: string;
+    clientSeed: string;
     wager: number;
     outcomes: {
         profit: number;
@@ -52,6 +54,7 @@ declare const InputSchema: z.ZodObject<{
     currency: string;
     hashChainId: string;
     kind: string;
+    clientSeed: string;
     wager: number;
     outcomes: {
         profit: number;
@@ -69,11 +72,12 @@ type FinalizeMetadataData = {
     hash: Uint8Array;
     outcomes: Outcome[];
     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
         }
 
@@ -246,13 +248,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 +295,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)
@@ -310,6 +313,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     user_id: session.user_id,
                                     casino_id: session.casino_id,
                                     experience_id: session.experience_id,
+                                    client_seed: input.clientSeed,
                                     metadata: finalizedMetadata || {},
                                     ...(betConfig.saveOutcomes
                                         ? {
@@ -335,9 +339,10 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         profit, 
                         outcomes,
                         outcome_idx,
+                        client_seed,
                         metadata
                       )
-                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
                       RETURNING id
                     `,
                                     values: [
@@ -351,6 +356,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         newBet.profit,
                                         newBet.outcomes.map((o) => `(${o.weight},${o.profit})`),
                                         newBet.outcome_idx,
+                                        newBet.client_seed,
                                         newBet.metadata,
                                     ],
                                 })
@@ -402,18 +408,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.5",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [