@moneypot/hub 1.16.0 → 1.16.1

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

@@ -2,21 +2,19 @@ import * as pg from "pg";
 import stream from "node:stream";
 import { DbCasino, DbExperience, DbSession, DbTransferStatusKind, DbUser, DbWithdrawal } from "./types.js";
 import { TransferStatusKind } from "../__generated__/graphql.js";
+import { PgClientInTransaction } from "./transaction.js";
 export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
 export declare function getPgClient(connectionString: string): InstanceType<typeof pg.Client>;
+export * from "./transaction.js";
 export interface QueryExecutor {
     query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }
 export declare class UserFriendlyError extends Error {
     constructor(userFriendlyMessage: string);
 }
-export type PgClientInTransaction = pg.PoolClient & {
-    _inTransaction: true;
-};
-export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (_pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
 export declare function userFromActiveSessionKey(pgClient: QueryExecutor, sessionKey: string): Promise<{
     user: DbUser;
     sessionId: DbSession["id"];

package/dist/src/db/index.js

@@ -2,9 +2,9 @@ import * as pg from "pg";
 import stream from "node:stream";
 import { exactlyOneRow, maybeOneRow } from "./util.js";
 import { logger } from "../logger.js";
-import { setTimeout } from "node:timers/promises";
 import { assert } from "tsafe";
 import { insertAuditLog } from "../audit-log.js";
+import { withPgPoolTransaction } from "./transaction.js";
 export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
@@ -13,61 +13,13 @@ export function getPgClient(connectionString) {
     const client = new pg.Client({ connectionString });
     return client;
 }
+export * from "./transaction.js";
 export class UserFriendlyError extends Error {
     constructor(userFriendlyMessage) {
         super(userFriendlyMessage);
         this.name = "UserFriendlyError";
     }
 }
-const PG_ERROR_CODE = {
-    deadlock: "40P01",
-    serializationFailure: "40001",
-};
-export async function withPgPoolTransaction(pool, callback, retryCount = 0, maxRetries = 3) {
-    let pgClient = null;
-    try {
-        pgClient = await pool.connect();
-        await pgClient.query("begin isolation level serializable");
-        Object.defineProperty(pgClient, "_inTransaction", {
-            value: true,
-            writable: false,
-            enumerable: false,
-            configurable: false,
-        });
-        const result = await callback(pgClient);
-        await pgClient.query("commit");
-        return result;
-    }
-    catch (error) {
-        if (pgClient) {
-            try {
-                await pgClient.query("rollback");
-            }
-            catch (rollbackError) {
-                logger.error(error, "Original error");
-                logger.error(rollbackError, "Rollback failed");
-                pgClient.release(true);
-                pgClient = null;
-                throw error;
-            }
-            if (retryCount < maxRetries &&
-                error instanceof pg.DatabaseError &&
-                (error.code === PG_ERROR_CODE.deadlock ||
-                    error.code === PG_ERROR_CODE.serializationFailure)) {
-                const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
-                logger.warn(`Retrying transaction in ${Math.floor(backoffMs)}ms (attempt ${retryCount + 2}/${maxRetries + 1}) due to pg error code ${error.code}: ${error.message}`);
-                await setTimeout(backoffMs);
-                return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
-            }
-        }
-        throw error;
-    }
-    finally {
-        if (pgClient) {
-            pgClient.release();
-        }
-    }
-}
 export async function userFromActiveSessionKey(pgClient, sessionKey) {
     const result = await pgClient
         .query(`
@@ -186,10 +138,10 @@ export async function insertDeposit(pool, o) {
     if (o.amount <= 0) {
         throw new UserFriendlyError("amount must be positive");
     }
-    return withPgPoolTransaction(pool, async (client) => {
+    return withPgPoolTransaction(pool, async (pgClient) => {
         let dbDeposit;
         try {
-            dbDeposit = await client
+            dbDeposit = await pgClient
                 .query(`
         INSERT INTO hub.deposit(casino_id, mp_transfer_id, user_id, experience_id, amount, currency_key)
         VALUES ($1, $2, $3, $4, $5, $6)
@@ -214,19 +166,35 @@ export async function insertDeposit(pool, o) {
             }
             throw e;
         }
-        const dbBalance = await client
+        await pgClient.query(`
+      INSERT INTO hub.balance (casino_id, user_id, experience_id, currency_key, amount)
+      VALUES ($1, $2, $3, $4, 0)
+      ON CONFLICT (casino_id, user_id, experience_id, currency_key) DO NOTHING
+      `, [o.casinoId, o.userId, o.experienceId, o.currency]);
+        const dbLockedBalance = await pgClient
             .query(`
-        insert into hub.balance(casino_id, user_id, experience_id, currency_key, amount)
-        values ($1, $2, $3, $4, $5)
-        on conflict (casino_id, user_id, experience_id, currency_key) do update
-        set amount = balance.amount + excluded.amount
-        returning id, amount
-      `, [o.casinoId, o.userId, o.experienceId, o.currency, o.amount])
+  SELECT id, amount
+  FROM hub.balance 
+  WHERE casino_id = $1
+    AND user_id = $2
+    AND experience_id = $3
+    AND currency_key = $4
+
+  FOR UPDATE
+  `, [o.casinoId, o.userId, o.experienceId, o.currency])
+            .then(exactlyOneRow);
+        const dbBalanceAfterUpdate = await pgClient
+            .query(`
+        UPDATE hub.balance
+        SET amount = amount + $1
+        WHERE id = $2
+        RETURNING id, amount
+      `, [o.amount, dbLockedBalance.id])
             .then(exactlyOneRow);
-        await insertAuditLog(client, "player-balance", {
-            balanceId: dbBalance.id,
-            balanceOld: dbBalance.amount - o.amount,
-            balanceNew: dbBalance.amount,
+        await insertAuditLog(pgClient, "player-balance", {
+            balanceId: dbLockedBalance.id,
+            balanceOld: dbLockedBalance.amount,
+            balanceNew: dbBalanceAfterUpdate.amount,
             balanceDelta: o.amount,
             action: "hub:deposit",
             refType: "hub.deposit",
@@ -235,7 +203,6 @@ export async function insertDeposit(pool, o) {
     });
 }
 export async function processWithdrawal(pgClient, { casinoId, mpTransferId, userId, experienceId, amount, currency, status, }) {
-    assert(pgClient._inTransaction, "pgClient must be in transaction");
     await pgClient.query(`
       INSERT INTO hub.withdrawal (
         casino_id, 

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

@@ -0,0 +1,17 @@
+import * as pg from "pg";
+declare const PgClientInTransactionBrand: unique symbol;
+export type PgClientInTransaction = pg.PoolClient & {
+    readonly [PgClientInTransactionBrand]: true;
+};
+export declare function isInTransaction(pgClient: pg.PoolClient): pgClient is PgClientInTransaction;
+export declare function assertInTransaction(pgClient: pg.PoolClient): asserts pgClient is PgClientInTransaction;
+export declare function getIsolationLevel(pgClient: PgClientInTransaction): IsolationLevel | null;
+export declare const IsolationLevel: {
+    readonly READ_COMMITTED: "READ COMMITTED";
+    readonly REPEATABLE_READ: "REPEATABLE READ";
+    readonly SERIALIZABLE: "SERIALIZABLE";
+};
+export type IsolationLevel = (typeof IsolationLevel)[keyof typeof IsolationLevel];
+export declare function withPgPoolTransaction<T>(pool: pg.Pool, callback: (pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
+export declare function withPgPoolTransaction<T>(pool: pg.Pool, isolationLevel: IsolationLevel, callback: (pgClient: PgClientInTransaction) => Promise<T>, retryCount?: number, maxRetries?: number): Promise<T>;
+export {};

package/dist/src/db/transaction.js

@@ -0,0 +1,93 @@
+import * as pg from "pg";
+import { logger } from "../logger.js";
+import { setTimeout } from "node:timers/promises";
+const PgClientInTransactionBrand = Symbol("PgClientInTransaction");
+const PG_ERROR_CODE = {
+    deadlock: "40P01",
+    serializationFailure: "40001",
+};
+const SIDECAR = new WeakMap();
+export function isInTransaction(pgClient) {
+    return SIDECAR.has(pgClient);
+}
+export function assertInTransaction(pgClient) {
+    if (!isInTransaction(pgClient)) {
+        throw new Error("Must be called inside a transaction");
+    }
+}
+export function getIsolationLevel(pgClient) {
+    return SIDECAR.get(pgClient) ?? null;
+}
+export const IsolationLevel = {
+    READ_COMMITTED: "READ COMMITTED",
+    REPEATABLE_READ: "REPEATABLE READ",
+    SERIALIZABLE: "SERIALIZABLE",
+};
+export async function withPgPoolTransaction(pool, callbackOrIsolationLevel, callbackOrRetryCount, retryCountOrMaxRetries = 0, maxRetries = 3) {
+    let callback;
+    let isolationLevel = IsolationLevel.SERIALIZABLE;
+    let retryCount = 0;
+    if (typeof callbackOrIsolationLevel === "function") {
+        callback = callbackOrIsolationLevel;
+        if (typeof callbackOrRetryCount === "number") {
+            retryCount = callbackOrRetryCount;
+            maxRetries = retryCountOrMaxRetries;
+        }
+    }
+    else {
+        isolationLevel = callbackOrIsolationLevel;
+        callback = callbackOrRetryCount;
+        retryCount = retryCountOrMaxRetries;
+    }
+    let pgClient = null;
+    try {
+        pgClient = await pool.connect();
+        if (isolationLevel === IsolationLevel.READ_COMMITTED) {
+            await pgClient.query("BEGIN");
+        }
+        else {
+            await pgClient.query(`BEGIN ISOLATION LEVEL ${isolationLevel}`);
+        }
+        SIDECAR.set(pgClient, isolationLevel);
+        assertInTransaction(pgClient);
+        const result = await callback(pgClient);
+        await pgClient.query("COMMIT");
+        return result;
+    }
+    catch (error) {
+        if (pgClient) {
+            try {
+                await pgClient.query("ROLLBACK");
+            }
+            catch (rollbackError) {
+                logger.error(error, "Original error");
+                logger.error(rollbackError, "Rollback failed");
+                SIDECAR.delete(pgClient);
+                pgClient.release(true);
+                pgClient = null;
+                throw error;
+            }
+            if (retryCount < maxRetries &&
+                error instanceof pg.DatabaseError &&
+                (error.code === PG_ERROR_CODE.deadlock ||
+                    error.code === PG_ERROR_CODE.serializationFailure)) {
+                const backoffMs = Math.min(100 * Math.pow(2, retryCount), 2000);
+                logger.warn(`Retrying transaction in ${Math.floor(backoffMs)}ms (attempt ${retryCount + 2}/${maxRetries + 1}) due to pg error code ${error.code}: ${error.message}`);
+                await setTimeout(backoffMs);
+                if (isolationLevel === IsolationLevel.READ_COMMITTED) {
+                    return withPgPoolTransaction(pool, callback, retryCount + 1, maxRetries);
+                }
+                else {
+                    return withPgPoolTransaction(pool, isolationLevel, callback, retryCount + 1, maxRetries);
+                }
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (pgClient) {
+            SIDECAR.delete(pgClient);
+            pgClient.release();
+        }
+    }
+}

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

@@ -3,7 +3,6 @@ import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
 import { logger } from "../logger.js";
 export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
-    assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
     const hashChain = await pgClient
         .query(`
        SELECT * 
@@ -32,7 +31,6 @@ export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, ite
         metadata,
         digest: Buffer.from(digest).toString("base64"),
     }, "[dbInsertHubHash] Inserting hash");
-    assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
     if (kind === DbHashKind.INTERMEDIATE) {
         assert(typeof clientSeed === "string", "clientSeed must be provided for INTERMEDIATE hashes");
     }

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

@@ -2,9 +2,7 @@ import { logger } from "../logger.js";
 import { getPreimageHash } from "./get-hash.js";
 import { DbHashKind } from "../db/types.js";
 import { dbInsertHubHash } from "../db/index.js";
-import { assert } from "tsafe";
 export async function dbRevealHashChain(pgClient, { hashChainId, }) {
-    assert(pgClient._inTransaction, "dbRevealHashChain must be called in a transaction");
     logger.debug({ hashChainId }, "Revealing hash chain");
     const preimageHashResult = await getPreimageHash({
         hashChainId,

package/dist/src/pg-advisory-lock.js

@@ -1,4 +1,3 @@
-import { assert } from "tsafe";
 var LockNamespace;
 (function (LockNamespace) {
     LockNamespace[LockNamespace["MP_TAKE_REQUEST"] = 1] = "MP_TAKE_REQUEST";
@@ -26,15 +25,12 @@ async function acquireAdvisoryLock(pgClient, namespace, hash) {
 }
 export const PgAdvisoryLock = {
     forMpTakeRequestProcessing: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.MP_TAKE_REQUEST, createHashKey(params.mpTakeRequestId, params.casinoId));
     },
     forNewHashChain: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.NEW_HASH_CHAIN, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatPlayerAction: async (pgClient, params) => {
-        assert(pgClient._inTransaction, "pgClient must be in a transaction");
         await acquireAdvisoryLock(pgClient, LockNamespace.CHAT_PLAYER_ACTION, createHashKey(params.userId, params.experienceId, params.casinoId));
     },
     forChatModManagement: async (pgClient, params) => {

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

@@ -4,7 +4,6 @@ import { assert } from "tsafe";
 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";
@@ -230,11 +229,6 @@ async function processTransfersUntilEmpty({ afterCursor, graphqlClient, casinoIn
     let hasNextPage = true;
     const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
     while (hasNextPage && !signal.aborted) {
-        await processWithdrawalRequests({
-            casinoId: casinoInfo.id,
-            graphqlClient,
-            pool,
-        });
         if (signal.aborted) {
             logger.info(`[processTransfersUntilEmpty] Aborted by graceful shutdown.`);
             break;

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

@@ -107,6 +107,21 @@ export async function processTransfer({ casinoId, controllerId, transfer, graphq
                 }
                 logger.debug(data, "MP_CLAIM_TRANSFER response");
                 if (data.claimTransfer?.result.__typename !== "ClaimTransferSuccess") {
+                    if (data.claimTransfer?.result.__typename ===
+                        "InvalidTransferStatus" &&
+                        data.claimTransfer?.result.currentStatus ===
+                            TransferStatusKind.Completed) {
+                        logger.info(`Transfer ${transfer.id} already claimed (status: COMPLETED), skipping claim but attempting deposit insert`);
+                        await db.insertDeposit(pool, {
+                            casinoId,
+                            mpTransferId: transfer.id,
+                            userId: dbSender.id,
+                            experienceId: dbExperience.id,
+                            amount: transfer.amount,
+                            currency: currency.id,
+                        });
+                        return;
+                    }
                     throw new Error(`Failed to claim transfer: ${JSON.stringify(data.claimTransfer)}`);
                 }
                 await db.insertDeposit(pool, {

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

@@ -243,7 +243,6 @@ export async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest,
     });
 }
 async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     assert(mpTakeRequest.status === MpTakeRequestStatus.Pending);
     const { dbUser, dbExperience, dbCurrency, dbBalance } = await loadRequiredEntities(pgClient, {
         type: "mpId",
@@ -327,7 +326,6 @@ async function createAndProcessNewTakeRequest({ pgClient, mpTakeRequest, casinoI
     });
 }
 async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     switch (takeRequest.status) {
         case LocalTakeRequestStatus.PENDING:
             logger.info(`[processExistingTakeRequest] Take request ${takeRequest.id} in PENDING state`);
@@ -371,7 +369,6 @@ async function processExistingTakeRequest({ pgClient, takeRequest, casinoId, gra
     return null;
 }
 async function attemptTransfer({ pgClient, takeRequestId, mpTakeRequestId, mpExperienceId, mpUserId, amount, currencyKey, graphqlClient, }) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         const transferResult = await graphqlClient.request(MP_TRANSFER_TAKE_REQUEST, {
             mpTakeRequestId,
@@ -592,20 +589,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             logger.warn({ mpTransferId, takeRequestId }, `[completeTransfer] Transfer was already refunded. This should never happen.`);
                             break;
                         }
-                        const dbBalanceAfterUpdate = await pgClient
+                        const dbLockedBalance = await pgClient
                             .query({
                             text: `
-                UPDATE hub.balance
-                SET amount = amount + $1
-                WHERE user_id = $2 
-                  AND experience_id = $3 
-                  AND casino_id = $4 
-                  AND currency_key = $5
-
-                RETURNING id, amount
+                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.reserved_amount,
                                 takeRequestData.user_id,
                                 takeRequestData.experience_id,
                                 takeRequestData.casino_id,
@@ -613,10 +608,18 @@ export async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTrans
                             ],
                         })
                             .then(exactlyOneRow);
+                        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: dbBalanceAfterUpdate.id,
-                            balanceOld: dbBalanceAfterUpdate.amount - takeRequestData.reserved_amount,
-                            balanceNew: dbBalanceAfterUpdate.amount,
+                            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",
@@ -740,7 +743,6 @@ async function processStuckRequests({ casinoId, graphqlClient, abortSignal, pool
 }
 async function loadRequiredEntities(pgClient, params) {
     const { type, currencyKey, casinoId } = params;
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     const dbCurrency = await pgClient
         .query({
         text: `
@@ -839,7 +841,6 @@ async function loadRequiredEntities(pgClient, params) {
     return { dbCurrency, dbUser, dbExperience, dbBalance };
 }
 async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, takeRequestId) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     try {
         logger.info(`[rejectMpTakeRequest] Rejecting take request ${mpTakeRequestId}`);
         const rejectResult = await graphqlClient.request(MP_REJECT_TAKE_REQUEST, {
@@ -916,7 +917,6 @@ async function rejectMpTakeRequest(pgClient, graphqlClient, mpTakeRequestId, tak
     }
 }
 async function updateTakeRequestStatus(pgClient, takeRequestId, status) {
-    assert(pgClient._inTransaction, "pgClient must be in a transaction");
     return pgClient.query({
         text: `
       UPDATE hub.take_request

package/package.json

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