以太坊作为全球第二大公链,其共识机制从工作量证明（PoW）向权益证明（PoS）的过渡虽已启动，但PoW阶段形成的挖矿逻辑仍是理解区块链共识机制的重要基础，本文将以以太坊PoW时代的核心挖矿流程为切入点，结合关键源码片段，解析从交易收集、区块构建、哈希计算到区块确认的全过程，帮助读者深入理解以太坊挖矿的技术本质。

以太坊挖矿的核心目标与前提

挖矿是以太坊PoW阶段的核心共识机制,其目标是让矿工通过计算竞争，将新的交易打包成区块并添加到区块链中，同时获得区块奖励和交易手续费作为激励，要参与挖矿，需满足两个前提条件：

  1. 节点同步：矿工节点需完成全链数据同步，确保拥有最新的区块链状态（包括最新区块头、交易列表、账户状态等）。
  2. 算力准备：矿工需配备高性能GPU（因以太坊挖矿依赖Ethash算法，对内存带宽要求较高），并运行挖矿软件（如Ethminer、Claymore等）与以太坊客户端（如Geth、OpenEthereum）的交互。

挖矿流程全流程解析：从交易到区块

以太坊挖矿流程可拆解为六个核心步骤：交易收集与验证、区块构建、哈希计算（挖矿竞争）、区块广播、共识验证、区块确认与奖励结算，以下结合以太坊核心客户端Geth的源码（以v1.10.x版本为例），逐步解析各环节的实现逻辑。

1 交易收集与验证：待打包交易池管理

挖矿的第一步是从本地交易池（Mempool）中筛选有效交易，以太坊节点会接收网络上广播的交易，并存储在待处理交易池中，矿工需从中选取优先级高（手续费高）且状态有效的交易进行打包。

源码解析：交易池筛选逻辑（Geth core/tx_list.go）

// txList represents a sorted list of transactions and implements heap.Interface.
type txList struct {
    // 其他字段...
    items map[common.Hash]*types.Transaction // 交易哈希到交易的映射
    // ...
}
// Peek returns the next transaction by nonce.
func (l *txList) Peek() *types.Transaction {
    if l.Len() == 0 {
        return nil
    }
    return l.txs[l.txs[0]] // 按nonce排序后，取下一个nonce的交易
}
// Underlying returns all transactions contained in the list.
func (l *txList) Underlying() []*types.Transaction {
    txs := make([]*types.Transaction, 0, len(l.items))
    for _, tx := range l.items {
        txs = append(txs, tx)
    }
    return txs
}

矿工通过txList结构管理交易池，交易按nonce（发送方交易序号）排序，确保打包顺序的正确性，Geth还会通过core/tx_pool.go中的validateTx函数对交易进行验证，包括：

  • 签名有效性（检查签名是否匹配发送方地址）；
  • Nonce连续性（当前交易的nonce需等于发送方账户的最新nonce）；
  • 手续费合理性（GasPrice需满足矿工设置的最低阈值）；
  • 余额充足性（发送方账户余额需覆盖交易价值 手续费）。

2 区块构建：组装候选区块

交易筛选完成后,矿工需将这些交易与当前区块链状态组装成候选区块（Candidate Block），以太坊区块结构定义在types/block.go中，包含以下关键字段：

type Block struct {
    Header       Header     // 区块头（核心共识数据）
    Transactions []*Transaction // 交易列表
    Uncles       []*Header  // 叔块（叔块奖励机制）
    // ...
}
type Header struct {
    ParentHash  common.Hash // 父区块哈希
    Number      *big.Int    // 区块高度
    Time        uint64      // 时间戳
    Difficulty  *big.Int    // 区块难度（动态调整）
    MixHash     common.Hash // Ethash算法的mix哈希
    Nonce       uint64      // 随机数（挖矿目标值）
    // 其他字段：Coinbase（矿工地址）、Root（状态根）、Extra（额外数据）等
}

源码解析：候选区块构建（Geth miner/worker.go）

func (w *worker) newWork() *work {
    // 1. 获取最新区块头作为父区块
    parent := w.currentBlock
    header := &types.Header{
        ParentHash: parent.Hash(),
        Number:     new(big.Int).Add(parent.Number, common.Big1),
        Time:       uint64(time.Now().Unix()),
        // 其他字段初始化...
    }
    // 2. 从交易池中选取交易，计算GasLimit和状态根
    txs := w.txs.GetTransactions() // 获取交易池中的交易
    block := types.NewBlock(header, txs, nil, nil)
    // 3. 计算状态根（Merkle Patricia Trie根）
    statedb, err := w.eth.BlockChain().StateAt(parent.Root(), nil)
    if err != nil {
        log.Error("Failed to get state", "err", err)
        return nil
    }
    for _, tx := range txs {
        // 执行交易，更新状态
        if _, err := statedb.ProcessTx(w.eth.BlockChain().Config(), tx, w.eth.BlockChain().GetVMConfig()); err != nil {
            log.Error("Failed to process tx", "err", err)
            continue
        }
    }
    header.Root = statedb.IntermediateRoot(false) // 更新状态根
    return &work{
        header:    header,
        txs:       txs,
        createdAt: time.Now(),
    }
}

newWork函数是候选区块构建的核心，主要完成三件事：

  • 初始化区块头：以最新区块为父区块，设置高度、时间戳等基础字段；
  • 选取交易：从交易池中获取有效交易，计算区块的GasLimit（需满足当前区块GasLimit上限，如1500万）；
  • 计算状态根：通过执行交易更新状态树，生成最新的状态根（header.Root），确保区块状态的有效性。

3 哈希计算与挖矿竞争：Ethash算法与Nonce碰撞

区块构建完成后,矿工的核心任务是找到满足“难度目标”的Nonce值，以太坊使用Ethash算法（一种改良的DAG算法），其核心是通过两个数据集（全数据集DAG和缓存数据集Cache）生成区块头的哈希，并寻找Nonce使得哈希值小于当前难度的目标值。

Ethash算法逻辑（Geth consensus/ethash/ethash.go）

// Hashimoto aggregates data from full dataset to compute the final hash.
func Hashimoto(hash, nonce []byte, fullSize uint64, cache []uint64, lookup func([]byte) []uint32) ([]byte, []byte) {
    // 1. 计算DAG的迭代次数
    mixHash := make([]byte, 64)
    digest := make([]byte, 32)
    // 2. 生成初始mix
    mix := new(big.Int).SetBytes(hash)
    for i := 0; i < 32; i   {
        mix.Add(mix, big.NewInt(int64(nonce[i%8])))
    }
    // 3. 通过Cache和DAG计算mixHash
    for i := uint64(0); i < datasetParents(fullSize); i   {
        parent := mixHashimotoFull(fullSize, cache, mix.Uint64()%fullSize, lookup)
        mix.Add(mix, new(big.Int).SetBytes(parent))
    }
    // 4. 计算最终哈希
    digest = crypto.Keccak256(mix.Bytes(), nonce)
    mixHash = crypto.Keccak256(mix.Bytes())
    return digest, mixHash
}
// VerifyHash verifies if a nonce satisfies the difficulty requirement.
func VerifyHash(header *types.Header) bool {
    target := new(big.Int).Div(two256, header.Difficulty)
    hash := crypto.Keccak256(
        header.ParentHash[:],
        header.UncleHash[:],
        header.Coinbase[:],
        header.Root[:],
        header.TxHash[:],
        header.ReceiptHash[:],
        header.Bloom.Bytes(),
        header.Number.Bytes(),
        header.GasLimit.Bytes(),
        header.GasUsed.Bytes(),
        header.Time.Bytes(),
        header.Extra,
        header.MixHash[:],
        common.Uint64ToBytes(header.Nonce),
    )
    return new(big.Int).SetBytes(hash).Cmp(target) <= 0
}

挖矿过程本质是暴力破解Nonce：矿工不断尝试不同的Nonce值，调用Hashimoto函数计算区块头的哈