@moneypot/hub 1.3.0-dev.1 → 1.3.0-dev.11

package/dist/src/config.d.ts

@@ -1,14 +1,9 @@
 import "dotenv/config";
-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;
+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;

package/dist/src/config.js

@@ -1,57 +1,83 @@
 import "dotenv/config";
 import pgConnectionString from "pg-connection-string";
 import { logger } from "./logger.js";
-let NODE_ENV = process.env.NODE_ENV || "";
-if (!NODE_ENV) {
-    NODE_ENV = "development";
-    logger.warn("Missing NODE_ENV env var. Defaulting to 'development'");
+import { assert } from "tsafe";
+function getEnvVariable(key, transform = (value) => value) {
+    return transform(process.env[key] || "");
 }
-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.)");
+export const NODE_ENV = getEnvVariable("NODE_ENV", (value) => {
+    if (!value) {
+        logger.warn("Missing NODE_ENV env var. Defaulting to 'development'");
+        return "development";
     }
-}
-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;
+    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.)");
+    }
+    return value || "";
+});

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

@@ -2,6 +2,7 @@ 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,10 +1,11 @@
 import * as pg from "pg";
-import config from "../config.js";
+import * as 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,3 +114,31 @@ 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 +1,5 @@
-export {};
+export const DbHashKind = {
+    TERMINAL: "TERMINAL",
+    INTERMEDIATE: "INTERMEDIATE",
+    PREIMAGE: "PREIMAGE",
+};

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,35 @@
+import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
+import { assert } from "tsafe";
+export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
+    assert(pgClient._inTransaction, "dbLockHashChain 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,57 @@
+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

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

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

@@ -0,0 +1,20 @@
+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

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

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

@@ -0,0 +1,111 @@
+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

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

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

@@ -0,0 +1,46 @@
+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/index.d.ts

@@ -1,6 +1,6 @@
 import { Express } from "express";
 import { Logger } from "./logger.js";
-export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
+export { MakeOutcomeBetPlugin, type OutcomeBetConfigMap, type OutcomeBetConfig, } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, type PluginContext, type PluginIdentity, type UserSessionContext, } from "./server/graphile.config.js";
 export type ServerOptions = {
     configureApp?: (app: Express) => void;

package/dist/src/index.js

@@ -1,11 +1,11 @@
 import PgUpgradeSchema, { DatabaseAheadError, } from "@moneypot/pg-upgrade-schema";
 import * as db from "./db/index.js";
-import config from "./config.js";
+import * as config from "./config.js";
 import { createHubServer } from "./server/index.js";
 import { initializeTransferProcessors } from "./process-transfers.js";
 import { join } from "path";
 import { logger, setLogger } from "./logger.js";
-export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
+export { MakeOutcomeBetPlugin, } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
 async function initialize(options) {
     if (options.logger) {

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

@@ -1,8 +1,13 @@
-import { PoolClient } from "pg";
-import { DbCasino, DbProcessedTakeRequest } from "./db/types.js";
-export declare const pgAdvisoryLock: {
-    forMpTakeRequestProcessing: (pgClient: PoolClient, params: {
+import { DbCasino, DbExperience, DbProcessedTakeRequest, DbUser } from "./db/types.js";
+import { PgClientInTransaction } from "./db/index.js";
+export declare const PgAdvisoryLock: {
+    forMpTakeRequestProcessing: (pgClient: PgClientInTransaction, 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,6 +1,8 @@
+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;
@@ -20,8 +22,13 @@ 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/005-hash-chain.sql

@@ -0,0 +1,84 @@
+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/pg-versions/{005-outcome-bet.sql → 006-outcome-bet.sql}

@@ -1,3 +1,6 @@
+drop table if exists hub.outcome_bet cascade;
+drop type if exists hub.outcome cascade;
+
 create type hub.outcome as (
     weight float,
     profit float
@@ -14,6 +17,9 @@ 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,
 
@@ -24,7 +30,7 @@ create table hub.outcome_bet (
     profit       float not null,
 
     -- null when no outcomes saved
-    outcome_idx  smallint null,
+    outcome_idx  smallint null check (outcome_idx between 0 and array_length(outcomes,1)-1),
     outcomes     hub.outcome[] not null default '{}',
 
     -- Operator-provided data per bet
@@ -37,6 +43,7 @@ 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-authenticate.js

@@ -1,6 +1,6 @@
 import { GraphQLError } from "graphql";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { assert, is } from "tsafe";
+import { assert } from "tsafe";
 import { GET_USER_FROM_USER_TOKEN } from "../graphql-queries.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { createGraphqlClient } from "../graphql-client.js";
@@ -9,6 +9,18 @@ import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import * as jwtService from "../services/jwt-service.js";
 import { extractGraphQLErrorInfo, isGraphQLError } from "../GraphQLError.js";
+import { z } from "zod";
+const BaseUrlSchema = z
+    .string()
+    .refine((val) => URL.canParse(val), "Base URL must be a valid url")
+    .transform((val) => new URL(val))
+    .refine((val) => val.protocol === "http:" || val.protocol === "https:", "Base URL must use http or https protocol")
+    .refine((val) => val.pathname === "/" && val.search === "" && val.hash === "", "Base URL must have no path, query, nor hash")
+    .transform((val) => val.toString().replace(/\/$/, ""));
+const InputSchema = z.object({
+    casinoBaseUrl: BaseUrlSchema,
+    userToken: z.string().min(1, "User token required"),
+});
 export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
     return {
         typeDefs: gql `
@@ -38,9 +50,18 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                 hubAuthenticate(_, { $input }) {
                     try {
                         const $context = context();
-                        const $success = sideEffect([$input, $context], ([input, context]) => {
+                        const $success = sideEffect([$input, $context], ([rawInput, context]) => {
                             return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                assert(is(input));
+                                let input;
+                                try {
+                                    input = InputSchema.parse(rawInput);
+                                }
+                                catch (e) {
+                                    if (e instanceof z.ZodError) {
+                                        throw new GraphQLError(e.errors[0].message);
+                                    }
+                                    throw e;
+                                }
                                 const { userToken: jwt, casinoBaseUrl } = input;
                                 const casino = await pgClient
                                     .query({

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

@@ -1,4 +1,15 @@
 import { z } from "zod";
+import { Result } from "../util.js";
+declare const OutcomeSchema: z.ZodObject<{
+    weight: z.ZodNumber;
+    profit: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    weight: number;
+    profit: number;
+}, {
+    weight: number;
+    profit: number;
+}>;
 declare const InputSchema: z.ZodObject<{
     kind: z.ZodString;
     wager: z.ZodNumber;
@@ -25,33 +36,49 @@ declare const InputSchema: z.ZodObject<{
         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: {
         weight: number;
         profit: number;
     }[];
+    metadata?: Record<string, any> | undefined;
 }, {
     currency: string;
+    hashChainId: string;
     kind: string;
     wager: number;
     outcomes: {
         weight: number;
         profit: number;
     }[];
+    metadata?: Record<string, any> | undefined;
 }>;
 type Input = z.infer<typeof InputSchema>;
-type BetConfig = {
+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;
-    getMetadata?: (input: Input) => Promise<Record<string, any>>;
+    initializeMetadataFromUntrustedUserInput?: (input: Input) => Result<Record<string, any>, string>;
+    finalizeMetadata?: (validatedMetadata: Record<string, any>, data: FinalizeMetadataData) => Record<string, any>;
 };
-export type BetConfigMap<BetKind extends string> = {
-    [betKind in BetKind]: BetConfig;
+export type OutcomeBetConfigMap<BetKind extends string> = {
+    [betKind in BetKind]: OutcomeBetConfig;
 };
 export declare function MakeOutcomeBetPlugin<BetKind extends string>({ betConfigs }: {
-    betConfigs: BetConfigMap<BetKind>;
+    betConfigs: OutcomeBetConfigMap<BetKind>;
 }): GraphileConfig.Plugin;
 export {};

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

@@ -1,9 +1,11 @@
-import { context, object, sideEffect } from "postgraphile/grafast";
+import { access, context, object, ObjectStep, polymorphicBranch, sideEffect, } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import { z } from "zod";
 import { GraphQLError } from "graphql";
-import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, 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";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -35,6 +37,8 @@ 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
@@ -48,10 +52,11 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .gte(0, "House edge must be >= 0")
         .lte(1, "House edge must be <= 1"),
     saveOutcomes: z.boolean(),
-    getMetadata: z
+    initializeMetadataFromUntrustedUserInput: z
+        .function()
+        .optional(),
+    finalizeMetadata: z
         .function()
-        .args(InputSchema)
-        .returns(z.record(z.string(), z.any()))
         .optional(),
 }));
 export function MakeOutcomeBetPlugin({ betConfigs }) {
@@ -69,12 +74,20 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           wager: Int!
           currency: String!
           outcomes: [HubOutcomeInput!]!
+          hashChainId: UUID!
+          metadata: JSON
         }
 
-        type HubMakeOutcomeBetPayload {
+        type HubMakeOutcomeBetOk {
           bet: HubOutcomeBet!
         }
 
+        union HubMakeOutcomeBetResult = HubMakeOutcomeBetOk | HubBadHashChainError
+
+        type HubMakeOutcomeBetPayload {
+          result: HubMakeOutcomeBetResult!
+        }
+
         extend type Mutation {
           hubMakeOutcomeBet(input: HubMakeOutcomeBetInput!): HubMakeOutcomeBetPayload
         }
@@ -85,7 +98,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                 Mutation: {
                     hubMakeOutcomeBet: (_, { $input }) => {
                         const $identity = context().get("identity");
-                        const $betId = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                        const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("Unauthorized");
                             }
@@ -108,6 +121,16 @@ 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) {
@@ -158,7 +181,65 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 if (maxPotentialPayout > maxAllowablePayout) {
                                     throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
                                 }
-                                const { outcome, outcomeIdx } = pickRandomOutcome(input.outcomes);
+                                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 { outcome, outcomeIdx } = pickRandomOutcome(input.outcomes, betHashResult.hash);
                                 const netPlayerAmount = input.wager * outcome.profit;
                                 await pgClient.query({
                                     text: `
@@ -193,17 +274,27 @@ 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: betConfig.getMetadata
-                                        ? await betConfig.getMetadata(input)
-                                        : {},
+                                    metadata: finalizedMetadata || {},
                                     ...(betConfig.saveOutcomes
                                         ? {
                                             outcomes: input.outcomes,
@@ -221,6 +312,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         user_id, 
                         casino_id, 
                         experience_id, 
+                        hash_chain_id,
                         kind,
                         currency_key, 
                         wager, 
@@ -229,13 +321,14 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         outcome_idx,
                         metadata
                       )
-                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
                       RETURNING id
                     `,
                                     values: [
                                         newBet.user_id,
                                         newBet.casino_id,
                                         newBet.experience_id,
+                                        newBet.hash_chain_id,
                                         newBet.kind,
                                         newBet.currency_key,
                                         newBet.wager,
@@ -246,11 +339,31 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     ],
                                 })
                                     .then(exactlyOneRow);
-                                return bet.id;
+                                return {
+                                    __typename: "HubMakeOutcomeBetOk",
+                                    betId: bet.id,
+                                };
                             });
                         });
                         return object({
-                            bet: outcomeBetTable.get({ id: $betId }),
+                            result: $result,
+                        });
+                    },
+                },
+                HubMakeOutcomeBetOk: {
+                    __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, {
+                            HubMakeOutcomeBetOk: {},
+                            HubBadHashChainError: {},
                         });
                     },
                 },
@@ -258,12 +371,13 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-function generateRandomNumber() {
-    const array = new Uint32Array(1);
-    crypto.getRandomValues(array);
-    return array[0] / 2 ** 32;
+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 pickRandomOutcome(outcomes) {
+function pickRandomOutcome(outcomes, hash) {
     assert(outcomes.length >= 2, "Outcome count must be >= 2");
     const totalWeight = sum(outcomes.map((o) => o.weight));
     const outcomesWithProbability = outcomes.map((o) => ({
@@ -272,12 +386,12 @@ function pickRandomOutcome(outcomes) {
     }));
     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 = generateRandomNumber();
-    let cumProb = 0;
+    const randomValue = normalizeHash(hash);
+    let cumulativeProb = 0;
     for (let i = 0; i < outcomesWithProbability.length; i++) {
         const outcome = outcomesWithProbability[i];
-        cumProb += outcome.probability;
-        if (randomValue <= cumProb) {
+        cumulativeProb += outcome.probability;
+        if (randomValue <= cumulativeProb) {
             return { outcome, outcomeIdx: i };
         }
     }
@@ -323,3 +437,41 @@ 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 config from "./config.js";
+import * as 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 config from "../config.js";
+import * as config from "../config.js";
 import { maskError } from "./handle-errors.js";
 import * as db from "../db/index.js";
 import { SmartTagsPlugin } from "../smart-tags.js";
@@ -20,6 +20,9 @@ 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";
 export const requiredPlugins = [
     SmartTagsPlugin,
     IdToNodeIdPlugin,
@@ -35,6 +38,9 @@ export const requiredPlugins = [
 export const defaultPlugins = [
     ...(config.NODE_ENV === "development" ? [DebugPlugin] : []),
     ...requiredPlugins,
+    HubBadHashChainErrorPlugin,
+    HubCreateHashChainPlugin,
+    HubUserActiveHashChainPlugin,
     HubClaimFaucetPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];

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

@@ -1,5 +1,5 @@
 import { GraphQLError } from "postgraphile/graphql";
-import config from "../config.js";
+import * as 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 config from "../config.js";
+import * as 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.1",
+  "version": "1.3.0-dev.11",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [