Fix again TestService_Start_OnlyStartsOnce.

beacon-chain/p2p/broadcaster_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
@@ -218,19 +219,30 @@ func TestService_BroadcastAttestation(t *testing.T) {
 func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	const port = uint(2000)
 
+	// The DB has to be shared in all peers to avoid the
+	// duplicate metrics collector registration attempted.
+	// However, we don't care for this test.
+	db := testDB.SetupDB(t)
+
 	// Setup bootnode.
-	cfg := &Config{PingInterval: testPingInterval}
+	cfg := &Config{PingInterval: testPingInterval, DB: db}
 	cfg.UDPPort = uint(port)
 	_, pkey := createAddrAndPrivKey(t)
 	ipAddr := net.ParseIP("127.0.0.1")
 	genesisTime := time.Now()
 	genesisValidatorsRoot := make([]byte, 32)
+
 	s := &Service{
 		cfg:                   cfg,
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 		custodyInfo:           &custodyInfo{},
+		ctx:                   t.Context(),
+		custodyInfoSet:        make(chan struct{}),
 	}
+
+	close(s.custodyInfoSet)
+
 	bootListener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
 	defer bootListener.Close()
@@ -245,6 +257,7 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 		Discv5BootStrapAddrs: []string{bootNode.String()},
 		MaxPeers:             2,
 		PingInterval:         testPingInterval,
+		DB:                   db,
 	}
 	// Setup 2 different hosts
 	for i := uint(1); i <= 2; i++ {
@@ -259,7 +272,12 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 			genesisTime:           genesisTime,
 			genesisValidatorsRoot: genesisValidatorsRoot,
 			custodyInfo:           &custodyInfo{},
+			ctx:                   t.Context(),
+			custodyInfoSet:        make(chan struct{}),
 		}
+
+		close(s.custodyInfoSet)
+
 		listener, err := s.startDiscoveryV5(ipAddr, pkey)
 		// Set for 2nd peer
 		if i == 2 {
@@ -682,6 +700,11 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 }
 
 func TestService_BroadcastDataColumn(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	const (
 		port        = 2000
 		columnIndex = 12
@@ -711,18 +734,26 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	// Create a host.
 	_, pkey, ipAddr := createHost(t, port)
 
+	// Create a shared DB for the service
+	db := testDB.SetupDB(t)
+
+	// Create and close the custody info channel immediately since custodyInfo is already set
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	service := &Service{
 		ctx:                   ctx,
 		host:                  p1.BHost,
 		pubsub:                p1.PubSub(),
 		joinedTopics:          map[string]*pubsub.Topic{},
-		cfg:                   &Config{},
+		cfg:                   &Config{DB: db},
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		subnetsLock:           make(map[uint64]*sync.RWMutex),
 		subnetsLockLock:       sync.Mutex{},
 		peers:                 peers.NewStatus(ctx, &peers.StatusConfig{ScorerParams: &scorers.Config{}}),
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 
 	// Create a listener.

beacon-chain/p2p/discovery_test.go

@@ -136,20 +136,31 @@ func setNodeSubnets(localNode *enode.LocalNode, attSubnets []uint64) {
 }
 
 func TestCreateListener(t *testing.T) {
-	port := 1024
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	ipAddr, pkey := createAddrAndPrivKey(t)
+
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
+		ctx:                   t.Context(),
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
-		cfg:                   &Config{UDPPort: uint(port)},
+		cfg:                   &Config{UDPPort: 2200, DB: db},
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 	listener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
 	defer listener.Close()
 
 	assert.Equal(t, true, listener.Self().IP().Equal(ipAddr), "IP address is not the expected type")
-	assert.Equal(t, port, listener.Self().UDP(), "Incorrect port number")
+	assert.Equal(t, 2200, listener.Self().UDP(), "Incorrect port number")
 
 	pubkey := listener.Self().Pubkey()
 	XisSame := pkey.PublicKey.X.Cmp(pubkey.X) == 0
@@ -161,15 +172,26 @@ func TestCreateListener(t *testing.T) {
 }
 
 func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
-	port := 2000
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	ipAddr, pkey := createAddrAndPrivKey(t)
 	genesisTime := time.Now()
 	genesisValidatorsRoot := make([]byte, 32)
+
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
-		cfg:                   &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
+		ctx:                   t.Context(),
+		cfg:                   &Config{UDPPort: 6000, PingInterval: testPingInterval, DisableLivenessCheck: true, DB: db}, // Use high port to reduce conflicts
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 	bootListener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -183,19 +205,26 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 
 	var listeners []*listenerWrapper
 	for i := 1; i <= 5; i++ {
-		port = 3000 + i
+		port := 6000 + i // Use unique high ports for peer discovery
 		cfg := &Config{
 			Discv5BootStrapAddrs: []string{bootNode.String()},
 			UDPPort:              uint(port),
 			PingInterval:         testPingInterval,
 			DisableLivenessCheck: true,
+			DB:                   db,
 		}
 		ipAddr, pkey := createAddrAndPrivKey(t)
+
+		custodyInfoSetLoop := make(chan struct{})
+		close(custodyInfoSetLoop)
+
 		s = &Service{
+			ctx:                   t.Context(),
 			cfg:                   cfg,
 			genesisTime:           genesisTime,
 			genesisValidatorsRoot: genesisValidatorsRoot,
 			custodyInfo:           &custodyInfo{},
+			custodyInfoSet:        custodyInfoSetLoop,
 		}
 		listener, err := s.startDiscoveryV5(ipAddr, pkey)
 		assert.NoError(t, err, "Could not start discovery for node")
@@ -221,14 +250,9 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 
 func TestCreateLocalNode(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-
-	// Set the fulu fork epoch to something other than the far future epoch.
-	initFuluForkEpoch := params.BeaconConfig().FuluForkEpoch
-	params.BeaconConfig().FuluForkEpoch = 42
-
-	defer func() {
-		params.BeaconConfig().FuluForkEpoch = initFuluForkEpoch
-	}()
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
 
 	testCases := []struct {
 		name          string
@@ -264,11 +288,11 @@ func TestCreateLocalNode(t *testing.T) {
 
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
-			// Define ports.
+			// Define ports. Use unique ports since this test validates ENR content.
 			const (
-				udpPort  = 2000
-				tcpPort  = 3000
-				quicPort = 3000
+				udpPort  = 3100
+				tcpPort  = 3101
+				quicPort = 3102
 			)
 
 			custodyRequirement := params.BeaconConfig().CustodyRequirement
@@ -344,13 +368,24 @@ func TestCreateLocalNode(t *testing.T) {
 }
 
 func TestRebootDiscoveryListener(t *testing.T) {
-	port := 1024
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	ipAddr, pkey := createAddrAndPrivKey(t)
+
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
+		ctx:                   t.Context(),
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
-		cfg:                   &Config{UDPPort: uint(port)},
+		cfg:                   &Config{UDPPort: 0, DB: db}, // Use 0 to let OS assign an available port
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 
 	createListener := func() (*discover.UDPv5, error) {
@@ -377,13 +412,24 @@ func TestRebootDiscoveryListener(t *testing.T) {
 }
 
 func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	addr := net.ParseIP("invalidIP")
 	_, pkey := createAddrAndPrivKey(t)
+
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
+		ctx:                   t.Context(),
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		cfg:                   &Config{},
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 	node, err := s.createLocalNode(pkey, addr, 0, 0, 0)
 	require.NoError(t, err)
@@ -392,17 +438,30 @@ func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
 }
 
 func TestMultiAddrConversion_OK(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	hook := logTest.NewGlobal()
 	ipAddr, pkey := createAddrAndPrivKey(t)
+
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
+		ctx: t.Context(),
 		cfg: &Config{
-			UDPPort:  2000,
-			TCPPort:  3000,
-			QUICPort: 3000,
+			UDPPort:  0, // Use 0 to let OS assign an available port
+			TCPPort:  0,
+			QUICPort: 0,
+			DB:       db,
 		},
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 	listener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -464,6 +523,11 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) {
 }
 
 func TestHostIsResolved(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	host := "dns.google"
 	ips := map[string]bool{
 		"8.8.8.8":              true,
@@ -472,13 +536,20 @@ func TestHostIsResolved(t *testing.T) {
 		"2001:4860:4860::8844": true,
 	}
 
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
+		ctx: t.Context(),
 		cfg: &Config{
 			HostDNS: host,
+			DB:      db,
 		},
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 	ip, key := createAddrAndPrivKey(t)
 	list, err := s.createListener(ip, key)
@@ -540,15 +611,26 @@ func TestOutboundPeerThreshold(t *testing.T) {
 }
 
 func TestUDPMultiAddress(t *testing.T) {
-	port := 6500
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	ipAddr, pkey := createAddrAndPrivKey(t)
 	genesisTime := time.Now()
 	genesisValidatorsRoot := make([]byte, 32)
+
+	db := testDB.SetupDB(t)
+	custodyInfoSet := make(chan struct{})
+	close(custodyInfoSet)
+
 	s := &Service{
-		cfg:                   &Config{UDPPort: uint(port)},
+		ctx:                   t.Context(),
+		cfg:                   &Config{UDPPort: 2500, DB: db},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 		custodyInfo:           &custodyInfo{},
+		custodyInfoSet:        custodyInfoSet,
 	}
 
 	createListener := func() (*discover.UDPv5, error) {
@@ -562,7 +644,7 @@ func TestUDPMultiAddress(t *testing.T) {
 	multiAddresses, err := s.DiscoveryAddresses()
 	require.NoError(t, err)
 	require.Equal(t, true, len(multiAddresses) > 0)
-	assert.Equal(t, true, strings.Contains(multiAddresses[0].String(), fmt.Sprintf("%d", port)))
+	assert.Equal(t, true, strings.Contains(multiAddresses[0].String(), fmt.Sprintf("%d", 2500)))
 	assert.Equal(t, true, strings.Contains(multiAddresses[0].String(), "udp"))
 }
 
@@ -912,7 +994,7 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 					actualPingCount++
 					return nil
 				},
-				cfg:                   &Config{UDPPort: 2000, DB: testDB.SetupDB(t)},
+				cfg:                   &Config{UDPPort: 0, DB: testDB.SetupDB(t)}, // Use 0 to let OS assign an available port
 				peers:                 p2p.Peers(),
 				genesisTime:           time.Now().Add(-time.Duration(tc.epochSinceGenesis*secondsPerEpoch) * time.Second),
 				genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),

beacon-chain/p2p/service_test.go

@@ -63,9 +63,9 @@ func TestService_Start_OnlyStartsOnce(t *testing.T) {
 
 	cs := startup.NewClockSynchronizer()
 	cfg := &Config{
-		UDPPort:     2000,
-		TCPPort:     3000,
-		QUICPort:    3000,
+		UDPPort:     0, // Use 0 to let OS assign an available port
+		TCPPort:     0,
+		QUICPort:    0,
 		ClockWaiter: cs,
 		DB:          testDB.SetupDB(t),
 	}
@@ -73,6 +73,7 @@ func TestService_Start_OnlyStartsOnce(t *testing.T) {
 	require.NoError(t, err)
 	s.dv5Listener = testp2p.NewMockListener(nil, nil)
 	s.custodyInfo = &custodyInfo{}
+	close(s.custodyInfoSet)
 	exitRoutine := make(chan bool)
 	go func() {
 		s.Start()
@@ -111,9 +112,9 @@ func TestService_Start_NoDiscoverFlag(t *testing.T) {
 
 	cs := startup.NewClockSynchronizer()
 	cfg := &Config{
-		UDPPort:       2000,
-		TCPPort:       3000,
-		QUICPort:      3000,
+		UDPPort:       0, // Use 0 to let OS assign an available port
+		TCPPort:       0,
+		QUICPort:      0,
 		StateNotifier: &mock.MockStateNotifier{},
 		NoDiscovery:   true, // <-- no s.dv5Listener is created
 		ClockWaiter:   cs,
@@ -147,12 +148,16 @@ func TestService_Start_NoDiscoverFlag(t *testing.T) {
 
 func TestListenForNewNodes(t *testing.T) {
 	const (
-		port              = uint(2000)
+		bootPort          = uint(2200) // Use specific port for bootnode ENR
 		testPollingPeriod = 1 * time.Second
 		peerCount         = 5
 	)
 
 	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	db := testDB.SetupDB(t)
 
 	// Setup bootnode.
@@ -160,7 +165,7 @@ func TestListenForNewNodes(t *testing.T) {
 		StateNotifier:        &mock.MockStateNotifier{},
 		PingInterval:         testPingInterval,
 		DisableLivenessCheck: true,
-		UDPPort:              port,
+		UDPPort:              bootPort,
 		DB:                   db,
 	}
 
@@ -199,18 +204,19 @@ func TestListenForNewNodes(t *testing.T) {
 	hosts := make([]host.Host, 0, peerCount)
 
 	for i := uint(1); i <= peerCount; i++ {
+		peerPort := bootPort + i
 		cfg = &Config{
 			Discv5BootStrapAddrs: []string{bootNode.String()},
 			PingInterval:         testPingInterval,
 			DisableLivenessCheck: true,
 			MaxPeers:             peerCount,
 			ClockWaiter:          cs,
-			UDPPort:              port + i,
-			TCPPort:              port + i,
+			UDPPort:              peerPort,
+			TCPPort:              peerPort,
 			DB:                   db,
 		}
 
-		h, pkey, ipAddr := createHost(t, port+i)
+		h, pkey, ipAddr := createHost(t, peerPort)
 
 		s := &Service{
 			cfg:                   cfg,
@@ -271,6 +277,10 @@ func TestListenForNewNodes(t *testing.T) {
 
 func TestPeer_Disconnect(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.FuluForkEpoch = 0
+	params.OverrideBeaconConfig(config)
+
 	h1, _, _ := createHost(t, 5000)
 	defer func() {
 		if err := h1.Close(); err != nil {

beacon-chain/rpc/eth/beacon/handlers_pool_test.go

@@ -356,6 +356,12 @@ func TestListAttestationsV2(t *testing.T) {
 			request := httptest.NewRequest(http.MethodGet, url, nil)
 			writer := httptest.NewRecorder()
 			writer.Body = &bytes.Buffer{}
+      
+			params.SetupTestConfigCleanup(t)
+			config := params.BeaconConfig()
+			config.ElectraForkEpoch = 0
+			config.FuluForkEpoch = config.FarFutureEpoch
+			params.OverrideBeaconConfig(config)
 
 			s.ListAttestationsV2(writer, request)
 			assert.Equal(t, http.StatusOK, writer.Code)
@@ -394,6 +400,186 @@ func TestListAttestationsV2(t *testing.T) {
 				assert.Equal(t, "0x0400000000000000", a.CommitteeBits)
 			}
 		})
+		t.Run("Post-Fulu", func(t *testing.T) {
+			cb1 := primitives.NewAttestationCommitteeBits()
+			cb1.SetBitAt(1, true)
+			cb2 := primitives.NewAttestationCommitteeBits()
+			cb2.SetBitAt(2, true)
+
+			attFulu1 := &ethpbv1alpha1.AttestationElectra{
+				AggregationBits: []byte{1, 10},
+				Data: &ethpbv1alpha1.AttestationData{
+					Slot:            1,
+					CommitteeIndex:  0,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot1"), 32),
+					Source: &ethpbv1alpha1.Checkpoint{
+						Epoch: 1,
+						Root:  bytesutil.PadTo([]byte("sourceroot1"), 32),
+					},
+					Target: &ethpbv1alpha1.Checkpoint{
+						Epoch: 10,
+						Root:  bytesutil.PadTo([]byte("targetroot1"), 32),
+					},
+				},
+				CommitteeBits: cb1,
+				Signature:     bytesutil.PadTo([]byte("signature1"), 96),
+			}
+			attFulu2 := &ethpbv1alpha1.AttestationElectra{
+				AggregationBits: []byte{1, 10},
+				Data: &ethpbv1alpha1.AttestationData{
+					Slot:            1,
+					CommitteeIndex:  0,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot2"), 32),
+					Source: &ethpbv1alpha1.Checkpoint{
+						Epoch: 1,
+						Root:  bytesutil.PadTo([]byte("sourceroot2"), 32),
+					},
+					Target: &ethpbv1alpha1.Checkpoint{
+						Epoch: 10,
+						Root:  bytesutil.PadTo([]byte("targetroot2"), 32),
+					},
+				},
+				CommitteeBits: cb2,
+				Signature:     bytesutil.PadTo([]byte("signature2"), 96),
+			}
+			attFulu3 := &ethpbv1alpha1.AttestationElectra{
+				AggregationBits: bitfield.NewBitlist(8),
+				Data: &ethpbv1alpha1.AttestationData{
+					Slot:            2,
+					CommitteeIndex:  0,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot3"), 32),
+					Source: &ethpbv1alpha1.Checkpoint{
+						Epoch: 1,
+						Root:  bytesutil.PadTo([]byte("sourceroot3"), 32),
+					},
+					Target: &ethpbv1alpha1.Checkpoint{
+						Epoch: 10,
+						Root:  bytesutil.PadTo([]byte("targetroot3"), 32),
+					},
+				},
+				CommitteeBits: cb1,
+				Signature:     bytesutil.PadTo([]byte("signature3"), 96),
+			}
+			attFulu4 := &ethpbv1alpha1.AttestationElectra{
+				AggregationBits: bitfield.NewBitlist(8),
+				Data: &ethpbv1alpha1.AttestationData{
+					Slot:            2,
+					CommitteeIndex:  0,
+					BeaconBlockRoot: bytesutil.PadTo([]byte("blockroot4"), 32),
+					Source: &ethpbv1alpha1.Checkpoint{
+						Epoch: 1,
+						Root:  bytesutil.PadTo([]byte("sourceroot4"), 32),
+					},
+					Target: &ethpbv1alpha1.Checkpoint{
+						Epoch: 10,
+						Root:  bytesutil.PadTo([]byte("targetroot4"), 32),
+					},
+				},
+				CommitteeBits: cb2,
+				Signature:     bytesutil.PadTo([]byte("signature4"), 96),
+			}
+			bs, err := util.NewBeaconStateElectra()
+			require.NoError(t, err)
+
+			params.SetupTestConfigCleanup(t)
+			config := params.BeaconConfig()
+			config.ElectraForkEpoch = 0
+			config.FuluForkEpoch = 0
+			params.OverrideBeaconConfig(config)
+
+			chainService := &blockchainmock.ChainService{State: bs}
+			s := &Server{
+				AttestationsPool: attestations.NewPool(),
+				ChainInfoFetcher: chainService,
+				TimeFetcher:      chainService,
+			}
+			// Added one pre electra attestation to ensure it is ignored.
+			require.NoError(t, s.AttestationsPool.SaveAggregatedAttestations([]ethpbv1alpha1.Att{attFulu1, attFulu2, att1}))
+			require.NoError(t, s.AttestationsPool.SaveUnaggregatedAttestations([]ethpbv1alpha1.Att{attFulu3, attFulu4, att3}))
+
+			t.Run("empty request", func(t *testing.T) {
+				url := "http://example.com"
+				request := httptest.NewRequest(http.MethodGet, url, nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.ListAttestationsV2(writer, request)
+				assert.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.ListAttestationsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+
+				var atts []*structs.AttestationElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &atts))
+				assert.Equal(t, 4, len(atts))
+				assert.Equal(t, "fulu", resp.Version)
+			})
+			t.Run("slot request", func(t *testing.T) {
+				url := "http://example.com?slot=2"
+				request := httptest.NewRequest(http.MethodGet, url, nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.ListAttestationsV2(writer, request)
+				assert.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.ListAttestationsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+
+				var atts []*structs.AttestationElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &atts))
+				assert.Equal(t, 2, len(atts))
+				assert.Equal(t, "fulu", resp.Version)
+				for _, a := range atts {
+					assert.Equal(t, "2", a.Data.Slot)
+				}
+			})
+			t.Run("index request", func(t *testing.T) {
+				url := "http://example.com?committee_index=2"
+				request := httptest.NewRequest(http.MethodGet, url, nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.ListAttestationsV2(writer, request)
+				assert.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.ListAttestationsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+
+				var atts []*structs.AttestationElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &atts))
+				assert.Equal(t, 2, len(atts))
+				assert.Equal(t, "fulu", resp.Version)
+				for _, a := range atts {
+					assert.Equal(t, "0x0400000000000000", a.CommitteeBits)
+				}
+			})
+			t.Run("both slot + index request", func(t *testing.T) {
+				url := "http://example.com?slot=2&committee_index=2"
+				request := httptest.NewRequest(http.MethodGet, url, nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.ListAttestationsV2(writer, request)
+				assert.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.ListAttestationsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+
+				var atts []*structs.AttestationElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &atts))
+				assert.Equal(t, 1, len(atts))
+				assert.Equal(t, "fulu", resp.Version)
+				for _, a := range atts {
+					assert.Equal(t, "2", a.Data.Slot)
+					assert.Equal(t, "0x0400000000000000", a.CommitteeBits)
+				}
+			})
+		})
 	})
 }
 
@@ -494,6 +680,7 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			params.SetupTestConfigCleanup(t)
 			config := params.BeaconConfig()
 			config.ElectraForkEpoch = 0
+			config.FuluForkEpoch = config.FarFutureEpoch
 			params.OverrideBeaconConfig(config)
 
 			var body bytes.Buffer
@@ -574,6 +761,7 @@ func TestSubmitAttestationsV2(t *testing.T) {
 			assert.Equal(t, true, strings.Contains(e.Failures[0].Message, "Incorrect attestation signature"))
 		})
 	})
+
 	t.Run("post-electra", func(t *testing.T) {
 		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig()
@@ -1493,6 +1681,7 @@ func TestGetAttesterSlashingsV2(t *testing.T) {
 
 		require.DeepEqual(t, slashingPostElectra, ss[0])
 	})
+
 	t.Run("post-electra-ok", func(t *testing.T) {
 		bs, err := util.NewBeaconStateElectra()
 		require.NoError(t, err)
@@ -1500,6 +1689,7 @@ func TestGetAttesterSlashingsV2(t *testing.T) {
 		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig()
 		config.ElectraForkEpoch = 100
+    config.FuluForkEpoch = config.FarFutureEpoch
 		params.OverrideBeaconConfig(config)
 
 		chainService := &blockchainmock.ChainService{State: bs}
@@ -1570,6 +1760,7 @@ func TestGetAttesterSlashingsV2(t *testing.T) {
 		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig()
 		config.ElectraForkEpoch = 100
+    	config.FuluForkEpoch = config.FarFutureEpoch
 		params.OverrideBeaconConfig(config)
 
 		chainService := &blockchainmock.ChainService{State: bs}
@@ -1596,6 +1787,83 @@ func TestGetAttesterSlashingsV2(t *testing.T) {
 		require.NoError(t, json.Unmarshal(resp.Data, &slashings))
 		require.NotNil(t, slashings)
 		require.Equal(t, 0, len(slashings))
+
+		t.Run("Post-Fulu", func(t *testing.T) {
+			t.Run("post-fulu-ok", func(t *testing.T) {
+				bs, err := util.NewBeaconStateElectra()
+				require.NoError(t, err)
+
+				params.SetupTestConfigCleanup(t)
+				config := params.BeaconConfig()
+				config.ElectraForkEpoch = 0
+				config.FuluForkEpoch = 0
+				params.OverrideBeaconConfig(config)
+
+				chainService := &blockchainmock.ChainService{State: bs}
+
+				s := &Server{
+					ChainInfoFetcher: chainService,
+					TimeFetcher:      chainService,
+					SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{slashingPostElectra}},
+				}
+
+				request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/beacon/pool/attester_slashings", nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.GetAttesterSlashingsV2(writer, request)
+				require.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.GetAttesterSlashingsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+				assert.Equal(t, "fulu", resp.Version)
+
+				// Unmarshal resp.Data into a slice of slashings
+				var slashings []*structs.AttesterSlashingElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &slashings))
+
+				ss, err := structs.AttesterSlashingsElectraToConsensus(slashings)
+				require.NoError(t, err)
+
+				require.DeepEqual(t, slashingPostElectra, ss[0])
+			})
+			t.Run("no-slashings", func(t *testing.T) {
+				bs, err := util.NewBeaconStateElectra()
+				require.NoError(t, err)
+
+				params.SetupTestConfigCleanup(t)
+				config := params.BeaconConfig()
+				config.ElectraForkEpoch = 0
+				config.FuluForkEpoch = 0
+				params.OverrideBeaconConfig(config)
+
+				chainService := &blockchainmock.ChainService{State: bs}
+				s := &Server{
+					ChainInfoFetcher: chainService,
+					TimeFetcher:      chainService,
+					SlashingsPool:    &slashingsmock.PoolMock{PendingAttSlashings: []ethpbv1alpha1.AttSlashing{}},
+				}
+
+				request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/beacon/pool/attester_slashings", nil)
+				writer := httptest.NewRecorder()
+				writer.Body = &bytes.Buffer{}
+
+				s.GetAttesterSlashingsV2(writer, request)
+				require.Equal(t, http.StatusOK, writer.Code)
+				resp := &structs.GetAttesterSlashingsResponse{}
+				require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+				require.NotNil(t, resp)
+				require.NotNil(t, resp.Data)
+				assert.Equal(t, "fulu", resp.Version)
+
+				// Unmarshal resp.Data into a slice of slashings
+				var slashings []*structs.AttesterSlashingElectra
+				require.NoError(t, json.Unmarshal(resp.Data, &slashings))
+				require.NotNil(t, slashings)
+				require.Equal(t, 0, len(slashings))
+			})
+		})
 	})
 }
 

changelog/james-prysm_fulu-p2p-rpc-test-fixes.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- adds and fixes p2p & rpc tests caused by enabling fulu fork epoch.