@moneypot/hub 1.12.0 → 1.13.0

package/README.md

@@ -76,6 +76,10 @@ insert into hub.api_key default values returning key;
 
 ## Changelog
 
+### 1.13.x
+
+- Added `hubRevealHashChain` mutation to generate a preimage hash for the chain and mark it as inactive.
+
 ### 1.12.x
 
 - Added `hub.audit_log` table to track balance and bankroll changes.

package/dist/src/db/index.js

@@ -136,17 +136,21 @@ export async function setTransferCursor(pgClient, { cursor, casinoId, }) {
 export async function upsertUser(pgClient, { uname, casinoId, mpUserId, }) {
     const user = await pgClient
         .query(`
-        WITH ins AS (
-            INSERT INTO hub.user (casino_id, mp_user_id, uname)
-            VALUES ($1, $2, $3)
-            ON CONFLICT (casino_id, mp_user_id) DO NOTHING
-            RETURNING *
-        )
-        SELECT * FROM ins
-        UNION ALL
-        SELECT * FROM hub.user
-        WHERE casino_id = $1 AND mp_user_id = $2
-        LIMIT 1;
+      WITH upsert AS (
+        INSERT INTO hub.user (casino_id, mp_user_id, uname)
+        VALUES ($1, $2, $3)
+        ON CONFLICT (casino_id, mp_user_id) DO UPDATE 
+        SET uname = EXCLUDED.uname 
+        WHERE hub.user.uname IS DISTINCT FROM EXCLUDED.uname
+        RETURNING *
+      )
+      SELECT * FROM upsert
+      UNION ALL
+      SELECT * FROM hub.user
+      WHERE casino_id = $1 AND mp_user_id = $2
+        AND NOT EXISTS (SELECT 1 FROM upsert)
+      LIMIT 1;
+
     `, [casinoId, mpUserId, uname])
         .then(exactlyOneRow);
     return user;

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

@@ -1,9 +1,10 @@
 import { DbHashKind, } from "../db/types.js";
 import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
+import { logger } from "../logger.js";
 export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
     assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
-    return pgClient
+    const hashChain = await pgClient
         .query(`
        SELECT * 
        FROM hub.hash_chain 
@@ -17,10 +18,24 @@ export async function dbLockHubHashChain(pgClient, { userId, experienceId, casin
     `, [hashChainId, userId, experienceId, casinoId])
         .then(maybeOneRow)
         .then((row) => row ?? null);
+    if (hashChain) {
+        assert(hashChain.current_iteration >= 1, "Hash chain iteration must be >= 1");
+    }
+    return hashChain;
 }
 export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, clientSeed, metadata = {}, }) {
+    logger.debug({
+        hashChainId,
+        kind,
+        iteration,
+        clientSeed,
+        metadata,
+        digest: Buffer.from(digest).toString("base64"),
+    }, "[dbInsertHubHash] Inserting hash");
     assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
-    assert(kind === DbHashKind.INTERMEDIATE && typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
+    if (kind === DbHashKind.INTERMEDIATE) {
+        assert(typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
+    }
     return pgClient
         .query(`
     INSERT INTO hub.hash (hash_chain_id, kind, digest, iteration, client_seed, metadata)

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

@@ -65,9 +65,12 @@ export const HubCreateHashChainPlugin = makeExtendSchemaPlugin((build) => {
                                     config.HASHCHAINSERVER_MAX_ITERATIONS,
                                 ])
                                     .then(exactlyOneRow);
-                                const terminalHash = await HashCommon.getTerminalHash({
+                                const terminalHashResult = await HashCommon.getTerminalHash({
                                     hashChainId: dbHashChain.id,
                                 });
+                                if (terminalHashResult.type !== "success") {
+                                    throw new Error("Failed to get terminal hash");
+                                }
                                 await pgClient.query(`
                   INSERT INTO hub.hash (
                     hash_chain_id, 
@@ -79,7 +82,7 @@ export const HubCreateHashChainPlugin = makeExtendSchemaPlugin((build) => {
                   `, [
                                     dbHashChain.id,
                                     DbHashKind.TERMINAL,
-                                    terminalHash,
+                                    terminalHashResult.hash,
                                     config.HASHCHAINSERVER_MAX_ITERATIONS,
                                 ]);
                                 return dbHashChain.id;

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

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

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

@@ -0,0 +1,74 @@
+import { context, object, sideEffect } from "postgraphile/grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { dbLockHubHashChain, withPgPoolTransaction } from "../../db/index.js";
+import z, { prettifyError } from "zod/v4";
+import { GraphQLError } from "graphql";
+import { assert } from "tsafe";
+import { dbRevealHashChain } from "../reveal-hash-chain.js";
+const InputSchema = z.object({
+    hashChainId: z.uuidv7("Invalid hash chain ID"),
+});
+export const HubRevealHashChainPlugin = makeExtendSchemaPlugin((build) => {
+    const hashTable = build.input.pgRegistry.pgResources.hub_hash;
+    return {
+        typeDefs: gql `
+      input HubRevealHashChainInput {
+        hashChainId: UUID!
+      }
+
+      type HubRevealHashChainPayload {
+        preimageHash: HubHash!
+      }
+
+      extend type Mutation {
+        hubRevealHashChain(
+          input: HubRevealHashChainInput!
+        ): HubRevealHashChainPayload!
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubRevealHashChain: (_, { $input }) => {
+                        const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
+                        const $preimageHashId = sideEffect([$input, $identity, $superuserPool], ([rawInput, identity, superuserPool]) => {
+                            if (identity?.kind !== "user") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            let input;
+                            try {
+                                input = InputSchema.parse(rawInput);
+                            }
+                            catch (e) {
+                                if (e instanceof z.ZodError) {
+                                    throw new GraphQLError(prettifyError(e));
+                                }
+                                throw e;
+                            }
+                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                const hashChain = await dbLockHubHashChain(pgClient, {
+                                    userId: identity.session.user_id,
+                                    experienceId: identity.session.experience_id,
+                                    casinoId: identity.session.casino_id,
+                                    hashChainId: input.hashChainId,
+                                });
+                                if (!hashChain || !hashChain.active) {
+                                    throw new GraphQLError("Active hash chain not found");
+                                }
+                                assert(hashChain.current_iteration >= 1, "Invalid hash chain iteration");
+                                const dbPreimageHash = await dbRevealHashChain(pgClient, {
+                                    hashChainId: input.hashChainId,
+                                });
+                                return dbPreimageHash.id;
+                            });
+                        });
+                        return object({
+                            preimageHash: hashTable.get({ id: $preimageHashId }),
+                        });
+                    },
+                },
+            },
+        },
+    };
+});

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

@@ -0,0 +1,5 @@
+import { DbHash } from "../db/types.js";
+import { PgClientInTransaction } from "../db/index.js";
+export declare function dbRevealHashChain(pgClient: PgClientInTransaction, { hashChainId, }: {
+    hashChainId: string;
+}): Promise<DbHash>;

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

@@ -0,0 +1,35 @@
+import { logger } from "../logger.js";
+import { getPreimageHash } from "./get-hash.js";
+import { DbHashKind } from "../db/types.js";
+import { dbInsertHubHash } from "../db/index.js";
+import { assert } from "tsafe";
+export async function dbRevealHashChain(pgClient, { hashChainId, }) {
+    assert(pgClient._inTransaction, "dbRevealHashChain must be called in a transaction");
+    logger.debug({ hashChainId }, "Revealing hash chain");
+    const preimageHashResult = await getPreimageHash({
+        hashChainId,
+    });
+    logger.debug({ preimageHashResult }, "Preimage hash result");
+    if (preimageHashResult.type === "success") {
+        const dbPreimageHash = 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");
+        }
+        return dbPreimageHash;
+    }
+    else {
+        logger.warn({ hashChainId, error: preimageHashResult }, "Failed to reveal hash chain");
+        throw new Error("Failed to reveal hash chain");
+    }
+}

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

@@ -69,6 +69,7 @@ CREATE POLICY select_hash_chain ON hub.hash_chain FOR SELECT USING (
   )
 );
 
+-- TODO: Since we have RLS we could just make hashes public for simplicity/perf
 CREATE POLICY select_hash ON hub.hash FOR SELECT USING (
   -- Operator can see all rows
   hub_hidden.is_operator() OR

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

@@ -5,11 +5,12 @@ import { GraphQLError } from "graphql";
 import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, 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 { getIntermediateHash } from "../hash-chain/get-hash.js";
 import { makeFinalHash, pickRandomOutcome } from "../hash-chain/util.js";
 import { logger } from "../logger.js";
 import { validateRisk } from "../risk-policy.js";
 import { insertAuditLog } from "../audit-log.js";
+import { dbRevealHashChain } from "../hash-chain/reveal-hash-chain.js";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -215,15 +216,24 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                             message: "Active hash chain not found",
                                         };
                                     }
-                                    if (dbHashChain.current_iteration <= 1) {
-                                        if (dbHashChain.current_iteration === 1) {
-                                            finishHashChainInBackground({
-                                                hashChainId: input.hashChainId,
-                                                pool: superuserPool,
-                                            }).catch((e) => {
-                                                logger.error({ hashChainId: input.hashChainId, error: e }, "Error finishing hash chain in background");
-                                            });
-                                        }
+                                    if (dbHashChain.current_iteration < 1) {
+                                        logger.error({
+                                            hashChainId: input.hashChainId,
+                                            iteration: dbHashChain.current_iteration,
+                                        }, "Hash chain has invalid iteration < 1");
+                                        return {
+                                            __typename: "HubBadHashChainError",
+                                            message: "Hash chain is in an invalid state",
+                                        };
+                                    }
+                                    if (dbHashChain.current_iteration === 1) {
+                                        await pgClient.query(`UPDATE hub.hash_chain SET active = false WHERE id = $1`, [input.hashChainId]);
+                                        revealHashChainInBackground({
+                                            hashChainId: input.hashChainId,
+                                            pool: superuserPool,
+                                        }).catch((e) => {
+                                            logger.error({ hashChainId: input.hashChainId, error: e }, "Error finishing hash chain in background");
+                                        });
                                         return {
                                             __typename: "HubBadHashChainError",
                                             message: "Hash chain drained. Create a new one.",
@@ -413,38 +423,8 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-async function finishHashChainInBackground({ hashChainId, pool, }) {
-    logger.debug({ hashChainId }, "Finishing hash chain in background");
-    const preimageHashResult = await getPreimageHash({
-        hashChainId,
+async function revealHashChainInBackground({ hashChainId, pool, }) {
+    return await withPgPoolTransaction(pool, async (pgClient) => {
+        await dbRevealHashChain(pgClient, { hashChainId });
     });
-    logger.debug({ preimageHashResult }, "Preimage hash result");
-    if (preimageHashResult.type === "success") {
-        logger.debug({
-            hashChainId,
-            kind: DbHashKind.PREIMAGE,
-            digest: preimageHashResult.hash,
-            iteration: 0,
-        }, "Inserting preimage hash");
-        await withPgPoolTransaction(pool, 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 {
-        logger.warn({ hashChainId, error: preimageHashResult }, "Failed to insert preimage hash in background");
-    }
 }

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

@@ -23,6 +23,7 @@ import { HubBadHashChainErrorPlugin } from "../hash-chain/plugins/hub-bad-hash-c
 import { HubUserActiveHashChainPlugin } from "../hash-chain/plugins/hub-user-active-hash-chain.js";
 import { HubOutcomeInputNonNullFieldsPlugin } from "../plugins/hub-outcome-input-non-null-fields.js";
 import { HubPutAlertPlugin } from "../plugins/hub-put-alert.js";
+import { HubRevealHashChainPlugin } from "../hash-chain/plugins/hub-reveal-hash-chain.js";
 export const requiredPlugins = [
     SmartTagsPlugin,
     IdToNodeIdPlugin,
@@ -42,6 +43,7 @@ export const defaultPlugins = [
     HubBadHashChainErrorPlugin,
     HubCreateHashChainPlugin,
     HubUserActiveHashChainPlugin,
+    HubRevealHashChainPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];
 export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, }) {

package/package.json

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