@moneypot/hub 1.22.2 → 1.22.4

package/dist/src/liability/public/db.js

@@ -1,5 +1,9 @@
 import { exactlyOneRow } from "../../db/util.js";
 export async function dbCreateLiability(pgClient, { lockedBankrollId, casinoId, experienceId, userId, currencyKey, refId, refType, maxPayout, deadline, }) {
+    await pgClient.query({
+        text: `SELECT 1 FROM hub.bankroll WHERE id = $1 FOR UPDATE`,
+        values: [lockedBankrollId],
+    });
     const row = await pgClient
         .query({
         text: `
@@ -39,6 +43,17 @@ export async function dbCreateLiability(pgClient, { lockedBankrollId, casinoId,
 }
 export async function dbResolveLiabilityByRef(pgClient, { refType, refId, lockedBankrollId, }) {
     const _proofOfGoodBehavior = lockedBankrollId;
+    await pgClient.query({
+        text: `
+      SELECT 1 FROM hub.bankroll
+      WHERE id = (
+        SELECT bankroll_id FROM hub.liability
+        WHERE ref_type = $1 AND ref_id = $2
+      )
+      FOR UPDATE
+    `,
+        values: [refType, refId],
+    });
     const result = await pgClient.query({
         text: `
       WITH resolved AS (

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

@@ -1,6 +1,6 @@
 import { createClient as createWebsocketClient, } from "graphql-ws";
 import { gql } from "../__generated__/gql.js";
-import { print } from "graphql";
+import { getOperationAST, print } from "graphql";
 import { createGraphqlClient } from "../graphql-client.js";
 import { useFragment } from "../__generated__/fragment-masking.js";
 import { TRANSFER_FIELDS } from "./graphql.js";
@@ -51,6 +51,8 @@ async function mpGetExperienceTransfer(graphqlClient, id) {
     return mpTransfer;
 }
 export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controllerId, apiKey, pool, }) {
+    if (signal.aborted)
+        return;
     logger.info(`Starting websocket processor for ${graphqlUrl}`);
     const client = createWebsocketClient({
         url: httpToWs(new URL(graphqlUrl)).toString(),
@@ -63,9 +65,7 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
         },
         keepAlive: 1_000,
         retryWait: async (retries) => {
-            const baseDelay = Math.min(1000 * Math.pow(2, retries), 30_000);
-            const jitter = Math.floor(Math.random() * 10_000);
-            await abortableTimeout(baseDelay + jitter, signal);
+            await abortableTimeout(backoffDelayMs(retries), signal);
         },
     });
     client.on("connected", () => {
@@ -78,60 +78,83 @@ export function startWebsocketProcessor({ casinoId, graphqlUrl, signal, controll
         logger.error(error, `[websocketProcessor] Error on websocket ${graphqlUrl}`);
     });
     const graphqlClient = createGraphqlClient({ graphqlUrl, apiKey });
-    const dispose1 = createSubscription(client, MP_NEW_EXPERIENCE_TRANSFER, async (result) => {
-        const transferId = result.data?.newExperienceTransfer?.id;
-        if (!transferId) {
-            logger.warn(result, `Weird, no transfer id in websocket 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}`);
-        await processTransfer({
-            casinoId,
-            controllerId,
-            transfer: mpTransfer,
-            graphqlClient,
-            pool,
-        });
-    });
-    const dispose2 = createSubscription(client, MP_NEW_TAKE_REQUEST, async (result) => {
-        const mpTakeRequestId = result.data?.newTakeRequest?.id;
-        if (!mpTakeRequestId) {
-            logger.warn(result, `Weird, no take request id in websocket 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;
-        }
-        await processSingleTakeRequest({
-            mpTakeRequestId,
-            mpTakeRequest,
-            casinoId,
-            graphqlClient,
-            pool,
-        });
-    });
-    signal.addEventListener("abort", () => {
-        dispose1();
-        dispose2();
-    });
-}
-function createSubscription(client, query, handler) {
-    return client.subscribe({ query: print(query) }, {
-        next: (result) => {
-            handler(result).catch((e) => {
-                logger.error(e, `Error while handling websocket result`);
+    keepSubscribed({
+        client,
+        query: MP_NEW_EXPERIENCE_TRANSFER,
+        signal,
+        idOf: (result) => result.data?.newExperienceTransfer?.id,
+        handleId: async (transferId) => {
+            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}`);
+            await processTransfer({
+                casinoId,
+                controllerId,
+                transfer: mpTransfer,
+                graphqlClient,
+                pool,
             });
         },
-        error: (err) => {
-            logger.error(err, `Error during WebSocket subscription`);
+    });
+    keepSubscribed({
+        client,
+        query: MP_NEW_TAKE_REQUEST,
+        signal,
+        idOf: (result) => result.data?.newTakeRequest?.id,
+        handleId: async (mpTakeRequestId) => {
+            const mpTakeRequest = await mpGetTakeRequest(graphqlClient, mpTakeRequestId);
+            if (!mpTakeRequest) {
+                logger.warn(`No take request found in casino api for mp take request id ${mpTakeRequestId}`);
+                return;
+            }
+            await processSingleTakeRequest({
+                mpTakeRequestId,
+                mpTakeRequest,
+                casinoId,
+                graphqlClient,
+                pool,
+            });
         },
-        complete: () => logger.info("Subscription closed"),
     });
 }
+function backoffDelayMs(attempt) {
+    const baseDelay = Math.min(1000 * Math.pow(2, attempt), 30_000);
+    const jitter = Math.floor(Math.random() * 10_000);
+    return baseDelay + jitter;
+}
+function keepSubscribed({ client, query, signal, idOf, handleId, }) {
+    const name = getOperationAST(query)?.name?.value ?? "subscription";
+    let attempt = 0;
+    let dispose = () => { };
+    const ended = (how, err) => {
+        if (signal.aborted)
+            return;
+        const delay = backoffDelayMs(attempt++);
+        logger.warn({ err }, `[websocketProcessor] Casino ended ${name} with ${how}, resubscribing in ${delay}ms`);
+        abortableTimeout(delay, signal).then(subscribe);
+    };
+    const subscribe = () => {
+        if (signal.aborted)
+            return;
+        dispose = client.subscribe({ query: print(query) }, {
+            next: (result) => {
+                const id = idOf(result);
+                if (!id) {
+                    logger.warn(result, `Weird, no id in ${name} websocket result`);
+                    return;
+                }
+                attempt = 0;
+                handleId(id).catch((e) => {
+                    logger.error(e, `Error while handling websocket result`);
+                });
+            },
+            error: (err) => ended("error", err),
+            complete: () => ended("complete"),
+        });
+    };
+    signal.addEventListener("abort", () => dispose(), { once: true });
+    subscribe();
+}

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

@@ -178,13 +178,18 @@ export async function processTakeRequests({ abortSignal, controllerId, casinoId,
         if (abortSignal.aborted) {
             break;
         }
-        await processSingleTakeRequest({
-            mpTakeRequestId: takeRequest.id,
-            mpTakeRequest: takeRequest,
-            casinoId,
-            graphqlClient,
-            pool,
-        });
+        try {
+            await processSingleTakeRequest({
+                mpTakeRequestId: takeRequest.id,
+                mpTakeRequest: takeRequest,
+                casinoId,
+                graphqlClient,
+                pool,
+            });
+        }
+        catch (error) {
+            logger.error(error, `[processTakeRequests] Failed to process take request ${takeRequest.id}`);
+        }
     }
     await processPendingTransferCompletions({
         casinoId,
@@ -252,7 +257,11 @@ async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoI
         currencyKey: mpTakeRequest.currencyKey,
         casinoId,
     });
-    assert(dbUser && dbExperience && dbCurrency && dbBalance, "Required entities not found");
+    if (!dbUser || !dbExperience || !dbCurrency || !dbBalance) {
+        logger.warn(`[createAndProcessNewTakeRequest] Rejecting take request ${mpTakeRequest.id}: no hub balance`);
+        await rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequest.id);
+        return null;
+    }
     const amountToTransfer = Math.floor(typeof mpTakeRequest.amount === "number"
         ? Math.min(mpTakeRequest.amount, dbBalance.amount)
         : dbBalance.amount);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moneypot/hub",
-  "version": "1.22.2",
+  "version": "1.22.4",
   "author": "moneypot.com",
   "homepage": "https://moneypot.com/hub",
   "keywords": [