우리를 믿지 마세요.

/**
 * 노블 라이브러리를 믿지 않기 위한 두 번째 구현.
 *
 * 이 사이트는 @noble/secp256k1 로 개인키가 공개된 퍼즐의 개인키 -> 주소를 재유도해서
 * 데이터가 맞는지 확인한다(scripts/build-data.mjs). 그런데 그 검증은
 * "노블이 맞다" 를 전제로 한다. 노블이 틀렸다면 검증도 같이 틀린다.
 *
 * 그래서 여기서는 타원곡선 산술을 BigInt 로 처음부터 다시 짠다.
 * 라이브러리를 한 줄도 쓰지 않는다 — 유한체 나눗셈도, 점 덧셈도, 배가도.
 * 그리고 개인키가 있는 83개 전부에서 노블과 같은 공개키가 나오는지 대조한다.
 * (나머지 77개는 개인키가 없어서 유도할 대상 자체가 없다.)
 *
 * 두 구현이 독립이므로, 둘 다 틀리려면 서로 다른 코드가 같은 방식으로
 * 틀려야 한다. 그건 훨씬 있을 법하지 않은 일이다.
 *
 * 참고: Arnaud Brousseau 의 keys.deconstructed 가 같은 동기로 쓰였다.
 * 다만 그 구현의 점 덧셈에는 대칭점 분기가 죽어 있는 버그가 있어
 * (this.y.eq(this.y) 는 언제나 참) 코드를 가져오지 않고 새로 썼다.
 */
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';

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

/* ────────────────────────── 유한체 ──────────────────────────
 * 비트코인 곡선이 사는 소수체. p = 2^256 - 2^32 - 977
 * (부동소수점을 거치지 않고 BigInt 로만 쓴다)               */
const P = 2n ** 256n - 2n ** 32n - 977n;
const N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;

const mod = (a) => ((a % P) + P) % P;

/** a^e mod P — 제곱-곱셈법. BigInt 의 ** 는 지수가 크면 터진다. */
function powmod(a, e) {
  let r = 1n, b = mod(a);
  while (e > 0n) {
    if (e & 1n) r = (r * b) % P;
    b = (b * b) % P;
    e >>= 1n;
  }
  return r;
}

/** 1/a mod P — 페르마의 소정리: p 가 소수면 a^(p-2) ≡ 1/a */
const inv = (a) => powmod(a, P - 2n);

/* ──────────────────── 타원곡선 y² = x³ + 7 ────────────────────
 * 점은 {x, y} 이고 무한원점(항등원)은 null 로 둔다.          */

/** 이 점이 정말 곡선 위에 있는가 */
function onCurve(pt) {
  if (pt === null) return true;
  return mod(pt.y * pt.y) === mod(pt.x * pt.x * pt.x + 7n);
}

function double(pt) {
  if (pt === null) return null;
  if (pt.y === 0n) return null;              // 접선이 수직 -> 무한원점
  const s = mod(3n * pt.x * pt.x * inv(2n * pt.y));
  const x = mod(s * s - 2n * pt.x);
  return { x, y: mod(s * (pt.x - x) - pt.y) };
}

function add(a, b) {
  if (a === null) return b;                  // 0 + B = B
  if (b === null) return a;                  // A + 0 = A
  if (a.x === b.x) {
    // 여기가 브루소 구현이 틀린 자리다. y 가 다르면 서로 대칭점이므로 합은 0.
    if (mod(a.y + b.y) === 0n) return null;
    return double(a);                        // 같은 점이면 배가
  }
  const s = mod((b.y - a.y) * inv(b.x - a.x));
  const x = mod(s * s - a.x - b.x);
  return { x, y: mod(s * (a.x - x) - a.y) };
}

/** k·G — 아래에서 위로 훑는 배가-덧셈 */
function multiply(k, pt) {
  let r = null, cur = pt, n = k;
  while (n > 0n) {
    if (n & 1n) r = add(r, cur);
    cur = double(cur);
    n >>= 1n;
  }
  return r;
}

const G = {
  x: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
  y: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n,
};

const hex64 = (n) => n.toString(16).padStart(64, '0');

/** 개인키 -> 압축 공개키 hex. 라이브러리 없이. */
function derivePubkey(k) {
  const pt = multiply(k, G);
  if (pt === null) throw new Error('무한원점이 나왔다');
  if (!onCurve(pt)) throw new Error('곡선 위의 점이 아니다');
  return (pt.y % 2n === 0n ? '02' : '03') + hex64(pt.x);
}

/* ──────────────────────────── 검사 ──────────────────────────── */
let fail = 0;
const ok = (name, cond, extra = '') => {
  if (cond) console.log(`  ✓ ${name}${extra ? '  ' + extra : ''}`);
  else { console.log(`  ✗ ${name}${extra ? '  ' + extra : ''}`); fail++; }
};

console.log('\n곡선 산술이 스스로 일관적인가');
ok('G 가 곡선 위에 있다', onCurve(G));
ok('2G 가 곡선 위에 있다', onCurve(double(G)));
ok('G + G = 2G', (() => { const a = add(G, G), b = double(G); return a.x === b.x && a.y === b.y; })());
ok('G + (-G) = 무한원점', add(G, { x: G.x, y: mod(-G.y) }) === null);
ok('3G = 2G + G = G + 2G', (() => {
  const a = add(double(G), G), b = add(G, double(G));
  return a.x === b.x && a.y === b.y;
})());
ok('(a+b)G = aG + bG', (() => {
  const a = 1234567n, b = 7654321n;
  const l = multiply(a + b, G), r = add(multiply(a, G), multiply(b, G));
  return l.x === r.x && l.y === r.y;
})());
ok('n·G = 무한원점 (군의 위수)', multiply(N, G) === null);

// 공개된 표준 벡터. https://en.bitcoin.it/wiki/Secp256k1
console.log('\n표준 시험값과 대조');
ok('1·G 의 x 좌표', hex64(multiply(1n, G).x) === '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798');
ok('2·G 의 x 좌표', hex64(multiply(2n, G).x) === 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5');
ok('3·G 의 x 좌표', hex64(multiply(3n, G).x) === 'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9');
// SHA-256 과 RIPEMD-160 은 노블 것을 쓰므로, 공개된 시험값으로 따로 확인한다
const h = (b) => Buffer.from(b).toString('hex');
ok('SHA-256("abc")', h(sha256(Buffer.from('abc'))) === 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
ok('RIPEMD-160("abc")', h(ripemd160(Buffer.from('abc'))) === '8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');

/* ── 본론: 160개 퍼즐을 두 구현으로 각각 유도해 대조 ── */
const data = JSON.parse(readFileSync(join(root, 'data/puzzles.json'), 'utf8'));
const withKey = data.puzzles.filter((p) => p.privateKey);

console.log(`\n퍼즐 ${withKey.length}개를 두 구현으로 각각 유도해 대조`);
const t0 = process.hrtime.bigint();
let mismatch = [];
for (const p of withKey) {
  const k = BigInt('0x' + p.privateKey);
  const mine = derivePubkey(k);
  const noble = secp.etc.bytesToHex(secp.getPublicKey(hexToBytes(hex64(k)), true));
  if (mine !== noble || mine !== p.publicKey) {
    mismatch.push({ n: p.n, mine, noble, stored: p.publicKey });
  }
}
const ms = Number(process.hrtime.bigint() - t0) / 1e6;

ok(`${withKey.length}개 전부 일치 (직접 구현 = 노블 = 저장된 값)`, mismatch.length === 0,
   `${ms.toFixed(0)}ms`);
for (const m of mismatch) {
  console.log(`      #${m.n}\n        직접 ${m.mine}\n        노블 ${m.noble}\n        저장 ${m.stored}`);
}

// 공개키만 공개된 미해결 퍼즐: 저장된 공개키가 곡선 위의 점인지라도 확인한다
const pubOnly = data.puzzles.filter((p) => p.publicKey && !p.privateKey);
let bad = 0;
for (const p of pubOnly) {
  const x = BigInt('0x' + p.publicKey.slice(2));
  const y2 = mod(x * x * x + 7n);
  // 제곱근이 존재하는가 — 오일러 판정법
  if (powmod(y2, (P - 1n) / 2n) !== 1n) bad++;
}
ok(`미해결 중 공개키 공개된 ${pubOnly.length}개가 전부 곡선 위의 점`, bad === 0);

function hexToBytes(s) {
  const o = new Uint8Array(s.length / 2);
  for (let i = 0; i < o.length; i++) o[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
  return o;
}

// /verify 페이지가 이 스크립트 전문을 보여준다. 런타임에 파일을 읽으면
// 파일시스템 없는 환경에서 죽으므로 지금 박아둔다.
// 커밋되는 파일이므로 실행마다 달라지는 값(측정 시간 같은)은 넣지 않는다.
// 걸린 시간은 위 콘솔 출력에만 남긴다.
writeFileSync(
  join(root, 'data/crosscheck-source.json'),
  JSON.stringify({
    path: 'scripts/crosscheck.mjs',
    source: readFileSync(fileURLToPath(import.meta.url), 'utf8'),
    checked: withKey.length,
  }, null, 2) + '\n',
);

console.log(fail === 0 ? '\n✓ 교차검증 통과 — 독립된 두 구현이 같은 답을 냅니다\n' : `\n✗ ${fail}개 실패\n`);
process.exit(fail === 0 ? 0 : 1);