@moneypot/hub 1.2.7 → 1.3.0-dev.1

package/README.md

@@ -28,6 +28,7 @@ import {
   type ServerOptions,
   defaultPlugins,
   startAndListen,
+  MakeOutcomeBetPlugin,
 } from "@moneypot/hub";
 import path from "path";
 
@@ -40,6 +41,9 @@ const options: ServerOptions = {
     // These are required for the hub server to function
     ...defaultPlugins,
     // Add your custom plugins here to extend server functionality
+    MakeOutcomeBetPlugin({
+      houseEdge: 0.01,
+    }),
   ],
 
   // File path where the generated GraphQL schema definition will be saved

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

@@ -6,8 +6,8 @@ export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";
 export declare function getPgClient(connectionString: string): InstanceType<typeof pg.Client>;
-export declare const postgraphilePool: import("pg").Pool;
-export declare const superuserPool: import("pg").Pool;
+export declare const postgraphilePool: pg.Pool;
+export declare const superuserPool: pg.Pool;
 export interface QueryExecutor {
     query<T extends pg.QueryResultRow = any>(queryText: string, values?: any[]): Promise<pg.QueryResult<T>>;
 }

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 import { Express } from "express";
 import { Logger } from "./logger.js";
+export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, type PluginContext, type PluginIdentity, type UserSessionContext, } from "./server/graphile.config.js";
 export type ServerOptions = {
     configureApp?: (app: Express) => void;

package/dist/src/index.js

@@ -5,6 +5,7 @@ import { createHubServer } from "./server/index.js";
 import { initializeTransferProcessors } from "./process-transfers.js";
 import { join } from "path";
 import { logger, setLogger } from "./logger.js";
+export { MakeOutcomeBetPlugin } from "./plugins/hub-make-outcome-bet.js";
 export { defaultPlugins, } from "./server/graphile.config.js";
 async function initialize(options) {
     if (options.logger) {
@@ -54,6 +55,9 @@ async function initialize(options) {
     });
 }
 export async function startAndListen(options) {
+    if (options.plugins && options.plugins.some((p) => typeof p === "function")) {
+        throw new Error("`plugins` should be an array of GraphileConfig.Plugin but one of the items is a function. Did you forget to call it?");
+    }
     if (options.userDatabaseMigrationsPath &&
         !options.userDatabaseMigrationsPath.startsWith("/")) {
         throw new Error(`userDatabaseMigrationsPath must be an absolute path, got ${options.userDatabaseMigrationsPath}`);

package/dist/src/pg-versions/005-outcome-bet.sql

@@ -0,0 +1,56 @@
+create type hub.outcome as (
+    weight float,
+    profit float
+);
+
+create table hub.outcome_bet (
+    id           uuid primary key default hub_hidden.uuid_generate_v7(),
+
+    -- Operator-given kind like "WHEEL", "PLINKO", 
+    -- Probably not worth using a postgres enum here since they are not flexible.
+    kind         text not null,
+
+    user_id       uuid not null references hub.user(id),
+    experience_id uuid not null references hub.experience(id),
+    casino_id     uuid not null references hub.casino(id),
+
+    currency_key text not null,
+    wager        float not null,
+
+    -- -1 = lose wager, -2 = lose 2x wager
+    -- 0.5 = 1.5x wager, 1 = 2x wager
+    -- In other words, a multiplier in a game might say "2.5x", 
+    -- but the profit is multiplier-1 = 1.5 profit
+    profit       float not null,
+
+    -- null when no outcomes saved
+    outcome_idx  smallint null,
+    outcomes     hub.outcome[] not null default '{}',
+
+    -- Operator-provided data per bet
+    metadata     jsonb not null default '{}',
+
+    foreign key (currency_key, casino_id) references hub.currency(key, casino_id)
+);
+
+create index outcome_bet_user_id_idx on hub.outcome_bet(user_id);
+create index outcome_bet_experience_id_idx on hub.outcome_bet(experience_id);
+create index outcome_bet_casino_id_idx on hub.outcome_bet(casino_id);
+create index outcome_bet_kind_idx on hub.outcome_bet(kind);
+
+-- GRANT
+
+grant select on hub.outcome_bet to app_postgraphile;
+
+-- RLS
+
+alter table hub.outcome_bet enable row level security;
+
+create policy select_outcome_bet on hub.outcome_bet for select using (
+    hub_hidden.is_operator() or
+    (
+        user_id = hub_hidden.current_user_id() and
+        experience_id = hub_hidden.current_experience_id() and
+        casino_id = hub_hidden.current_casino_id()
+    )
+);

package/dist/src/plugins/hub-make-outcome-bet.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+declare const InputSchema: z.ZodObject<{
+    kind: z.ZodString;
+    wager: z.ZodNumber;
+    currency: z.ZodString;
+    outcomes: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        weight: z.ZodNumber;
+        profit: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        weight: number;
+        profit: number;
+    }, {
+        weight: number;
+        profit: number;
+    }>, "many">, {
+        weight: number;
+        profit: number;
+    }[], {
+        weight: number;
+        profit: number;
+    }[]>, {
+        weight: number;
+        profit: number;
+    }[], {
+        weight: number;
+        profit: number;
+    }[]>;
+}, "strict", z.ZodTypeAny, {
+    currency: string;
+    kind: string;
+    wager: number;
+    outcomes: {
+        weight: number;
+        profit: number;
+    }[];
+}, {
+    currency: string;
+    kind: string;
+    wager: number;
+    outcomes: {
+        weight: number;
+        profit: number;
+    }[];
+}>;
+type Input = z.infer<typeof InputSchema>;
+type BetConfig = {
+    houseEdge: number;
+    saveOutcomes: boolean;
+    getMetadata?: (input: Input) => Promise<Record<string, any>>;
+};
+export type BetConfigMap<BetKind extends string> = {
+    [betKind in BetKind]: BetConfig;
+};
+export declare function MakeOutcomeBetPlugin<BetKind extends string>({ betConfigs }: {
+    betConfigs: BetConfigMap<BetKind>;
+}): GraphileConfig.Plugin;
+export {};

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

@@ -0,0 +1,325 @@
+import { context, object, sideEffect } from "postgraphile/grafast";
+import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
+import { z } from "zod";
+import { GraphQLError } from "graphql";
+import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { assert } from "tsafe";
+const FLOAT_EPSILON = 1e-10;
+function sum(ns) {
+    return ns.reduce((a, b) => a + b, 0);
+}
+function calculatePlayerEV(outcomes) {
+    const totalWeight = sum(outcomes.map((o) => o.weight));
+    return sum(outcomes.map((o) => (o.weight / totalWeight) * o.profit));
+}
+function calculateHouseEV(outcomes) {
+    return -calculatePlayerEV(outcomes);
+}
+const OutcomeSchema = z
+    .object({
+    weight: z.number().gt(0, `Outcome weight must be > 0`),
+    profit: z.number(),
+})
+    .strict();
+const InputSchema = z
+    .object({
+    kind: z.string(),
+    wager: z
+        .number()
+        .int("Wager must be an integer")
+        .gte(1, "Wager must be >= 1"),
+    currency: z.string(),
+    outcomes: z
+        .array(OutcomeSchema)
+        .min(2, "Outcome count must be >= 2")
+        .max(50, "Outcome count must be <= 50")
+        .refine((data) => data.some((o) => o.profit < 0), "At least one outcome should have profit < 0")
+        .refine((data) => data.some((o) => o.profit > 0), "At least one outcome should have profit > 0"),
+})
+    .strict();
+const BetKindSchema = z
+    .string()
+    .min(1, "Bet kind must be at least 1 character")
+    .regex(/^[A-Z_]+$/, "Bet kind must only contain A-Z and underscores")
+    .regex(/^[A-Z]/, "Bet kind must start with a letter A-Z");
+const BetConfigsSchema = z.record(BetKindSchema, z.object({
+    houseEdge: z
+        .number()
+        .gte(0, "House edge must be >= 0")
+        .lte(1, "House edge must be <= 1"),
+    saveOutcomes: z.boolean(),
+    getMetadata: z
+        .function()
+        .args(InputSchema)
+        .returns(z.record(z.string(), z.any()))
+        .optional(),
+}));
+export function MakeOutcomeBetPlugin({ betConfigs }) {
+    BetConfigsSchema.parse(betConfigs);
+    const betKinds = Object.keys(betConfigs);
+    return makeExtendSchemaPlugin((build) => {
+        const outcomeBetTable = build.input.pgRegistry.pgResources.hub_outcome_bet;
+        const typeDefs = gql `
+        enum BetKind {
+          ${betKinds.join("\n")}
+        }
+
+        input HubMakeOutcomeBetInput {
+          kind: BetKind!
+          wager: Int!
+          currency: String!
+          outcomes: [HubOutcomeInput!]!
+        }
+
+        type HubMakeOutcomeBetPayload {
+          bet: HubOutcomeBet!
+        }
+
+        extend type Mutation {
+          hubMakeOutcomeBet(input: HubMakeOutcomeBetInput!): HubMakeOutcomeBetPayload
+        }
+      `;
+        return {
+            typeDefs,
+            plans: {
+                Mutation: {
+                    hubMakeOutcomeBet: (_, { $input }) => {
+                        const $identity = context().get("identity");
+                        const $betId = 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);
+                                }
+                                throw e;
+                            }
+                            const betConfig = betConfigs[betKind];
+                            if (!betConfig) {
+                                throw new GraphQLError(`Invalid bet kind`);
+                            }
+                            if (!betKinds.includes(rawInput.kind)) {
+                                throw new GraphQLError(`Invalid bet kind`);
+                            }
+                            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: `
+                  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 dbLockBalanceAndBankroll(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");
+                                }
+                                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 < maxPlayerLoss) {
+                                    if (minProfit === -1) {
+                                        throw new GraphQLError(`You cannot afford wager`);
+                                    }
+                                    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 * 0.01;
+                                if (maxPotentialPayout > maxAllowablePayout) {
+                                    throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
+                                }
+                                const { outcome, outcomeIdx } = pickRandomOutcome(input.outcomes);
+                                const netPlayerAmount = input.wager * outcome.profit;
+                                await pgClient.query({
+                                    text: `
+                    UPDATE hub.balance
+                    SET amount = amount + $1
+                    WHERE user_id = $2
+                      AND casino_id = $3
+                      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: `
+                    UPDATE hub.bankroll
+                    SET amount = amount - $1,
+                        bets = bets + 1,
+                        wagered = wagered + $4
+                    WHERE currency_key = $2
+                      AND casino_id = $3
+                  `,
+                                    values: [
+                                        netPlayerAmount,
+                                        dbCurrency.key,
+                                        session.casino_id,
+                                        input.wager,
+                                    ],
+                                });
+                                const newBet = {
+                                    kind: rawInput.kind,
+                                    wager: input.wager,
+                                    profit: outcome.profit,
+                                    currency_key: dbCurrency.key,
+                                    user_id: session.user_id,
+                                    casino_id: session.casino_id,
+                                    experience_id: session.experience_id,
+                                    metadata: betConfig.getMetadata
+                                        ? await betConfig.getMetadata(input)
+                                        : {},
+                                    ...(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, 
+                        experience_id, 
+                        kind,
+                        currency_key, 
+                        wager, 
+                        profit, 
+                        outcomes,
+                        outcome_idx,
+                        metadata
+                      )
+                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+                      RETURNING id
+                    `,
+                                    values: [
+                                        newBet.user_id,
+                                        newBet.casino_id,
+                                        newBet.experience_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 bet.id;
+                            });
+                        });
+                        return object({
+                            bet: outcomeBetTable.get({ id: $betId }),
+                        });
+                    },
+                },
+            },
+        };
+    }, "HubMakeOutcomeBetPlugin");
+}
+function generateRandomNumber() {
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0] / 2 ** 32;
+}
+function pickRandomOutcome(outcomes) {
+    assert(outcomes.length >= 2, "Outcome count must be >= 2");
+    const totalWeight = sum(outcomes.map((o) => o.weight));
+    const outcomesWithProbability = outcomes.map((o) => ({
+        ...o,
+        probability: o.weight / totalWeight,
+    }));
+    const totalProb = outcomesWithProbability.reduce((sum, outcome) => sum + outcome.probability, 0);
+    assert(Math.abs(totalProb - 1.0) < FLOAT_EPSILON, "Probabilities must sum to ~1");
+    const randomValue = generateRandomNumber();
+    let cumProb = 0;
+    for (let i = 0; i < outcomesWithProbability.length; i++) {
+        const outcome = outcomesWithProbability[i];
+        cumProb += outcome.probability;
+        if (randomValue <= cumProb) {
+            return { outcome, outcomeIdx: i };
+        }
+    }
+    return {
+        outcome: outcomes[outcomes.length - 1],
+        outcomeIdx: outcomes.length - 1,
+    };
+}
+async function dbLockBalanceAndBankroll(pgClient, { userId, casinoId, experienceId, currencyKey, }) {
+    assert(pgClient._inTransaction, "pgClient must be in a transaction");
+    const row = await pgClient
+        .query(`
+        WITH locked_balance AS (
+          SELECT amount
+          FROM hub.balance
+          WHERE user_id        = $1
+            AND casino_id      = $2
+            AND experience_id  = $3
+            AND currency_key   = $4
+
+          FOR UPDATE
+        )
+        SELECT
+          pb.amount as player_balance,
+          br.amount as house_bankroll
+        FROM locked_balance pb
+        JOIN hub.bankroll br
+          ON br.casino_id   = $2
+        AND br.currency_key = $4
+
+        FOR UPDATE OF br
+      `, [userId, casinoId, experienceId, currencyKey])
+        .then(maybeOneRow);
+    return row
+        ? {
+            found: true,
+            dbPlayerBalance: row.player_balance,
+            dbHouseBankroll: row.house_bankroll,
+        }
+        : {
+            found: false,
+            dbPlayerBalance: null,
+            dbHouseBankroll: null,
+        };
+}

package/package.json

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