@moneypot/hub 1.9.0-dev.1 → 1.9.0-dev.11

package/dist/src/db/index.js

@@ -132,7 +132,7 @@ export async function getTransferCursor(pgClient, { casinoId, }) {
     return row?.cursor;
 }
 export async function setTransferCursor(pgClient, { cursor, casinoId, }) {
-    logger.debug(cursor, `[setTransferCursor] Setting cursor`);
+    logger.debug({ cursor }, `[setTransferCursor] Setting cursor`);
     await pgClient.query(`
     insert into hub_hidden.transfer_cursor (casino_id, cursor)
     values ($1, $2)

package/dist/src/format-currency.d.ts

@@ -0,0 +1,9 @@
+export declare function formatCurrency(amount: number, currency: {
+    displayUnitScale: number;
+    displayUnitName: string;
+}, options?: {
+    excludeUnit?: boolean;
+}): string;
+export declare function pluralize(word: string, count: number, suffix?: string): string;
+export declare function getDecimalPlaces(displayUnitScale: number): number;
+export declare function truncateDecimalPrecision(value: number, decimals: number): number;

package/dist/src/format-currency.js

@@ -0,0 +1,40 @@
+export function formatCurrency(amount, currency, options = {
+    excludeUnit: false,
+}) {
+    const decimalPlaces = getDecimalPlaces(currency.displayUnitScale);
+    const scaledAmount = amount / (currency.displayUnitScale || 1);
+    const truncatedAmount = truncateDecimalPrecision(scaledAmount, decimalPlaces);
+    const formatter = new Intl.NumberFormat("en-US", {
+        minimumFractionDigits: decimalPlaces,
+        maximumFractionDigits: decimalPlaces,
+        useGrouping: true,
+    });
+    const formatted = formatter.format(truncatedAmount);
+    if (options.excludeUnit) {
+        return formatted;
+    }
+    return `${formatted} ${pluralize(currency.displayUnitName, truncatedAmount)}`;
+}
+export function pluralize(word, count, suffix = "s") {
+    return count === 1 ? word : word + suffix;
+}
+export function getDecimalPlaces(displayUnitScale) {
+    return displayUnitScale < 10 ? 0 : Math.log10(displayUnitScale);
+}
+export function truncateDecimalPrecision(value, decimals) {
+    if (decimals < 0) {
+        throw new Error("Decimals must be a non-negative integer");
+    }
+    if (!Number.isFinite(value)) {
+        return value;
+    }
+    const str = value.toString();
+    const dotIndex = str.indexOf(".");
+    if (dotIndex === -1) {
+        return value;
+    }
+    const truncatedStr = decimals === 0
+        ? str.substring(0, dotIndex)
+        : str.substring(0, dotIndex + decimals + 1);
+    return parseFloat(truncatedStr);
+}

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) {
@@ -22,7 +23,7 @@ async function initialize(options) {
         });
     }
     catch (e) {
-        logger.error("Error upgrading core schema", e);
+        logger.error(e, "Error upgrading core schema");
         if (e instanceof DatabaseAheadError) {
             logger.error(`${"⚠️".repeat(10)}\n@moneypot/hub database was reset to prepare for a production release and you must reset your database to continue. Please see <https://www.npmjs.com/package/@moneypot/hub#change-log> for more info.`);
             process.exit(1);

package/dist/src/logger.d.ts

@@ -1,3 +1,3 @@
-import { type Logger } from "pino";
+import pino, { type Logger } from "pino";
 export { type Logger };
-export declare const logger: Logger;
+export declare const logger: pino.Logger;

package/dist/src/logger.js

@@ -1,4 +1,4 @@
-import { pino } from "pino";
+import pino from "pino";
 import { LOG_LEVEL, LOG_PRETTY, NODE_ENV } from "./config.js";
 function createLogger(options) {
     const prettify = LOG_PRETTY === undefined ? NODE_ENV !== "production" : LOG_PRETTY;

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

@@ -1,6 +1,7 @@
-import { z } from "zod";
+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,15 +76,6 @@ export type OutcomeBetConfig = {
 export type OutcomeBetConfigMap<BetKind extends string> = {
     [betKind in BetKind]: OutcomeBetConfig;
 };
-export type RiskLimits = {
-    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

@@ -1,6 +1,6 @@
 import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { z } from "zod";
+import * as z from "zod";
 import { GraphQLError } from "graphql";
 import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
@@ -8,6 +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 { validateRisk } from "../risk-policy.js";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -64,10 +65,6 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .function()
         .optional(),
 }));
-const RiskLimitsSchema = z.object({
-    maxWager: z.number().finite().int().positive(),
-    maxPayout: z.number().finite().int().positive(),
-});
 export function MakeOutcomeBetPlugin({ betConfigs }) {
     BetConfigsSchema.parse(betConfigs);
     const betKinds = Object.keys(betConfigs);
@@ -154,7 +151,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 const dbCurrency = await superuserPool
                                     .query({
                                     text: `
-                  SELECT key
+                  SELECT key, display_unit_name, display_unit_scale
                   FROM hub.currency
                   WHERE key = $1
                     AND casino_id = $2
@@ -190,28 +187,18 @@ 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 (${maxPayout}). Bankroll: ${dbHouseBankroll.amount}`);
-                                    }
-                                    const riskLimitsResult = RiskLimitsSchema.safeParse(betConfig.riskPolicy
-                                        ? betConfig.riskPolicy({
-                                            currency: input.currency,
-                                            wager: input.wager,
-                                            bankroll: dbHouseBankroll.amount,
-                                        })
-                                        : {});
-                                    if (!riskLimitsResult.success) {
-                                        throw new GraphQLError(`Invalid risk policy: ${riskLimitsResult.error.issues[0].message}`);
-                                    }
-                                    const riskLimits = riskLimitsResult.data;
-                                    if (riskLimits.maxWager != null &&
-                                        input.wager > riskLimits.maxWager) {
-                                        throw new GraphQLError(`Wager exceeds limit (${riskLimits.maxWager}). Your wager: ${input.wager}`);
-                                    }
-                                    if (riskLimits.maxPayout != null &&
-                                        maxPayout > riskLimits.maxPayout) {
-                                        throw new GraphQLError(`Payout exceeds limit (${riskLimits.maxPayout}). Your payout: ${maxPayout}`);
+                                    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,
+                                    });
+                                    if (!riskResult.ok) {
+                                        throw new GraphQLError(riskResult.error);
                                     }
                                     const dbHashChain = await dbLockHubHashChain(pgClient, {
                                         userId: session.user_id,

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

@@ -46,7 +46,7 @@ export function initializeTransferProcessors({ signal, }) {
             await listenForNewCasinos({ signal });
         }
         catch (e) {
-            logger.error(`Error initializing transfer processors:`, e);
+            logger.error(e, `Error initializing transfer processors`);
         }
     })();
 }

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

@@ -139,7 +139,7 @@ export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
             });
         }
         catch (error) {
-            logger.error(`Failed to process withdrawal request ${request.id}:`, error);
+            logger.error(error, `Failed to process withdrawal request ${request.id}`);
         }
     }
 }

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

@@ -0,0 +1,20 @@
+import { Result } from "./util.js";
+export type RiskPolicyArgs = {
+    currency: string;
+    wager: number;
+    bankroll: number;
+    maxPotentialPayout: number;
+};
+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.1",
+  "version": "1.9.0-dev.11",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [