@moneypot/hub 1.2.7 → 1.3.0-dev.10

package/README.md

@@ -28,6 +28,7 @@ import {
   type ServerOptions,
   defaultPlugins,
   startAndListen,
+  MakeOutcomeBetPlugin,
 } from "@moneypot/hub";
 import path from "path";
 
@@ -40,6 +41,9 @@ const options: ServerOptions = {
     // These are required for the hub server to function
     ...defaultPlugins,
     // Add your custom plugins here to extend server functionality
+    MakeOutcomeBetPlugin({
+      houseEdge: 0.01,
+    }),
   ],
 
   // File path where the generated GraphQL schema definition will be saved

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

@@ -6,8 +6,8 @@ export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
 export declare function getPgClient(connectionString: string): InstanceType<typeof pg.Client>;
-export declare const postgraphilePool: import("pg").Pool;
-export declare const superuserPool: import("pg").Pool;
+export declare const postgraphilePool: pg.Pool;
+export declare const superuserPool: pg.Pool;
 export interface QueryExecutor {
     query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }

package/dist/src/db/index.js

@@ -1,5 +1,5 @@
 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";

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 dbLockHashChain(pgClient: PgClientInTransaction, { userId, experienceId, casinoId, hashChainId, }: {
+    userId: DbUser["id"];
+    experienceId: DbExperience["id"];
+    casinoId: DbCasino["id"];
+    hashChainId: DbHashChain["id"];
+}): Promise<DbHashChain | null>;
+export declare function dbInsertHash(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 dbLockHashChain(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 dbInsertHash(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,5 +1,6 @@
 import { Express } from "express";
 import { Logger } from "./logger.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,10 +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 { defaultPlugins, } from "./server/graphile.config.js";
 async function initialize(options) {
     if (options.logger) {
@@ -54,6 +55,9 @@ async function initialize(options) {
     });
 }
 export async function startAndListen(options) {
+    if (options.plugins && options.plugins.some((p) => typeof p === "function")) {
+        throw new Error("`plugins` should be an array of GraphileConfig.Plugin but one of the items is a function. Did you forget to call it?");
+    }
     if (options.userDatabaseMigrationsPath &&
         !options.userDatabaseMigrationsPath.startsWith("/")) {
         throw new Error(`userDatabaseMigrationsPath must be an absolute path, got ${options.userDatabaseMigrationsPath}`);

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));
+    },
 };