From fcdd05f2b1b38ee5cf8ce4b676137b271860a9a1 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 17 Nov 2026 21:42:28 -0500 Subject: [PATCH 1/2] [ownership] Server-side deck ownership, collection API, 40-card eligibility (#57) - server/game/ownership.ts: verifyAccount, resolveDeck (token ids only; canonical owner in linked wallets, confirmations, exact deckSize, 4 copies per pageId, cards rebuilt from their block), collection (all linked wallets, paged at one tip, no 128-block cap). Signature agreed with host-pvp on #57. - server/game/collection.ts: GET /api/game/collection (Dex bearer) with owned, playable, needed, eligible. - account router exports accountVerifier; http.ts shares one AccountStore and DexKeys between the account and game routes and passes gameRouter({ownership}). - App.tsx: My collection counts cards in every wallet linked to the account. - tests/ownership-deck.test.ts: in-memory ledger fixture, no network. Co-Authored-By: Claude Opus 5.5 --- docs/game/OWNERSHIP_API.md | 73 ++++++++++ server/account/router.ts | 19 ++- server/game/collection.ts | 57 ++++++++ server/game/index.ts | 5 +- server/game/ownership.ts | 211 +++++++++++++++++++++++++++ server/testnet/http.ts | 13 +- src/App.tsx | 8 +- tests/ownership-deck.test.ts | 275 +++++++++++++++++++++++++++++++++++ 8 files changed, 653 insertions(+), 8 deletions(-) create mode 100644 docs/game/OWNERSHIP_API.md create mode 100644 server/game/collection.ts create mode 100644 server/game/ownership.ts create mode 100644 tests/ownership-deck.test.ts diff --git a/docs/game/OWNERSHIP_API.md b/docs/game/OWNERSHIP_API.md new file mode 100644 index 0000000..0a03096 --- /dev/null +++ b/docs/game/OWNERSHIP_API.md @@ -0,0 +1,73 @@ +# Ownership and collection API (Night 2, #57) + +Server-side checks that a player owns the cards they play. Off-chain only: nothing here moves, burns or locks a card, and nothing changes consensus. + +## The rules (ruleset data) + +| Key | Default | Meaning | +|---|---|---| +| `deckSize` | 40 | A constructed deck has exactly this many cards. A testnet mode file may lower it. | +| `maxCopiesPerPage` | 4 | The MTG-style copy limit. Cards minted from the same Wikipedia `pageId` are separate cards, but at most this many go in one deck. | +| `minConfirmations` | 1 | The confirmations each card's mint block needs. Rated play uses `RATED_MIN_CONFIRMATIONS` = 3. | + +## `server/game/ownership.ts` (used by the PvP host) + +```ts +verifyAccount(deps, idToken: unknown): Promise +resolveDeck(deps, account, tokenIds: unknown, opts?: Partial): Promise +collection(deps, account, opts?: { minConfirmations?: number }): Promise +``` + +- **`deps`** is `{ ledger, accounts, verifyIdToken }`. In production, `server/testnet/http.ts` builds it from the node's `Ledger`, the shared `AccountStore`, and `accountVerifier()` from `server/account/router.ts`. It passes the result to `gameRouter({ ownership })`. +- **`resolveDeck`** accepts token ids only, never card JSON. For each card it checks: + - the card is on the canonical chain (`ledger.nft()`); + - its current owner (after transfers) is one of the account's linked wallets; + - it has enough confirmations; + - the deck size and copy limit. + + Each card is rebuilt from its own block (`article` and `statsSnapshot`). The cards come back in the order given. +- **Errors** are thrown as `DeckError { code, status, tokenIds, pageId? }`. `tokenIds` lists every offending card of that class. + + | `code` | `status` | + |---|---| + | `auth` | 401 | + | `size` | 400 | + | `duplicate-token` | 400 | + | `unknown-token` (not on chain, or malformed) | 400 | + | `not-owned` (includes "no linked wallet") | 403 | + | `unconfirmed` | 400 | + | `copy-limit` | 400 | + + `OwnershipUnavailable` (503) means Dex is unreachable or the chain tip kept moving during a read. +- **`collection`** pages `ledger.deck()` (24 per page) across every linked wallet at one canonical tip, restarting if the tip moves. There is no 128-block snapshot cap. + +## `GET /api/game/collection` + +`Authorization: Bearer ` (the same token as `/api/account/me`). Optional: `?minConfirmations=N`. + +```ts +{ + tip, wallets: string[], + deckSize: 40, copyLimit: 4, maxCopiesPerPage: 4, minConfirmations: 1, + owned: number, // confirmed cards across all linked wallets + playable: number, // Σ min(copies, copyLimit) per pageId + needed: number, // max(0, deckSize - playable) + eligible: boolean, // playable >= deckSize + cards: ChainCard[] // tokenId, owner, confirmations, pageId, title, revisionId, url, extract, imageUrl?, + // height, blockHash, createdAt, powHash, article, statsSnapshot +} +``` + +| Case | Response | +|---|---| +| No linked wallets | 200 with `cards: []` and `needed: 40` | +| Missing or invalid token | 401 | +| Dex unreachable | 503 | +| Bad query | 400 | + +The UI shows `playable / deckSize`, for example "23 / 40 cards", and how to mine. + +## Not covered (known gaps) + +- **Peer hosts.** Account stores are per node, and a Dex token sent to a peer could be replayed elsewhere (engineer review §2, G6). This API is for the self-hosted node only. The stretch fix is a wallet-signed deck claim. +- **Plausibility of minted stats** (G5): `pageId` → `title` and `revisionId` → `size` are not cross-checked yet. diff --git a/server/account/router.ts b/server/account/router.ts index 9fe0530..44c8a36 100644 --- a/server/account/router.ts +++ b/server/account/router.ts @@ -12,12 +12,28 @@ export type AccountDeps = { config?: OidcConfig; keys?: DexKeys; store?: Account type Authed = Request & { account?: Account }; const hex64 = z.string().regex(/^[a-f0-9]{64}$/); +/** + * Verifies a Dex ID token and records the account. Shared with the game routes + * (server/game/collection.ts, the PvP host) so every route uses the same store and keys. + * Throws TokenError (status 401) for a bad token; other errors mean Dex is unreachable. + */ +export function accountVerifier(config: OidcConfig, keys: Pick, store: Pick, + now: () => number = Date.now): (idToken: string) => Promise { + return async idToken => { + const claims = await verifyIdToken(idToken, keys, config, { now: now() }); + const account: Account = { sub: claims.sub, issuer: claims.iss, name: displayName(claims), username: claims.preferred_username ?? '' }; + store.upsert(account); + return account; + }; +} + export function createAccountRouter(deps: AccountDeps = {}): Router { const config = deps.config ?? oidcConfig(); const now = deps.now ?? Date.now; const keys = deps.keys ?? new DexKeys(config, deps.fetcher, now); const store = deps.store ?? new AccountStore(resolve(deps.dataDir ?? 'data', 'accounts.sqlite'), now); const router = Router(); + const verify = accountVerifier(config, keys, store, now); const toAccount = (claims: Awaited>): Account => ({ sub: claims.sub, issuer: claims.iss, name: displayName(claims), username: claims.preferred_username ?? '' }); @@ -26,8 +42,7 @@ export function createAccountRouter(deps: AccountDeps = {}): Router { try { const m = /^Bearer ([A-Za-z0-9_.-]+)$/.exec(req.get('authorization') ?? ''); if (!m) throw new TokenError('Log in with your eom.dev account'); - req.account = toAccount(await verifyIdToken(m[1], keys, config, { now: now() })); - store.upsert(req.account); + req.account = await verify(m[1]); next(); } catch (e) { next(e); } }; diff --git a/server/game/collection.ts b/server/game/collection.ts new file mode 100644 index 0000000..74044b2 --- /dev/null +++ b/server/game/collection.ts @@ -0,0 +1,57 @@ +/** + * GET /api/game/collection Authorization: Bearer [?minConfirmations=N] + * + * Every card the account's linked wallets own (no 128-block cap) and whether that is enough to + * build a deck. Eligibility counts the copy limit: 40 copies of one article is 4 playable cards. + */ +import { Router, type Request, type Response } from 'express'; +import { DeckError, collectionAt, ownershipRules, playableCount, verifyAccount, + type ChainCard, type OwnershipDeps, type OwnershipRules } from './ownership.ts'; + +export type CollectionResponse = { + tip: string; + wallets: string[]; + deckSize: number; + /** Max copies per pageId. `maxCopiesPerPage` is the same value under the ruleset's name. */ + copyLimit: number; + maxCopiesPerPage: number; + minConfirmations: number; + /** Confirmed cards across all linked wallets. */ + owned: number; + /** Σ min(copies, copyLimit) per pageId: the most cards a legal deck can draw from. */ + playable: number; + /** max(0, deckSize - playable). */ + needed: number; + /** playable >= deckSize. */ + eligible: boolean; + cards: ChainCard[]; +}; + +export function collectionResponse(deps: Pick, sub: string, + rules?: Partial): CollectionResponse { + const r = ownershipRules(rules); + const { tip, wallets, cards } = collectionAt(deps, { sub }, { minConfirmations: r.minConfirmations }); + const playable = playableCount(cards, r.maxCopiesPerPage); + return { tip, wallets, deckSize: r.deckSize, copyLimit: r.maxCopiesPerPage, maxCopiesPerPage: r.maxCopiesPerPage, + minConfirmations: r.minConfirmations, owned: cards.length, playable, needed: Math.max(0, r.deckSize - playable), + eligible: playable >= r.deckSize, cards }; +} + +export function collectionRouter(deps: OwnershipDeps & { rules?: Partial }): Router { + const router = Router(); + router.get('/', async (req: Request, res: Response) => { + res.setHeader('Cache-Control', 'no-store'); + const q = req.query.minConfirmations; + if (q !== undefined && (typeof q !== 'string' || !/^[1-9]\d{0,3}$/.test(q))) { res.status(400).json({ error: 'Invalid minConfirmations' }); return; } + const m = /^Bearer ([A-Za-z0-9_.-]{1,8192})$/.exec(req.get('authorization') ?? ''); + try { + const account = await verifyAccount(deps, m?.[1]); + res.json(collectionResponse(deps, account.sub, { ...deps.rules, ...(q ? { minConfirmations: Number(q) } : {}) })); + } catch (e) { + const err = e as Error & { status?: number }; + const status = e instanceof DeckError ? err.status! : err.status === 503 ? 503 : 500; + res.status(status).json({ error: status === 500 ? 'Collection unavailable' : err.message }); + } + }); + return router; +} diff --git a/server/game/index.ts b/server/game/index.ts index b9a1a97..4ed375b 100644 --- a/server/game/index.ts +++ b/server/game/index.ts @@ -12,11 +12,14 @@ import { createGameRouter } from './router.ts'; import { MatchStore } from './store.ts'; import type { EnginePort } from './engine-port.ts'; import { TrendCache } from './trends.ts'; +import type { OwnershipDeps } from './ownership.ts'; type Enrichment = { get(pageId: number): Promise<{ pageviews: { trendPercent: number | null } }> }; export async function gameRouter(options: { dataDir: string | null; enrichment?: Enrichment; - engine?: EnginePort; env?: NodeJS.ProcessEnv; warmTrends?: boolean; handleSignals?: boolean }): Promise { + engine?: EnginePort; env?: NodeJS.ProcessEnv; warmTrends?: boolean; handleSignals?: boolean; + /** Server-side ownership (#57) for ./ownership.ts verifyAccount/resolveDeck/collection; absent in Night 1 tests. */ + ownership?: OwnershipDeps }): Promise { const env = options.env ?? process.env; const engine = options.engine ?? (await import('./engine-binding.ts')).engineBinding; const modes = loadModes(env); diff --git a/server/game/ownership.ts b/server/game/ownership.ts new file mode 100644 index 0000000..6d27de3 --- /dev/null +++ b/server/game/ownership.ts @@ -0,0 +1,211 @@ +/** + * Server-side ownership for constructed play (Night 2, #57). Signature agreed with host-pvp (#56). + * + * The host never trusts card data from a client. A deck arrives as token ids only; each one + * must be on the canonical chain, owned by one of the account's linked wallets, and confirmed + * enough. The card is then rebuilt from its own block (article + mint stats snapshot). + * + * Off-chain only: nothing here moves, burns or locks a card, and nothing touches consensus. + * No Wikipedia calls; the only I/O is the injected ID-token verifier (Dex JWKS, cached). + */ +import type { Account } from '../account/store.ts'; +import type { Article } from '../../shared/protocol.ts'; +import type { MintStatsSnapshot } from '../../shared/enrichment.ts'; +import type { TestnetBlock } from '../../shared/testnet.ts'; + +export type OwnershipRules = { + /** Exact deck size for constructed play. Production is 40; a testnet mode file may lower it. */ + deckSize: number; + /** MTG-style copy limit: cards minted from the same Wikipedia pageId. */ + maxCopiesPerPage: number; + /** Minimum confirmations of each card's mint block (1 casual, 3 rated). */ + minConfirmations: number; +}; +export const DEFAULT_OWNERSHIP_RULES: Readonly = Object.freeze({ deckSize: 40, maxCopiesPerPage: 4, minConfirmations: 1 }); +export const RATED_MIN_CONFIRMATIONS = 3; +/** Upper bound on any deck request we will even look at (a deck is 40; this only guards the loop). */ +export const MAX_DECK_TOKENS = 200; +/** Guard against an unbounded collection. Far above anything the chain can mint for one player soon. */ +export const MAX_COLLECTION = 20_000; +/** server/testnet/ledger.ts MAX_DECK_PAGE. */ +const PAGE = 24; +/** A tip change mid-scan restarts the scan; give up after this many rather than loop forever. */ +const MAX_RESTARTS = 4; + +// Structural: server/testnet/ledger.ts `Ledger` and server/account/store.ts `AccountStore` +// satisfy these, and tests pass in-memory fixtures. +export type OwnershipLedger = { + nft(tokenId: string): { block: TestnetBlock; owner: string; sequence: number; confirmations: number } | undefined; + deck(address: string, offset: number, limit: number): { + tip: string; total: number; next: number | null; + nfts: { block: TestnetBlock; sequence: number; confirmations: number }[]; + }; + summary(): { tip: string; height: number }; +}; +export type OwnershipAccounts = { wallets(sub: string): { address: string }[]; upsert?(a: Account): void }; +export type OwnershipDeps = { + ledger: OwnershipLedger; + accounts: OwnershipAccounts; + /** server/account/router.ts accountVerifier(); throws an error with status 401 for a bad token. */ + verifyIdToken(idToken: string): Promise; +}; + +/** One owned NFT as built from its canonical block (never from client JSON). */ +export type ChainCard = { + tokenId: string; + /** Current owner (after transfers), one of the account's linked wallets. */ + owner: string; + confirmations: number; + pageId: number; + title: string; + revisionId: number; + url: string; + extract: string; + imageUrl?: string; + height: number; + blockHash: string; + createdAt: number; + powHash: string; + article: Article; + statsSnapshot: MintStatsSnapshot; +}; + +export type DeckErrorCode = 'auth' | 'size' | 'duplicate-token' | 'unknown-token' | 'not-owned' | 'unconfirmed' | 'copy-limit'; +const STATUS: Record = { + auth: 401, size: 400, 'duplicate-token': 400, 'unknown-token': 400, 'not-owned': 403, unconfirmed: 400, 'copy-limit': 400, +}; +export class DeckError extends Error { + readonly code: DeckErrorCode; + /** Every offending token of this class, so the UI can highlight them. */ + readonly tokenIds: string[]; + readonly status: 400 | 401 | 403; + readonly pageId?: number; + constructor(code: DeckErrorCode, message: string, tokenIds: string[] = [], pageId?: number) { + super(message); + this.name = 'DeckError'; + this.code = code; this.tokenIds = tokenIds; this.status = STATUS[code]; + if (pageId !== undefined) this.pageId = pageId; + } +} +/** Thrown when Dex or the ledger cannot answer right now (not the player's fault). */ +export class OwnershipUnavailable extends Error { readonly status = 503; } + +const TOKEN = /^[a-f0-9]{64}$/; +const isInt = (n: unknown, min: number, max: number): n is number => Number.isSafeInteger(n) && (n as number) >= min && (n as number) <= max; + +/** Merges partial rules over the defaults and rejects nonsense (mode files are data, so validate). */ +export function ownershipRules(rules: Partial = {}): OwnershipRules { + const defined = Object.fromEntries(Object.entries(rules).filter(([, v]) => v !== undefined)) as Partial; + const r = { ...DEFAULT_OWNERSHIP_RULES, ...defined }; + if (!isInt(r.deckSize, 1, MAX_DECK_TOKENS)) throw new RangeError(`deckSize must be 1..${MAX_DECK_TOKENS}`); + if (!isInt(r.maxCopiesPerPage, 1, MAX_DECK_TOKENS)) throw new RangeError(`maxCopiesPerPage must be 1..${MAX_DECK_TOKENS}`); + if (!isInt(r.minConfirmations, 1, 1_000_000)) throw new RangeError('minConfirmations must be >= 1'); + return r; +} + +/** Builds the card from the canonical block. `owner` is the current owner from the index, not the miner. */ +export function cardFromChain(nft: { block: TestnetBlock; confirmations: number }, owner: string): ChainCard { + const b = structuredClone(nft.block); + const card: ChainCard = { tokenId: b.tokenId, owner, confirmations: nft.confirmations, + pageId: b.article.pageId, title: b.article.title, revisionId: b.article.revisionId, url: b.article.url, extract: b.article.extract, + height: b.height, blockHash: b.hash, createdAt: b.createdAt, powHash: b.powHash, article: b.article, statsSnapshot: b.statsSnapshot }; + if (b.article.image) card.imageUrl = b.article.image; + return card; +} + +/** Verifies a Dex ID token from a request body. Throws DeckError('auth') or OwnershipUnavailable. */ +export async function verifyAccount(deps: Pick, idToken: unknown): Promise { + if (typeof idToken !== 'string' || !idToken || idToken.length > 8192) throw new DeckError('auth', 'Log in with your eom.dev account to play with your cards'); + try { return await deps.verifyIdToken(idToken); } + catch (e) { + if ((e as { status?: number }).status === 401) throw new DeckError('auth', (e as Error).message || 'Log in again with your eom.dev account'); + throw new OwnershipUnavailable('eom.dev login is temporarily unavailable'); + } +} + +/** + * Verifies a constructed deck for an already-verified account. Resolves to the cards in the + * order given, or throws the first class of DeckError found (listing every offending token). + */ +export async function resolveDeck(deps: Pick, account: Pick, tokenIds: unknown, + opts?: Partial): Promise { + const r = ownershipRules(opts); + if (!Array.isArray(tokenIds) || tokenIds.length > MAX_DECK_TOKENS) throw new DeckError('size', `A deck is exactly ${r.deckSize} cards`); + const invalid = tokenIds.filter(t => typeof t !== 'string' || !TOKEN.test(t)).map(t => String(t).slice(0, 80)).slice(0, 10); + if (invalid.length) throw new DeckError('unknown-token', 'Invalid card identifier', invalid); + const ids = tokenIds as string[]; + if (ids.length !== r.deckSize) throw new DeckError('size', `A deck is exactly ${r.deckSize} cards (got ${ids.length})`); + const seen = new Set(), dupes = new Set(); + for (const id of ids) (seen.has(id) ? dupes : seen).add(id); + if (dupes.size) throw new DeckError('duplicate-token', 'The same card appears more than once', [...dupes]); + + const wallets = new Set(deps.accounts.wallets(account.sub).map(w => w.address)); + if (!wallets.size) throw new DeckError('not-owned', 'Link a wallet to your eom.dev account to play with your cards', ids); + + const cards: ChainCard[] = [], missing: string[] = [], foreign: string[] = [], young: string[] = []; + for (const id of ids) { + const nft = deps.ledger.nft(id); + if (!nft || nft.block.tokenId !== id) { missing.push(id); continue; } + if (!wallets.has(nft.owner)) { foreign.push(id); continue; } + if (nft.confirmations < r.minConfirmations) { young.push(id); continue; } + cards.push(cardFromChain(nft, nft.owner)); + } + if (missing.length) throw new DeckError('unknown-token', 'Card not found on the canonical chain', missing); + if (foreign.length) throw new DeckError('not-owned', 'Card is not owned by a wallet linked to this account', foreign); + if (young.length) throw new DeckError('unconfirmed', `Card needs ${r.minConfirmations} confirmation${r.minConfirmations === 1 ? '' : 's'}`, young); + + const byPage = new Map(); + for (const c of cards) byPage.set(c.pageId, [...(byPage.get(c.pageId) ?? []), c.tokenId]); + for (const [pageId, tokens] of byPage) + if (tokens.length > r.maxCopiesPerPage) throw new DeckError('copy-limit', `At most ${r.maxCopiesPerPage} copies of the same article`, tokens, pageId); + return cards; +} + +/** + * Every card the account owns across its linked wallets, read at one canonical tip (restarting + * if the tip moves), with no snapshot cap. Only cards with `minConfirmations` (default 1). + */ +export async function collection(deps: Pick, account: Pick, + opts: { minConfirmations?: number } = {}): Promise { + return collectionAt(deps, account, opts).cards; +} + +/** collection() plus the tip and wallets it was read at. Synchronous. */ +export function collectionAt(deps: Pick, account: Pick, + opts: { minConfirmations?: number } = {}): { tip: string; wallets: string[]; cards: ChainCard[] } { + const minConfirmations = ownershipRules({ minConfirmations: opts.minConfirmations }).minConfirmations; + const wallets = [...new Set(deps.accounts.wallets(account.sub).map(w => w.address))]; + for (let attempt = 0; attempt <= MAX_RESTARTS; attempt++) { + const tip = deps.ledger.summary().tip; + const cards = scan(deps.ledger, wallets, tip, minConfirmations); + if (cards) return { tip, wallets, cards }; + } + throw new OwnershipUnavailable('The chain is moving too fast to read a consistent collection; try again'); +} + +/** Returns null if the tip moved during the scan. */ +function scan(ledger: OwnershipLedger, wallets: string[], tip: string, minConfirmations: number): ChainCard[] | null { + const cards: ChainCard[] = []; + for (const address of wallets) { + let offset: number | null = 0; + while (offset !== null) { + const page = ledger.deck(address, offset, PAGE); + if (page.tip !== tip) return null; + for (const nft of page.nfts) { + if (nft.confirmations >= minConfirmations) cards.push(cardFromChain(nft, address)); + if (cards.length > MAX_COLLECTION) throw new OwnershipUnavailable('Collection too large to list'); + } + // Defensive: a page that makes no progress would loop forever. + offset = page.next !== null && page.next > offset ? page.next : null; + } + } + return cards; +} + +/** How many of these cards a legal deck could use under the copy limit: Σ min(copies, limit) per pageId. */ +export function playableCount(cards: Pick[], maxCopiesPerPage: number): number { + const perPage = new Map(); + for (const c of cards) perPage.set(c.pageId, (perPage.get(c.pageId) ?? 0) + 1); + let n = 0; for (const count of perPage.values()) n += Math.min(count, maxCopiesPerPage); + return n; +} diff --git a/server/testnet/http.ts b/server/testnet/http.ts index be6d366..9053218 100644 --- a/server/testnet/http.ts +++ b/server/testnet/http.ts @@ -17,7 +17,10 @@ import { IS_MAINNET, PROFILE } from '../../shared/network.ts'; import { assertLaunchAllowed, launchManifest } from '../launch.ts'; import { resourceConfig, RpcBudget, RpcError } from '../resources.ts'; import { trustedProxies, operationsPort, startOperations } from '../operations.ts'; -import { createAccountRouter } from '../account/router.ts'; +import { accountVerifier, createAccountRouter } from '../account/router.ts'; +import { AccountStore } from '../account/store.ts'; +import { DexKeys, oidcConfig } from '../account/oidc.ts'; +import { collectionRouter } from '../game/collection.ts'; const root = fileURLToPath(new URL('../../', import.meta.url)); assertLaunchAllowed(); @@ -150,8 +153,12 @@ app.post('/p2p/transaction',workLimit,async(req,res)=>{ const id=await ledger.submitTransaction(transaction); res.status(202).json({id,status:'pending'}); }); -app.use('/api/account',createAccountRouter({dataDir})); -app.use('/api/game',await (await import('../game/index.ts')).gameRouter({dataDir,enrichment:wikipediaEnrichment})); +// One account store and one Dex key cache, shared by the account and game routes (#57). +const oidc=oidcConfig(), dexKeys=new DexKeys(oidc), accounts=new AccountStore(resolve(dataDir,'accounts.sqlite')); +const ownership={ledger,accounts,verifyIdToken:accountVerifier(oidc,dexKeys,accounts)}; +app.use('/api/account',createAccountRouter({config:oidc,keys:dexKeys,store:accounts})); +app.use('/api/game/collection',collectionRouter(ownership)); +app.use('/api/game',await (await import('../game/index.ts')).gameRouter({dataDir,enrichment:wikipediaEnrichment,ownership})); app.use(['/api','/p2p'],(_req,res)=>{res.status(404).json({error:'Unknown testnet endpoint'});}); app.use(express.static(resolve(root,'dist'))); app.get('/{*path}',(_req,res)=>res.sendFile(resolve(root,'dist/index.html'))); diff --git a/src/App.tsx b/src/App.tsx index e302ace..19dd2fe 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -10,7 +10,7 @@ import { Card, samples, imageCredit, type CardData } from './Card.tsx'; import { WalletPanel } from './WalletPanel.tsx'; import { useModalFocus } from './useModalFocus.ts'; import { ThemePicker } from './ThemePicker.tsx'; -import { LoginButton } from './auth/LoginButton.tsx'; +import { LoginButton, useAccount } from './auth/LoginButton.tsx'; import { TradeDesk } from './TradeDesk.tsx'; import { IS_MAINNET, NETWORK_GENESIS_TIME, NETWORK_LABEL } from '../shared/network.ts'; import { StateClient } from '../shared/rpc-client.ts'; @@ -48,6 +48,7 @@ function transferProblem(state: TestnetSnapshot, card: CardData, address: string export default function App() { const [view, setView] = useState('Discover'); + const linkedAccount = useAccount(); const [wallet, setWallet] = useState(); const [snapshot, setSnapshot] = useState(); const [rpcAvailable, setRpcAvailable] = useState(false); @@ -127,7 +128,10 @@ export default function App() { } catch (e) { setTransferError(message(e)); } finally { transferInFlight.current = false; setTransferBusy(false); } }; - const owned = snapshot?.blocks.filter(b => wallet && testnetOwnerOf(snapshot, b.tokenId) === wallet.address) ?? []; + // Every canonical card owned by this browser's wallet or any wallet linked to the eom.dev account (#57). + // The full canonical chain is paged in by StateClient, so nothing is capped at 128 blocks. + const mine = new Set([wallet?.address, ...(linkedAccount?.wallets ?? []).map(w => w.address)].filter(Boolean)); + const owned = snapshot?.blocks.filter(b => mine.has(testnetOwnerOf(snapshot, b.tokenId) ?? '')) ?? []; const visibleCards = view === 'My collection' ? owned.map(asCard) : snapshot?.blocks.length ? [...snapshot.blocks].reverse().slice(0, 12).map(asCard) : samples; const filtered = visibleCards.filter(c => (category === 'All cards' || c.article.category === category) && diff --git a/tests/ownership-deck.test.ts b/tests/ownership-deck.test.ts new file mode 100644 index 0000000..309801c --- /dev/null +++ b/tests/ownership-deck.test.ts @@ -0,0 +1,275 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createHash } from 'node:crypto'; +import express from 'express'; +import type { AddressInfo } from 'node:net'; +import { resolveDeck, collection, verifyAccount, playableCount, ownershipRules, DEFAULT_OWNERSHIP_RULES, + DeckError, OwnershipUnavailable, type OwnershipDeps, type OwnershipLedger } from '../server/game/ownership.ts'; +import { collectionRouter, collectionResponse } from '../server/game/collection.ts'; +import type { Account } from '../server/account/store.ts'; +import type { TestnetBlock } from '../shared/testnet.ts'; + +// In-memory fixture: the same shape as Ledger.nft/deck/summary and AccountStore.wallets. No network. +const hex = (s: string) => createHash('sha256').update(s).digest('hex'); +const ALICE = hex('alice'), ALICE2 = hex('alice-2'), BOB = hex('bob'); + +function block(n: number, pageId: number, miner: string): TestnetBlock { + return { + version: 6, network: 'testnet', chainId: 'test', height: n, previousHash: hex(`b${n - 1}`), createdAt: 1_800_000_000 + n, + article: { pageId, title: `Article ${pageId}`, extract: `Extract ${pageId}.`, url: `https://en.wikipedia.org/?curid=${pageId}`, + revisionId: 1000 + pageId, source: 'live', category: 'History' }, + statsSnapshot: { capturedAt: '2026-11-17T00:00:00Z', revisionId: 1000 + pageId, pageBytes: 5000 + pageId, languageCount: 3, + languagesTruncated: false, pageviews: null } as unknown as TestnetBlock['statsSnapshot'], + owner: miner, publicKey: 'pk', nonce: 0, target: 'f'.repeat(64), key: '0'.repeat(64), transactionsRoot: '0'.repeat(64), + stateRoot: '0'.repeat(64), hash: hex(`b${n}`), tokenId: hex(`t${n}`), powHash: hex(`p${n}`), signature: 'sig', transactions: [], + } as unknown as TestnetBlock; +} + +class FakeLedger implements OwnershipLedger { + tip = 'tip-0'; + height = 0; + cards: { block: TestnetBlock; owner: string }[] = []; + deckCalls = 0; + onDeck?: () => void; + mint(owner: string, pageId: number): string { + const b = block(++this.height, pageId, owner); + this.cards.push({ block: b, owner }); + this.tip = `tip-${this.height}`; + return b.tokenId; + } + mineEmpty(n = 1) { this.height += n; this.tip = `tip-${this.height}`; } + transfer(token: string, to: string) { this.cards.find(c => c.block.tokenId === token)!.owner = to; } + private conf(b: TestnetBlock) { return this.height - b.height + 1; } + nft(token: string) { + const c = this.cards.find(x => x.block.tokenId === token); + return c ? { block: structuredClone(c.block), owner: c.owner, sequence: 0, confirmations: this.conf(c.block) } : undefined; + } + deck(address: string, offset: number, limit: number) { + this.deckCalls++; + assert.ok(limit <= 24, 'ledger pages are at most 24'); + const mine = this.cards.filter(c => c.owner === address); + const nfts = mine.slice(offset, offset + limit).map(c => ({ block: structuredClone(c.block), sequence: 0, confirmations: this.conf(c.block) })); + const result = { tip: this.tip, total: mine.length, next: offset + nfts.length < mine.length ? offset + nfts.length : null, nfts }; + this.onDeck?.(); + return result; + } + summary() { return { tip: this.tip, height: this.height, network: 'testnet', chainId: 'test' }; } +} + +function fixture(wallets: Record = { alice: [ALICE, ALICE2], bob: [BOB] }) { + const ledger = new FakeLedger(); + const deps: OwnershipDeps = { ledger, accounts: { wallets: sub => (wallets[sub] ?? []).map(address => ({ address })) }, + verifyIdToken: async (t: string): Promise => { + const m = /^good\.token\.(\w+)$/.exec(t); + if (m) return { sub: m[1], issuer: 'https://dex.example/', name: m[1], username: m[1] }; + if (t === 'dex.is.down') throw new Error('fetch failed'); + throw Object.assign(new Error('Token expired'), { status: 401 }); + } }; + return { ledger, deps }; +} +/** n cards for `owner`, distinct pageIds starting at `firstPage`. */ +const mintMany = (l: FakeLedger, owner: string, n: number, firstPage = 1) => Array.from({ length: n }, (_, i) => l.mint(owner, firstPage + i)); + +const ALICE_ACCT = { sub: 'alice' }, BOB_ACCT = { sub: 'bob' }; +async function rejects(p: Promise, code: string, tokenIds?: string[]) { + await assert.rejects(p, (e: unknown) => { + assert.ok(e instanceof DeckError, String(e)); + assert.equal(e.code, code); + if (tokenIds) assert.deepEqual(e.tokenIds, tokenIds); + return true; + }); +} + +test('defaults are a 40-card deck, 4 copies per article, 1 confirmation', () => { + assert.deepEqual({ ...DEFAULT_OWNERSHIP_RULES }, { deckSize: 40, maxCopiesPerPage: 4, minConfirmations: 1 }); + assert.equal(ownershipRules({ deckSize: 10, minConfirmations: undefined }).minConfirmations, 1); + assert.throws(() => ownershipRules({ deckSize: 0 }), RangeError); + assert.throws(() => ownershipRules({ maxCopiesPerPage: 1.5 }), RangeError); + assert.throws(() => ownershipRules({ minConfirmations: 0 }), RangeError); +}); + +test('verifyAccount maps token failures to DeckError(auth) and Dex outages to OwnershipUnavailable', async () => { + const { deps } = fixture(); + assert.equal((await verifyAccount(deps, 'good.token.alice')).sub, 'alice'); + for (const t of [undefined, '', 42, 'x'.repeat(9000)]) await rejects(verifyAccount(deps, t), 'auth'); + await assert.rejects(verifyAccount(deps, 'bad'), (e: unknown) => e instanceof DeckError && e.code === 'auth' && e.status === 401 && e.message === 'Token expired'); + await assert.rejects(verifyAccount(deps, 'dex.is.down'), (e: unknown) => e instanceof OwnershipUnavailable && e.status === 503); +}); + +test('resolveDeck accepts 40 owned cards across linked wallets and builds them from the chain, in order', async () => { + const { ledger, deps } = fixture(); + const ids = [...mintMany(ledger, ALICE, 25, 1), ...mintMany(ledger, ALICE2, 15, 100)].reverse(); + const cards = await resolveDeck(deps, ALICE_ACCT, ids); + assert.equal(cards.length, 40); + assert.deepEqual(cards.map(c => c.tokenId), ids); + const c = cards.find(x => x.pageId === 100)!; + const chain = ledger.nft(c.tokenId)!.block; + assert.equal(c.owner, ALICE2); + assert.equal(c.title, 'Article 100'); + assert.equal(c.revisionId, 1100); + assert.equal(c.article.title, 'Article 100'); + assert.equal(c.statsSnapshot.pageBytes, 5100); + assert.equal(c.blockHash, chain.hash); + assert.equal(c.powHash, chain.powHash); + assert.equal(c.height, chain.height); +}); + +test('resolveDeck takes token ids only: card data is never taken from the client', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 40); + const forged = ids.map(tokenId => ({ tokenId, article: { title: 'Barack Obama' }, statsSnapshot: { pageBytes: 9e9 } })); + await rejects(resolveDeck(deps, ALICE_ACCT, forged), 'unknown-token'); +}); + +test('resolveDeck enforces the exact deck size from ruleset data', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 41); + for (const deck of [ids.slice(0, 39), ids, [], 'nope', null, Array(10_000).fill(ids[0])]) await rejects(resolveDeck(deps, ALICE_ACCT, deck), 'size'); + assert.equal((await resolveDeck(deps, ALICE_ACCT, ids.slice(0, 10), { deckSize: 10 })).length, 10, 'a testnet mode may lower deckSize'); +}); + +test('resolveDeck rejects malformed and duplicated token ids', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 40); + await rejects(resolveDeck(deps, ALICE_ACCT, [...ids.slice(0, 39), 'ABC']), 'unknown-token', ['ABC']); + await rejects(resolveDeck(deps, ALICE_ACCT, [...ids.slice(0, 39), ids[0]]), 'duplicate-token', [ids[0]]); +}); + +test('resolveDeck requires a linked wallet', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 40); + await assert.rejects(resolveDeck(deps, { sub: 'stranger' }, ids), (e: unknown) => e instanceof DeckError && e.code === 'not-owned' && e.status === 403 && /Link a wallet/.test(e.message)); +}); + +test('resolveDeck rejects unknown cards and cards owned by someone else, listing every one', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 38); + const bobs = mintMany(ledger, BOB, 2, 500); + await rejects(resolveDeck(deps, ALICE_ACCT, [...ids, ...bobs]), 'not-owned', bobs); + await rejects(resolveDeck(deps, ALICE_ACCT, [...ids, hex('nope'), bobs[0]]), 'unknown-token', [hex('nope')]); + // Bob cannot field Alice's cards either, even though they exist. + await rejects(resolveDeck(deps, BOB_ACCT, [...ids, ...bobs]), 'not-owned', ids); +}); + +test('ownership follows transfers: the current owner, not the miner, may play the card', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 40); + ledger.transfer(ids[7], BOB); + await rejects(resolveDeck(deps, ALICE_ACCT, ids), 'not-owned', [ids[7]]); + const cards = await resolveDeck(deps, BOB_ACCT, [ids[7], ...mintMany(ledger, BOB, 39, 300)]); + assert.equal(cards[0].owner, BOB); +}); + +test('resolveDeck requires minConfirmations (3 for rated play)', async () => { + const { ledger, deps } = fixture(); + const ids = mintMany(ledger, ALICE, 40); + // The last card has 1 confirmation, the one before it 2. + await rejects(resolveDeck(deps, ALICE_ACCT, ids, { minConfirmations: 3 }), 'unconfirmed', ids.slice(38)); + ledger.mineEmpty(2); + assert.equal((await resolveDeck(deps, ALICE_ACCT, ids, { minConfirmations: 3 })).length, 40); +}); + +test('duplicates of an article count as separate cards, up to 4 copies per pageId', async () => { + const { ledger, deps } = fixture(); + const base = mintMany(ledger, ALICE, 35, 1); + const copies = Array.from({ length: 5 }, () => ledger.mint(ALICE, 777)); + await assert.rejects(resolveDeck(deps, ALICE_ACCT, [...base, ...copies]), + (e: unknown) => e instanceof DeckError && e.code === 'copy-limit' && e.pageId === 777 && e.tokenIds.length === 5); + const cards = await resolveDeck(deps, ALICE_ACCT, [...base, ...copies.slice(0, 4), ledger.mint(ALICE, 900)]); + assert.equal(cards.filter(c => c.pageId === 777).length, 4); + assert.equal((await resolveDeck(deps, ALICE_ACCT, [...base, ...copies], { maxCopiesPerPage: 5 })).length, 40, 'the copy limit is ruleset data'); +}); + +test('playableCount applies the copy limit', () => { + const cards = [1, 1, 1, 1, 1, 1, 2, 3].map(pageId => ({ pageId })); + assert.equal(playableCount(cards, 4), 6); + assert.equal(playableCount(cards, 1), 3); +}); + +test('collection lists every owned card across wallets with no 128-block cap', async () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 150, 1); + mintMany(ledger, BOB, 10, 1000); + mintMany(ledger, ALICE2, 3, 2000); + const cards = await collection(deps, ALICE_ACCT); + assert.equal(cards.length, 153); + assert.equal(new Set(cards.map(x => x.tokenId)).size, 153); + assert.ok(cards.every(x => x.owner === ALICE || x.owner === ALICE2)); + const r = collectionResponse(deps, 'alice'); + assert.equal(r.owned, 153); assert.equal(r.playable, 153); assert.equal(r.needed, 0); assert.equal(r.eligible, true); + assert.deepEqual(r.wallets, [ALICE, ALICE2]); + assert.equal(r.tip, ledger.tip); + assert.deepEqual(await collection(deps, { sub: 'stranger' }), []); +}); + +test('collection shows progress toward 40 and applies the copy limit to eligibility', () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 20, 1); + for (let i = 0; i < 10; i++) ledger.mint(ALICE, 4242); + const c = collectionResponse(deps, 'alice'); + assert.equal(c.owned, 30); assert.equal(c.playable, 24); assert.equal(c.needed, 16); assert.equal(c.eligible, false); + assert.equal(c.deckSize, 40); assert.equal(c.copyLimit, 4); assert.equal(c.maxCopiesPerPage, 4); + assert.equal(collectionResponse(deps, 'alice', { deckSize: 20 }).eligible, true); + const none = collectionResponse(deps, 'stranger'); + assert.equal(none.owned, 0); assert.equal(none.needed, 40); assert.deepEqual(none.cards, []); +}); + +test('collection only counts cards with enough confirmations', async () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 5); + assert.equal((await collection(deps, ALICE_ACCT, { minConfirmations: 3 })).length, 3); +}); + +test('collection restarts when the tip moves mid-scan and gives up if it never settles', async () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 60); + let moves = 1; + ledger.onDeck = () => { if (moves-- > 0) ledger.mint(ALICE, 9999); }; + const c = collectionResponse(deps, 'alice'); + assert.equal(c.owned, 61); + assert.equal(c.tip, ledger.tip); + ledger.onDeck = () => { ledger.mineEmpty(); }; + await assert.rejects(collection(deps, ALICE_ACCT), OwnershipUnavailable); +}); + +async function serve(router: express.Router) { + const app = express(); + app.use('/api/game/collection', router); + const server = app.listen(0, '127.0.0.1'); + await new Promise(r => server.once('listening', r)); + const base = `http://127.0.0.1:${(server.address() as AddressInfo).port}/api/game/collection`; + return { base, close: () => new Promise(r => server.close(r)) }; +} + +test('GET /api/game/collection requires a verified eom.dev token (local loopback only, no upstream)', async () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 23); + const { base, close } = await serve(collectionRouter(deps)); + const as = (t: string) => ({ headers: { authorization: `Bearer ${t}` } }); + try { + let res = await fetch(base); + assert.equal(res.status, 401); + res = await fetch(base, as('bad.token.x!')); + assert.equal(res.status, 401); + res = await fetch(base, as('expired.token.x')); + assert.equal(res.status, 401); + assert.equal((await res.json()).error, 'Token expired'); + res = await fetch(base, as('dex.is.down')); + assert.equal(res.status, 503); + res = await fetch(`${base}?minConfirmations=abc`, as('good.token.alice')); + assert.equal(res.status, 400); + res = await fetch(base, as('good.token.alice')); + assert.equal(res.status, 200); + assert.equal(res.headers.get('cache-control'), 'no-store'); + const body = await res.json(); + assert.equal(body.owned, 23); assert.equal(body.playable, 23); assert.equal(body.needed, 17); + assert.equal(body.eligible, false); assert.equal(body.deckSize, 40); assert.equal(body.copyLimit, 4); + assert.equal(body.cards.length, 23); + assert.equal(body.cards[0].title, 'Article 1'); + assert.equal(body.cards[0].pageId, 1); + res = await fetch(`${base}?minConfirmations=3`, as('good.token.alice')); + assert.equal((await res.json()).owned, 21); + res = await fetch(base, as('good.token.bob')); + assert.equal((await res.json()).owned, 0); + } finally { await close(); } +}); -- 2.54.0 From 9943de3b538705f3a469f6fb37b699e911800697 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 17 Nov 2026 22:02:50 -0500 Subject: [PATCH 2/2] [ownership] collectionRouter: optional injected duelCard hook (#57) Attaches duel: DuelCard to collection cards when the server has a frozen profile (requested by ui-duel); omitted while pending, never fetches. Co-Authored-By: Claude Opus 5.5 --- server/game/collection.ts | 25 ++++++++++++++++++++++--- tests/ownership-deck.test.ts | 16 ++++++++++++++++ 2 files changed, 38 insertions(+), 3 deletions(-) diff --git a/server/game/collection.ts b/server/game/collection.ts index 74044b2..e000c91 100644 --- a/server/game/collection.ts +++ b/server/game/collection.ts @@ -24,7 +24,8 @@ export type CollectionResponse = { needed: number; /** playable >= deckSize. */ eligible: boolean; - cards: ChainCard[]; + /** `duel` is present when the server has a frozen profile for the card (see collectionRouter's `duelCard`). */ + cards: (ChainCard & { duel?: unknown })[]; }; export function collectionResponse(deps: Pick, sub: string, @@ -37,7 +38,16 @@ export function collectionResponse(deps: Pick= r.deckSize, cards }; } -export function collectionRouter(deps: OwnershipDeps & { rules?: Partial }): Router { +export type CollectionRouterDeps = OwnershipDeps & { + rules?: Partial; + /** + * Optional: the same chain card → duel card function the PvP host uses, so the browser shows and + * plays exactly what PvP would. Return undefined while a card's profile is pending; it must not fetch. + */ + duelCard?: (card: ChainCard) => unknown; +}; + +export function collectionRouter(deps: CollectionRouterDeps): Router { const router = Router(); router.get('/', async (req: Request, res: Response) => { res.setHeader('Cache-Control', 'no-store'); @@ -46,7 +56,16 @@ export function collectionRouter(deps: OwnershipDeps & { rules?: Partial { + let duel: unknown; + try { duel = toDuel(c); } catch { duel = undefined; } + return duel === undefined ? c : { ...c, duel }; + }); + } + res.json(body); } catch (e) { const err = e as Error & { status?: number }; const status = e instanceof DeckError ? err.status! : err.status === 503 ? 503 : 500; diff --git a/tests/ownership-deck.test.ts b/tests/ownership-deck.test.ts index 309801c..073525e 100644 --- a/tests/ownership-deck.test.ts +++ b/tests/ownership-deck.test.ts @@ -273,3 +273,19 @@ test('GET /api/game/collection requires a verified eom.dev token (local loopback assert.equal((await res.json()).owned, 0); } finally { await close(); } }); + +test('GET /api/game/collection attaches the injected duel card when one is ready, and omits it otherwise', async () => { + const { ledger, deps } = fixture(); + mintMany(ledger, ALICE, 3); + const duelCard = (c: { pageId: number }) => { + if (c.pageId === 2) return undefined; // profile pending + if (c.pageId === 3) throw new Error('boom'); // never breaks the collection + return { kind: 'Figure', pageId: c.pageId }; + }; + const { base, close } = await serve(collectionRouter({ ...deps, duelCard })); + try { + const body = await (await fetch(base, { headers: { authorization: 'Bearer good.token.alice' } })).json(); + assert.deepEqual(body.cards.map((c: { duel?: unknown }) => c.duel), [{ kind: 'Figure', pageId: 1 }, undefined, undefined]); + assert.ok(!('duel' in body.cards[1])); + } finally { await close(); } +}); -- 2.54.0