@moneypot/hub 1.20.6 → 1.21.0

package/dist/dashboard/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Dashboard</title>
-    <script type="module" crossorigin src="/dashboard/assets/index-0G7cFk_0.js"></script>
+    <script type="module" crossorigin src="/dashboard/assets/index-n_xD3-qc.js"></script>
     <link rel="stylesheet" crossorigin href="/dashboard/assets/index-Bl5lLFHa.css">
   </head>
   <body>

package/dist/src/audit-log.d.ts

@@ -1,7 +1,7 @@
 import { DbPlayerBalance, DbHouseBankroll } from "./db/types.js";
 import { QueryExecutor } from "./db/util.js";
 export type AuditLogType = "player-balance" | "house-bankroll" | "both";
-export type HubAuditAction = "hub:init" | "hub:deposit" | "hub:take_request:pending" | "hub:take_request:refund" | "hub:outcome_bet";
+export type HubAuditAction = "hub:init" | "hub:deposit" | "hub:take_request:pending" | "hub:take_request:refund" | "hub:outcome_bet" | "hub:bankroll:adjust";
 export type HubAuditRefType = "hub.deposit" | "hub.outcome_bet" | "hub.take_request";
 export type AuditAction = HubAuditAction | (string & {});
 export type AuditRefType = HubAuditRefType | (string & {});

package/dist/src/pg-versions/018-scope-chat-owner-reads.sql

@@ -0,0 +1,49 @@
+
+drop policy select_chat_message on hub.chat_message;
+create policy select_chat_message on hub.chat_message for select using (
+  hub_hidden.is_operator()
+
+  or (
+    hidden_at is null
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+
+  or (
+    hub_hidden.is_experience_owner()
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+);
+
+drop policy select_chat_mute on hub.chat_mute;
+create policy select_chat_mute on hub.chat_mute for select using (
+  hub_hidden.is_operator()
+
+  or hub_hidden.current_user_id() = hub.chat_mute.user_id
+
+  or (
+    hub_hidden.is_experience_owner()
+    and hub.chat_mute.experience_id = hub_hidden.current_experience_id()
+    and hub.chat_mute.casino_id = hub_hidden.current_casino_id()
+  )
+
+  or exists (
+    select 1
+    from hub.chat_mod
+    where user_id = hub_hidden.current_user_id()
+      and casino_id = hub.chat_mute.casino_id
+      and experience_id = hub.chat_mute.experience_id
+  )
+);
+
+drop policy select_chat_mod on hub.chat_mod;
+create policy select_chat_mod on hub.chat_mod for select using (
+  hub_hidden.is_operator()
+
+  or (
+    hub_hidden.is_experience_owner()
+    and experience_id = hub_hidden.current_experience_id()
+    and casino_id = hub_hidden.current_casino_id()
+  )
+);

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

@@ -2,7 +2,7 @@ import { GraphQLError } from "graphql";
 import { context, object, sideEffect } from "postgraphile/grafast";
 import { extendSchema, gql } from "postgraphile/utils";
 import z from "zod/v4";
-import { extractFirstZodErrorMessage } from "../../util.js";
+import { extractFirstZodErrorMessage, uuidEqual } from "../../util.js";
 import { exactlyOneRow, maybeOneRow, withPgPoolTransaction, } from "../../db/index.js";
 const InputSchema = z.object({
     clientId: z.uuid("Invalid client ID"),
@@ -69,6 +69,10 @@ export const HubChatCreateSystemMessagePlugin = extendSchema((build) => {
                             if (!dbExperience) {
                                 throw new GraphQLError("Experience not found");
                             }
+                            if (identity.kind === "user" &&
+                                !uuidEqual(identity.session.experience_id, dbExperience.id)) {
+                                throw new GraphQLError("Your session does not match the experienceId");
+                            }
                             return await withPgPoolTransaction(superuserPool, async (pgClient) => {
                                 const dbChatMessage = await pgClient
                                     .query({

package/dist/src/plugins/chat/hub-chat-mod-management.js

@@ -85,9 +85,9 @@ export const HubChatModManagementPlugin = extendSchema((build) => {
                                 text: `
                     SELECT id
                     FROM hub.user
-                    WHERE id = $1 AND experience_id = $2
+                    WHERE id = $1 AND casino_id = $2
                   `,
-                                values: [input.userId, input.experienceId],
+                                values: [input.userId, dbTargetExperience.casino_id],
                             })
                                 .then(maybeOneRow);
                             if (!dbTargetUser) {
@@ -167,9 +167,9 @@ export const HubChatModManagementPlugin = extendSchema((build) => {
                                 text: `
                     SELECT id
                     FROM hub.user
-                    WHERE id = $1 AND experience_id = $2
+                    WHERE id = $1 AND casino_id = $2
                   `,
-                                values: [input.userId, input.experienceId],
+                                values: [input.userId, dbTargetExperience.casino_id],
                             })
                                 .then(maybeOneRow);
                             if (!dbTargetUser) {

package/dist/src/plugins/hub-add-casino.js

@@ -56,8 +56,8 @@ export const HubAddCasinoPlugin = makeExtendSchemaPlugin((build) => {
                                     throw new GraphQLError("Unauthorized");
                                 }
                                 assert(is(input));
-                                logger.info(input, "Input");
                                 const { name, baseUrl, graphqlUrl, apiKey } = input;
+                                logger.info({ name, baseUrl, graphqlUrl }, "Input");
                                 const graphqlClient = new GraphQLClient(graphqlUrl, {
                                     headers: {
                                         Authorization: `apikey:${apiKey}`,

package/dist/src/plugins/hub-adjust-bankroll.d.ts

@@ -0,0 +1 @@
+export declare const HubAdjustBankrollPlugin: GraphileConfig.Plugin;

package/dist/src/plugins/hub-adjust-bankroll.js

@@ -0,0 +1,106 @@
+import { GraphQLError } from "graphql";
+import { context, object, sideEffect } from "postgraphile/grafast";
+import { extendSchema, gql } from "postgraphile/utils";
+import z from "zod/v4";
+import { extractFirstZodErrorMessage } from "../util.js";
+import { maybeOneRow, withPgPoolTransaction, } from "../db/index.js";
+import { insertAuditLog } from "../audit-log.js";
+const InputSchema = z.object({
+    bankrollId: z.uuid("Invalid bankroll ID"),
+    delta: z
+        .number()
+        .int("Delta must be a whole number of base units")
+        .refine((delta) => delta !== 0, "Delta must not be zero"),
+    reason: z
+        .string()
+        .trim()
+        .min(1, "Reason is required")
+        .max(200, "Max reason length: 200 chars"),
+});
+export const HubAdjustBankrollPlugin = extendSchema((build) => {
+    const bankrollTable = build.input.pgRegistry.pgResources.hub_bankroll;
+    return {
+        typeDefs: gql `
+      input HubAdjustBankrollInput {
+        bankrollId: UUID!
+        "Amount to add, in base units. Negative takes money out."
+        delta: Float!
+        reason: String!
+      }
+
+      type HubAdjustBankrollPayload {
+        hubBankroll: HubBankroll!
+      }
+
+      extend type Mutation {
+        hubAdjustBankroll(
+          input: HubAdjustBankrollInput!
+        ): HubAdjustBankrollPayload
+      }
+    `,
+        objects: {
+            Mutation: {
+                plans: {
+                    hubAdjustBankroll(_, { $input }) {
+                        const $identity = context().get("identity");
+                        const $superuserPool = context().get("superuserPool");
+                        const $bankrollId = sideEffect([$input, $identity, $superuserPool], async ([rawInput, identity, superuserPool]) => {
+                            if (identity?.kind !== "operator") {
+                                throw new GraphQLError("Unauthorized");
+                            }
+                            let input;
+                            try {
+                                input = InputSchema.parse(rawInput);
+                            }
+                            catch (e) {
+                                if (e instanceof z.ZodError) {
+                                    throw new GraphQLError(extractFirstZodErrorMessage(e));
+                                }
+                                throw e;
+                            }
+                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                const dbBankroll = await pgClient
+                                    .query({
+                                    text: `
+                        SELECT id, amount, liability
+                        FROM hub.bankroll
+                        WHERE id = $1
+                        FOR UPDATE
+                      `,
+                                    values: [input.bankrollId],
+                                })
+                                    .then(maybeOneRow);
+                                if (!dbBankroll) {
+                                    throw new GraphQLError("Bankroll not found");
+                                }
+                                const newAmount = dbBankroll.amount + input.delta;
+                                if (newAmount > Number.MAX_SAFE_INTEGER) {
+                                    throw new GraphQLError("Bankroll would be too large");
+                                }
+                                if (newAmount < dbBankroll.liability) {
+                                    throw new GraphQLError("Bankroll can't go below what open games may pay out");
+                                }
+                                await pgClient.query({
+                                    text: `UPDATE hub.bankroll SET amount = $2 WHERE id = $1`,
+                                    values: [dbBankroll.id, newAmount],
+                                });
+                                await insertAuditLog(pgClient, "house-bankroll", {
+                                    action: "hub:bankroll:adjust",
+                                    bankrollId: dbBankroll.id,
+                                    bankrollOld: dbBankroll.amount,
+                                    bankrollNew: newAmount,
+                                    bankrollDelta: input.delta,
+                                    metadata: { reason: input.reason },
+                                });
+                                return dbBankroll.id;
+                            });
+                        });
+                        return object({
+                            hubBankroll: bankrollTable.get({ id: $bankrollId }),
+                        });
+                    },
+                },
+            },
+        },
+    };
+}, "HubAdjustBankrollPlugin");

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

@@ -29,9 +29,6 @@ export const AddCasinoSchema = z.strictObject({
     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) => {
@@ -44,10 +41,5 @@ export const ValidateCasinoFieldsPlugin = wrapPlans(() => ({
             sideEffect($input, (input) => validate(input, AddCasinoSchema));
             return plan();
         },
-        updateHubBankrollById: (plan, $source, fieldArgs) => {
-            const $patch = fieldArgs.getRaw(["input", "hubBankrollPatch"]);
-            sideEffect($patch, (patch) => validate(patch, UpdateBankrollSchema));
-            return plan();
-        },
     },
 }));

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

@@ -5,8 +5,6 @@ import assert from "assert";
 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/v4";
 const activeCasinos = new Set();
 export async function startCasinoTransferProcessor({ casinoId, signal, pool, }) {
     if (activeCasinos.has(casinoId)) {
@@ -44,51 +42,9 @@ export function initializeTransferProcessors({ signal, pool, }) {
                 logger.info(`Starting casino processor for "${casino.name}" at "${casino.graphql_url}"`);
                 startCasinoTransferProcessor({ casinoId: casino.id, signal, pool });
             }
-            await listenForNewCasinos({ signal, pool });
         }
         catch (e) {
             logger.error(e, `Error initializing transfer processors`);
         }
     })();
 }
-async function listenForNewCasinos({ signal, pool, }) {
-    const pgClient = new pg.Client(config.SUPERUSER_DATABASE_URL);
-    await pgClient.connect();
-    const NewCasinoPayload = z.object({
-        id: z.string(),
-    });
-    pgClient.on("notification", async (msg) => {
-        logger.debug(msg, `[listenForNewCasinos] received notification`);
-        switch (msg.channel) {
-            case "hub:new_casino": {
-                if (!msg.payload) {
-                    logger.error("hub:new_casino notification has no payload");
-                    return;
-                }
-                let json;
-                try {
-                    json = JSON.parse(msg.payload);
-                }
-                catch (error) {
-                    logger.error(error, "Error parsing new casino notification");
-                }
-                const result = NewCasinoPayload.safeParse(json);
-                if (!result.success) {
-                    logger.error(result.error, "Error parsing new casino notification");
-                    return;
-                }
-                startCasinoTransferProcessor({
-                    casinoId: result.data.id,
-                    signal,
-                    pool,
-                });
-                break;
-            }
-        }
-    });
-    signal.addEventListener("abort", () => {
-        pgClient.removeAllListeners("notification");
-        pgClient.end();
-    });
-    await pgClient.query("LISTEN new_casino");
-}

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

@@ -123,35 +123,59 @@ export function startPollingProcessor({ casinoId, signal, pool, }) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (3)`);
                     break;
                 }
-                cursor = await processTransfersUntilEmpty({
-                    afterCursor: cursor,
-                    graphqlClient,
-                    casinoInfo: { ...casino, ...casinoSecret },
-                    signal,
-                    pool,
-                });
+                let anyTaskFailed = false;
+                try {
+                    cursor = await processTransfersUntilEmpty({
+                        afterCursor: cursor,
+                        graphqlClient,
+                        casinoInfo: { ...casino, ...casinoSecret },
+                        signal,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `transfer polling failed for casino ${casinoId}`);
+                }
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (4)`);
                     break;
                 }
-                await processWithdrawals({
-                    abortSignal: signal,
-                    casinoId: casino.id,
-                    graphqlClient,
-                    pool,
-                });
+                try {
+                    await processWithdrawals({
+                        abortSignal: signal,
+                        casinoId: casino.id,
+                        graphqlClient,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `withdrawal processing failed for casino ${casinoId}`);
+                }
                 if (signal.aborted) {
                     logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (5)`);
                     break;
                 }
-                await processTakeRequests({
-                    abortSignal: signal,
-                    controllerId: casinoSecret.controller_id,
-                    casinoId: casino.id,
-                    graphqlClient,
-                    pool,
-                });
-                processorState.backoffTime = MIN_BACKOFF_TIME;
+                try {
+                    await processTakeRequests({
+                        abortSignal: signal,
+                        controllerId: casinoSecret.controller_id,
+                        casinoId: casino.id,
+                        graphqlClient,
+                        pool,
+                    });
+                }
+                catch (e) {
+                    anyTaskFailed = true;
+                    logger.error(e, `take request processing failed for casino ${casinoId}`);
+                }
+                if (anyTaskFailed) {
+                    processorState.backoffTime = Math.min(processorState.backoffTime * 2, MAX_BACKOFF_TIME);
+                }
+                else {
+                    processorState.backoffTime = MIN_BACKOFF_TIME;
+                }
             }
             catch (e) {
                 processorState.backoffTime = Math.min(processorState.backoffTime * 2, MAX_BACKOFF_TIME);

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

@@ -143,10 +143,6 @@ 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(pool, {
-                    withdrawalId: transfer.id,
-                    newStatus: "CANCELED",
-                });
                 return;
             case TransferStatusKind.Unclaimed:
                 throw new Error(`Unexpected UNCLAIMED withdrawal.`);

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

@@ -90,7 +90,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
             return;
         }
         assert(mpTransfer.__typename === "ExperienceTransfer", `Expected experience transfer but got ${mpTransfer.__typename}`);
-        processTransfer({
+        await processTransfer({
             casinoId,
             controllerId,
             transfer: mpTransfer,

package/dist/src/server/graphile.config.js

@@ -15,6 +15,7 @@ import { HubUserBalanceByCurrencyPlugin } from "../plugins/hub-user-balance-by-c
 import { logger } from "../logger.js";
 import { ValidateCasinoFieldsPlugin } from "../plugins/validate-fields.js";
 import { HubAddCasinoPlugin } from "../plugins/hub-add-casino.js";
+import { HubAdjustBankrollPlugin } from "../plugins/hub-adjust-bankroll.js";
 import { HubBalanceAlertPlugin } from "../plugins/hub-balance-alert.js";
 import { custom as customPgOmitArchivedPlugin } from "@graphile-contrib/pg-omit-archived";
 import { HubCurrentXPlugin } from "../plugins/hub-current-x.js";
@@ -44,6 +45,7 @@ export const requiredPlugins = [
     HubUserBalanceByCurrencyPlugin,
     HubAddCasinoPlugin,
     ValidateCasinoFieldsPlugin,
+    HubAdjustBankrollPlugin,
     HubOutcomeInputNonNullFieldsPlugin,
     HubBadHashChainErrorPlugin,
     HubCreateHashChainPlugin,

package/dist/src/smart-tags.js

@@ -23,9 +23,14 @@ export const SmartTagsPlugin = makeJSONPgSmartTagsPlugin({
                     behavior: ["-orderBy"],
                 },
             },
-            "hub.bankroll.amount": {
+            "hub.user.client_id": {
                 tags: {
-                    behavior: ["+attribute:update"],
+                    behavior: ["-select", "-filterBy", "-orderBy"],
+                },
+            },
+            "hub.experience.client_id": {
+                tags: {
+                    behavior: ["-select", "-filterBy", "-orderBy"],
                 },
             },
         },
@@ -35,11 +40,6 @@ export const SmartTagsPlugin = makeJSONPgSmartTagsPlugin({
                     behavior: ["-resource:select"],
                 },
             },
-            "hub.bankroll": {
-                tags: {
-                    behavior: ["+resource:update"],
-                },
-            },
             "hub.casino": {
                 tags: {
                     behavior: [

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

@@ -215,8 +215,8 @@ export async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest,
         const existingRequest = await pgClient
             .query({
             text: `
-        SELECT id, mp_take_request_id, status, reserved_amount, user_id, experience_id, currency_key 
-        FROM hub.take_request 
+        SELECT id, mp_take_request_id, status, reserved_amount, user_id, experience_id, currency_key, mp_transfer_id
+        FROM hub.take_request
         WHERE mp_take_request_id = $1 AND casino_id = $2
         FOR UPDATE
       `,
@@ -332,6 +332,10 @@ async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, gra
             logger.info(`[processExistingTakeRequest] Take request ${takeRequest.id} in PENDING state`);
             break;
         case LocalTakeRequestStatus.PROCESSING: {
+            if (takeRequest.mp_transfer_id) {
+                logger.info(`[processExistingTakeRequest] Take request ${takeRequest.id} already has transfer ${takeRequest.mp_transfer_id}`);
+                break;
+            }
             const { dbUser, dbExperience, dbCurrency } = await loadRequiredEntities(pgClient, {
                 type: "localId",
                 userId: takeRequest.user_id,
@@ -439,7 +443,6 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
     catch (error) {
         logger.error(error, `[attemptTransfer] Error creating transfer`);
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        const shouldRetry = error instanceof Error && isNetworkError(error);
         await pgClient.query({
             text: `
         UPDATE hub.take_request
@@ -450,41 +453,12 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
       `,
             values: [takeRequestId, errorMessage.slice(0, 200)],
         });
-        if (!shouldRetry) {
-            logger.info({ takeRequestId }, `[attemptTransfer] Non-retryable error, marking as FAILED and refunding`);
-            await pgClient.query({
-                text: `
-          UPDATE hub.take_request
-          SET status = $1,
-              debug = COALESCE(debug, '') || ' | Non-retryable error, refunding'
-          WHERE id = $2
-        `,
-                values: [LocalTakeRequestStatus.FAILED, takeRequestId],
-            });
-            await refundTakeRequest(pgClient, takeRequestId);
-            return null;
-        }
-        const TRANSFER_RETRY_TIMEOUT_SECONDS = 30;
-        const takeRequestAfterAttempt = await pgClient
-            .query({
-            text: `SELECT transfer_first_failure_at FROM hub.take_request WHERE id = $1`,
-            values: [takeRequestId],
-        })
-            .then(exactlyOneRow);
-        const elapsedMs = Date.now() - takeRequestAfterAttempt.transfer_first_failure_at.getTime();
-        if (elapsedMs >= TRANSFER_RETRY_TIMEOUT_SECONDS * 1000) {
-            logger.error({ takeRequestId, elapsedMs }, `[attemptTransfer] Retry timeout (${TRANSFER_RETRY_TIMEOUT_SECONDS}s) reached, marking as FAILED and refunding`);
-            await pgClient.query({
-                text: `
-          UPDATE hub.take_request
-          SET status = $1,
-              debug = COALESCE(debug, '') || ' | Transfer retry timeout reached, refunding'
-          WHERE id = $2
-        `,
-                values: [LocalTakeRequestStatus.FAILED, takeRequestId],
-            });
-            await refundTakeRequest(pgClient, takeRequestId);
-        }
+        await settleTakeRequestAfterFailedTransfer({
+            pgClient,
+            graphqlClient,
+            takeRequestId,
+            mpTakeRequestId,
+        });
         return null;
     }
 }
@@ -633,6 +607,10 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             .then(exactlyOneRow);
                         if (takeRequestData.refunded_at) {
                             logger.warn({ mpTransferId, takeRequestId }, `[completeTransfer] Transfer was already refunded. This should never happen.`);
+                            await pgClient.query({
+                                text: `UPDATE hub.take_request SET transfer_needs_completion = FALSE WHERE id = $1`,
+                                values: [takeRequestId],
+                            });
                             break;
                         }
                         const dbLockedBalance = await pgClient
@@ -1094,11 +1072,76 @@ async function refundTakeRequest(pgClient, takeRequestId) {
     logger.info({ takeRequestId, amount: takeRequestData.reserved_amount }, `[refundTakeRequest] Successfully refunded`);
     return true;
 }
+const NETWORK_ERROR_MARKERS = [
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "socket hang up",
+];
 function isNetworkError(e) {
-    return (e.message?.includes("ECONNREFUSED") ||
-        e.message?.includes("ECONNRESET") ||
-        e.message?.includes("ETIMEDOUT") ||
-        e.message?.includes("EHOSTUNREACH") ||
-        e.message?.includes("ENETUNREACH") ||
-        e.message?.includes("socket hang up"));
+    for (let cur = e, depth = 0; cur && depth < 5; depth++) {
+        const err = cur;
+        const text = `${String(err.code ?? "")} ${String(err.message ?? "")}`;
+        if (NETWORK_ERROR_MARKERS.some((marker) => text.includes(marker))) {
+            return true;
+        }
+        cur = err.cause;
+    }
+    return false;
+}
+async function settleTakeRequestAfterFailedTransfer({ pgClient, graphqlClient, takeRequestId, mpTakeRequestId, }) {
+    let mpTakeRequest = null;
+    try {
+        const rejectResult = await graphqlClient.request(MP_REJECT_TAKE_REQUEST, {
+            mpTakeRequestId,
+        });
+        if (rejectResult.rejectTakeRequest.result.__typename !==
+            "RejectTakeRequestSuccess") {
+            mpTakeRequest = await mpGetTakeRequest(graphqlClient, mpTakeRequestId);
+            if (!mpTakeRequest) {
+                throw new Error(`Take request ${mpTakeRequestId} not found on casino`);
+            }
+        }
+    }
+    catch (e) {
+        logger.error({ err: e, takeRequestId, networkError: isNetworkError(e) }, `[settleTakeRequestAfterFailedTransfer] Transfer outcome unknown, keeping the reservation and retrying`);
+        return;
+    }
+    if (mpTakeRequest?.experienceTransfer) {
+        logger.info({ takeRequestId, mpTransferId: mpTakeRequest.experienceTransfer.id }, `[settleTakeRequestAfterFailedTransfer] Casino already made the transfer`);
+        await pgClient.query({
+            text: `
+        UPDATE hub.take_request
+        SET mp_transfer_id = $1,
+            mp_transfer_status = $2,
+            transfer_needs_completion = TRUE,
+            mp_status = $3
+        WHERE id = $4
+      `,
+            values: [
+                mpTakeRequest.experienceTransfer.id,
+                MpTransferStatus.Pending,
+                mpTakeRequest.status,
+                takeRequestId,
+            ],
+        });
+        return;
+    }
+    const [status, mpStatus] = mpTakeRequest
+        ? [LocalTakeRequestStatus.FAILED, mpTakeRequest.status]
+        : [LocalTakeRequestStatus.REJECTED, MpTakeRequestStatus.ControllerRejected];
+    logger.info({ takeRequestId, mpStatus }, `[settleTakeRequestAfterFailedTransfer] Casino confirmed no transfer, refunding`);
+    await pgClient.query({
+        text: `
+      UPDATE hub.take_request
+      SET status = $1,
+          mp_status = $2,
+          debug = COALESCE(debug, '') || ' | Casino confirmed no transfer, refunding'
+      WHERE id = $3
+    `,
+        values: [status, mpStatus, takeRequestId],
+    });
+    await refundTakeRequest(pgClient, takeRequestId);
 }