forked from WikiDeck/wikideck
Night 2 (2026-11-17), from the `claude/wikideck` fork's `night/2026-11-17` branch. It follows Night 1 (#22).
## What's in it
- **Duel engine** (fork #72, #80): 40-card decks of cards you own, Notability/Citations, keywords, effects T1–T12, Connected, a hidden-information-safe `viewFor`/`logFor`, and replay. Balance v1 tuning (#84) gives the first player about 51%.
- **Card profiles** (#70, #82): Figure, Location, Event, Institution or Doctrine, plus stats, keywords and rules text, all derived from real article data. Templates only.
- **Design and story** (#66, #69, #83): DUEL_DESIGN.md, plus the match log and the encyclopedic "Battle of X (2026)" recap.
- **PvP** (#74, #77, #81, #76, #85):
- The server checks ownership, and 40-card eligibility is enforced.
- Modes: Classic (ranked), Draft and Trending.
- Invites, quick match, Elo, a ladder and recap pages. Online matches render on the duel board.
- **Duel board UI** (#79): MTG-style card faces and combat declaration, built for 360 px first.
- **Polite Wikimedia client** (#73, #75): throttled, cached and identified requests, the mint-path fix, and a prefetch pool.
- **Android mining** (#78): native RandomX, as a sideload build. The emulator mined a testnet block.
- **Testnet ops** (#67, #68).
PR numbers refer to `claude/wikideck`.
## Status
- **Tests:** 423, of which 422 pass, 0 fail and 1 is skipped. The build is OK (`node:24-alpine`, `--network none`).
- **Testnet:** running this commit (036489c) on r350.
- **Untouched:** no changes to `server/testnet/consensus.ts`, `randomx.ts`, `native/` or the mainnet compose.
- **Review:** night-review reviewed fork #66–#79. #80–#85 came from the agents' unfinished branches and were not reviewed.
- **Known gaps:**
- The PvP end-to-end test hasn't been run (it needs two eom.dev accounts).
- Bot matches aren't reachable from Play.
- Card identity pre-bake hasn't been done.
- The RandomX verifier latch (`server/testnet/randomx.ts:140`) is still open.
This PR is for Eric to merge.
🤖 Generated with [Claude Code](https://claude.com/claude-code)Reviewed-on: WikiDeck/wikideck#23
Co-authored-by: Claude <claude@eom.dev>
114 lines
5.7 KiB
TypeScript
114 lines
5.7 KiB
TypeScript
import { Router, type Request, type Response, type NextFunction } from 'express';
|
|
import { resolve } from 'node:path';
|
|
import { z } from 'zod';
|
|
import { DexKeys, TokenError, displayName, exchangeCode, oidcConfig, verifyIdToken, type OidcConfig } from './oidc.ts';
|
|
import { AccountStore, LinkError, type Account } from './store.ts';
|
|
|
|
// Mounted at /api/account by server/testnet/http.ts. Body parsing, the POST origin check,
|
|
// rate limits and no-store caching come from the /api middleware there.
|
|
export type AccountDeps = { config?: OidcConfig; keys?: DexKeys; store?: AccountStore; dataDir?: string;
|
|
fetcher?: typeof fetch; now?: () => number };
|
|
|
|
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<DexKeys, 'key'>, store: Pick<AccountStore, 'upsert'>,
|
|
now: () => number = Date.now): (idToken: string) => Promise<Account> {
|
|
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<ReturnType<typeof verifyIdToken>>): Account =>
|
|
({ sub: claims.sub, issuer: claims.iss, name: displayName(claims), username: claims.preferred_username ?? '' });
|
|
|
|
const auth = async (req: Authed, _res: Response, next: NextFunction) => {
|
|
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 = await verify(m[1]);
|
|
next();
|
|
} catch (e) { next(e); }
|
|
};
|
|
|
|
// Public, so the browser builds the authorize URL without fetching Dex (no CSP/CORS change).
|
|
router.get('/config', async (_req, res, next) => {
|
|
try {
|
|
const meta = await keys.meta();
|
|
res.json({ issuer: config.issuer, clientId: config.clientId, scopes: config.scopes,
|
|
authorizationEndpoint: meta.authorization_endpoint, redirectUris: config.redirectUris });
|
|
} catch (e) { next(e); }
|
|
});
|
|
|
|
router.post('/token', async (req, res, next) => {
|
|
try {
|
|
const body = z.object({ code: z.string().min(1).max(512), codeVerifier: z.string().regex(/^[A-Za-z0-9._~-]{43,128}$/),
|
|
redirectUri: z.string().max(256), nonce: z.string().min(16).max(128) }).strict().parse(req.body);
|
|
if (!config.redirectUris.includes(body.redirectUri)) throw new LinkError('Redirect URI not allowed');
|
|
const { idToken } = await exchangeCode(keys, body, deps.fetcher);
|
|
const claims = await verifyIdToken(idToken, keys, config, { now: now(), nonce: body.nonce });
|
|
const account = toAccount(claims);
|
|
store.upsert(account);
|
|
res.json({ idToken, expiresAt: claims.exp * 1000, account: { ...account, wallets: store.wallets(account.sub) } });
|
|
} catch (e) { next(e); }
|
|
});
|
|
|
|
router.get('/me', auth, (req: Authed, res) => {
|
|
const a = req.account!;
|
|
res.json({ ...a, wallets: store.wallets(a.sub) });
|
|
});
|
|
|
|
router.post('/challenge', auth, (req: Authed, res, next) => {
|
|
try {
|
|
const { address } = z.object({ address: hex64 }).strict().parse(req.body);
|
|
res.json(store.challenge(req.account!, address));
|
|
} catch (e) { next(e); }
|
|
});
|
|
|
|
// Wallet keys never leave the client: only the public key and a signature arrive here.
|
|
router.post('/link', auth, (req: Authed, res, next) => {
|
|
try {
|
|
const body = z.object({ nonce: z.string().regex(/^[A-Za-z0-9_-]{16,64}$/), address: hex64,
|
|
publicKey: z.string().max(256), signature: z.string().max(256) }).strict().parse(req.body);
|
|
res.status(201).json(store.link(req.account!, body));
|
|
} catch (e) { next(e); }
|
|
});
|
|
|
|
router.delete('/link/:address', auth, (req: Authed, res) => {
|
|
const address = String(req.params.address);
|
|
if (!/^[a-f0-9]{64}$/.test(address)) { res.status(400).json({ error: 'Invalid wallet address' }); return; }
|
|
res.json({ removed: store.unlink(req.account!.sub, address) });
|
|
});
|
|
|
|
// Leaderboards: GET /api/account/names?addresses=a,b,c → { [address]: displayName }
|
|
router.get('/names', (req, res) => {
|
|
const list = String(req.query.addresses ?? '').split(',').filter(Boolean);
|
|
if (list.length > 100 || !list.every(a => /^[a-f0-9]{64}$/.test(a))) { res.status(400).json({ error: 'Invalid addresses' }); return; }
|
|
res.json({ names: store.names(list) });
|
|
});
|
|
|
|
router.use((err: Error & { status?: number }, _req: Request, res: Response, _next: NextFunction) => {
|
|
if (err instanceof TokenError || err instanceof LinkError) { res.status(err.status).json({ error: err.message }); return; }
|
|
if (err instanceof z.ZodError) { res.status(400).json({ error: 'Invalid request' }); return; }
|
|
if (/OIDC|JWKS/.test(err.message) || err.name === 'TimeoutError' || err.message === 'fetch failed') { res.status(503).json({ error: 'eom.dev login is temporarily unavailable' }); return; }
|
|
res.status(err.status === 413 ? 413 : 400).json({ error: 'Account request failed' });
|
|
});
|
|
return router;
|
|
}
|