Add Eth2 Fork ENR Functionality

beacon-chain/blockchain/service.go

@@ -187,7 +187,8 @@ func (s *Service) Start() {
 		s.stateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Initialized,
 			Data: &statefeed.InitializedData{
-				StartTime: s.genesisTime,
+				StartTime:             s.genesisTime,
+				GenesisValidatorsRoot: beaconState.GenesisValidatorRoot(),
 			},
 		})
 	} else {
@@ -228,13 +229,15 @@ func (s *Service) Start() {
 // deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
 func (s *Service) processChainStartTime(ctx context.Context, genesisTime time.Time) {
 	preGenesisState := s.chainStartFetcher.PreGenesisState()
-	if err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.chainStartFetcher.ChainStartEth1Data()); err != nil {
+	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.chainStartFetcher.ChainStartEth1Data())
+	if err != nil {
 		log.Fatalf("Could not initialize beacon chain: %v", err)
 	}
 	s.stateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.Initialized,
 		Data: &statefeed.InitializedData{
-			StartTime: genesisTime,
+			StartTime:             genesisTime,
+			GenesisValidatorsRoot: initializedState.GenesisValidatorRoot(),
 		},
 	})
 }
@@ -246,19 +249,19 @@ func (s *Service) initializeBeaconChain(
 	ctx context.Context,
 	genesisTime time.Time,
 	preGenesisState *stateTrie.BeaconState,
-	eth1data *ethpb.Eth1Data) error {
+	eth1data *ethpb.Eth1Data) (*stateTrie.BeaconState, error) {
 	_, span := trace.StartSpan(context.Background(), "beacon-chain.Service.initializeBeaconChain")
 	defer span.End()
 	s.genesisTime = genesisTime
 	unixTime := uint64(genesisTime.Unix())
 
 	genesisState, err := state.OptimizedGenesisBeaconState(unixTime, preGenesisState, eth1data)
 	if err != nil {
-		return errors.Wrap(err, "could not initialize genesis state")
+		return nil, errors.Wrap(err, "could not initialize genesis state")
 	}
 
 	if err := s.saveGenesisData(ctx, genesisState); err != nil {
-		return errors.Wrap(err, "could not save genesis data")
+		return nil, errors.Wrap(err, "could not save genesis data")
 	}
 
 	log.Info("Initialized beacon chain genesis state")
@@ -268,15 +271,15 @@ func (s *Service) initializeBeaconChain(
 
 	// Update committee shuffled indices for genesis epoch.
 	if err := helpers.UpdateCommitteeCache(genesisState, 0 /* genesis epoch */); err != nil {
-		return err
+		return nil, err
 	}
 	if err := helpers.UpdateProposerIndicesInCache(genesisState, 0 /* genesis epoch */); err != nil {
-		return err
+		return nil, err
 	}
 
 	s.opsService.SetGenesisTime(genesisState.GenesisTime())
 
-	return nil
+	return genesisState, nil
 }
 
 // Stop the blockchain service's main event loop and associated goroutines.

beacon-chain/blockchain/service_test.go

@@ -291,7 +291,7 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{
+	if _, err := bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{
 		DepositRoot: hashTreeRoot[:],
 	}); err != nil {
 		t.Fatal(err)

beacon-chain/core/feed/state/events.go

@@ -31,4 +31,6 @@ type ChainStartedData struct {
 type InitializedData struct {
 	// StartTime is the time at which the chain started.
 	StartTime time.Time
+	// GenesisValidatorsRoot represents ssz.HashTreeRoot(state.validators).
+	GenesisValidatorsRoot []byte
 }

beacon-chain/node/node.go

@@ -286,6 +286,7 @@ func (b *BeaconNode) registerP2P(ctx *cli.Context) error {
 	}
 
 	svc, err := p2p.NewService(&p2p.Config{
+		StateNotifier:     b,
 		NoDiscovery:       ctx.Bool(cmd.NoDiscovery.Name),
 		StaticPeers:       sliceutil.SplitCommaSeparated(ctx.StringSlice(cmd.StaticPeers.Name)),
 		BootstrapNodeAddr: bootnodeAddrs,

beacon-chain/p2p/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "dial_relay_node.go",
         "discovery.go",
         "doc.go",
+        "fork.go",
         "gossip_topic_mappings.go",
         "handshake.go",
         "info.go",
@@ -31,14 +32,19 @@ go_library(
     ],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/p2p/connmgr:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared:go_default_library",
+        "//shared/bytesutil:go_default_library",
         "//shared/featureconfig:go_default_library",
         "//shared/hashutil:go_default_library",
         "//shared/iputils:go_default_library",
+        "//shared/params:go_default_library",
         "//shared/runutil:go_default_library",
         "//shared/traceutil:go_default_library",
         "@com_github_btcsuite_btcd//btcec:go_default_library",
@@ -73,6 +79,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_prysmaticlabs_go_ssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],
@@ -85,6 +92,7 @@ go_test(
         "broadcaster_test.go",
         "dial_relay_node_test.go",
         "discovery_test.go",
+        "fork_test.go",
         "gossip_topic_mappings_test.go",
         "options_test.go",
         "parameter_test.go",
@@ -96,10 +104,15 @@ go_test(
     flaky = True,
     tags = ["block-network"],
     deps = [
+        "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/feed:go_default_library",
+        "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//proto/testing:go_default_library",
         "//shared/iputils:go_default_library",
+        "//shared/params:go_default_library",
         "//shared/testutil:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
@@ -116,6 +129,7 @@ go_test(
         "@com_github_multiformats_go_multiaddr//:go_default_library",
         "@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],
 )

beacon-chain/p2p/config.go

@@ -1,8 +1,11 @@
 package p2p
 
+import "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
+
 // Config for the p2p service. These parameters are set from application level flags
 // to initialize the p2p service.
 type Config struct {
+	StateNotifier         state.Notifier
 	NoDiscovery           bool
 	StaticPeers           []string
 	BootstrapNodeAddr     []string

beacon-chain/p2p/discovery.go

@@ -30,21 +30,29 @@ type Listener interface {
 	LocalNode() *enode.LocalNode
 }
 
-func createListener(ipAddr net.IP, privKey *ecdsa.PrivateKey, cfg *Config) *discover.UDPv5 {
+func (s *Service) createListener(
+	ipAddr net.IP,
+	privKey *ecdsa.PrivateKey,
+) *discover.UDPv5 {
 	udpAddr := &net.UDPAddr{
 		IP:   ipAddr,
-		Port: int(cfg.UDPPort),
+		Port: int(s.cfg.UDPPort),
 	}
 	conn, err := net.ListenUDP("udp4", udpAddr)
 	if err != nil {
 		log.Fatal(err)
 	}
-	localNode, err := createLocalNode(privKey, ipAddr, int(cfg.UDPPort), int(cfg.TCPPort))
+	localNode, err := s.createLocalNode(
+		privKey,
+		ipAddr,
+		int(s.cfg.UDPPort),
+		int(s.cfg.TCPPort),
+	)
 	if err != nil {
 		log.Fatal(err)
 	}
-	if cfg.HostAddress != "" {
-		hostIP := net.ParseIP(cfg.HostAddress)
+	if s.cfg.HostAddress != "" {
+		hostIP := net.ParseIP(s.cfg.HostAddress)
 		if hostIP.To4() == nil {
 			log.Errorf("Invalid host address given: %s", hostIP.String())
 		} else {
@@ -55,7 +63,7 @@ func createListener(ipAddr net.IP, privKey *ecdsa.PrivateKey, cfg *Config) *disc
 		PrivateKey: privKey,
 	}
 	dv5Cfg.Bootnodes = []*enode.Node{}
-	for _, addr := range cfg.Discv5BootStrapAddr {
+	for _, addr := range s.cfg.Discv5BootStrapAddr {
 		bootNode, err := enode.Parse(enode.ValidSchemes, addr)
 		if err != nil {
 			log.Fatal(err)
@@ -70,7 +78,12 @@ func createListener(ipAddr net.IP, privKey *ecdsa.PrivateKey, cfg *Config) *disc
 	return network
 }
 
-func createLocalNode(privKey *ecdsa.PrivateKey, ipAddr net.IP, udpPort int, tcpPort int) (*enode.LocalNode, error) {
+func (s *Service) createLocalNode(
+	privKey *ecdsa.PrivateKey,
+	ipAddr net.IP,
+	udpPort int,
+	tcpPort int,
+) (*enode.LocalNode, error) {
 	db, err := enode.OpenDB("")
 	if err != nil {
 		return nil, errors.Wrap(err, "could not open node's peer database")
@@ -85,11 +98,18 @@ func createLocalNode(privKey *ecdsa.PrivateKey, ipAddr net.IP, udpPort int, tcpP
 	localNode.SetFallbackIP(ipAddr)
 	localNode.SetFallbackUDP(udpPort)
 
+	localNode, err = addForkEntry(localNode, s.genesisTime, s.genesisValidatorsRoot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not add eth2 fork version entry to enr")
+	}
 	return intializeAttSubnets(localNode), nil
 }
 
-func startDiscoveryV5(addr net.IP, privKey *ecdsa.PrivateKey, cfg *Config) (*discover.UDPv5, error) {
-	listener := createListener(addr, privKey, cfg)
+func (s *Service) startDiscoveryV5(
+	addr net.IP,
+	privKey *ecdsa.PrivateKey,
+) (*discover.UDPv5, error) {
+	listener := s.createListener(addr, privKey)
 	record := listener.Self()
 	log.WithField("ENR", record.String()).Info("Started discovery v5")
 	return listener, nil

beacon-chain/p2p/discovery_test.go

@@ -14,6 +14,9 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/libp2p/go-libp2p-core/host"
+	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
+	stateFeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/shared/iputils"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 	logTest "github.com/sirupsen/logrus/hooks/test"
@@ -48,7 +51,10 @@ func createAddrAndPrivKey(t *testing.T) (net.IP, *ecdsa.PrivateKey) {
 func TestCreateListener(t *testing.T) {
 	port := 1024
 	ipAddr, pkey := createAddrAndPrivKey(t)
-	listener := createListener(ipAddr, pkey, &Config{UDPPort: uint(port)})
+	s := &Service{
+		cfg: &Config{UDPPort: uint(port)},
+	}
+	listener := s.createListener(ipAddr, pkey)
 	defer listener.Close()
 
 	if !listener.Self().IP().Equal(ipAddr) {
@@ -70,21 +76,33 @@ func TestCreateListener(t *testing.T) {
 func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 	port := 2000
 	ipAddr, pkey := createAddrAndPrivKey(t)
-	bootListener := createListener(ipAddr, pkey, &Config{UDPPort: uint(port)})
+	genesisTime := time.Now()
+	genesisValidatorsRoot := make([]byte, 32)
+	s := &Service{
+		cfg:                   &Config{UDPPort: uint(port)},
+		genesisTime:           genesisTime,
+		genesisValidatorsRoot: genesisValidatorsRoot,
+	}
+	bootListener := s.createListener(ipAddr, pkey)
 	defer bootListener.Close()
 
 	bootNode := bootListener.Self()
-	cfg := &Config{
-		Discv5BootStrapAddr: []string{bootNode.String()},
-		Encoding:            "ssz",
-	}
 
 	var listeners []*discover.UDPv5
 	for i := 1; i <= 5; i++ {
 		port = 3000 + i
-		cfg.UDPPort = uint(port)
+		cfg := &Config{
+			Discv5BootStrapAddr: []string{bootNode.String()},
+			Encoding:            "ssz",
+			UDPPort:             uint(port),
+		}
 		ipAddr, pkey := createAddrAndPrivKey(t)
-		listener, err := startDiscoveryV5(ipAddr, pkey, cfg)
+		s = &Service{
+			cfg:                   cfg,
+			genesisTime:           genesisTime,
+			genesisValidatorsRoot: genesisValidatorsRoot,
+		}
+		listener, err := s.startDiscoveryV5(ipAddr, pkey)
 		if err != nil {
 			t.Errorf("Could not start discovery for node: %v", err)
 		}
@@ -110,7 +128,8 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
 	addr := net.ParseIP("invalidIP")
 	_, pkey := createAddrAndPrivKey(t)
-	node, err := createLocalNode(pkey, addr, 0, 0)
+	s := &Service{}
+	node, err := s.createLocalNode(pkey, addr, 0, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -123,7 +142,13 @@ func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
 func TestMultiAddrConversion_OK(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ipAddr, pkey := createAddrAndPrivKey(t)
-	listener := createListener(ipAddr, pkey, &Config{})
+	s := &Service{
+		cfg: &Config{
+			TCPPort: 0,
+			UDPPort: 0,
+		},
+	}
+	listener := s.createListener(ipAddr, pkey)
 
 	_ = convertToMultiAddr([]*enode.Node{listener.Self()})
 	testutil.AssertLogsDoNotContain(t, hook, "Node doesn't have an ip4 address")
@@ -132,7 +157,9 @@ func TestMultiAddrConversion_OK(t *testing.T) {
 }
 
 func TestStaticPeering_PeersAreAdded(t *testing.T) {
-	cfg := &Config{Encoding: "ssz", MaxPeers: 30}
+	cfg := &Config{
+		Encoding: "ssz", MaxPeers: 30,
+	}
 	port := 3000
 	var staticPeers []string
 	var hosts []host.Host
@@ -152,16 +179,20 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) {
 	cfg.TCPPort = 14001
 	cfg.UDPPort = 14000
 	cfg.StaticPeers = staticPeers
-
+	mockChainService := &mock.ChainService{}
 	s, err := NewService(cfg)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	s.Start()
-	s.dv5Listener = &mockListener{}
-	defer s.Stop()
-	time.Sleep(100 * time.Millisecond)
+	s.stateNotifier = mockChainService.StateNotifier()
+
+	startService(t, s, &feed.Event{
+		Type: stateFeed.Initialized,
+		Data: &stateFeed.InitializedData{
+			StartTime:             time.Now(),
+			GenesisValidatorsRoot: make([]byte, 32),
+		},
+	})
 
 	peers := s.host.Network().Peers()
 	if len(peers) != 5 {