@dust-dice/verifier 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dust-dice/verifier",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "description": "Independent verifier for Dust Dice: replays every roll of a finished table from the chain's own record \u2014 no operator, no trust \u2014 and the shared read-side helpers (compiled-contract handles, indexer queries).",
   "exports": {
@@ -28,11 +28,11 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-runtime": "0.19.0",
-    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "5.0.0-beta.7",
-    "@midnight-ntwrk/midnight-js-network-id": "5.0.0-beta.7",
-    "@midnight-ntwrk/midnight-js-protocol": "5.0.0-beta.7",
-    "@midnight-ntwrk/midnight-js-types": "5.0.0-beta.7"
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-network-id": "4.1.1",
+    "@midnight-ntwrk/midnight-js-protocol": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
@@ -60,8 +60,8 @@
     "dust-dice-verify": "dist/verify.js"
   },
   "peerDependencies": {
-    "@dust-dice/api": ">=0.4.0",
-    "@dust-dice/contract": ">=0.4.1"
+    "@dust-dice/api": "0.4.4",
+    "@dust-dice/contract": "0.4.4"
   },
   "//peerDependencies": "The verifier resolves the compiled contract artifacts from wherever @dust-dice/contract is installed next to it. As regular dependencies with exact pins, npm nested a second copy of the contract package under the verifier whenever the consumer's version differed \u2014 and that copy was the one its config found (dust-dice bug #33). Peers make the consumer's single copy the only one."
 }

package/src/contracts.ts

@@ -15,17 +15,21 @@
  */
 
 import { CompiledContract } from '@midnight-ntwrk/midnight-js-protocol/compact-js';
+import { ContractState } from '@midnight-ntwrk/midnight-js-protocol/compact-runtime';
 import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
 import {
   Table,
   Lobby,
   tableWitnesses,
   lobbyWitnesses,
+  unshieldedBalances,
+  type UnshieldedBalances,
   type TablePrivateState,
   type LobbyPrivateState,
 } from '@dust-dice/contract';
 
 import { NETWORK } from './config.ts';
+import { contractStateHexAt } from './indexer.ts';
 
 export { Table, Lobby };
 
@@ -71,6 +75,9 @@ export const CompiledLobbyContract = CompiledContract.make<Lobby.Contract<LobbyP
 export type TableLedger = Table.Ledger;
 export type LobbyLedger = Lobby.Ledger;
 
+/** Which state to read: the latest, or the one a specific transaction left behind. */
+export type LedgerAt = { txHash: string };
+
 /**
  * Read a table's ledger with a ONE-SHOT query.
  *
@@ -79,28 +86,45 @@ export type LobbyLedger = Lobby.Ledger;
  * driver -- and there is one after almost every transaction -- has to use `queryContractState`.
  * (bugs-found.md §0 #10; the same reason probes/gate0/src/step.ts reads this way.)
  *
- * `blockHeight` pins the read to a past block, which is what the chain-only verifier walks the
- * game with.
+ * `at.txHash` pins the read to the state a transaction left, which is what the chain-only
+ * verifier walks the game with. By TRANSACTION, not by block: on this indexer (4.3.x) a block
+ * offset means "the action in that block", and with simultaneous rounds several of a table's
+ * transactions routinely share one -- a block-keyed read cannot say which it returned. The SDK
+ * offers no transaction-hash offset, so that read goes straight to the indexer.
  */
-export async function readTableLedger(address: string, blockHeight?: number): Promise<TableLedger> {
-  const pdp = indexerPublicDataProvider(NETWORK.indexer, NETWORK.indexerWS);
-  const state =
-    blockHeight === undefined
-      ? await pdp.queryContractState(address)
-      : await pdp.queryContractState(address, { type: 'blockHeight', blockHeight });
-  if (!state) {
-    throw new Error(
-      `no contract state at ${address}${blockHeight === undefined ? '' : ` @ block ${blockHeight}`}`,
-    );
+export async function readContractState(address: string, at?: LedgerAt): Promise<ContractState> {
+  if (at === undefined) {
+    const pdp = indexerPublicDataProvider(NETWORK.indexer, NETWORK.indexerWS);
+    const state = await pdp.queryContractState(address);
+    if (!state) throw new Error(`no contract state at ${address}`);
+    return state;
   }
-  return Table.ledger(state.data);
+  const hex = await contractStateHexAt(address, at.txHash);
+  if (!hex) throw new Error(`no contract state at ${address} after tx ${at.txHash}`);
+  return ContractState.deserialize(Buffer.from(hex.replace(/^0x/, ''), 'hex'));
+}
+
+export async function readTableLedger(address: string, at?: LedgerAt): Promise<TableLedger> {
+  return Table.ledger((await readContractState(address, at)).data);
 }
 
 export async function readLobbyLedger(address: string): Promise<LobbyLedger> {
-  const pdp = indexerPublicDataProvider(NETWORK.indexer, NETWORK.indexerWS);
-  const state = await pdp.queryContractState(address);
-  if (!state) throw new Error(`no contract state at ${address}`);
-  return Lobby.ledger(state.data);
+  return Lobby.ledger((await readContractState(address)).data);
+}
+
+/**
+ * What the LEDGER says the contract holds, for checking against the `pot` it claims.
+ *
+ * Read out of the contract's own state, NOT out of the indexer's
+ * `contractAction { unshieldedBalances }` -- that field answers `[]` on this indexer even for a
+ * table sitting on a pot, which reads as a solvency alarm instead of a balance. See
+ * `@dust-dice/contract`'s `custody.ts` and the test that pins it.
+ */
+export async function contractUnshieldedBalances(
+  address: string,
+  at?: LedgerAt,
+): Promise<UnshieldedBalances> {
+  return unshieldedBalances(await readContractState(address, at));
 }
 
 /** `Dice` as the plain five-element array everything else in this repo speaks. */

package/src/indexer.ts

@@ -10,7 +10,6 @@
  * 4,900,000 in exactly this situation (docs/bugs-found.md §9). PER-TRANSACTION UTXO MOVEMENT IS
  * THE ONLY TRUSTWORTHY MEASURE, and it is what these queries read:
  *
- *   - `contractAction(address){ unshieldedBalances }`  what the LEDGER says the contract holds
  *   - `transactions(offset:{hash}){ unshieldedCreatedOutputs / unshieldedSpentOutputs }`
  *                                                     who actually received or spent what, with
  *                                                     `registeredForDustGeneration` per created
@@ -18,14 +17,17 @@
  *   - `transactions(offset:{hash}){ raw }`            the transaction's byte size, which is what
  *                                                     the `OutsideTimeToDismiss` admission check
  *                                                     measures
- *   - `contract(address){ actions }`                  the table's whole public history, which is
+ *   - `contractActions(address, offset)` subscription  the table's whole public history, which is
  *                                                     all the chain-only verifier is given
+ *   - `contractAction(address, offset:{transactionOffset})` the state one transaction left
  *
  * There is no user-address balance query in this indexer's schema (checked by introspecting
  * `__schema.queryType.fields`: only `bridgeBalance(address)` takes an address, and that is the
  * Cardano bridge, not NIGHT), so per-address totals are derived from the UTXO sets above.
  */
 
+import { NATIVE_TOKEN_HEX } from '@dust-dice/contract';
+
 import { NETWORK } from './config.ts';
 
 export interface GqlUnshieldedUtxo {
@@ -70,8 +72,11 @@ async function gql<T>(query: string, variables: Record<string, unknown> = {}): P
   return body.data;
 }
 
-/** The native (NIGHT) token type is 32 zero bytes. Matches Compact's `nativeToken()`. */
-export const NATIVE_TOKEN_HEX = '00'.repeat(32);
+/**
+ * The token-type constant and the balance decode live with the contract package, next to the
+ * ledger layout they read; re-exported here so callers of this module keep one import.
+ */
+export { NATIVE_TOKEN_HEX, nativeBalance } from '@dust-dice/contract';
 
 const isNative = (u: { tokenType: string }): boolean =>
   u.tokenType.replace(/^0x/, '').toLowerCase() === NATIVE_TOKEN_HEX;
@@ -84,35 +89,11 @@ export function sumNativeFor(utxos: GqlUnshieldedUtxo[], owner: string): bigint
   return sumNative(utxos.filter((u) => u.owner === owner));
 }
 
-/**
- * The contract's own unshielded balances as the LEDGER sees them, keyed by token-type hex.
- *
- * `unshieldedBalances` hangs off `ContractAction`, NOT off `Contract` -- `contract(address)`
- * returns a `Contract` whose only fields are address/state/maintenanceAuthority/actions.
- * `contractAction(address)` returns the latest action, which is what carries the running
- * balances, and all three action variants declare the field so it selects on the interface.
- */
-export async function contractUnshieldedBalances(address: string): Promise<Record<string, bigint>> {
-  const data = await gql<{
-    contractAction: { unshieldedBalances: { tokenType: string; amount: string }[] } | null;
-  }>(
-    `query ($address: HexEncoded!) {
-       contractAction(address: $address) { unshieldedBalances { tokenType amount } }
-     }`,
-    { address },
-  );
-  const out: Record<string, bigint> = {};
-  for (const b of data.contractAction?.unshieldedBalances ?? [])
-    out[b.tokenType] = BigInt(b.amount);
-  return out;
-}
-
-export function nativeBalance(balances: Record<string, bigint>): bigint {
-  for (const [k, v] of Object.entries(balances)) {
-    if (k.replace(/^0x/, '').toLowerCase() === NATIVE_TOKEN_HEX) return v;
-  }
-  return 0n;
-}
+// What the contract HOLDS is deliberately NOT read here. The schema does offer
+// `contractAction { unshieldedBalances }`, and it answers `[]` for every action of every
+// contract on this indexer -- tables sitting on a pot included -- so a custody check built on
+// it reports a solvent table as empty, which is the shape of a solvency alarm. Custody comes
+// from the contract's own state: `contracts.ts`'s `contractUnshieldedBalances`.
 
 /**
  * One transaction by hash, with its UTXO deltas and its raw bytes.
@@ -164,42 +145,151 @@ export const allowanceMs = (bytes: number): number => Math.max(15.0, 0.002 * byt
 /** The floor a contract call must clear to be admitted at all, in bytes. */
 export const ADMISSION_FLOOR_BYTES = 7984;
 
+/**
+ * One graphql-transport-ws subscription, collected until `done` accepts a row (that row included)
+ * or `max` rows have arrived.
+ *
+ * A raw WebSocket on purpose: the protocol is four message types -- init, ack, subscribe, next --
+ * and a client library would be a second copy of what the SDK already bundles. Node's global
+ * WebSocket (22+, this package's floor) is all it needs.
+ */
+function subscribeUntil<T>(
+  query: string,
+  variables: Record<string, unknown>,
+  field: string,
+  done: (row: T) => boolean,
+  max: number,
+  timeoutMs = 60_000,
+): Promise<T[]> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(NETWORK.indexerWS, 'graphql-transport-ws');
+    const rows: T[] = [];
+    let settled = false;
+    const finish = (err?: Error): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      ws.close();
+      if (err) reject(err);
+      else resolve(rows);
+    };
+    const timer = setTimeout(
+      () => finish(new Error(`indexer subscription ${field}: still open after ${timeoutMs} ms`)),
+      timeoutMs,
+    );
+    ws.onopen = () => ws.send(JSON.stringify({ type: 'connection_init' }));
+    ws.onerror = () => finish(new Error(`indexer subscription ${field}: websocket error`));
+    ws.onclose = () =>
+      finish(new Error(`indexer subscription ${field}: closed after ${rows.length} rows`));
+    ws.onmessage = (ev) => {
+      const m = JSON.parse(String(ev.data)) as { type: string; payload?: unknown };
+      if (m.type === 'connection_ack') {
+        ws.send(JSON.stringify({ id: '1', type: 'subscribe', payload: { query, variables } }));
+      } else if (m.type === 'next') {
+        const p = m.payload as { data?: Record<string, T>; errors?: { message: string }[] };
+        if (p.errors?.length) {
+          finish(new Error(`indexer GraphQL: ${p.errors.map((e) => e.message).join('; ')}`));
+          return;
+        }
+        const row = p.data?.[field];
+        if (row === undefined) return;
+        rows.push(row);
+        if (done(row) || rows.length >= max) finish();
+      } else if (m.type === 'error') {
+        finish(
+          new Error(`indexer subscription ${field}: ${JSON.stringify(m.payload).slice(0, 300)}`),
+        );
+      } else if (m.type === 'complete') {
+        finish();
+      }
+    };
+  });
+}
+
+const sameAddress = (a: string, b: string): boolean =>
+  a.replace(/^0x/, '').toLowerCase() === b.replace(/^0x/, '').toLowerCase();
+
 /**
  * A contract's whole public history, oldest first.
  *
  * This is the ONLY thing `verify.ts` is given beyond the table's address: every join, every
  * turn and the settlement are recovered from these actions and the contract states they point
- * at. The indexer returns them newest-first, so they are reversed here.
+ * at.
+ *
+ * The indexer this build talks to (4.3.x, the preprod line) has no query that LISTS a contract's
+ * actions -- the ledger-9 `contract(address){ actions }` is gone. It has the `contractActions`
+ * SUBSCRIPTION, which replays every action from a block offset and then stays open for new ones;
+ * it is what midnight-js's own provider uses. The stream has no "caught up" marker of its own,
+ * so the latest action is fetched first over plain HTTP and its transaction ends the collection
+ * -- after as many rows as that transaction has actions on this contract, because a fast turn is
+ * one transaction carrying up to seven calls and stopping at the first would drop the rest. The
+ * deploy block comes from the same query (`ContractCall.deploy`), so nothing from before the
+ * contract existed is streamed.
  */
 export async function contractActions(address: string, limit = 1000): Promise<ContractAction[]> {
   type Row = {
     __typename: ContractAction['kind'];
     entryPoint?: string;
-    transaction: { hash: string; block: { height: number; timestamp: string } };
+    transaction: { hash: string; block: { height: number; timestamp: string | number } };
   };
-  const data = await gql<{ contract: { actions: Row[] } | null }>(
-    `query ($address: HexEncoded!, $limit: Int!) {
-       contract(address: $address) {
-         actions(limit: $limit) {
-           __typename
-           ... on ContractCall { entryPoint transaction { hash block { height timestamp } } }
-           ... on ContractDeploy { transaction { hash block { height timestamp } } }
-           ... on ContractUpdate { transaction { hash block { height timestamp } } }
-         }
+  const head = await gql<{
+    contractAction: (Row & { deploy?: { transaction: { block: { height: number } } } }) | null;
+  }>(
+    `query ($address: HexEncoded!) {
+       contractAction(address: $address) {
+         __typename
+         transaction { hash block { height timestamp } }
+         ... on ContractCall { deploy { transaction { block { height } } } }
        }
      }`,
-    { address, limit },
+    { address },
+  );
+  if (!head.contractAction) throw new Error(`no contract at ${address}`);
+  const latest = head.contractAction;
+  const fromHeight = latest.deploy?.transaction.block.height ?? latest.transaction.block.height;
+
+  const lastTx = await gql<{ transactions: { contractActions: { address: string }[] }[] }>(
+    `query ($hash: HexEncoded!) {
+       transactions(offset: { hash: $hash }) { contractActions { address } }
+     }`,
+    { hash: latest.transaction.hash },
+  );
+  const lastTxActions = (lastTx.transactions[0]?.contractActions ?? []).filter((a) =>
+    sameAddress(a.address, address),
+  ).length;
+
+  let seenOfLast = 0;
+  const rows = await subscribeUntil<Row>(
+    `subscription ($address: HexEncoded!, $offset: BlockOffset) {
+       contractActions(address: $address, offset: $offset) {
+         __typename
+         ... on ContractCall { entryPoint }
+         transaction { hash block { height timestamp } }
+       }
+     }`,
+    { address, offset: { height: fromHeight } },
+    'contractActions',
+    (row) => row.transaction.hash === latest.transaction.hash && ++seenOfLast >= lastTxActions,
+    limit,
+  );
+  return rows.map((a) => ({
+    kind: a.__typename,
+    entryPoint: a.entryPoint,
+    txHash: a.transaction.hash,
+    blockHeight: a.transaction.block.height,
+    blockTimestamp: Number(a.transaction.block.timestamp),
+  }));
+}
+
+/** The state a specific transaction left the contract in, as the indexer's hex; null if none. */
+export async function contractStateHexAt(address: string, txHash: string): Promise<string | null> {
+  const data = await gql<{ contractAction: { state: string } | null }>(
+    `query ($address: HexEncoded!, $hash: HexEncoded!) {
+       contractAction(address: $address, offset: { transactionOffset: { hash: $hash } }) { state }
+     }`,
+    { address, hash: txHash },
   );
-  if (!data.contract) throw new Error(`no contract at ${address}`);
-  return data.contract.actions
-    .map((a) => ({
-      kind: a.__typename,
-      entryPoint: a.entryPoint,
-      txHash: a.transaction.hash,
-      blockHeight: a.transaction.block.height,
-      blockTimestamp: Number(a.transaction.block.timestamp),
-    }))
-    .reverse();
+  return data.contractAction?.state ?? null;
 }
 
 /** Current chain tip, for sanity-checking that blocks are being produced. */

package/src/verify.ts

@@ -26,7 +26,7 @@
  *      having replayed every earlier round in order;
  *   4. every score, recomputed from the dice with api/src/rules.ts -- the contract-canonical
  *      rules engine, not the circuit -- matches the scorecard the chain holds, box by box,
- *      including the upper bonus and the Yahtzee bonuses;
+ *      including the upper bonus and the five-of-a-kind bonuses;
  *   5. the winner the tie-break selects, among SURVIVORS, is the seat the chain paid;
  *   6. the settle transaction spent ZERO user inputs and created exactly the two expected
  *      outputs, to the addresses recorded at join and at construction.
@@ -195,9 +195,9 @@ const GROUP_RANK: Record<string, number> = {
 /**
  * Read the table's whole history: every transaction, and the state it left behind.
  *
- * One `queryContractState` per transaction, pinned to its block. `contractStateObservable` is
- * not usable for this -- it misses rapid successive updates and its first emission may predate
- * the write being read (bugs-found.md §0 #10).
+ * One state read per transaction, pinned to that transaction. `contractStateObservable` is not
+ * usable for this -- it misses rapid successive updates and its first emission may predate the
+ * write being read (bugs-found.md §0 #10).
  */
 async function readHistory(address: string): Promise<LogGroup[]> {
   const actions = (await contractActions(address)).filter((a) => a.kind !== 'ContractDeploy');
@@ -210,7 +210,7 @@ async function readHistory(address: string): Promise<LogGroup[]> {
       blockHeight: calls[0]!.blockHeight,
       txHash,
       entryPoints: calls.map((x) => x.entryPoint ?? '?'),
-      led: await readTableLedger(address, calls[0]!.blockHeight),
+      led: await readTableLedger(address, { txHash }),
       sharesBlock: false,
     });
   }
@@ -241,7 +241,7 @@ function seatCard(led: TableLedger, seat: number): Scorecard {
   const c = led.seatCard.lookup(BigInt(seat));
   return {
     scores: c.filled.map((f, i) => (f ? Number(c.scores[i]) : null)),
-    yahtzeeBonuses: Number(c.yahtzeeBonuses),
+    fiveOfAKindBonuses: Number(c.fiveOfAKindBonuses),
   };
 }