67 lines
4.8 KiB
TypeScript
Executable File
67 lines
4.8 KiB
TypeScript
Executable File
import { CONSENSUS, type TestnetBlock } from '../../shared/testnet.ts';
|
|
import { CHAIN_ID, GENESIS_TIME, MAX_TARGET, expectedTarget, medianTime, workFor } from '../testnet/consensus.ts';
|
|
|
|
const SPACE = 1n << 256n;
|
|
/** Analysis only. Calls the actual retarget/median helpers but DOES NOT construct valid blocks,
|
|
* perform PoW, invoke Ledger, or provide a production fake-PoW selector. */
|
|
export type Scenario = 'steady' | 'rapid' | 'slow' | 'stall' | 'median-minimum' | 'future-edge';
|
|
export type TracePoint = { height: number; wallTime: number; timestamp: number; target: string;
|
|
cumulativeWork: string; expectedHashes: number; nextTarget: string };
|
|
export function expectedHashes(target: string): number {
|
|
if (!/^[a-f0-9]{64}$/.test(target)) throw new Error('Invalid target');
|
|
return Number(SPACE) / Number(BigInt(`0x${target}`) + 1n);
|
|
}
|
|
export function targetForHashrate(hashesPerSecond: number, seconds = CONSENSUS.targetSeconds): string {
|
|
if (!Number.isSafeInteger(hashesPerSecond) || hashesPerSecond < 1 || hashesPerSecond > 1_000_000_000_000 ||
|
|
!Number.isSafeInteger(seconds) || seconds < 1 || seconds > 86400) throw new Error('Hashrate/interval outside analysis bounds');
|
|
const denominator = BigInt(hashesPerSecond) * BigInt(seconds);
|
|
const target = SPACE / denominator - 1n;
|
|
const maximum = BigInt(`0x${MAX_TARGET}`);
|
|
return (target < 1n ? 1n : target > maximum ? maximum : target).toString(16).padStart(64,'0');
|
|
}
|
|
export function simulate(scenario: Scenario, count = 60): TracePoint[] {
|
|
if (!['steady','rapid','slow','stall','median-minimum','future-edge'].includes(scenario) ||
|
|
!Number.isSafeInteger(count) || count < 1 || count > 1000) throw new Error('Invalid bounded simulation');
|
|
const history: TestnetBlock[] = [], result: TracePoint[] = [];
|
|
let wallTime = GENESIS_TIME, cumulativeWork = 0n;
|
|
for (let i = 0; i < count; i++) {
|
|
const target = expectedTarget(history);
|
|
const spacing = scenario === 'rapid' ? 1 : scenario === 'slow' ? CONSENSUS.targetSeconds * 8
|
|
: scenario === 'stall' && i === 20 ? 7 * 86400 : CONSENSUS.targetSeconds;
|
|
wallTime += spacing;
|
|
const timestamp = scenario === 'median-minimum' ? medianTime(history) + 1
|
|
: scenario === 'future-edge' ? wallTime + CONSENSUS.maxFutureSeconds : wallTime;
|
|
if (timestamp <= medianTime(history) || timestamp > wallTime + CONSENSUS.maxFutureSeconds) throw new Error('Analysis generated an invalid timestamp');
|
|
// Only these fields are read by expectedTarget/medianTime. Never submit these records to a node.
|
|
history.push({ createdAt: timestamp, target } as TestnetBlock);
|
|
cumulativeWork += workFor(target);
|
|
result.push({ height:i+1,wallTime,timestamp,target,cumulativeWork:cumulativeWork.toString(),
|
|
expectedHashes:expectedHashes(target),nextTarget:expectedTarget(history) });
|
|
}
|
|
return result;
|
|
}
|
|
/** Idealized fixed-difficulty Poisson race: probability of ever catching up from a CURRENT
|
|
* known z-block deficit, q<p. NOT probability of double-spend after z confirmations. */
|
|
export function idealCatchup(attackerShare: number, deficit: number): number {
|
|
if (!Number.isFinite(attackerShare) || attackerShare < 0 || attackerShare > 1 ||
|
|
!Number.isSafeInteger(deficit) || deficit < 0 || deficit > 1000) throw new Error('Invalid race assumptions');
|
|
if (deficit === 0 || attackerShare >= .5) return 1;
|
|
return (attackerShare / (1-attackerShare)) ** deficit;
|
|
}
|
|
export function calibrationReport() {
|
|
const scenarios = Object.fromEntries((['steady','rapid','slow','stall','median-minimum','future-edge'] as const)
|
|
.map(name=>[name,simulate(name)]));
|
|
const a=scenarios.steady.at(-1)!,b=scenarios.rapid.at(-1)!;
|
|
return { schema:'wikideck-consensus-analysis-v1',chainId:CHAIN_ID,consensusChanged:false,
|
|
scope:'Deterministic header-math scenarios only; no valid blocks, mining or launch.',
|
|
initialExpectedHashes:expectedHashes(MAX_TARGET),targetSeconds:CONSENSUS.targetSeconds,
|
|
assumptions:'Spacing is externally imposed, not stochastic mining at constant hashrate. Work comparisons do not imply an attacker can produce that work.',
|
|
scenarios,
|
|
partitionExample:{steadyHeight:a.height,rapidHeight:b.height,steadyWork:a.cumulativeWork,rapidWork:b.cumulativeWork,
|
|
winnerByStrictWork:BigInt(b.cumulativeWork)>BigInt(a.cumulativeWork)?'rapid':'steady',
|
|
warning:'Models fork-choice inputs, not peer synchronization, block validity or achievable hashpower.'},
|
|
knownDeficitCatchup:[.1,.25,.4,.49].map(share=>({attackerShare:share,probability:idealCatchup(share,10),currentDeficit:10})),
|
|
candidateTargets:[1,10,100,1000,10000].map(hps=>({assumedNetworkHashesPerSecond:hps,target:targetForHashrate(hps)})),
|
|
decision:'NO-GO: measurement, independent analysis, multi-host rehearsal and explicit operator approval still required.' };
|
|
}
|