퍼블릭 체인/프라이크체인 + 블록 탐색기 개발 소스 코드 완전 분석

공공/비공개 체인이란 무엇인가요?

퍼블릭 블록체인비트코인, 이더리움, 솔라나, 아발란치 등 다양한 프로젝트를 대표하는 완전 개방형 블록체인 네트워크로, 누구나 노드 운영, 거래 제출, 데이터 검증에 참여할 수 있습니다. 핵심 기능은 허가 없이, 분산되어 있으며 검열에 저항한다는 점입니다.

프라이크 블록체인이는 허가된 블록체인 네트워크이며, 노드의 접속 및 종료는 관리자가 제어하여 내부 데이터 공유, 공급망 추적성, 금융 청산 및 결제 등 다양한 상황에 적합합니다. 대표적인 프레임워크로는 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(이더리움 가상 머신)은 가장 주류적인 구현체로, 거의 모든 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를 통해 데이터를 검증하세요
• 검증기 노드: 합의 블록 생산에 참여하려면 높은 가용성과 보안이 필요합니다

운영 및 관리 모니터링 지점

추천 기술 스택

개발 과정

NovaLinkR 팀의 퍼블릭 체인 및 브라우저 프로젝트 경험을 바탕으로 전체 개발 과정은 다음과 같습니다: