@moneypot/hub 1.19.3 → 1.19.5-dev.0

package/README.md

@@ -80,6 +80,7 @@ You should always keep your hub server up to date as soon as possible. Never ins
 ### 1.19.x
 
 - All of hub's internal graphql-schema-modifying plugins have been moved to hub's set of required plugins.
+- Added `FAILED` take request auto-handling
 
 ### 1.18.x
 

package/dist/src/db/types.d.ts

@@ -114,6 +114,8 @@ export type DbTakeRequest = {
     mp_transfer_status: DbTransferStatusKind | null;
     transfer_needs_completion: boolean;
     transfer_completion_attempted_at: Date | null;
+    transfer_failure_count: number;
+    transfer_first_failure_at: Date | null;
     refunded_at: Date | null;
     updated_at: Date;
 };

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
-import { Express } from "express";
+import { type ConfigureAppArgs } from "./server/index.js";
 import { type PluginIdentity } from "./server/graphile.config.js";
-import { ServerContext } from "./context.js";
+import { type ServerContext } from "./context.js";
 declare global {
     namespace Grafast {
         interface Context {
@@ -22,10 +22,9 @@ export { type CustomGameConfig, type CustomGameConfigMap, } from "./custom-game-
 export { validateRisk, type RiskPolicy, type RiskPolicyArgs, type RiskLimits, } from "./risk-policy.js";
 export type PluginContext = Grafast.Context;
 export { defaultPlugins, type PluginIdentity, type UserSessionContext, type HubPlugin, } from "./server/graphile.config.js";
-export type ConfigureAppArgs = {
-    app: Express;
-    superuserPool: ServerContext["superuserPool"];
-};
+export type { ConfigureAppArgs } from "./server/index.js";
+import { runMigrations } from "./migrations.js";
+export { runMigrations };
 import type { HubPlugin } from "./server/graphile.config.js";
 export type ServerOptions = {
     configureApp?: (args: ConfigureAppArgs) => void;
@@ -37,9 +36,6 @@ export type ServerOptions = {
     enablePlayground?: boolean;
     port?: number;
 };
-export declare function runMigrations(options: {
-    userDatabaseMigrationsPath?: string;
-}): Promise<void>;
 export declare function startAndListen(options: ServerOptions): Promise<{
     port: number;
     stop: () => Promise<void>;

package/dist/src/index.js

@@ -1,77 +1,12 @@
-import PgUpgradeSchema, { DatabaseAheadError, } from "@moneypot/pg-upgrade-schema";
-import * as db from "./db/index.js";
 import * as config from "./config.js";
-import { createHubServer } from "./server/index.js";
-import { initializeTransferProcessors } from "./process-transfers/index.js";
-import { join } from "path";
 import { logger } from "./logger.js";
-import { createServerContext, closeServerContext, } from "./context.js";
+import { createHubServer } from "./server/index.js";
 export { HubGameConfigPlugin, } from "./plugins/hub-game-config-plugin.js";
 export { validateRisk, } from "./risk-policy.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
-export async function runMigrations(options) {
-    if (options.userDatabaseMigrationsPath) {
-        const { existsSync, statSync } = await import("fs");
-        if (!existsSync(options.userDatabaseMigrationsPath)) {
-            throw new Error(`userDatabaseMigrationsPath does not exist: ${options.userDatabaseMigrationsPath}`);
-        }
-        const stats = statSync(options.userDatabaseMigrationsPath);
-        if (!stats.isDirectory()) {
-            throw new Error(`userDatabaseMigrationsPath is not a directory: ${options.userDatabaseMigrationsPath}`);
-        }
-    }
-    const pgClient = db.getPgClient(config.SUPERUSER_DATABASE_URL);
-    await pgClient.connect();
-    try {
-        try {
-            await PgUpgradeSchema.default({
-                pgClient,
-                dirname: join(import.meta.dirname, "pg-versions"),
-                schemaName: "hub_core_versions",
-                silent: process.env.NODE_ENV === "test",
-            });
-        }
-        catch (e) {
-            logger.error(e, "Error upgrading core schema");
-            if (e instanceof DatabaseAheadError) {
-                logger.error(`${"⚠️".repeat(10)}\n@moneypot/hub database was reset to prepare for a production release and you must reset your database to continue. Please see <https://www.npmjs.com/package/@moneypot/hub#change-log> for more info.`);
-                process.exit(1);
-            }
-            throw e;
-        }
-        if (options.userDatabaseMigrationsPath) {
-            await PgUpgradeSchema.default({
-                pgClient,
-                dirname: options.userDatabaseMigrationsPath,
-                schemaName: "hub_user_versions",
-                silent: process.env.NODE_ENV === "test",
-            });
-        }
-    }
-    finally {
-        await pgClient.end();
-    }
-}
-async function initialize(options) {
-    if (options.signal.aborted) {
-        logger.info("Initialization aborted by graceful shutdown");
-        return;
-    }
-    await runMigrations({
-        userDatabaseMigrationsPath: options.userDatabaseMigrationsPath,
-    });
-    if (options.signal.aborted) {
-        logger.info("Initialization aborted by graceful shutdown");
-        return;
-    }
-    if (process.env.NODE_ENV !== "test") {
-        initializeTransferProcessors({
-            signal: options.signal,
-            pool: options.context.superuserPool,
-        });
-    }
-}
-export async function startAndListen(options) {
+import { runMigrations } from "./migrations.js";
+export { runMigrations };
+function validateOptions(options) {
     if (options.plugins && options.plugins.some((p) => typeof p === "function")) {
         throw new Error("`plugins` should be an array of HubPlugin but one of the items is a function. Did you forget to call it?");
     }
@@ -83,60 +18,38 @@ export async function startAndListen(options) {
         !options.exportSchemaSDLPath.startsWith("/")) {
         throw new Error(`exportSchemaSDLPath must be an absolute path, got ${options.exportSchemaSDLPath}`);
     }
-    const abortController = new AbortController();
-    let isShuttingDown = false;
-    const context = createServerContext();
-    await initialize({
+}
+export async function startAndListen(options) {
+    validateOptions(options);
+    await runMigrations({
         userDatabaseMigrationsPath: options.userDatabaseMigrationsPath,
-        signal: abortController.signal,
-        context,
     });
     const hubServer = createHubServer({
         configureApp: options.configureApp,
         plugins: options.plugins,
         exportSchemaSDLPath: options.exportSchemaSDLPath,
         extraPgSchemas: options.extraPgSchemas,
-        abortSignal: abortController.signal,
-        context,
         enableChat: options.enableChat ?? true,
         enablePlayground: options.enablePlayground ?? true,
         port: options.port ?? config.PORT,
+        runProcessors: process.env.NODE_ENV !== "test",
     });
-    const gracefulShutdown = async ({ exit = true } = {}) => {
-        if (isShuttingDown) {
-            logger.warn("Already shutting down.");
-            return;
-        }
-        isShuttingDown = true;
-        logger.info("Shutting down gracefully...");
-        abortController.abort();
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        logger.info("Closing resources...");
-        await hubServer.shutdown();
-        try {
-            await Promise.race([
-                closeServerContext(context),
-                new Promise((_, reject) => setTimeout(() => reject(new Error("Database cleanup timeout")), 3000)),
-            ]);
-            logger.info("Cleanup complete.");
-        }
-        catch (err) {
-            logger.warn(err, "Cleanup error (proceeding anyway)");
-        }
-        if (exit) {
-            process.exit(0);
-        }
-    };
     if (process.env.NODE_ENV !== "test") {
-        process.on("SIGINT", gracefulShutdown);
-        process.on("SIGTERM", gracefulShutdown);
-    }
-    return hubServer.listen().then(({ port }) => {
-        return {
-            port,
-            stop: async () => {
-                await gracefulShutdown({ exit: false });
-            },
+        const handler = () => {
+            hubServer
+                .shutdown()
+                .then(() => process.exit(0))
+                .catch((err) => {
+                logger.error(err, "Shutdown error");
+                process.exit(1);
+            });
         };
-    });
+        process.on("SIGINT", handler);
+        process.on("SIGTERM", handler);
+    }
+    const { port } = await hubServer.listen();
+    return {
+        port,
+        stop: () => hubServer.shutdown(),
+    };
 }

package/dist/src/migrations.d.ts

@@ -0,0 +1,3 @@
+export declare function runMigrations(options: {
+    userDatabaseMigrationsPath?: string;
+}): Promise<void>;

package/dist/src/migrations.js

@@ -0,0 +1,48 @@
+import PgUpgradeSchema, { DatabaseAheadError, } from "@moneypot/pg-upgrade-schema";
+import * as db from "./db/index.js";
+import * as config from "./config.js";
+import { join } from "path";
+import { logger } from "./logger.js";
+export async function runMigrations(options) {
+    if (options.userDatabaseMigrationsPath) {
+        const { existsSync, statSync } = await import("fs");
+        if (!existsSync(options.userDatabaseMigrationsPath)) {
+            throw new Error(`userDatabaseMigrationsPath does not exist: ${options.userDatabaseMigrationsPath}`);
+        }
+        const stats = statSync(options.userDatabaseMigrationsPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`userDatabaseMigrationsPath is not a directory: ${options.userDatabaseMigrationsPath}`);
+        }
+    }
+    const pgClient = db.getPgClient(config.SUPERUSER_DATABASE_URL);
+    await pgClient.connect();
+    try {
+        try {
+            await PgUpgradeSchema.default({
+                pgClient,
+                dirname: join(import.meta.dirname, "pg-versions"),
+                schemaName: "hub_core_versions",
+                silent: process.env.NODE_ENV === "test",
+            });
+        }
+        catch (e) {
+            logger.error(e, "Error upgrading core schema");
+            if (e instanceof DatabaseAheadError) {
+                logger.error(`${"⚠️".repeat(10)}\n@moneypot/hub database was reset to prepare for a production release and you must reset your database to continue. Please see <https://www.npmjs.com/package/@moneypot/hub#change-log> for more info.`);
+                process.exit(1);
+            }
+            throw e;
+        }
+        if (options.userDatabaseMigrationsPath) {
+            await PgUpgradeSchema.default({
+                pgClient,
+                dirname: options.userDatabaseMigrationsPath,
+                schemaName: "hub_user_versions",
+                silent: process.env.NODE_ENV === "test",
+            });
+        }
+    }
+    finally {
+        await pgClient.end();
+    }
+}

package/dist/src/pg-versions/014-take-request-transfer-retry.sql

@@ -0,0 +1,11 @@
+ALTER TABLE hub.take_request
+ADD COLUMN IF NOT EXISTS transfer_failure_count int DEFAULT 0,
+ADD COLUMN IF NOT EXISTS transfer_first_failure_at timestamptz;
+
+CREATE INDEX IF NOT EXISTS take_request_transfer_retry_idx
+ON hub.take_request(casino_id, status, transfer_first_failure_at)
+WHERE mp_transfer_id IS NULL AND status = 'PROCESSING';
+
+CREATE INDEX IF NOT EXISTS take_request_failed_refund_idx
+ON hub.take_request(casino_id, status, refunded_at)
+WHERE mp_transfer_id IS NULL AND status = 'FAILED' AND refunded_at IS NULL;

package/dist/src/server/index.d.ts

@@ -1,4 +1,3 @@
-import { ServerOptions } from "../index.js";
 import { ServerContext } from "../context.js";
 export type HubServer = {
     listen: () => Promise<{
@@ -6,10 +5,20 @@ export type HubServer = {
     }>;
     shutdown: () => Promise<void>;
 };
-export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, port, }: Pick<ServerOptions, "plugins" | "exportSchemaSDLPath" | "extraPgSchemas" | "configureApp"> & {
-    abortSignal: AbortSignal;
-    context: ServerContext;
+import type { Express } from "express";
+import type { HubPlugin } from "./graphile.config.js";
+export type ConfigureAppArgs = {
+    app: Express;
+    superuserPool: ServerContext["superuserPool"];
+};
+export type CreateHubServerOptions = {
+    configureApp?: (args: ConfigureAppArgs) => void;
+    plugins?: readonly HubPlugin[];
+    extraPgSchemas?: string[];
+    exportSchemaSDLPath?: string;
     enableChat: boolean;
     enablePlayground: boolean;
     port: number;
-}): HubServer;
+    runProcessors: boolean;
+};
+export declare function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, enableChat, enablePlayground, port, runProcessors, }: CreateHubServerOptions): HubServer;

package/dist/src/server/index.js

@@ -2,6 +2,8 @@ import { createServer as createNodeServer } from "node:http";
 import { grafserv } from "postgraphile/grafserv/express/v4";
 import postgraphile from "postgraphile";
 import { createPreset, defaultPlugins } from "./graphile.config.js";
+import { createServerContext, closeServerContext, } from "../context.js";
+import { initializeTransferProcessors } from "../process-transfers/index.js";
 import express from "express";
 import { logger } from "../logger.js";
 import cors from "./middleware/cors.js";
@@ -44,13 +46,15 @@ function createExpressServer(context) {
     });
     return app;
 }
-export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, abortSignal, context, enableChat, enablePlayground, port, }) {
+export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, extraPgSchemas, enableChat, enablePlayground, port, runProcessors, }) {
+    const abortController = new AbortController();
+    const context = createServerContext();
     const expressServer = createExpressServer(context);
     const { preset, pgService } = createPreset({
         plugins: plugins ?? defaultPlugins,
         exportSchemaSDLPath,
         extraPgSchemas: extraPgSchemas ?? [],
-        abortSignal,
+        abortSignal: abortController.signal,
         context,
         enableChat,
         enablePlayground,
@@ -64,10 +68,16 @@ export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, ex
     nodeServer.on("error", (e) => {
         logger.error(e);
     });
-    const mountMiddlewarePromise = serv.addTo(expressServer, nodeServer);
+    let isShuttingDown = false;
     return {
         listen: async () => {
-            await mountMiddlewarePromise;
+            if (runProcessors) {
+                initializeTransferProcessors({
+                    signal: abortController.signal,
+                    pool: context.superuserPool,
+                });
+            }
+            await serv.addTo(expressServer, nodeServer);
             await pgl.getSchema();
             return new Promise((resolve) => {
                 nodeServer.listen(port, () => {
@@ -78,12 +88,23 @@ export function createHubServer({ configureApp, plugins, exportSchemaSDLPath, ex
             });
         },
         shutdown: async () => {
+            if (isShuttingDown) {
+                logger.warn("Already shutting down.");
+                return;
+            }
+            isShuttingDown = true;
+            logger.info("Shutting down gracefully...");
+            abortController.abort();
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            logger.info("Closing resources...");
             nodeServer.closeAllConnections();
+            await closeServerContext(context);
             await pgService.release?.();
             await pgl.release();
             await new Promise((resolve) => {
                 nodeServer.close(() => resolve());
             });
+            logger.info("Cleanup complete.");
         },
     };
 }

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

@@ -25,3 +25,8 @@ export declare function completeTransfer({ mpTakeRequestId, takeRequestId, mpTra
     casinoId: string;
     pool: pg.Pool;
 }): Promise<void>;
+export declare function processFailedRequestRefunds({ casinoId, abortSignal, pool, }: {
+    casinoId: string;
+    abortSignal: AbortSignal;
+    pool: pg.Pool;
+}): Promise<void>;

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

@@ -193,6 +193,7 @@ export async function processTakeRequests({ abortSignal, controllerId, casinoId,
         pool,
     });
     await processStuckRequests({ casinoId, graphqlClient, abortSignal, pool });
+    await processFailedRequestRefunds({ casinoId, abortSignal, pool });
 }
 async function fetchPendingTakeRequests(graphqlClient, controllerId) {
     const result = await graphqlClient.request(MP_PAGINATE_PENDING_TAKE_REQUESTS, {
@@ -382,6 +383,7 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
         }
         const result = transferResult.transferCurrencyExperienceToUser.result;
         let transferId = null;
+        let needsImmediateRefund = false;
         let resultStatus = LocalTakeRequestStatus.PROCESSING;
         switch (result.__typename) {
             case "TransferSuccess":
@@ -400,6 +402,7 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
                 }
                 else {
                     resultStatus = LocalTakeRequestStatus.FAILED;
+                    needsImmediateRefund = true;
                 }
                 break;
             }
@@ -409,8 +412,8 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
         await pgClient.query({
             text: `
         UPDATE hub.take_request
-        SET status = $1, 
-            mp_transfer_id = $2, 
+        SET status = $1,
+            mp_transfer_id = $2,
             mp_transfer_status = $3,
             transfer_needs_completion = $4,
             mp_status = $5
@@ -427,18 +430,61 @@ async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExp
                 takeRequestId,
             ],
         });
+        if (needsImmediateRefund) {
+            logger.info({ takeRequestId }, `[attemptTransfer] Take request already terminal on MP, refunding`);
+            await refundTakeRequest(pgClient, takeRequestId);
+        }
         return transferId;
     }
     catch (error) {
-        logger.error(error, `[attemptTransfer] 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
-        SET status = $1
-        WHERE id = $2
+        SET transfer_failure_count = COALESCE(transfer_failure_count, 0) + 1,
+            transfer_first_failure_at = COALESCE(transfer_first_failure_at, now()),
+            debug = COALESCE(debug, '') || ' | Transfer attempt failed: ' || $2::text
+        WHERE id = $1
       `,
-            values: [LocalTakeRequestStatus.FAILED, takeRequestId],
+            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);
+        }
         return null;
     }
 }
@@ -720,7 +766,10 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool
       WHERE casino_id = $1
         AND status = $2
         AND mp_transfer_id IS NULL
-        AND updated_at < now() - interval '5 minutes'
+        AND (
+          transfer_first_failure_at IS NULL
+          OR transfer_first_failure_at < now() - interval '10 seconds'
+        )
       LIMIT 10
     `,
         values: [casinoId, LocalTakeRequestStatus.PROCESSING],
@@ -741,6 +790,41 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool
         });
     }
 }
+export async function processFailedRequestRefunds({ casinoId, abortSignal, pool, }) {
+    if (abortSignal.aborted) {
+        return;
+    }
+    const failedRequests = await pool
+        .query({
+        text: `
+      SELECT id, mp_take_request_id
+      FROM hub.take_request
+      WHERE casino_id = $1
+        AND status = $2
+        AND mp_transfer_id IS NULL
+        AND refunded_at IS NULL
+        AND reserved_amount > 0
+      LIMIT 10
+    `,
+        values: [casinoId, LocalTakeRequestStatus.FAILED],
+    })
+        .then((result) => result.rows);
+    if (failedRequests.length > 0) {
+        logger.info(`[processFailedRequestRefunds] Found ${failedRequests.length} FAILED requests needing refunds`);
+    }
+    for (const request of failedRequests) {
+        if (abortSignal.aborted) {
+            break;
+        }
+        await withPgPoolTransaction(pool, async (pgClient) => {
+            await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+                mpTakeRequestId: request.mp_take_request_id,
+                casinoId,
+            });
+            await refundTakeRequest(pgClient, request.id);
+        });
+    }
+}
 async function loadRequiredEntities(pgClient, params) {
     const { type, currencyKey, casinoId } = params;
     const dbCurrency = await pgClient
@@ -926,6 +1010,90 @@ async function updateTakeRequestStatus(pgClient, takeRequestId, status) {
         values: [status, takeRequestId],
     });
 }
+async function refundTakeRequest(pgClient, takeRequestId) {
+    const takeRequestData = await pgClient
+        .query({
+        text: `
+        SELECT *
+        FROM hub.take_request
+        WHERE id = $1
+        FOR UPDATE
+      `,
+        values: [takeRequestId],
+    })
+        .then(exactlyOneRow);
+    if (takeRequestData.refunded_at) {
+        logger.debug({ takeRequestId }, `[refundTakeRequest] Already refunded, skipping`);
+        return false;
+    }
+    if (takeRequestData.reserved_amount <= 0) {
+        logger.debug({ takeRequestId }, `[refundTakeRequest] No reserved amount to refund`);
+        return false;
+    }
+    const dbLockedBalance = await pgClient
+        .query({
+        text: `
+        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.user_id,
+            takeRequestData.experience_id,
+            takeRequestData.casino_id,
+            takeRequestData.currency_key,
+        ],
+    })
+        .then(maybeOneRow);
+    if (!dbLockedBalance) {
+        logger.error({ takeRequestId, takeRequestData }, `[refundTakeRequest] Balance record not found - cannot refund`);
+        await pgClient.query({
+            text: `
+        UPDATE hub.take_request
+        SET debug = COALESCE(debug, '') || ' | Refund failed: balance record not found'
+        WHERE id = $1
+      `,
+            values: [takeRequestId],
+        });
+        return false;
+    }
+    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: dbLockedBalance.id,
+        balanceOld: dbLockedBalance.amount,
+        balanceNew: dbLockedBalance.amount + takeRequestData.reserved_amount,
+        balanceDelta: takeRequestData.reserved_amount,
+        action: "hub:take_request:refund",
+        refType: "hub.take_request",
+        refId: takeRequestId,
+    });
+    await pgClient.query({
+        text: `
+      UPDATE hub.take_request
+      SET refunded_at = now(),
+          debug = COALESCE(debug, '') || $2,
+          updated_at = now()
+      WHERE id = $1
+    `,
+        values: [
+            takeRequestId,
+            ` | Refunded ${takeRequestData.reserved_amount} base units of ${takeRequestData.currency_key}`,
+        ],
+    });
+    logger.info({ takeRequestId, amount: takeRequestData.reserved_amount }, `[refundTakeRequest] Successfully refunded`);
+    return true;
+}
 function isNetworkError(e) {
     return (e.message?.includes("ECONNREFUSED") ||
         e.message?.includes("ECONNRESET") ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.19.3",
+  "version": "1.19.5-dev.0",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [