@moneypot/hub 1.4.9 → 1.5.0

package/dist/src/plugins/hub-make-outcome-bet.js

@@ -1,4 +1,4 @@
-import { access, context, object, ObjectStep, polymorphicBranch, sideEffect, } from "postgraphile/grafast";
+import { access, context, object, ObjectStep, sideEffect, } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import { z } from "zod";
 import { GraphQLError } from "graphql";
@@ -98,167 +98,168 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
       `;
         return {
             typeDefs,
-            plans: {
+            objects: {
                 Mutation: {
-                    hubMakeOutcomeBet: (_, { $input }) => {
-                        const $identity = context().get("identity");
-                        const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
-                            if (identity?.kind !== "user") {
-                                throw new GraphQLError("Unauthorized");
-                            }
-                            let input;
-                            let betKind;
-                            try {
-                                input = InputSchema.parse(rawInput);
-                                betKind = BetKindSchema.parse(rawInput.kind);
-                            }
-                            catch (e) {
-                                if (e instanceof z.ZodError) {
-                                    throw new GraphQLError(e.errors[0].message);
+                    plans: {
+                        hubMakeOutcomeBet: (_, { $input }) => {
+                            const $identity = context().get("identity");
+                            const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                                if (identity?.kind !== "user") {
+                                    throw new GraphQLError("Unauthorized");
                                 }
-                                throw e;
-                            }
-                            const betConfig = betConfigs[betKind];
-                            if (!betConfig) {
-                                throw new GraphQLError(`Invalid bet kind`);
-                            }
-                            if (!betConfig.allowLossBeyondWager) {
-                                const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
-                                if (minProfit < -1) {
-                                    throw new GraphQLError(`Loss beyond wager not allowed: outcome profit must be >= -1`);
+                                let input;
+                                let betKind;
+                                try {
+                                    input = InputSchema.parse(rawInput);
+                                    betKind = BetKindSchema.parse(rawInput.kind);
                                 }
-                            }
-                            let initializedMetadata;
-                            if (betConfig.initializeMetadataFromUntrustedUserInput) {
-                                const result = betConfig.initializeMetadataFromUntrustedUserInput(input);
-                                if (result.ok) {
-                                    initializedMetadata = result.value;
+                                catch (e) {
+                                    if (e instanceof z.ZodError) {
+                                        throw new GraphQLError(e.errors[0].message);
+                                    }
+                                    throw e;
+                                }
+                                const betConfig = betConfigs[betKind];
+                                if (!betConfig) {
+                                    throw new GraphQLError(`Invalid bet kind`);
+                                }
+                                if (!betConfig.allowLossBeyondWager) {
+                                    const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
+                                    if (minProfit < -1) {
+                                        throw new GraphQLError(`Loss beyond wager not allowed: outcome profit must be >= -1`);
+                                    }
+                                }
+                                let initializedMetadata;
+                                if (betConfig.initializeMetadataFromUntrustedUserInput) {
+                                    const result = betConfig.initializeMetadataFromUntrustedUserInput(input);
+                                    if (result.ok) {
+                                        initializedMetadata = result.value;
+                                    }
+                                    else {
+                                        throw new GraphQLError(`Invalid input: ${result.error}`);
+                                    }
                                 }
-                                else {
-                                    throw new GraphQLError(`Invalid input: ${result.error}`);
+                                const houseEV = calculateHouseEV(input.outcomes);
+                                const minHouseEV = Math.max(0, betConfig.houseEdge - FLOAT_EPSILON);
+                                if (houseEV < minHouseEV) {
+                                    throw new GraphQLError(`No deal. House EV too low: ${houseEV.toFixed(4)}`);
                                 }
-                            }
-                            const houseEV = calculateHouseEV(input.outcomes);
-                            const minHouseEV = Math.max(0, betConfig.houseEdge - FLOAT_EPSILON);
-                            if (houseEV < minHouseEV) {
-                                throw new GraphQLError(`No deal. House EV too low: ${houseEV.toFixed(4)}`);
-                            }
-                            const { session } = identity;
-                            const dbCurrency = await superuserPool
-                                .query({
-                                text: `
+                                const { session } = identity;
+                                const dbCurrency = await superuserPool
+                                    .query({
+                                    text: `
                   SELECT key
                   FROM hub.currency
                   WHERE key = $1
                     AND casino_id = $2
                 `,
-                                values: [input.currency, session.casino_id],
-                            })
-                                .then(maybeOneRow);
-                            if (!dbCurrency) {
-                                throw new GraphQLError("Currency not found");
-                            }
-                            return withPgPoolTransaction(superuserPool, async (pgClient) => {
-                                const { dbPlayerBalance, dbHouseBankroll, found } = await dbLockPlayerBalanceAndHouseBankroll(pgClient, {
-                                    userId: session.user_id,
-                                    casinoId: session.casino_id,
-                                    experienceId: session.experience_id,
-                                    currencyKey: dbCurrency.key,
-                                });
-                                if (!found) {
-                                    throw new GraphQLError("No balance entry found for player or house");
+                                    values: [input.currency, session.casino_id],
+                                })
+                                    .then(maybeOneRow);
+                                if (!dbCurrency) {
+                                    throw new GraphQLError("Currency not found");
                                 }
-                                const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
-                                const maxPlayerLoss = Math.abs(input.wager * minProfit);
-                                console.log("Determining if player can afford bet", {
-                                    wager: input.wager,
-                                    minProfit,
-                                    maxPlayerLoss,
-                                    dbPlayerBalance,
-                                });
-                                if (dbPlayerBalance.amount < maxPlayerLoss) {
-                                    if (minProfit === -1) {
-                                        throw new GraphQLError(`You cannot afford wager`);
+                                return withPgPoolTransaction(superuserPool, async (pgClient) => {
+                                    const { dbPlayerBalance, dbHouseBankroll, found } = await dbLockPlayerBalanceAndHouseBankroll(pgClient, {
+                                        userId: session.user_id,
+                                        casinoId: session.casino_id,
+                                        experienceId: session.experience_id,
+                                        currencyKey: dbCurrency.key,
+                                    });
+                                    if (!found) {
+                                        throw new GraphQLError("No balance entry found for player or house");
                                     }
-                                    throw new GraphQLError("You cannot afford the worst outcome");
-                                }
-                                const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
-                                const maxPotentialPayout = input.wager * maxProfitMultiplier;
-                                const maxAllowablePayout = dbHouseBankroll.amount * 0.01;
-                                if (maxPotentialPayout > maxAllowablePayout) {
-                                    throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
-                                }
-                                const dbHashChain = await dbLockHubHashChain(pgClient, {
-                                    userId: session.user_id,
-                                    experienceId: session.experience_id,
-                                    casinoId: session.casino_id,
-                                    hashChainId: input.hashChainId,
-                                });
-                                if (!dbHashChain || !dbHashChain.active) {
-                                    return {
-                                        __typename: "HubBadHashChainError",
-                                        message: "Active hash chain not found",
-                                    };
-                                }
-                                if (dbHashChain.current_iteration <= 1) {
-                                    if (dbHashChain.current_iteration === 1) {
-                                        finishHashChainInBackground({
-                                            hashChainId: input.hashChainId,
-                                        }).catch((e) => {
-                                            console.error("Error finishing hash chain in background", { hashChainId: input.hashChainId, error: e });
-                                        });
+                                    const minProfit = Math.min(...input.outcomes.map((o) => o.profit));
+                                    const maxPlayerLoss = Math.abs(input.wager * minProfit);
+                                    console.log("Determining if player can afford bet", {
+                                        wager: input.wager,
+                                        minProfit,
+                                        maxPlayerLoss,
+                                        dbPlayerBalance,
+                                    });
+                                    if (dbPlayerBalance.amount < maxPlayerLoss) {
+                                        if (minProfit === -1) {
+                                            throw new GraphQLError(`You cannot afford wager`);
+                                        }
+                                        throw new GraphQLError("You cannot afford the worst outcome");
                                     }
-                                    return {
-                                        __typename: "HubBadHashChainError",
-                                        message: "Hash chain drained. Create a new one.",
-                                    };
-                                }
-                                const betHashIteration = dbHashChain.current_iteration - 1;
-                                assert(betHashIteration > 0, "Bet hash iteration must be > 0");
-                                const betHashResult = await getIntermediateHash({
-                                    hashChainId: input.hashChainId,
-                                    iteration: betHashIteration,
-                                });
-                                switch (betHashResult.type) {
-                                    case "success":
-                                        break;
-                                    case "bad_hash_chain":
+                                    const maxProfitMultiplier = Math.max(...input.outcomes.map((o) => o.profit));
+                                    const maxPotentialPayout = input.wager * maxProfitMultiplier;
+                                    const maxAllowablePayout = dbHouseBankroll.amount * 0.01;
+                                    if (maxPotentialPayout > maxAllowablePayout) {
+                                        throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
+                                    }
+                                    const dbHashChain = await dbLockHubHashChain(pgClient, {
+                                        userId: session.user_id,
+                                        experienceId: session.experience_id,
+                                        casinoId: session.casino_id,
+                                        hashChainId: input.hashChainId,
+                                    });
+                                    if (!dbHashChain || !dbHashChain.active) {
                                         return {
                                             __typename: "HubBadHashChainError",
-                                            message: "Hash chain not found",
+                                            message: "Active hash chain not found",
                                         };
-                                    default: {
-                                        const _exhaustiveCheck = betHashResult;
-                                        throw new Error(`Unknown bet hash result: ${_exhaustiveCheck}`);
                                     }
-                                }
-                                const dbHash = await dbInsertHubHash(pgClient, {
-                                    hashChainId: dbHashChain.id,
-                                    kind: DbHashKind.INTERMEDIATE,
-                                    digest: betHashResult.hash,
-                                    iteration: betHashIteration,
-                                    clientSeed: input.clientSeed,
-                                });
-                                const result = await pgClient.query(`
+                                    if (dbHashChain.current_iteration <= 1) {
+                                        if (dbHashChain.current_iteration === 1) {
+                                            finishHashChainInBackground({
+                                                hashChainId: input.hashChainId,
+                                            }).catch((e) => {
+                                                console.error("Error finishing hash chain in background", { hashChainId: input.hashChainId, error: e });
+                                            });
+                                        }
+                                        return {
+                                            __typename: "HubBadHashChainError",
+                                            message: "Hash chain drained. Create a new one.",
+                                        };
+                                    }
+                                    const betHashIteration = dbHashChain.current_iteration - 1;
+                                    assert(betHashIteration > 0, "Bet hash iteration must be > 0");
+                                    const betHashResult = await getIntermediateHash({
+                                        hashChainId: input.hashChainId,
+                                        iteration: betHashIteration,
+                                    });
+                                    switch (betHashResult.type) {
+                                        case "success":
+                                            break;
+                                        case "bad_hash_chain":
+                                            return {
+                                                __typename: "HubBadHashChainError",
+                                                message: "Hash chain not found",
+                                            };
+                                        default: {
+                                            const _exhaustiveCheck = betHashResult;
+                                            throw new Error(`Unknown bet hash result: ${_exhaustiveCheck}`);
+                                        }
+                                    }
+                                    const dbHash = await dbInsertHubHash(pgClient, {
+                                        hashChainId: dbHashChain.id,
+                                        kind: DbHashKind.INTERMEDIATE,
+                                        digest: betHashResult.hash,
+                                        iteration: betHashIteration,
+                                        clientSeed: input.clientSeed,
+                                    });
+                                    const result = await pgClient.query(`
                         UPDATE hub.hash_chain
                         SET current_iteration = $2
                         WHERE id = $1
                     `, [dbHashChain.id, betHashIteration]);
-                                if (result.rowCount !== 1) {
-                                    throw new GraphQLError("Failed to update hash chain iteration");
-                                }
-                                const finalHash = makeFinalHash({
-                                    serverHash: betHashResult.hash,
-                                    clientSeed: input.clientSeed,
-                                });
-                                const { outcomeIdx, roll } = pickRandomOutcome({
-                                    outcomes: input.outcomes,
-                                    finalHash: finalHash,
-                                }, FLOAT_EPSILON);
-                                const outcome = input.outcomes[outcomeIdx];
-                                const netPlayerAmount = input.wager * outcome.profit;
-                                await pgClient.query({
-                                    text: `
+                                    if (result.rowCount !== 1) {
+                                        throw new GraphQLError("Failed to update hash chain iteration");
+                                    }
+                                    const finalHash = makeFinalHash({
+                                        serverHash: betHashResult.hash,
+                                        clientSeed: input.clientSeed,
+                                    });
+                                    const { outcomeIdx, roll } = pickRandomOutcome({
+                                        outcomes: input.outcomes,
+                                        finalHash: finalHash,
+                                    }, FLOAT_EPSILON);
+                                    const outcome = input.outcomes[outcomeIdx];
+                                    const netPlayerAmount = input.wager * outcome.profit;
+                                    await pgClient.query({
+                                        text: `
                     UPDATE hub.balance
                     SET amount = amount + $1
                     WHERE user_id = $2
@@ -266,16 +267,16 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                       AND experience_id = $4
                       AND currency_key = $5
                   `,
-                                    values: [
-                                        netPlayerAmount,
-                                        session.user_id,
-                                        session.casino_id,
-                                        session.experience_id,
-                                        dbCurrency.key,
-                                    ],
-                                });
-                                await pgClient.query({
-                                    text: `
+                                        values: [
+                                            netPlayerAmount,
+                                            session.user_id,
+                                            session.casino_id,
+                                            session.experience_id,
+                                            dbCurrency.key,
+                                        ],
+                                    });
+                                    await pgClient.query({
+                                        text: `
                     UPDATE hub.bankroll
                     SET amount = amount - $1,
                         bets = bets + 1,
@@ -283,48 +284,48 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                     WHERE currency_key = $2
                       AND casino_id = $3
                   `,
-                                    values: [
-                                        netPlayerAmount,
-                                        dbCurrency.key,
-                                        session.casino_id,
-                                        input.wager,
-                                    ],
-                                });
-                                const immutableData = structuredClone({
-                                    wager: input.wager,
-                                    currencyKey: dbCurrency.key,
-                                    clientSeed: input.clientSeed,
-                                    hash: betHashResult.hash,
-                                    outcomes: input.outcomes,
-                                    outcomeIdx,
-                                    roll,
-                                });
-                                const finalizedMetadata = betConfig.finalizeMetadata
-                                    ? betConfig.finalizeMetadata(initializedMetadata, immutableData)
-                                    : initializedMetadata;
-                                const newBet = {
-                                    kind: rawInput.kind,
-                                    wager: input.wager,
-                                    profit: outcome.profit,
-                                    currency_key: dbCurrency.key,
-                                    hash_id: dbHash.id,
-                                    user_id: session.user_id,
-                                    casino_id: session.casino_id,
-                                    experience_id: session.experience_id,
-                                    metadata: finalizedMetadata || {},
-                                    ...(betConfig.saveOutcomes
-                                        ? {
-                                            outcomes: input.outcomes,
-                                            outcome_idx: outcomeIdx,
-                                        }
-                                        : {
-                                            outcomes: [],
-                                            outcome_idx: null,
-                                        }),
-                                };
-                                const bet = await pgClient
-                                    .query({
-                                    text: `
+                                        values: [
+                                            netPlayerAmount,
+                                            dbCurrency.key,
+                                            session.casino_id,
+                                            input.wager,
+                                        ],
+                                    });
+                                    const immutableData = structuredClone({
+                                        wager: input.wager,
+                                        currencyKey: dbCurrency.key,
+                                        clientSeed: input.clientSeed,
+                                        hash: betHashResult.hash,
+                                        outcomes: input.outcomes,
+                                        outcomeIdx,
+                                        roll,
+                                    });
+                                    const finalizedMetadata = betConfig.finalizeMetadata
+                                        ? betConfig.finalizeMetadata(initializedMetadata, immutableData)
+                                        : initializedMetadata;
+                                    const newBet = {
+                                        kind: rawInput.kind,
+                                        wager: input.wager,
+                                        profit: outcome.profit,
+                                        currency_key: dbCurrency.key,
+                                        hash_id: dbHash.id,
+                                        user_id: session.user_id,
+                                        casino_id: session.casino_id,
+                                        experience_id: session.experience_id,
+                                        metadata: finalizedMetadata || {},
+                                        ...(betConfig.saveOutcomes
+                                            ? {
+                                                outcomes: input.outcomes,
+                                                outcome_idx: outcomeIdx,
+                                            }
+                                            : {
+                                                outcomes: [],
+                                                outcome_idx: null,
+                                            }),
+                                    };
+                                    const bet = await pgClient
+                                        .query({
+                                        text: `
                       INSERT INTO hub.outcome_bet (
                         user_id, 
                         casino_id, 
@@ -341,47 +342,49 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
                       RETURNING id
                     `,
-                                    values: [
-                                        newBet.user_id,
-                                        newBet.casino_id,
-                                        newBet.experience_id,
-                                        newBet.hash_id,
-                                        newBet.kind,
-                                        newBet.currency_key,
-                                        newBet.wager,
-                                        newBet.profit,
-                                        newBet.outcomes.map((o) => `(${o.weight},${o.profit})`),
-                                        newBet.outcome_idx,
-                                        newBet.metadata,
-                                    ],
-                                })
-                                    .then(exactlyOneRow);
-                                return {
-                                    __typename: "HubMakeOutcomeBetSuccess",
-                                    betId: bet.id,
-                                };
+                                        values: [
+                                            newBet.user_id,
+                                            newBet.casino_id,
+                                            newBet.experience_id,
+                                            newBet.hash_id,
+                                            newBet.kind,
+                                            newBet.currency_key,
+                                            newBet.wager,
+                                            newBet.profit,
+                                            newBet.outcomes.map((o) => `(${o.weight},${o.profit})`),
+                                            newBet.outcome_idx,
+                                            newBet.metadata,
+                                        ],
+                                    })
+                                        .then(exactlyOneRow);
+                                    return {
+                                        __typename: "HubMakeOutcomeBetSuccess",
+                                        betId: bet.id,
+                                    };
+                                });
+                            });
+                            return object({
+                                result: $result,
                             });
-                        });
-                        return object({
-                            result: $result,
-                        });
+                        },
                     },
                 },
                 HubMakeOutcomeBetSuccess: {
-                    __assertStep: ObjectStep,
-                    bet($data) {
-                        const $betId = access($data, "betId");
-                        return outcomeBetTable.get({ id: $betId });
+                    assertStep: ObjectStep,
+                    plans: {
+                        bet($data) {
+                            const $betId = access($data, "betId");
+                            return outcomeBetTable.get({ id: $betId });
+                        },
                     },
                 },
                 HubMakeOutcomeBetPayload: {
-                    __assertStep: ObjectStep,
-                    result($data) {
-                        const $result = $data.get("result");
-                        return polymorphicBranch($result, {
-                            HubMakeOutcomeBetSuccess: {},
-                            HubBadHashChainError: {},
-                        });
+                    assertStep: ObjectStep,
+                    plans: {
+                        result($data) {
+                            const $result = $data.get("result");
+                            return $result;
+                        },
                     },
                 },
             },

package/dist/src/plugins/hub-put-alert.js

@@ -14,45 +14,49 @@ export const HubPutAlertPlugin = makeExtendSchemaPlugin(() => {
         mpTransferId: UUID!
       }
     `,
-        plans: {
+        objects: {
             Subscription: {
-                hubPutAlert: {
-                    subscribePlan(_$root) {
-                        const $pgSubscriber = context().get("pgSubscriber");
-                        const $identity = context().get("identity");
-                        const $channelKey = lambda($identity, (identity) => {
-                            if (identity?.kind === "user") {
-                                return `hub:user:${identity.session.user_id}:put`;
-                            }
-                            else {
-                                return "";
-                            }
-                        });
-                        return listenWithFilter($pgSubscriber, $channelKey, jsonParse, $identity, (item, identity) => {
-                            if (typeof item !== "string") {
-                                console.warn(`hubPutAlert: item is not a string: ${JSON.stringify(item)}`);
-                                return false;
-                            }
-                            if (identity?.kind !== "user") {
-                                return false;
-                            }
-                            else {
-                                return (identity.session.experience_id ===
-                                    JSON.parse(item).experience_id);
-                            }
-                        });
-                    },
-                    plan($event) {
-                        return $event;
+                plans: {
+                    hubPutAlert: {
+                        subscribePlan(_$root) {
+                            const $pgSubscriber = context().get("pgSubscriber");
+                            const $identity = context().get("identity");
+                            const $channelKey = lambda($identity, (identity) => {
+                                if (identity?.kind === "user") {
+                                    return `hub:user:${identity.session.user_id}:put`;
+                                }
+                                else {
+                                    return "";
+                                }
+                            });
+                            return listenWithFilter($pgSubscriber, $channelKey, jsonParse, $identity, (item, identity) => {
+                                if (typeof item !== "string") {
+                                    console.warn(`hubPutAlert: item is not a string: ${JSON.stringify(item)}`);
+                                    return false;
+                                }
+                                if (identity?.kind !== "user") {
+                                    return false;
+                                }
+                                else {
+                                    return (identity.session.experience_id ===
+                                        JSON.parse(item).experience_id);
+                                }
+                            });
+                        },
+                        plan($event) {
+                            return $event;
+                        },
                     },
                 },
             },
             HubPutAlertPayload: {
-                currencyKey($event) {
-                    return $event.get("currency_key");
-                },
-                mpTransferId($event) {
-                    return $event.get("mp_transfer_id");
+                plans: {
+                    currencyKey($event) {
+                        return $event.get("currency_key");
+                    },
+                    mpTransferId($event) {
+                        return $event.get("mp_transfer_id");
+                    },
                 },
             },
         },