@moneypot/hub 0.0.1

package/dist/src/process-transfers.js

@@ -0,0 +1,413 @@
+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 config from "./config.js";
+import { z } from "zod";
+import { gql } from "./__generated__/gql.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";
+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
+        }
+      }
+    }
+  }
+`);
+const casinoMap = new Map();
+const MIN_BACKOFF_TIME = 5000;
+const MAX_BACKOFF_TIME = 30 * 1000;
+async function listenForNewCasinos() {
+    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 });
+                break;
+            }
+        }
+    });
+    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, }) {
+    let hasNextPage = true;
+    const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
+    while (hasNextPage) {
+        await processWithdrawalRequests({
+            casinoId: casinoInfo.id,
+            graphqlClient,
+        });
+        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;
+            }
+            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;
+        await timeout(1000);
+    }
+    return afterCursor;
+}
+async function processWithdrawals({ casinoId, graphqlClient, }) {
+    const withdrawals = await db.getPendingWithdrawals(superuserPool, {
+        casinoId,
+        limit: 10,
+    });
+    if (withdrawals.length > 0) {
+        logger.debug(`[sendWithdrawalLoop] withdrawals:`, withdrawals);
+    }
+    for (const withdrawal of withdrawals) {
+        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, }) {
+    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,
+        });
+        if (cursor && !isUuid(cursor)) {
+            logger.info(`Migrating from old transfer cursor format: "${cursor}"...`);
+            const json = Buffer.from(cursor, "base64").toString("utf8");
+            const parsed = JSON.parse(json);
+            assert(Array.isArray(parsed), `Expected premigrated transfer cursor to decode into json array, got ${json}`);
+            const transferId = parsed[1];
+            logger.info(`Migrated cursor: ${cursor} => ${transferId}`);
+            cursor = transferId;
+        }
+        let upsertedCurrencies = false;
+        let shouldStop = false;
+        processorState.emitter.on("once", () => {
+            shouldStop = true;
+        });
+        while (!shouldStop) {
+            try {
+                const now = Date.now();
+                const timeToWait = Math.max(0, processorState.backoffTime - (now - processorState.lastAttempt));
+                if (timeToWait > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, timeToWait));
+                }
+                processorState.lastAttempt = Date.now();
+                const casino = await dbGetCasinoById(superuserPool, casinoId);
+                if (!casino) {
+                    logger.warn(`casino ${casinoId} not found. Stopping processor...`);
+                    shouldStop = true;
+                    break;
+                }
+                const casinoSecret = await dbGetCasinoSecretById(superuserPool, casino.id);
+                if (!casinoSecret) {
+                    logger.warn(`Casino secret hasn't been set for casino ${casinoId}. Skipping...`);
+                    continue;
+                }
+                const graphqlClient = createGraphqlClient({
+                    graphqlUrl: casino.graphql_url,
+                    apiKey: casinoSecret.api_key,
+                });
+                await jwtService.refreshCasinoJwksTask(superuserPool, {
+                    casinoId: casino.id,
+                    graphqlClient,
+                });
+                if (!upsertedCurrencies) {
+                    const currencies = await graphqlClient
+                        .request(GET_CURRENCIES)
+                        .then((res) => {
+                        return (res.allCurrencies?.nodes || []).flatMap((x) => x ? [x] : []);
+                    });
+                    if (currencies.length > 0) {
+                        await db.upsertCurrencies(superuserPool, {
+                            casinoId: casino.id,
+                            currencies,
+                        });
+                    }
+                    upsertedCurrencies = true;
+                }
+                cursor = await processTransfersUntilEmpty({
+                    afterCursor: cursor,
+                    graphqlClient,
+                    casinoInfo: { ...casino, ...casinoSecret },
+                });
+                await processWithdrawals({ casinoId: casino.id, graphqlClient });
+                processorState.backoffTime = MIN_BACKOFF_TIME;
+            }
+            catch (e) {
+                processorState.backoffTime = Math.min(processorState.backoffTime * 2, MAX_BACKOFF_TIME);
+                logger.error(`transfer processor failed:`, e);
+                logger.debug(`Next retry for casino ${casinoId} in ${processorState.backoffTime}ms`);
+            }
+        }
+        logger.debug(`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}`);
+        return;
+    }
+    processorState.emitter.emit("stop");
+}
+export function initializeTransferProcessors() {
+    (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}"`);
+                startTransferProcessor({ casinoId: casino.id });
+            }
+            await listenForNewCasinos();
+        }
+        catch (e) {
+            logger.error(`Error initializing transfer processors:`, e);
+        }
+    })();
+}

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

@@ -0,0 +1,5 @@
+import { GraphQLClient } from "graphql-request";
+export declare function processWithdrawalRequests({ casinoId, graphqlClient, }: {
+    casinoId: string;
+    graphqlClient: GraphQLClient;
+}): Promise<void>;

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

@@ -0,0 +1,129 @@
+import { assert } from "tsafe";
+import { TransferStatusKind } from "./__generated__/graphql.js";
+import { withPgPoolTransaction, superuserPool } from "./db/index.js";
+import { maybeOneRow, exactlyOneRow } from "./db/util.js";
+import { START_PENDING_EXPERIENCE_TRANSFER } from "./graphql-queries.js";
+import { logger } from "./logger.js";
+async function processWithdrawalRequest({ requestId, graphqlClient, }) {
+    return withPgPoolTransaction(superuserPool, async (pgClient) => {
+        const dbWithdrawalRequest = await pgClient
+            .query({
+            text: `
+          select *
+          from hub.withdrawal_request
+          where id = $1
+
+          FOR UPDATE
+        `,
+            values: [requestId],
+        })
+            .then(maybeOneRow);
+        if (!dbWithdrawalRequest) {
+            throw new Error("Withdrawal request not found");
+        }
+        if (dbWithdrawalRequest.mp_transfer_id) {
+            return;
+        }
+        const dbUser = await pgClient
+            .query({
+            text: `select * from hub.user where id = $1`,
+            values: [dbWithdrawalRequest.user_id],
+        })
+            .then(exactlyOneRow);
+        const dbExperience = await pgClient
+            .query({
+            text: `select * from hub.experience where id = $1`,
+            values: [dbWithdrawalRequest.experience_id],
+        })
+            .then(exactlyOneRow);
+        const mpResult = await graphqlClient
+            .request({
+            document: START_PENDING_EXPERIENCE_TRANSFER,
+            variables: {
+                mpUserId: dbUser.mp_user_id,
+                mpExperienceId: dbExperience.mp_experience_id,
+                amount: dbWithdrawalRequest.amount,
+                currency: dbWithdrawalRequest.currency_key,
+                metadata: JSON.stringify({
+                    id: `withdrawal_request:${dbWithdrawalRequest.id}`,
+                }),
+            },
+        })
+            .then((res) => res.transferCurrencyExperienceToUser?.result);
+        if (mpResult?.__typename !== "TransferCurrencyExperienceToUserSuccess" &&
+            mpResult?.__typename !== "TransferMetadataIdExists") {
+            throw new Error(`Failed to start MP transfer: ${mpResult}`);
+        }
+        const mpTransferId = mpResult.transfer.id;
+        const mpStatus = mpResult.transfer.status;
+        await pgClient
+            .query({
+            text: `
+        update hub.withdrawal_request
+        set mp_transfer_id = $2
+        where id = $1
+      `,
+            values: [dbWithdrawalRequest.id, mpTransferId],
+        })
+            .then((res) => {
+            assert(res.rowCount === 1, `Expected to update a hub.withdrawal_request.mp_transfer_id`);
+        });
+        if (mpStatus === TransferStatusKind.Pending ||
+            mpStatus === TransferStatusKind.Completed) {
+        }
+        else {
+            logger.warn(`Expected status to be PENDING or COMPLETED, but got ${mpStatus}`);
+            return;
+        }
+        await pgClient.query({
+            text: `
+        insert into hub.withdrawal(
+          id, 
+          casino_id, 
+          mp_transfer_id,
+          user_id, 
+          experience_id, 
+          amount,
+          currency_key,
+          status,
+          withdrawal_request_id
+        ) 
+        values ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      `,
+            values: [
+                dbWithdrawalRequest.id,
+                dbWithdrawalRequest.casino_id,
+                mpTransferId,
+                dbWithdrawalRequest.user_id,
+                dbWithdrawalRequest.experience_id,
+                dbWithdrawalRequest.amount,
+                dbWithdrawalRequest.currency_key,
+                mpResult.transfer.status,
+                dbWithdrawalRequest.id,
+            ],
+        });
+    });
+}
+export async function processWithdrawalRequests({ casinoId, graphqlClient, }) {
+    const pendingRequests = await superuserPool.query({
+        text: `
+      SELECT wr.* 
+      FROM hub.withdrawal_request wr
+      WHERE wr.casino_id = $1 
+      AND wr.mp_transfer_id IS NULL
+      LIMIT 10
+    `,
+        values: [casinoId],
+    });
+    for (const request of pendingRequests.rows) {
+        try {
+            await processWithdrawalRequest({
+                requestId: request.id,
+                graphqlClient,
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to process withdrawal request ${request.id}:`, error);
+        }
+    }
+}

package/dist/src/server/graphile.config.d.ts

@@ -0,0 +1,33 @@
+import "graphile-config";
+import "postgraphile";
+type UserSessionContext = {
+    user_id: string;
+    mp_user_id: string;
+    casino_id: string;
+    experience_id: string;
+    session_id: string;
+};
+type PluginIdentity = {
+    kind: "user";
+    session: UserSessionContext;
+} | {
+    kind: "operator";
+};
+export type PluginContext = Grafast.Context & {
+    identity?: PluginIdentity;
+};
+export declare const requiredPlugins: readonly GraphileConfig.Plugin[];
+declare global {
+    namespace GraphileBuild {
+        interface SchemaOptions {
+            pgDeletedColumnName?: string;
+        }
+    }
+}
+export declare const defaultPlugins: readonly GraphileConfig.Plugin[];
+export declare function createPreset({ plugins, exportSchemaSDLPath, extraPgSchemas, }: {
+    plugins: readonly GraphileConfig.Plugin[];
+    exportSchemaSDLPath: string;
+    extraPgSchemas: string[];
+}): GraphileConfig.Preset;
+export {};