Extend fork ID to timestamp-based forks (#6324)

Starting from
[Shanghai](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md),
forks are based on timestamps rather than block heights (see PR #6238).
This PR extends [EIP-2124](https://eips.ethereum.org/EIPS/eip-2124) Fork
ID to include timestamp-based blocks. See also
ethereum/go-ethereum#25878.

Co-authored-by: Marius van der Wijden <[email protected]>

Author: yperbasis

cmd/observer/observer/server.go

@@ -109,8 +109,8 @@ func makeForksENREntry(chain string) (enr.Entry, error) {
 		return nil, fmt.Errorf("unknown chain %s", chain)
 	}
 
-	forks := forkid.GatherForks(chainConfig)
-	return eth.CurrentENREntryFromForks(forks, *genesisHash, 0), nil
+	heightForks, timeForks := forkid.GatherForks(chainConfig)
+	return eth.CurrentENREntryFromForks(heightForks, timeForks, *genesisHash, 0, 0), nil
 }
 
 func (server *Server) Bootnodes() []*enode.Node {

cmd/rpcdaemon/commands/erigon_system.go

@@ -13,7 +13,8 @@ import (
 // Forks is a data type to record a list of forks passed by this node
 type Forks struct {
 	GenesisHash common.Hash `json:"genesis"`
-	Forks       []uint64    `json:"forks"`
+	HeightForks []uint64    `json:"heightForks"`
+	TimeForks   []uint64    `json:"timeForks"`
 }
 
 // Forks implements erigon_forks. Returns the genesis block hash and a sorted list of all forks block numbers
@@ -28,9 +29,9 @@ func (api *ErigonImpl) Forks(ctx context.Context) (Forks, error) {
 	if err != nil {
 		return Forks{}, err
 	}
-	forksBlocks := forkid.GatherForks(chainConfig)
+	heightForks, timeForks := forkid.GatherForks(chainConfig)
 
-	return Forks{genesis.Hash(), forksBlocks}, nil
+	return Forks{genesis.Hash(), heightForks, timeForks}, nil
 }
 
 // Post the merge eth_blockNumber will return latest forkChoiceHead block number

cmd/sentry/sentry/eth_handshake.go

@@ -71,13 +71,6 @@ func checkPeerStatusCompatibility(
 		return fmt.Errorf("genesis hash does not match: theirs %x, ours %x", reply.Genesis, genesisHash)
 	}
 
-	forks := make([]uint64, len(status.ForkData.Forks))
-	// copy because forkid.NewFilterFromForks will write into this slice
-	copy(forks, status.ForkData.Forks)
-	forkFilter := forkid.NewFilterFromForks(forks, genesisHash, status.MaxBlock)
-	if err := forkFilter(reply.ForkID); err != nil {
-		return err
-	}
-
-	return nil
+	forkFilter := forkid.NewFilterFromForks(status.ForkData.HeightForks, status.ForkData.TimeForks, genesisHash, status.MaxBlockHeight, status.MaxBlockTime)
+	return forkFilter(reply.ForkID)
 }

cmd/sentry/sentry/eth_handshake_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/ledgerwatch/erigon-lib/gointerfaces"
 	proto_sentry "github.com/ledgerwatch/erigon-lib/gointerfaces/sentry"
+	"github.com/stretchr/testify/assert"
+
 	"github.com/ledgerwatch/erigon/common"
 	"github.com/ledgerwatch/erigon/core/forkid"
 	"github.com/ledgerwatch/erigon/eth/protocols/eth"
 	"github.com/ledgerwatch/erigon/params"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckPeerStatusCompatibility(t *testing.T) {
@@ -23,17 +24,19 @@ func TestCheckPeerStatusCompatibility(t *testing.T) {
 		TD:              big.NewInt(0),
 		Head:            common.Hash{},
 		Genesis:         params.MainnetGenesisHash,
-		ForkID:          forkid.NewID(params.MainnetChainConfig, params.MainnetGenesisHash, 0),
+		ForkID:          forkid.NewID(params.MainnetChainConfig, params.MainnetGenesisHash, 0, 0),
 	}
+	heightForks, timeForks := forkid.GatherForks(params.MainnetChainConfig)
 	status := proto_sentry.StatusData{
 		NetworkId:       networkID,
 		TotalDifficulty: gointerfaces.ConvertUint256IntToH256(new(uint256.Int)),
 		BestHash:        nil,
 		ForkData: &proto_sentry.Forks{
-			Genesis: gointerfaces.ConvertHashToH256(params.MainnetGenesisHash),
-			Forks:   forkid.GatherForks(params.MainnetChainConfig),
+			Genesis:     gointerfaces.ConvertHashToH256(params.MainnetGenesisHash),
+			HeightForks: heightForks,
+			TimeForks:   timeForks,
 		},
-		MaxBlock: 0,
+		MaxBlockHeight: 0,
 	}
 
 	t.Run("ok", func(t *testing.T) {

cmd/sentry/sentry/sentry_api.go

@@ -18,10 +18,11 @@ import (
 
 // Methods of sentry called by Core
 
-func (cs *MultiClient) UpdateHead(ctx context.Context, height uint64, hash common.Hash, td *uint256.Int) {
+func (cs *MultiClient) UpdateHead(ctx context.Context, height, time uint64, hash common.Hash, td *uint256.Int) {
 	cs.lock.Lock()
 	defer cs.lock.Unlock()
 	cs.headHeight = height
+	cs.headTime = time
 	cs.headHash = hash
 	cs.headTd = td
 	statusMsg := cs.makeStatusData()

cmd/sentry/sentry/sentry_grpc_server.go

@@ -292,7 +292,7 @@ func handShake(
 			TD:              ourTD.ToBig(),
 			Head:            gointerfaces.ConvertH256ToHash(status.BestHash),
 			Genesis:         genesisHash,
-			ForkID:          forkid.NewIDFromForks(status.ForkData.Forks, genesisHash, status.MaxBlock),
+			ForkID:          forkid.NewIDFromForks(status.ForkData.HeightForks, status.ForkData.TimeForks, genesisHash, status.MaxBlockHeight, status.MaxBlockTime),
 		}
 		errc <- p2p.Send(rw, eth.StatusMsg, s)
 	}()
@@ -957,8 +957,8 @@ func (ss *GrpcServer) SetStatus(ctx context.Context, statusData *proto_sentry.St
 		ss.P2pServer = srv
 	}
 
-	ss.P2pServer.LocalNode().Set(eth.CurrentENREntryFromForks(statusData.ForkData.Forks, genesisHash, statusData.MaxBlock))
-	if ss.statusData == nil || statusData.MaxBlock != 0 {
+	ss.P2pServer.LocalNode().Set(eth.CurrentENREntryFromForks(statusData.ForkData.HeightForks, statusData.ForkData.TimeForks, genesisHash, statusData.MaxBlockHeight, statusData.MaxBlockTime))
+	if ss.statusData == nil || statusData.MaxBlockHeight != 0 {
 		// Not overwrite statusData if the message contains zero MaxBlock (comes from standalone transaction pool)
 		ss.statusData = statusData
 	}

cmd/sentry/sentry/sentry_grpc_server_test.go

@@ -11,14 +11,15 @@ import (
 	proto_sentry "github.com/ledgerwatch/erigon-lib/gointerfaces/sentry"
 	"github.com/ledgerwatch/erigon-lib/kv"
 	"github.com/ledgerwatch/erigon-lib/kv/memdb"
+	"github.com/stretchr/testify/require"
+
 	"github.com/ledgerwatch/erigon/common"
 	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/forkid"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/eth/protocols/eth"
 	"github.com/ledgerwatch/erigon/p2p"
 	"github.com/ledgerwatch/erigon/params"
-	"github.com/stretchr/testify/require"
 )
 
 func testSentryServer(db kv.Getter, genesis *core.Genesis, genesisHash common.Hash) *GrpcServer {
@@ -34,14 +35,17 @@ func testSentryServer(db kv.Getter, genesis *core.Genesis, genesisHash common.Ha
 
 	headTd256 := new(uint256.Int)
 	headTd256.SetFromBig(headTd)
+	heightForks, timeForks := forkid.GatherForks(genesis.Config)
 	s.statusData = &proto_sentry.StatusData{
 		NetworkId:       1,
 		TotalDifficulty: gointerfaces.ConvertUint256IntToH256(headTd256),
 		BestHash:        gointerfaces.ConvertHashToH256(head.Hash()),
-		MaxBlock:        head.Number.Uint64(),
+		MaxBlockHeight:  head.Number.Uint64(),
+		MaxBlockTime:    head.Time,
 		ForkData: &proto_sentry.Forks{
-			Genesis: gointerfaces.ConvertHashToH256(genesisHash),
-			Forks:   forkid.GatherForks(genesis.Config),
+			Genesis:     gointerfaces.ConvertHashToH256(genesisHash),
+			HeightForks: heightForks,
+			TimeForks:   timeForks,
 		},
 	}
 	return s
@@ -107,8 +111,8 @@ func testForkIDSplit(t *testing.T, protocol uint) {
 	}
 
 	// Progress into Homestead. Fork's match, so we don't care what the future holds
-	s1.statusData.MaxBlock = 1
-	s2.statusData.MaxBlock = 1
+	s1.statusData.MaxBlockHeight = 1
+	s2.statusData.MaxBlockHeight = 1
 
 	go func() { errc <- handShake(ctx, s1.GetStatus(), [64]byte{1}, p2pNoFork, protocol, protocol, nil) }()
 	go func() { errc <- handShake(ctx, s2.GetStatus(), [64]byte{2}, p2pProFork, protocol, protocol, nil) }()
@@ -125,8 +129,8 @@ func testForkIDSplit(t *testing.T, protocol uint) {
 	}
 
 	// Progress into Spurious. Forks mismatch, signalling differing chains, reject
-	s1.statusData.MaxBlock = 2
-	s2.statusData.MaxBlock = 2
+	s1.statusData.MaxBlockHeight = 2
+	s2.statusData.MaxBlockHeight = 2
 
 	// Both nodes should allow the other to connect (same genesis, next fork is the same)
 	go func() { errc <- handShake(ctx, s1.GetStatus(), [64]byte{1}, p2pNoFork, protocol, protocol, nil) }()

cmd/sentry/sentry/sentry_multi_client.go

@@ -252,10 +252,12 @@ type MultiClient struct {
 	nodeName      string
 	sentries      []direct.SentryClient
 	headHeight    uint64
+	headTime      uint64
 	headHash      common.Hash
 	headTd        *uint256.Int
 	ChainConfig   *params.ChainConfig
-	forks         []uint64
+	heightForks   []uint64
+	timeForks     []uint64
 	genesisHash   common.Hash
 	networkId     uint64
 	db            kv.RwDB
@@ -311,12 +313,12 @@ func NewMultiClient(
 		passivePeers:  chainConfig.TerminalTotalDifficultyPassed,
 	}
 	cs.ChainConfig = chainConfig
-	cs.forks = forkid.GatherForks(cs.ChainConfig)
+	cs.heightForks, cs.timeForks = forkid.GatherForks(cs.ChainConfig)
 	cs.genesisHash = genesisHash
 	cs.networkId = networkID
 	var err error
 	err = db.View(context.Background(), func(tx kv.Tx) error {
-		cs.headHeight, cs.headHash, cs.headTd, err = cs.Bd.UpdateFromDb(tx)
+		cs.headHeight, cs.headTime, cs.headHash, cs.headTd, err = cs.Bd.UpdateFromDb(tx)
 		return err
 	})
 	return cs, err
@@ -777,10 +779,12 @@ func (cs *MultiClient) makeStatusData() *proto_sentry.StatusData {
 		NetworkId:       s.networkId,
 		TotalDifficulty: gointerfaces.ConvertUint256IntToH256(s.headTd),
 		BestHash:        gointerfaces.ConvertHashToH256(s.headHash),
-		MaxBlock:        s.headHeight,
+		MaxBlockHeight:  s.headHeight,
+		MaxBlockTime:    s.headTime,
 		ForkData: &proto_sentry.Forks{
-			Genesis: gointerfaces.ConvertHashToH256(s.genesisHash),
-			Forks:   s.forks,
+			Genesis:     gointerfaces.ConvertHashToH256(s.genesisHash),
+			HeightForks: s.heightForks,
+			TimeForks:   s.timeForks,
 		},
 		PassivePeers: cs.passivePeers,
 	}

common/sorted.go

@@ -15,3 +15,13 @@ func SortedKeys[K constraints.Ordered, V any](m map[K]V) []K {
 	slices.Sort(keys)
 	return keys
 }
+
+func RemoveDuplicatesFromSorted[T constraints.Ordered](slice []T) []T {
+	for i := 1; i < len(slice); i++ {
+		if slice[i] == slice[i-1] {
+			slice = append(slice[:i], slice[i+1:]...)
+			i--
+		}
+	}
+	return slice
+}

common/sorted_test.go

@@ -0,0 +1,29 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRemoveDuplicatesFromSorted(t *testing.T) {
+	tests := []struct {
+		in  []int
+		out []int
+	}{
+		{[]int{}, []int{}},
+		{[]int{1, 2, 5}, []int{1, 2, 5}},
+		{[]int{1, 1, 2, 5, 5, 5, 7}, []int{1, 2, 5, 7}},
+		{[]int{8, 8, 5, 4, 4, 4, 2}, []int{8, 5, 4, 2}},
+		{[]int{8, 8, 8, 8, 8, 4}, []int{8, 4}},
+		{[]int{1, 8, 8, 8, 8, 8}, []int{1, 8}},
+		{[]int{8, 8, 8, 8, 8}, []int{8}},
+		{[]int{-3, -3}, []int{-3}},
+		{[]int{-3}, []int{-3}},
+	}
+
+	for _, test := range tests {
+		x := RemoveDuplicatesFromSorted(test.in)
+		assert.Equal(t, test.out, x)
+	}
+}