@moneypot/hub 1.17.1 → 1.18.0-dev.2

package/dist/src/db/index.js

@@ -82,7 +82,9 @@ export class DatabaseNotifier extends stream.EventEmitter {
 }
 export async function getTransferCursor(pgClient, { casinoId, }) {
     const row = await pgClient
-        .query("select cursor from hub_hidden.transfer_cursor where casino_id = $1", [casinoId])
+        .query("select cursor from hub_hidden.transfer_cursor where casino_id = $1", [
+        casinoId,
+    ])
         .then(maybeOneRow);
     return row?.cursor;
 }

package/dist/src/db/public.d.ts

@@ -1,10 +1,13 @@
-import { DbBalance, DbBankroll, DbCurrency, DbSession } from "./types.js";
+import { DbBalance, DbBankroll, DbCasino, DbCurrency, DbSession } from "./types.js";
 import { PgClientInTransaction, QueryExecutor } from "./index.js";
 export declare function dbGetActiveSessionById(pgClient: QueryExecutor, sessionId: string): Promise<DbSession | undefined>;
 export declare function dbGetCasinoCurrencyByKey(pgClient: QueryExecutor, { currencyKey, casinoId }: {
     currencyKey: string;
     casinoId: string;
 }): Promise<DbCurrency | undefined>;
+export declare function dbGetHouseBankrolls(pgClient: QueryExecutor, { casinoId }: {
+    casinoId: DbCasino["id"];
+}): Promise<Pick<DbBankroll, "id" | "currency_key" | "amount">[]>;
 export declare function dbLockPlayerBalance(pgClient: PgClientInTransaction, { userId, casinoId, experienceId, currencyKey, }: {
     userId: string;
     casinoId: string;

package/dist/src/db/public.js

@@ -13,20 +13,29 @@ export async function dbGetCasinoCurrencyByKey(pgClient, { currencyKey, casinoId
         .query(`
         SELECT *
         FROM hub.currency
-        WHERE key = $1 
+        WHERE key = $1
           AND casino_id = $2
       `, [currencyKey, casinoId])
         .then(maybeOneRow);
 }
+export async function dbGetHouseBankrolls(pgClient, { casinoId }) {
+    return pgClient
+        .query(`
+      SELECT id, currency_key, amount
+      FROM hub.bankroll
+      WHERE casino_id = $1
+      `, [casinoId])
+        .then((res) => res.rows);
+}
 export async function dbLockPlayerBalance(pgClient, { userId, casinoId, experienceId, currencyKey, }) {
     return pgClient
         .query(`
-    SELECT * 
-    FROM hub.balance 
-    WHERE user_id = $1 
-      AND casino_id = $2 
-      AND experience_id = $3 
-      AND currency_key = $4 
+    SELECT *
+    FROM hub.balance
+    WHERE user_id = $1
+      AND casino_id = $2
+      AND experience_id = $3
+      AND currency_key = $4
     FOR UPDATE
     `, [userId, casinoId, experienceId, currencyKey])
         .then(maybeOneRow)
@@ -35,10 +44,10 @@ export async function dbLockPlayerBalance(pgClient, { userId, casinoId, experien
 export async function dbLockHouseBankroll(pgClient, { casinoId, currencyKey }) {
     return pgClient
         .query(`
-      SELECT * 
-      FROM hub.bankroll 
-      WHERE casino_id = $1 
-        AND currency_key = $2 
+      SELECT *
+      FROM hub.bankroll
+      WHERE casino_id = $1
+        AND currency_key = $2
       FOR UPDATE
       `, [casinoId, currencyKey])
         .then(maybeOneRow)

package/dist/src/hash-chain/plugins/hub-bad-hash-chain-error.js

@@ -4,7 +4,7 @@ export const HubBadHashChainErrorPlugin = makeExtendSchemaPlugin(() => {
     return {
         typeDefs: gql `
       type HubBadHashChainError {
-        message: String
+        message: String!
       }
     `,
         objects: {

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

@@ -46,7 +46,7 @@ export const HubChatCreateUserMessagePlugin = extendSchema((build) => {
       }
 
       union HubChatCreateUserMessageResult =
-          HubChatCreateUserMessageSuccess
+        | HubChatCreateUserMessageSuccess
         | HubChatUserRateLimited
         | HubChatUserMuted
 

package/dist/src/plugins/chat/hub-chat-subscription.js

@@ -35,7 +35,7 @@ export const HubChatSubscriptionPlugin = extendSchema((build) => {
       }
 
       union HubChatSubscriptionPayload =
-          HubChatSubscriptionNewMessage
+        | HubChatSubscriptionNewMessage
         | HubChatSubscriptionMuted
         | HubChatSubscriptionUnmuted
 

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, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbGetHouseBankrolls, 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";
@@ -92,7 +92,12 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           bet: HubOutcomeBet!
         }
 
-        union HubMakeOutcomeBetResult = HubMakeOutcomeBetSuccess | HubBadHashChainError
+        type HubRiskError {
+          message: String!
+          riskLimits: HubRiskLimit!
+        }
+
+        union HubMakeOutcomeBetResult = HubMakeOutcomeBetSuccess | HubBadHashChainError | HubRiskError
 
         type HubMakeOutcomeBetPayload {
           result: HubMakeOutcomeBetResult!
@@ -101,10 +106,70 @@ 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 }) => {
@@ -284,18 +349,28 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     }
                                     const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
                                     const maxPotentialPayout = input.wager * maxProfitMultiplier;
+                                    const riskLimits = betConfig.riskPolicy({
+                                        type: "get-limits",
+                                        currency: input.currency,
+                                        bankroll: dbHouseBankroll.amount,
+                                    });
                                     const riskResult = validateRisk({
+                                        type: "validate-bet",
                                         currency: input.currency,
                                         wager: input.wager,
                                         bankroll: dbHouseBankroll.amount,
                                         maxPotentialPayout,
-                                        riskPolicy: betConfig.riskPolicy,
+                                        riskLimits,
                                         displayUnitName: dbCurrency.display_unit_name,
                                         displayUnitScale: dbCurrency.display_unit_scale,
                                         outcomes: input.outcomes,
                                     });
                                     if (!riskResult.ok) {
-                                        throw new GraphQLError(riskResult.error);
+                                        return {
+                                            __typename: "HubRiskError",
+                                            message: riskResult.error.message,
+                                            riskLimits: riskResult.error.riskLimits,
+                                        };
                                     }
                                     await pgClient.query({
                                         text: `
@@ -354,14 +429,14 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         .query({
                                         text: `
                       INSERT INTO hub.outcome_bet (
-                        user_id, 
-                        casino_id, 
-                        experience_id, 
+                        user_id,
+                        casino_id,
+                        experience_id,
                         hash_id,
                         kind,
-                        currency_key, 
-                        wager, 
-                        profit, 
+                        currency_key,
+                        wager,
+                        profit,
                         outcomes,
                         outcome_idx,
                         metadata
@@ -422,6 +497,28 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         },
                     },
                 },
+                HubRiskError: {
+                    assertStep: ObjectStep,
+                    plans: {
+                        message($data) {
+                            return access($data, "message");
+                        },
+                        riskLimits($data) {
+                            return access($data, "riskLimits");
+                        },
+                    },
+                },
+                HubRiskLimit: {
+                    assertStep: ObjectStep,
+                    plans: {
+                        maxWager($data) {
+                            return access($data, "maxWager");
+                        },
+                        maxPayout($data) {
+                            return access($data, "maxPayout");
+                        },
+                    },
+                },
                 HubMakeOutcomeBetPayload: {
                     assertStep: ObjectStep,
                     plans: {

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

@@ -107,8 +107,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
                 }
                 logger.debug(data, "MP_CLAIM_TRANSFER response");
                 if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
-                    if (data.claimTransfer?.result.__typename ===
-                        "InvalidTransferStatus" &&
+                    if (data.claimTransfer?.result.__typename === "InvalidTransferStatus" &&
                         data.claimTransfer?.result.currentStatus ===
                             TransferStatusKind.Completed) {
                         logger.info(`Transfer ${transfer.id} already claimed (status: COMPLETED), skipping claim but attempting deposit insert`);

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

@@ -1,20 +1,29 @@
 import { DbOutcome } from "./db/types.js";
 import { Result } from "./util.js";
 export type RiskPolicyArgs = {
+    type: "validate-bet";
     currency: string;
     wager: number;
     bankroll: number;
     maxPotentialPayout: number;
     outcomes: DbOutcome[];
 };
+export type BetLimitPolicyArgs = {
+    type: "get-limits";
+    currency: string;
+    bankroll: number;
+};
 export type RiskLimits = {
     maxWager?: number;
     maxPayout: number;
 };
-export type RiskPolicy = (args: RiskPolicyArgs) => RiskLimits;
+export type RiskPolicy = (args: RiskPolicyArgs | BetLimitPolicyArgs) => RiskLimits;
 export declare function validateRisk(options: RiskPolicyArgs & {
-    riskPolicy: RiskPolicy;
+    riskLimits: RiskLimits;
 } & {
     displayUnitName: string;
     displayUnitScale: number;
-}): Result<void, string>;
+}): Result<void, {
+    message: string;
+    riskLimits: RiskLimits;
+}>;

package/dist/src/risk-policy.js

@@ -1,5 +1,4 @@
 import { formatCurrency } from "./format-currency.js";
-import { logger } from "./logger.js";
 import { z } from "zod/v4";
 const RiskLimitsSchema = z
     .object({
@@ -8,53 +7,45 @@ const RiskLimitsSchema = z
 })
     .strict();
 export function validateRisk(options) {
-    const { wager, bankroll, maxPotentialPayout, riskPolicy } = options;
+    const { wager, bankroll, maxPotentialPayout } = options;
     if (maxPotentialPayout > bankroll) {
+        const message = `House cannot cover potential payout (${formatCurrency(maxPotentialPayout, {
+            displayUnitName: options.displayUnitName,
+            displayUnitScale: options.displayUnitScale,
+        })}). Bankroll: ${formatCurrency(bankroll, {
+            displayUnitName: options.displayUnitName,
+            displayUnitScale: options.displayUnitScale,
+        })}`;
         return {
             ok: false,
-            error: `House cannot cover potential payout (${formatCurrency(maxPotentialPayout, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })}). Bankroll: ${formatCurrency(bankroll, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })}`,
+            error: { message, riskLimits: options.riskLimits },
         };
     }
-    if (!riskPolicy) {
-        return { ok: true, value: undefined };
-    }
-    const limitsResult = RiskLimitsSchema.safeParse(riskPolicy(options));
-    if (!limitsResult.success) {
-        logger.error(limitsResult, "Invalid risk policy");
-        return {
-            ok: false,
-            error: "Invalid risk policy",
-        };
-    }
-    const limits = limitsResult.data;
-    if (limits.maxWager !== undefined && wager > limits.maxWager) {
+    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: `Wager (${formatCurrency(wager, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })}) exceeds limit (${formatCurrency(limits.maxWager, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })})`,
+            error: { message, riskLimits: options.riskLimits },
         };
     }
-    if (maxPotentialPayout > limits.maxPayout) {
+    if (maxPotentialPayout > options.riskLimits.maxPayout) {
+        const message = `Payout (${formatCurrency(maxPotentialPayout, {
+            displayUnitName: options.displayUnitName,
+            displayUnitScale: options.displayUnitScale,
+        })}) exceeds limit (${formatCurrency(options.riskLimits.maxPayout, {
+            displayUnitName: options.displayUnitName,
+            displayUnitScale: options.displayUnitScale,
+        })})`;
         return {
             ok: false,
-            error: `Payout (${formatCurrency(maxPotentialPayout, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })}) exceeds limit (${formatCurrency(limits.maxPayout, {
-                displayUnitName: options.displayUnitName,
-                displayUnitScale: options.displayUnitScale,
-            })})`,
+            error: { message, riskLimits: options.riskLimits },
         };
     }
     return { ok: true, value: undefined };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.17.1",
+  "version": "1.18.0-dev.2",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [
@@ -37,6 +37,7 @@
     "check": "tsc --noEmit && npm run check-dashboard",
     "check-tests": "tsc -p tests/tsconfig.json --noEmit",
     "check-dashboard": "cd ./dashboard && npm run check",
+    "format": "prettier --write \"**/*.ts\"",
     "lint": "eslint --fix . && npm run lint-dashboard",
     "lint-dashboard": "cd ./dashboard && npm run lint",
     "prepublishOnly": "npm run build",
@@ -77,6 +78,7 @@
     "eslint": "^9.8.0",
     "globals": "^16.0.0",
     "pino-pretty": "^13.0.0",
+    "prettier": "^3.6.2",
     "supertest": "^7.0.0",
     "tsx": "^4.20.3",
     "typescript": "^5.4.5",