@moneypot/hub 1.20.5 → 1.21.0

package/dist/dashboard/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Dashboard</title>
-    <script type="module" crossorigin src="/dashboard/assets/index-0G7cFk_0.js"></script>
+    <script type="module" crossorigin src="/dashboard/assets/index-n_xD3-qc.js"></script>
     <link rel="stylesheet" crossorigin href="/dashboard/assets/index-Bl5lLFHa.css">
   </head>
   <body>

package/dist/src/audit-log.d.ts

@@ -1,7 +1,7 @@
 import { DbPlayerBalance, DbHouseBankroll } from "./db/types.js";
 import { QueryExecutor } from "./db/util.js";
 export type AuditLogType = "player-balance" | "house-bankroll" | "both";
-export type HubAuditAction = "hub:init" | "hub:deposit" | "hub:take_request:pending" | "hub:take_request:refund" | "hub:outcome_bet";
+export type HubAuditAction = "hub:init" | "hub:deposit" | "hub:take_request:pending" | "hub:take_request:refund" | "hub:outcome_bet" | "hub:bankroll:adjust";
 export type HubAuditRefType = "hub.deposit" | "hub.outcome_bet" | "hub.take_request";
 export type AuditAction = HubAuditAction | (string & {});
 export type AuditRefType = HubAuditRefType | (string & {});

package/dist/src/index.d.ts

@@ -20,7 +20,7 @@ declare global {
 export { HubGameConfigPlugin, type OutcomeBetConfigMap, type OutcomeBetConfig, } from "./plugins/hub-game-config-plugin.js";
 export { type CustomGameConfig, type CustomGameConfigMap, } from "./custom-game-config.js";
 export { validateRisk, type RiskPolicy, type RiskPolicyArgs, type RiskLimits, } from "./risk-policy.js";
-export { type DbLiability, type NewLiability, type LiabilityConfig, type LiabilityHandler, type LiabilityResolved, type DbLockedLiability, LIABILITY_RESOLVED, createLiabilityConfig, } from "./liability/public/index.js";
+export { type DbLiability, type NewLiability, type LiabilityConfig, type LiabilityHandler, type LiabilityResolved, type DbLockedLiability, type HandleDeadlineArgs, type HandleDeadlineFn, LIABILITY_RESOLVED, createLiabilityConfig, } from "./liability/public/index.js";
 export type PluginContext = Grafast.Context;
 export * from "./db/types.js";
 export { defaultPlugins, type PluginIdentity, type UserSessionContext, type HubPlugin, } from "./server/graphile.config.js";

package/dist/src/liability/internal/processor.js

@@ -95,6 +95,7 @@ export async function processOneDeadlinedLiability(pgClient, { liabilityConfig,
             lockedLiability: dbLockedLiability,
             lockedPlayerBalance: dbLockedPlayerBalance,
             lockedHouseBankroll: dbLockedHouseBankroll,
+            liabilityConfig: liabilityConfig,
         });
         const { resolved_at } = await pgClient
             .query(`SELECT resolved_at FROM hub.liability WHERE id = $1`, [dbLockedLiability.id])

package/dist/src/liability/public/config.d.ts

@@ -13,6 +13,7 @@ export type HandleDeadlineArgs<RefType extends string> = {
     lockedLiability: DbLockedLiability<RefType>;
     lockedPlayerBalance: Pick<DbLockedPlayerBalance, "id" | "amount">;
     lockedHouseBankroll: Pick<DbLockedHouseBankrollWithAvailable, "id" | "grossAmount" | "available">;
+    liabilityConfig: LiabilityConfig<RefType>;
 };
 export type HandleDeadlineFn<RefType extends string> = (args: HandleDeadlineArgs<RefType>) => Promise<LiabilityResolved>;
 export type LiabilityRefTypeConfig<RefType extends string> = {

package/dist/src/liability/public/index.d.ts

@@ -1,2 +1,2 @@
 export type { DbLiability, NewLiability } from "../types.js";
-export { type LiabilityConfig, type LiabilityRefTypeConfig as LiabilityHandler, type LiabilityResolved, type DbLockedLiability, LIABILITY_RESOLVED, createLiabilityConfig, } from "./config.js";
+export { type LiabilityConfig, type LiabilityRefTypeConfig as LiabilityHandler, type LiabilityResolved, type DbLockedLiability, type HandleDeadlineArgs, type HandleDeadlineFn, LIABILITY_RESOLVED, createLiabilityConfig, } from "./config.js";

package/dist/src/pg-versions/018-scope-chat-owner-reads.sql

@@ -0,0 +1,49 @@
+
+drop policy select_chat_message on hub.chat_message;
+create policy select_chat_message on hub.chat_message for select using (
+  hub_hidden.is_operator()
+
+  or (
+    hidden_at is null
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+
+  or (
+    hub_hidden.is_experience_owner()
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+);
+
+drop policy select_chat_mute on hub.chat_mute;
+create policy select_chat_mute on hub.chat_mute for select using (
+  hub_hidden.is_operator()
+
+  or hub_hidden.current_user_id() = hub.chat_mute.user_id
+
+  or (
+    hub_hidden.is_experience_owner()
+    and hub.chat_mute.experience_id = hub_hidden.current_experience_id()
+    and hub.chat_mute.casino_id = hub_hidden.current_casino_id()
+  )
+
+  or exists (
+    select 1
+    from hub.chat_mod
+    where user_id = hub_hidden.current_user_id()
+      and casino_id = hub.chat_mute.casino_id
+      and experience_id = hub.chat_mute.experience_id
+  )
+);
+
+drop policy select_chat_mod on hub.chat_mod;
+create policy select_chat_mod on hub.chat_mod for select using (
+  hub_hidden.is_operator()
+
+  or (
+    hub_hidden.is_experience_owner()
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+);

package/dist/src/plugins/chat/hub-chat-create-system-message.js

@@ -2,7 +2,7 @@ import { GraphQLError } from "graphql";
 import { context, object, sideEffect } from "postgraphile/grafast";
 import { extendSchema, gql } from "postgraphile/utils";
 import z from "zod/v4";
-import { extractFirstZodErrorMessage } from "../../util.js";
+import { extractFirstZodErrorMessage, uuidEqual } from "../../util.js";
 import { exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../../db/index.js";
 const InputSchema = z.object({
     clientId: z.uuid("Invalid client ID"),
@@ -69,6 +69,10 @@ export const HubChatCreateSystemMessagePlugin = extendSchema((build) => {
                             if (!dbExperience) {
                                 throw new GraphQLError("Experience not found");
                             }
+                            if (identity.kind === "user" &&
+                                !uuidEqual(identity.session.experience_id, dbExperience.id)) {
+                                throw new GraphQLError("Your session does not match the experienceId");
+                            }
                             return await withPgPoolTransaction(superuserPool, async (pgClient) => {
                                 const dbChatMessage = await pgClient
                                     .query({

package/dist/src/plugins/chat/hub-chat-mod-management.js

@@ -85,9 +85,9 @@ export const HubChatModManagementPlugin = extendSchema((build) => {
                                 text: `
                     SELECT id
                     FROM hub.user
-                    WHERE id = $1 AND experience_id = $2
+                    WHERE id = $1 AND casino_id = $2
                   `,
-                                values: [input.userId, input.experienceId],
+                                values: [input.userId, dbTargetExperience.casino_id],
                             })
                                 .then(maybeOneRow);
                             if (!dbTargetUser) {
@@ -167,9 +167,9 @@ export const HubChatModManagementPlugin = extendSchema((build) => {
                                 text: `
                     SELECT id
                     FROM hub.user
-                    WHERE id = $1 AND experience_id = $2
+                    WHERE id = $1 AND casino_id = $2
                   `,
-                                values: [input.userId, input.experienceId],
+                                values: [input.userId, dbTargetExperience.casino_id],
                             })
                                 .then(maybeOneRow);
                             if (!dbTargetUser) {

package/dist/src/plugins/hub-add-casino.js

@@ -56,8 +56,8 @@ export const HubAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
                                     throw new GraphQLError("Unauthorized");
                                 }
                                 assert(is(input));
-                                logger.info(input, "Input");
                                 const { name, baseUrl, graphqlUrl, apiKey } = input;
+                                logger.info({ name, baseUrl, graphqlUrl }, "Input");
                                 const graphqlClient = new GraphQLClient(graphqlUrl, {
                                     headers: {
                                         Authorization: `apikey:${apiKey}`,

package/dist/src/plugins/hub-adjust-bankroll.d.ts

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

package/dist/src/plugins/hub-adjust-bankroll.js

@@ -0,0 +1,106 @@
+import { GraphQLError } from "graphql";
+import { context, object, sideEffect } from "postgraphile/grafast";
+import { extendSchema, gql } from "postgraphile/utils";
+import z from "zod/v4";
+import { extractFirstZodErrorMessage } from "../util.js";
+import { maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { insertAuditLog } from "../audit-log.js";
+const InputSchema = z.object({
+    bankrollId: z.uuid("Invalid bankroll ID"),
+    delta: z
+        .number()
+        .int("Delta must be a whole number of base units")
+        .refine((delta) => delta !== 0, "Delta must not be zero"),
+    reason: z
+        .string()
+        .trim()
+        .min(1, "Reason is required")
+        .max(200, "Max reason length: 200 chars"),
+});
+export const HubAdjustBankrollPlugin = extendSchema((build) => {
+    const bankrollTable = build.input.pgRegistry.pgResources.hub_bankroll;
+    return {
+        typeDefs: gql `
+      input HubAdjustBankrollInput {
+        bankrollId: UUID!
+        "Amount to add, in base units. Negative takes money out."
+        delta: Float!
+        reason: String!
+      }
+
+      type HubAdjustBankrollPayload {
+        hubBankroll: HubBankroll!
+      }
+
+      extend type Mutation {
+        hubAdjustBankroll(
+          input: HubAdjustBankrollInput!
+        ): HubAdjustBankrollPayload
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubAdjustBankroll(_, { $input }) {
+                        const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
+                        const $bankrollId = sideEffect([$input, $identity, $superuserPool], async ([rawInput, identity, superuserPool]) => {
+                            if (identity?.kind !== "operator") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            let input;
+                            try {
+                                input = InputSchema.parse(rawInput);
+                            }
+                            catch (e) {
+                                if (e instanceof z.ZodError) {
+                                    throw new GraphQLError(extractFirstZodErrorMessage(e));
+                                }
+                                throw e;
+                            }
+                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                const dbBankroll = await pgClient
+                                    .query({
+                                    text: `
+                        SELECT id, amount, liability
+                        FROM hub.bankroll
+                        WHERE id = $1
+                        FOR UPDATE
+                      `,
+                                    values: [input.bankrollId],
+                                })
+                                    .then(maybeOneRow);
+                                if (!dbBankroll) {
+                                    throw new GraphQLError("Bankroll not found");
+                                }
+                                const newAmount = dbBankroll.amount + input.delta;
+                                if (newAmount > Number.MAX_SAFE_INTEGER) {
+                                    throw new GraphQLError("Bankroll would be too large");
+                                }
+                                if (newAmount < dbBankroll.liability) {
+                                    throw new GraphQLError("Bankroll can't go below what open games may pay out");
+                                }
+                                await pgClient.query({
+                                    text: `UPDATE hub.bankroll SET amount = $2 WHERE id = $1`,
+                                    values: [dbBankroll.id, newAmount],
+                                });
+                                await insertAuditLog(pgClient, "house-bankroll", {
+                                    action: "hub:bankroll:adjust",
+                                    bankrollId: dbBankroll.id,
+                                    bankrollOld: dbBankroll.amount,
+                                    bankrollNew: newAmount,
+                                    bankrollDelta: input.delta,
+                                    metadata: { reason: input.reason },
+                                });
+                                return dbBankroll.id;
+                            });
+                        });
+                        return object({
+                            hubBankroll: bankrollTable.get({ id: $bankrollId }),
+                        });
+                    },
+                },
+            },
+        },
+    };
+}, "HubAdjustBankrollPlugin");

package/dist/src/plugins/validate-fields.js

@@ -29,9 +29,6 @@ export const AddCasinoSchema = z.strictObject({
     graphqlUrl: v.graphqlUrl(),
     apiKey: z.uuid(),
 });
-const UpdateBankrollSchema = z.strictObject({
-    amount: z.number().int().min(0),
-});
 export const ValidateCasinoFieldsPlugin = wrapPlans(() => ({
     Mutation: {
         updateHubCasinoById: (plan, $source, fieldArgs) => {
@@ -44,10 +41,5 @@ export const ValidateCasinoFieldsPlugin = wrapPlans(() => ({
             sideEffect($input, (input) => validate(input, AddCasinoSchema));
             return plan();
         },
-        updateHubBankrollById: (plan, $source, fieldArgs) => {
-            const $patch = fieldArgs.getRaw(["input", "hubBankrollPatch"]);
-            sideEffect($patch, (patch) => validate(patch, UpdateBankrollSchema));
-            return plan();
-        },
     },
 }));

package/dist/src/process-transfers/index.js

@@ -5,8 +5,6 @@ import assert from "assert";
 import { logger } from "../logger.js";
 import * as config from "../config.js";
 import * as db from "../db/index.js";
-import * as pg from "pg";
-import { z } from "zod/v4";
 const activeCasinos = new Set();
 export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {
@@ -44,51 +42,9 @@ export function initializeTransferProcessors({ signal, pool, }) {
                 logger.info(`Starting casino processor for "${casino.name}" at "${casino.graphql_url}"`);
                 startCasinoTransferProcessor({ casinoId: casino.id, signal, pool });
             }
-            await listenForNewCasinos({ signal, pool });
         }
         catch (e) {
             logger.error(e, `Error initializing transfer processors`);
         }
     })();
 }
-async function listenForNewCasinos({ signal, pool, }) {
-    const pgClient = new pg.Client(config.SUPERUSER_DATABASE_URL);
-    await pgClient.connect();
-    const NewCasinoPayload = z.object({
-        id: z.string(),
-    });
-    pgClient.on("notification", async (msg) => {
-        logger.debug(msg, `[listenForNewCasinos] received notification`);
-        switch (msg.channel) {
-            case "hub:new_casino": {
-                if (!msg.payload) {
-                    logger.error("hub:new_casino notification has no payload");
-                    return;
-                }
-                let json;
-                try {
-                    json = JSON.parse(msg.payload);
-                }
-                catch (error) {
-                    logger.error(error, "Error parsing new casino notification");
-                }
-                const result = NewCasinoPayload.safeParse(json);
-                if (!result.success) {
-                    logger.error(result.error, "Error parsing new casino notification");
-                    return;
-                }
-                startCasinoTransferProcessor({
-                    casinoId: result.data.id,
-                    signal,
-                    pool,
-                });
-                break;
-            }
-        }
-    });
-    signal.addEventListener("abort", () => {
-        pgClient.removeAllListeners("notification");
-        pgClient.end();
-    });
-    await pgClient.query("LISTEN new_casino");
-}

package/dist/src/process-transfers/polling-processor.js

@@ -123,35 +123,59 @@ export function startPollingProcessor({ casinoId, signal, pool, }) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (3)`);
                     break;
                 }
-                cursor = await processTransfersUntilEmpty({
-                    afterCursor: cursor,
-                    graphqlClient,
-                    casinoInfo: { ...casino, ...casinoSecret },
-                    signal,
-                    pool,
-                });
+                let anyTaskFailed = false;
+                try {
+                    cursor = await processTransfersUntilEmpty({
+                        afterCursor: cursor,
+                        graphqlClient,
+                        casinoInfo: { ...casino, ...casinoSecret },
+                        signal,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `transfer polling failed for casino ${casinoId}`);
+                }
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (4)`);
                     break;
                 }
-                await processWithdrawals({
-                    abortSignal: signal,
-                    casinoId: casino.id,
-                    graphqlClient,
-                    pool,
-                });
+                try {
+                    await processWithdrawals({
+                        abortSignal: signal,
+                        casinoId: casino.id,
+                        graphqlClient,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `withdrawal processing failed for casino ${casinoId}`);
+                }
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (5)`);
                     break;
                 }
-                await processTakeRequests({
-                    abortSignal: signal,
-                    controllerId: casinoSecret.controller_id,
-                    casinoId: casino.id,
-                    graphqlClient,
-                    pool,
-                });
-                processorState.backoffTime = MIN_BACKOFF_TIME;
+                try {
+                    await processTakeRequests({
+                        abortSignal: signal,
+                        controllerId: casinoSecret.controller_id,
+                        casinoId: casino.id,
+                        graphqlClient,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `take request processing failed for casino ${casinoId}`);
+                }
+                if (anyTaskFailed) {
+                    processorState.backoffTime = Math.min(processorState.backoffTime * 2, MAX_BACKOFF_TIME);
+                }
+                else {
+                    processorState.backoffTime = MIN_BACKOFF_TIME;
+                }
             }
             catch (e) {
                 processorState.backoffTime = Math.min(processorState.backoffTime * 2, MAX_BACKOFF_TIME);

package/dist/src/process-transfers/process-transfer.js

@@ -143,10 +143,6 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
         logger.debug(`I sent ${user.uname} ${transfer.amount} base units of ${currency.id}`);
         switch (transfer.status) {
             case TransferStatusKind.Canceled:
-                await db.settleWithdrawal(pool, {
-                    withdrawalId: transfer.id,
-                    newStatus: "CANCELED",
-                });
                 return;
             case TransferStatusKind.Unclaimed:
                 throw new Error(`Unexpected UNCLAIMED withdrawal.`);

package/dist/src/process-transfers/websocket-processor.js

@@ -90,7 +90,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             return;
         }
         assert(mpTransfer.__typename === "ExperienceTransfer", `Expected experience transfer but got ${mpTransfer.__typename}`);
-        processTransfer({
+        await processTransfer({
             casinoId,
             controllerId,
             transfer: mpTransfer,

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

@@ -15,6 +15,7 @@ import { HubUserBalanceByCurrencyPlugin } from "../plugins/hub-user-balance-by-c
 import { logger } from "../logger.js";
 import { ValidateCasinoFieldsPlugin } from "../plugins/validate-fields.js";
 import { HubAddCasinoPlugin } from "../plugins/hub-add-casino.js";
+import { HubAdjustBankrollPlugin } from "../plugins/hub-adjust-bankroll.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";
@@ -44,6 +45,7 @@ export const requiredPlugins = [
     HubUserBalanceByCurrencyPlugin,
     HubAddCasinoPlugin,
     ValidateCasinoFieldsPlugin,
+    HubAdjustBankrollPlugin,
     HubOutcomeInputNonNullFieldsPlugin,
     HubBadHashChainErrorPlugin,
     HubCreateHashChainPlugin,

package/dist/src/smart-tags.js

@@ -23,9 +23,14 @@ export const SmartTagsPlugin = makeJSONPgSmartTagsPlugin({
                     behavior: ["-orderBy"],
                 },
             },
-            "hub.bankroll.amount": {
+            "hub.user.client_id": {
                 tags: {
-                    behavior: ["+attribute:update"],
+                    behavior: ["-select", "-filterBy", "-orderBy"],
+                },
+            },
+            "hub.experience.client_id": {
+                tags: {
+                    behavior: ["-select", "-filterBy", "-orderBy"],
                 },
             },
         },
@@ -35,11 +40,6 @@ export const SmartTagsPlugin = makeJSONPgSmartTagsPlugin({
                     behavior: ["-resource:select"],
                 },
             },
-            "hub.bankroll": {
-                tags: {
-                    behavior: ["+resource:update"],
-                },
-            },
             "hub.casino": {
                 tags: {
                     behavior: [