パブリックチェーン/プライベートチェーン+ブロックエクスプローラー開発のソースコードの完全な分析

パブリックチェーン/プライベートチェーンとは何ですか?

パブリックブロックチェーンこれは完全にオープンなブロックチェーンネットワークであり、誰でもノードの運用、取引の提出、データ検証に参加でき、ビットコイン、イーサリアム、ソラナ、アバランチなどのプロジェクトを代表しています。 その中核的な特徴は、許可不要で分散型で検閲に強いことです。

プライベートブロックチェーンこれは許可されたブロックチェーンネットワークであり、ノードの結合・退出はマネージャーによって制御されるため、内部データ共有、サプライチェーンのトレーサビリティ、金融のクリアリングや決済などのシナリオに適しています。 代表的なフレームワークには、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
}

チェーンアーキテクチャ設計

完全なブロックチェーンは、下から上へ次の技術的レベルに分けることができます。

ノード開発コアモジュール

ブロックチェーンノードはネットワークの基本的な構成要素であり、取引の受領、ブロックの検証、状態の維持、合意への参加を担います。 以下はnode coreモジュールのソースコード構造です:

ブロックおよびトランザクションデータ構造

// 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仮想マシン)は最も一般的な実装であり、ほぼすべてのEVM互換チェーンが同じバイトコード仕様に基づいています。

EVM実行モデル

• スタックアーキテクチャ:最大オペランドスタック深度は1024、要素あたり256ビット(32バイト)
• 決定論的実行: 同じ入力が同じ出力を生み出しなければ、ネットワーク全体の同じ状態が保証されます
• ガス機構:各命令は無限ループやリソース乱用を防ぐために一定のガスを消費します
• 状態隔離: 各契約は独立したストレージ空間を持ち、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())
        }
    }
}

ブロックエクスプローラーの概要

ブロックエクスプローラーブロックチェーンネットワークの「検索エンジン」として、オンチェーンデータの視覚的なクエリ機能を提供します。 それは、ローンチ後、すべてのパブリック/プライベートチェーンがサポートしなければならないインフラです。

コア機能:

ブロックエクスプローラーシステムアーキテクチャ

ブロックエクスプローラーのソースコード実装

ブロック同期エンジン

// 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(リモートプロシージャコール)インターフェースは、外部アプリケーションがブロックチェーンノードとやり取りするための橋渡しとして機能します。 標準の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(),
    }
}

展開と作戦

ノード展開アーキテクチャ

• フルノード完全なブロックチェーンデータを保存し、すべての取引とブロックを検証し、P2Pネットワークに参加しています
• アーカイブノード: すべての履歴状態を保持し、任意のブロック高さでのステータスクエリをサポートし、ブラウザにとって必須の機能です
• ライトノード: ブロックヘッダーのみを保存し、Merkle Proofでデータを検証し、モバイルウォレットに適しています
• バリデータノード: コンセンサスブロックの生産に参加するには高い可用性とセキュリティが必要です

O&M監視ポイント

推奨技術スタック

開発プロセス

NovaLinkRチームのパブリックチェーンおよびブラウザプロジェクト提供の経験に基づき、開発プロセスの全体像は以下の通りです。