@moneypot/hub 1.3.0-dev.14 → 1.3.0-dev.3

package/dist/src/config.d.ts

@@ -1,9 +1,14 @@
 import "dotenv/config";
-export declare const NODE_ENV: string;
-export declare const PORT: number;
-export declare const MP_GRAPHQL_URL: string;
-export declare const DATABASE_URL: string;
-export declare const SUPERUSER_DATABASE_URL: string;
-export declare const HASHCHAINSERVER_URL: string;
-export declare const HASHCHAINSERVER_MAX_ITERATIONS: number;
-export declare const HASHCHAINSERVER_APPLICATION_SECRET: string;
+export interface Config {
+    NODE_ENV: string;
+    PORT: number;
+    DATABASE_URL: string;
+    SUPERUSER_DATABASE_URL: string;
+    MP_GRAPHQL_URL: string;
+    HASHCHAINSERVER_OPTS: {
+        baseUrl: string;
+        applicationSecret: string;
+    };
+}
+declare const config: Config;
+export default config;

package/dist/src/config.js

@@ -1,83 +1,57 @@
 import "dotenv/config";
 import pgConnectionString from "pg-connection-string";
 import { logger } from "./logger.js";
-import { assert } from "tsafe";
-function getEnvVariable(key, transform = (value) => value) {
-    return transform(process.env[key] || "");
+let NODE_ENV = process.env.NODE_ENV || "";
+if (!NODE_ENV) {
+    NODE_ENV = "development";
+    logger.warn("Missing NODE_ENV env var. Defaulting to 'development'");
 }
-export const NODE_ENV = getEnvVariable("NODE_ENV", (value) => {
-    if (!value) {
-        logger.warn("Missing NODE_ENV env var. Defaulting to 'development'");
-        return "development";
-    }
-    return value;
-});
-export const PORT = getEnvVariable("PORT", (value) => {
-    const parsed = Number.parseInt(value, 10);
-    if (!parsed || parsed <= 0 || !Number.isSafeInteger(parsed)) {
-        logger.warn("Warning: PORT missing or invalid, defaulting to ", parsed);
-        return 4000;
-    }
-    return parsed;
-});
-export const MP_GRAPHQL_URL = getEnvVariable("MP_GRAPHQL_URL", (value) => {
-    if (!value) {
-        logger.warn("Missing MP_GRAPHQL_URL env var. Defaulting to http://localhost:3000/graphql");
-        return "http://localhost:3000/graphql";
-    }
-    if (!URL.parse(value)) {
-        logger.warn("MP_GRAPHQL_URL is not a valid URL. Defaulting to http://localhost:3000/graphql");
-    }
-    const url = new URL(value);
-    if (url.pathname !== "/graphql") {
-        logger.warn("MP_GRAPHQL_URL pathname is not '/graphql'. Are you sure it points to a graphql endpoint?");
-    }
-    return value;
-});
-export const DATABASE_URL = getEnvVariable("DATABASE_URL", (value) => {
-    if (!value) {
-        throw new Error(`Missing DATABASE_URL env var.`);
-    }
-    if (!URL.parse(value)) {
-        logger.warn("DATABASE_URL is not a valid URL.");
-    }
-    const databaseUrlUsername = pgConnectionString.parse(value).user;
-    if (databaseUrlUsername !== "app_postgraphile") {
-        logger.warn(`DATABASE_URL username is ${databaseUrlUsername}, expected app_postgraphile`);
-    }
-    return value;
-});
-export const SUPERUSER_DATABASE_URL = getEnvVariable("SUPERUSER_DATABASE_URL", (value) => {
-    if (!value) {
-        throw new Error("SUPERUSER_DATABASE_URL env var is required");
-    }
-    if (!URL.parse(value)) {
-        logger.warn("SUPERUSER_DATABASE_URL is not a valid URL.");
-    }
-    return value;
-});
-export const HASHCHAINSERVER_URL = getEnvVariable("HASHCHAINSERVER_URL", (value) => {
-    value = value || "mock-server";
-    if (value === "mock-server") {
-        logger.warn("Using mock-server for HASHCHAINSERVER_URL. This is only allowed in development.");
-    }
-    else if (!URL.parse(value)) {
-        logger.warn("HASHCHAINSERVER_URL is not a valid URL. It can either be empty, 'mock-server', or URL but it was: " +
-            value);
-    }
-    if (NODE_ENV !== "development" && value === "mock-server") {
-        logger.warn("Using mock-server for HASHCHAINSERVER_URL. This is only allowed in development.");
-    }
-    return value;
-});
-export const HASHCHAINSERVER_MAX_ITERATIONS = getEnvVariable("HASHCHAINSERVER_MAX_ITERATIONS", (value) => {
-    const iterations = Number.parseInt(value, 10) || 1_000;
-    assert(iterations >= 10, "HASHCHAINSERVER_MAX_ITERATIONS must be >= 10");
-    return iterations;
-});
-export const HASHCHAINSERVER_APPLICATION_SECRET = getEnvVariable("HASHCHAINSERVER_APPLICATION_SECRET", (value) => {
-    if (!value && NODE_ENV !== "development") {
-        logger.warn("Missing HASHCHAINSERVER_APPLICATION_SECRET and NODE_ENV != 'development': To use the hashchain server you must pick a random (but stable) HASHCHAINSERVER_APPLICATION_SECRET for secure communciation with it. (If you aren't using the hashchain server, you can ignore this.)");
+let PORT = Number.parseInt(process.env.PORT || "", 10);
+if (!PORT || PORT <= 0 || !Number.isSafeInteger(PORT)) {
+    PORT = 4000;
+    logger.warn("Warning: PORT missing or invalid, defaulting to ", PORT);
+}
+let MP_GRAPHQL_URL = process.env.MP_GRAPHQL_URL || "";
+if (!MP_GRAPHQL_URL) {
+    MP_GRAPHQL_URL = "http://localhost:3000/graphql";
+    logger.warn(`Missing MP_GRAPHQL_URL env var. Defaulting to ${MP_GRAPHQL_URL}`);
+}
+if (!MP_GRAPHQL_URL.includes("/graphql")) {
+    logger.warn(`MP_GRAPHQL_URL didn't include '/graphql'. Are you sure it points to a graphql endpoint?`);
+}
+const DATABASE_URL = process.env.DATABASE_URL || "";
+if (!DATABASE_URL) {
+    throw new Error(`Missing DATABASE_URL env var.`);
+}
+const databaseUrlUsername = pgConnectionString.parse(DATABASE_URL).user;
+if (databaseUrlUsername !== "app_postgraphile") {
+    logger.warn(`DATABASE_URL username is ${databaseUrlUsername}, expected app_postgraphile`);
+}
+const SUPERUSER_DATABASE_URL = process.env.SUPERUSER_DATABASE_URL || "";
+if (!SUPERUSER_DATABASE_URL) {
+    throw new Error("SUPERUSER_DATABASE_URL env var is required");
+}
+const HASHCHAINSERVER_URL = process.env.HASHCHAINSERVER_URL || "mock-server";
+if (HASHCHAINSERVER_URL == "mock-server") {
+    logger.warn(`Missing HASHCHAINSERVER_URL env var, defaulting to mock-server.`);
+    if (NODE_ENV !== "development") {
+        logger.warn("Missing HASHCHAINSERVER_URL and NODE_ENV != 'development': You're using the hashchain mock-server outside of development. (If you aren't using the hashchain server, you can ignore this.)");
     }
-    return value || "";
-});
+}
+const HASHCHAINSERVER_APPLICATION_SECRET = process.env.HASHCHAINSERVER_APPLICATION_SECRET || "";
+if (!HASHCHAINSERVER_APPLICATION_SECRET && NODE_ENV !== "development") {
+    logger.warn("Missing HASHCHAINSERVER_APPLICATION_SECRET and NODE_ENV != 'development': To use the hashchain server you must pick a random (but stable) HASHCHAINSERVER_APPLICATION_SECRET for secure communciation with it. (If you aren't using the hashchain server, you can ignore this.)");
+}
+const HASHCHAINSERVER_OPTS = {
+    baseUrl: HASHCHAINSERVER_URL,
+    applicationSecret: HASHCHAINSERVER_APPLICATION_SECRET,
+};
+const config = {
+    NODE_ENV,
+    PORT,
+    DATABASE_URL,
+    SUPERUSER_DATABASE_URL,
+    MP_GRAPHQL_URL,
+    HASHCHAINSERVER_OPTS,
+};
+export default config;

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

@@ -2,7 +2,6 @@ import * as pg from "pg";
 import stream from "node:stream";
 import { DbCasino, DbExperience, DbSession, DbTransferStatusKind, DbUser, DbWithdrawal } from "./types.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
-export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";

package/dist/src/db/index.js

@@ -1,11 +1,10 @@
 import * as pg from "pg";
-import * as config from "../config.js";
+import config from "../config.js";
 import stream from "node:stream";
 import { exactlyOneRow, maybeOneRow } from "./util.js";
 import { logger } from "../logger.js";
 import { setTimeout } from "node:timers/promises";
 import { assert } from "tsafe";
-export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";

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

@@ -114,31 +114,3 @@ export type DbTakeRequest = {
     transfer_completion_attempted_at: Date | null;
     updated_at: Date;
 };
-export type DbHashChain = {
-    id: string;
-    user_id: string;
-    experience_id: string;
-    casino_id: string;
-    client_seed: string;
-    max_iterations: number;
-    current_iteration: number;
-    active: boolean;
-};
-export declare const DbHashKind: {
-    readonly TERMINAL: "TERMINAL";
-    readonly INTERMEDIATE: "INTERMEDIATE";
-    readonly PREIMAGE: "PREIMAGE";
-};
-export type DbHashKind = (typeof DbHashKind)[keyof typeof DbHashKind];
-export type DbHash = {
-    id: string;
-    kind: DbHashKind;
-    hash_chain_id: string;
-    iteration: number;
-    digest: Uint8Array;
-    metadata: Record<string, unknown>;
-};
-export type DbHubOutcome = {
-    weight: number;
-    profit: number;
-};

package/dist/src/db/types.js

@@ -1,5 +1 @@
-export const DbHashKind = {
-    TERMINAL: "TERMINAL",
-    INTERMEDIATE: "INTERMEDIATE",
-    PREIMAGE: "PREIMAGE",
-};
+export {};

package/dist/src/index.js

@@ -1,6 +1,6 @@
 import PgUpgradeSchema, { DatabaseAheadError, } from "@moneypot/pg-upgrade-schema";
 import * as db from "./db/index.js";
-import * as config from "./config.js";
+import config from "./config.js";
 import { createHubServer } from "./server/index.js";
 import { initializeTransferProcessors } from "./process-transfers.js";
 import { join } from "path";

package/dist/src/pg-advisory-lock.d.ts

@@ -1,13 +1,8 @@
-import { DbCasino, DbExperience, DbProcessedTakeRequest, DbUser } from "./db/types.js";
-import { PgClientInTransaction } from "./db/index.js";
-export declare const PgAdvisoryLock: {
-    forMpTakeRequestProcessing: (pgClient: PgClientInTransaction, params: {
+import { PoolClient } from "pg";
+import { DbCasino, DbProcessedTakeRequest } from "./db/types.js";
+export declare const pgAdvisoryLock: {
+    forMpTakeRequestProcessing: (pgClient: PoolClient, params: {
         mpTakeRequestId: DbProcessedTakeRequest["mp_take_request_id"];
         casinoId: DbCasino["id"];
     }) => Promise<void>;
-    forNewHashChain: (pgClient: PgClientInTransaction, params: {
-        userId: DbUser["id"];
-        experienceId: DbExperience["id"];
-        casinoId: DbCasino["id"];
-    }) => Promise<void>;
 };

package/dist/src/pg-advisory-lock.js

@@ -1,8 +1,6 @@
-import { assert } from "tsafe";
 var LockNamespace;
 (function (LockNamespace) {
     LockNamespace[LockNamespace["MP_TAKE_REQUEST"] = 1] = "MP_TAKE_REQUEST";
-    LockNamespace[LockNamespace["NEW_HASH_CHAIN"] = 2] = "NEW_HASH_CHAIN";
 })(LockNamespace || (LockNamespace = {}));
 function simpleHash32(text) {
     let hash = 0;
@@ -22,13 +20,8 @@ async function acquireAdvisoryLock(pgClient, namespace, hash) {
         values: [namespace, hash],
     });
 }
-export const PgAdvisoryLock = {
+export const pgAdvisoryLock = {
     forMpTakeRequestProcessing: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.MP_TAKE_REQUEST, createHashKey(params.mpTakeRequestId, params.casinoId));
     },
-    forNewHashChain: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
-        await acquireAdvisoryLock(pgClient, LockNamespace.NEW_HASH_CHAIN, createHashKey(params.userId, params.experienceId, params.casinoId));
-    },
 };

package/dist/src/pg-versions/{006-outcome-bet.sql → 005-outcome-bet.sql}

@@ -1,6 +1,3 @@
-drop table if exists hub.outcome_bet cascade;
-drop type if exists hub.outcome cascade;
-
 create type hub.outcome as (
     weight float,
     profit float
@@ -17,9 +14,6 @@ create table hub.outcome_bet (
     experience_id uuid not null references hub.experience(id),
     casino_id     uuid not null references hub.casino(id),
 
-    -- provably fair hash chain
-    hash_chain_id uuid not null references hub.hash_chain(id),
-
     currency_key text not null,
     wager        float not null,
 
@@ -30,7 +24,7 @@ create table hub.outcome_bet (
     profit       float not null,
 
     -- null when no outcomes saved
-    outcome_idx  smallint null check (outcome_idx between 0 and array_length(outcomes,1)-1),
+    outcome_idx  smallint null,
     outcomes     hub.outcome[] not null default '{}',
 
     -- Operator-provided data per bet
@@ -43,7 +37,6 @@ create index outcome_bet_user_id_idx on hub.outcome_bet(user_id);
 create index outcome_bet_experience_id_idx on hub.outcome_bet(experience_id);
 create index outcome_bet_casino_id_idx on hub.outcome_bet(casino_id);
 create index outcome_bet_kind_idx on hub.outcome_bet(kind);
-create index outcome_bet_hash_chain_id_idx on hub.outcome_bet(hash_chain_id);
 
 -- GRANT
 

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

@@ -1,15 +1,4 @@
 import { z } from "zod";
-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;
     wager: z.ZodNumber;
@@ -18,62 +7,46 @@ declare const InputSchema: z.ZodObject<{
         weight: z.ZodNumber;
         profit: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
-        profit: number;
         weight: number;
-    }, {
         profit: number;
+    }, {
         weight: number;
-    }>, "many">, {
         profit: number;
+    }>, "many">, {
         weight: number;
-    }[], {
         profit: number;
+    }[], {
         weight: number;
-    }[]>, {
         profit: number;
+    }[]>, {
         weight: number;
-    }[], {
         profit: number;
+    }[], {
         weight: number;
+        profit: number;
     }[]>;
-    hashChainId: z.ZodString;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strict", z.ZodTypeAny, {
     currency: string;
-    hashChainId: string;
     kind: string;
     wager: number;
     outcomes: {
-        profit: number;
         weight: number;
+        profit: number;
     }[];
-    metadata?: Record<string, any> | undefined;
 }, {
     currency: string;
-    hashChainId: string;
     kind: string;
     wager: number;
     outcomes: {
-        profit: number;
         weight: number;
+        profit: number;
     }[];
-    metadata?: Record<string, any> | undefined;
 }>;
 type Input = z.infer<typeof InputSchema>;
-type Outcome = z.infer<typeof OutcomeSchema>;
-type FinalizeMetadataData = {
-    wager: number;
-    currencyKey: string;
-    clientSeed: string;
-    hash: Uint8Array;
-    outcomes: Outcome[];
-    outcomeIdx: number;
-};
 export type OutcomeBetConfig = {
     houseEdge: number;
     saveOutcomes: boolean;
-    initializeMetadataFromUntrustedUserInput?: (input: Input) => Result<Record<string, any>, string>;
-    finalizeMetadata?: (validatedMetadata: Record<string, any>, data: FinalizeMetadataData) => Record<string, any>;
+    getMetadata?: (input: Input) => Promise<Record<string, any>>;
 };
 export type OutcomeBetConfigMap<BetKind extends string> = {
     [betKind in BetKind]: OutcomeBetConfig;

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

@@ -1,12 +1,9 @@
-import { access, context, object, ObjectStep, polymorphicBranch, sideEffect, } from "postgraphile/grafast";
+import { context, object, sideEffect } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import { z } from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
-import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
-import { getIntermediateHash, getPreimageHash, } from "../hash-chain/get-hash.js";
-import { createHmac } from "node:crypto";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -38,8 +35,6 @@ const InputSchema = z
         .max(50, "Outcome count must be <= 50")
         .refine((data) => data.some((o) => o.profit < 0), "At least one outcome should have profit < 0")
         .refine((data) => data.some((o) => o.profit > 0), "At least one outcome should have profit > 0"),
-    hashChainId: z.string().uuid("Invalid hash chain ID"),
-    metadata: z.record(z.string(), z.any()).optional(),
 })
     .strict();
 const BetKindSchema = z
@@ -53,11 +48,10 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .gte(0, "House edge must be >= 0")
         .lte(1, "House edge must be <= 1"),
     saveOutcomes: z.boolean(),
-    initializeMetadataFromUntrustedUserInput: z
-        .function()
-        .optional(),
-    finalizeMetadata: z
+    getMetadata: z
         .function()
+        .args(InputSchema)
+        .returns(z.record(z.string(), z.any()))
         .optional(),
 }));
 export function MakeOutcomeBetPlugin({ betConfigs }) {
@@ -75,18 +69,10 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           wager: Int!
           currency: String!
           outcomes: [HubOutcomeInput!]!
-          hashChainId: UUID!
-          metadata: JSON
-        }
-
-        type HubMakeOutcomeBetSuccess {
-          bet: HubOutcomeBet!
         }
 
-        union HubMakeOutcomeBetResult = HubMakeOutcomeBetSuccess | HubBadHashChainError
-
         type HubMakeOutcomeBetPayload {
-          result: HubMakeOutcomeBetResult!
+          bet: HubOutcomeBet!
         }
 
         extend type Mutation {
@@ -99,7 +85,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                 Mutation: {
                     hubMakeOutcomeBet: (_, { $input }) => {
                         const $identity = context().get("identity");
-                        const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                        const $betId = sideEffect([$identity, $input], async ([identity, rawInput]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("Unauthorized");
                             }
@@ -122,16 +108,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                             if (!betKinds.includes(rawInput.kind)) {
                                 throw new GraphQLError(`Invalid bet kind`);
                             }
-                            let initializedMetadata;
-                            if (betConfig.initializeMetadataFromUntrustedUserInput) {
-                                const result = betConfig.initializeMetadataFromUntrustedUserInput(input);
-                                if (result.ok) {
-                                    initializedMetadata = result.value;
-                                }
-                                else {
-                                    throw new GraphQLError(`Invalid input: ${result.error}`);
-                                }
-                            }
                             const houseEV = calculateHouseEV(input.outcomes);
                             const minHouseEV = Math.max(0, betConfig.houseEdge - FLOAT_EPSILON);
                             if (houseEV < minHouseEV) {
@@ -182,76 +158,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 if (maxPotentialPayout > maxAllowablePayout) {
                                     throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
                                 }
-                                const dbHashChain = await dbLockHubHashChain(pgClient, {
-                                    userId: session.user_id,
-                                    experienceId: session.experience_id,
-                                    casinoId: session.casino_id,
-                                    hashChainId: input.hashChainId,
-                                });
-                                if (!dbHashChain || !dbHashChain.active) {
-                                    return {
-                                        __typename: "HubBadHashChainError",
-                                        message: "Active hash chain not found",
-                                    };
-                                }
-                                if (dbHashChain.current_iteration <= 1) {
-                                    if (dbHashChain.current_iteration === 1) {
-                                        finishHashChainInBackground({
-                                            hashChainId: input.hashChainId,
-                                        }).catch((e) => {
-                                            console.error("Error finishing hash chain in background", { hashChainId: input.hashChainId, error: e });
-                                        });
-                                    }
-                                    return {
-                                        __typename: "HubBadHashChainError",
-                                        message: "Hash chain drained. Create a new one.",
-                                    };
-                                }
-                                const betHashIteration = dbHashChain.current_iteration - 1;
-                                assert(betHashIteration > 0, "Bet hash iteration must be > 0");
-                                const betHashResult = await getIntermediateHash({
-                                    hashChainId: input.hashChainId,
-                                    iteration: betHashIteration,
-                                });
-                                switch (betHashResult.type) {
-                                    case "success":
-                                        break;
-                                    case "bad_hash_chain":
-                                        return {
-                                            __typename: "HubBadHashChainError",
-                                            message: "Hash chain not found",
-                                        };
-                                    default: {
-                                        const _exhaustiveCheck = betHashResult;
-                                        throw new Error(`Unknown bet hash result: ${_exhaustiveCheck}`);
-                                    }
-                                }
-                                await dbInsertHubHash(pgClient, {
-                                    hashChainId: dbHashChain.id,
-                                    kind: DbHashKind.INTERMEDIATE,
-                                    digest: betHashResult.hash,
-                                    iteration: betHashIteration,
-                                });
-                                const result = await pgClient.query(`
-                        UPDATE hub.hash_chain
-                        SET current_iteration = $2
-                        WHERE id = $1
-                    `, [dbHashChain.id, betHashIteration]);
-                                if (result.rowCount !== 1) {
-                                    throw new GraphQLError("Failed to update hash chain iteration");
-                                }
-                                const finalHash = (() => {
-                                    const serverHash = betHashResult.hash;
-                                    const clientSeed = dbHashChain.client_seed;
-                                    const finalHash = createHmac("sha256", serverHash)
-                                        .update(clientSeed)
-                                        .digest();
-                                    return finalHash;
-                                })();
-                                const { outcome, outcomeIdx } = pickRandomOutcome({
-                                    outcomes: input.outcomes,
-                                    hash: finalHash,
-                                });
+                                const { outcome, outcomeIdx } = pickRandomOutcome(input.outcomes);
                                 const netPlayerAmount = input.wager * outcome.profit;
                                 await pgClient.query({
                                     text: `
@@ -286,27 +193,17 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         input.wager,
                                     ],
                                 });
-                                const immutableData = structuredClone({
-                                    wager: input.wager,
-                                    currencyKey: dbCurrency.key,
-                                    clientSeed: dbHashChain.client_seed,
-                                    hash: betHashResult.hash,
-                                    outcomes: input.outcomes,
-                                    outcomeIdx,
-                                });
-                                const finalizedMetadata = betConfig.finalizeMetadata
-                                    ? betConfig.finalizeMetadata(initializedMetadata, immutableData)
-                                    : initializedMetadata;
                                 const newBet = {
                                     kind: rawInput.kind,
                                     wager: input.wager,
                                     profit: outcome.profit,
                                     currency_key: dbCurrency.key,
-                                    hash_chain_id: input.hashChainId,
                                     user_id: session.user_id,
                                     casino_id: session.casino_id,
                                     experience_id: session.experience_id,
-                                    metadata: finalizedMetadata || {},
+                                    metadata: betConfig.getMetadata
+                                        ? await betConfig.getMetadata(input)
+                                        : {},
                                     ...(betConfig.saveOutcomes
                                         ? {
                                             outcomes: input.outcomes,
@@ -324,7 +221,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         user_id, 
                         casino_id, 
                         experience_id, 
-                        hash_chain_id,
                         kind,
                         currency_key, 
                         wager, 
@@ -333,14 +229,13 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         outcome_idx,
                         metadata
                       )
-                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                       RETURNING id
                     `,
                                     values: [
                                         newBet.user_id,
                                         newBet.casino_id,
                                         newBet.experience_id,
-                                        newBet.hash_chain_id,
                                         newBet.kind,
                                         newBet.currency_key,
                                         newBet.wager,
@@ -351,31 +246,11 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     ],
                                 })
                                     .then(exactlyOneRow);
-                                return {
-                                    __typename: "HubMakeOutcomeBetSuccess",
-                                    betId: bet.id,
-                                };
+                                return bet.id;
                             });
                         });
                         return object({
-                            result: $result,
-                        });
-                    },
-                },
-                HubMakeOutcomeBetSuccess: {
-                    __assertStep: ObjectStep,
-                    bet($data) {
-                        const $betId = access($data, "betId");
-                        return outcomeBetTable.get({ id: $betId });
-                    },
-                },
-                HubMakeOutcomeBetPayload: {
-                    __assertStep: ObjectStep,
-                    result($data) {
-                        const $result = $data.get("result");
-                        return polymorphicBranch($result, {
-                            HubMakeOutcomeBetSuccess: {},
-                            HubBadHashChainError: {},
+                            bet: outcomeBetTable.get({ id: $betId }),
                         });
                     },
                 },
@@ -383,13 +258,12 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-function normalizeHash(hash) {
-    assert(hash.length >= 4, "Hash must be at least 4 bytes");
-    const view = new DataView(hash.buffer, hash.byteOffset, Math.min(hash.byteLength, 4));
-    const uint32Value = view.getUint32(0, false);
-    return uint32Value / Math.pow(2, 32);
+function generateRandomNumber() {
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0] / 2 ** 32;
 }
-function pickRandomOutcome({ outcomes, hash, }) {
+function pickRandomOutcome(outcomes) {
     assert(outcomes.length >= 2, "Outcome count must be >= 2");
     const totalWeight = sum(outcomes.map((o) => o.weight));
     const outcomesWithProbability = outcomes.map((o) => ({
@@ -398,12 +272,12 @@ 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);
-    let cumulativeProb = 0;
+    const randomValue = generateRandomNumber();
+    let cumProb = 0;
     for (let i = 0; i < outcomesWithProbability.length; i++) {
         const outcome = outcomesWithProbability[i];
-        cumulativeProb += outcome.probability;
-        if (randomValue <= cumulativeProb) {
+        cumProb += outcome.probability;
+        if (randomValue <= cumProb) {
             return { outcome, outcomeIdx: i };
         }
     }
@@ -449,41 +323,3 @@ async function dbLockBalanceAndBankroll(pgClient, { userId, casinoId, experience
             dbHouseBankroll: null,
         };
 }
-async function finishHashChainInBackground({ hashChainId, }) {
-    console.log("Finishing hash chain in background", { hashChainId });
-    const preimageHashResult = await getPreimageHash({
-        hashChainId,
-    });
-    console.log("Preimage hash result", { preimageHashResult });
-    if (preimageHashResult.type === "success") {
-        console.log("Inserting preimage hash", {
-            hashChainId,
-            kind: DbHashKind.PREIMAGE,
-            digest: preimageHashResult.hash,
-            iteration: 0,
-        });
-        await withPgPoolTransaction(superuserPool, async (pgClient) => {
-            await dbInsertHubHash(pgClient, {
-                hashChainId,
-                kind: DbHashKind.PREIMAGE,
-                digest: preimageHashResult.hash,
-                iteration: 0,
-            });
-            const result = await pgClient.query(`
-        UPDATE hub.hash_chain
-        SET current_iteration = 0,
-            active = false
-        WHERE id = $1
-      `, [hashChainId]);
-            if (result.rowCount !== 1) {
-                throw new Error("Failed to update hash chain iteration");
-            }
-        });
-    }
-    else {
-        console.warn("Failed to insert preimage hash in background", {
-            hashChainId,
-            error: preimageHashResult,
-        });
-    }
-}

package/dist/src/process-transfers.js

@@ -6,7 +6,7 @@ import EventEmitter from "events";
 import { superuserPool } from "./db/index.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "./db/internal.js";
 import pg from "pg";
-import * as config from "./config.js";
+import config from "./config.js";
 import { z } from "zod";
 import { gql } from "./__generated__/gql.js";
 import { logger } from "./logger.js";

package/dist/src/server/graphile.config.js

@@ -2,7 +2,7 @@ import "graphile-config";
 import "postgraphile";
 import { makePgService } from "postgraphile/adaptors/pg";
 import { PostGraphileAmberPreset } from "postgraphile/presets/amber";
-import * as config from "../config.js";
+import config from "../config.js";
 import { maskError } from "./handle-errors.js";
 import * as db from "../db/index.js";
 import { SmartTagsPlugin } from "../smart-tags.js";
@@ -20,10 +20,6 @@ import { HubAddCasinoPlugin } from "../plugins/hub-add-casino.js";
 import { HubBalanceAlertPlugin } from "../plugins/hub-balance-alert.js";
 import { custom as customPgOmitArchivedPlugin } from "@graphile-contrib/pg-omit-archived";
 import { HubCurrentXPlugin } from "../plugins/hub-current-x.js";
-import { HubCreateHashChainPlugin } from "../hash-chain/plugins/hub-create-hash-chain.js";
-import { HubBadHashChainErrorPlugin } from "../hash-chain/plugins/hub-bad-hash-chain-error.js";
-import { HubUserActiveHashChainPlugin } from "../hash-chain/plugins/hub-user-active-hash-chain.js";
-import { HubOutcomeInputNonNullFieldsPlugin } from "../plugins/hub-outcome-input-non-null-fields.js";
 export const requiredPlugins = [
     SmartTagsPlugin,
     IdToNodeIdPlugin,
@@ -39,10 +35,6 @@ export const requiredPlugins = [
 export const defaultPlugins = [
     ...(config.NODE_ENV === "development" ? [DebugPlugin] : []),
     ...requiredPlugins,
-    HubOutcomeInputNonNullFieldsPlugin,
-    HubBadHashChainErrorPlugin,
-    HubCreateHashChainPlugin,
-    HubUserActiveHashChainPlugin,
     HubClaimFaucetPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];

package/dist/src/server/handle-errors.js

@@ -1,5 +1,5 @@
 import { GraphQLError } from "postgraphile/graphql";
-import * as config from "../config.js";
+import config from "../config.js";
 const isDev = config.NODE_ENV === "development";
 const isTest = config.NODE_ENV === "test";
 const camelCase = (s) => s.toLowerCase().replace(/(_\\w)/g, (m) => m[1].toUpperCase());

package/dist/src/server/index.js

@@ -3,7 +3,7 @@ import { grafserv } from "grafserv/express/v4";
 import postgraphile from "postgraphile";
 import { createPreset, defaultPlugins } from "./graphile.config.js";
 import express from "express";
-import * as config from "../config.js";
+import config from "../config.js";
 import { logger } from "../logger.js";
 import cors from "./middleware/cors.js";
 import authentication from "./middleware/authentication.js";

package/dist/src/take-request/process-take-request.js

@@ -2,7 +2,7 @@ import { gql } from "../__generated__/gql.js";
 import { TakeRequestStatus as MpTakeRequestStatus, TransferStatusKind as MpTransferStatus, } from "../__generated__/graphql.js";
 import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
-import { PgAdvisoryLock } from "../pg-advisory-lock.js";
+import { pgAdvisoryLock } from "../pg-advisory-lock.js";
 const MP_PAGINATE_PENDING_TAKE_REQUESTS = gql(`
   query MpPaginatedPendingTakeRequests($controllerId: UUID!, $after: Cursor) {
     allTakeRequests(
@@ -178,7 +178,7 @@ async function fetchPendingTakeRequests(graphqlClient, controllerId) {
 }
 async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }) {
     return withPgPoolTransaction(superuserPool, async (pgClient) => {
-        await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
             mpTakeRequestId,
             casinoId,
         });
@@ -457,7 +457,7 @@ async function processPendingTransferCompletions({ casinoId, graphqlClient, abor
 }
 async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTransferId, graphqlClient, casinoId, }) {
     return withPgPoolTransaction(superuserPool, async (pgClient) => {
-        await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
             mpTakeRequestId,
             casinoId,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.3.0-dev.14",
+  "version": "1.3.0-dev.3",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [

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

@@ -1,15 +0,0 @@
-import { DbCasino, DbExperience, DbHash, DbHashChain, DbUser } from "../db/types.js";
-import { PgClientInTransaction } from "../db/index.js";
-export declare function dbLockHubHashChain(pgClient: PgClientInTransaction, { userId, experienceId, casinoId, hashChainId, }: {
-    userId: DbUser["id"];
-    experienceId: DbExperience["id"];
-    casinoId: DbCasino["id"];
-    hashChainId: DbHashChain["id"];
-}): Promise<DbHashChain | null>;
-export declare function dbInsertHubHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, metadata, }: {
-    hashChainId: DbHashChain["id"];
-    kind: DbHash["kind"];
-    digest: DbHash["digest"];
-    iteration: number;
-    metadata?: DbHash["metadata"];
-}): Promise<DbHash>;

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

@@ -1,35 +0,0 @@
-import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
-import { assert } from "tsafe";
-export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
-    assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
-    return pgClient
-        .query(`
-       SELECT * 
-       FROM hub.hash_chain 
-       WHERE id = $1 
-         AND user_id = $2
-         AND experience_id = $3
-         AND casino_id = $4
-         AND active = TRUE
-       
-       FOR UPDATE
-    `, [hashChainId, userId, experienceId, casinoId])
-        .then(maybeOneRow)
-        .then((row) => row ?? null);
-}
-export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, metadata = {}, }) {
-    assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
-    return pgClient
-        .query(`
-    INSERT INTO hub.hash (hash_chain_id, kind, digest, iteration, metadata)
-    VALUES ($1, $2, $3, $4, $5)
-    RETURNING *
-  `, [
-        hashChainId,
-        kind,
-        digest,
-        iteration,
-        metadata,
-    ])
-        .then(exactlyOneRow);
-}

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

@@ -1,17 +0,0 @@
-export type HashResult = {
-    type: "bad_hash_chain";
-    reason: "hashchain_too_old" | "empty_response";
-} | {
-    type: "success";
-    hash: Uint8Array;
-};
-export declare function getIntermediateHash({ hashChainId, iteration, }: {
-    hashChainId: string;
-    iteration: number;
-}): Promise<HashResult>;
-export declare function getPreimageHash({ hashChainId, }: {
-    hashChainId: string;
-}): Promise<HashResult>;
-export declare function getTerminalHash({ hashChainId, }: {
-    hashChainId: string;
-}): Promise<HashResult>;

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

@@ -1,57 +0,0 @@
-import { getHash } from "@moneypot/hash-herald";
-import * as config from "../config.js";
-const HASH_HERALD_OPTIONS = {
-    baseUrl: config.HASHCHAINSERVER_URL,
-    applicationSecret: config.HASHCHAINSERVER_APPLICATION_SECRET,
-};
-function resultFromGetHashResponse(response) {
-    if (!response.resp) {
-        return { type: "bad_hash_chain", reason: "empty_response" };
-    }
-    const $case = response.resp.$case;
-    switch ($case) {
-        case "hash":
-            return { type: "success", hash: response.resp.value };
-        case "hashchainTooOldError":
-            return { type: "bad_hash_chain", reason: "hashchain_too_old" };
-        default: {
-            const _exhaustiveCheck = $case;
-            throw new Error(`Unknown hash response: ${_exhaustiveCheck}`);
-        }
-    }
-}
-export async function getIntermediateHash({ hashChainId, iteration, }) {
-    const req = {
-        hashchainId: hashChainId,
-        iterations: iteration,
-        context: undefined,
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}
-export async function getPreimageHash({ hashChainId, }) {
-    const req = {
-        hashchainId: hashChainId,
-        iterations: 0,
-        context: {
-            event: {
-                $case: "fetchingPreimage",
-                value: {},
-            },
-        },
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}
-export async function getTerminalHash({ hashChainId, }) {
-    const iterations = 1_000;
-    const req = {
-        hashchainId: hashChainId,
-        iterations,
-        context: {
-            event: {
-                $case: "fetchingTerminalHash",
-                value: {},
-            },
-        },
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}

package/dist/src/hash-chain/plugins/hub-bad-hash-chain-error.d.ts

@@ -1 +0,0 @@
-export declare const HubBadHashChainErrorPlugin: GraphileConfig.Plugin;

package/dist/src/hash-chain/plugins/hub-bad-hash-chain-error.js

@@ -1,20 +0,0 @@
-import { ObjectStep, access } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-export const HubBadHashChainErrorPlugin = makeExtendSchemaPlugin(() => {
-    return {
-        typeDefs: gql `
-      type HubBadHashChainError {
-        message: String
-      }
-    `,
-        plans: {
-            HubBadHashChainError: {
-                __assertStep: ObjectStep,
-                message($data) {
-                    const $message = access($data, "message");
-                    return $message;
-                },
-            },
-        },
-    };
-}, "HubBadHashChainErrorPlugin");

package/dist/src/hash-chain/plugins/hub-create-hash-chain.d.ts

@@ -1 +0,0 @@
-export declare const HubCreateHashChainPlugin: GraphileConfig.Plugin;

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

@@ -1,111 +0,0 @@
-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!
-      }
-    `,
-        plans: {
-            Mutation: {
-                hubCreateHashChain: (_, { $input }) => {
-                    const $identity = context().get("identity");
-                    const $hashChainId = sideEffect([$input, $identity], ([rawInput, 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,
-                                experienceId: identity.session.experience_id,
-                                casinoId: identity.session.casino_id,
-                            });
-                            await pgClient.query(`
-                  UPDATE hub.hash_chain
-                  SET active = false
-                  WHERE user_id = $1 
-                    AND experience_id = $2
-                    AND casino_id = $3
-                    AND active = true
-                  `, [
-                                identity.session.user_id,
-                                identity.session.experience_id,
-                                identity.session.casino_id,
-                            ]);
-                            const dbHashChain = await pgClient
-                                .query(`
-                  INSERT INTO hub.hash_chain (
-                    user_id, 
-                    experience_id, 
-                    casino_id, 
-                    client_seed, 
-                    active, 
-                    max_iteration, 
-                    current_iteration
-                  )
-                  VALUES ($1, $2, $3, $4, true, $5, $5)
-                  RETURNING *
-                  `, [
-                                identity.session.user_id,
-                                identity.session.experience_id,
-                                identity.session.casino_id,
-                                clientSeed,
-                                config.HASHCHAINSERVER_MAX_ITERATIONS,
-                            ])
-                                .then(exactlyOneRow);
-                            const terminalHash = await HashCommon.getTerminalHash({
-                                hashChainId: dbHashChain.id,
-                            });
-                            await pgClient.query(`
-                  INSERT INTO hub.hash (
-                    hash_chain_id, 
-                    kind, 
-                    digest, 
-                    iteration
-                  )
-                  VALUES ($1, $2, $3, $4)
-                  `, [
-                                dbHashChain.id,
-                                DbHashKind.TERMINAL,
-                                terminalHash,
-                                config.HASHCHAINSERVER_MAX_ITERATIONS,
-                            ]);
-                            return dbHashChain.id;
-                        });
-                    });
-                    return object({
-                        hashChain: hashChainTable.get({ id: $hashChainId }),
-                    });
-                },
-            },
-        },
-    };
-}, "CreateHashChainPlugin");

package/dist/src/hash-chain/plugins/hub-user-active-hash-chain.d.ts

@@ -1 +0,0 @@
-export declare const HubUserActiveHashChainPlugin: GraphileConfig.Plugin;

package/dist/src/hash-chain/plugins/hub-user-active-hash-chain.js

@@ -1,46 +0,0 @@
-import { maybeOneRow } from "@moneypot/hub/db";
-import { inhibitOnNull } from "@moneypot/hub/grafast";
-import { context } from "@moneypot/hub/grafast";
-import { gql, makeExtendSchemaPlugin } from "@moneypot/hub/graphile";
-import { withPgClient } from "postgraphile/@dataplan/pg";
-import { object } from "postgraphile/grafast";
-export const HubUserActiveHashChainPlugin = makeExtendSchemaPlugin((build) => {
-    const hashChainTable = build.input.pgRegistry.pgResources.hub_hash_chain;
-    return {
-        typeDefs: gql `
-      extend type HubUser {
-        activeHashChain: HubHashChain
-      }
-    `,
-        plans: {
-            HubUser: {
-                activeHashChain: ($record) => {
-                    const $identity = context().get("identity");
-                    const $hashChainId = withPgClient(hashChainTable.executor, object({ userId: $record.get("id"), identity: $identity }), async (pgClient, { userId, identity }) => {
-                        if (identity?.kind !== "user") {
-                            return null;
-                        }
-                        const { session } = identity;
-                        const activeHashChain = await pgClient
-                            .query({
-                            text: `
-                    select id
-                    from hub.hash_chain
-                    where user_id = $1
-                      and experience_id = $2
-                      and casino_id = $3
-                      and active = TRUE
-                    order by id desc
-                    limit 1
-                  `,
-                            values: [userId, session.experience_id, session.casino_id],
-                        })
-                            .then(maybeOneRow);
-                        return activeHashChain?.id ?? null;
-                    });
-                    return hashChainTable.get({ id: inhibitOnNull($hashChainId) });
-                },
-            },
-        },
-    };
-}, "HubActiveHashChainPlugin");

package/dist/src/pg-versions/005-hash-chain.sql

@@ -1,84 +0,0 @@
-CREATE TABLE hub.hash_chain (
-  id            uuid PRIMARY KEY DEFAULT hub_hidden.uuid_generate_v7(),
-  user_id       uuid NOT NULL REFERENCES hub.user(id),
-  experience_id uuid NOT NULL REFERENCES hub.experience(id),
-  casino_id     uuid NOT NULL REFERENCES hub.casino(id),
-  client_seed   text NOT NULL,
-  active        boolean NOT NULL,
-
-  max_iteration int NOT NULL check (max_iteration > 0),
-  current_iteration int NOT NULL check (current_iteration between 0 and max_iteration)
-);
-
--- TODO: Should probably index current_iteration
--- CREATE INDEX hash_chain_current_iteration_idx ON hub.hash_chain(current_iteration);
-
-CREATE INDEX hash_chain_user_id_idx ON hub.hash_chain(user_id);
-CREATE INDEX hash_chain_experience_id_idx ON hub.hash_chain(experience_id);
-CREATE INDEX hash_chain_casino_id_idx ON hub.hash_chain(casino_id);
-
--- Ensure only one active hash_chain per user per experience per casino
-CREATE UNIQUE INDEX active_hash_chain_idx
-  ON hub.hash_chain (user_id, experience_id, casino_id)
-  WHERE active = true;
-
-CREATE TYPE hub.hash_kind AS ENUM (
-  'TERMINAL', -- max iteration hash (e.g. iteration 1000)
-  'INTERMEDIATE', -- intermediate hash (e.g. iteration 1-999)
-  'PREIMAGE' -- preimage hash (always iteration 0)
-);
-
--- this is the base table for all bets events
-CREATE TABLE hub.hash (
-  id            uuid PRIMARY KEY DEFAULT hub_hidden.uuid_generate_v7(),
-  kind          hub.hash_kind NOT NULL,
-  hash_chain_id uuid NOT NULL REFERENCES hub.hash_chain(id),
-  iteration     int NOT NULL check (iteration >= 0),    -- which Nth value from the hash chain it is
-  digest        bytea NOT NULL,   -- the actual hash we got from hash chain server
-  metadata      jsonb NOT NULL DEFAULT '{}' -- operator can store game-specific tags
-);
-
-CREATE INDEX hash_hash_chain_id_idx ON hub.hash(hash_chain_id);
-
--- Ensure iterations are unique per hash_chain to avoid dupe mistakes
-CREATE UNIQUE INDEX hash_hash_chain_id_iteration_idx ON hub.hash(hash_chain_id, iteration);
-
--- Ensure a hash_chain only has of each end-type hash
-CREATE UNIQUE INDEX hash_chain_terminal_hash_idx ON hub.hash (hash_chain_id)
-  WHERE kind = 'TERMINAL';
-CREATE UNIQUE INDEX hash_chain_preimage_hash_idx ON hub.hash (hash_chain_id)
-  WHERE kind = 'PREIMAGE';
-
--- GRANTS
-
-GRANT SELECT ON TABLE hub.hash_chain TO app_postgraphile;
-GRANT SELECT ON TABLE hub.hash TO app_postgraphile;
-
--- RLS
-ALTER TABLE hub.hash_chain ENABLE ROW LEVEL SECURITY;
-ALTER TABLE hub.hash ENABLE ROW LEVEL SECURITY;
-
-CREATE POLICY select_hash_chain ON hub.hash_chain FOR SELECT USING (
-  -- Operator can see all rows
-  hub_hidden.is_operator() OR
-  -- User can see their own rows
-  (
-    user_id = hub_hidden.current_user_id() AND
-    experience_id = hub_hidden.current_experience_id() AND
-    casino_id = hub_hidden.current_casino_id()
-  )
-);
-
-CREATE POLICY select_hash ON hub.hash FOR SELECT USING (
-  -- Operator can see all rows
-  hub_hidden.is_operator() OR
-  -- User can see their own rows by checking the associated hash_chain
-  EXISTS (
-    SELECT 1 
-    FROM hub.hash_chain 
-    WHERE hub.hash_chain.id = hub.hash.hash_chain_id
-      AND hub.hash_chain.user_id = hub_hidden.current_user_id()
-      AND hub.hash_chain.experience_id = hub_hidden.current_experience_id()
-      AND hub.hash_chain.casino_id = hub_hidden.current_casino_id()
-  )
-);

package/dist/src/plugins/hub-outcome-input-non-null-fields.d.ts

@@ -1,18 +0,0 @@
-import { GraphQLInputFieldConfig } from "graphql";
-export declare const HubOutcomeInputNonNullFieldsPlugin: {
-    name: string;
-    version: string;
-    description: string;
-    schema: {
-        hooks: {
-            GraphQLInputObjectType_fields_field: (field: GraphQLInputFieldConfig, build: any, context: any) => {
-                type: any;
-                description?: import("graphql/jsutils/Maybe.js").Maybe<string>;
-                defaultValue?: unknown;
-                deprecationReason?: import("graphql/jsutils/Maybe.js").Maybe<string>;
-                extensions?: import("graphql/jsutils/Maybe.js").Maybe<Readonly<import("graphql").GraphQLInputFieldExtensions>>;
-                astNode?: import("graphql/jsutils/Maybe.js").Maybe<import("graphql").InputValueDefinitionNode>;
-            };
-        };
-    };
-};

package/dist/src/plugins/hub-outcome-input-non-null-fields.js

@@ -1,20 +0,0 @@
-export const HubOutcomeInputNonNullFieldsPlugin = {
-    name: "HubOutcomeInputNonNullFieldsPlugin",
-    version: "0.0.0",
-    description: "Specifies that HubOutcomeInput fields are non-null",
-    schema: {
-        hooks: {
-            GraphQLInputObjectType_fields_field: (field, build, context) => {
-                const { scope: { fieldName }, } = context;
-                if (context.scope.pgCodec?.name === "hubOutcome" &&
-                    ["profit", "weight"].includes(fieldName)) {
-                    return {
-                        ...field,
-                        type: new build.graphql.GraphQLNonNull(field.type),
-                    };
-                }
-                return field;
-            },
-        },
-    },
-};