core: implement EIP-4788 BeaconRoot precompile

common/types.go

@@ -19,6 +19,7 @@ package common
 import (
 	"bytes"
 	"database/sql/driver"
+	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
@@ -65,6 +66,13 @@ func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
 // If b is larger than len(h), b will be cropped from the left.
 func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) }
 
+// Uint64ToHash sets the lowest 8 bytes of hash to u in big endian format.
+func Uint64ToHash(u uint64) Hash {
+	var h Hash
+	binary.BigEndian.PutUint64(h[24:], u)
+	return h
+}
+
 // Less compares two hashes.
 func (h Hash) Less(other Hash) bool {
 	return bytes.Compare(h[:], other[:]) < 0

consensus/misc/eip4788.go

@@ -0,0 +1,47 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package misc
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+// ApplyBeaconRoot adds the beacon root from the header to the state.
+func ApplyBeaconRoot(header *types.Header, state *state.StateDB) {
+	// If EIP-4788 is enabled, we need to store the block root
+	timeKey, time, rootKey, root := calcBeaconRootIndices(header)
+	state.SetState(params.BeaconRootsStorageAddress, timeKey, time)
+	state.SetState(params.BeaconRootsStorageAddress, rootKey, root)
+	// We also need to ensure that the BeaconRoot address has nonzero nonce.
+	if state.GetNonce(params.BeaconRootsStorageAddress) == 0 {
+		state.SetNonce(params.BeaconRootsStorageAddress, 1)
+	}
+}
+
+func calcBeaconRootIndices(header *types.Header) (timeKey, time, rootKey, root common.Hash) {
+	// timeKey -> header.Time
+	timeIndex := header.Time % params.HistoricalRootsModulus
+	timeKey = common.Uint64ToHash(timeIndex)
+	time = common.Uint64ToHash(header.Time)
+	// rootKey -> header.BeaconRoot
+	rootKey = common.Uint64ToHash(timeIndex + params.HistoricalRootsModulus)
+	root = *header.BeaconRoot
+	return
+}

consensus/misc/eip4788_test.go

@@ -0,0 +1,63 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package misc
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type tcInput struct {
+	HeaderTime       uint64
+	HeaderBeaconRoot common.Hash
+
+	TimeKey common.Hash
+	Time    common.Hash
+	RootKey common.Hash
+	Root    common.Hash
+}
+
+func TestCalcBeaconRootIndices(t *testing.T) {
+	data, err := os.ReadFile("./testdata/eip4788_beaconroot.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var tests []tcInput
+	if err := json.Unmarshal(data, &tests); err != nil {
+		t.Fatal(err)
+	}
+	for i, tc := range tests {
+		header := types.Header{Time: tc.HeaderTime, BeaconRoot: &tc.HeaderBeaconRoot}
+		haveTimeKey, haveTime, haveRootKey, haveRoot := calcBeaconRootIndices(&header)
+		if haveTimeKey != tc.TimeKey {
+			t.Errorf("test %d: invalid time key: \nhave %v\nwant %v", i, haveTimeKey, tc.TimeKey)
+		}
+		if haveTime != tc.Time {
+			t.Errorf("test %d: invalid time: \nhave %v\nwant %v", i, haveTime, tc.Time)
+		}
+		if haveRootKey != tc.RootKey {
+			t.Errorf("test %d: invalid root key: \nhave %v\nwant %v", i, haveRootKey, tc.RootKey)
+		}
+		if haveRoot != tc.Root {
+			t.Errorf("test %d: invalid root: \nhave %v\nwant %v", i, haveRoot, tc.Root)
+		}
+	}
+}

consensus/misc/testdata/eip4788_beaconroot.json

@@ -0,0 +1,26 @@
+[
+  {
+    "HeaderTime": 0,
+    "HeaderBeaconRoot": "0x0100000000000000000000000000000000000000000000000000000000000000",
+    "TimeKey": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "Time": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "RootKey": "0x0000000000000000000000000000000000000000000000000000000000018000",
+    "Root": "0x0100000000000000000000000000000000000000000000000000000000000000"
+  },
+  {
+    "HeaderTime": 120265298769267,
+    "HeaderBeaconRoot": "0xfffefc0000000000000000000000000000000000000000000000000000000000",
+    "TimeKey": "0x000000000000000000000000000000000000000000000000000000000000f573",
+    "Time": "0x00000000000000000000000000000000000000000000000000006d6172697573",
+    "RootKey": "0x0000000000000000000000000000000000000000000000000000000000027573",
+    "Root": "0xfffefc0000000000000000000000000000000000000000000000000000000000"
+  },
+  {
+    "HeaderTime": 18446744073709551615,
+    "HeaderBeaconRoot": "0xfffefcffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+    "TimeKey": "0x000000000000000000000000000000000000000000000000000000000000ffff",
+    "Time": "0x000000000000000000000000000000000000000000000000ffffffffffffffff",
+    "RootKey": "0x0000000000000000000000000000000000000000000000000000000000027fff",
+    "Root": "0xfffefcffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+  }
+]

core/state_processor.go

@@ -71,6 +71,15 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(statedb)
 	}
+	if p.config.IsCancun(blockNumber, block.Time()) {
+		if header.BeaconRoot == nil {
+			return nil, nil, 0, errors.New("expected beacon root post-cancun")
+		}
+		misc.ApplyBeaconRoot(header, statedb)
+	} else if header.BeaconRoot != nil {
+		return nil, nil, 0, errors.New("beacon root set pre-cancun")
+	}
+
 	var (
 		context = NewEVMBlockContext(header, p.bc, nil)
 		vmenv   = vm.NewEVM(context, vm.TxContext{}, statedb, p.config, cfg)

core/types/block.go

@@ -90,6 +90,9 @@ type Header struct {
 
 	// ExcessBlobGas was added by EIP-4844 and is ignored in legacy headers.
 	ExcessBlobGas *uint64 `json:"excessBlobGas" rlp:"optional"`
+
+	// BeaconRoot was added by EIP-4788 and is ignored in legacy headers.
+	BeaconRoot *common.Hash `json:"beaconRoot" rlp:"optional"`
 }
 
 // field type overrides for gencodec
@@ -378,6 +381,10 @@ func (b *Block) BlobGasUsed() *uint64 {
 	return blobGasUsed
 }
 
+func (b *Block) BeaconRoot() *common.Hash {
+	return b.header.BeaconRoot
+}
+
 func (b *Block) Header() *Header { return CopyHeader(b.header) }
 
 // Body returns the non-header content of the block.