@moneypot/hub 1.16.0 → 1.16.2

package/dist/src/db/transaction.js

@@ -0,0 +1,93 @@
+import * as pg from "pg";
+import { logger } from "../logger.js";
+import { setTimeout } from "node:timers/promises";
+const PgClientInTransactionBrand = Symbol("PgClientInTransaction");
+const PG_ERROR_CODE = {
+    deadlock: "40P01",
+    serializationFailure: "40001",
+};
+const SIDECAR = new WeakMap();
+export function isInTransaction(pgClient) {
+    return SIDECAR.has(pgClient);
+}
+export function assertInTransaction(pgClient) {
+    if (!isInTransaction(pgClient)) {
+        throw new Error("Must be called inside a transaction");
+    }
+}
+export function getIsolationLevel(pgClient) {
+    return SIDECAR.get(pgClient) ?? null;
+}
+export const IsolationLevel = {
+    READ_COMMITTED: "READ COMMITTED",
+    REPEATABLE_READ: "REPEATABLE READ",
+    SERIALIZABLE: "SERIALIZABLE",
+};
+export async function withPgPoolTransaction(pool, callbackOrIsolationLevel, callbackOrRetryCount, retryCountOrMaxRetries = 0, maxRetries = 3) {
+    let callback;
+    let isolationLevel = IsolationLevel.SERIALIZABLE;
+    let retryCount = 0;
+    if (typeof callbackOrIsolationLevel === "function") {
+        callback = callbackOrIsolationLevel;
+        if (typeof callbackOrRetryCount === "number") {
+            retryCount = callbackOrRetryCount;
+            maxRetries = retryCountOrMaxRetries;
+        }
+    }
+    else {
+        isolationLevel = callbackOrIsolationLevel;
+        callback = callbackOrRetryCount;
+        retryCount = retryCountOrMaxRetries;
+    }
+    let pgClient = null;
+    try {
+        pgClient = await pool.connect();
+        if (isolationLevel === IsolationLevel.READ_COMMITTED) {
+            await pgClient.query("BEGIN");
+        }
+        else {
+            await pgClient.query(`BEGIN ISOLATION LEVEL ${isolationLevel}`);
+        }
+        SIDECAR.set(pgClient, isolationLevel);
+        assertInTransaction(pgClient);
+        const result = await callback(pgClient);
+        await pgClient.query("COMMIT");
+        return result;
+    }
+    catch (error) {
+        if (pgClient) {
+            try {
+                await pgClient.query("ROLLBACK");
+            }
+            catch (rollbackError) {
+                logger.error(error, "Original error");
+                logger.error(rollbackError, "Rollback failed");
+                SIDECAR.delete(pgClient);
+                pgClient.release(true);
+                pgClient = null;
+                throw error;
+            }
+            if (retryCount < maxRetries &&
+                error instanceof pg.DatabaseError &&
+                (error.code === PG_ERROR_CODE.deadlock ||
+                    error.code === PG_ERROR_CODE.serializationFailure)) {
+                const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
+                logger.warn(`Retrying transaction in ${Math.floor(backoffMs)}ms (attempt ${retryCount + 2}/${maxRetries + 1}) due to pg error code ${error.code}: ${error.message}`);
+                await setTimeout(backoffMs);
+                if (isolationLevel === IsolationLevel.READ_COMMITTED) {
+                    return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
+                }
+                else {
+                    return withPgPoolTransaction(pool, isolationLevel, callback, retryCount + 1, maxRetries);
+                }
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (pgClient) {
+            SIDECAR.delete(pgClient);
+            pgClient.release();
+        }
+    }
+}

package/dist/src/hash-chain/db-hash-chain.js

@@ -3,7 +3,6 @@ import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
 import { logger } from "../logger.js";
 export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
-    assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
     const hashChain = await pgClient
         .query(`
        SELECT * 
@@ -32,7 +31,6 @@ export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, ite
         metadata,
         digest: Buffer.from(digest).toString("base64"),
     }, "[dbInsertHubHash] Inserting hash");
-    assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
     if (kind === DbHashKind.INTERMEDIATE) {
         assert(typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
     }

package/dist/src/hash-chain/reveal-hash-chain.js

@@ -2,9 +2,7 @@ import { logger } from "../logger.js";
 import { getPreimageHash } from "./get-hash.js";
 import { DbHashKind } from "../db/types.js";
 import { dbInsertHubHash } from "../db/index.js";
-import { assert } from "tsafe";
 export async function dbRevealHashChain(pgClient, { hashChainId, }) {
-    assert(pgClient._inTransaction, "dbRevealHashChain must be called in a transaction");
     logger.debug({ hashChainId }, "Revealing hash chain");
     const preimageHashResult = await getPreimageHash({
         hashChainId,

package/dist/src/pg-advisory-lock.js

@@ -1,4 +1,3 @@
-import { assert } from "tsafe";
 var LockNamespace;
 (function (LockNamespace) {
     LockNamespace[LockNamespace["MP_TAKE_REQUEST"] = 1] = "MP_TAKE_REQUEST";
@@ -26,15 +25,12 @@ async function acquireAdvisoryLock(pgClient, namespace, hash) {
 }
 export const PgAdvisoryLock = {
     forMpTakeRequestProcessing: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.MP_TAKE_REQUEST, createHashKey(params.mpTakeRequestId, params.casinoId));
     },
     forNewHashChain: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.NEW_HASH_CHAIN, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatPlayerAction: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.CHAT_PLAYER_ACTION, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatModManagement: async (pgClient, params) => {

package/dist/src/plugins/chat/hub-chat-subscription.d.ts

@@ -8,7 +8,7 @@ declare const ChatPgNotifyPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"unmute">;
     user_id: z.ZodString;
-}, z.core.$strip>]>;
+}, z.core.$strip>], "type">;
 export type ChatPgNotifyPayload = z.infer<typeof ChatPgNotifyPayloadSchema>;
 export declare const HubChatSubscriptionPlugin: GraphileConfig.Plugin;
 export {};

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

@@ -9,7 +9,7 @@ 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";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { prettifyError } from "zod/v4";
 const BaseUrlSchema = z
     .string()

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

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as z from "zod/v4";
 import { DbOutcome } from "../db/index.js";
 import { Result } from "../util.js";
 import { RiskPolicy } from "../risk-policy.js";
@@ -7,53 +7,13 @@ declare const InputSchema: z.ZodObject<{
     clientSeed: z.ZodString;
     wager: z.ZodNumber;
     currency: z.ZodString;
-    outcomes: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+    outcomes: z.ZodArray<z.ZodObject<{
         weight: z.ZodNumber;
         profit: z.ZodNumber;
-    }, "strict", z.ZodTypeAny, {
-        profit: number;
-        weight: number;
-    }, {
-        profit: number;
-        weight: number;
-    }>, "many">, {
-        profit: number;
-        weight: number;
-    }[], {
-        profit: number;
-        weight: number;
-    }[]>, {
-        profit: number;
-        weight: number;
-    }[], {
-        profit: number;
-        weight: number;
-    }[]>;
+    }, z.core.$strict>>;
     hashChainId: z.ZodString;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strict", z.ZodTypeAny, {
-    currency: string;
-    hashChainId: string;
-    kind: string;
-    clientSeed: string;
-    outcomes: {
-        profit: number;
-        weight: number;
-    }[];
-    wager: number;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    currency: string;
-    hashChainId: string;
-    kind: string;
-    clientSeed: string;
-    outcomes: {
-        profit: number;
-        weight: number;
-    }[];
-    wager: number;
-    metadata?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strict>;
 type Input = z.infer<typeof InputSchema>;
 type Metadata = NonNullable<Input["metadata"]>;
 type FinalizeMetadataData = {

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

@@ -1,6 +1,6 @@
 import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
 import { gql, extendSchema } from "postgraphile/utils";
-import * as z from "zod";
+import * as z from "zod/v4";
 import { GraphQLError } from "graphql";
 import { DbHashKind, dbLockHouseBankroll, dbLockPlayerBalance, exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";

package/dist/src/plugins/hub-put-alert.js

@@ -1,9 +1,9 @@
 import { context, lambda } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { gql, extendSchema } from "postgraphile/utils";
 import { jsonParse } from "postgraphile/@dataplan/json";
 import { listenWithFilter } from "./listen-with-filter.js";
 import { logger } from "../logger.js";
-export const HubPutAlertPlugin = makeExtendSchemaPlugin(() => {
+export const HubPutAlertPlugin = extendSchema((_build) => {
     return {
         typeDefs: gql `
       extend type Subscription {

package/dist/src/plugins/listen-with-filter.d.ts

@@ -6,7 +6,7 @@ export declare class ListenWithFilterStep<TTopics extends {
 }, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput> extends Step<TTopics[TTopic][]> {
     itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep;
     filterFn: (item: unknown, filterInput: TFilterInput) => boolean;
-    static $$export: {
+    static $export: {
         moduleName: string;
         exportName: string;
     };
@@ -14,9 +14,10 @@ export declare class ListenWithFilterStep<TTopics extends {
     private pubsubDep;
     private topicDep;
     private filterInputDep;
-    constructor(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean);
+    private initialEventDep;
+    constructor(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean, $initialEvent?: Step<TTopics[TTopic]>);
     execute({ indexMap, values, stream, }: ExecutionDetails<readonly [GrafastSubscriber<TTopics>, TTopic]>): GrafastResultStreamList<TTopics[TTopic]>;
 }
 export declare function listenWithFilter<TTopics extends {
     [topic: string]: any;
-}, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput>(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean): ListenWithFilterStep<TTopics, TTopic, TPayloadStep, TFilterInput>;
+}, TTopic extends keyof TTopics, TPayloadStep extends Step, TFilterInput>(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan: ((itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep) | undefined, filterInputPlan: Step<TFilterInput>, filterFn: (item: unknown, filterInput: TFilterInput) => boolean, $initialEvent?: Step<TTopics[TTopic]>): ListenWithFilterStep<TTopics, TTopic, TPayloadStep, TFilterInput>;

package/dist/src/plugins/listen-with-filter.js

@@ -1,9 +1,9 @@
-import { constant, isDev, isExecutableStep, SafeError, } from "postgraphile/grafast";
+import { constant, isDev, isStep, SafeError, } from "postgraphile/grafast";
 import { Step } from "postgraphile/grafast";
 export class ListenWithFilterStep extends Step {
     itemPlan;
     filterFn;
-    static $$export = {
+    static $export = {
         moduleName: "grafast",
         exportName: "ListenWithFilterStep",
     };
@@ -11,17 +11,21 @@ export class ListenWithFilterStep extends Step {
     pubsubDep;
     topicDep;
     filterInputDep;
-    constructor(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn) {
+    initialEventDep = null;
+    constructor(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn, $initialEvent) {
         super();
         this.itemPlan = itemPlan;
         this.filterFn = filterFn;
         const $topic = typeof topicOrPlan === "string" ? constant(topicOrPlan) : topicOrPlan;
-        const $pubsub = isExecutableStep(pubsubOrPlan)
+        const $pubsub = isStep(pubsubOrPlan)
             ? pubsubOrPlan
             : constant(pubsubOrPlan, false);
         this.pubsubDep = this.addDependency($pubsub);
         this.topicDep = this.addDependency($topic);
         this.filterInputDep = this.addDependency(filterInputPlan);
+        if ($initialEvent) {
+            this.initialEventDep = this.addDependency($initialEvent);
+        }
     }
     execute({ indexMap, values, stream, }) {
         if (!stream) {
@@ -30,20 +34,22 @@ export class ListenWithFilterStep extends Step {
         const pubsubValue = values[this.pubsubDep];
         const topicValue = values[this.topicDep];
         const filterInputValue = values[this.filterInputDep];
+        const initialEventValue = this.initialEventDep !== null ? values[this.initialEventDep] : null;
         return indexMap((i) => {
             const pubsub = pubsubValue.at(i);
             if (!pubsub) {
                 throw new SafeError("Subscription not supported", isDev
                     ? {
-                        hint: `${this.dependencies[this.pubsubDep]} did not provide a GrafastSubscriber; perhaps you forgot to add the relevant property to context?`,
+                        hint: `Pubsub did not provide a GrafastSubscriber; perhaps you forgot to add the relevant property to context?`,
                     }
                     : {});
             }
             const topic = topicValue.at(i);
             const filterInput = filterInputValue.at(i);
             const origStream = pubsub.subscribe(topic);
+            const initialEvent = initialEventValue?.at(i);
             const filterFn = this.filterFn;
-            return {
+            const filteredStream = {
                 [Symbol.asyncIterator]: async function* () {
                     const iterator = await origStream;
                     for await (const item of iterator) {
@@ -53,9 +59,60 @@ export class ListenWithFilterStep extends Step {
                     }
                 },
             };
+            if (initialEvent === undefined) {
+                return filteredStream;
+            }
+            else {
+                if (filterFn(initialEvent, filterInput)) {
+                    return withInitialValue(initialEvent, filteredStream);
+                }
+                else {
+                    return filteredStream;
+                }
+            }
         });
     }
 }
-export function listenWithFilter(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn) {
-    return new ListenWithFilterStep(pubsubOrPlan, topicOrPlan, itemPlan, filterInputPlan, filterFn);
+export function listenWithFilter(pubsubOrPlan, topicOrPlan, itemPlan = ($item) => $item, filterInputPlan, filterFn, $initialEvent) {
+    return new ListenWithFilterStep(pubsubOrPlan, topicOrPlan, itemPlan, filterInputPlan, filterFn, $initialEvent);
 }
+const DONE = Object.freeze({ value: undefined, done: true });
+const withInitialValue = (initialVal, source) => ({
+    [Symbol.asyncIterator]() {
+        const sourceIterator = source[Symbol.asyncIterator]();
+        let first = true;
+        let done = null;
+        return {
+            async next() {
+                if (done)
+                    return done;
+                if (first) {
+                    first = false;
+                    return { value: initialVal, done: false };
+                }
+                const res = await sourceIterator.next();
+                if (res.done)
+                    done = res;
+                return res;
+            },
+            async return(value) {
+                done ??= { value: value, done: true };
+                if (typeof sourceIterator.return === "function") {
+                    try {
+                        await sourceIterator.return();
+                    }
+                    catch {
+                    }
+                }
+                return done;
+            },
+            async throw(err) {
+                done ??= DONE;
+                if (typeof sourceIterator.throw === "function") {
+                    return sourceIterator.throw(err);
+                }
+                throw err;
+            },
+        };
+    },
+});

package/dist/src/plugins/validate-fields.js

@@ -1,15 +1,16 @@
 import { sideEffect } from "postgraphile/grafast";
 import { GraphQLError } from "postgraphile/graphql";
-import { makeWrapPlansPlugin } from "postgraphile/utils";
-import * as v from "../validate.js";
-import * as Yup from "yup";
+import { wrapPlans } from "postgraphile/utils";
+import * as v from "../validate-zod.js";
+import z, { prettifyError } from "zod/v4";
 function validate(value, schema) {
     try {
-        schema.validateSync(value, { strict: true, abortEarly: true });
+        schema.parse(value);
     }
     catch (e) {
-        if (e instanceof Yup.ValidationError) {
-            const errorMessage = e.path ? `${e.path}: ${e.errors[0]}` : e.errors[0];
+        if (e instanceof z.ZodError) {
+            const fieldPath = e.issues.map((issue) => issue.path.join(".")).join(".");
+            const errorMessage = `Field "${fieldPath}": ${prettifyError(e)}`;
             throw new GraphQLError(errorMessage);
         }
         else {
@@ -17,45 +18,36 @@ function validate(value, schema) {
         }
     }
 }
-const casinoPatchSchema = Yup.object()
-    .shape({
-    name: Yup.string().trim().min(1),
-    graphqlUrl: v.graphqlUrl(),
+const CasinoPatchSchema = z.strictObject({
+    name: z.string().trim().min(1).optional(),
+    graphqlUrl: v.graphqlUrl().optional(),
+    baseUrl: v.baseUrl().optional(),
+});
+const AddCasinoSchema = z.strictObject({
+    name: z.string().trim().min(1),
     baseUrl: v.baseUrl(),
-})
-    .strict()
-    .noUnknown();
-const addCasinoSchema = Yup.object()
-    .shape({
-    name: Yup.string().trim().min(1).required(),
-    baseUrl: v.baseUrl().required(),
-    graphqlUrl: v.graphqlUrl().required(),
-    apiKey: v.uuid().required(),
-})
-    .strict()
-    .noUnknown();
-const updateBankrollSchema = Yup.object()
-    .shape({
-    amount: Yup.number().integer().min(0).required(),
-})
-    .strict()
-    .noUnknown();
-export const ValidateCasinoFieldsPlugin = makeWrapPlansPlugin({
+    graphqlUrl: v.graphqlUrl(),
+    apiKey: z.uuid(),
+});
+const UpdateBankrollSchema = z.strictObject({
+    amount: z.number().int().min(0),
+});
+export const ValidateCasinoFieldsPlugin = wrapPlans(() => ({
     Mutation: {
         updateHubCasinoById: (plan, $source, fieldArgs) => {
             const $patch = fieldArgs.getRaw(["input", "hubCasinoPatch"]);
-            sideEffect($patch, (patch) => validate(patch, casinoPatchSchema));
+            sideEffect($patch, (patch) => validate(patch, CasinoPatchSchema));
             return plan();
         },
         hubAddCasino: (plan, $source, fieldArgs) => {
             const $input = fieldArgs.getRaw(["input"]);
-            sideEffect($input, (input) => validate(input, addCasinoSchema));
+            sideEffect($input, (input) => validate(input, AddCasinoSchema));
             return plan();
         },
         updateHubBankrollById: (plan, $source, fieldArgs) => {
             const $patch = fieldArgs.getRaw(["input", "hubBankrollPatch"]);
-            sideEffect($patch, (patch) => validate(patch, updateBankrollSchema));
+            sideEffect($patch, (patch) => validate(patch, UpdateBankrollSchema));
             return plan();
         },
     },
-});
+}));

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

@@ -6,7 +6,7 @@ import { logger } from "../logger.js";
 import * as config from "../config.js";
 import * as db from "../db/index.js";
 import * as pg from "pg";
-import { z } from "zod";
+import { z } from "zod/v4";
 const activeCasinos = new Set();
 export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {

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

@@ -4,7 +4,6 @@ import { assert } from "tsafe";
 import { isUuid } from "../util.js";
 import { createGraphqlClient } from "../graphql-client.js";
 import { GET_CURRENCIES } from "../graphql-queries.js";
-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";
@@ -230,11 +229,6 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
     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.`);
             break;

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

@@ -107,6 +107,21 @@ 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" &&
+                        data.claimTransfer?.result.currentStatus ===
+                            TransferStatusKind.Completed) {
+                        logger.info(`Transfer ${transfer.id} already claimed (status: COMPLETED), skipping claim but attempting deposit insert`);
+                        await db.insertDeposit(pool, {
+                            casinoId,
+                            mpTransferId: transfer.id,
+                            userId: dbSender.id,
+                            experienceId: dbExperience.id,
+                            amount: transfer.amount,
+                            currency: currency.id,
+                        });
+                        return;
+                    }
                     throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
                 }
                 await db.insertDeposit(pool, {

package/dist/src/risk-policy.js

@@ -1,6 +1,6 @@
 import { formatCurrency } from "./format-currency.js";
 import { logger } from "./logger.js";
-import { z } from "zod";
+import { z } from "zod/v4";
 const RiskLimitsSchema = z
     .object({
     maxWager: z.number().positive().optional(),

package/dist/src/services/jwt-service.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 import * as jose from "jose";
 import { gql } from "../__generated__/gql.js";
 import { maybeOneRow } from "../db/util.js";

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

@@ -243,7 +243,6 @@ export async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest,
     });
 }
 async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     assert(mpTakeRequest.status === MpTakeRequestStatus.Pending);
     const { dbUser, dbExperience, dbCurrency, dbBalance } = await loadRequiredEntities(pgClient, {
         type: "mpId",
@@ -327,7 +326,6 @@ async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoI
     });
 }
 async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     switch (takeRequest.status) {
         case LocalTakeRequestStatus.PENDING:
             logger.info(`[processExistingTakeRequest] Take request ${takeRequest.id} in PENDING state`);
@@ -371,7 +369,6 @@ async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, gra
     return null;
 }
 async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExperienceId, mpUserId, amount, currencyKey, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         const transferResult = await graphqlClient.request(MP_TRANSFER_TAKE_REQUEST, {
             mpTakeRequestId,
@@ -592,20 +589,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             logger.warn({ mpTransferId, takeRequestId }, `[completeTransfer] Transfer was already refunded. This should never happen.`);
                             break;
                         }
-                        const dbBalanceAfterUpdate = await pgClient
+                        const dbLockedBalance = await pgClient
                             .query({
                             text: `
-                UPDATE hub.balance
-                SET amount = amount + $1
-                WHERE user_id = $2 
-                  AND experience_id = $3 
-                  AND casino_id = $4 
-                  AND currency_key = $5
-
-                RETURNING id, amount
+                SELECT id, amount
+                FROM hub.balance
+                WHERE user_id = $1
+                  AND experience_id = $2
+                  AND casino_id = $3
+                  AND currency_key = $4
+                FOR UPDATE
               `,
                             values: [
-                                takeRequestData.reserved_amount,
                                 takeRequestData.user_id,
                                 takeRequestData.experience_id,
                                 takeRequestData.casino_id,
@@ -613,10 +608,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             ],
                         })
                             .then(exactlyOneRow);
+                        await pgClient.query({
+                            text: `
+                UPDATE hub.balance
+                SET amount = amount + $1
+                WHERE id = $2
+              `,
+                            values: [takeRequestData.reserved_amount, dbLockedBalance.id],
+                        });
                         await insertAuditLog(pgClient, "player-balance", {
-                            balanceId: dbBalanceAfterUpdate.id,
-                            balanceOld: dbBalanceAfterUpdate.amount - takeRequestData.reserved_amount,
-                            balanceNew: dbBalanceAfterUpdate.amount,
+                            balanceId: dbLockedBalance.id,
+                            balanceOld: dbLockedBalance.amount,
+                            balanceNew: dbLockedBalance.amount + takeRequestData.reserved_amount,
                             balanceDelta: takeRequestData.reserved_amount,
                             action: "hub:take_request:refund",
                             refType: "hub.take_request",
@@ -740,7 +743,6 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool
 }
 async function loadRequiredEntities(pgClient, params) {
     const { type, currencyKey, casinoId } = params;
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     const dbCurrency = await pgClient
         .query({
         text: `
@@ -839,7 +841,6 @@ async function loadRequiredEntities(pgClient, params) {
     return { dbCurrency, dbUser, dbExperience, dbBalance };
 }
 async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, takeRequestId) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         logger.info(`[rejectMpTakeRequest] Rejecting take request ${mpTakeRequestId}`);
         const rejectResult = await graphqlClient.request(MP_REJECT_TAKE_REQUEST, {
@@ -916,7 +917,6 @@ async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, tak
     }
 }
 async function updateTakeRequestStatus(pgClient, takeRequestId, status) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     return pgClient.query({
         text: `
       UPDATE hub.take_request

package/dist/src/validate-zod.d.ts

@@ -0,0 +1,3 @@
+import z from "zod/v4";
+export declare const baseUrl: () => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<URL, string>>, z.ZodTransform<string, URL>>;
+export declare const graphqlUrl: () => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<URL, string>>, z.ZodTransform<string, URL>>;