@moneypot/hub 1.3.0-dev.15 → 1.3.0-dev.4

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

@@ -2,7 +2,6 @@ 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";
-export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";

package/dist/src/db/index.js

@@ -5,7 +5,6 @@ import { exactlyOneRow, maybeOneRow } from "./util.js";
 import { logger } from "../logger.js";
 import { setTimeout } from "node:timers/promises";
 import { assert } from "tsafe";
-export * from "../hash-chain/db-hash-chain.js";
 export * from "./types.js";
 export * from "./public.js";
 export * from "./util.js";

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

@@ -138,7 +138,3 @@ export type DbHash = {
     digest: Uint8Array;
     metadata: Record<string, unknown>;
 };
-export type DbHubOutcome = {
-    weight: number;
-    profit: number;
-};

package/dist/src/hash-chain/db-hash-chain.d.ts

@@ -1,12 +1,12 @@
 import { DbCasino, DbExperience, DbHash, DbHashChain, DbUser } from "../db/types.js";
 import { PgClientInTransaction } from "../db/index.js";
-export declare function dbLockHubHashChain(pgClient: PgClientInTransaction, { userId, experienceId, casinoId, hashChainId, }: {
+export declare function dbLockHashChain(pgClient: PgClientInTransaction, { userId, experienceId, casinoId, hashChainId, }: {
     userId: DbUser["id"];
     experienceId: DbExperience["id"];
     casinoId: DbCasino["id"];
     hashChainId: DbHashChain["id"];
 }): Promise<DbHashChain | null>;
-export declare function dbInsertHubHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, metadata, }: {
+export declare function dbInsertHash(pgClient: PgClientInTransaction, { hashChainId, kind, digest, iteration, metadata, }: {
     hashChainId: DbHashChain["id"];
     kind: DbHash["kind"];
     digest: DbHash["digest"];

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

@@ -1,7 +1,7 @@
 import { exactlyOneRow, maybeOneRow, } from "../db/index.js";
 import { assert } from "tsafe";
-export async function dbLockHubHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
-    assert(pgClient._inTransaction, "dbLockHubHashChain must be called in a transaction");
+export async function dbLockHashChain(pgClient, { userId, experienceId, casinoId, hashChainId, }) {
+    assert(pgClient._inTransaction, "dbLockHashChain must be called in a transaction");
     return pgClient
         .query(`
        SELECT * 
@@ -17,7 +17,7 @@ export async function dbLockHubHashChain(pgClient, { userId, experienceId, casin
         .then(maybeOneRow)
         .then((row) => row ?? null);
 }
-export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, metadata = {}, }) {
+export async function dbInsertHash(pgClient, { hashChainId, kind, digest, iteration, metadata = {}, }) {
     assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
     return pgClient
         .query(`

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

@@ -1,15 +1,4 @@
 import { z } from "zod";
-import { Result } from "../util.js";
-declare const OutcomeSchema: z.ZodObject<{
-    weight: z.ZodNumber;
-    profit: z.ZodNumber;
-}, "strict", z.ZodTypeAny, {
-    profit: number;
-    weight: number;
-}, {
-    profit: number;
-    weight: number;
-}>;
 declare const InputSchema: z.ZodObject<{
     kind: z.ZodString;
     wager: z.ZodNumber;
@@ -18,62 +7,49 @@ declare const InputSchema: z.ZodObject<{
         weight: z.ZodNumber;
         profit: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
-        profit: number;
         weight: number;
-    }, {
         profit: number;
+    }, {
         weight: number;
-    }>, "many">, {
         profit: number;
+    }>, "many">, {
         weight: number;
-    }[], {
         profit: number;
+    }[], {
         weight: number;
-    }[]>, {
         profit: number;
+    }[]>, {
         weight: number;
-    }[], {
         profit: number;
+    }[], {
         weight: number;
+        profit: number;
     }[]>;
     hashChainId: z.ZodString;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strict", z.ZodTypeAny, {
     currency: string;
-    hashChainId: string;
     kind: string;
+    hashChainId: string;
     wager: number;
     outcomes: {
-        profit: number;
         weight: number;
+        profit: number;
     }[];
-    metadata?: Record<string, any> | undefined;
 }, {
     currency: string;
-    hashChainId: string;
     kind: string;
+    hashChainId: string;
     wager: number;
     outcomes: {
-        profit: number;
         weight: number;
+        profit: number;
     }[];
-    metadata?: Record<string, any> | undefined;
 }>;
 type Input = z.infer<typeof InputSchema>;
-type Outcome = z.infer<typeof OutcomeSchema>;
-type FinalizeMetadataData = {
-    wager: number;
-    currencyKey: string;
-    clientSeed: string;
-    hash: Uint8Array;
-    outcomes: Outcome[];
-    outcomeIdx: number;
-};
 export type OutcomeBetConfig = {
     houseEdge: number;
     saveOutcomes: boolean;
-    initializeMetadataFromUntrustedUserInput?: (input: Input) => Result<Record<string, any>, string>;
-    finalizeMetadata?: (validatedMetadata: Record<string, any>, data: FinalizeMetadataData) => Record<string, any>;
+    getMetadata?: (input: Input) => Promise<Record<string, any>>;
 };
 export type OutcomeBetConfigMap<BetKind extends string> = {
     [betKind in BetKind]: OutcomeBetConfig;

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

@@ -4,9 +4,8 @@ import { z } from "zod";
 import { GraphQLError } from "graphql";
 import { DbHashKind, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
-import { dbInsertHubHash, dbLockHubHashChain, } from "../hash-chain/db-hash-chain.js";
+import { dbInsertHash, dbLockHashChain } from "../hash-chain/db-hash-chain.js";
 import { getIntermediateHash, getPreimageHash, } from "../hash-chain/get-hash.js";
-import { createHmac } from "node:crypto";
 const FLOAT_EPSILON = 1e-10;
 function sum(ns) {
     return ns.reduce((a, b) => a + b, 0);
@@ -39,7 +38,6 @@ const InputSchema = z
         .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"),
     hashChainId: z.string().uuid("Invalid hash chain ID"),
-    metadata: z.record(z.string(), z.any()).optional(),
 })
     .strict();
 const BetKindSchema = z
@@ -53,11 +51,10 @@ const BetConfigsSchema = z.record(BetKindSchema, z.object({
         .gte(0, "House edge must be >= 0")
         .lte(1, "House edge must be <= 1"),
     saveOutcomes: z.boolean(),
-    initializeMetadataFromUntrustedUserInput: z
-        .function()
-        .optional(),
-    finalizeMetadata: z
+    getMetadata: z
         .function()
+        .args(InputSchema)
+        .returns(z.record(z.string(), z.any()))
         .optional(),
 }));
 export function MakeOutcomeBetPlugin({ betConfigs }) {
@@ -76,14 +73,13 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           currency: String!
           outcomes: [HubOutcomeInput!]!
           hashChainId: UUID!
-          metadata: JSON
         }
 
-        type HubMakeOutcomeBetSuccess {
+        type HubMakeOutcomeBetOk {
           bet: HubOutcomeBet!
         }
 
-        union HubMakeOutcomeBetResult = HubMakeOutcomeBetSuccess | HubBadHashChainError
+        union HubMakeOutcomeBetResult = HubMakeOutcomeBetOk | HubBadHashChainError
 
         type HubMakeOutcomeBetPayload {
           result: HubMakeOutcomeBetResult!
@@ -119,15 +115,8 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                             if (!betConfig) {
                                 throw new GraphQLError(`Invalid bet kind`);
                             }
-                            let initializedMetadata;
-                            if (betConfig.initializeMetadataFromUntrustedUserInput) {
-                                const result = betConfig.initializeMetadataFromUntrustedUserInput(input);
-                                if (result.ok) {
-                                    initializedMetadata = result.value;
-                                }
-                                else {
-                                    throw new GraphQLError(`Invalid input: ${result.error}`);
-                                }
+                            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);
@@ -179,7 +168,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 if (maxPotentialPayout > maxAllowablePayout) {
                                     throw new GraphQLError(`House risk limit exceeded. Max payout: ${maxPotentialPayout.toFixed(4)}`);
                                 }
-                                const dbHashChain = await dbLockHubHashChain(pgClient, {
+                                const dbHashChain = await dbLockHashChain(pgClient, {
                                     userId: session.user_id,
                                     experienceId: session.experience_id,
                                     casinoId: session.casino_id,
@@ -223,7 +212,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         throw new Error(`Unknown bet hash result: ${_exhaustiveCheck}`);
                                     }
                                 }
-                                await dbInsertHubHash(pgClient, {
+                                await dbInsertHash(pgClient, {
                                     hashChainId: dbHashChain.id,
                                     kind: DbHashKind.INTERMEDIATE,
                                     digest: betHashResult.hash,
@@ -237,18 +226,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 if (result.rowCount !== 1) {
                                     throw new GraphQLError("Failed to update hash chain iteration");
                                 }
-                                const finalHash = (() => {
-                                    const serverHash = betHashResult.hash;
-                                    const clientSeed = dbHashChain.client_seed;
-                                    const finalHash = createHmac("sha256", serverHash)
-                                        .update(clientSeed)
-                                        .digest();
-                                    return finalHash;
-                                })();
-                                const { outcome, outcomeIdx } = pickRandomOutcome({
-                                    outcomes: input.outcomes,
-                                    hash: finalHash,
-                                });
+                                const { outcome, outcomeIdx } = pickRandomOutcome(input.outcomes, betHashResult.hash);
                                 const netPlayerAmount = input.wager * outcome.profit;
                                 await pgClient.query({
                                     text: `
@@ -283,17 +261,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                         input.wager,
                                     ],
                                 });
-                                const immutableData = structuredClone({
-                                    wager: input.wager,
-                                    currencyKey: dbCurrency.key,
-                                    clientSeed: dbHashChain.client_seed,
-                                    hash: betHashResult.hash,
-                                    outcomes: input.outcomes,
-                                    outcomeIdx,
-                                });
-                                const finalizedMetadata = betConfig.finalizeMetadata
-                                    ? betConfig.finalizeMetadata(initializedMetadata, immutableData)
-                                    : initializedMetadata;
                                 const newBet = {
                                     kind: rawInput.kind,
                                     wager: input.wager,
@@ -303,7 +270,9 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     user_id: session.user_id,
                                     casino_id: session.casino_id,
                                     experience_id: session.experience_id,
-                                    metadata: finalizedMetadata || {},
+                                    metadata: betConfig.getMetadata
+                                        ? await betConfig.getMetadata(input)
+                                        : {},
                                     ...(betConfig.saveOutcomes
                                         ? {
                                             outcomes: input.outcomes,
@@ -349,7 +318,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                 })
                                     .then(exactlyOneRow);
                                 return {
-                                    __typename: "HubMakeOutcomeBetSuccess",
+                                    __typename: "HubMakeOutcomeBetOk",
                                     betId: bet.id,
                                 };
                             });
@@ -359,7 +328,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         });
                     },
                 },
-                HubMakeOutcomeBetSuccess: {
+                HubMakeOutcomeBetOk: {
                     __assertStep: ObjectStep,
                     bet($data) {
                         const $betId = access($data, "betId");
@@ -371,7 +340,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                     result($data) {
                         const $result = $data.get("result");
                         return polymorphicBranch($result, {
-                            HubMakeOutcomeBetSuccess: {},
+                            HubMakeOutcomeBetOk: {},
                             HubBadHashChainError: {},
                         });
                     },
@@ -386,7 +355,7 @@ function normalizeHash(hash) {
     const uint32Value = view.getUint32(0, false);
     return uint32Value / Math.pow(2, 32);
 }
-function pickRandomOutcome({ outcomes, hash, }) {
+function pickRandomOutcome(outcomes, hash) {
     assert(outcomes.length >= 2, "Outcome count must be >= 2");
     const totalWeight = sum(outcomes.map((o) => o.weight));
     const outcomesWithProbability = outcomes.map((o) => ({
@@ -460,7 +429,7 @@ async function finishHashChainInBackground({ hashChainId, }) {
             iteration: 0,
         });
         await withPgPoolTransaction(superuserPool, async (pgClient) => {
-            await dbInsertHubHash(pgClient, {
+            await dbInsertHash(pgClient, {
                 hashChainId,
                 kind: DbHashKind.PREIMAGE,
                 digest: preimageHashResult.hash,

package/dist/src/plugins/hub-user-balance-by-currency.js

@@ -1,30 +1,55 @@
-import { access, constant, context } from "postgraphile/grafast";
+import { access, context, loadOne, object, } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-import { TYPES } from "postgraphile/@dataplan/pg";
-import { sql } from "postgraphile/pg-sql2";
+import { superuserPool } from "../db/index.js";
+import { pgSelectSingleFromRecord, } from "postgraphile/@dataplan/pg";
 export const HubUserBalanceByCurrencyPlugin = makeExtendSchemaPlugin((build) => {
-    const balanceTable = build.input.pgRegistry.pgResources.hub_balance;
+    const balances = build.input.pgRegistry.pgResources.hub_balance;
     return {
         typeDefs: gql `
         extend type HubUser {
-          hubBalanceByCurrency(currency: String!): HubBalance
+          balanceByCurrency(currency: String!): HubBalance
         }
       `,
         plans: {
             HubUser: {
-                hubBalanceByCurrency: ($record, { $currency }) => {
+                balanceByCurrency: ($record, { $currency }) => {
                     const $identity = context().get("identity");
-                    const $balances = balanceTable.find();
-                    $balances.where(sql `
-              ${$balances}.currency_key = ${$balances.placeholder($currency, TYPES.text)}
-              AND ${$balances}.user_id = ${$balances.placeholder($record.get("id"), TYPES.uuid)}
-              AND ${$balances}.casino_id = ${$balances.placeholder(access($identity, ["session", "casino_id"]), TYPES.uuid)}
-              AND ${$balances}.experience_id = ${$balances.placeholder(access($identity, ["session", "experience_id"]), TYPES.uuid)}
-            `);
-                    $balances.setFirst(constant(1));
-                    return $balances.single();
+                    const $params = object({
+                        currency: $currency,
+                        targetUserId: $record.get("id"),
+                        casino_id: access($identity, ["session", "casino_id"]),
+                        experience_id: access($identity, ["session", "experience_id"]),
+                    });
+                    const $balance = loadOne($params, batchGetUserBalanceByCurrency);
+                    return pgSelectSingleFromRecord(balances, $balance);
                 },
             },
         },
     };
 });
+async function batchGetUserBalanceByCurrency(paramsArray) {
+    const values = [];
+    const valuePlaceholders = [];
+    paramsArray.forEach((p, index) => {
+        const baseIndex = index * 4 + 1;
+        valuePlaceholders.push(`($${baseIndex}, $${baseIndex + 1}::uuid, $${baseIndex + 2}::uuid, $${baseIndex + 3}::uuid)`);
+        values.push(p.currency, p.targetUserId, p.casino_id, p.experience_id);
+    });
+    const sql = `
+    SELECT b.*
+    FROM hub.balance b
+    JOIN (
+      VALUES
+        ${valuePlaceholders.join(",\n        ")}
+    ) AS vals(currency_key, user_id, casino_id, experience_id)
+    ON b.currency_key = vals.currency_key
+    AND b.user_id = vals.user_id
+    AND b.casino_id = vals.casino_id
+    AND b.experience_id = vals.experience_id
+  `;
+    const { rows } = await superuserPool.query(sql, values);
+    return paramsArray.map((p) => rows.find((row) => row.currency_key === p.currency &&
+        row.user_id === p.targetUserId &&
+        row.casino_id === p.casino_id &&
+        row.experience_id === p.experience_id));
+}

package/dist/src/server/graphile.config.js

@@ -23,7 +23,6 @@ import { HubCurrentXPlugin } from "../plugins/hub-current-x.js";
 import { HubCreateHashChainPlugin } from "../hash-chain/plugins/hub-create-hash-chain.js";
 import { HubBadHashChainErrorPlugin } from "../hash-chain/plugins/hub-bad-hash-chain-error.js";
 import { HubUserActiveHashChainPlugin } from "../hash-chain/plugins/hub-user-active-hash-chain.js";
-import { HubOutcomeInputNonNullFieldsPlugin } from "../plugins/hub-outcome-input-non-null-fields.js";
 export const requiredPlugins = [
     SmartTagsPlugin,
     IdToNodeIdPlugin,
@@ -39,7 +38,6 @@ export const requiredPlugins = [
 export const defaultPlugins = [
     ...(config.NODE_ENV === "development" ? [DebugPlugin] : []),
     ...requiredPlugins,
-    HubOutcomeInputNonNullFieldsPlugin,
     HubBadHashChainErrorPlugin,
     HubCreateHashChainPlugin,
     HubUserActiveHashChainPlugin,

package/package.json

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

package/dist/src/plugins/hub-outcome-input-non-null-fields.d.ts

@@ -1,18 +0,0 @@
-import { GraphQLInputFieldConfig } from "graphql";
-export declare const HubOutcomeInputNonNullFieldsPlugin: {
-    name: string;
-    version: string;
-    description: string;
-    schema: {
-        hooks: {
-            GraphQLInputObjectType_fields_field: (field: GraphQLInputFieldConfig, build: any, context: any) => {
-                type: any;
-                description?: import("graphql/jsutils/Maybe.js").Maybe<string>;
-                defaultValue?: unknown;
-                deprecationReason?: import("graphql/jsutils/Maybe.js").Maybe<string>;
-                extensions?: import("graphql/jsutils/Maybe.js").Maybe<Readonly<import("graphql").GraphQLInputFieldExtensions>>;
-                astNode?: import("graphql/jsutils/Maybe.js").Maybe<import("graphql").InputValueDefinitionNode>;
-            };
-        };
-    };
-};

package/dist/src/plugins/hub-outcome-input-non-null-fields.js

@@ -1,20 +0,0 @@
-export const HubOutcomeInputNonNullFieldsPlugin = {
-    name: "HubOutcomeInputNonNullFieldsPlugin",
-    version: "0.0.0",
-    description: "Specifies that HubOutcomeInput fields are non-null",
-    schema: {
-        hooks: {
-            GraphQLInputObjectType_fields_field: (field, build, context) => {
-                const { scope: { fieldName }, } = context;
-                if (context.scope.pgCodec?.name === "hubOutcome" &&
-                    ["profit", "weight"].includes(fieldName)) {
-                    return {
-                        ...field,
-                        type: new build.graphql.GraphQLNonNull(field.type),
-                    };
-                }
-                return field;
-            },
-        },
-    },
-};