公鏈/私鏈 + 區塊瀏覽器開發源碼全解析

什麼是公鏈/私鏈

公鏈（Public Blockchain）是完全開放的區塊鏈網絡，任何人都可以參與節點運行、交易提交和數據驗證，代表項目包括 Bitcoin、Ethereum、Solana、Avalanche 等。其核心特徵是無許可、去中心化和抗審查。

私鏈（Private Blockchain）是許可型區塊鏈網絡，節點的加入和退出由管理方控制，適用於企業內部數據共享、供應鏈追溯、金融清結算等場景。代表框架包括 Hyperledger Fabric、Quorum、FISCO BCOS 等。

核心特徵對比

公鏈與私鏈技術對比

共識機制詳解

共識機制是區塊鏈的核心引擎，決定了網絡如何就賬本狀態達成一致。不同場景需要不同的共識算法取捨。

主流共識算法

共識算法源碼結構（PoS 示例）

// validator_set.go - 验证者集合管理
type ValidatorSet struct {
    Validators []*Validator
    TotalStake uint64
}

type Validator struct {
    Address    common.Address
    Stake      uint64
    Commission float64
    Active     bool
}

// 按权重选择出块者（加权随机）
func (vs *ValidatorSet) SelectProposer(seed []byte) *Validator {
    hash := crypto.Keccak256(seed)
    target := new(big.Int).SetBytes(hash)
    target.Mod(target, big.NewInt(int64(vs.TotalStake)))

    cumulative := uint64(0)
    for _, v := range vs.Validators {
        if !v.Active { continue }
        cumulative += v.Stake
        if cumulative > target.Uint64() {
            return v
        }
    }
    return vs.Validators[0]
}

// 验证区块签名
func (vs *ValidatorSet) VerifyBlockSignature(block *Block) error {
    proposer := vs.GetValidator(block.ProposerAddress)
    if proposer == nil {
        return ErrUnknownValidator
    }
    if !crypto.VerifySignature(proposer.PublicKey, block.Hash(), block.Signature) {
        return ErrInvalidSignature
    }
    return nil
}

鏈架構設計

一條完整的區塊鏈從底層到上層可劃分為以下技術層次：

節點開發核心模塊

區塊鏈節點是網絡的基本組成單元，負責接收交易、驗證區塊、維護狀態和參與共識。以下是節點核心模塊的源碼結構：

區塊與交易數據結構

// block.go - 区块结构定义
type BlockHeader struct {
    ParentHash   common.Hash    `json:"parentHash"`
    StateRoot    common.Hash    `json:"stateRoot"`
    TxRoot       common.Hash    `json:"transactionsRoot"`
    ReceiptRoot  common.Hash    `json:"receiptsRoot"`
    Coinbase     common.Address `json:"miner"`
    Difficulty   *big.Int       `json:"difficulty"`
    Number       *big.Int       `json:"number"`
    GasLimit     uint64         `json:"gasLimit"`
    GasUsed      uint64         `json:"gasUsed"`
    Timestamp    uint64         `json:"timestamp"`
    Nonce        [8]byte        `json:"nonce"`
}

type Block struct {
    Header       *BlockHeader
    Transactions []*Transaction
    Uncles       []*BlockHeader
}

type Transaction struct {
    Nonce    uint64          `json:"nonce"`
    GasPrice *big.Int        `json:"gasPrice"`
    Gas      uint64          `json:"gas"`
    To       *common.Address `json:"to"`
    Value    *big.Int        `json:"value"`
    Data     []byte          `json:"input"`
    V, R, S  *big.Int        // 签名数据
}

// 计算区块哈希
func (b *Block) Hash() common.Hash {
    return crypto.Keccak256Hash(rlp.Encode(b.Header))
}

// 验证区块有效性
func (b *Block) Validate(parent *Block) error {
    if b.Header.ParentHash != parent.Hash() {
        return ErrInvalidParentHash
    }
    if b.Header.Number.Uint64() != parent.Header.Number.Uint64()+1 {
        return ErrInvalidBlockNumber
    }
    if b.Header.Timestamp <= parent.Header.Timestamp {
        return ErrInvalidTimestamp
    }
    return nil
}

交易池（TxPool）

// txpool.go - 交易池管理
type TxPool struct {
    pending map[common.Address]*txList  // 可执行交易
    queue   map[common.Address]*txList  // 等待 nonce 连续
    mu      sync.RWMutex
    maxSize int
}

func (pool *TxPool) AddTransaction(tx *Transaction) error {
    pool.mu.Lock()
    defer pool.mu.Unlock()

    // 1. 验证签名
    sender, err := tx.RecoverSender()
    if err != nil { return ErrInvalidSignature }

    // 2. 验证 nonce
    currentNonce := pool.stateDB.GetNonce(sender)
    if tx.Nonce < currentNonce { return ErrNonceTooLow }

    // 3. 验证余额
    cost := new(big.Int).Mul(tx.GasPrice, new(big.Int).SetUint64(tx.Gas))
    cost.Add(cost, tx.Value)
    if pool.stateDB.GetBalance(sender).Cmp(cost) < 0 {
        return ErrInsufficientFunds
    }

    // 4. 加入交易池
    if tx.Nonce == currentNonce {
        pool.pending[sender].Add(tx)
    } else {
        pool.queue[sender].Add(tx)
    }
    return nil
}

智能合約虛擬機

智能合約虛擬機（VM）是鏈上代碼的執行環境。EVM（Ethereum Virtual Machine）是最主流的實現，幾乎所有 EVM 兼容鏈都基於相同的字節碼規範。

EVM 執行模型

• 棧式架構：操作數棧最大深度 1024，每個元素 256 位（32 字節）
• 確定性執行：相同輸入必然產生相同輸出，確保全網狀態一致
• Gas 機制：每條指令消耗固定 Gas，防止無限循環和資源濫用
• 狀態隔離：每個合約擁有獨立存儲空間，通過 SSTORE/SLOAD 讀寫

EVM 核心指令集實現

// evm/interpreter.go - EVM 解释器核心循环
func (evm *EVM) Execute(contract *Contract, input []byte) ([]byte, error) {
    var (
        stack   = newStack()
        memory  = newMemory()
        pc      uint64 = 0
        gas     uint64 = contract.Gas
    )

    code := contract.Code
    for pc < uint64(len(code)) {
        op := OpCode(code[pc])
        operation := evm.jumpTable[op]

        // Gas 扣费
        if gas < operation.gasCost {
            return nil, ErrOutOfGas
        }
        gas -= operation.gasCost

        // 执行指令
        switch op {
        case ADD:
            a, b := stack.Pop(), stack.Pop()
            stack.Push(new(big.Int).Add(a, b))
        case SSTORE:
            key, value := stack.Pop(), stack.Pop()
            evm.StateDB.SetState(contract.Address, key, value)
        case CALL:
            // 跨合约调用
            addr, value, inOffset, inSize := stack.Pop4()
            ret, err := evm.Call(contract, addr, input[inOffset:inOffset+inSize], gas/64, value)
            stack.Push(ret)
        case RETURN:
            offset, size := stack.Pop(), stack.Pop()
            return memory.GetSlice(offset, size), nil
        }
        pc++
    }
    return nil, nil
}

自定義預編譯合約

預編譯合約是內置在節點中的高性能合約，用於密碼學運算、跨鏈橋接等操作：

// precompiles.go - 自定义预编译合约注册
var PrecompiledContracts = map[common.Address]PrecompiledContract{
    common.HexToAddress("0x01"): &ecRecover{},     // 签名恢复
    common.HexToAddress("0x02"): &sha256hash{},    // SHA256
    common.HexToAddress("0x03"): &ripemd160hash{}, // RIPEMD160
    common.HexToAddress("0x09"): &blake2F{},       // Blake2
    // 自定义：跨链验证
    common.HexToAddress("0x20"): &crossChainVerifier{},
}

P2P 網絡層

P2P 網絡是區塊鏈的通信基礎，負責節點發現、區塊廣播、交易傳播和狀態同步。

節點發現協議（Kademlia DHT）

// p2p/discovery.go - 节点发现
type DiscoveryProtocol struct {
    table    *KademliaTable
    udpConn  *net.UDPConn
    bootNodes []*Node
}

func (d *DiscoveryProtocol) FindNeighbors(target NodeID) []*Node {
    closest := d.table.FindClosest(target, 16)
    var results []*Node

    for _, node := range closest {
        // 发送 FindNode 请求
        resp, err := d.sendFindNode(node, target)
        if err != nil { continue }
        results = append(results, resp.Nodes...)
    }

    // 更新路由表
    for _, n := range results {
        d.table.AddNode(n)
    }
    return d.table.FindClosest(target, 16)
}

// 区块广播
func (srv *Server) BroadcastBlock(block *Block) {
    peers := srv.GetPeers()
    // 对 sqrt(N) 个节点发送完整区块
    fullBroadcast := int(math.Sqrt(float64(len(peers))))
    for i, peer := range peers {
        if i < fullBroadcast {
            peer.SendBlock(block)
        } else {
            // 其余节点仅发送区块哈希
            peer.SendBlockHash(block.Hash())
        }
    }
}

區塊瀏覽器概述

區塊瀏覽器（Block Explorer）是區塊鏈網絡的"搜索引擎"，為用戶提供鏈上數據的可視化查詢能力。它是每條公鏈/私鏈上線後必須配套的基礎設施。

核心功能

區塊瀏覽器系統架構

區塊瀏覽器源碼實現

區塊同步引擎

// indexer/sync_engine.go - 区块同步核心
type SyncEngine struct {
    rpcClient   *ethclient.Client
    db          *gorm.DB
    redis       *redis.Client
    currentHead uint64
    batchSize   int
}

func (s *SyncEngine) Start(ctx context.Context) error {
    // 获取已索引的最新高度
    s.currentHead = s.db.GetLatestBlockNumber()
    log.Info("Starting sync from block", "number", s.currentHead)

    for {
        select {
        case <-ctx.Done():
            return nil
        default:
            chainHead, _ := s.rpcClient.BlockNumber(ctx)
            if s.currentHead >= chainHead {
                // 已追上最新区块，切换为实时模式
                s.subscribeNewBlocks(ctx)
                continue
            }
            // 批量同步历史区块
            s.syncBatch(ctx, s.currentHead+1, min(s.currentHead+uint64(s.batchSize), chainHead))
        }
    }
}

func (s *SyncEngine) syncBatch(ctx context.Context, from, to uint64) {
    var wg sync.WaitGroup
    blocks := make([]*BlockData, to-from+1)

    for i := from; i <= to; i++ {
        wg.Add(1)
        go func(num uint64) {
            defer wg.Done()
            block, _ := s.rpcClient.BlockByNumber(ctx, big.NewInt(int64(num)))
            receipts, _ := s.rpcClient.BatchGetReceipts(ctx, block.Transactions())
            blocks[num-from] = &BlockData{Block: block, Receipts: receipts}
        }(i)
    }
    wg.Wait()

    // 批量写入数据库
    s.db.BatchInsertBlocks(blocks)
    s.currentHead = to
}

交易解析器

// indexer/tx_parser.go - 交易解析与分类
type TxParser struct {
    abiRegistry map[common.Address]*abi.ABI
}

func (p *TxParser) ParseTransaction(tx *types.Transaction, receipt *types.Receipt) *ParsedTx {
    result := &ParsedTx{
        Hash:      tx.Hash(),
        From:      getSender(tx),
        To:        tx.To(),
        Value:     tx.Value(),
        GasUsed:   receipt.GasUsed,
        Status:    receipt.Status == 1,
        Timestamp: time.Now(),
    }

    // 识别交易类型
    if tx.To() == nil {
        result.Type = "contract_creation"
        result.ContractAddress = receipt.ContractAddress
    } else if len(tx.Data()) >= 4 {
        result.Type = "contract_call"
        methodID := tx.Data()[:4]
        // 解码合约方法
        if abi, ok := p.abiRegistry[*tx.To()]; ok {
            method, _ := abi.MethodById(methodID)
            result.MethodName = method.Name
            result.DecodedInput, _ = method.Inputs.Unpack(tx.Data()[4:])
        }
    } else {
        result.Type = "transfer"
    }

    // 解析事件日志
    for _, log := range receipt.Logs {
        event := p.decodeEvent(log)
        result.Events = append(result.Events, event)
    }
    return result
}

前端數據展示（React 組件）

// components/BlockList.tsx - 实时区块列表
export function BlockList() {
  const [blocks, setBlocks] = useState<Block[]>([]);

  useEffect(() => {
    // WebSocket 实时推送新区块
    const ws = new WebSocket('wss://explorer-api.example.com/ws');
    ws.onmessage = (event) => {
      const newBlock = JSON.parse(event.data);
      setBlocks(prev => [newBlock, ...prev.slice(0, 19)]);
    };
    return () => ws.close();
  }, []);

  return (
    <div className="block-list">
      {blocks.map(block => (
        <div key={block.number} className="block-card">
          <span className="block-number">#{block.number}</span>
          <span className="block-txs">{block.txCount} txs</span>
          <span className="block-time">{timeAgo(block.timestamp)}</span>
          <span className="block-validator">{shortAddr(block.validator)}</span>
        </div>
      ))}
    </div>
  );
}

RPC 接口設計

RPC（Remote Procedure Call）接口是外部應用與區塊鏈節點交互的橋樑。標準 JSON-RPC 2.0 協議是行業通用方案。

核心 RPC 方法

自定義擴展 RPC

// rpc/custom_api.go - 自定义浏览器专用 RPC
type ExplorerAPI struct {
    db    *gorm.DB
    cache *redis.Client
}

// 获取地址完整画像
func (api *ExplorerAPI) GetAddressProfile(address common.Address) (*AddressProfile, error) {
    profile := &AddressProfile{
        Address:     address,
        Balance:     api.getBalance(address),
        TxCount:     api.db.CountTransactions(address),
        TokenHoldings: api.getTokenBalances(address),
        IsContract:  api.isContract(address),
    }
    if profile.IsContract {
        profile.ContractInfo = api.getContractMeta(address)
        profile.Creator = api.getContractCreator(address)
    }
    return profile, nil
}

// 获取网络实时统计
func (api *ExplorerAPI) GetNetworkStats() *NetworkStats {
    return &NetworkStats{
        TPS:            api.cache.Get("current_tps"),
        ActiveAddresses: api.cache.Get("daily_active_addresses"),
        TotalTx:        api.db.CountAllTransactions(),
        GasPrice:       api.getAvgGasPrice(),
        ValidatorCount: api.getActiveValidators(),
    }
}

部署與運維

節點部署架構

• 全節點（Full Node）：存儲完整區塊鏈數據，驗證所有交易和區塊，參與 P2P 網絡
• 歸檔節點（Archive Node）：保留所有歷史狀態，支持任意區塊高度的狀態查詢，瀏覽器必備
• 輕節點（Light Node）：僅存儲區塊頭，通過 Merkle Proof 驗證數據，適合移動端錢包
• 驗證者節點（Validator）：參與共識出塊，需要高可用和安全保障

運維監控要點

推薦技術棧

開發流程

基於 NovaLinkR 團隊的公鏈與瀏覽器項目交付經驗，完整開發流程如下：