@moneypot/hub 1.5.1 → 1.6.0-dev.0

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

@@ -0,0 +1,89 @@
+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";
+import * as config from "../config.js";
+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, }) {
+    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);
+    assert(casino, `Casino not found for casino id ${casinoId}`);
+    assert(secret, `Secret not found for casino id ${casinoId}`);
+    activeCasinos.add(casinoId);
+    startPollingProcessor({ casinoId, signal });
+    startWebsocketProcessor({
+        casinoId,
+        graphqlUrl: casino.graphql_url,
+        signal,
+        controllerId: secret.controller_id,
+        apiKey: secret.api_key,
+    });
+}
+export function initializeTransferProcessors({ signal, }) {
+    (async () => {
+        try {
+            const casinos = await db.listCasinos(superuserPool);
+            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}"`);
+                    continue;
+                }
+                if (config.NODE_ENV === "production" &&
+                    new URL(casino.graphql_url).hostname === "localhost") {
+                    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 });
+            }
+            await listenForNewCasinos({ signal });
+        }
+        catch (e) {
+            logger.error(`Error initializing transfer processors:`, e);
+        }
+    })();
+}
+async function listenForNewCasinos({ signal }) {
+    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(`[listenForNewCasinos] received notification:`, msg);
+        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 parsing new casino notification:", error);
+                }
+                const result = NewCasinoPayload.safeParse(json);
+                if (!result.success) {
+                    logger.error("Error parsing new casino notification:", result.error);
+                    return;
+                }
+                startCasinoTransferProcessor({ casinoId: result.data.id, signal });
+                break;
+            }
+        }
+    });
+    signal.addEventListener("abort", () => {
+        pgClient.removeAllListeners("notification");
+        pgClient.end();
+    });
+    await pgClient.query("LISTEN new_casino");
+}

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

@@ -0,0 +1,10 @@
+import * as db from "../db/index.js";
+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, }: {
+    casinoId: db.DbCasino["id"];
+    signal: AbortSignal;
+}): void;

package/dist/src/{process-transfers.js → process-transfers/polling-processor.js}

@@ -1,335 +1,59 @@
-import * as db from "./db/index.js";
-import { GET_CURRENCIES, PAGINATE_TRANSFERS } from "./graphql-queries.js";
-import { TransferStatusKind, } from "./__generated__/graphql.js";
-import { createGraphqlClient } from "./graphql-client.js";
-import EventEmitter from "events";
-import { superuserPool } from "./db/index.js";
-import { dbGetCasinoById, dbGetCasinoSecretById } from "./db/internal.js";
-import pg from "pg";
-import * as config from "./config.js";
-import { z } from "zod";
-import { gql } from "./__generated__/gql.js";
-import { logger } from "./logger.js";
+import * as db from "../db/index.js";
+import { logger } from "../logger.js";
 import { assert } from "tsafe";
-import { isUuid } from "./util.js";
-import { processWithdrawalRequests } from "./process-withdrawal-request.js";
-import * as jwtService from "./services/jwt-service.js";
-import { processTakeRequests } from "./take-request/process-take-request.js";
-const MP_COMPLETE_TRANSFER = gql(`
-  mutation CompleteTransfer($mpTransferId: UUID!) {
-    completeTransfer(input: { id: $mpTransferId }) {
-      result {
-        ... on CompleteTransferSuccess {
-          __typename
-          transfer {
-            id
-            ... on ExperienceTransfer {
-              id
-              status
-            }
-          }
-        }
-        ... on InvalidTransferStatus {
-          __typename
-          currentStatus
-          message
-        }
+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";
+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";
+import { useFragment } from "../__generated__/fragment-masking.js";
+import { TRANSFER_FIELDS } from "./graphql.js";
+export const PAGINATE_TRANSFERS = gql(`
+  query PaginateTransfers(
+    $controllerId: UUID!
+    $after: Cursor
+    $limit: Int = 10
+  ) {
+    transfersByHolder(
+      input: {
+        holderId: $controllerId
+        after: $after
+        first: $limit
+        orderBy: ID_ASC
+        type: EXPERIENCE
       }
-    }
-  }
-`);
-const MP_CLAIM_TRANSFER = gql(`
-  mutation ClaimTransfer($mpTransferId: UUID!) {
-    claimTransfer(input: { id: $mpTransferId }) {
-      result {
-        ... on ClaimTransferSuccess {
-          __typename
-          transfer {
-            id
-            ... on ExperienceTransfer {
-              id
-              status
-            }
-          }
-        }
-        ... on InvalidTransferStatus {
-          __typename
-          currentStatus
-          message
+    ) {
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+      edges {
+        cursor
+        node {
+          ...TransferFields
         }
       }
     }
   }
 `);
-const casinoMap = new Map();
 const MIN_BACKOFF_TIME = 5000;
 const MAX_BACKOFF_TIME = 30 * 1000;
-async function listenForNewCasinos({ signal }) {
-    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(`[listenForNewCasinos] received notification:`, msg);
-        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 parsing new casino notification:", error);
-                }
-                const result = NewCasinoPayload.safeParse(json);
-                if (!result.success) {
-                    logger.error("Error parsing new casino notification:", result.error);
-                    return;
-                }
-                startTransferProcessor({ casinoId: result.data.id, signal });
-                break;
-            }
-        }
-    });
-    signal.addEventListener("abort", () => {
-        pgClient.removeAllListeners("notification");
-        pgClient.end();
-    });
-    await pgClient.query("LISTEN new_casino");
-}
-async function processTransfer({ casinoId, controllerId, transfer, graphqlClient, }) {
-    assert(transfer, "Expected transfer");
-    assert(transfer.__typename === "ExperienceTransfer", `Expected ExperienceTransfer but got ${transfer.__typename}`);
-    logger.debug(`processing transfer ${transfer.id} for casino ${casinoId}...`);
-    logger.debug("transfer", transfer);
-    assert(transfer.experienceByExperienceId, "Expected experienceByExperienceId");
-    const isIncoming = controllerId === transfer.toHolderId;
-    const user = isIncoming
-        ? transfer.holderByFromHolderId
-        : transfer.holderByToHolderId;
-    assert(user?.__typename === "User", "Expected user transfer participant");
-    const currency = transfer.currencyByCurrency;
-    const dbSender = await db.upsertUser(superuserPool, {
-        casinoId,
-        mpUserId: user.id,
-        uname: user.uname,
-    });
-    const dbExperience = await db.upsertExperience(superuserPool, {
-        casinoId,
-        mpExperienceId: transfer.experienceByExperienceId.id,
-        name: transfer.experienceByExperienceId.name,
-    });
-    await db.upsertCurrencies(superuserPool, {
-        casinoId,
-        currencies: [currency],
-    });
-    if (isIncoming) {
-        logger.debug(`${user.uname} sent me ${transfer.amount} base units of ${currency.id}`);
-        switch (transfer.status) {
-            case TransferStatusKind.Pending:
-                throw new Error(`Unexpected PENDING deposit transfer: ${JSON.stringify(transfer)}`);
-            case TransferStatusKind.Canceled:
-            case TransferStatusKind.Expired:
-                return;
-            case TransferStatusKind.Completed: {
-                await db.insertDeposit(superuserPool, {
-                    casinoId,
-                    mpTransferId: transfer.id,
-                    userId: dbSender.id,
-                    experienceId: dbExperience.id,
-                    amount: transfer.amount,
-                    currency: currency.id,
-                });
-                return;
-            }
-            case TransferStatusKind.Unclaimed: {
-                let data;
-                try {
-                    data = await graphqlClient.request(MP_CLAIM_TRANSFER, {
-                        mpTransferId: transfer.id,
-                    });
-                }
-                catch (e) {
-                    logger.error(`Error sending claimTransfer(${transfer.id}) to ${casinoId}:`, e);
-                    throw e;
-                }
-                logger.debug("MP_CLAIM_TRANSFER response:", data);
-                if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
-                    throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
-                }
-                await db.insertDeposit(superuserPool, {
-                    casinoId,
-                    mpTransferId: transfer.id,
-                    userId: dbSender.id,
-                    experienceId: dbExperience.id,
-                    amount: transfer.amount,
-                    currency: currency.id,
-                });
-                return;
-            }
-            default: {
-                const exhaustiveCheck = transfer.status;
-                throw new Error(`Unexpected transfer status: ${exhaustiveCheck}`);
-            }
-        }
-    }
-    else {
-        logger.debug(`I sent ${user.uname} ${transfer.amount} base units of ${currency.id}`);
-        switch (transfer.status) {
-            case TransferStatusKind.Canceled:
-                throw new Error("TODO: Unexpected CANCELED withdrawal. Need to refund the user.");
-            case TransferStatusKind.Unclaimed:
-                throw new Error(`Unexpected UNCLAIMED withdrawal.`);
-            case TransferStatusKind.Expired:
-                throw new Error(`Unexpected EXPIRED withdrawal.`);
-            case TransferStatusKind.Pending:
-            case TransferStatusKind.Completed:
-                return;
-            default: {
-                const exhaustiveCheck = transfer.status;
-                throw new Error(`Unexpected transfer status: ${exhaustiveCheck}`);
-            }
-        }
-    }
-}
-async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, }) {
-    let hasNextPage = true;
-    const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
-    while (hasNextPage && !signal.aborted) {
-        await processWithdrawalRequests({
-            casinoId: casinoInfo.id,
-            graphqlClient,
-        });
-        if (signal.aborted) {
-            logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
-            break;
-        }
-        const data = await graphqlClient.request(PAGINATE_TRANSFERS, {
-            controllerId: casinoInfo.controller_id,
-            limit: 10,
-            after: afterCursor,
-        });
-        const transfers = data.transfersByHolder?.edges.flatMap((x) => x?.node || []) || [];
-        if (transfers.length === 0) {
-            break;
-        }
-        else {
-            if (transfers.length > 0) {
-                logger.debug(`processing ${transfers.length} transfers...`);
-            }
-        }
-        for (const transfer of transfers) {
-            const cursor = transfer.id;
-            if (transfer.__typename !== "ExperienceTransfer") {
-                logger.error(`transfer ${transfer.id} is not an ExperienceTransfer, skipping`);
-                continue;
-            }
-            if (signal.aborted) {
-                logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
-                break;
-            }
-            await processTransfer({
-                casinoId: casinoInfo.id,
-                controllerId: casinoInfo.controller_id,
-                transfer,
-                graphqlClient,
-            });
-            await db.setTransferCursor(superuserPool, {
-                cursor,
-                casinoId: casinoInfo.id,
-            });
-        }
-        hasNextPage = data.transfersByHolder.pageInfo.hasNextPage;
-        afterCursor = data.transfersByHolder.pageInfo.endCursor || undefined;
-        if (signal.aborted) {
-            logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
-            break;
-        }
-        await timeout(1000);
-    }
-    return afterCursor;
-}
-async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
-    if (abortSignal.aborted) {
-        return;
-    }
-    const withdrawals = await db.getPendingWithdrawals(superuserPool, {
-        casinoId,
-        limit: 10,
-    });
-    if (withdrawals.length > 0) {
-        logger.debug(`[sendWithdrawalLoop] withdrawals:`, withdrawals);
-    }
-    for (const withdrawal of withdrawals) {
-        if (abortSignal.aborted) {
-            break;
-        }
-        const response = await graphqlClient.request(MP_COMPLETE_TRANSFER, {
-            mpTransferId: withdrawal.mp_transfer_id,
-        });
-        const __typename = response.completeTransfer?.result.__typename;
-        assert(__typename, `completeTransfer response missing result`);
-        switch (__typename) {
-            case undefined:
-                break;
-            case "CompleteTransferSuccess": {
-                await db.settleWithdrawal({
-                    withdrawalId: withdrawal.id,
-                    newStatus: "COMPLETED",
-                });
-                break;
-            }
-            case "InvalidTransferStatus": {
-                logger.error(`Invalid transfer state for transfer ${withdrawal.mp_transfer_id}: ${response.completeTransfer?.result.message}`);
-                const currentState = response.completeTransfer?.result.currentStatus;
-                assert(currentState, "Expected currentState");
-                switch (currentState) {
-                    case TransferStatusKind.Canceled:
-                    case TransferStatusKind.Completed:
-                        await db.settleWithdrawal({
-                            withdrawalId: withdrawal.id,
-                            newStatus: currentState,
-                        });
-                        continue;
-                    case TransferStatusKind.Pending:
-                    case TransferStatusKind.Unclaimed:
-                    case TransferStatusKind.Expired:
-                        throw new Error(`Withdrawal shouldn't have status: ${currentState}`);
-                    default: {
-                        const exhaustive = currentState;
-                        throw new Error(`Unexpected currentState: ${exhaustive}`);
-                    }
-                }
-            }
-            default: {
-                const exhaustiveCheck = __typename;
-                throw new Error(`Unexpected completeTransfer result: ${exhaustiveCheck}`);
-            }
-        }
-    }
-}
-export function casinoIdsInProcess() {
-    return Array.from(casinoMap.keys());
-}
-export function startTransferProcessor({ casinoId, signal, }) {
+export function startPollingProcessor({ casinoId, signal, }) {
     if (signal.aborted) {
         logger.info(`[startTransferProcessor] AbortSignal aborted. Not starting processor for casino ${casinoId}`);
         return;
     }
     logger.info(`starting processor for casino ${casinoId}`);
-    if (casinoMap.has(casinoId)) {
-        throw new Error(`processor already running for casino ${casinoId}`);
-    }
     const processorState = {
-        emitter: new EventEmitter(),
         backoffTime: MIN_BACKOFF_TIME,
         lastAttempt: 0,
     };
-    casinoMap.set(casinoId, processorState);
     (async () => {
         let cursor = await db.getTransferCursor(superuserPool, {
             casinoId,
@@ -345,7 +69,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
         }
         let upsertedCurrencies = false;
         let shouldStop = false;
-        processorState.emitter.on("once", () => {
+        signal.addEventListener("abort", () => {
             shouldStop = true;
         });
         while (!shouldStop && !signal.aborted) {
@@ -372,7 +96,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
                     apiKey: casinoSecret.api_key,
                 });
                 if (signal.aborted) {
-                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown.`);
+                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (1)`);
                     break;
                 }
                 await jwtService.refreshCasinoJwksTask(superuserPool, {
@@ -381,7 +105,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
                 });
                 if (!upsertedCurrencies) {
                     if (signal.aborted) {
-                        logger.info(`[startTransferProcessor] Aborted by graceful shutdown.`);
+                        logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (2)`);
                         break;
                     }
                     const currencies = await graphqlClient
@@ -398,7 +122,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
                     upsertedCurrencies = true;
                 }
                 if (signal.aborted) {
-                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown.`);
+                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (3)`);
                     break;
                 }
                 cursor = await processTransfersUntilEmpty({
@@ -408,7 +132,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
                     signal,
                 });
                 if (signal.aborted) {
-                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown.`);
+                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (4)`);
                     break;
                 }
                 await processWithdrawals({
@@ -417,7 +141,7 @@ export function startTransferProcessor({ casinoId, signal, }) {
                     graphqlClient,
                 });
                 if (signal.aborted) {
-                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown.`);
+                    logger.info(`[startTransferProcessor] Aborted by graceful shutdown. (5)`);
                     break;
                 }
                 await processTakeRequests({
@@ -435,37 +159,122 @@ export function startTransferProcessor({ casinoId, signal, }) {
             }
         }
         logger.info(`processor stopped for casino ${casinoId}`);
-        casinoMap.delete(casinoId);
     })();
 }
-export function stopTransferProcessor(casinoId) {
-    const processorState = casinoMap.get(casinoId);
-    if (!processorState) {
-        logger.warn(`processor not running for casino ${casinoId}`);
+async function processWithdrawals({ abortSignal, casinoId, graphqlClient, }) {
+    if (abortSignal.aborted) {
         return;
     }
-    processorState.emitter.emit("stop");
-}
-export function initializeTransferProcessors({ signal, }) {
-    (async () => {
-        try {
-            const casinos = await db.listCasinos(superuserPool);
-            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}"`);
-                    continue;
-                }
-                if (config.NODE_ENV === "production" &&
-                    new URL(casino.graphql_url).hostname === "localhost") {
-                    logger.warn(`${casino.id} has localhost endpoint "${casino.graphql_url}" while NODE_ENV=production.`);
+    const withdrawals = await db.getPendingWithdrawals(superuserPool, {
+        casinoId,
+        limit: 10,
+    });
+    if (withdrawals.length > 0) {
+        logger.debug(`[sendWithdrawalLoop] withdrawals:`, withdrawals);
+    }
+    for (const withdrawal of withdrawals) {
+        if (abortSignal.aborted) {
+            break;
+        }
+        const response = await graphqlClient.request(MP_COMPLETE_TRANSFER, {
+            mpTransferId: withdrawal.mp_transfer_id,
+        });
+        const __typename = response.completeTransfer?.result.__typename;
+        assert(__typename, `completeTransfer response missing result`);
+        switch (__typename) {
+            case undefined:
+                break;
+            case "CompleteTransferSuccess": {
+                await db.settleWithdrawal({
+                    withdrawalId: withdrawal.id,
+                    newStatus: "COMPLETED",
+                });
+                break;
+            }
+            case "InvalidTransferStatus": {
+                logger.error(`Invalid transfer state for transfer ${withdrawal.mp_transfer_id}: ${response.completeTransfer?.result.message}`);
+                const currentState = response.completeTransfer?.result.currentStatus;
+                assert(currentState, "Expected currentState");
+                switch (currentState) {
+                    case TransferStatusKind.Canceled:
+                    case TransferStatusKind.Completed:
+                        await db.settleWithdrawal({
+                            withdrawalId: withdrawal.id,
+                            newStatus: currentState,
+                        });
+                        continue;
+                    case TransferStatusKind.Pending:
+                    case TransferStatusKind.Unclaimed:
+                    case TransferStatusKind.Expired:
+                        throw new Error(`Withdrawal shouldn't have status: ${currentState}`);
+                    default: {
+                        const exhaustive = currentState;
+                        throw new Error(`Unexpected currentState: ${exhaustive}`);
+                    }
                 }
-                logger.info(`Starting casino processor for "${casino.name}" at "${casino.graphql_url}"`);
-                startTransferProcessor({ casinoId: casino.id, signal });
             }
-            await listenForNewCasinos({ signal });
+            default: {
+                const exhaustiveCheck = __typename;
+                throw new Error(`Unexpected completeTransfer result: ${exhaustiveCheck}`);
+            }
+        }
+    }
+}
+async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoInfo, signal, }) {
+    let hasNextPage = true;
+    const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
+    while (hasNextPage && !signal.aborted) {
+        await processWithdrawalRequests({
+            casinoId: casinoInfo.id,
+            graphqlClient,
+        });
+        if (signal.aborted) {
+            logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
+            break;
         }
-        catch (e) {
-            logger.error(`Error initializing transfer processors:`, e);
+        const data = await graphqlClient.request(PAGINATE_TRANSFERS, {
+            controllerId: casinoInfo.controller_id,
+            limit: 10,
+            after: afterCursor,
+        });
+        const transfers = data.transfersByHolder?.edges.flatMap((x) => x?.node || []) || [];
+        if (transfers.length === 0) {
+            break;
         }
-    })();
+        else {
+            if (transfers.length > 0) {
+                logger.debug(`processing ${transfers.length} transfers...`);
+            }
+        }
+        for (const transferRef of transfers) {
+            const transfer = useFragment(TRANSFER_FIELDS, transferRef);
+            const cursor = transfer.id;
+            if (transfer.__typename !== "ExperienceTransfer") {
+                logger.error(`transfer ${transfer.id} is not an ExperienceTransfer, skipping`);
+                continue;
+            }
+            if (signal.aborted) {
+                logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
+                break;
+            }
+            await processTransfer({
+                casinoId: casinoInfo.id,
+                controllerId: casinoInfo.controller_id,
+                transfer,
+                graphqlClient,
+            });
+            await db.setTransferCursor(superuserPool, {
+                cursor,
+                casinoId: casinoInfo.id,
+            });
+        }
+        hasNextPage = data.transfersByHolder.pageInfo.hasNextPage;
+        afterCursor = data.transfersByHolder.pageInfo.endCursor || undefined;
+        if (signal.aborted) {
+            logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
+            break;
+        }
+        await timeout(1000);
+    }
+    return afterCursor;
 }