@moneypot/hub 1.5.1 → 1.6.0-dev.0

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

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

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

@@ -0,0 +1,151 @@
+import * as db from "../db/index.js";
+import { TransferStatusKind, } from "../__generated__/graphql.js";
+import { superuserPool } from "../db/index.js";
+import { gql } from "../__generated__/gql.js";
+import { logger } from "../logger.js";
+import { assert } from "tsafe";
+export 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
+        }
+      }
+    }
+  }
+`);
+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
+        }
+      }
+    }
+  }
+`);
+export 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({
+                    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({
+                    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:
+                await db.settleWithdrawal({
+                    withdrawalId: transfer.id,
+                    newStatus: "CANCELED",
+                });
+                return;
+            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}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }: {
+    casinoId: string;
+    graphqlUrl: string;
+    signal: AbortSignal;
+    controllerId: string;
+    apiKey: string;
+}): void;

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

@@ -0,0 +1,133 @@
+import { createClient as createWebsocketClient, } from "graphql-ws";
+import { gql } from "../__generated__/gql.js";
+import { print } from "graphql";
+import { createGraphqlClient } from "../graphql-client.js";
+import { useFragment } from "../__generated__/fragment-masking.js";
+import { TRANSFER_FIELDS } from "./graphql.js";
+import { logger } from "../logger.js";
+import { processTransfer } from "./process-transfer.js";
+import assert from "assert";
+import { mpGetTakeRequest, processSingleTakeRequest, } from "../take-request/process-take-request.js";
+function httpToWs(url) {
+    if (url.protocol === "http:") {
+        url.protocol = "ws:";
+    }
+    else if (url.protocol === "https:") {
+        url.protocol = "wss:";
+    }
+    return url;
+}
+const MP_NEW_EXPERIENCE_TRANSFER = gql(`
+  subscription MpNewExperienceTransfer {
+    newExperienceTransfer {
+      id
+    }
+  }
+`);
+const MP_GET_EXPERIENCE_TRANSFER = gql(`
+  query MpGetExperienceTransfer($id: UUID!) {
+    experienceTransferById(id: $id) {
+      ...TransferFields
+    }
+  }
+`);
+const MP_NEW_TAKE_REQUEST = gql(`
+  subscription MpNewTakeRequest {
+    newTakeRequest {
+      id
+    }
+  }
+`);
+async function mpGetExperienceTransfer(graphqlClient, id) {
+    const result = await graphqlClient.request(MP_GET_EXPERIENCE_TRANSFER, {
+        id,
+    });
+    const x = result.experienceTransferById;
+    if (!x) {
+        return null;
+    }
+    const mpTransfer = useFragment(TRANSFER_FIELDS, x);
+    return mpTransfer;
+}
+export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, }) {
+    console.log(`Starting websocket processor for ${graphqlUrl} using apiKey ${apiKey}`);
+    const client = createWebsocketClient({
+        url: httpToWs(new URL(graphqlUrl)).toString(),
+        connectionParams: {
+            authorization: `apikey:${apiKey}`,
+        },
+        retryAttempts: Infinity,
+        shouldRetry: () => {
+            return true;
+        },
+        keepAlive: 1_000,
+    });
+    client.on("connected", () => {
+        logger.info(`[websocketProcessor] Connected to websocket ${graphqlUrl}`);
+    });
+    client.on("closed", () => {
+        logger.info(`[websocketProcessor] Disconnected from websocket ${graphqlUrl}`);
+    });
+    client.on("error", (error) => {
+        logger.error(`[websocketProcessor] Error on websocket ${graphqlUrl}`, error);
+    });
+    const graphqlClient = createGraphqlClient({ graphqlUrl, apiKey });
+    const dispose1 = createSubscription(client, MP_NEW_EXPERIENCE_TRANSFER, async (result) => {
+        console.log(`😎 Get transfer from websocket`, result);
+        const transferId = result.data?.newExperienceTransfer?.id;
+        if (!transferId) {
+            logger.warn(`Weird, no transfer id in websocket result`, result);
+            return;
+        }
+        const mpTransfer = await mpGetExperienceTransfer(graphqlClient, transferId);
+        if (!mpTransfer) {
+            logger.warn(`No experience transfer found in casino api for mp transfer id ${transferId}`);
+            return;
+        }
+        assert(mpTransfer.__typename === "ExperienceTransfer", `Expected experience transfer but got ${mpTransfer.__typename}`);
+        console.log(`🎉 Loaded transfer from MP API`, mpTransfer);
+        processTransfer({
+            casinoId,
+            controllerId,
+            transfer: mpTransfer,
+            graphqlClient,
+        });
+    });
+    const dispose2 = createSubscription(client, MP_NEW_TAKE_REQUEST, async (result) => {
+        console.log(`😎 Get take request from websocket`, result);
+        const mpTakeRequestId = result.data?.newTakeRequest?.id;
+        if (!mpTakeRequestId) {
+            logger.warn(`Weird, no take request id in websocket result`, result);
+            return;
+        }
+        const mpTakeRequest = await mpGetTakeRequest(graphqlClient, mpTakeRequestId);
+        if (!mpTakeRequest) {
+            logger.warn(`No take request found in casino api for mp take request id ${mpTakeRequestId}`);
+            return;
+        }
+        console.log(`🎉 Loaded take request from MP API`, mpTakeRequest);
+        await processSingleTakeRequest({
+            mpTakeRequestId,
+            mpTakeRequest,
+            casinoId,
+            graphqlClient,
+        });
+    });
+    signal.addEventListener("abort", () => {
+        dispose1();
+        dispose2();
+    });
+}
+function createSubscription(client, query, handler) {
+    return client.subscribe({ query: print(query) }, {
+        next: (result) => {
+            handler(result).catch((e) => {
+                console.error(`Error while handling websocket result`, e);
+            });
+        },
+        error: (err) => {
+            console.error(`Error during WebSocket subscription`, err);
+        },
+        complete: () => console.log("Subscription closed"),
+    });
+}

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

@@ -2,7 +2,6 @@ import { z } from "zod";
 import * as jose from "jose";
 import { gql } from "../__generated__/gql.js";
 import { maybeOneRow } from "../db/util.js";
-import { logger } from "../logger.js";
 const CACHE_TTL = "5 minutes";
 const GET_CASINO_JWKS = gql(`
   query GetCasinoJWKS {
@@ -22,7 +21,6 @@ const JSONWebKeySetSchema = z.object({
         .min(1),
 });
 async function dbInsertCasinoJWKS(pgClient, { casinoId, jwks: unvalidatedJwks, }) {
-    logger.debug(`[dbInsertCasinoJWKS] Inserting JWKS for casino ${casinoId}`, unvalidatedJwks);
     const result = JSONWebKeySetSchema.safeParse(unvalidatedJwks);
     if (!result.success) {
         throw new Error(`Will not insert invalid JWKS into database: ${result.error}`);
@@ -60,9 +58,7 @@ async function dbGetCasinoJWKS(pgClient, { casinoId }) {
     return jwks ?? null;
 }
 async function mpFetchCasinoJWKS(graphqlClient) {
-    console.log("sending request to casino");
     const response = await graphqlClient.request(GET_CASINO_JWKS);
-    console.log("response", response);
     const jwks = response.jwks;
     if (jwks.keys.length === 0) {
         throw new Error("No JWKS keys found in response");

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

@@ -1,7 +1,16 @@
 import { GraphQLClient } from "graphql-request";
+import { MpTakeRequestFieldsFragment } from "../__generated__/graphql.js";
+export declare const MP_TAKE_REQUEST_FIELDS: import("@graphql-typed-document-node/core").TypedDocumentNode<MpTakeRequestFieldsFragment, unknown>;
+export declare function mpGetTakeRequest(graphqlClient: GraphQLClient, id: string): Promise<MpTakeRequestFieldsFragment | null>;
 export declare function processTakeRequests({ abortSignal, controllerId, casinoId, graphqlClient, }: {
     abortSignal: AbortSignal;
     controllerId: string;
     casinoId: string;
     graphqlClient: GraphQLClient;
 }): Promise<void>;
+export declare function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }: {
+    mpTakeRequestId: string;
+    mpTakeRequest?: MpTakeRequestFieldsFragment;
+    casinoId: string;
+    graphqlClient: GraphQLClient;
+}): Promise<string | null>;

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

@@ -3,6 +3,35 @@ import { TakeRequestStatus as MpTakeRequestStatus, TransferStatusKind as MpTrans
 import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
 import { PgAdvisoryLock } from "../pg-advisory-lock.js";
+import { useFragment } from "../__generated__/fragment-masking.js";
+import { logger } from "../logger.js";
+export const MP_TAKE_REQUEST_FIELDS = gql(`
+  fragment MpTakeRequestFields on TakeRequest {
+    id
+    status
+    amount
+    currencyKey
+    userId
+    experienceId
+    experienceTransfer {
+      id
+      amount
+    }
+  }
+`);
+const MP_GET_TAKE_REQUEST = gql(`
+  query MpGetTakeRequest($id: UUID!) {
+    takeRequestById(id: $id) {
+      ...MpTakeRequestFields
+    }
+  }
+`);
+export async function mpGetTakeRequest(graphqlClient, id) {
+    const result = await graphqlClient.request(MP_GET_TAKE_REQUEST, { id });
+    return result.takeRequestById
+        ? useFragment(MP_TAKE_REQUEST_FIELDS, result.takeRequestById)
+        : null;
+}
 const MP_PAGINATE_PENDING_TAKE_REQUESTS = gql(`
   query MpPaginatedPendingTakeRequests($controllerId: UUID!, $after: Cursor) {
     allTakeRequests(
@@ -17,16 +46,7 @@ const MP_PAGINATE_PENDING_TAKE_REQUESTS = gql(`
       edges {
         cursor
         node {
-          id
-          status
-          amount
-          currencyKey
-          userId
-          experienceId
-          experienceTransfer {
-            id
-            amount
-          }
+          ...MpTakeRequestFields
         }
       }
     }
@@ -151,7 +171,6 @@ export async function processTakeRequests({ abortSignal, controllerId, casinoId,
         return;
     }
     const takeRequests = await fetchPendingTakeRequests(graphqlClient, controllerId);
-    console.log(`[processTakeRequests] Found ${takeRequests.length} take requests`);
     for (const takeRequest of takeRequests) {
         if (abortSignal.aborted) {
             break;
@@ -174,9 +193,14 @@ async function fetchPendingTakeRequests(graphqlClient, controllerId) {
     const result = await graphqlClient.request(MP_PAGINATE_PENDING_TAKE_REQUESTS, {
         controllerId,
     });
-    return (result.allTakeRequests?.edges.flatMap((edge) => edge?.node || []) || []);
+    return (result.allTakeRequests?.edges.flatMap((edge) => {
+        const takeRequest = edge?.node;
+        if (!takeRequest)
+            return [];
+        return useFragment(MP_TAKE_REQUEST_FIELDS, takeRequest);
+    }) || []);
 }
-async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }) {
+export async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }) {
     return withPgPoolTransaction(superuserPool, async (pgClient) => {
         await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
             mpTakeRequestId,
@@ -441,7 +465,9 @@ async function processPendingTransferCompletions({ casinoId, graphqlClient, abor
         values: [casinoId],
     })
         .then((result) => result.rows);
-    console.log(`[processPendingTransferCompletions] Found ${pendingCompletions.length} transfers needing completion`);
+    if (pendingCompletions.length > 0) {
+        logger.info(`[processPendingTransferCompletions] Found ${pendingCompletions.length} transfers needing completion`);
+    }
     for (const request of pendingCompletions) {
         if (abortSignal.aborted) {
             break;
@@ -581,7 +607,9 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, }) {
         values: [casinoId, LocalTakeRequestStatus.PROCESSING],
     })
         .then((result) => result.rows);
-    console.log(`[processStuckRequests] Found ${stuckRequests.length} stuck take requests`);
+    if (stuckRequests.length > 0) {
+        logger.info(`[processStuckRequests] Found ${stuckRequests.length} stuck take requests`);
+    }
     for (const request of stuckRequests) {
         if (abortSignal.aborted) {
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.5.1",
+  "version": "1.6.0-dev.0",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [
@@ -49,6 +49,7 @@
     "express": "^5.0.1",
     "graphql": "^16.8.1",
     "graphql-request": "^7.0.0",
+    "graphql-ws": "^6.0.5",
     "jose": "^6.0.11",
     "pg": "^8.12.0",
     "pg-connection-string": "^2.6.4",
@@ -63,7 +64,7 @@
     "@graphql-codegen/client-preset": "^4.2.5",
     "@graphql-typed-document-node/core": "^3.2.0",
     "@types/express": "^5.0.0",
-    "@types/node": "^22.1.0",
+    "@types/node": "^24.0.3",
     "@types/pg": "^8.11.5",
     "eslint": "^9.8.0",
     "globals": "^16.0.0",

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

@@ -1,10 +0,0 @@
-import * as db from "./db/index.js";
-export declare function casinoIdsInProcess(): string[];
-export declare function startTransferProcessor({ casinoId, signal, }: {
-    casinoId: db.DbCasino["id"];
-    signal: AbortSignal;
-}): void;
-export declare function stopTransferProcessor(casinoId: string): void;
-export declare function initializeTransferProcessors({ signal, }: {
-    signal: AbortSignal;
-}): void;