What is an Ethereum block? Please explain block structure, Merkle trees, and block generation process - 面试题

Ethereum blocks are basic data units of Ethereum blockchain, containing transactions, state roots, and other important information. Here's a detailed analysis of Ethereum blocks:

Basic Block Structure

1. Block Header

Block header contains metadata information of the block:

javascript
{
  parentHash: "0x...",           // Hash of parent block
  sha3Uncles: "0x...",           // Hash of uncle blocks
  miner: "0x...",                 // Miner/validator address
  stateRoot: "0x...",            // Root hash of state tree
  transactionsRoot: "0x...",      // Root hash of transaction tree
  receiptsRoot: "0x...",          // Root hash of receipt tree
  logsBloom: "0x...",            // Bloom filter for fast log queries
  difficulty: "0x...",            // Difficulty value (PoW)
  number: 12345678,               // Block number
  gasLimit: 30000000,             // Gas limit
  gasUsed: 15000000,              // Gas used
  timestamp: 1234567890,          // Timestamp
  extraData: "0x...",             // Extra data
  mixHash: "0x...",              // PoW mix hash
  nonce: "0x..."                 // PoW nonce
}

2. Block Body

Block body contains actual list of transactions:

javascript
{
  transactions: [
    {
      hash: "0x...",
      from: "0x...",
      to: "0x...",
      value: "0x...",
      gas: 21000,
      gasPrice: "0x...",
      input: "0x...",
      nonce: 5
    }
    // ... more transactions
  ]
}

Merkle Tree Structure

1. State Trie

Stores state information of all accounts.

shell
State Root
├── Account 1 (balance, nonce, codeHash, storageRoot)
├── Account 2 (balance, nonce, codeHash, storageRoot)
└── Account 3 (balance, nonce, codeHash, storageRoot)

2. Transaction Trie

Stores all transactions in the block.

3. Receipt Trie

Stores execution receipts for each transaction.

javascript
// Transaction receipt example
{
  transactionHash: "0x...",
  transactionIndex: 0,
  blockHash: "0x...",
  blockNumber: 12345678,
  from: "0x...",
  to: "0x...",
  cumulativeGasUsed: 21000,
  gasUsed: 21000,
  contractAddress: null,
  logs: [
    {
      address: "0x...",
      topics: ["0x...", "0x..."],
      data: "0x...",
      blockNumber: 12345678,
      transactionHash: "0x...",
      transactionIndex: 0,
      blockHash: "0x...",
      logIndex: 0
    }
  ],
  status: 1  // 1 indicates success, 0 indicates failure
}

Block Generation Process

1. PoW Era (Before Merge)

javascript
// Miner mining process
async function mineBlock(blockNumber) {
  const transactions = await selectTransactions();
  const block = {
    number: blockNumber,
    transactions: transactions,
    parentHash: await getPreviousBlockHash(),
    timestamp: Date.now(),
    difficulty: calculateDifficulty()
  };
  
  // Find nonce that meets difficulty requirement
  let nonce = 0;
  while (true) {
    const hash = calculateBlockHash(block, nonce);
    if (hash < difficulty) {
      block.nonce = nonce;
      block.hash = hash;
      break;
    }
    nonce++;
  }
  
  return block;
}

2. PoS Era (After Merge)

javascript
// Validator proposes block
async function proposeBlock(validator) {
  const transactions = await selectTransactions();
  const block = {
    number: await getCurrentBlockNumber() + 1,
    transactions: transactions,
    parentHash: await getLatestBlockHash(),
    timestamp: Date.now(),
    proposer: validator.address
  };
  
  // Sign block
  const signature = await validator.sign(block);
  block.signature = signature;
  
  // Broadcast block
  await broadcastBlock(block);
  
  return block;
}

Block Validation

1. Basic Validation

javascript
function validateBlock(block) {
  // Validate block header
  if (!isValidParentHash(block.parentHash)) {
    throw new Error("Invalid parent hash");
  }
  
  // Validate timestamp
  if (block.timestamp > Date.now() + 15) {
    throw new Error("Invalid timestamp");
  }
  
  // Validate gas limit
  if (block.gasUsed > block.gasLimit) {
    throw new Error("Gas used exceeds limit");
  }
  
  // Validate transactions
  for (const tx of block.transactions) {
    validateTransaction(tx);
  }
  
  // Validate state root
  const calculatedStateRoot = calculateStateRoot(block);
  if (calculatedStateRoot !== block.stateRoot) {
    throw new Error("Invalid state root");
  }
  
  return true;
}

2. State Transition

javascript
async function applyBlock(block) {
  let state = await loadState(block.parentHash);
  
  // Execute all transactions
  for (const tx of block.transactions) {
    const result = await executeTransaction(tx, state);
    state = result.newState;
  }
  
  // Validate final state
  const finalStateRoot = calculateStateRoot(state);
  if (finalStateRoot !== block.stateRoot) {
    throw new Error("State root mismatch");
  }
  
  return state;
}

Uncle Blocks

1. Concept

Uncle blocks are valid blocks that were not included in the main chain due to network latency and other reasons.

2. Purpose

Improve network security
Reduce centralization risk
Give miners/validators partial rewards

3. Inclusion Rules

javascript
function canIncludeUncle(uncle, currentBlock) {
  // Uncle must be uncle or great-uncle of current block
  const depth = currentBlock.number - uncle.number;
  if (depth < 1 || depth > 6) {
    return false;
  }
  
  // Uncle cannot be ancestor of current block
  if (isAncestor(uncle, currentBlock)) {
    return false;
  }
  
  // Uncle cannot have been included before
  if (isAlreadyIncluded(uncle)) {
    return false;
  }
  
  return true;
}

Block Time

1. Block Time

PoW era: About 13-15 seconds
PoS era: About 12 seconds

2. Timestamp Validation

javascript
function validateTimestamp(block, parentBlock) {
  const minTime = parentBlock.timestamp;
  const maxTime = Date.now() + 15;
  
  return block.timestamp >= minTime && block.timestamp <= maxTime;
}

Block Size and Gas Limit

1. Gas Limit

Each block has a gas limit
Prevents blocks from being too large
Dynamic adjustment mechanism

2. Gas Usage

javascript
function calculateGasUsage(block) {
  let totalGas = 0;
  
  for (const tx of block.transactions) {
    totalGas += tx.gasUsed;
  }
  
  return totalGas;
}

Block Explorer

1. Query Block Information

javascript
// Query block using ethers.js
const block = await provider.getBlock(blockNumber);
console.log("Block number:", block.number);
console.log("Block hash:", block.hash);
console.log("Transactions:", block.transactions.length);
console.log("Gas used:", block.gasUsed.toString());
console.log("Timestamp:", new Date(block.timestamp * 1000));

2. Query Transactions in Block

javascript
// Get all transactions in block
const blockWithTransactions = await provider.getBlockWithTransactions(blockNumber);
for (const tx of blockWithTransactions.transactions) {
  console.log("Transaction hash:", tx.hash);
  console.log("From:", tx.from);
  console.log("To:", tx.to);
  console.log("Value:", ethers.utils.formatEther(tx.value));
}

Block Reorganization (Reorg)

1. Concept

When a longer chain is discovered, the network switches to the new chain. This process is called reorganization.

2. Handling Reorgs

javascript
async function handleReorg(newChain) {
  const commonAncestor = findCommonAncestor(currentChain, newChain);
  
  // Rollback to common ancestor
  for (let i = currentChain.length - 1; i > commonAncestor.index; i--) {
    await rollbackBlock(currentChain[i]);
  }
  
  // Apply new blocks
  for (let i = commonAncestor.index + 1; i < newChain.length; i++) {
    await applyBlock(newChain[i]);
  }
  
  currentChain = newChain;
}

Best Practices

Monitor Blocks: Monitor new blocks in real-time
Validate Data: Verify integrity of block data
Handle Reorgs: Properly handle blockchain reorganizations
Optimize Queries: Use caching to improve query efficiency
Error Handling: Properly handle block validation errors

Ethereum blocks are the foundation of blockchain technology. Understanding their structure and working principles is crucial for developing blockchain applications.