BlockchainDevGuide0002

프로그래밍 기초 완전 정복 A-Z

JavaScript로 해시·암호화·블록체인 기초를 직접 구현하는 실전 가이드

📋 학습 목차 — 코드를 치면서 블록체인을 이해합니다

개발 환경 세팅

Node.js · VSCode · npm — 블록체인 개발의 첫 번째 관문

# 설치 확인 명령어 (터미널/PowerShell에서 실행)
node --version   # v20.x.x 출력되면 OK
npm --version    # 10.x.x 출력되면 OK
git --version    # git version 2.x.x 출력되면 OK

# 첫 프로젝트 만들기
mkdir blockchain-study   # 폴더 생성
cd blockchain-study
npm init -y              # package.json 자동 생성

# 필수 패키지 설치
npm install elliptic     # 타원곡선 암호화 (지갑 생성)
npm install merkletreejs # 머클 트리
npm install ws           # WebSocket (P2P 네트워크)

JavaScript 핵심 문법

블록체인 개발에 반드시 필요한 JS 문법만 빠르게 정복합니다

// ✅ 변수 선언 — const(상수), let(변수), var(쓰지 말 것)
const blockHash = '0x1234abcd...';   // 재할당 불가 (권장)
let nonce = 0;                         // 재할당 가능

// ✅ 블록체인에서 자주 쓰는 데이터 타입
const amount = BigInt('1000000000000000000');  // 1 ETH (Wei 단위, 일반 숫자로 못 표현)
const txData = {                        // 객체 (트랜잭션 구조)
  from: '0xAbc...',
  to: '0xDef...',
  amount: 1000n,                        // BigInt 리터럴
  timestamp: Date.now()
};
const txList = [txData, txData2];       // 배열 (블록의 트랜잭션 목록)

// ✅ 16진수 / 2진수 / Buffer 다루기 (블록체인 핵심!)
const hex = 'ff';
console.log(parseInt(hex, 16));           // 255 (16진수 → 10진수)
console.log((255).toString(16));        // 'ff' (10진수 → 16진수)
console.log((255).toString(2));         // '11111111' (10진수 → 2진수)

// Buffer: 바이너리 데이터 처리 (해시값, 서명 등에 필수)
const buf = Buffer.from('hello', 'utf8');
console.log(buf.toString('hex'));         // '68656c6c6f'

// ✅ 화살표 함수 (블록체인 코드에서 가장 많이 쓰임)
const double = (x) => x * 2;
const greet = (name) => {
  return `Hello, ${name}!`;              // 템플릿 리터럴
};

// ✅ 클래스 — 블록(Block), 블록체인(Blockchain) 구조 만들 때 사용
class Block {
  constructor(index, data, previousHash) {
    this.index = index;
    this.timestamp = Date.now();
    this.data = data;
    this.previousHash = previousHash;
    this.nonce = 0;
    this.hash = this.calculateHash();
  }

  calculateHash() {
    // 다음 챕터에서 실제 구현!
    return `${this.index}${this.timestamp}${JSON.stringify(this.data)}${this.nonce}`;
  }

  // getter: 외부에서 hash처럼 접근 가능
  get isValid() {
    return this.hash === this.calculateHash();
  }
}

// 상속 — 특수 블록 만들 때
class GenesisBlock extends Block {
  constructor() {
    super(0, 'Genesis Block', '0000000000');
  }
}

블록체인과 통신할 때 (이더리움 노드 조회, 트랜잭션 전송 등)는 시간이 걸리는 작업입니다. async/await 없이는 코드가 멈추거나 순서가 뒤바뀝니다!

// ❌ 나쁜 예: 콜백 지옥 (블록체인 개발 시 절대 쓰지 말 것)
getBlock(1, (block) => {
  getTransaction(block.txId, (tx) => {
    verifySignature(tx, (result) => {
      console.log(result);  // 콜백 지옥!
    });
  });
});

// ✅ 좋은 예: async/await (현업 표준)
async function processBlock() {
  try {
    const block = await getBlock(1);
    const tx = await getTransaction(block.txId);
    const result = await verifySignature(tx);
    console.log(result);    // 깔끔!
  } catch (error) {
    console.error('블록 처리 실패:', error);
  }
}

// Promise.all — 여러 비동기 작업 동시 실행
const [block1, block2, block3] = await Promise.all([
  getBlock(1),
  getBlock(2),
  getBlock(3)
]);  // 3개 동시 요청 → 더 빠름!

해시 함수 직접 구현

Node.js crypto 모듈로 SHA-256 해시를 만들고 실제 데이터에 적용합니다

// hash.js — 해시 유틸리티 모음
const crypto = require('crypto');    // Node.js 내장 모듈, 설치 불필요!

// 1. 기본 SHA-256
function sha256(data) {
  return crypto
    .createHash('sha256')
    .update(data)
    .digest('hex');         // 'hex': 16진수 문자열 반환
}

// 2. 객체를 해시로 (블록 해시에 사용)
function hashObject(obj) {
  const json = JSON.stringify(obj, Object.keys(obj).sort());
  // 키를 정렬해야 { a:1, b:2 }와 { b:2, a:1 }이 같은 해시가 됨!
  return sha256(json);
}

// 3. 파일 해시 (대용량 파일도 처리 가능)
const fs = require('fs');
function hashFile(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  return crypto.createHash('sha256').update(fileBuffer).digest('hex');
}

// 4. HMAC: 비밀키가 있는 해시 (API 서명에 사용)
function hmacSha256(data, secretKey) {
  return crypto
    .createHmac('sha256', secretKey)
    .update(data)
    .digest('hex');
}

// 테스트
console.log(sha256('Hello Blockchain!'));
// d29e6f09b4c5a...  (항상 같은 결과)

const block = { index: 1, data: 'Transfer 1 ETH', timestamp: 1710000000000 };
console.log(hashObject(block));
// 객체의 모든 필드를 포함한 해시

// ❌ 절대 금지: 평문 비밀번호 저장
// DB: { username: 'alice', password: 'mypassword123' } — 해킹 시 그대로 노출!

// ✅ 올바른 방법: Salt + Hash (현업 표준)
function hashPassword(password) {
  const salt = crypto.randomBytes(16).toString('hex');  // 랜덤 소금값
  const hash = crypto
    .createHash('sha256')
    .update(salt + password)                       // salt를 앞에 붙여 레인보우 테이블 공격 방지
    .digest('hex');
  return `${salt}:${hash}`;  // DB에 저장
}

function verifyPassword(password, stored) {
  const [salt, hash] = stored.split(':');
  const inputHash = crypto.createHash('sha256').update(salt + password).digest('hex');
  return hash === inputHash;
}

const stored = hashPassword('mypassword123');
console.log(verifyPassword('mypassword123', stored));  // true
console.log(verifyPassword('wrongpassword', stored)); // false
// 💡 현업에서는 bcrypt, argon2 라이브러리 사용 권장 (더 안전)

비대칭 암호화 구현

공개키/개인키 생성, 디지털 서명, 서명 검증까지 — 지갑의 핵심 원리

💡 왜 ECDSA(타원곡선)인가?
RSA보다 훨씬 짧은 키로 동일한 보안 수준 달성. 256비트 ECDSA ≈ RSA 3072비트. 비트코인·이더리움 모두 secp256k1 곡선 사용.

// npm install elliptic
const { ec: EC } = require('elliptic');
const crypto = require('crypto');

// secp256k1: 비트코인·이더리움이 사용하는 타원곡선
const ec = new EC('secp256k1');

// ── 1. 키 페어 생성 ──────────────────────────────────────
const keyPair = ec.genKeyPair();

const privateKey = keyPair.getPrivate('hex');
const publicKey  = keyPair.getPublic('hex');

console.log('🔑 개인키 (64자리 hex):', privateKey);
console.log('📫 공개키 (130자리 hex):', publicKey);
// ⚠️ 개인키는 절대 공유하지 마세요! 이걸 가진 사람이 지갑 주인입니다.

// ── 2. 트랜잭션 서명 ─────────────────────────────────────
function signTransaction(txData, privateKeyHex) {
  const signingKey = ec.keyFromPrivate(privateKeyHex);
  
  // 트랜잭션 데이터의 해시를 서명 (데이터 전체가 아닌 해시에 서명)
  const txHash = crypto
    .createHash('sha256')
    .update(JSON.stringify(txData))
    .digest('hex');

  const signature = signingKey.sign(txHash);
  return {
    r: signature.r.toString('hex'),
    s: signature.s.toString('hex'),
    txHash
  };
}

// ── 3. 서명 검증 ─────────────────────────────────────────
function verifySignature(txData, signature, publicKeyHex) {
  const signingKey = ec.keyFromPublic(publicKeyHex, 'hex');
  const txHash = crypto
    .createHash('sha256')
    .update(JSON.stringify(txData))
    .digest('hex');
  
  return signingKey.verify(txHash, { r: signature.r, s: signature.s });
}

// ── 테스트 ───────────────────────────────────────────────
const tx = { from: publicKey, to: '0xBob...', amount: 1.5 };
const sig = signTransaction(tx, privateKey);
console.log('서명 유효?', verifySignature(tx, sig, publicKey)); // true

// 데이터 변조 시뮬레이션
const tamperedTx = { ...tx, amount: 100 };  // 금액 조작!
console.log('변조 후 유효?', verifySignature(tamperedTx, sig, publicKey)); // false!

// 이더리움 지갑 주소 도출 과정 (단순화 버전)
// 실제: 개인키 → 공개키(secp256k1) → Keccak-256 해시 → 마지막 20바이트 = 주소

function deriveAddress(publicKeyHex) {
  // 공개키 앞의 '04' prefix 제거 (비압축 형식)
  const pubKeyNoPrefix = publicKeyHex.slice(2);
  
  // SHA-256 해시 후 앞 12바이트 제거 → 20바이트 = 이더리움 주소
  const hash = crypto.createHash('sha256').update(pubKeyNoPrefix).digest('hex');
  return '0x' + hash.slice(-40);  // 마지막 40자리 (20바이트)
}

console.log('지갑 주소:', deriveAddress(publicKey));
// 출력: 0x1a2b3c4d5e6f... (40자리 hex)

// 💡 핵심 원리:
// 개인키(64자리) → 공개키(130자리) → 주소(42자리)
// 주소에서 공개키를 역산할 수 없음! (단방향)
// 주소에서 개인키를 역산할 수 없음! (단방향)

머클 트리 직접 구현

트랜잭션 무결성 검증의 핵심 자료구조를 코드로 만들어봅니다

💡 머클 트리란?

블록에 담긴 수천 개 트랜잭션을 하나의 해시(머클 루트)로 요약합니다.
특정 트랜잭션이 블록에 포함됐는지를 전체 블록체인 다운로드 없이 증명할 수 있습니다 (SPV).

// merkle.js — 머클 트리 직접 구현
const crypto = require('crypto');

const hash = (data) => crypto.createHash('sha256').update(data).digest('hex');

function buildMerkleTree(transactions) {
  if (transactions.length === 0) return null;
  
  // 트랜잭션 → 리프 해시
  let level = transactions.map(tx => hash(JSON.stringify(tx)));
  
  while (level.length > 1) {
    const nextLevel = [];
    
    for (let i = 0; i < level.length; i += 2) {
      const left = level[i];
      const right = i + 1 < level.length ? level[i + 1] : left;  // 홀수면 복사
      nextLevel.push(hash(left + right));
    }
    level = nextLevel;
  }
  
  return level[0];  // 머클 루트
}

// 테스트
const txs = [
  { from: 'Alice', to: 'Bob',   amount: 1.5 },
  { from: 'Bob',   to: 'Carol', amount: 0.3 },
  { from: 'Carol', to: 'Dave',  amount: 2.0 },
  { from: 'Dave',  to: 'Alice', amount: 0.7 },
];

const merkleRoot = buildMerkleTree(txs);
console.log('머클 루트:', merkleRoot);
// TX1 변조 후 머클 루트가 완전히 달라짐을 확인!

트랜잭션 구조 구현

UTXO 개념 이해, 서명된 트랜잭션 생성, 유효성 검증까지

// transaction.js — 서명된 트랜잭션 클래스
const crypto = require('crypto');
const { ec: EC } = require('elliptic');
const ec = new EC('secp256k1');

class Transaction {
  constructor(fromAddress, toAddress, amount) {
    this.fromAddress = fromAddress;  // 공개키 (보내는 사람)
    this.toAddress   = toAddress;    // 받는 사람 주소
    this.amount      = amount;
    this.timestamp   = Date.now();
    this.signature   = null;
  }

  // 트랜잭션의 해시 (서명 대상)
  calculateHash() {
    return crypto
      .createHash('sha256')
      .update(this.fromAddress + this.toAddress + this.amount + this.timestamp)
      .digest('hex');
  }

  // 개인키로 서명
  signTransaction(signingKey) {
    if (signingKey.getPublic('hex') !== this.fromAddress) {
      throw new Error('다른 사람 지갑으로 서명할 수 없습니다!');
    }
    const txHash = this.calculateHash();
    const sig = signingKey.sign(txHash, 'base64');
    this.signature = sig.toDER('hex');
  }

  // 서명 검증 (채굴자가 수행)
  isValid() {
    if (this.fromAddress === null) return true;  // 채굴 보상 트랜잭션
    if (!this.signature) throw new Error('서명이 없는 트랜잭션');

    const publicKey = ec.keyFromPublic(this.fromAddress, 'hex');
    return publicKey.verify(this.calculateHash(), this.signature);
  }
}

// 사용 예시
const aliceKey = ec.genKeyPair();
const bobPublicKey = ec.genKeyPair().getPublic('hex');

const tx = new Transaction(aliceKey.getPublic('hex'), bobPublicKey, 50);
tx.signTransaction(aliceKey);
console.log('트랜잭션 유효?', tx.isValid());  // true

⛏️ Chapter 07. PoW 채굴 알고리즘 구현

Proof of Work — 블록체인의 심장을 직접 만들다

📚 7.1 PoW란 무엇인가?

Proof of Work(작업 증명)는 비트코인이 채택한 합의 알고리즘입니다. "엄청난 계산을 해야만 블록을 만들 수 있다"는 원리로, 악의적인 공격자가 체인을 조작하려면 전 세계 채굴자보다 더 많은 연산 능력을 가져야 합니다.

💻 7.2 Blockchain 클래스 완성 (PoW 포함)

앞서 만든 Block, Transaction, MerkleTree를 합쳐 완전한 Blockchain 클래스를 구현합니다.

// ============================
// blockchain.js — 완전한 PoW 블록체인
// ============================
const crypto = require('crypto');

class Block {
  constructor(index, previousHash, transactions, difficulty = 4) {
    this.index          = index;
    this.timestamp      = Date.now();
    this.transactions   = transactions;
    this.previousHash   = previousHash;
    this.difficulty     = difficulty;
    this.nonce          = 0;
    this.merkleRoot     = this.computeMerkleRoot();
    this.hash           = this.mineBlock();
  }

  computeMerkleRoot() {
    const txHashes = this.transactions.map(tx =>
      crypto.createHash('sha256')
            .update(JSON.stringify(tx))
            .digest('hex')
    );
    return txHashes.reduce((a, b) =>
      crypto.createHash('sha256').update(a + b).digest('hex')
    , 'genesis');
  }

  calculateHash() {
    return crypto
      .createHash('sha256')
      .update(
        this.index +
        this.timestamp +
        this.merkleRoot +
        this.previousHash +
        this.nonce
      )
      .digest('hex');
  }

  mineBlock() {
    const target = '0'.repeat(this.difficulty);
    let hash = this.calculateHash();
    while (!hash.startsWith(target)) {
      this.nonce++;
      hash = this.calculateHash();
    }
    console.log(`⛏️  블록 ${this.index} 채굴 완료! nonce=${this.nonce} hash=${hash.substring(0,20)}...`);
    return hash;
  }
}

class Blockchain {
  constructor() {
    this.chain              = [this.createGenesisBlock()];
    this.difficulty          = 3;
    this.pendingTransactions = [];
    this.miningReward        = 12.5;
    this.blockTime           = 10000; // 목표: 10초
  }

  createGenesisBlock() {
    return new Block(0, '0000000000000000', [{
      from: 'GENESIS', to: 'GENESIS', amount: 0
    }], 0);
  }

  getLatestBlock() {
    return this.chain[this.chain.length - 1];
  }

  addTransaction(transaction) {
    if (!transaction.from || !transaction.to)
      throw new Error('Transaction must include from and to address!');
    if (transaction.amount <= 0)
      throw new Error('Transaction amount must be positive!');
    this.pendingTransactions.push(transaction);
  }

  minePendingTransactions(minerAddress) {
    // 채굴 보상 트랜잭션 추가
    const rewardTx = {
      from: 'COINBASE',
      to: minerAddress,
      amount: this.miningReward
    };
    this.pendingTransactions.push(rewardTx);

    // 새 블록 채굴
    const startTime = Date.now();
    const block = new Block(
      this.chain.length,
      this.getLatestBlock().hash,
      [...this.pendingTransactions],
      this.difficulty
    );
    const elapsed = Date.now() - startTime;

    // 난이도 자동 조절 (difficulty adjustment)
    if (elapsed < this.blockTime / 2)       this.difficulty++;
    else if (elapsed > this.blockTime * 2)  this.difficulty--;

    this.chain.push(block);
    this.pendingTransactions = [];
    return block;
  }

  getBalance(address) {
    let balance = 0;
    for (const block of this.chain) {
      for (const tx of block.transactions) {
        if (tx.from === address) balance -= tx.amount;
        if (tx.to   === address) balance += tx.amount;
      }
    }
    return balance;
  }

  isChainValid() {
    for (let i = 1; i < this.chain.length; i++) {
      const current  = this.chain[i];
      const previous = this.chain[i - 1];
      if (current.hash !== current.calculateHash())   return false;
      if (current.previousHash !== previous.hash)      return false;
    }
    return true;
  }
}

// ===== 실행 테스트 =====
const myChain = new Blockchain();
myChain.addTransaction({ from: 'Alice', to: 'Bob',   amount: 50  });
myChain.addTransaction({ from: 'Bob',   to: 'Carol', amount: 30  });
myChain.minePendingTransactions('Miner1');
console.log('Miner1 잔액:', myChain.getBalance('Miner1'));
console.log('체인 유효성:', myChain.isChainValid());

📊 7.3 난이도 조절 메커니즘 (Difficulty Adjustment)

$ node blockchain.js
⛏️  블록 0 채굴 완료! nonce=0    hash=0000000000000000...  (제네시스)
⛏️  블록 1 채굴 완료! nonce=1847 hash=0007a3f2e9b1c4d8...
⛏️  블록 2 채굴 완료! nonce=4521 hash=000b2c91fe730a55...
Miner1 잔액: 12.5
체인 유효성: true
난이도 조절 → difficulty: 4 (채굴 시간: 4.2s)

🔗 7.4 51% 공격 이해하기

// 공격자가 체인 데이터 변조 시도
const attacked = new Blockchain();
attacked.chain[1].transactions[0].amount = 9999;

console.log('공격 후 체인 유효성:', attacked.isChainValid());
// 출력: 공격 후 체인 유효성: false ← 즉시 탐지!

// 공격자가 51% 해시파워를 가지면?
// → 변조된 블록부터 다시 채굴해야 함 (엄청난 비용)
// → 비트코인 전체 해시파워의 51% = 수천억 원 이상의 장비 필요

👛 Chapter 08. 지갑(Wallet) 구현

키 생성부터 잔액 조회까지 — 비트코인 지갑의 모든 것

📚 8.1 지갑(Wallet)이란?

블록체인 지갑은 실제 코인을 저장하지 않습니다. 대신 개인키(Private Key)와 공개키(Public Key)를 관리합니다. 잔액은 블록체인에 기록되어 있고, 지갑은 그 잔액을 사용할 수 있는 열쇠를 보관합니다.

💻 8.2 Wallet 클래스 전체 구현

// wallet.js
const { generateKeyPairSync, createSign, createVerify, createHash } = require('crypto');

class Wallet {
  constructor() {
    // EC 키 쌍 생성 (secp256k1 — 비트코인과 동일 곡선)
    const { privateKey, publicKey } = generateKeyPairSync('ec', {
      namedCurve: 'secp256k1',
      publicKeyEncoding:  { type: 'spki',  format: 'pem' },
      privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
    });
    this.privateKey = privateKey;
    this.publicKey  = publicKey;
    this.address    = this.deriveAddress();
  }

  deriveAddress() {
    // 공개키를 SHA-256 후 앞 20바이트 → 주소
    return createHash('sha256')
      .update(this.publicKey)
      .digest('hex')
      .substring(0, 40);  // 40 hex chars = 20 bytes
  }

  sign(dataHash) {
    const sign = createSign('SHA256');
    sign.update(dataHash);
    sign.end();
    return sign.sign(this.privateKey, 'hex');
  }

  static verify(dataHash, signature, publicKey) {
    const verify = createVerify('SHA256');
    verify.update(dataHash);
    verify.end();
    return verify.verify(publicKey, signature, 'hex');
  }

  createTransaction(toAddress, amount, blockchain) {
    const balance = blockchain.getBalance(this.address);
    if (balance < amount)
      throw new Error(`잔액 부족! 잔액: ${balance}, 요청: ${amount}`);

    const tx = {
      from:      this.address,
      to:        toAddress,
      amount,
      timestamp: Date.now(),
      publicKey: this.publicKey
    };
    const txHash = createHash('sha256')
      .update(JSON.stringify({from: tx.from, to: tx.to, amount: tx.amount}))
      .digest('hex');
    tx.signature = this.sign(txHash);
    return tx;
  }
}

// ===== 사용 예시 =====
const alice = new Wallet();
const bob   = new Wallet();
console.log('Alice 주소:', alice.address);
console.log('Bob   주소:', bob.address);

🔐 8.3 HD Wallet (계층적 결정론적 지갑)

MetaMask, Trust Wallet 등 현대 지갑은 모두 BIP-32/BIP-39 표준의 HD Wallet을 사용합니다.

// npm install bip39 hdkey
const bip39 = require('bip39');
const HDKey = require('hdkey');

const mnemonic = bip39.generateMnemonic();
console.log('니모닉:', mnemonic);

const seed = await bip39.mnemonicToSeed(mnemonic);
const root = HDKey.fromMasterSeed(seed);

// 이더리움 첫 번째 주소
const child = root.derive("m/44'/60'/0'/0/0");
console.log('개인키:', child.privateKey.toString('hex'));

🌐 Chapter 09. P2P 네트워크 기초

WebSocket으로 탈중앙화 노드 네트워크 직접 구현

📚 9.1 P2P 네트워크 개요

블록체인은 중앙 서버 없이 모든 노드가 서로 연결되는 P2P (Peer-to-Peer) 네트워크로 운영됩니다. 새 블록이 채굴되면 전체 네트워크에 전파(broadcast)됩니다.

💻 9.2 WebSocket P2P 노드 구현

// p2p-node.js — npm install ws express
const WebSocket = require('ws');
const express   = require('express');

const MessageType = {
  QUERY_LATEST:        0,
  QUERY_ALL:           1,
  RESPONSE_BLOCKCHAIN: 2,
  BROADCAST_TX:        3
};

class P2PNode {
  constructor(httpPort, p2pPort, blockchain) {
    this.blockchain = blockchain;
    this.peers      = new Set();
    this.initHttpServer(httpPort);
    this.initP2PServer(p2pPort);
  }

  initHttpServer(port) {
    const app = express();
    app.use(express.json());

    app.get('/blocks', (req, res) =>
      res.json(this.blockchain.chain));

    app.get('/peers', (req, res) =>
      res.json([...this.peers].map(ws => ws.url)));

    app.post('/addPeer', (req, res) => {
      this.connectToPeer(req.body.peer);
      res.json({ status: 'connected' });
    });

    app.post('/mine', (req, res) => {
      const block = this.blockchain.minePendingTransactions(req.body.miner);
      this.broadcast(this.responseLatestMsg());
      res.json(block);
    });

    app.listen(port, () =>
      console.log(`🌐 HTTP API 서버: http://localhost:${port}`));
  }

  initP2PServer(port) {
    const server = new WebSocket.Server({ port });
    server.on('connection', ws => this.initConnection(ws));
    console.log(`⚡ P2P 서버 리스닝: ws://localhost:${port}`);
  }

  initConnection(ws) {
    this.peers.add(ws);
    ws.on('message', msg => this.handleMessage(ws, JSON.parse(msg)));
    ws.on('close',   ()  => this.peers.delete(ws));
    ws.on('error',   ()  => this.peers.delete(ws));
    // 연결 즉시 최신 블록 요청
    ws.send(JSON.stringify({ type: MessageType.QUERY_LATEST }));
  }

  handleMessage(ws, msg) {
    switch (msg.type) {
      case MessageType.QUERY_LATEST:
        ws.send(JSON.stringify(this.responseLatestMsg()));
        break;
      case MessageType.QUERY_ALL:
        ws.send(JSON.stringify({ type: MessageType.RESPONSE_BLOCKCHAIN, data: this.blockchain.chain }));
        break;
      case MessageType.RESPONSE_BLOCKCHAIN:
        this.handleBlockchainResponse(msg.data);
        break;
    }
  }

  handleBlockchainResponse(receivedChain) {
    const latestReceived = receivedChain[receivedChain.length - 1];
    const latestHeld     = this.blockchain.getLatestBlock();
    if (latestReceived.index > latestHeld.index) {
      console.log('더 긴 체인 발견 — 체인 교체 중...');
      if (receivedChain.length > this.blockchain.chain.length) {
        this.blockchain.chain = receivedChain;
        this.broadcast(this.responseLatestMsg());
      }
    }
  }

  connectToPeer(peerUrl) {
    const ws = new WebSocket(peerUrl);
    ws.on('open', () => this.initConnection(ws));
  }

  broadcast(msg) {
    this.peers.forEach(ws => ws.send(JSON.stringify(msg)));
  }

  responseLatestMsg() {
    return {
      type: MessageType.RESPONSE_BLOCKCHAIN,
      data: [this.blockchain.getLatestBlock()]
    };
  }
}

// ===== 실행 =====
const chain  = new Blockchain();
const node1  = new P2PNode(3001, 6001, chain);
// node1 → http://localhost:3001/mine, /blocks, /peers

🧪 9.3 멀티 노드 테스트

# 터미널 1 — 노드1 실행
HTTP_PORT=3001 P2P_PORT=6001 node p2p-node.js

# 터미널 2 — 노드2 실행
HTTP_PORT=3002 P2P_PORT=6002 node p2p-node.js

# 터미널 3 — 노드 연결 (노드2가 노드1에 연결)
curl -X POST http://localhost:3002/addPeer \
     -H "Content-Type: application/json" \
     -d '{"peer":"ws://localhost:6001"}'

# 노드1에서 채굴 — 노드2에 자동으로 전파됨
curl -X POST http://localhost:3001/mine \
     -d '{"miner":"Alice"}' -H "Content-Type: application/json"

# 노드2에서 체인 확인 (동기화 되었는지)
curl http://localhost:3002/blocks

🎤 Chapter 10. 현업 면접 Q&A TOP 15

블록체인 개발자 취업 면접에서 실제로 물어보는 질문들

✅ 학습 체크리스트

이 챕터를 완료했다면 아래 항목들을 모두 체크할 수 있어야 합니다:

BlockchainDevGuide0002 완료!

JavaScript 프로그래밍 기초부터 SHA-256, ECDSA, 머클트리,
UTXO, PoW 채굴, HD Wallet, P2P 네트워크까지 완전 정복했습니다!