Files
wikideck/tests/mobile-mining-miner.test.ts
claudeanderic dbb89ce9c5 Night 2: 40-card Magic-style duel, PvP with owned decks, polite Wikimedia client, Android mining (#23)
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>
2026-11-18 18:12:24 +00:00

122 lines
6.6 KiB
TypeScript

// mobile-mining: the WebView mining loop must build blocks byte-identical to server/testnet/miner.ts.
// No network calls: the node API and the RandomX engine are in-process fakes.
import test from 'node:test';
import assert from 'node:assert/strict';
import { createHash, generateKeyPairSync, sign } from 'node:crypto';
import { CHAIN_ID, MAX_TARGET, address, makeTemplate, miningBlob, mintId, sha256, validateBlock } from '../server/testnet/consensus.ts';
import { type MiningTemplate, type TestnetBlock } from '../shared/testnet.ts';
import { deriveStats } from '../shared/enrichment.ts';
import type { PowEngine } from '../server/testnet/randomx.ts';
import { MobileMiner, buildBlock, checkTemplate, meetsTarget, miningBlobHex, mintIdOf, type MinerEngine, type MineResult } from '../src/mobile-miner.ts';
const keys = generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
const publicKey = keys.publicKey.export({ format: 'der', type: 'spki' }).toString('base64');
const me = { publicKey, address: address(publicKey) };
const signer = async (message: string) => sign('sha256', Buffer.from(message), { key: keys.privateKey, dsaEncoding: 'ieee-p1363' }).toString('base64');
const fakeHash = (key: string, blob: Uint8Array) => createHash('sha256').update(Buffer.concat([Buffer.from(key, 'hex'), Buffer.from(blob)])).digest('hex');
// Test-only stand-in for RandomX on both sides (production has no fake PoW).
const pow: PowEngine = { hash: async (key, blob) => fakeHash(key, blob), close() {} };
function template(target = MAX_TARGET): MiningTemplate {
const pageBytes = 2048, languageCount = 3;
const stats = { capturedAt: '2026-11-17T00:00:00.000Z', revisionId: 7, pageBytes, languageCount, languagesTruncated: false,
pageviews: { status: 'unavailable' as const, months: [], latestMonth: '2026-10', total: null, dailyAverage: null, trendPercent: null },
stats: deriveStats(pageBytes, languageCount, null) };
const article = { pageId: 4242, title: 'Tetrated dodecahedron', extract: 'A deterministic test article.', image: 'https://upload.wikimedia.org/wikipedia/commons/test.jpg',
url: 'https://en.wikipedia.org/?curid=4242', revisionId: 7, source: 'live' as const, category: 'Science' };
const t = makeTemplate([], {}, me.address, me.publicKey, [], article, stats, Math.floor(Date.now() / 1000));
t.header.target = target;
t.blob = miningBlob(t.header).toString('hex');
return t;
}
/** Fake engine that speaks the plugin's mine contract with the fake hash. */
class FakeEngine implements MinerEngine {
started = 0; stopped = 0; calls = 0;
async start() { this.started++; }
async stop() { this.stopped++; }
async mine(_lane: number, key: string, blobHex: string, target: string, offset: number, max: number): Promise<MineResult> {
this.calls++;
const blob = Buffer.from(blobHex, 'hex');
let nonce = blob.readBigUInt64LE(offset);
for (let i = 0; i < max; i++, nonce++) {
blob.writeBigUInt64LE(nonce, offset);
const hash = fakeHash(key, blob);
if (meetsTarget(hash, target)) return { found: true, hash, nonce: nonce.toString() };
}
return { found: false };
}
}
test('browser blob and mint id match consensus', async () => {
const t = template();
for (const nonce of [0, 1, 2 ** 32 + 5, Number.MAX_SAFE_INTEGER]) {
const header = { ...t.header, nonce };
assert.equal(await miningBlobHex(header), miningBlob(header).toString('hex'));
}
assert.equal(await mintIdOf(t.header), mintId(t.header));
assert.equal(t.header.chainId, CHAIN_ID);
});
test('buildBlock produces a block the consensus validator accepts', async () => {
const t = template();
const header = { ...t.header, nonce: 0 };
while (!meetsTarget(fakeHash(header.key, miningBlob(header)), header.target)) header.nonce++;
const powHash = fakeHash(header.key, miningBlob(header));
const block = await buildBlock(t, header.nonce, powHash, signer);
assert.equal(block.hash, sha256(miningBlob(header)));
assert.equal(block.signature.length > 0, true);
const { block: valid } = await validateBlock(structuredClone(block), [], {}, pow);
assert.equal(valid.tokenId, mintId(header));
});
test('checkTemplate rejects work for another network or wallet', async () => {
const t = template();
await checkTemplate(t, CHAIN_ID, me);
await assert.rejects(checkTemplate(t, 'f'.repeat(64), me), /another network/);
await assert.rejects(checkTemplate(t, CHAIN_ID, { ...me, address: '0'.repeat(64) }), /another wallet/);
await assert.rejects(checkTemplate({ ...t, blob: '00'.repeat(40) }, CHAIN_ID, me), /does not match/);
});
test('MobileMiner mines, signs and submits one accepted block, then stops the engine', async () => {
const engine = new FakeEngine();
const submitted: TestnetBlock[] = [];
const api = async (path: string, body?: unknown) => {
if (path === '/api/mining/template') { assert.deepEqual(body, { owner: me.address, publicKey: me.publicKey }); return template('0' + 'f'.repeat(63)); }
if (path === '/api/blocks') { submitted.push(body as TestnetBlock); await validateBlock(structuredClone(body), [], {}, pow); return { accepted: true }; }
if (path === '/p2p/status') return { tip: 'x' };
throw new Error(`unexpected ${path}`);
};
const miner = new MobileMiner({ engine, api, sign: signer, chainId: CHAIN_ID }, me);
await miner.start(1, 1);
assert.equal(miner.status.phase, 'stopped', miner.status.message);
assert.equal(miner.status.accepted, 1);
assert.equal(submitted.length, 1);
assert.equal(submitted[0].owner, me.address);
assert.ok(engine.stopped >= 1);
});
test('a tripped safeguard stops mining before the engine starts', async () => {
const engine = new FakeEngine();
const miner = new MobileMiner({ engine, api: async () => { throw new Error('no network'); }, sign: signer, chainId: CHAIN_ID,
blocked: () => 'battery saver is on' }, me);
await miner.start(1, 1);
assert.equal(miner.status.phase, 'error');
assert.match(miner.status.message ?? '', /battery saver/);
assert.equal(engine.started, 0);
assert.equal(engine.calls, 0);
});
test('stop() halts an in-progress search', async () => {
const engine = new FakeEngine();
const api = async (path: string) => path === '/api/mining/template' ? template('0'.repeat(64)) : { tip: template().header.previousHash };
const miner = new MobileMiner({ engine, api, sign: signer, chainId: CHAIN_ID }, me);
const run = miner.start(1);
for (let i = 0; engine.calls < 3 && i < 2000; i++) await new Promise(r => setTimeout(r, 1));
assert.ok(engine.calls >= 3, miner.status.message);
await miner.stop('Stopped.');
await run;
assert.equal(miner.status.phase, 'stopped');
assert.equal(miner.status.accepted, 0);
});