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

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

@@ -1,12 +1,9 @@
-import { access, context, object, ObjectStep, polymorphicBranch, sideEffect, } from "postgraphile/grafast";
+import { context, object, sideEffect } from "postgraphile/grafast";
 import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
 import { z } from "zod";
 import { GraphQLError } from "graphql";
-import { DbHashKind, exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
+import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
-import { dbInsertHubHash, dbLockHubHashChain, } 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);
@@ -38,8 +35,6 @@ const InputSchema = z
         .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"),
-    hashChainId: z.string().uuid("Invalid hash chain ID"),
-    metadata: z.record(z.string(), z.any()).optional(),
 })
     .strict();
 const BetKindSchema = z
@@ -53,11 +48,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 }) {
@@ -75,18 +69,10 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
           wager: Int!
           currency: String!
           outcomes: [HubOutcomeInput!]!
-          hashChainId: UUID!
-          metadata: JSON
-        }
-
-        type HubMakeOutcomeBetSuccess {
-          bet: HubOutcomeBet!
         }
 
-        union HubMakeOutcomeBetResult = HubMakeOutcomeBetSuccess | HubBadHashChainError
-
         type HubMakeOutcomeBetPayload {
-          result: HubMakeOutcomeBetResult!
+          bet: HubOutcomeBet!
         }
 
         extend type Mutation {
@@ -99,7 +85,7 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                 Mutation: {
                     hubMakeOutcomeBet: (_, { $input }) => {
                         const $identity = context().get("identity");
-                        const $result = sideEffect([$identity, $input], async ([identity, rawInput]) => {
+                        const $betId = sideEffect([$identity, $input], async ([identity, rawInput]) => {
                             if (identity?.kind !== "user") {
                                 throw new GraphQLError("Unauthorized");
                             }
@@ -119,15 +105,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,76 +158,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, {
-                                    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 });
-                                        });
-                                    }
-                                    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}`);
-                                    }
-                                }
-                                await dbInsertHubHash(pgClient, {
-                                    hashChainId: dbHashChain.id,
-                                    kind: DbHashKind.INTERMEDIATE,
-                                    digest: betHashResult.hash,
-                                    iteration: betHashIteration,
-                                });
-                                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 = (() => {
-                                    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);
                                 const netPlayerAmount = input.wager * outcome.profit;
                                 await pgClient.query({
                                     text: `
@@ -283,27 +193,17 @@ 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,
                                     profit: outcome.profit,
                                     currency_key: dbCurrency.key,
-                                    hash_chain_id: input.hashChainId,
                                     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,
@@ -321,7 +221,6 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         user_id, 
                         casino_id, 
                         experience_id, 
-                        hash_chain_id,
                         kind,
                         currency_key, 
                         wager, 
@@ -330,14 +229,13 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                         outcome_idx,
                         metadata
                       )
-                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+                      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                       RETURNING id
                     `,
                                     values: [
                                         newBet.user_id,
                                         newBet.casino_id,
                                         newBet.experience_id,
-                                        newBet.hash_chain_id,
                                         newBet.kind,
                                         newBet.currency_key,
                                         newBet.wager,
@@ -348,31 +246,11 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
                                     ],
                                 })
                                     .then(exactlyOneRow);
-                                return {
-                                    __typename: "HubMakeOutcomeBetSuccess",
-                                    betId: bet.id,
-                                };
+                                return bet.id;
                             });
                         });
                         return object({
-                            result: $result,
-                        });
-                    },
-                },
-                HubMakeOutcomeBetSuccess: {
-                    __assertStep: ObjectStep,
-                    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: {},
+                            bet: outcomeBetTable.get({ id: $betId }),
                         });
                     },
                 },
@@ -380,13 +258,12 @@ export function MakeOutcomeBetPlugin({ betConfigs }) {
         };
     }, "HubMakeOutcomeBetPlugin");
 }
-function normalizeHash(hash) {
-    assert(hash.length >= 4, "Hash must be at least 4 bytes");
-    const view = new DataView(hash.buffer, hash.byteOffset, Math.min(hash.byteLength, 4));
-    const uint32Value = view.getUint32(0, false);
-    return uint32Value / Math.pow(2, 32);
+function generateRandomNumber() {
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0] / 2 ** 32;
 }
-function pickRandomOutcome({ outcomes, hash, }) {
+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) => ({
@@ -395,12 +272,12 @@ function pickRandomOutcome({ outcomes, hash, }) {
     }));
     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 = normalizeHash(hash);
-    let cumulativeProb = 0;
+    const randomValue = generateRandomNumber();
+    let cumProb = 0;
     for (let i = 0; i < outcomesWithProbability.length; i++) {
         const outcome = outcomesWithProbability[i];
-        cumulativeProb += outcome.probability;
-        if (randomValue <= cumulativeProb) {
+        cumProb += outcome.probability;
+        if (randomValue <= cumProb) {
             return { outcome, outcomeIdx: i };
         }
     }
@@ -446,41 +323,3 @@ async function dbLockBalanceAndBankroll(pgClient, { userId, casinoId, experience
             dbHouseBankroll: null,
         };
 }
-async function finishHashChainInBackground({ hashChainId, }) {
-    console.log("Finishing hash chain in background", { hashChainId });
-    const preimageHashResult = await getPreimageHash({
-        hashChainId,
-    });
-    console.log("Preimage hash result", { preimageHashResult });
-    if (preimageHashResult.type === "success") {
-        console.log("Inserting preimage hash", {
-            hashChainId,
-            kind: DbHashKind.PREIMAGE,
-            digest: preimageHashResult.hash,
-            iteration: 0,
-        });
-        await withPgPoolTransaction(superuserPool, async (pgClient) => {
-            await dbInsertHubHash(pgClient, {
-                hashChainId,
-                kind: DbHashKind.PREIMAGE,
-                digest: preimageHashResult.hash,
-                iteration: 0,
-            });
-            const result = await pgClient.query(`
-        UPDATE hub.hash_chain
-        SET current_iteration = 0,
-            active = false
-        WHERE id = $1
-      `, [hashChainId]);
-            if (result.rowCount !== 1) {
-                throw new Error("Failed to update hash chain iteration");
-            }
-        });
-    }
-    else {
-        console.warn("Failed to insert preimage hash in background", {
-            hashChainId,
-            error: preimageHashResult,
-        });
-    }
-}

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/process-transfers.js

@@ -6,7 +6,7 @@ import EventEmitter from "events";
 import { superuserPool } from "./db/index.js";
 import { dbGetCasinoById, dbGetCasinoSecretById } from "./db/internal.js";
 import pg from "pg";
-import * as config from "./config.js";
+import config from "./config.js";
 import { z } from "zod";
 import { gql } from "./__generated__/gql.js";
 import { logger } from "./logger.js";

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

@@ -2,7 +2,7 @@ import "graphile-config";
 import "postgraphile";
 import { makePgService } from "postgraphile/adaptors/pg";
 import { PostGraphileAmberPreset } from "postgraphile/presets/amber";
-import * as config from "../config.js";
+import config from "../config.js";
 import { maskError } from "./handle-errors.js";
 import * as db from "../db/index.js";
 import { SmartTagsPlugin } from "../smart-tags.js";
@@ -20,10 +20,6 @@ import { HubAddCasinoPlugin } from "../plugins/hub-add-casino.js";
 import { HubBalanceAlertPlugin } from "../plugins/hub-balance-alert.js";
 import { custom as customPgOmitArchivedPlugin } from "@graphile-contrib/pg-omit-archived";
 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,10 +35,6 @@ export const requiredPlugins = [
 export const defaultPlugins = [
     ...(config.NODE_ENV === "development" ? [DebugPlugin] : []),
     ...requiredPlugins,
-    HubOutcomeInputNonNullFieldsPlugin,
-    HubBadHashChainErrorPlugin,
-    HubCreateHashChainPlugin,
-    HubUserActiveHashChainPlugin,
     HubClaimFaucetPlugin,
     customPgOmitArchivedPlugin("deleted"),
 ];

package/dist/src/server/handle-errors.js

@@ -1,5 +1,5 @@
 import { GraphQLError } from "postgraphile/graphql";
-import * as config from "../config.js";
+import config from "../config.js";
 const isDev = config.NODE_ENV === "development";
 const isTest = config.NODE_ENV === "test";
 const camelCase = (s) => s.toLowerCase().replace(/(_\\w)/g, (m) => m[1].toUpperCase());

package/dist/src/server/index.js

@@ -3,7 +3,7 @@ import { grafserv } from "grafserv/express/v4";
 import postgraphile from "postgraphile";
 import { createPreset, defaultPlugins } from "./graphile.config.js";
 import express from "express";
-import * as config from "../config.js";
+import config from "../config.js";
 import { logger } from "../logger.js";
 import cors from "./middleware/cors.js";
 import authentication from "./middleware/authentication.js";

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

@@ -2,7 +2,7 @@ import { gql } from "../__generated__/gql.js";
 import { TakeRequestStatus as MpTakeRequestStatus, TransferStatusKind as MpTransferStatus, } from "../__generated__/graphql.js";
 import { exactlyOneRow, maybeOneRow, superuserPool, withPgPoolTransaction, } from "../db/index.js";
 import { assert } from "tsafe";
-import { PgAdvisoryLock } from "../pg-advisory-lock.js";
+import { pgAdvisoryLock } from "../pg-advisory-lock.js";
 const MP_PAGINATE_PENDING_TAKE_REQUESTS = gql(`
   query MpPaginatedPendingTakeRequests($controllerId: UUID!, $after: Cursor) {
     allTakeRequests(
@@ -178,7 +178,7 @@ async function fetchPendingTakeRequests(graphqlClient, controllerId) {
 }
 async function processSingleTakeRequest({ mpTakeRequestId, mpTakeRequest, casinoId, graphqlClient, }) {
     return withPgPoolTransaction(superuserPool, async (pgClient) => {
-        await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
             mpTakeRequestId,
             casinoId,
         });
@@ -457,7 +457,7 @@ async function processPendingTransferCompletions({ casinoId, graphqlClient, abor
 }
 async function completeTransfer({ mpTakeRequestId, takeRequestId, mpTransferId, graphqlClient, casinoId, }) {
     return withPgPoolTransaction(superuserPool, async (pgClient) => {
-        await PgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
+        await pgAdvisoryLock.forMpTakeRequestProcessing(pgClient, {
             mpTakeRequestId,
             casinoId,
         });

package/package.json

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

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

@@ -1,15 +0,0 @@
-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, }: {
-    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, }: {
-    hashChainId: DbHashChain["id"];
-    kind: DbHash["kind"];
-    digest: DbHash["digest"];
-    iteration: number;
-    metadata?: DbHash["metadata"];
-}): Promise<DbHash>;

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

@@ -1,35 +0,0 @@
-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");
-    return pgClient
-        .query(`
-       SELECT * 
-       FROM hub.hash_chain 
-       WHERE id = $1 
-         AND user_id = $2
-         AND experience_id = $3
-         AND casino_id = $4
-         AND active = TRUE
-       
-       FOR UPDATE
-    `, [hashChainId, userId, experienceId, casinoId])
-        .then(maybeOneRow)
-        .then((row) => row ?? null);
-}
-export async function dbInsertHubHash(pgClient, { hashChainId, kind, digest, iteration, metadata = {}, }) {
-    assert(pgClient._inTransaction, "dbInsertHash must be called in a transaction");
-    return pgClient
-        .query(`
-    INSERT INTO hub.hash (hash_chain_id, kind, digest, iteration, metadata)
-    VALUES ($1, $2, $3, $4, $5)
-    RETURNING *
-  `, [
-        hashChainId,
-        kind,
-        digest,
-        iteration,
-        metadata,
-    ])
-        .then(exactlyOneRow);
-}

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

@@ -1,17 +0,0 @@
-export type HashResult = {
-    type: "bad_hash_chain";
-    reason: "hashchain_too_old" | "empty_response";
-} | {
-    type: "success";
-    hash: Uint8Array;
-};
-export declare function getIntermediateHash({ hashChainId, iteration, }: {
-    hashChainId: string;
-    iteration: number;
-}): Promise<HashResult>;
-export declare function getPreimageHash({ hashChainId, }: {
-    hashChainId: string;
-}): Promise<HashResult>;
-export declare function getTerminalHash({ hashChainId, }: {
-    hashChainId: string;
-}): Promise<HashResult>;

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

@@ -1,57 +0,0 @@
-import { getHash } from "@moneypot/hash-herald";
-import * as config from "../config.js";
-const HASH_HERALD_OPTIONS = {
-    baseUrl: config.HASHCHAINSERVER_URL,
-    applicationSecret: config.HASHCHAINSERVER_APPLICATION_SECRET,
-};
-function resultFromGetHashResponse(response) {
-    if (!response.resp) {
-        return { type: "bad_hash_chain", reason: "empty_response" };
-    }
-    const $case = response.resp.$case;
-    switch ($case) {
-        case "hash":
-            return { type: "success", hash: response.resp.value };
-        case "hashchainTooOldError":
-            return { type: "bad_hash_chain", reason: "hashchain_too_old" };
-        default: {
-            const _exhaustiveCheck = $case;
-            throw new Error(`Unknown hash response: ${_exhaustiveCheck}`);
-        }
-    }
-}
-export async function getIntermediateHash({ hashChainId, iteration, }) {
-    const req = {
-        hashchainId: hashChainId,
-        iterations: iteration,
-        context: undefined,
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}
-export async function getPreimageHash({ hashChainId, }) {
-    const req = {
-        hashchainId: hashChainId,
-        iterations: 0,
-        context: {
-            event: {
-                $case: "fetchingPreimage",
-                value: {},
-            },
-        },
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}
-export async function getTerminalHash({ hashChainId, }) {
-    const iterations = 1_000;
-    const req = {
-        hashchainId: hashChainId,
-        iterations,
-        context: {
-            event: {
-                $case: "fetchingTerminalHash",
-                value: {},
-            },
-        },
-    };
-    return getHash(HASH_HERALD_OPTIONS, req).then(resultFromGetHashResponse);
-}

package/dist/src/hash-chain/plugins/hub-bad-hash-chain-error.d.ts

@@ -1 +0,0 @@
-export declare const HubBadHashChainErrorPlugin: GraphileConfig.Plugin;

package/dist/src/hash-chain/plugins/hub-bad-hash-chain-error.js

@@ -1,20 +0,0 @@
-import { ObjectStep, access } from "postgraphile/grafast";
-import { gql, makeExtendSchemaPlugin } from "postgraphile/utils";
-export const HubBadHashChainErrorPlugin = makeExtendSchemaPlugin(() => {
-    return {
-        typeDefs: gql `
-      type HubBadHashChainError {
-        message: String
-      }
-    `,
-        plans: {
-            HubBadHashChainError: {
-                __assertStep: ObjectStep,
-                message($data) {
-                    const $message = access($data, "message");
-                    return $message;
-                },
-            },
-        },
-    };
-}, "HubBadHashChainErrorPlugin");

package/dist/src/hash-chain/plugins/hub-create-hash-chain.d.ts

@@ -1 +0,0 @@
-export declare const HubCreateHashChainPlugin: GraphileConfig.Plugin;