@moneypot/hub 1.16.2 → 1.16.4

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

@@ -1,10 +1,11 @@
 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, }: {
+export declare function dbLockHubHashChain(pgClient: PgClientInTransaction, { userId, experienceId, casinoId, hashChainId, active, }: {
     userId: DbUser["id"];
     experienceId: DbExperience["id"];
     casinoId: DbCasino["id"];
     hashChainId: DbHashChain["id"];
+    active: "must-be-active" | "active-or-inactive";
 }): Promise<DbHashChain | null>;
 export declare function dbInsertHubHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, clientSeed, metadata, }: {
     hashChainId: DbHashChain["id"];

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

@@ -2,25 +2,20 @@ 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, }) {
-    const hashChain = await pgClient
+export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, active, }) {
+    const dbLockedHashChain = await 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])
+    SELECT * 
+    FROM hub.hash_chain 
+    WHERE id = $1 
+      AND user_id = $2
+      AND experience_id = $3
+      AND casino_id = $4
+      AND ($5::text = 'active-or-inactive' OR active = TRUE)
+    FOR UPDATE`, [hashChainId, userId, experienceId, casinoId, active])
         .then(maybeOneRow)
         .then((row) => row ?? null);
-    if (hashChain) {
-        assert(hashChain.current_iteration >= 1, "Hash chain iteration must be >= 1");
-    }
-    return hashChain;
+    return dbLockedHashChain;
 }
 export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, clientSeed, metadata = {}, }) {
     logger.debug({

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

@@ -1,14 +1,13 @@
 import { context, object, sideEffect } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { gql, extendSchema } 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) => {
+export const HubRevealHashChainPlugin = extendSchema((build) => {
     const hashTable = build.input.pgRegistry.pgResources.hub_hash;
     return {
         typeDefs: gql `
@@ -47,20 +46,20 @@ export const HubRevealHashChainPlugin = makeExtendSchemaPlugin((build) => {
                                 throw e;
                             }
                             return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                const hashChain = await dbLockHubHashChain(pgClient, {
+                                const dbLockedHashChain = await dbLockHubHashChain(pgClient, {
                                     userId: identity.session.user_id,
                                     experienceId: identity.session.experience_id,
                                     casinoId: identity.session.casino_id,
                                     hashChainId: input.hashChainId,
+                                    active: "active-or-inactive",
                                 });
-                                if (!hashChain || !hashChain.active) {
-                                    throw new GraphQLError("Active hash chain not found");
+                                if (!dbLockedHashChain) {
+                                    throw new GraphQLError("Hash chain not found");
                                 }
-                                assert(hashChain.current_iteration >= 1, "Invalid hash chain iteration");
-                                const dbPreimageHash = await dbRevealHashChain(pgClient, {
-                                    hashChainId: input.hashChainId,
+                                const dbPreimageHashId = await dbRevealHashChain(pgClient, {
+                                    hashChainId: dbLockedHashChain.id,
                                 });
-                                return dbPreimageHash.id;
+                                return dbPreimageHashId;
                             });
                         });
                         return object({

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

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

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

@@ -1,16 +1,39 @@
 import { logger } from "../logger.js";
 import { getPreimageHash } from "./get-hash.js";
 import { DbHashKind } from "../db/types.js";
-import { dbInsertHubHash } from "../db/index.js";
+import { dbInsertHubHash, maybeOneRow, } from "../db/index.js";
 export async function dbRevealHashChain(pgClient, { hashChainId, }) {
     logger.debug({ hashChainId }, "Revealing hash chain");
+    const dbLockedHashChain = await pgClient
+        .query(`
+    SELECT *
+    FROM hub.hash_chain
+    WHERE id = $1
+    FOR UPDATE
+    `, [hashChainId])
+        .then(maybeOneRow);
+    if (!dbLockedHashChain) {
+        throw new Error("Hash chain not found");
+    }
+    const dbPreimageHash = await pgClient
+        .query(`
+      SELECT id 
+      FROM hub.hash 
+      WHERE hash_chain_id = $1 
+        AND kind = 'PREIMAGE'
+        AND iteration = 0
+    `, [hashChainId])
+        .then(maybeOneRow);
+    if (dbPreimageHash) {
+        return dbPreimageHash.id;
+    }
     const preimageHashResult = await getPreimageHash({
-        hashChainId,
+        hashChainId: dbLockedHashChain.id,
     });
     logger.debug({ preimageHashResult }, "Preimage hash result");
     if (preimageHashResult.type === "success") {
         const dbPreimageHash = await dbInsertHubHash(pgClient, {
-            hashChainId,
+            hashChainId: dbLockedHashChain.id,
             kind: DbHashKind.PREIMAGE,
             digest: preimageHashResult.hash,
             iteration: 0,
@@ -20,11 +43,11 @@ export async function dbRevealHashChain(pgClient, { hashChainId, }) {
         SET current_iteration = 0,
             active = false
         WHERE id = $1
-      `, [hashChainId]);
+      `, [dbLockedHashChain.id]);
         if (result.rowCount !== 1) {
             throw new Error("Failed to update hash chain iteration");
         }
-        return dbPreimageHash;
+        return dbPreimageHash.id;
     }
     else {
         logger.warn({ hashChainId, error: preimageHashResult }, "Failed to reveal hash chain");

package/dist/src/plugins/hub-authenticate.js

@@ -4,7 +4,7 @@ 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";
-import { constant, context, error, object, sideEffect, } from "postgraphile/grafast";
+import { constant, context, object, sideEffect } from "postgraphile/grafast";
 import { withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import * as jwtService from "../services/jwt-service.js";
@@ -114,7 +114,7 @@ export const HubAuthenticatePlugin = extendSchema(() => {
                                                 throw new GraphQLError(errorInfo.message);
                                             }
                                         }
-                                        throw error;
+                                        throw e;
                                     }
                                     const result = res.userFromUserToken;
                                     if (!result || !result.user || !result.experience) {

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

@@ -199,6 +199,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         experienceId: session.experience_id,
                                         casinoId: session.casino_id,
                                         hashChainId: input.hashChainId,
+                                        active: "must-be-active",
                                     });
                                     if (!dbHashChain || !dbHashChain.active) {
                                         return {

package/package.json

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