@moneypot/hub 1.18.0-dev.2 → 1.18.0-dev.4

package/README.md

@@ -77,6 +77,14 @@ insert into hub.api_key default values returning key;
 
 You should always keep your hub server up to date as soon as possible. Never install an old, intermediate version: it may leave you without an automatic upgrade path.
 
+### 1.18.x
+
+- `MakeOutcomeBetPlugin` replaced by `HubGameConfigPlugin({ outcomeBetConfigs,
+customGameConfigs })`
+- Added graphql query `hubRiskLimits(gameKinds: [DICE])` to get risk limits for
+  the game kinds configured in `HubGameConfigPlugin`.
+  - This lets experiences display the max payout for each kind of bet.
+
 ### 1.17.x
 
 - Postgres transactions now default to read committed (postgres default)

package/dist/src/custom-game-config.d.ts

@@ -0,0 +1,7 @@
+import { RiskPolicy } from "./risk-policy.js";
+export type CustomGameConfig = {
+    riskPolicy: RiskPolicy;
+};
+export type CustomGameConfigMap<CustomGameKind extends string> = {
+    [kind in CustomGameKind]: CustomGameConfig;
+};

package/dist/src/custom-game-config.js

@@ -0,0 +1 @@
+export {};

package/dist/src/index.d.ts

@@ -17,22 +17,25 @@ declare global {
         }
     }
 }
-export { MakeOutcomeBetPlugin, type OutcomeBetConfigMap, type OutcomeBetConfig, } from "./plugins/hub-make-outcome-bet.js";
+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 PluginContext = Grafast.Context;
-export { defaultPlugins, type PluginIdentity, type UserSessionContext, } from "./server/graphile.config.js";
+export { defaultPlugins, type PluginIdentity, type UserSessionContext, type HubPlugin, } from "./server/graphile.config.js";
 export type ConfigureAppArgs = {
     app: Express;
     superuserPool: ServerContext["superuserPool"];
 };
+import type { HubPlugin } from "./server/graphile.config.js";
 export type ServerOptions = {
     configureApp?: (args: ConfigureAppArgs) => void;
-    plugins?: readonly GraphileConfig.Plugin[];
+    plugins?: readonly HubPlugin[];
     extraPgSchemas?: string[];
     exportSchemaSDLPath?: string;
     userDatabaseMigrationsPath?: string;
     enableChat?: boolean;
     enablePlayground?: boolean;
+    port?: number;
 };
 export declare function runMigrations(options: {
     userDatabaseMigrationsPath?: string;

package/dist/src/index.js

@@ -6,7 +6,7 @@ import { initializeTransferProcessors } from "./process-transfers/index.js";
 import { join } from "path";
 import { logger } from "./logger.js";
 import { createServerContext, closeServerContext, } from "./context.js";
-export { MakeOutcomeBetPlugin, } from "./plugins/hub-make-outcome-bet.js";
+export { HubGameConfigPlugin, } from "./plugins/hub-game-config-plugin.js";
 export { validateRisk, } from "./risk-policy.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
 export async function runMigrations(options) {
@@ -28,6 +28,7 @@ export async function runMigrations(options) {
                 pgClient,
                 dirname: join(import.meta.dirname, "pg-versions"),
                 schemaName: "hub_core_versions",
+                silent: process.env.NODE_ENV === "test",
             });
         }
         catch (e) {
@@ -43,6 +44,7 @@ export async function runMigrations(options) {
                 pgClient,
                 dirname: options.userDatabaseMigrationsPath,
                 schemaName: "hub_user_versions",
+                silent: process.env.NODE_ENV === "test",
             });
         }
     }
@@ -71,7 +73,7 @@ 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?");
+        throw new Error("`plugins` should be an array of HubPlugin but one of the items is a function. Did you forget to call it?");
     }
     if (options.userDatabaseMigrationsPath &&
         !options.userDatabaseMigrationsPath.startsWith("/")) {
@@ -98,6 +100,7 @@ export async function startAndListen(options) {
         context,
         enableChat: options.enableChat ?? true,
         enablePlayground: options.enablePlayground ?? true,
+        port: options.port ?? config.PORT,
     });
     const gracefulShutdown = async ({ exit = true } = {}) => {
         if (isShuttingDown) {
@@ -128,9 +131,9 @@ export async function startAndListen(options) {
         process.on("SIGINT", gracefulShutdown);
         process.on("SIGTERM", gracefulShutdown);
     }
-    return hubServer.listen().then(() => {
+    return hubServer.listen().then(({ port }) => {
         return {
-            port: config.PORT,
+            port,
             stop: async () => {
                 await gracefulShutdown({ exit: false });
             },

package/dist/src/plugins/hub-game-config-plugin.d.ts

@@ -0,0 +1,15 @@
+import { type OutcomeBetConfig, type OutcomeBetConfigMap } from "./hub-make-outcome-bet.js";
+import { CustomGameConfigMap } from "../custom-game-config.js";
+export type { OutcomeBetConfig, OutcomeBetConfigMap };
+declare const HUB_GAME_CONFIG_PLUGIN_BRAND: unique symbol;
+export type HubGameConfigPlugin = {
+    readonly [HUB_GAME_CONFIG_PLUGIN_BRAND]: true;
+    readonly outcomeBetConfigs: OutcomeBetConfigMap<string>;
+    readonly customGameConfigs?: CustomGameConfigMap<string>;
+};
+export declare function isHubGameConfigPlugin(p: unknown): p is HubGameConfigPlugin;
+export declare function expandHubGameConfigPlugin(config: HubGameConfigPlugin): GraphileConfig.Plugin[];
+export declare function HubGameConfigPlugin<OutcomeBetKind extends string, CustomGameKind extends string = never>({ outcomeBetConfigs, customGameConfigs, }: {
+    outcomeBetConfigs: OutcomeBetConfigMap<OutcomeBetKind>;
+    customGameConfigs?: CustomGameConfigMap<CustomGameKind>;
+}): HubGameConfigPlugin;

package/dist/src/plugins/hub-game-config-plugin.js

@@ -0,0 +1,25 @@
+import { MakeOutcomeBetPlugin, } from "./hub-make-outcome-bet.js";
+import { HubRiskLimitsPlugin } from "./hub-risk-limits.js";
+const HUB_GAME_CONFIG_PLUGIN_BRAND = Symbol("HubGameConfigPlugin");
+export function isHubGameConfigPlugin(p) {
+    return (typeof p === "object" &&
+        p !== null &&
+        HUB_GAME_CONFIG_PLUGIN_BRAND in p &&
+        p[HUB_GAME_CONFIG_PLUGIN_BRAND] === true);
+}
+export function expandHubGameConfigPlugin(config) {
+    return [
+        MakeOutcomeBetPlugin({ outcomeBetConfigs: config.outcomeBetConfigs }),
+        HubRiskLimitsPlugin({
+            outcomeBetConfigs: config.outcomeBetConfigs,
+            customGameConfigs: config.customGameConfigs,
+        }),
+    ];
+}
+export function HubGameConfigPlugin({ outcomeBetConfigs, customGameConfigs, }) {
+    return {
+        [HUB_GAME_CONFIG_PLUGIN_BRAND]: true,
+        outcomeBetConfigs,
+        customGameConfigs,
+    };
+}

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

@@ -33,10 +33,10 @@ export type OutcomeBetConfig = {
     initializeMetadataFromUntrustedUserInput?: (input: Input) => Result<Metadata, string>;
     finalizeMetadata?: (validatedMetadata: Metadata, data: FinalizeMetadataData) => Metadata;
 };
-export type OutcomeBetConfigMap<BetKind extends string> = {
-    [betKind in BetKind]: OutcomeBetConfig;
+export type OutcomeBetConfigMap<OutcomeBetKind extends string> = {
+    [kind in OutcomeBetKind]: OutcomeBetConfig;
 };
-export declare function MakeOutcomeBetPlugin<BetKind extends string>({ betConfigs }: {
-    betConfigs: OutcomeBetConfigMap<BetKind>;
+export declare function MakeOutcomeBetPlugin<OutcomeBetKind extends string>({ outcomeBetConfigs, }: {
+    outcomeBetConfigs: OutcomeBetConfigMap<OutcomeBetKind>;
 }): GraphileConfig.Plugin;
 export {};

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

@@ -2,7 +2,7 @@ import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/g
 import { gql, extendSchema } from "postgraphile/utils";
 import * as z from "zod/v4";
 import { GraphQLError } from "graphql";
-import { DbHashKind, dbGetHouseBankrolls, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
 import { getIntermediateHash } from "../hash-chain/get-hash.js";
@@ -68,18 +68,19 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .function()
         .optional(),
 }));
-export function MakeOutcomeBetPlugin({ betConfigs }) {
-    BetConfigsSchema.parse(betConfigs);
-    const betKinds = Object.keys(betConfigs);
+export function MakeOutcomeBetPlugin({ outcomeBetConfigs, }) {
+    BetConfigsSchema.parse(outcomeBetConfigs);
+    const outcomeBetKinds = Object.keys(outcomeBetConfigs);
+    const outcomeBetKindEnumValues = outcomeBetKinds.length > 0 ? outcomeBetKinds : ["_NONE"];
     return extendSchema((build) => {
         const outcomeBetTable = build.input.pgRegistry.pgResources.hub_outcome_bet;
         const typeDefs = gql `
-        enum BetKind {
-          ${betKinds.join("\n")}
+        enum OutcomeBetKind {
+          ${outcomeBetKindEnumValues.join("\n")}
         }
 
         input HubMakeOutcomeBetInput {
-          kind: BetKind!
+          kind: OutcomeBetKind!
           wager: Int!
           currency: String!
           outcomes: [HubOutcomeInput!]!
@@ -106,70 +107,10 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         extend type Mutation {
           hubMakeOutcomeBet(input: HubMakeOutcomeBetInput!): HubMakeOutcomeBetPayload
         }
-
-        type HubRiskLimit {
-          maxPayout: Float!
-          maxWager: Float
-        }
-
-        type HubBulkRiskLimit {
-          betKind: BetKind!
-          currency: String!
-          maxPayout: Float!
-          maxWager: Float
-        }
-
-        extend type Query {
-          hubRiskLimits(betKinds: [BetKind!]!): [HubBulkRiskLimit!]!
-        }
       `;
         return {
             typeDefs,
             objects: {
-                Query: {
-                    plans: {
-                        hubRiskLimits: (_, { $betKinds }) => {
-                            const $identity = context().get("identity");
-                            const $superuserPool = context().get("superuserPool");
-                            const $result = sideEffect([$identity, $superuserPool, $betKinds], async ([identity, superuserPool, inputBetKinds]) => {
-                                if (identity?.kind !== "user") {
-                                    throw new GraphQLError("Unauthorized");
-                                }
-                                if (inputBetKinds.length > 5) {
-                                    throw new GraphQLError("Maximum 5 bet kinds allowed");
-                                }
-                                if (new Set(inputBetKinds).size !== inputBetKinds.length) {
-                                    throw new GraphQLError("Duplicate bet kinds not allowed");
-                                }
-                                for (const kind of inputBetKinds) {
-                                    if (!betConfigs[kind]) {
-                                        throw new GraphQLError(`Invalid bet kind: ${kind}`);
-                                    }
-                                }
-                                const dbHouseBankrolls = await dbGetHouseBankrolls(superuserPool, {
-                                    casinoId: identity.session.casino_id,
-                                });
-                                const limits = inputBetKinds.flatMap((betKind) => {
-                                    const betConfig = betConfigs[betKind];
-                                    return dbHouseBankrolls.map((bankroll) => {
-                                        const riskLimits = betConfig.riskPolicy({
-                                            type: "get-limits",
-                                            currency: bankroll.currency_key,
-                                            bankroll: bankroll.amount,
-                                        });
-                                        return {
-                                            betKind,
-                                            currency: bankroll.currency_key,
-                                            ...riskLimits,
-                                        };
-                                    });
-                                });
-                                return limits;
-                            });
-                            return $result;
-                        },
-                    },
-                },
                 Mutation: {
                     plans: {
                         hubMakeOutcomeBet: (_, { $input }) => {
@@ -180,10 +121,10 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     throw new GraphQLError("Unauthorized");
                                 }
                                 let input;
-                                let betKind;
+                                let outcomeBetKind;
                                 try {
                                     input = InputSchema.parse(rawInput);
-                                    betKind = BetKindSchema.parse(rawInput.kind);
+                                    outcomeBetKind = BetKindSchema.parse(rawInput.kind);
                                 }
                                 catch (e) {
                                     if (e instanceof z.ZodError) {
@@ -195,9 +136,9 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     input.currency !== "HOUSE") {
                                     throw new GraphQLError("Playground users can only bet with HOUSE currency");
                                 }
-                                const betConfig = betConfigs[betKind];
+                                const betConfig = outcomeBetConfigs[outcomeBetKind];
                                 if (!betConfig) {
-                                    throw new GraphQLError(`Invalid bet kind`);
+                                    throw new GraphQLError(`Invalid outcome bet kind`);
                                 }
                                 if (!betConfig.allowLossBeyondWager) {
                                     const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
@@ -508,17 +449,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         },
                     },
                 },
-                HubRiskLimit: {
-                    assertStep: ObjectStep,
-                    plans: {
-                        maxWager($data) {
-                            return access($data, "maxWager");
-                        },
-                        maxPayout($data) {
-                            return access($data, "maxPayout");
-                        },
-                    },
-                },
                 HubMakeOutcomeBetPayload: {
                     assertStep: ObjectStep,
                     plans: {

package/dist/src/plugins/hub-risk-limits.d.ts

@@ -0,0 +1,6 @@
+import { OutcomeBetConfigMap } from "./hub-make-outcome-bet.js";
+import { CustomGameConfigMap } from "../custom-game-config.js";
+export declare function HubRiskLimitsPlugin<OutcomeBetKind extends string, CustomGameKind extends string = never>({ outcomeBetConfigs, customGameConfigs, }: {
+    outcomeBetConfigs: OutcomeBetConfigMap<OutcomeBetKind>;
+    customGameConfigs?: CustomGameConfigMap<CustomGameKind>;
+}): GraphileConfig.Plugin;

package/dist/src/plugins/hub-risk-limits.js

@@ -0,0 +1,128 @@
+import { context, sideEffect, access } from "postgraphile/grafast";
+import { gql, extendSchema } from "postgraphile/utils";
+import { GraphQLError } from "graphql";
+import { dbGetHouseBankrolls } from "../db/index.js";
+export function HubRiskLimitsPlugin({ outcomeBetConfigs, customGameConfigs, }) {
+    const outcomeBetKinds = Object.keys(outcomeBetConfigs);
+    const customGameKinds = customGameConfigs
+        ? Object.keys(customGameConfigs)
+        : [];
+    if (customGameConfigs) {
+        const outcomeBetKindSet = new Set(outcomeBetKinds);
+        for (const kind of customGameKinds) {
+            if (outcomeBetKindSet.has(kind)) {
+                throw new Error(`Key collision: "${kind}" exists in both outcomeBetConfigs and customGameConfigs`);
+            }
+        }
+    }
+    const anyGameKinds = [...outcomeBetKinds, ...customGameKinds];
+    const anyGameKindEnumValues = anyGameKinds.length > 0 ? anyGameKinds : ["_NONE"];
+    const mergedConfigs = {};
+    for (const kind of outcomeBetKinds) {
+        mergedConfigs[kind] = outcomeBetConfigs[kind];
+    }
+    if (customGameConfigs) {
+        for (const kind of customGameKinds) {
+            mergedConfigs[kind] = customGameConfigs[kind];
+        }
+    }
+    return extendSchema((build) => {
+        const typeDefs = gql `
+      enum AnyGameKind {
+        ${anyGameKindEnumValues.join("\n")}
+      }
+
+      ${customGameKinds.length > 0
+            ? `enum CustomGameKind {
+        ${customGameKinds.join("\n")}
+      }`
+            : ""}
+
+      type HubRiskLimit {
+        maxPayout: Float!
+      }
+
+      type HubBulkRiskLimit {
+        gameKind: AnyGameKind!
+        currency: String!
+        maxPayout: Float!
+      }
+
+      extend type Query {
+        hubRiskLimits(gameKinds: [AnyGameKind!]!): [HubBulkRiskLimit!]!
+      }
+    `;
+        return {
+            typeDefs,
+            objects: {
+                Query: {
+                    plans: {
+                        hubRiskLimits: (_, { $gameKinds }) => {
+                            const $identity = context().get("identity");
+                            const $superuserPool = context().get("superuserPool");
+                            const $result = sideEffect([$identity, $superuserPool, $gameKinds], async ([identity, superuserPool, inputGameKinds]) => {
+                                if (identity?.kind !== "user") {
+                                    throw new GraphQLError("Unauthorized");
+                                }
+                                if (inputGameKinds.length > 10) {
+                                    throw new GraphQLError("Maximum 10 game kinds allowed");
+                                }
+                                if (new Set(inputGameKinds).size !== inputGameKinds.length) {
+                                    throw new GraphQLError("Duplicate game kinds not allowed");
+                                }
+                                for (const kind of inputGameKinds) {
+                                    if (kind === "_NONE" || !mergedConfigs[kind]) {
+                                        throw new GraphQLError(`Invalid game kind: ${kind}`);
+                                    }
+                                }
+                                if (anyGameKinds.length === 0) {
+                                    return [];
+                                }
+                                const dbHouseBankrolls = await dbGetHouseBankrolls(superuserPool, {
+                                    casinoId: identity.session.casino_id,
+                                });
+                                const limits = inputGameKinds.flatMap((gameKind) => {
+                                    const config = mergedConfigs[gameKind];
+                                    return dbHouseBankrolls.map((bankroll) => {
+                                        const riskLimits = config.riskPolicy({
+                                            type: "get-limits",
+                                            currency: bankroll.currency_key,
+                                            bankroll: bankroll.amount,
+                                        });
+                                        return {
+                                            gameKind,
+                                            currency: bankroll.currency_key,
+                                            maxPayout: riskLimits.maxPayout,
+                                        };
+                                    });
+                                });
+                                return limits;
+                            });
+                            return $result;
+                        },
+                    },
+                },
+                HubRiskLimit: {
+                    plans: {
+                        maxPayout($data) {
+                            return access($data, "maxPayout");
+                        },
+                    },
+                },
+                HubBulkRiskLimit: {
+                    plans: {
+                        gameKind($data) {
+                            return access($data, "gameKind");
+                        },
+                        currency($data) {
+                            return access($data, "currency");
+                        },
+                        maxPayout($data) {
+                            return access($data, "maxPayout");
+                        },
+                    },
+                },
+            },
+        };
+    }, "HubRiskLimitsPlugin");
+}

package/dist/src/process-withdrawal-request.d.ts

@@ -1,7 +1 @@
-import * as pg from "pg";
-import { GraphQLClient } from "graphql-request";
-export declare function processWithdrawalRequests({ casinoId, graphqlClient, pool, }: {
-    casinoId: string;
-    graphqlClient: GraphQLClient;
-    pool: pg.Pool;
-}): Promise<void>;
+export {};

package/dist/src/process-withdrawal-request.js

@@ -1,146 +1 @@
-import { assert } from "tsafe";
-import { TransferStatusKind } from "./__generated__/graphql.js";
-import { withPgPoolTransaction } from "./db/index.js";
-import { maybeOneRow, exactlyOneRow } from "./db/util.js";
-import { START_PENDING_EXPERIENCE_TRANSFER } from "./graphql-queries.js";
-import { logger } from "./logger.js";
-async function processWithdrawalRequest({ requestId, graphqlClient, pool, }) {
-    return withPgPoolTransaction(pool, async (pgClient) => {
-        const dbWithdrawalRequest = await pgClient
-            .query({
-            text: `
-          select *
-          from hub.withdrawal_request
-          where id = $1
-
-          FOR UPDATE
-        `,
-            values: [requestId],
-        })
-            .then(maybeOneRow);
-        if (!dbWithdrawalRequest) {
-            throw new Error("Withdrawal request not found");
-        }
-        if (dbWithdrawalRequest.mp_transfer_id) {
-            return;
-        }
-        const dbUser = await pgClient
-            .query({
-            text: `select * from hub.user where id = $1`,
-            values: [dbWithdrawalRequest.user_id],
-        })
-            .then(exactlyOneRow);
-        const dbExperience = await pgClient
-            .query({
-            text: `select * from hub.experience where id = $1`,
-            values: [dbWithdrawalRequest.experience_id],
-        })
-            .then(exactlyOneRow);
-        const mpResult = await graphqlClient
-            .request({
-            document: START_PENDING_EXPERIENCE_TRANSFER,
-            variables: {
-                mpUserId: dbUser.mp_user_id,
-                mpExperienceId: dbExperience.mp_experience_id,
-                amount: dbWithdrawalRequest.amount,
-                currency: dbWithdrawalRequest.currency_key,
-                metadata: JSON.stringify({
-                    id: `withdrawal_request:${dbWithdrawalRequest.id}`,
-                }),
-            },
-        })
-            .then((res) => res.transferCurrencyExperienceToUser?.result);
-        if (!mpResult?.__typename) {
-            throw new Error(`Failed to start MP transfer: ${mpResult}`);
-        }
-        if (mpResult.__typename === "TakeRequestAlreadyTerminal") {
-            if (mpResult.takeRequest.experienceTransfer) {
-                const mpTransferId = mpResult.takeRequest.experienceTransfer.id;
-                await pgClient.query({
-                    text: `
-            update hub.withdrawal_request
-            set mp_transfer_id = $2
-            where id = $1
-          `,
-                    values: [dbWithdrawalRequest.id, mpTransferId],
-                });
-            }
-        }
-        if (mpResult?.__typename !== "TransferSuccess" &&
-            mpResult?.__typename !== "TransferMetadataIdExists") {
-            throw new Error(`Failed to start MP transfer: ${mpResult}`);
-        }
-        const mpTransferId = mpResult.transfer.id;
-        const mpStatus = mpResult.transfer.status;
-        await pgClient
-            .query({
-            text: `
-        update hub.withdrawal_request
-        set mp_transfer_id = $2
-        where id = $1
-      `,
-            values: [dbWithdrawalRequest.id, mpTransferId],
-        })
-            .then((res) => {
-            assert(res.rowCount === 1, `Expected to update a hub.withdrawal_request.mp_transfer_id`);
-        });
-        if (mpStatus === TransferStatusKind.Pending ||
-            mpStatus === TransferStatusKind.Completed) {
-        }
-        else {
-            logger.warn(`Expected status to be PENDING or COMPLETED, but got ${mpStatus}`);
-            return;
-        }
-        await pgClient.query({
-            text: `
-        insert into hub.withdrawal(
-          id, 
-          casino_id, 
-          mp_transfer_id,
-          user_id, 
-          experience_id, 
-          amount,
-          currency_key,
-          status,
-          withdrawal_request_id
-        ) 
-        values ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-      `,
-            values: [
-                dbWithdrawalRequest.id,
-                dbWithdrawalRequest.casino_id,
-                mpTransferId,
-                dbWithdrawalRequest.user_id,
-                dbWithdrawalRequest.experience_id,
-                dbWithdrawalRequest.amount,
-                dbWithdrawalRequest.currency_key,
-                mpResult.transfer.status,
-                dbWithdrawalRequest.id,
-            ],
-        });
-    });
-}
-export async function processWithdrawalRequests({ casinoId, graphqlClient, pool, }) {
-    const pendingRequests = await pool.query({
-        text: `
-      SELECT wr.* 
-      FROM hub.withdrawal_request wr
-      WHERE wr.casino_id = $1 
-      AND wr.mp_transfer_id IS NULL
-      LIMIT 10
-    `,
-        values: [casinoId],
-    });
-    for (const request of pendingRequests.rows) {
-        try {
-            await processWithdrawalRequest({
-                requestId: request.id,
-                graphqlClient,
-                pool,
-            });
-        }
-        catch (error) {
-            logger.error(error, `Failed to process withdrawal request ${request.id}`);
-        }
-    }
-}
+export {};

package/dist/src/risk-policy.d.ts

@@ -14,7 +14,6 @@ export type BetLimitPolicyArgs = {
     bankroll: number;
 };
 export type RiskLimits = {
-    maxWager?: number;
     maxPayout: number;
 };
 export type RiskPolicy = (args: RiskPolicyArgs | BetLimitPolicyArgs) => RiskLimits;

package/dist/src/risk-policy.js

@@ -2,7 +2,6 @@ import { formatCurrency } from "./format-currency.js";
 import { z } from "zod/v4";
 const RiskLimitsSchema = z
     .object({
-    maxWager: z.number().positive().optional(),
     maxPayout: z.number().positive(),
 })
     .strict();
@@ -21,20 +20,6 @@ export function validateRisk(options) {
             error: { message, riskLimits: options.riskLimits },
         };
     }
-    if (options.riskLimits.maxWager !== undefined &&
-        wager > options.riskLimits.maxWager) {
-        const message = `Wager (${formatCurrency(wager, {
-            displayUnitName: options.displayUnitName,
-            displayUnitScale: options.displayUnitScale,
-        })}) exceeds limit (${formatCurrency(options.riskLimits.maxWager, {
-            displayUnitName: options.displayUnitName,
-            displayUnitScale: options.displayUnitScale,
-        })})`;
-        return {
-            ok: false,
-            error: { message, riskLimits: options.riskLimits },
-        };
-    }
     if (maxPotentialPayout > options.riskLimits.maxPayout) {
         const message = `Payout (${formatCurrency(maxPotentialPayout, {
             displayUnitName: options.displayUnitName,

package/dist/src/server/graphile.config.d.ts

@@ -27,8 +27,10 @@ export type OurPgSettings = {
 };
 export declare const requiredPlugins: readonly GraphileConfig.Plugin[];
 export declare const defaultPlugins: readonly GraphileConfig.Plugin[];
+import { HubGameConfigPlugin } from "../plugins/hub-game-config-plugin.js";
+export type HubPlugin = GraphileConfig.Plugin | HubGameConfigPlugin;
 export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }: {
-    plugins: readonly GraphileConfig.Plugin[];
+    plugins: readonly HubPlugin[];
     exportSchemaSDLPath?: string;
     extraPgSchemas: string[];
     abortSignal: AbortSignal;

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

@@ -56,6 +56,7 @@ export const defaultPlugins = [
     HubPreimageHashFieldPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];
+import { HubGameConfigPlugin, isHubGameConfigPlugin, expandHubGameConfigPlugin, } from "../plugins/hub-game-config-plugin.js";
 export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }) {
     if (exportSchemaSDLPath) {
         if (!exportSchemaSDLPath.startsWith("/")) {
@@ -66,9 +67,20 @@ export function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, abo
         }
         logger.info(`Will save generated graphql schema to ${exportSchemaSDLPath}`);
     }
-    const mutablePlugins = [...plugins];
+    const pluginsWithDefault = plugins.some(isHubGameConfigPlugin)
+        ? plugins
+        : [...plugins, HubGameConfigPlugin({ outcomeBetConfigs: {} })];
+    const mutablePlugins = [];
+    for (const p of pluginsWithDefault) {
+        if (isHubGameConfigPlugin(p)) {
+            mutablePlugins.push(...expandHubGameConfigPlugin(p));
+        }
+        else {
+            mutablePlugins.push(p);
+        }
+    }
     for (const requiredPlugin of requiredPlugins) {
-        if (!plugins.some((plugin) => plugin === requiredPlugin)) {
+        if (!mutablePlugins.some((plugin) => plugin === requiredPlugin)) {
             logger.warn(`Adding required plugin "${requiredPlugin.name}"`);
             mutablePlugins.unshift(requiredPlugin);
         }

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

@@ -1,12 +1,15 @@
 import { ServerOptions } from "../index.js";
 import { ServerContext } from "../context.js";
 export type HubServer = {
-    listen: () => Promise<void>;
+    listen: () => Promise<{
+        port: number;
+    }>;
     shutdown: () => Promise<void>;
 };
-export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
+export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, port, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
     abortSignal: AbortSignal;
     context: ServerContext;
     enableChat: boolean;
     enablePlayground: boolean;
+    port: number;
 }): HubServer;

package/dist/src/server/index.js

@@ -3,7 +3,6 @@ import { grafserv } from "postgraphile/grafserv/express/v4";
 import postgraphile from "postgraphile";
 import { createPreset, defaultPlugins } from "./graphile.config.js";
 import express from "express";
-import * as config from "../config.js";
 import { logger } from "../logger.js";
 import cors from "./middleware/cors.js";
 import authentication from "./middleware/authentication.js";
@@ -45,7 +44,7 @@ function createExpressServer(context) {
     });
     return app;
 }
-export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, }) {
+export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, port, }) {
     const expressServer = createExpressServer(context);
     const preset = createPreset({
         plugins: plugins ?? defaultPlugins,
@@ -72,7 +71,11 @@ export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, ex
     return {
         listen: () => {
             return new Promise((resolve) => {
-                nodeServer.listen(config.PORT, resolve);
+                nodeServer.listen(port, () => {
+                    const addr = nodeServer.address();
+                    const actualPort = typeof addr === "object" && addr ? addr.port : port;
+                    resolve({ port: actualPort });
+                });
             });
         },
         shutdown: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.18.0-dev.2",
+  "version": "1.18.0-dev.4",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [
@@ -51,7 +51,7 @@
   "dependencies": {
     "@graphile-contrib/pg-omit-archived": "^4.0.0-beta.4",
     "@moneypot/hash-herald": "^1.0.0",
-    "@moneypot/pg-upgrade-schema": "^2.0.4",
+    "@moneypot/pg-upgrade-schema": "^2.1.0",
     "@noble/curves": "^1.5.0",
     "dotenv": "^16.4.5",
     "express": "^5.0.1",