@moneypot/hub 1.22.0 → 1.22.2

package/dist/src/hash-chain/get-hash.js

@@ -4,6 +4,14 @@ const HASH_HERALD_OPTIONS = {
     baseUrl: config.HASHCHAINSERVER_URL,
     applicationSecret: config.HASHCHAINSERVER_APPLICATION_SECRET,
 };
+const HASH_HERALD_TIMEOUT_MS = 10_000;
+function getHashWithTimeout(req) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`hash-herald did not answer within ${HASH_HERALD_TIMEOUT_MS}ms`)), HASH_HERALD_TIMEOUT_MS);
+    });
+    return Promise.race([getHash(HASH_HERALD_OPTIONS, req), timeout]).finally(() => clearTimeout(timer));
+}
 function resultFromGetHashResponse(response) {
     if (!response.resp) {
         return { type: "bad_hash_chain", reason: "empty_response" };
@@ -26,7 +34,7 @@ export async function getIntermediateHash({ hashChainId, iteration, }) {
         iterations: iteration,
         context: undefined,
     };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
+    return getHashWithTimeout(req).then(resultFromGetHashResponse);
 }
 export async function getPreimageHash({ hashChainId, }) {
     const req = {
@@ -39,7 +47,7 @@ export async function getPreimageHash({ hashChainId, }) {
             },
         },
     };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
+    return getHashWithTimeout(req).then(resultFromGetHashResponse);
 }
 export async function getTerminalHash({ hashChainId, }) {
     const iterations = config.HASHCHAINSERVER_MAX_ITERATIONS;
@@ -53,5 +61,5 @@ export async function getTerminalHash({ hashChainId, }) {
             },
         },
     };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
+    return getHashWithTimeout(req).then(resultFromGetHashResponse);
 }

package/dist/src/liability/internal/processor.d.ts

@@ -2,8 +2,10 @@ import * as pg from "pg";
 import { type PgClientInTransaction } from "../../db/transaction.js";
 import { LiabilityConfigInternal } from "../public/config.js";
 import { QueryExecutor } from "../../db/util.js";
-export declare function dbGetLiabilityIdsPastDeadline(pgClient: QueryExecutor, { limit }?: {
+export declare function dbGetLiabilityIdsPastDeadline(pgClient: QueryExecutor, { limit, excludeIds, before, }?: {
     limit?: number;
+    excludeIds?: string[];
+    before?: Date;
 }): Promise<string[]>;
 export declare function startLiabilityDeadlineProcessor<RefType extends string>({ signal, pool, liabilityConfig, }: {
     signal: AbortSignal;
@@ -14,8 +16,11 @@ export declare function processOneDeadlinedLiability<RefType extends string>(pgC
     liabilityConfig: LiabilityConfigInternal<RefType>;
     liabilityId: string;
 }): Promise<void>;
-export declare function processDeadlinedLiabilities<RefType extends string>({ pool, liabilityConfig, signal, }: {
+export declare function processDeadlinedLiabilities<RefType extends string>({ pool, liabilityConfig, signal, batchSize, }: {
     pool: pg.Pool;
     liabilityConfig: LiabilityConfigInternal<RefType>;
     signal: AbortSignal;
-}): Promise<void>;
+    batchSize?: number;
+}): Promise<{
+    failed: number;
+}>;

package/dist/src/liability/internal/processor.js

@@ -4,17 +4,18 @@ import { dbLockHouseBankroll, dbLockPlayerBalance } from "../../db/public.js";
 import { exactlyOneRow, maybeOneRow } from "../../db/util.js";
 import { abortableTimeout } from "../../util.js";
 const BATCH_SIZE = 100;
-export async function dbGetLiabilityIdsPastDeadline(pgClient, { limit = 100 } = {}) {
+export async function dbGetLiabilityIdsPastDeadline(pgClient, { limit = 100, excludeIds = [], before = new Date(), } = {}) {
     const result = await pgClient.query({
         text: `
       SELECT id
       FROM hub.liability
       WHERE resolved_at IS NULL
-        AND deadline < now()
+        AND deadline < $3
+        AND NOT (id = ANY($2::uuid[]))
       ORDER BY deadline ASC
       LIMIT $1
     `,
-        values: [limit],
+        values: [limit, excludeIds, before],
     });
     return result.rows.map((r) => r.id);
 }
@@ -89,46 +90,55 @@ export async function processOneDeadlinedLiability(pgClient, { liabilityConfig,
         logger.error(`No house bankroll found for liability ${dbLockedLiability.id}.`);
         return;
     }
-    try {
-        await refTypeConfig.handleDeadline({
-            pgClientInTransaction: pgClient,
-            lockedLiability: dbLockedLiability,
-            lockedPlayerBalance: dbLockedPlayerBalance,
-            lockedHouseBankroll: dbLockedHouseBankroll,
-            liabilityConfig: liabilityConfig,
-        });
-        const { resolved_at } = await pgClient
-            .query(`SELECT resolved_at FROM hub.liability WHERE id = $1`, [dbLockedLiability.id])
-            .then(exactlyOneRow);
-        if (!resolved_at) {
-            throw new Error(`Handler returned LIABILITY_RESOLVED but did not resolve liability ${dbLockedLiability.id} (ref_type: ${dbLockedLiability.ref_type}, ref_id: ${dbLockedLiability.ref_id}). ` +
-                `Handler must call dbResolveLiabilityByRef before returning.`);
-        }
-        logger.debug(`Resolved liability ${dbLockedLiability.id}`);
-    }
-    catch (e) {
-        logger.error(e, `Error handling deadline for liability ${dbLockedLiability.id}`);
-        throw e;
-    }
-}
-export async function processDeadlinedLiabilities({ pool, liabilityConfig, signal, }) {
-    const liabilityIds = await dbGetLiabilityIdsPastDeadline(pool, {
-        limit: BATCH_SIZE,
+    await refTypeConfig.handleDeadline({
+        pgClientInTransaction: pgClient,
+        lockedLiability: dbLockedLiability,
+        lockedPlayerBalance: dbLockedPlayerBalance,
+        lockedHouseBankroll: dbLockedHouseBankroll,
+        liabilityConfig: liabilityConfig,
     });
-    if (liabilityIds.length === 0) {
-        return;
+    const { resolved_at } = await pgClient
+        .query(`SELECT resolved_at FROM hub.liability WHERE id = $1`, [dbLockedLiability.id])
+        .then(exactlyOneRow);
+    if (!resolved_at) {
+        throw new Error(`Handler returned LIABILITY_RESOLVED but did not resolve liability ${dbLockedLiability.id} (ref_type: ${dbLockedLiability.ref_type}, ref_id: ${dbLockedLiability.ref_id}). ` +
+            `Handler must call dbResolveLiabilityByRef before returning.`);
     }
-    logger.info(`Processor found ${liabilityIds.length} liability candidates...`);
-    for (const liabilityId of liabilityIds) {
-        if (signal.aborted) {
-            logger.info(`[processExpiredLiabilities] Aborted by graceful shutdown.`);
+    logger.debug(`Resolved liability ${dbLockedLiability.id}`);
+}
+export async function processDeadlinedLiabilities({ pool, liabilityConfig, signal, batchSize = BATCH_SIZE, }) {
+    const before = new Date();
+    const tried = [];
+    let failed = 0;
+    while (!signal.aborted) {
+        const liabilityIds = await dbGetLiabilityIdsPastDeadline(pool, {
+            limit: batchSize,
+            excludeIds: tried,
+            before,
+        });
+        if (liabilityIds.length === 0) {
             break;
         }
-        await withPgPoolTransaction(pool, async (pgClient) => {
-            await processOneDeadlinedLiability(pgClient, {
-                liabilityConfig,
-                liabilityId,
-            });
-        });
+        logger.info(`Processor found ${liabilityIds.length} liability candidates...`);
+        for (const liabilityId of liabilityIds) {
+            if (signal.aborted) {
+                logger.info(`[processExpiredLiabilities] Aborted by graceful shutdown.`);
+                break;
+            }
+            tried.push(liabilityId);
+            try {
+                await withPgPoolTransaction(pool, async (pgClient) => {
+                    await processOneDeadlinedLiability(pgClient, {
+                        liabilityConfig,
+                        liabilityId,
+                    });
+                });
+            }
+            catch (e) {
+                failed++;
+                logger.error({ err: e, liabilityId }, `Error handling deadline for liability ${liabilityId}`);
+            }
+        }
     }
+    return { failed };
 }

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

@@ -8,9 +8,16 @@ export async function dbCreateLiability(pgClient, { lockedBankrollId, casinoId,
           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
           RETURNING *
         ),
+        -- Sub-statements share one snapshot, so the sum can't see the
+        -- inserted row; its payout is added separately.
         bankroll_update AS (
           UPDATE hub.bankroll
-          SET liability = liability + $8
+          SET liability = $8 + (
+            SELECT COALESCE(SUM(max_payout), 0)
+            FROM hub.liability
+            WHERE bankroll_id = $1
+              AND resolved_at IS NULL
+          )
           WHERE id = $1
         )
         SELECT * FROM inserted
@@ -40,10 +47,18 @@ export async function dbResolveLiabilityByRef(pgClient, { refType, refId, locked
         WHERE ref_type = $1
           AND ref_id = $2
           AND resolved_at IS NULL
-        RETURNING bankroll_id, max_payout
+        RETURNING id, bankroll_id
       )
+      -- The sum reads the statement's snapshot, where the resolved row is
+      -- still active, so it is excluded by id.
       UPDATE hub.bankroll
-      SET liability = liability - resolved.max_payout
+      SET liability = (
+        SELECT COALESCE(SUM(l.max_payout), 0)
+        FROM hub.liability l
+        WHERE l.bankroll_id = resolved.bankroll_id
+          AND l.resolved_at IS NULL
+          AND l.id <> resolved.id
+      )
       FROM resolved
       WHERE hub.bankroll.id = resolved.bankroll_id
     `,

package/package.json

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