우리를 믿지 마세요.

/**
 * 퍼즐 원본 데이터를 검증하고 data/puzzles.json 으로 만든다.
 *
 * 원본(data/raw/puzzles.txt)은 외부에서 가져온 것이라 그대로 믿지 않는다.
 * 여기서 하는 검증:
 *   1. 160행이 전부 있고 행 번호 = 퍼즐 번호인지
 *   2. 범위가 정확히 [2^(n-1), 2^n - 1] 인지
 *   3. 해결된 퍼즐: 개인키 -> 압축 공개키 -> 주소 가 원본 주소와 일치하는지
 *   4. 개인키가 실제로 그 범위 안에 들어있는지
 *   5. 공개키가 공개된 퍼즐: 공개키 -> 주소 가 원본 주소와 일치하는지
 * 하나라도 틀리면 빌드를 실패시킨다.
 */
import { readFileSync, writeFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';
import * as secp from '@noble/secp256k1';
import { sha256 } from '@noble/hashes/sha2.js';
import { ripemd160 } from '@noble/hashes/legacy.js';
import { base58check } from '@scure/base';

const root = join(dirname(fileURLToPath(import.meta.url)), '..');
const NOT_SOLVED = 'NOT SOLVED';

const b58c = base58check(sha256);

/** 압축 공개키(hex) -> P2PKH 주소 */
function pubkeyToAddress(pubHex) {
  const h160 = ripemd160(sha256(hexToBytes(pubHex)));
  const payload = new Uint8Array(21);
  payload[0] = 0x00; // mainnet P2PKH
  payload.set(h160, 1);
  return b58c.encode(payload);
}

function hexToBytes(hex) {
  const clean = hex.length % 2 ? '0' + hex : hex;
  const out = new Uint8Array(clean.length / 2);
  for (let i = 0; i < out.length; i++) out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
  return out;
}

/** 개인키(hex, 64자) -> 압축 공개키(hex) */
function privToPub(privHex) {
  return secp.etc.bytesToHex(secp.getPublicKey(hexToBytes(privHex.padStart(64, '0')), true));
}

// ---------------------------------------------------------------- 파싱
const raw = readFileSync(join(root, 'data/raw/puzzles.txt'), 'utf8');
const lines = raw.split('\n').filter((l) => l.trim());
const errors = [];

if (lines.length !== 160) errors.push(`행 수가 160이 아님: ${lines.length}`);

const puzzles = lines.map((line, idx) => {
  const n = idx + 1;
  const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
  if (cells.length !== 5) {
    errors.push(`#${n}: 컬럼 수가 5가 아님 (${cells.length})`);
    return null;
  }
  const [range, address, status, pub, priv] = cells;
  const [loHex, hiHex] = range.split(':');

  const lo = BigInt('0x' + loHex);
  const hi = BigInt('0x' + hiHex);

  // 2. 범위 검증
  const expLo = n === 1 ? 1n : 1n << BigInt(n - 1);
  const expHi = (1n << BigInt(n)) - 1n;
  if (lo !== expLo || hi !== expHi) {
    errors.push(`#${n}: 범위 불일치 — 원본 ${loHex}:${hiHex}, 기대 ${expLo.toString(16)}:${expHi.toString(16)}`);
  }

  const solved = status === 'SOLVED';
  const hasPub = pub !== NOT_SOLVED;
  const privateKey = priv !== NOT_SOLVED ? priv.toLowerCase() : null;

  // 3 & 4. 해결된 퍼즐 검증
  let publicKey = hasPub ? pub.toLowerCase() : null;
  if (privateKey) {
    const k = BigInt('0x' + privateKey);
    if (k < lo || k > hi) {
      errors.push(`#${n}: 개인키가 범위 밖 (${privateKey})`);
    }
    const derivedPub = privToPub(privateKey);
    if (publicKey && derivedPub !== publicKey) {
      errors.push(`#${n}: 개인키에서 유도한 공개키가 원본과 다름`);
    }
    publicKey = derivedPub;
    const derivedAddr = pubkeyToAddress(derivedPub);
    if (derivedAddr !== address) {
      errors.push(`#${n}: 개인키 -> 주소 불일치 — 유도 ${derivedAddr}, 원본 ${address}`);
    }
  } else if (publicKey) {
    // 5. 공개키만 있는 경우
    const derivedAddr = pubkeyToAddress(publicKey);
    if (derivedAddr !== address) {
      errors.push(`#${n}: 공개키 -> 주소 불일치 — 유도 ${derivedAddr}, 원본 ${address}`);
    }
  }

  // 2023-04-16 증액 이후 상금 규칙: 미해결 퍼즐은 n/10 BTC.
  // 해결된 퍼즐은 이미 인출되어 0이므로, 참고용 "당초 상금"만 계산해 둔다.
  const prize = n / 10;

  return {
    n,
    address,
    rangeStart: '0x' + lo.toString(16),
    rangeEnd: '0x' + hi.toString(16),
    bits: n,
    solved,
    // 공개키 노출 = Kangaroo/BSGS 로 O(2^(n/2)) 공격 가능
    pubkeyExposed: hasPub,
    publicKey,
    privateKey,
    prizeBtc: prize,
  };
}).filter(Boolean);

if (errors.length) {
  console.error('\n✗ 데이터 검증 실패\n');
  for (const e of errors) console.error('  ' + e);
  process.exit(1);
}

const solved = puzzles.filter((p) => p.solved);
const unsolved = puzzles.filter((p) => !p.solved);
const attackable = unsolved.filter((p) => p.pubkeyExposed);

const out = {
  generatedAt: new Date().toISOString(),
  source: 'https://github.com/roadhero/Bitcoin-Puzzle-Info (BTC-Solved-Unsolved.txt) — 전 항목 secp256k1 재유도 검증 완료',
  totals: {
    all: puzzles.length,
    solved: solved.length,
    unsolved: unsolved.length,
    pubkeyExposedUnsolved: attackable.length,
    remainingPrizeBtc: Number(unsolved.reduce((s, p) => s + p.prizeBtc, 0).toFixed(1)),
  },
  puzzles,
};

writeFileSync(join(root, 'data/puzzles.json'), JSON.stringify(out, null, 2) + '\n');

// /verify 페이지가 이 스크립트 전문을 보여준다. 런타임에 파일을 읽으면
// 파일시스템 없는 환경(Cloudflare Workers 등)에서 죽으므로 지금 박아둔다.
const selfPath = fileURLToPath(import.meta.url);
writeFileSync(
  join(root, 'data/build-data-source.json'),
  JSON.stringify({ path: 'scripts/build-data.mjs', source: readFileSync(selfPath, 'utf8') }, null, 2) + '\n',
);

console.log('✓ 검증 통과');
console.log(`  전체 ${out.totals.all} / 해결 ${out.totals.solved} / 미해결 ${out.totals.unsolved}`);
console.log(`  미해결 중 공개키 노출: ${attackable.map((p) => p.n).join(', ')}`);
console.log(`  남은 상금 합계: ${out.totals.remainingPrizeBtc} BTC`);
console.log(`  가장 쉬운 미해결: #${unsolved[0].n} (2^${unsolved[0].n - 1} ~ 2^${unsolved[0].n})`);