Prueba de trabajo y reajuste de dificultad

# Proof of work and difficulty retargeting

Run `node tools/labs/proof-of-work-difficulty/mine.mjs` and `node tools/labs/proof-of-work-difficulty/retarget.mjs`.

`mine.mjs` searches a nonce whose SHA-256 has the required leading zero bits and compares the attempts with the 2^bits expectation. `retarget.mjs` simulates block times with a seeded random source, retargets every 144 blocks by height, clamps each change to 4x, and checks that the block time returns to the target after an 8x hashrate jump. Both are deterministic fixtures: no network, no wallet, no real chain.

// Proof of work: find a nonce whose SHA-256 has at least `bits` leading zero bits.
// Deterministic for a fixed block payload, so the attempts can be checked.
import { createHash } from 'node:crypto';

function leadingZeroBits(buffer) {
  let bits = 0;
  for (const byte of buffer) {
    if (byte === 0) { bits += 8; continue; }
    return bits + Math.clz32(byte) - 24;
  }
  return bits;
}

export function mine(payload, bits) {
  for (let nonce = 0; ; nonce += 1) {
    const hash = createHash('sha256').update(`${payload}|${nonce}`).digest();
    if (leadingZeroBits(hash) >= bits) return { nonce, attempts: nonce + 1, hash: hash.toString('hex') };
  }
}

const payload = 'prev=00ab|txs=3|height=42';
const report = [8, 12, 16].map((bits) => {
  const result = mine(payload, bits);
  const expected = 2 ** bits;
  return { bits, expectedAttempts: expected, attempts: result.attempts, ratio: Number((result.attempts / expected).toFixed(2)), hash: result.hash.slice(0, 16) };
});
console.log(JSON.stringify({ lab: 'proof-of-work-difficulty', step: 'mine', report }, null, 2));
// Every hash must meet its target; attempts stay within 20x the expectation (geometric distribution).
const ok = report.every((row) => row.ratio <= 20 && /^0+/.test(row.hash.slice(0, Math.floor(row.bits / 4))));
if (!ok) process.exit(1);

// Difficulty retargeting: adjust every INTERVAL blocks *by height* (not by the difficulty
// value), proportionally to how long the window took, clamped to a 4x change.
const TARGET_SECONDS = 600;
const INTERVAL = 144;

// Seeded PRNG so the simulation is reproducible.
let seed = 42;
const random = () => ((seed = (seed * 1664525 + 1013904223) % 2 ** 32) / 2 ** 32);

export function retarget(difficulty, windowSeconds) {
  const expected = TARGET_SECONDS * INTERVAL;
  const proposed = difficulty * (expected / windowSeconds);
  return Math.min(difficulty * 4, Math.max(difficulty / 4, proposed));
}

let difficulty = 1;
let hashrate = 1; // difficulty units per TARGET_SECONDS
let windowSeconds = 0;
const windows = [];
for (let height = 1; height <= INTERVAL * 12; height += 1) {
  if (height === INTERVAL * 4 + 1) hashrate = 8; // hashrate jumps 8x after window 4
  const mean = TARGET_SECONDS * (difficulty / hashrate);
  windowSeconds += -Math.log(1 - random()) * mean; // exponential block time
  if (height % INTERVAL === 0) {
    windows.push({ window: height / INTERVAL, meanBlockSeconds: Math.round(windowSeconds / INTERVAL), difficulty: Number(difficulty.toFixed(2)) });
    difficulty = retarget(difficulty, windowSeconds);
    windowSeconds = 0;
  }
}
console.log(JSON.stringify({ lab: 'proof-of-work-difficulty', step: 'retarget', windows }, null, 2));
const last = windows.at(-1).meanBlockSeconds;
const clampHeld = windows.every((w, i) => i === 0 || w.difficulty <= windows[i - 1].difficulty * 4 + 1e-9);
// After the jump the block time returns near the target, and no step exceeded the clamp.
if (!(Math.abs(last - TARGET_SECONDS) < TARGET_SECONDS * 0.25 && clampHeld)) process.exit(1);