@moneypot/hub 1.9.0-dev.10 → 1.9.0-dev.12

package/dist/src/index.d.ts

@@ -15,7 +15,8 @@ declare global {
         }
     }
 }
-export { MakeOutcomeBetPlugin, type OutcomeBetConfigMap, type OutcomeBetConfig, type RiskPolicy, type RiskLimits, } from "./plugins/hub-make-outcome-bet.js";
+export { MakeOutcomeBetPlugin, type OutcomeBetConfigMap, type OutcomeBetConfig, } from "./plugins/hub-make-outcome-bet.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 type ServerOptions = {

package/dist/src/index.js

@@ -6,6 +6,7 @@ import { initializeTransferProcessors } from "./process-transfers/index.js";
 import { join } from "path";
 import { logger } from "./logger.js";
 export { MakeOutcomeBetPlugin, } from "./plugins/hub-make-outcome-bet.js";
+export { validateRisk, } from "./risk-policy.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
 async function initialize(options) {
     if (options.signal.aborted) {

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

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { DbOutcome } from "../db/index.js";
 import { Result } from "../util.js";
+import { RiskPolicy } from "../risk-policy.js";
 declare const InputSchema: z.ZodObject<{
     kind: z.ZodString;
     clientSeed: z.ZodString;
@@ -75,16 +76,6 @@ export type OutcomeBetConfig = {
 export type OutcomeBetConfigMap<BetKind extends string> = {
     [betKind in BetKind]: OutcomeBetConfig;
 };
-type AtLeastOneKey<T, Keys extends keyof T = keyof T> = Keys extends keyof T ? Required<Pick<T, Keys>> & Partial<Omit<T, Keys>> : never;
-export type RiskLimits = AtLeastOneKey<{
-    maxWager?: number;
-    maxPayout?: number;
-}>;
-export type RiskPolicy = (args: {
-    currency: string;
-    wager: number;
-    bankroll: number;
-}) => RiskLimits;
 export declare function MakeOutcomeBetPlugin<BetKind extends string>({ betConfigs }: {
     betConfigs: OutcomeBetConfigMap<BetKind>;
 }): GraphileConfig.Plugin;

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

@@ -8,7 +8,7 @@ import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chai
 import { getIntermediateHash, getPreimageHash, } from "../hash-chain/get-hash.js";
 import { makeFinalHash, pickRandomOutcome } from "../hash-chain/util.js";
 import { logger } from "../logger.js";
-import { formatCurrency } from "../format-currency.js";
+import { validateRisk } from "../risk-policy.js";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -65,15 +65,6 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .function()
         .optional(),
 }));
-const RiskLimitsSchema = z
-    .object({
-    maxWager: z.number().positive().optional(),
-    maxPayout: z.number().positive().optional(),
-})
-    .strict()
-    .refine((v) => v.maxWager !== undefined || v.maxPayout !== undefined, {
-    message: "Provide at least one of maxWager or maxPayout.",
-});
 export function MakeOutcomeBetPlugin({ betConfigs }) {
     BetConfigsSchema.parse(betConfigs);
     const betKinds = Object.keys(betConfigs);
@@ -196,47 +187,19 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         throw new GraphQLError("You cannot afford the worst outcome");
                                     }
                                     const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
-                                    const maxPayout = input.wager * maxProfitMultiplier;
-                                    if (maxPayout > dbHouseBankroll.amount) {
-                                        throw new GraphQLError(`House cannot cover potential payout (${formatCurrency(maxPayout, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}). Bankroll: ${formatCurrency(dbHouseBankroll.amount, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}`);
-                                    }
-                                    const riskLimitsResult = RiskLimitsSchema.safeParse(betConfig.riskPolicy
-                                        ? betConfig.riskPolicy({
-                                            currency: input.currency,
-                                            wager: input.wager,
-                                            bankroll: dbHouseBankroll.amount,
-                                        })
-                                        : {});
-                                    if (!riskLimitsResult.success) {
-                                        logger.error(riskLimitsResult.error, "Invalid risk policy");
-                                        throw new GraphQLError("Invalid risk policy");
-                                    }
-                                    const riskLimits = riskLimitsResult.data;
-                                    if (riskLimits.maxWager != null &&
-                                        input.wager > riskLimits.maxWager) {
-                                        throw new GraphQLError(`Wager exceeds limit (${formatCurrency(riskLimits.maxWager, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}). Your wager: ${formatCurrency(input.wager, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}`);
-                                    }
-                                    if (riskLimits.maxPayout != null &&
-                                        maxPayout > riskLimits.maxPayout) {
-                                        throw new GraphQLError(`Payout exceeds limit (${formatCurrency(riskLimits.maxPayout, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}). Your payout: ${formatCurrency(maxPayout, {
-                                            displayUnitName: dbCurrency.display_unit_name,
-                                            displayUnitScale: dbCurrency.display_unit_scale,
-                                        })}`);
+                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
+                                    const riskResult = validateRisk({
+                                        currency: input.currency,
+                                        wager: input.wager,
+                                        bankroll: dbHouseBankroll.amount,
+                                        maxPotentialPayout,
+                                        riskPolicy: betConfig.riskPolicy,
+                                        displayUnitName: dbCurrency.display_unit_name,
+                                        displayUnitScale: dbCurrency.display_unit_scale,
+                                        outcomes: input.outcomes,
+                                    });
+                                    if (!riskResult.ok) {
+                                        throw new GraphQLError(riskResult.error);
                                     }
                                     const dbHashChain = await dbLockHubHashChain(pgClient, {
                                         userId: session.user_id,

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

@@ -0,0 +1,22 @@
+import { DbOutcome } from "./db/types.js";
+import { Result } from "./util.js";
+export type RiskPolicyArgs = {
+    currency: string;
+    wager: number;
+    bankroll: number;
+    maxPotentialPayout: number;
+    outcomes: DbOutcome[];
+};
+type AtLeastOneKey<T, Keys extends keyof T = keyof T> = Keys extends keyof T ? Required<Pick<T, Keys>> & Partial<Omit<T, Keys>> : never;
+export type RiskLimits = AtLeastOneKey<{
+    maxWager?: number;
+    maxPayout?: number;
+}>;
+export type RiskPolicy = (args: RiskPolicyArgs) => RiskLimits;
+export declare function validateRisk(options: RiskPolicyArgs & {
+    riskPolicy: RiskPolicy;
+} & {
+    displayUnitName: string;
+    displayUnitScale: number;
+}): Result<void, string>;
+export {};

package/dist/src/risk-policy.js

@@ -0,0 +1,64 @@
+import { formatCurrency } from "./format-currency.js";
+import { logger } from "./logger.js";
+import { z } from "zod";
+const RiskLimitsSchema = z
+    .object({
+    maxWager: z.number().positive().optional(),
+    maxPayout: z.number().positive().optional(),
+})
+    .strict()
+    .refine((v) => v.maxWager !== undefined || v.maxPayout !== undefined, {
+    message: "Provide at least one of maxWager or maxPayout.",
+});
+export function validateRisk(options) {
+    const { wager, bankroll, maxPotentialPayout, riskPolicy } = options;
+    if (maxPotentialPayout > bankroll) {
+        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,
+            })}`,
+        };
+    }
+    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) {
+        return {
+            ok: false,
+            error: `Wager (${formatCurrency(wager, {
+                displayUnitName: options.displayUnitName,
+                displayUnitScale: options.displayUnitScale,
+            })}) exceeds limit (${formatCurrency(limits.maxWager, {
+                displayUnitName: options.displayUnitName,
+                displayUnitScale: options.displayUnitScale,
+            })})`,
+        };
+    }
+    if (limits.maxPayout !== undefined && maxPotentialPayout > limits.maxPayout) {
+        return {
+            ok: false,
+            error: `Payout (${formatCurrency(maxPotentialPayout, {
+                displayUnitName: options.displayUnitName,
+                displayUnitScale: options.displayUnitScale,
+            })}) exceeds limit (${formatCurrency(limits.maxPayout, {
+                displayUnitName: options.displayUnitName,
+                displayUnitScale: options.displayUnitScale,
+            })})`,
+        };
+    }
+    return { ok: true, value: undefined };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.9.0-dev.10",
+  "version": "1.9.0-dev.12",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [