@moneypot/hub 1.9.0-dev.9 → 1.10.0-dev.1

package/dist/src/plugins/hub-authenticate.js

@@ -5,7 +5,7 @@ import { GET_USER_FROM_USER_TOKEN } from "../graphql-queries.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { createGraphqlClient } from "../graphql-client.js";
 import { constant, context, error, object, sideEffect, } from "postgraphile/grafast";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction, } from "../db/index.js";
 import { logger } from "../logger.js";
 import * as jwtService from "../services/jwt-service.js";
 import { extractGraphQLErrorInfo, isGraphQLError } from "../GraphQLError.js";
@@ -51,7 +51,8 @@ export const HubAuthenticatePlugin = makeExtendSchemaPlugin(() => {
                     hubAuthenticate(_, { $input }) {
                         try {
                             const $context = context();
-                            const $success = sideEffect([$input, $context], ([rawInput, context]) => {
+                            const $superuserPool = $context.get("superuserPool");
+                            const $success = sideEffect([$input, $superuserPool, $context], ([rawInput, superuserPool, context]) => {
                                 return withPgPoolTransaction(superuserPool, async (pgClient) => {
                                     let input;
                                     try {

package/dist/src/plugins/hub-claim-faucet.js

@@ -1,6 +1,6 @@
 import { object } from "grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction, } from "../db/index.js";
 import { constant, context, sideEffect } from "postgraphile/grafast";
 import { assert } from "tsafe";
 const CLAIM_AMOUNT = 1000;
@@ -20,8 +20,10 @@ export const HubClaimFaucetPlugin = makeExtendSchemaPlugin(() => {
             Mutation: {
                 plans: {
                     hubClaimFaucet() {
-                        const $identity = context().get("identity");
-                        const $result = sideEffect([$identity], ([identity]) => {
+                        const $context = context();
+                        const $identity = $context.get("identity");
+                        const $superuserPool = $context.get("superuserPool");
+                        const $result = sideEffect([$identity, $superuserPool], ([identity, superuserPool]) => {
                             if (identity?.kind !== "user") {
                                 throw new Error("Must be logged in as user");
                             }

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

@@ -2,13 +2,13 @@ import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/g
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import * as z from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { DbHashKind, dbLockPlayerBalanceAndHouseBankroll, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
 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().int().positive().optional(),
-    maxPayout: z.number().int().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);
@@ -115,7 +106,8 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                     plans: {
                         hubMakeOutcomeBet: (_, { $input }) => {
                             const $identity = context().get("identity");
-                            const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                            const $superuserPool = context().get("superuserPool");
+                            const $result = sideEffect([$identity, $superuserPool, $input], async ([identity, superuserPool, rawInput]) => {
                                 if (identity?.kind !== "user") {
                                     throw new GraphQLError("Unauthorized");
                                 }
@@ -196,47 +188,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,
@@ -254,6 +218,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         if (dbHashChain.current_iteration === 1) {
                                             finishHashChainInBackground({
                                                 hashChainId: input.hashChainId,
+                                                pool: superuserPool,
                                             }).catch((e) => {
                                                 logger.error({ hashChainId: input.hashChainId, error: e }, "Error finishing hash chain in background");
                                             });
@@ -440,7 +405,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-async function finishHashChainInBackground({ hashChainId, }) {
+async function finishHashChainInBackground({ hashChainId, pool, }) {
     logger.debug({ hashChainId }, "Finishing hash chain in background");
     const preimageHashResult = await getPreimageHash({
         hashChainId,
@@ -453,7 +418,7 @@ async function finishHashChainInBackground({ hashChainId, }) {
             digest: preimageHashResult.hash,
             iteration: 0,
         }, "Inserting preimage hash");
-        await withPgPoolTransaction(superuserPool, async (pgClient) => {
+        await withPgPoolTransaction(pool, async (pgClient) => {
             await dbInsertHubHash(pgClient, {
                 hashChainId,
                 kind: DbHashKind.PREIMAGE,

package/dist/src/plugins/hub-withdraw.js

@@ -1,6 +1,6 @@
 import { constant, context, object, sideEffect } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { withPgPoolTransaction } from "../db/index.js";
 import { exactlyOneRow, maybeOneRow } from "../db/util.js";
 import { GraphQLError } from "graphql";
 export const HubWithdrawPlugin = makeExtendSchemaPlugin((build) => {
@@ -26,7 +26,8 @@ export const HubWithdrawPlugin = makeExtendSchemaPlugin((build) => {
                 plans: {
                     hubWithdraw(_, { $input }) {
                         const $identity = context().get("identity");
-                        const $withdrawalRequestId = sideEffect([$input, $identity], ([input, identity]) => {
+                        const $superuserPool = context().get("superuserPool");
+                        const $withdrawalRequestId = sideEffect([$input, $identity, $superuserPool], ([input, identity, superuserPool]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("You must be logged in");
                             }

package/dist/src/process-transfers/index.d.ts

@@ -1,9 +1,12 @@
 import { DbCasino, DbCasinoSecret } from "../db/index.js";
+import * as pg from "pg";
 export type CasinoWithSecret = DbCasino & DbCasinoSecret;
-export declare function startCasinoTransferProcessor({ casinoId, signal, }: {
+export declare function startCasinoTransferProcessor({ casinoId, signal, pool, }: {
     casinoId: string;
     signal: AbortSignal;
+    pool: pg.Pool;
 }): Promise<void>;
-export declare function initializeTransferProcessors({ signal, }: {
+export declare function initializeTransferProcessors({ signal, pool, }: {
     signal: AbortSignal;
+    pool: pg.Pool;
 }): void;

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

@@ -1,6 +1,5 @@
 import { startPollingProcessor } from "./polling-processor.js";
 import { startWebsocketProcessor } from "./websocket-processor.js";
-import { superuserPool } from "../db/index.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "../db/internal.js";
 import assert from "assert";
 import { logger } from "../logger.js";
@@ -9,28 +8,29 @@ import * as db from "../db/index.js";
 import * as pg from "pg";
 import { z } from "zod";
 const activeCasinos = new Set();
-export async function startCasinoTransferProcessor({ casinoId, signal, }) {
+export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {
         throw new Error(`processor already running for casino ${casinoId}`);
     }
-    const casino = await dbGetCasinoById(superuserPool, casinoId);
-    const secret = await dbGetCasinoSecretById(superuserPool, casinoId);
+    const casino = await dbGetCasinoById(pool, casinoId);
+    const secret = await dbGetCasinoSecretById(pool, casinoId);
     assert(casino, `Casino not found for casino id ${casinoId}`);
     assert(secret, `Secret not found for casino id ${casinoId}`);
     activeCasinos.add(casinoId);
-    startPollingProcessor({ casinoId, signal });
+    startPollingProcessor({ casinoId, signal, pool });
     startWebsocketProcessor({
         casinoId,
         graphqlUrl: casino.graphql_url,
         signal,
         controllerId: secret.controller_id,
         apiKey: secret.api_key,
+        pool,
     });
 }
-export function initializeTransferProcessors({ signal, }) {
+export function initializeTransferProcessors({ signal, pool, }) {
     (async () => {
         try {
-            const casinos = await db.listCasinos(superuserPool);
+            const casinos = await db.listCasinos(pool);
             for (const casino of casinos) {
                 if (!URL.canParse(casino.graphql_url)) {
                     logger.warn(`Skipping casino ${casino.id} due to invalid graphql_url: "${casino.graphql_url}"`);
@@ -41,16 +41,16 @@ export function initializeTransferProcessors({ signal, }) {
                     logger.warn(`${casino.id} has localhost endpoint "${casino.graphql_url}" while NODE_ENV=production.`);
                 }
                 logger.info(`Starting casino processor for "${casino.name}" at "${casino.graphql_url}"`);
-                startCasinoTransferProcessor({ casinoId: casino.id, signal });
+                startCasinoTransferProcessor({ casinoId: casino.id, signal, pool });
             }
-            await listenForNewCasinos({ signal });
+            await listenForNewCasinos({ signal, pool });
         }
         catch (e) {
             logger.error(e, `Error initializing transfer processors`);
         }
     })();
 }
-async function listenForNewCasinos({ signal }) {
+async function listenForNewCasinos({ signal, pool, }) {
     const pgClient = new pg.Client(config.SUPERUSER_DATABASE_URL);
     await pgClient.connect();
     const NewCasinoPayload = z.object({
@@ -76,7 +76,11 @@ async function listenForNewCasinos({ signal }) {
                     logger.error(result.error, "Error parsing new casino notification");
                     return;
                 }
-                startCasinoTransferProcessor({ casinoId: result.data.id, signal });
+                startCasinoTransferProcessor({
+                    casinoId: result.data.id,
+                    signal,
+                    pool,
+                });
                 break;
             }
         }

package/dist/src/process-transfers/polling-processor.d.ts

@@ -1,10 +1,12 @@
 import * as db from "../db/index.js";
+import * as pg from "pg";
 export declare const PAGINATE_TRANSFERS: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../__generated__/graphql.js").PaginateTransfersQuery, import("../__generated__/graphql.js").Exact<{
     controllerId: import("../__generated__/graphql.js").Scalars["UUID"]["input"];
     after?: import("../__generated__/graphql.js").InputMaybe<import("../__generated__/graphql.js").Scalars["Cursor"]["input"]>;
     limit?: import("../__generated__/graphql.js").InputMaybe<import("../__generated__/graphql.js").Scalars["Int"]["input"]>;
 }>>;
-export declare function startPollingProcessor({ casinoId, signal, }: {
+export declare function startPollingProcessor({ casinoId, signal, pool, }: {
     casinoId: db.DbCasino["id"];
     signal: AbortSignal;
+    pool: pg.Pool;
 }): void;

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

@@ -8,7 +8,6 @@ import { processWithdrawalRequests } from "../process-withdrawal-request.js";
 import { processTakeRequests } from "../take-request/process-take-request.js";
 import * as jwtService from "../services/jwt-service.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "../db/internal.js";
-import { superuserPool } from "../db/index.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
 import { MP_COMPLETE_TRANSFER, processTransfer } from "./process-transfer.js";
 import { gql } from "../__generated__/gql.js";
@@ -44,7 +43,7 @@ export const PAGINATE_TRANSFERS = gql(`
 `);
 const MIN_BACKOFF_TIME = 5000;
 const MAX_BACKOFF_TIME = 30 * 1000;
-export function startPollingProcessor({ casinoId, signal, }) {
+export function startPollingProcessor({ casinoId, signal, pool, }) {
     if (signal.aborted) {
         logger.info(`[startTransferProcessor] AbortSignal aborted. Not starting processor for casino ${casinoId}`);
         return;
@@ -55,7 +54,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
         lastAttempt: 0,
     };
     (async () => {
-        let cursor = await db.getTransferCursor(superuserPool, {
+        let cursor = await db.getTransferCursor(pool, {
             casinoId,
         });
         if (cursor && !isUuid(cursor)) {
@@ -80,13 +79,13 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     await new Promise((resolve) => setTimeout(resolve, timeToWait));
                 }
                 processorState.lastAttempt = Date.now();
-                const casino = await dbGetCasinoById(superuserPool, casinoId);
+                const casino = await dbGetCasinoById(pool, casinoId);
                 if (!casino) {
                     logger.warn(`casino ${casinoId} not found. Stopping processor...`);
                     shouldStop = true;
                     break;
                 }
-                const casinoSecret = await dbGetCasinoSecretById(superuserPool, casino.id);
+                const casinoSecret = await dbGetCasinoSecretById(pool, casino.id);
                 if (!casinoSecret) {
                     logger.warn(`Casino secret hasn't been set for casino ${casinoId}. Skipping...`);
                     continue;
@@ -99,7 +98,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (1)`);
                     break;
                 }
-                await jwtService.refreshCasinoJwksTask(superuserPool, {
+                await jwtService.refreshCasinoJwksTask(pool, {
                     casinoId: casino.id,
                     graphqlClient,
                 });
@@ -114,7 +113,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                         return (res.allCurrencies?.nodes || []).flatMap((x) => x ? [x] : []);
                     });
                     if (currencies.length > 0) {
-                        await db.upsertCurrencies(superuserPool, {
+                        await db.upsertCurrencies(pool, {
                             casinoId: casino.id,
                             currencies,
                         });
@@ -130,6 +129,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     graphqlClient,
                     casinoInfo: { ...casino, ...casinoSecret },
                     signal,
+                    pool,
                 });
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (4)`);
@@ -139,6 +139,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     abortSignal: signal,
                     casinoId: casino.id,
                     graphqlClient,
+                    pool,
                 });
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (5)`);
@@ -149,6 +150,7 @@ export function startPollingProcessor({ casinoId, signal, }) {
                     controllerId: casinoSecret.controller_id,
                     casinoId: casino.id,
                     graphqlClient,
+                    pool,
                 });
                 processorState.backoffTime = MIN_BACKOFF_TIME;
             }
@@ -161,11 +163,11 @@ export function startPollingProcessor({ casinoId, signal, }) {
         logger.info(`processor stopped for casino ${casinoId}`);
     })();
 }
-async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
+async function processWithdrawals({ abortSignal, casinoId, graphqlClient, pool, }) {
     if (abortSignal.aborted) {
         return;
     }
-    const withdrawals = await db.getPendingWithdrawals(superuserPool, {
+    const withdrawals = await db.getPendingWithdrawals(pool, {
         casinoId,
         limit: 10,
     });
@@ -185,7 +187,7 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
             case undefined:
                 break;
             case "CompleteTransferSuccess": {
-                await db.settleWithdrawal({
+                await db.settleWithdrawal(pool, {
                     withdrawalId: withdrawal.id,
                     newStatus: "COMPLETED",
                 });
@@ -198,7 +200,7 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
                 switch (currentState) {
                     case TransferStatusKind.Canceled:
                     case TransferStatusKind.Completed:
-                        await db.settleWithdrawal({
+                        await db.settleWithdrawal(pool, {
                             withdrawalId: withdrawal.id,
                             newStatus: currentState,
                         });
@@ -224,13 +226,14 @@ async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
         }
     }
 }
-async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, }) {
+async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, pool, }) {
     let hasNextPage = true;
     const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
     while (hasNextPage && !signal.aborted) {
         await processWithdrawalRequests({
             casinoId: casinoInfo.id,
             graphqlClient,
+            pool,
         });
         if (signal.aborted) {
             logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
@@ -266,8 +269,9 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
                 controllerId: casinoInfo.controller_id,
                 transfer,
                 graphqlClient,
+                pool,
             });
-            await db.setTransferCursor(superuserPool, {
+            await db.setTransferCursor(pool, {
                 cursor,
                 casinoId: casinoInfo.id,
             });

package/dist/src/process-transfers/process-transfer.d.ts

@@ -1,13 +1,15 @@
 import { TransferFieldsFragment } from "../__generated__/graphql.js";
 import { GraphQLClient } from "graphql-request";
+import * as pg from "pg";
 export declare const MP_COMPLETE_TRANSFER: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../__generated__/graphql.js").CompleteTransferMutation, import("../__generated__/graphql.js").Exact<{
     mpTransferId: import("../__generated__/graphql.js").Scalars["UUID"]["input"];
 }>>;
-export declare function processTransfer({ casinoId, controllerId, transfer, graphqlClient, }: {
+export declare function processTransfer({ casinoId, controllerId, transfer, graphqlClient, pool, }: {
     casinoId: string;
     controllerId: string;
     transfer: Extract<TransferFieldsFragment, {
         __typename: "ExperienceTransfer";
     }>;
     graphqlClient: GraphQLClient;
+    pool: pg.Pool;
 }): Promise<void>;

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

@@ -1,6 +1,5 @@
 import * as db from "../db/index.js";
 import { TransferStatusKind, } from "../__generated__/graphql.js";
-import { superuserPool } from "../db/index.js";
 import { gql } from "../__generated__/gql.js";
 import { logger } from "../logger.js";
 import { assert } from "tsafe";
@@ -50,7 +49,7 @@ const MP_CLAIM_TRANSFER = gql(`
     }
   }
 `);
-export async function processTransfer({ casinoId, controllerId, transfer, graphqlClient, }) {
+export async function processTransfer({ casinoId, controllerId, transfer, graphqlClient, pool, }) {
     assert(transfer, "Expected transfer");
     assert(transfer.__typename === "ExperienceTransfer", `Expected ExperienceTransfer but got ${transfer.__typename}`);
     logger.debug(`processing transfer ${transfer.id} for casino ${casinoId}...`);
@@ -62,17 +61,17 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
         : transfer.holderByToHolderId;
     assert(user?.__typename === "User", "Expected user transfer participant");
     const currency = transfer.currencyByCurrency;
-    const dbSender = await db.upsertUser(superuserPool, {
+    const dbSender = await db.upsertUser(pool, {
         casinoId,
         mpUserId: user.id,
         uname: user.uname,
     });
-    const dbExperience = await db.upsertExperience(superuserPool, {
+    const dbExperience = await db.upsertExperience(pool, {
         casinoId,
         mpExperienceId: transfer.experienceByExperienceId.id,
         name: transfer.experienceByExperienceId.name,
     });
-    await db.upsertCurrencies(superuserPool, {
+    await db.upsertCurrencies(pool, {
         casinoId,
         currencies: [currency],
     });
@@ -85,7 +84,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
             case TransferStatusKind.Expired:
                 return;
             case TransferStatusKind.Completed: {
-                await db.insertDeposit({
+                await db.insertDeposit(pool, {
                     casinoId,
                     mpTransferId: transfer.id,
                     userId: dbSender.id,
@@ -110,7 +109,7 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
                 if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
                     throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
                 }
-                await db.insertDeposit({
+                await db.insertDeposit(pool, {
                     casinoId,
                     mpTransferId: transfer.id,
                     userId: dbSender.id,
@@ -130,7 +129,7 @@ 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({
+                await db.settleWithdrawal(pool, {
                     withdrawalId: transfer.id,
                     newStatus: "CANCELED",
                 });

package/dist/src/process-transfers/websocket-processor.d.ts

@@ -1,7 +1,9 @@
-export declare function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }: {
+import * as pg from "pg";
+export declare function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, pool, }: {
     casinoId: string;
     graphqlUrl: string;
     signal: AbortSignal;
     controllerId: string;
     apiKey: string;
+    pool: pg.Pool;
 }): void;

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

@@ -49,7 +49,7 @@ async function mpGetExperienceTransfer(graphqlClient, id) {
     const mpTransfer = useFragment(TRANSFER_FIELDS, x);
     return mpTransfer;
 }
-export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }) {
+export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, pool, }) {
     logger.info(`Starting websocket processor for ${graphqlUrl} using apiKey ${apiKey}`);
     const client = createWebsocketClient({
         url: httpToWs(new URL(graphqlUrl)).toString(),
@@ -89,6 +89,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             controllerId,
             transfer: mpTransfer,
             graphqlClient,
+            pool,
         });
     });
     const dispose2 = createSubscription(client, MP_NEW_TAKE_REQUEST, async (result) => {
@@ -107,6 +108,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             mpTakeRequest,
             casinoId,
             graphqlClient,
+            pool,
         });
     });
     signal.addEventListener("abort", () => {

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

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

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

@@ -1,11 +1,11 @@
 import { assert } from "tsafe";
 import { TransferStatusKind } from "./__generated__/graphql.js";
-import { withPgPoolTransaction, superuserPool } from "./db/index.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, }) {
-    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+async function processWithdrawalRequest({ requestId, graphqlClient, pool, }) {
+    return withPgPoolTransaction(pool, async (pgClient) => {
         const dbWithdrawalRequest = await pgClient
             .query({
             text: `
@@ -120,8 +120,8 @@ async function processWithdrawalRequest({ requestId, graphqlClient, }) {
         });
     });
 }
-export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
-    const pendingRequests = await superuserPool.query({
+export async function processWithdrawalRequests({ casinoId, graphqlClient, pool, }) {
+    const pendingRequests = await pool.query({
         text: `
       SELECT wr.* 
       FROM hub.withdrawal_request wr
@@ -136,6 +136,7 @@ export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
             await processWithdrawalRequest({
                 requestId: request.id,
                 graphqlClient,
+                pool,
             });
         }
         catch (error) {

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

@@ -0,0 +1,20 @@
+import { DbOutcome } from "./db/types.js";
+import { Result } from "./util.js";
+export type RiskPolicyArgs = {
+    currency: string;
+    wager: number;
+    bankroll: number;
+    maxPotentialPayout: number;
+    outcomes: DbOutcome[];
+};
+export type RiskLimits = {
+    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>;