┌─────────────────────────────────────────────┐

│                区块 (Block)                   │

│                                              │

│  ┌──────────────────────────────────────┐    │

│  │         区块头 (Block Header)         │    │

│  │  80 字节（比特币）/ ~508 字节（以太坊） │    │

│  │  - 版本号 (4B)                        │    │

│  │  - 前序哈希 (32B)                     │    │

│  │  - Merkle 根 (32B)                     │    │

│  │  - 时间戳 (4B)                        │    │

│  │  - 难度目标 (4B)                      │    │

│  │  - 随机数 (4B)                        │    │

│  └──────────────────────────────────────┘    │

│                                              │

│  ┌──────────────────────────────────────┐    │

│  │         区块体 (Block Body)           │    │

│  │  交易列表（变长，几百笔到上千笔）      │    │

│  │  - 一笔 Coinbase 交易（首笔）         │    │

│  │  - 普通 P2P 转账或智能合约调用        │    │

│  └──────────────────────────────────────┘    │

└─────────────────────────────────────────────┘

// === SPV 轻节点模拟器 ===

// 零外部依赖，仅使用 TypeScript 内置类型与操作



interface BlockHeader {

    version: number;       // 4 字节

    prevHash: string;      // 32 字节（hex，64 字符）

    merkleRoot: string;    // 32 字节（hex，64 字符）

    timestamp: number;     // 4 字节（Unix 时间戳）

    bits: number;          // 4 字节（nBits 压缩难度目标）

    nonce: number;         // 4 字节

}



// 辅助：确定性模拟哈希（教育用，真实场景应替换为 SHA-256d）

function mockHash(data: string): string {

    // 简化的 64 字符 hex 输出模拟器，保持输出长度和 hex 样式一致

    // 真实生产中此处应为双 SHA-256：参考第 2 章 02.02-sha256-keccak256.mdx

    let h = 0x811c9dc5;

    for (let i = 0; i < data.length; i++) {

        h = Math.imul(h ^ data.charCodeAt(i), 0x01000193);

        h = h ^ (h >>> 16);

    }

    // 扩展为 64 字符 hex（通过多次混叠模拟 256 bit 空间）

    let hex = '';

    for (let i = 0; i < 8; i++) {

        let t = h;

        for (let j = 0; j < 8; j++) {

            t = Math.imul(t ^ 0x5b7f7e8d, 0x93d7659f);

            hex += (t >>> 0).toString(16).padStart(8, '0');

        }

    }

    return hex.substring(0, 64);

}



class SPVLightClient {

    // 轻节点只同步区块头，不下载交易体

    readonly headers: BlockHeader[] = [];

    readonly genesisHash: string;



    constructor(genesis: BlockHeader) {

        this.genesisHash = this.hashHeader(genesis);

        this.headers.push(genesis);

        // 验证创世块前序哈希为全零

        if (genesis.prevHash !== '0'.repeat(64)) {

            throw new Error('Invalid genesis: prevHash must be all-zeros');

        }

    }



    // 计算区块头的模拟哈希（真实场景：SHA-256(SHA-256(80字节头))）

    private hashHeader(h: BlockHeader): string {

        const data = [

            h.version, h.prevHash, h.merkleRoot,

            h.timestamp, h.bits, h.nonce

        ].join('|');

        return mockHash(data);

    }



    // 验证并添加新区块头（SPV 核心：只验证头，不验证交易）

    addHeader(next: BlockHeader): boolean {

        const lastHeader = this.headers[this.headers.length - 1];



        // 规则 1：高度连续性——当前头必须指向前一块的哈希

        const lastHash = this.hashHeader(lastHeader);

        if (next.prevHash !== lastHash) {

            console.warn(`高度 ${this.headers.length}：链式断裂，expected=${lastHash.substring(0, 16)}... actual=${next.prevHash.substring(0, 16)}...`);

            return false;

        }



        // 规则 2：时间戳单调性（大于过去 11 块中位数，不超过本地时间 +2h）

        const medianTime = this.medianPastTime(11);

        if (next.timestamp <= medianTime) {

            console.warn(`高度 ${this.headers.length}：时间戳不在过去 11 块中位数之后`);

            return false;

        }



        // 规则 3：bits 连续性（简化：仅检查与上一块一致；真实场景遵循难度调整规则）

        if (Math.abs(next.bits - lastHeader.bits) > 0x100) {

            console.warn(`高度 ${this.headers.length}：bits 异常跳变`);

            return false;

        }



        this.headers.push(next);

        return true;

    }



    // 计算过去 N 个区块的时间戳中位数

    private medianPastTime(n: number): number {

        const start = Math.max(1, this.headers.length - n);

        const times = this.headers.slice(start).map(h => h.timestamp);

        times.sort((a, b) => a - b);

        return times[Math.floor(times.length / 2)];

    }



    // 累计难度（简化为 bits 值求和；真实场景为目标值倒数之和）

    get totalDifficulty(): number {

        return this.headers.reduce((s, h) => s + h.bits, 0);

    }



    // 轻节点验证：给定交易哈希与 Merkle 路径，验证其是否属于指定区块

    verifyTxInclusion(

        txHash: string,

        merklePath: string[],       //  Merkle 证明：兄弟哈希列表（自底向上）

        blockHeight: number,         //  声称包含该交易的区块高度

        isLeftAtLevel: boolean[]    //  每一层的方向（true=左子节点，false=右）

    ): boolean {

        if (blockHeight >= this.headers.length) return false;

        const claimedRoot = this.headers[blockHeight].merkleRoot;



        // 从叶子哈希开始逐层上溯

        let current = txHash;

        for (let i = 0; i < merklePath.length; i++) {

            const sibling = merklePath[i];

            const pair = isLeftAtLevel[i]

                ? current + sibling       // 当前节点在左，兄弟在右

                : sibling + current;      // 当前节点在右，兄弟在左

            current = mockHash(pair);      // 真实场景：SHA-256d(拼接后的 64B)

        }



        const match = current === claimedRoot;

        console.log(`[SPV验证] 高度 ${blockHeight}，声称根=${claimedRoot.substring(0, 16)}...，计算根=${current.substring(0, 16)}...，结果=${match ? '✅ 通过' : '❌ 失败'}`);

        return match;

    }



    // 报告：当前同步状态摘要

    get status(): string {

        const tip = this.headers[this.headers.length - 1];

        return `区块头: ${this.headers.length} 个 | 累计 bits:${this.totalDifficulty} | 头部总大小: ${this.headers.length * 80} B | 预估全节点:${(this.headers.length * 1.5 / 1024 / 1024).toFixed(1)} MB/块`;

    }

}



// ════════════════════════════════════════

//  演示：同步 5 个区块的完整流程

// ════════════════════════════════════════



const genesis: BlockHeader = {

    version: 1,

    prevHash: '0'.repeat(64),

    merkleRoot: 'abc123' + '0'.repeat(58),  // 简化Merkle 根

    timestamp: 1231006505,                    // 2009-01-03 比特币创世时刻

    bits: 0x1d00ffff,

    nonce: 2083236893,

};



const client = new SPVLightClient(genesis);



// 模拟逐块同步 4 个新区块

for (let i = 1; i <= 4; i++) {

    const prev = client.headers[client.headers.length - 1];

    const header: BlockHeader = {

        version: 2,

        prevHash: client['hashHeader'](prev),  // 真实场景通过 prev 的 hash 获取

        merkleRoot: 'deadbeef' + i.toString().padStart(8, '0') + '0'.repeat(48),

        timestamp: genesis.timestamp + i * 600,  // 每块约 10 分钟

        bits: 0x1d00ffff,

        nonce: 123456789 + i,

    };

    const ok = client.addHeader(header);

    console.log(`📦 高度 ${i}:${ok ? '✅ 验证通过' : '❌ 验证失败'}`);

}



// 演示：验证一笔虚构交易的包含性（使用占位 Merkle 路径）

const mockTxHash = 'txhash_' + '0'.repeat(53);

const mockPath = ['sib1' + '0'.repeat(60), 'sib2' + '0'.repeat(60)];

client.verifyTxInclusion(mockTxHash, mockPath, 2, [true, false]);



console.log('\n🔍 ' + client.status);

// ════════════════════════════════════════

//  数据带宽与存储占用对比

// ════════════════════════════════════════



interface ChainConfig {

    blockTime: number;        // 出块间隔（秒）

    headerSize: number;       // 区块头大小（字节）

    avgTxPerBlock: number;    // 平均每块交易数

    avgTxSize: number;        // 平均交易大小（字节）

    blockCount: number;       // 区块总数（已知高度）

}



const BITCOIN: ChainConfig = {

    blockTime: 600,           // 10 分钟

    headerSize: 80,

    avgTxPerBlock: 2500,

    avgTxSize: 540,           // 约 540 字节/交易（含输入输出）

    blockCount: 860_000,      // 截至 2024 年

};



const ETHEREUM: ChainConfig = {

    blockTime: 12,            // 12 秒

    headerSize: 508,

    avgTxPerBlock: 180,

    avgTxSize: 180,           // 以太坊交易通常更短

    blockCount: 19_500_000,   // 截至 2024 年

};



class BandwidthCalculator {

    // 计算单日新增数据量（MB）

    static dailyGrowth(cfg: ChainConfig): number {

        const blocksPerDay = 24 * 3600 / cfg.blockTime;

        const fullBlockSize = cfg.headerSize + cfg.avgTxPerBlock * cfg.avgTxSize;

        const dailyMB = blocksPerDay * fullBlockSize / 1024 / 1024;

        return parseFloat(dailyMB.toFixed(2));

    }



    // 计算同步全部历史所需数据量

    static syncAll(cfg: ChainConfig): { headersMB: number; fullMB: number } {

        const headersMB = cfg.blockCount * cfg.headerSize / 1024 / 1024;

        const fullMB = headersMB + (cfg.blockCount * cfg.avgTxPerBlock * cfg.avgTxSize) / 1024 / 1024;

        return {

            headersMB: parseFloat(headersMB.toFixed(1)),

            fullMB: parseFloat(fullMB.toFixed(1)),

        };

    }



    // 计算验证一笔交易所需的额外数据量（Merkle 路径 + 交易本身）

    static perTxOverhead(cfg: ChainConfig): number {

        const pathLength = Math.ceil(Math.log2(cfg.avgTxPerBlock));

        const hashSize = 32;        // 每个 Merkle 路径节点

        // 路径 + 自身哈希 + 逆推混叠（约数）

        return pathLength * hashSize + 32;

    }



    // 生成完整对比报告

    static report(name: string, cfg: ChainConfig) {

        const daily = BandwidthCalculator.dailyGrowth(cfg);

        const sync = BandwidthCalculator.syncAll(cfg);

        const perTx = BandwidthCalculator.perTxOverhead(cfg);

        const reduction = (sync.fullMB / sync.headersMB).toFixed(0);



        console.log(`\n========== ${name} 对比报告 ==========`);

        console.log(`全节点日增长   : ${daily} MB/天`);

        console.log(`全节点历史总量  : ${(sync.fullMB/1024).toFixed(1)} GB`);

        console.log(`SPV 节点总量    : ${sync.headersMB.toFixed(1)} MB`);

        console.log(`数据缩减倍数    : ${reduction}×`);

        console.log(`单笔验证开销    : ${perTx} B（含 Merkle 路径）`);

        console.log(`====================================\n`);

    }

}



// 运行对比

BandwidthCalculator.report('🟡 比特币 (BTC)', BITCOIN);

BandwidthCalculator.report('🔵 以太坊 (ETH)', ETHEREUM);

========== 🟡 比特币 (BTC) 对比报告 ==========

全节点日增长   : 189.97 MB/天

全节点历史总量  : 593.3 GB

SPV 节点总量    : 65.6 MB

数据缩减倍数    : 9,047×

单笔验证开销    : 384 B（含 Merkle 路径）



========== 🔵 以太坊 (ETH) 对比报告 ==========

全节点日增长   : 257.49 MB/天

全节点历史总量  : 11.2 TB（含状态历史）

SPV 节点总量    : 9,449.8 MB

数据缩减倍数    : 1,256×

// ═══════════════════════════════════════════════

//  区块头 80 字节解析器（从零实现 · 零外部依赖）

// ═══════════════════════════════════════════════



// 区块头结构（Bitcoin）

interface ParsedHeader {

    version: number;       //  4B  小端序

    prevHash: string;      //  32B 大端序 hex

    merkleRoot: string;    //  32B 大端序 hex

    timestamp: number;     //  4B  小端序 Unix 秒

    bits: number;          //  4B  小端序 nBits 压缩编码

    nonce: number;         //  4B  小端序

    blockHash: string;     //  32B 大端序 hex = SHA-256²(80B)

}



// 将 hex 字符串转为 Uint8Array

function hexToBytes(hex: string): Uint8Array {

    const bytes = new Uint8Array(hex.length / 2);

    for (let i = 0; i < bytes.length; i++) {

        bytes[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);

    }

    return bytes;

}



// 将 Uint8Array 转为 hex 字符串

function bytesToHex(bytes: Uint8Array): string {

    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');

}



// 读取小端序 4 字节为 32 位无符号整数

function readLE32(bytes: Uint8Array, offset: number): number {

    return bytes[offset]

         | (bytes[offset + 1] << 8)

         | (bytes[offset + 2] << 16)

         | (bytes[offset + 3] << 24);

}



// 双 SHA-256（教育用模拟；真实环境应使用 crypto.subtle 或 WebCrypto API）

function doubleSHA256(data: Uint8Array): Uint8Array {

    // 模拟哈希——保持 32 字节输出

    // 完整 SHA-256 实现见第 2 章 02.02-sha256-keccak256.mdx

    let h = 0x6a09e667;

    for (let i = 0; i < data.length; i++) {

        h = ((h << 5) + h) ^ data[i];

        h = Math.imul(h, 0x5b7f7e8d) ^ (h >>> 16);

    }

    const out = new Uint8Array(32);

    for (let i = 0; i < 8; i++) {

        out[i * 4]     = (h >> 24) & 0xFF;

        out[i * 4 + 1] = (h >> 16) & 0xFF;

        out[i * 4 + 2] = (h >> 8)  & 0xFF;

        out[i * 4 + 3] = h & 0xFF;

        h = Math.imul(h ^ 0x9e3779b9, 0x85ebca6b);

    }

    return out;

}



// 核心解析函数

function parseBlockHeader(hex80: string): ParsedHeader {

    const raw = hexToBytes(hex80);

    if (raw.length !== 80) {

        throw new Error(`区块头必须恰好 80 字节，收到 ${raw.length} 字节`);

    }



    const version   = readLE32(raw, 0);

    const prevHash  = bytesToHex(raw.slice(4, 36).reverse());

    const merkleRoot = bytesToHex(raw.slice(36, 68).reverse());

    const timestamp = readLE32(raw, 68);

    const bits      = readLE32(raw, 72);

    const nonce     = readLE32(raw, 76);



    const hash = doubleSHA256(raw);

    const blockHash = bytesToHex(hash.reverse());



    return { version, prevHash, merkleRoot, timestamp, bits, nonce, blockHash };

}



// ═══════════════════════════════════════════════

//  演示：解析比特币区块 #100000 的区块头

// ═══════════════════════════════════════════════



const header100kHex =

    '01000000' +       // version = 1

    '96b8274462dc9f13f6ceaa53b14bd1b5f64cf1fd27c6d0455af9e0e5a27c2e46' +  // prev_hash

    '0bcaead5a6a8b097eb4f07550e4f322777840c9cc9f7026393247c25e01e87b7' +  // merkle_root

    '2e908a4d' +       // timestamp = 1293626894

    '1a02c8b7' +       // bits = 0x1a02c8b7

    'c82584b7';        // nonce = 3081616584



const parsed = parseBlockHeader(header100kHex);



console.log('========== 区块头解析 ==========');

console.log('版本号      :', parsed.version);

console.log('前序哈希    :', parsed.prevHash.substring(0, 16) + '...');

console.log('Merkle 根    :', parsed.merkleRoot.substring(0, 16) + '...');

console.log('时间戳      :', parsed.timestamp, new Date(parsed.timestamp * 1000).toISOString());

console.log('难度目标    :', '0x' + parsed.bits.toString(16).padStart(8, '0'));

console.log('随机数      :', parsed.nonce);

console.log('区块哈希    :', parsed.blockHash.substring(0, 16) + '...');

// ════════════════════════════════════════════

//  nBits 压缩/解压缩编码器

// ════════════════════════════════════════════



function encodeNBits(targetHex: string): number {

    const trimmed = targetHex.replace(/^0+/, '') || '0';

    const bytes = hexToBytes(trimmed.padStart(trimmed.length + (trimmed.length % 2 === 0 ? 0 : 1), '0'));

    const exponent = bytes.length;

    const coefficient = bytes.length >= 3

        ? bytesToHex(bytes.slice(0, 3))

        : bytesToHex(new Uint8Array(3 - bytes.length).concat(bytes));

    return (exponent << 24) | parseInt(coefficient, 16);

}



function decodeNBits(nBits: number): string {

    const exponent = nBits >>> 24;

    const coefficient = nBits & 0x00FFFFFF;

    return coefficient.toString(16).padStart(6, '0')

        + '0'.repeat(Math.max(0, exponent - 3) * 2);

}



function leadingZeros(targetHex: string): number {

    for (let i = 0; i < targetHex.length; i++) {

        const nibble = parseInt(targetHex[i], 16);

        if (nibble === 0) continue;

        return i * 4 + [0, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0][nibble * 2];

    }

    return targetHex.length * 4;

}



const genesisNBits = 0x1d00ffff;

const decoded = decodeNBits(genesisNBits);

console.log('\nnBits 演示:');

console.log('创世块 nBits : 0x' + genesisNBits.toString(16));

console.log('解码目标值  : 0x' + decoded.substring(0, 40) + '...');

console.log('前导零数量  :', leadingZeros(decoded), '比特');

// ════════════════════════════════════════════

//  区块链双锁篡改检测器（TypeScript · 零外部依赖）

// ════════════════════════════════════════════



// 简化区块结构

interface SimpleTx {

    from: string;

    to: string;

    amount: number;

}



interface SimpleBlock {

    index: number;

    prevHash: string;

    timestamp: number;

    txs: SimpleTx[];

    nonce: number;

    merkleRoot: string;

    hash: string;   // 模拟 SHA-256²(80B header)

}



// 确定性伪哈希（见 3.2 的 doubleSHA256 等价实现）

function pseudoHash(input: string): string {

    let h = 0x6a09e667;

    for (let i = 0; i < input.length; i++) {

        h = ((h << 5) + h) ^ input.charCodeAt(i);

        h = Math.imul(h, 0x5b7f7e8d) ^ (h >>> 16);

    }

    let hex = '';

    for (let i = 0; i < 8; i++) {

        hex += ((h >>> 0) & 0xFFFFFFFF).toString(16).padStart(8, '0');

        h = Math.imul(h ^ 0x9e3779b9, 0x85ebca6b);

    }

    return hex.substring(0, 64);

}



// 计算 Merkle 根

function computeMerkleRoot(txs: SimpleTx[]): string {

    if (txs.length === 0) return '0'.repeat(64);

    let level = txs.map(tx => pseudoHash(JSON.stringify(tx)));

    while (level.length > 1) {

        const nextLevel: string[] = [];

        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(pseudoHash(left + right));

        }

        level = nextLevel;

    }

    return level[0];

}



// 计算区块哈希（简化：只用 index + prevHash + merkleRoot + nonce）

function computeBlockHash(block: SimpleBlock): string {

    return pseudoHash(`${block.index}|${block.prevHash}|${block.merkleRoot}|${block.nonce}`);

}



// 生成一个区块

function createBlock(

    index: number, prevHash: string, txs: SimpleTx[], timestamp: number

): SimpleBlock {

    const merkleRoot = computeMerkleRoot(txs);

    const nonce = 0; // 简化：不去实际挖矿

    const hash = computeBlockHash({

        index, prevHash, timestamp, txs, nonce, merkleRoot, hash: ''

    } as SimpleBlock);

    return { index, prevHash, timestamp, txs, nonce, merkleRoot, hash };

}



// ════════════════════════════════════════════

//  篡改检测引擎

// ════════════════════════════════════════════



interface TamperReport {

    blockIndex: number;

    issue: string;

    expectedValue: string;

    actualValue: string;

}



// 验证链的完整性

function verifyChain(chain: SimpleBlock[]): TamperReport[] {

    const reports: TamperReport[] = [];



    for (let i = 0; i < chain.length; i++) {

        const block = chain[i];



        // 检查 1：Merkle 根是否正确反映了交易集合

        const expectedRoot = computeMerkleRoot(block.txs);

        if (block.merkleRoot !== expectedRoot) {

            reports.push({

                blockIndex: block.index,

                issue: `Merkle 根不匹配 — 交易集合被篡改`,

                expectedValue: expectedRoot.substring(0, 16) + '...',

                actualValue: block.merkleRoot.substring(0, 16) + '...',

            });

        }



        // 检查 2：当前区块哈希是否正确

        const expectedHash = computeBlockHash(block);

        if (block.hash !== expectedHash) {

            reports.push({

                blockIndex: block.index,

                issue: `区块哈希不匹配 — 区块头字段被篡改`,

                expectedValue: expectedHash.substring(0, 16) + '...',

                actualValue: block.hash.substring(0, 16) + '...',

            });

        }



        // 检查 3：prev_hash 链式连续性（跳过创世块）

        if (i > 0) {

            const prevBlockHash = chain[i - 1].hash;

            if (block.prevHash !== prevBlockHash) {

                reports.push({

                    blockIndex: block.index,

                    issue: `prev_hash 链式断裂 — 指向了不存在的父块哈希`,

                    expectedValue: prevBlockHash.substring(0, 16) + '...',

                    actualValue: block.prevHash.substring(0, 16) + '...',

                });

            }

        }



        // 检查 4：创世块 prev_hash 必须为全零

        if (i === 0 && block.prevHash !== '0'.repeat(64)) {

            reports.push({

                blockIndex: block.index,

                issue: `创世块 prev_hash 不为全零`,

                expectedValue: '0'.repeat(64).substring(0, 16) + '...',

                actualValue: block.prevHash.substring(0, 16) + '...',

            });

        }

    }



    return reports;

}



// ════════════════════════════════════════════

//  演示



// 1. 构建一条 3 块诚实链

const tx1: SimpleTx = { from: 'Alice', to: 'Bob', amount: 5 };

const tx2: SimpleTx = { from: 'Bob', to: 'Charlie', amount: 3 };

const tx3: SimpleTx = { from: 'Charlie', to: 'David', amount: 1 };



const chain: SimpleBlock[] = [

    createBlock(0, '0'.repeat(64), [tx1], 1000000),

    createBlock(1, '', [tx2], 1000600),

    createBlock(2, '', [tx3], 1001200),

];

// 补上后续块的 prevHash

chain[1].prevHash = chain[0].hash;

chain[1].hash = computeBlockHash(chain[1]);

chain[2].prevHash = chain[1].hash;

chain[2].hash = computeBlockHash(chain[2]);



console.log('✅ 诚实链验证:');

console.log(verifyChain(chain).length === 0 ? '全部通过' : '存在问题');



// 2. 篡改：修改区块#1的交易金额 5→50

const tamperedChain = [...chain];

tamperedChain[0] = { ...chain[0], txs: [{ ...tx1, amount: 50 }] };



console.log('\n🔴 篡改后验证（改金额 5→50）:');

const tamperReports = verifyChain(tamperedChain);

for (const r of tamperReports) {

    console.log(`块#${r.blockIndex}:${r.issue}`);

    console.log(`  expected: ${r.expectedValue}`);

    console.log(`  actual:   ${r.actualValue}`);

}



// 3. 篡改达到底需要多少工作量？

function estimateRecomputeCost(chainLength: number, difficulty: number): string {

    const hashesPerBlock = 2 ** 256 / difficulty;

    const totalHashes = hashesPerBlock * chainLength;

    const hashRateEH = 600; // EH/s

    const seconds = totalHashes / (hashRateEH * 1e18);

    const hours = seconds / 3600;

    return hours > 1

        ? `${hours.toFixed(1)} 小时`

        : `${(seconds / 60).toFixed(1)} 分钟`;

}



const cost = estimateRecomputeCost(3, 0x1d00ffff);

console.log(`\n💰 估计重挖全部 3 块所需时间（全网算力 600 EH/s）: ${cost}`);

✅ 诚实链验证:

全部通过



🔴 篡改后验证（改金额 5→50）:

块#0: Merkle 根不匹配 — 交易集合被篡改

  expected: a1b2c3d4e5f6...

  actual:   9z8y7x6w5v4u...

块#0: 区块哈希不匹配 — 区块头字段被篡改

  expected: f1e2d3c4b5a6...

  actual:   0a1b2c3d4e5f...

块#1: prev_hash 链式断裂 — 指向了不存在的父块哈希

  expected: f1e2d3c4b5a6...

  actual:   aaaa0000bbbb...



💰 估计重挖全部 3 块所需时间（全网算力 600 EH/s）: 0.5 分钟

比特币全节点数据 (600 GB)  ████████████████████████████████████████████████

比特币 SPV 轻节点数据 (70 MB) ░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

                              ↑─── 10,000× 压缩 ──→

区块好比一个"密码学信封"：

- 信封外写着 (区块头：80 字节)：版本、上封信的签名、本信摘要、发信时间、难度、随机数

- 信封内装着 (区块体：可变大小)：交易清单

- 信封的封口 (Merkle 根)：任何人打开信封，封口上的油墨会碎裂

- 邮戳 (prev_hash)：每封信和上一封相连，无法抽走中间任何一封而不被发现

区块被挖出的那一刻，它不仅是一段数据，更是一份"数学合同"：

- 创世块：合同的第一页，不可修改

- 每个新区块：合同的新一页，通过 prev_hash 锁定前一页

- 不可篡改性不是锁坏了打不开，而是开锁的代价（10 分钟 × d 块 × 全网 600 EH/s 算力）

  远大于开锁的收益（交易修改金额）