P(공격 성공) = (q/p)^z  (q < p인 경우)
P(공격 성공) = 1        (q ≥ p인 경우)

공격 통계:
- 총 재구성 횟수: 12회
- 최대 재구성 깊이: 24블록
- 이중지불된 금액: 219,500 ETC (~$1.1M)
- 공격 비용 추정: $5,000 - $10,000 (해시파워 임대 비용)
- 공격자 순이익: 약 $1,090,000

재구성된 블록 예시:
Block 7245623 → 7245647 (24블록 재구성)
Block 7246943 → 7246951 (8블록 재구성)

// 전통적인 방식 (Bitcoin)
선택 기준: 가장 긴 체인
Block A → Block B → Block C → Block D (길이: 4)
Block A → Block B → Block C' (길이: 3)
→ 첫 번째 체인 선택

// GHOST 방식 (Ethereum)
선택 기준: 가장 많은 작업증명이 누적된 서브트리
Block A → Block B → Block C → Block D (무게: 4)
              ↓
            Block C' (무게: 1)
→ 총 무게: 5

Block A → Block B' → Block C'' → Block D' (무게: 4)
→ 총 무게: 4

→ 첫 번째 서브트리 선택 (무게가 더 무거움)

// dPoW 작동 방식
1. Komodo 블록체인에서 블록 생성
   Block 1000: hash_1000

2. 주기적으로 (예: 10블록마다) 비트코인에 기록
   Bitcoin Block 700000: 
   OP_RETURN "KMD:1000:hash_1000"

3. 공격자가 Komodo를 51% 공격하려면
   → 비트코인도 함께 51% 공격해야 함!
   → 비트코인 공격 비용: 55억 달러
   → 경제적으로 불가능

🔐 51% Attack Simulation
==================================================
🌐 Normal Network Simulation
==================================================
✅ David mined a block!
Block mined: 00a3f5d8e9c2b1a4...
✅ Alice mined a block!
Block mined: 00b7c3e1f4d8a9c2...
✅ David mined a block!
Block mined: 00c9e2f5a8b3d1c4...
...

✅ Blockchain length: 11
✅ Chain valid: True

==================================================
🚨 51% Attack Simulation
==================================================
Attacker hash power: 53.0%
Attack depth: 5 blocks

📍 Fork point: Block 6
Honest chain length: 11
Attacker chain length: 6

🔨 Attacker mining secret chain...
  Round 1: Attacker mined block 6
  Round 1: Honest2 mined block 11
  Round 2: Attacker mined block 7
  Round 3: Attacker mined block 8
  Round 3: Honest1 mined block 12
  Round 4: Attacker mined block 9
  Round 5: Attacker mined block 10
  Round 6: Attacker mined block 11
  Round 7: Attacker mined block 12

📊 After 7 rounds:
Honest chain length: 13
Attacker chain length: 13

🎯 Attacker's chain is longer! Attempting to replace...
⚠️ Chain replaced! 51% attack successful!
💀 ATTACK SUCCESSFUL! Double spend executed!

==================================================
📈 Statistics
==================================================
Attack success: True
Final chain length: 13
Chain valid: True

이중지불 금액: 388,000 BTG
BTG 가격 (공격 당시): $50
총 이익: 388,000 × $50 = $19,400,000

순이익 = 총 이익 - 총 비용
       = $19,400,000 - $137,704.50
       = $19,262,295.50

ROI (투자 수익률) = (순이익 / 총 비용) × 100%
                  = ($19,262,295.50 / $137,704.50) × 100%
                  = 13,991%

약 140배의 수익! 😱

// PoS에서의 공격 비용
공격에 필요한 ETH: 전체 스테이킹된 ETH의 51%
현재 스테이킹된 ETH: 약 30,000,000 ETH
필요한 ETH: 30,000,000 × 0.51 = 15,300,000 ETH
ETH 가격: $2,000
총 비용: 15,300,000 × $2,000 = $30,600,000,000 (약 306억 달러!)

게다가:
- 공격 시도 시 슬래싱으로 스테이킹 자산 몰수
- 공격 성공 시 ETH 가격 폭락으로 자산 가치 하락
- 경제적으로 완전히 비합리적

// Decred의 하이브리드 합의
1. PoW 채굴자가 블록 생성
2. PoS 검증자가 블록 승인 (5명 중 3명 이상)
3. 둘 다 통과해야 블록이 확정

51% 공격을 하려면:
- PoW 해시파워의 51% + PoS 스테이크의 51%
- 두 가지를 동시에 장악해야 해서 거의 불가능

// AI 기반 이상 탐지 시스템
import tensorflow as tf
from sklearn.ensemble import IsolationForest

class AttackDetector:
    def __init__(self):
        self.model = IsolationForest(contamination=0.1)
        self.features = []
    
    def extract_features(self, blockchain):
        """블록체인에서 특징 추출"""
        features = {
            'hash_rate_variance': self.calculate_hash_rate_variance(),
            'block_time_variance': self.calculate_block_time_variance(),
            'reorg_frequency': self.count_reorganizations(),
            'large_transactions': self.detect_large_transactions(),
            'pool_concentration': self.calculate_pool_concentration()
        }
        return features
    
    def detect_anomaly(self, features):
        """이상 징후 탐지"""
        prediction = self.model.predict([features])
        if prediction == -1:
            alert("⚠️ Potential 51% attack detected!")
            return True
        return False

# 실시간 모니터링
detector = AttackDetector()
while True:
    features = detector.extract_features(blockchain)
    if detector.detect_anomaly(features):
        # 거래소에 알림, 입출금 중단 등
        emergency_protocol()

// 스마트 컨트랙트에서 확인 횟수 검증
pragma solidity ^0.8.0;

contract SecurePayment {
    uint256 public constant REQUIRED_CONFIRMATIONS = 12;
    
    struct Payment {
        address sender;
        address receiver;
        uint256 amount;
        uint256 blockNumber;
        bool confirmed;
    }
    
    mapping(uint256 => Payment) public payments;
    uint256 public paymentCount;
    
    function createPayment(address _receiver) external payable {
        payments[paymentCount] = Payment({
            sender: msg.sender,
            receiver: _receiver,
            amount: msg.value,
            blockNumber: block.number,
            confirmed: false
        });
        paymentCount++;
    }
    
    function confirmPayment(uint256 _paymentId) external {
        Payment storage payment = payments[_paymentId];
        require(!payment.confirmed, "Already confirmed");
        
        // 충분한 확인 횟수가 지났는지 검증
        require(
            block.number >= payment.blockNumber + REQUIRED_CONFIRMATIONS,
            "Not enough confirmations"
        );
        
        payment.confirmed = true;
        
        // 실제 송금 실행
        payable(payment.receiver).transfer(payment.amount);
    }
}

// Node.js로 구현한 블록체인 모니터링
const Web3 = require('web3');
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_KEY');

class BlockchainMonitor {
    constructor() {
        this.hashRateHistory = [];
        this.blockTimeHistory = [];
        this.reorgCount = 0;
    }
    
    async monitorHashRate() {
        const currentBlock = await web3.eth.getBlock('latest');
        const difficulty = currentBlock.difficulty;
        const blockTime = currentBlock.timestamp - 
                         (await web3.eth.getBlock(currentBlock.number - 1)).timestamp;
        
        // 해시레이트 계산 (간단한 추정)
        const hashRate = difficulty / blockTime;
        this.hashRateHistory.push(hashRate);
        
        // 최근 100블록의 평균과 비교
        if (this.hashRateHistory.length > 100) {
            this.hashRateHistory.shift();
            const avgHashRate = this.hashRateHistory.reduce((a, b) => a + b) / 100;
            const currentHashRate = this.hashRateHistory[this.hashRateHistory.length - 1];
            
            // 해시레이트가 갑자기 50% 이상 증가하면 경고
            if (currentHashRate > avgHashRate * 1.5) {
                this.alert('⚠️ Sudden hash rate increase detected!');
            }
        }
    }
    
    async detectReorganization() {
        const latestBlock = await web3.eth.getBlock('latest');
        const previousBlock = await web3.eth.getBlock(latestBlock.number - 1);
        
        // 이전 블록의 해시가 일치하지 않으면 재구성 발생
        if (latestBlock.parentHash !== previousBlock.hash) {
            this.reorgCount++;
            this.alert(`🚨 Chain reorganization detected! Count: ${this.reorgCount}`);
            
            // 재구성 깊이 계산
            let depth = 1;
            let currentBlock = latestBlock;
            while (depth < 100) {
                const prevBlock = await web3.eth.getBlock(currentBlock.number - 1);
                if (currentBlock.parentHash === prevBlock.hash) {
                    break;
                }
                depth++;
                currentBlock = prevBlock;
            }
            
            if (depth > 6) {
                this.alert(`🔴 CRITICAL: Deep reorganization detected! Depth: ${depth}`);
                this.emergencyProtocol();
            }
        }
    }
    
    alert(message) {
        console.log(message);
        // 이메일, SMS, Slack 등으로 알림 전송
        this.sendNotification(message);
    }
    
    emergencyProtocol() {
        // 긴급 프로토콜 실행
        // 1. 거래소 입출금 중단
        // 2. 관리자에게 긴급 연락
        // 3. 자동 대응 시스템 활성화
        console.log('🚨 EMERGENCY PROTOCOL ACTIVATED!');
    }
    
    async start() {
        console.log('🔍 Blockchain monitoring started...');
        setInterval(async () => {
            await this.monitorHashRate();
            await this.detectReorganization();
        }, 10000); // 10초마다 체크
    }
}

// 모니터링 시작
const monitor = new BlockchainMonitor();
monitor.start();

// 51% 공격에 강한 스마트 컨트랙트 패턴
pragma solidity ^0.8.0;

contract SecureVault {
    // 시간 잠금 (Time Lock)
    mapping(address => uint256) public unlockTime;
    mapping(address => uint256) public balances;
    
    uint256 public constant LOCK_DURATION = 1 days;
    
    function deposit() external payable {
        balances[msg.sender] += msg.value;
        // 입금 후 24시간 동안 출금 불가
        unlockTime[msg.sender] = block.timestamp + LOCK_DURATION;
    }
    
    function withdraw(uint256 _amount) external {
        require(block.timestamp >= unlockTime[msg.sender], "Still locked");
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        
        balances[msg.sender] -= _amount;
        payable(msg.sender).transfer(_amount);
    }
    
    // 다중 서명 (Multi-Sig)
    address[] public owners;
    mapping(uint256 => mapping(address => bool)) public confirmations;
    uint256 public required;
    
    struct Transaction {
        address to;
        uint256 value;
        bool executed;
        uint256 confirmationCount;
    }
    
    Transaction[] public transactions;
    
    modifier onlyOwner() {
        bool isOwner = false;
        for (uint i = 0; i < owners.length; i++) {
            if (owners[i] == msg.sender) {
                isOwner = true;
                break;
            }
        }
        require(isOwner, "Not an owner");
        _;
    }
    
    function submitTransaction(address _to, uint256 _value) 
        external 
        onlyOwner 
        returns (uint256) 
    {
        uint256 txId = transactions.length;
        transactions.push(Transaction({
            to: _to,
            value: _value,
            executed: false,
            confirmationCount: 0
        }));
        return txId;
    }
    
    function confirmTransaction(uint256 _txId) external onlyOwner {
        require(!confirmations[_txId][msg.sender], "Already confirmed");
        
        confirmations[_txId][msg.sender] = true;
        transactions[_txId].confirmationCount++;
        
        // 필요한 서명 수가 모이면 자동 실행
        if (transactions[_txId].confirmationCount >= required) {
            executeTransaction(_txId);
        }
    }
    
    function executeTransaction(uint256 _txId) internal {
        Transaction storage txn = transactions[_txId];
        require(!txn.executed, "Already executed");
        require(txn.confirmationCount >= required, "Not enough confirmations");
        
        txn.executed = true;
        payable(txn.to).transfer(txn.value);
    }
}