add header & block fields for Withdrawals

cmd/evm/internal/t8ntool/block.go

@@ -38,23 +38,24 @@ import (
 
 //go:generate go run github.com/fjl/gencodec -type header -field-override headerMarshaling -out gen_header.go
 type header struct {
- ParentHash common.Hash `json:"parentHash"`
- OmmerHash *common.Hash `json:"sha3Uncles"`
- Coinbase *common.Address `json:"miner"`
- Root common.Hash `json:"stateRoot" gencodec:"required"`
- TxHash *common.Hash `json:"transactionsRoot"`
- ReceiptHash *common.Hash `json:"receiptsRoot"`
- Bloom types.Bloom `json:"logsBloom"`
- Difficulty *big.Int `json:"difficulty"`
- Number *big.Int `json:"number" gencodec:"required"`
- GasLimit uint64 `json:"gasLimit" gencodec:"required"`
- GasUsed uint64 `json:"gasUsed"`
- Time uint64 `json:"timestamp" gencodec:"required"`
- Extra []byte `json:"extraData"`
- MixDigest common.Hash `json:"mixHash"`
- Nonce *types.BlockNonce `json:"nonce"`
- BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`
- ExcessDataGas *big.Int `json:"excessDataGas" rlp:"optional"`
+ ParentHash common.Hash `json:"parentHash"`
+ OmmerHash *common.Hash `json:"sha3Uncles"`
+ Coinbase *common.Address `json:"miner"`
+ Root common.Hash `json:"stateRoot" gencodec:"required"`
+ TxHash *common.Hash `json:"transactionsRoot"`
+ ReceiptHash *common.Hash `json:"receiptsRoot"`
+ Bloom types.Bloom `json:"logsBloom"`
+ Difficulty *big.Int `json:"difficulty"`
+ Number *big.Int `json:"number" gencodec:"required"`
+ GasLimit uint64 `json:"gasLimit" gencodec:"required"`
+ GasUsed uint64 `json:"gasUsed"`
+ Time uint64 `json:"timestamp" gencodec:"required"`
+ Extra []byte `json:"extraData"`
+ MixDigest common.Hash `json:"mixHash"`
+ Nonce *types.BlockNonce `json:"nonce"`
+ BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`
+ WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"`
+ ExcessDataGas *big.Int `json:"excessDataGas" rlp:"optional"`
 }
 
 type headerMarshaling struct {
@@ -68,10 +69,11 @@ type headerMarshaling struct {
 }
 
 type bbInput struct {
- Header *header `json:"header,omitempty"`
- OmmersRlp []string `json:"ommers,omitempty"`
- TxRlp string `json:"txs,omitempty"`
- Clique *cliqueInput `json:"clique,omitempty"`
+ Header *header `json:"header,omitempty"`
+ OmmersRlp []string `json:"ommers,omitempty"`
+ TxRlp string `json:"txs,omitempty"`
+ Withdrawals []*types.Withdrawal `json:"withdrawals,omitempty"`
+ Clique *cliqueInput `json:"clique,omitempty"`
 
  Ethash bool `json:"-"`
  EthashDir string `json:"-"`
@@ -115,22 +117,23 @@ func (c *cliqueInput) UnmarshalJSON(input []byte) error {
 // ToBlock converts i into a *types.Block
 func (i *bbInput) ToBlock() *types.Block {
  header := &types.Header{
- ParentHash: i.Header.ParentHash,
- UncleHash: types.EmptyUncleHash,
- Coinbase: common.Address{},
- Root: i.Header.Root,
- TxHash: types.EmptyRootHash,
- ReceiptHash: types.EmptyRootHash,
- Bloom: i.Header.Bloom,
- Difficulty: common.Big0,
- Number: i.Header.Number,
- GasLimit: i.Header.GasLimit,
- GasUsed: i.Header.GasUsed,
- Time: i.Header.Time,
- Extra: i.Header.Extra,
- MixDigest: i.Header.MixDigest,
- BaseFee: i.Header.BaseFee,
- ExcessDataGas: i.Header.ExcessDataGas,
+ ParentHash: i.Header.ParentHash,
+ UncleHash: types.EmptyUncleHash,
+ Coinbase: common.Address{},
+ Root: i.Header.Root,
+ TxHash: types.EmptyRootHash,
+ ReceiptHash: types.EmptyRootHash,
+ Bloom: i.Header.Bloom,
+ Difficulty: common.Big0,
+ Number: i.Header.Number,
+ GasLimit: i.Header.GasLimit,
+ GasUsed: i.Header.GasUsed,
+ Time: i.Header.Time,
+ Extra: i.Header.Extra,
+ MixDigest: i.Header.MixDigest,
+ BaseFee: i.Header.BaseFee,
+ WithdrawalsHash: i.Header.WithdrawalsHash,
+ ExcessDataGas: i.Header.ExcessDataGas,
  }
 
  // Fill optional values.

core/types/block.go

@@ -20,6 +20,7 @@ package types
 import (
  "bytes"
  "encoding/binary"
+ "errors"
  "fmt"
  "io"
  "math/big"
@@ -88,6 +89,9 @@ type Header struct {
  // BaseFee was added by EIP-1559 and is ignored in legacy headers.
  BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`
 
+ // WithdrawalsHash was added by EIP-4895 and is ignored in legacy headers.
+ WithdrawalsHash *common.Hash `json:"withdrawalsRoot" rlp:"optional"`
+
  // ExcessDataGas was added by EIP-4844 and is ignored in legacy headers.
  ExcessDataGas *big.Int `json:"excessDataGas" rlp:"optional"`
 
@@ -117,6 +121,10 @@ func (h *Header) SetExcessDataGas(v *big.Int) {
  if v != nil {
  h.ExcessDataGas.Set(v)
  }
+ if h.WithdrawalsHash == nil {
+ // leaving this nil would result in a buggy encoding
+ h.WithdrawalsHash = &EmptyRootHash
+ }
 }
 
 // Hash returns the block hash of the header, which is simply the keccak256 hash of its
@@ -184,6 +192,7 @@ type Block struct {
  header *Header
  uncles []*Header
  transactions Transactions
+ withdrawals []*Withdrawal
 
  // caches
  hash atomic.Value
@@ -271,9 +280,10 @@ func (txs *extBlockTxs) EncodeRLP(w io.Writer) error {
 
 // "external" block encoding. used for eth protocol, etc.
 type extblock struct {
- Header *Header
- Txs *extBlockTxs
- Uncles []*Header
+ Header *Header
+ Txs *extBlockTxs
+ Uncles []*Header
+ Withdrawals []*Withdrawal `rlp:"optional"`
 }
 
 // NewBlock creates a new block. The input data is copied,
@@ -315,6 +325,31 @@ func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*
  return b
 }
 
+// NewBlock2 creates a new block with withdrawals. The input data
+// is copied, changes to header and to the field values will not
+// affect the block.
+//
+// The values of TxHash, UncleHash, ReceiptHash and Bloom in header
+// are ignored and set to values derived from the given txs, uncles
+// and receipts.
+func NewBlock2(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, withdrawals []*Withdrawal, hasher TrieHasher) *Block {
+ b := NewBlock(header, txs, uncles, receipts, hasher)
+ if withdrawals == nil {
+ return b
+ }
+
+ b.withdrawals = make([]*Withdrawal, len(withdrawals))
+ copy(b.withdrawals, withdrawals)
+
+ if len(withdrawals) == 0 {
+ b.header.WithdrawalsHash = &EmptyRootHash
+ } else {
+ h := DeriveSha(Withdrawals(withdrawals), hasher)
+ b.header.WithdrawalsHash = &h
+ }
+ return b
+}
+
 // NewBlockWithHeader creates a block with the given header data. The
 // header data is copied, changes to header and to the field values
 // will not affect the block.
@@ -342,6 +377,10 @@ func CopyHeader(h *Header) *Header {
  cpy.Extra = make([]byte, len(h.Extra))
  copy(cpy.Extra, h.Extra)
  }
+ if h.WithdrawalsHash != nil {
+ cpy.WithdrawalsHash = new(common.Hash)
+ cpy.WithdrawalsHash.SetBytes(h.WithdrawalsHash.Bytes())
+ }
  return &cpy
 }
 
@@ -357,17 +396,24 @@ func (b *Block) DecodeRLP(s *rlp.Stream) error {
  return fmt.Errorf("transactions in blocks must not contain wrap-data, tx %d is bad", i)
  }
  }
- b.header, b.uncles, b.transactions = eb.Header, eb.Uncles, []*Transaction(*eb.Txs)
+ b.header, b.uncles, b.transactions, b.withdrawals = eb.Header, eb.Uncles, []*Transaction(*eb.Txs), eb.Withdrawals
  b.size.Store(rlp.ListSize(size))
  return nil
 }
 
 // EncodeRLP serializes b into the Ethereum RLP block format.
 func (b *Block) EncodeRLP(w io.Writer) error {
+ if b.header.ExcessDataGas != nil && b.header.WithdrawalsHash == nil {
+ // This situation should not arise, but if it does (due to a bug) you'd silently produce an
+ // encoding that would fail to decode. ref:
+ // https://github.com/ethereum/go-ethereum/pull/26077
+ return errors.New("nil WithdrawalsHash in header with non-nil ExcessDataGas")
+ }
  return rlp.Encode(w, extblock{
- Header: b.header,
- Txs: (*extBlockTxs)(&b.transactions),
- Uncles: b.uncles,
+ Header: b.header,
+ Txs: (*extBlockTxs)(&b.transactions),
+ Uncles: b.uncles,
+ Withdrawals: b.withdrawals,
  })
 }
 
@@ -410,6 +456,19 @@ func (b *Block) BaseFee() *big.Int {
  return new(big.Int).Set(b.header.BaseFee)
 }
 
+func (b *Block) WithdrawalsHash() *common.Hash {
+ if b.header.WithdrawalsHash == nil {
+ return nil
+ }
+ var h common.Hash
+ h.SetBytes(b.header.WithdrawalsHash.Bytes())
+ return &h
+}
+
+func (b *Block) Withdrawals() Withdrawals {
+ return b.withdrawals
+}
+
 func (b *Block) ExcessDataGas() *big.Int {
  if b.header.ExcessDataGas == nil {
  return nil
@@ -463,6 +522,7 @@ func (b *Block) WithSeal(header *Header) *Block {
  header: &cpy,
  transactions: b.transactions,
  uncles: b.uncles,
+ withdrawals: b.withdrawals,
  }
 }
 
@@ -480,6 +540,18 @@ func (b *Block) WithBody(transactions []*Transaction, uncles []*Header) *Block {
  return block
 }
 
+// WithBody2 returns a new block with the given transaction, uncle, and
+// withdrawal contents.
+func (b *Block) WithBody2(transactions []*Transaction, uncles []*Header, withdrawals []*Withdrawal) *Block {
+ block := b.WithBody(transactions, uncles)
+ if withdrawals == nil {
+ return block
+ }
+ block.withdrawals = make([]*Withdrawal, len(withdrawals))
+ copy(block.withdrawals, withdrawals)
+ return block
+}
+
 // Hash returns the keccak256 hash of b's header.
 // The hash is computed on the first call and cached thereafter.
 func (b *Block) Hash() common.Hash {