Hydrate header test helper (#8234)

* Hydrate headers and fix tests

* Gazelle

* Fix a slashing test

Co-authored-by: Radosław Kapka <rkapka@wp.pl>

beacon-chain/core/blocks/header_test.go

@@ -37,12 +37,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetSlot(10))
 	require.NoError(t, state.SetValidators(validators))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:       10, // Must be less than block.Slot
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 10, // Must be less than block.Slot
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -74,12 +71,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 	testutil.ResetCache()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	require.NoError(t, beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:       9,
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	}))
+	require.NoError(t, beaconState.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 	require.NoError(t, beaconState.SetSlot(10))
 
 	lbhdr, err := beaconState.LatestBlockHeader().HashTreeRoot()
@@ -115,13 +109,9 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:          9,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 
 	lbhsr, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -239,13 +229,9 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
-		Slot:          9,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot: 9,
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -300,13 +286,10 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	state := testutil.NewBeaconState()
 	require.NoError(t, state.SetValidators(validators))
 	require.NoError(t, state.SetSlot(10))
-	require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+	require.NoError(t, state.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 		Slot:          9,
 		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}))
+	})))
 
 	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -141,27 +141,21 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	proposerIdx := uint64(1)
 
 	header1 := &ethpb.SignedBeaconBlockHeader{
-		Header: &ethpb.BeaconBlockHeader{
+		Header: testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
-			Slot:          0,
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
-		},
+		}),
 	}
 	var err error
 	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
 
-	header2 := &ethpb.SignedBeaconBlockHeader{
+	header2 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerIdx,
-			Slot:          0,
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
 		},
-	}
+	})
 	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
 
@@ -211,24 +205,18 @@ func TestVerifyProposerSlashing(t *testing.T) {
 			name: "same header, same slot as state",
 			args: args{
 				slashing: &ethpb.ProposerSlashing{
-					Header_1: &ethpb.SignedBeaconBlockHeader{
+					Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
 							Slot:          currentSlot,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
-					},
-					Header_2: &ethpb.SignedBeaconBlockHeader{
+					}),
+					Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
 							Slot:          currentSlot,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
-					},
+					}),
 				},
 				beaconState: beaconState,
 			},
@@ -238,26 +226,18 @@ func TestVerifyProposerSlashing(t *testing.T) {
 			name: "same header, different signatures",
 			args: args{
 				slashing: &ethpb.ProposerSlashing{
-					Header_1: &ethpb.SignedBeaconBlockHeader{
+					Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
-							Slot:          0,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
 						Signature: sig1,
-					},
-					Header_2: &ethpb.SignedBeaconBlockHeader{
+					}),
+					Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 						Header: &ethpb.BeaconBlockHeader{
 							ProposerIndex: 1,
-							Slot:          0,
-							StateRoot:     bytesutil.PadTo([]byte{}, 32),
-							BodyRoot:      bytesutil.PadTo([]byte{}, 32),
-							ParentRoot:    bytesutil.PadTo([]byte{}, 32),
 						},
 						Signature: sig2,
-					},
+					}),
 				},
 				beaconState: beaconState,
 			},

beacon-chain/core/state/transition_test.go

@@ -164,24 +164,16 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
 	require.NoError(t, err)
 	slashing := &ethpb.ProposerSlashing{
-		Header_1: &ethpb.SignedBeaconBlockHeader{
+		Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
-				Slot:       params.BeaconConfig().SlotsPerEpoch,
-				ParentRoot: make([]byte, 32),
-				StateRoot:  make([]byte, 32),
-				BodyRoot:   make([]byte, 32),
+				Slot: params.BeaconConfig().SlotsPerEpoch,
 			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpb.SignedBeaconBlockHeader{
+		}),
+		Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
-				Slot:       params.BeaconConfig().SlotsPerEpoch * 2,
-				ParentRoot: make([]byte, 32),
-				StateRoot:  make([]byte, 32),
-				BodyRoot:   make([]byte, 32),
+				Slot: params.BeaconConfig().SlotsPerEpoch * 2,
 			},
-			Signature: make([]byte, 96),
-		},
+		}),
 	}
 	block.Block.Body.ProposerSlashings = []*ethpb.ProposerSlashing{slashing}
 
@@ -231,26 +223,20 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 
 	proposerSlashings := []*ethpb.ProposerSlashing{
 		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
+			Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
 					Slot:          1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
 				Signature: bytesutil.PadTo([]byte("A"), 96),
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
+			}),
+			Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
 					Slot:          1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
 				Signature: bytesutil.PadTo([]byte("B"), 96),
-			},
+			}),
 		},
 	}
 	attesterSlashings := []*ethpb.AttesterSlashing{
@@ -286,12 +272,11 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	genesisBlock := blocks.NewGenesisBlock([]byte{})
 	bodyRoot, err := genesisBlock.Block.HashTreeRoot()
 	require.NoError(t, err)
-	err = beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+	err = beaconState.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 		Slot:       genesisBlock.Block.Slot,
 		ParentRoot: genesisBlock.Block.ParentRoot,
 		BodyRoot:   bodyRoot[:],
-		StateRoot:  make([]byte, 32),
-	})
+	}))
 	require.NoError(t, err)
 	parentRoot, err := beaconState.LatestBlockHeader().HashTreeRoot()
 	require.NoError(t, err)
@@ -343,27 +328,23 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
 	require.NoError(t, err)
 
 	currentEpoch := helpers.CurrentEpoch(beaconState)
-	header1 := &ethpb.SignedBeaconBlockHeader{
+	header1 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerSlashIdx,
 			Slot:          1,
 			StateRoot:     bytesutil.PadTo([]byte("A"), 32),
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 		},
-	}
+	})
 	header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
 	require.NoError(t, err)
 
-	header2 := &ethpb.SignedBeaconBlockHeader{
+	header2 := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: proposerSlashIdx,
 			Slot:          1,
 			StateRoot:     bytesutil.PadTo([]byte("B"), 32),
-			ParentRoot:    make([]byte, 32),
-			BodyRoot:      make([]byte, 32),
 		},
-	}
+	})
 	header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
 	require.NoError(t, err)
 

beacon-chain/db/kv/slashings_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 )
@@ -14,24 +15,16 @@ func TestStore_ProposerSlashing_CRUD(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
 	prop := &ethpb.ProposerSlashing{
-		Header_1: &ethpb.SignedBeaconBlockHeader{
+		Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 5,
-				BodyRoot:      make([]byte, 32),
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpb.SignedBeaconBlockHeader{
+		}),
+		Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 5,
-				BodyRoot:      make([]byte, 32),
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
+		}),
 	}
 	slashingRoot, err := prop.HashTreeRoot()
 	require.NoError(t, err)

beacon-chain/rpc/validator/attester_test.go

@@ -371,11 +371,9 @@ func TestServer_GetAttestationData_HeadStateSlotGreaterThanRequestSlot(t *testin
 	beaconState := testutil.NewBeaconState()
 	require.NoError(t, beaconState.SetSlot(slot))
 	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix()-int64(slot*params.BeaconConfig().SecondsPerSlot))))
-	err = beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
+	err = beaconState.SetLatestBlockHeader(testutil.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
 		ParentRoot: blockRoot2[:],
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	})
+	}))
 	require.NoError(t, err)
 	err = beaconState.SetCurrentJustifiedCheckpoint(&ethpb.Checkpoint{
 		Epoch: 2,

shared/testutil/block.go

@@ -189,15 +189,13 @@ func GenerateProposerSlashingForValidator(
 	priv bls.SecretKey,
 	idx uint64,
 ) (*ethpb.ProposerSlashing, error) {
-	header1 := &ethpb.SignedBeaconBlockHeader{
+	header1 := HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			ProposerIndex: idx,
 			Slot:          bState.Slot(),
 			BodyRoot:      bytesutil.PadTo([]byte{0, 1, 0}, 32),
-			StateRoot:     make([]byte, 32),
-			ParentRoot:    make([]byte, 32),
 		},
-	}
+	})
 	currentEpoch := helpers.CurrentEpoch(bState)
 	var err error
 	header1.Signature, err = helpers.ComputeDomainAndSign(bState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, priv)
@@ -381,3 +379,31 @@ func randValIndex(bState *stateTrie.BeaconState) (uint64, error) {
 	}
 	return rand.NewGenerator().Uint64() % activeCount, nil
 }
+
+// HydrateSignedBeaconHeader hydrates a signed beacon block header with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateSignedBeaconHeader(h *ethpb.SignedBeaconBlockHeader) *ethpb.SignedBeaconBlockHeader {
+	if h.Signature == nil {
+		h.Signature = make([]byte, params.BeaconConfig().BLSSignatureLength)
+	}
+	h.Header = HydrateBeaconHeader(h.Header)
+	return h
+}
+
+// HydrateBeaconHeader hydrates a beacon block header with correct field length sizes
+// to comply with fssz marshalling and unmarshalling rules.
+func HydrateBeaconHeader(h *ethpb.BeaconBlockHeader) *ethpb.BeaconBlockHeader {
+	if h == nil {
+		h = &ethpb.BeaconBlockHeader{}
+	}
+	if h.BodyRoot == nil {
+		h.BodyRoot = make([]byte, 32)
+	}
+	if h.StateRoot == nil {
+		h.StateRoot = make([]byte, 32)
+	}
+	if h.ParentRoot == nil {
+		h.ParentRoot = make([]byte, 32)
+	}
+	return h
+}

shared/testutil/state.go

@@ -23,15 +23,11 @@ var st, _ = stateTrie.InitializeFromProtoUnsafe(&pb.BeaconState{
 		PreviousVersion: make([]byte, 4),
 		CurrentVersion:  make([]byte, 4),
 	},
-	Eth1DataVotes:       make([]*ethpb.Eth1Data, 0),
-	HistoricalRoots:     make([][]byte, 0),
-	JustificationBits:   bitfield.Bitvector4{0x0},
-	FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
-	LatestBlockHeader: &ethpb.BeaconBlockHeader{
-		ParentRoot: make([]byte, 32),
-		StateRoot:  make([]byte, 32),
-		BodyRoot:   make([]byte, 32),
-	},
+	Eth1DataVotes:               make([]*ethpb.Eth1Data, 0),
+	HistoricalRoots:             make([][]byte, 0),
+	JustificationBits:           bitfield.Bitvector4{0x0},
+	FinalizedCheckpoint:         &ethpb.Checkpoint{Root: make([]byte, 32)},
+	LatestBlockHeader:           HydrateBeaconHeader(&ethpb.BeaconBlockHeader{}),
 	PreviousEpochAttestations:   make([]*pb.PendingAttestation, 0),
 	CurrentEpochAttestations:    make([]*pb.PendingAttestation, 0),
 	PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},

slasher/db/kv/BUILD.bazel

@@ -60,6 +60,7 @@ go_test(
         "//proto/slashing:go_default_library",
         "//shared/bytesutil:go_default_library",
         "//shared/params:go_default_library",
+        "//shared/testutil:go_default_library",
         "//shared/testutil/assert:go_default_library",
         "//shared/testutil/require:go_default_library",
         "//slasher/db/types:go_default_library",

slasher/db/kv/proposer_slashings_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
 	"github.com/prysmaticlabs/prysm/shared/testutil/require"
 	"github.com/prysmaticlabs/prysm/slasher/db/types"
 	"gopkg.in/d4l3k/messagediff.v1"
@@ -18,24 +19,16 @@ func TestStore_ProposerSlashingNilBucket(t *testing.T) {
 	ctx := context.Background()
 
 	ps := &ethpb.ProposerSlashing{
-		Header_1: &ethpb.SignedBeaconBlockHeader{
+		Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 1,
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
-				BodyRoot:      make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
-		Header_2: &ethpb.SignedBeaconBlockHeader{
+		}),
+		Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 			Header: &ethpb.BeaconBlockHeader{
 				ProposerIndex: 1,
-				ParentRoot:    make([]byte, 32),
-				StateRoot:     make([]byte, 32),
-				BodyRoot:      make([]byte, 32),
 			},
-			Signature: make([]byte, 96),
-		},
+		}),
 	}
 	has, _, err := db.HasProposerSlashing(ctx, ps)
 	require.NoError(t, err)
@@ -59,70 +52,46 @@ func TestStore_SaveProposerSlashing(t *testing.T) {
 		{
 			ss: types.Active,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 1,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 1,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 		{
 			ss: types.Included,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 2,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 2,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 		{
 			ss: types.Reverted,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 3,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 3,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 	}
@@ -160,70 +129,46 @@ func TestStore_UpdateProposerSlashingStatus(t *testing.T) {
 		{
 			ss: types.Active,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 1,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 1,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 		{
 			ss: types.Active,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 2,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 2,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 		{
 			ss: types.Active,
 			ps: &ethpb.ProposerSlashing{
-				Header_1: &ethpb.SignedBeaconBlockHeader{
+				Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 3,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
-				Header_2: &ethpb.SignedBeaconBlockHeader{
+				}),
+				Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 					Header: &ethpb.BeaconBlockHeader{
 						ProposerIndex: 3,
-						ParentRoot:    make([]byte, 32),
-						StateRoot:     make([]byte, 32),
-						BodyRoot:      make([]byte, 32),
 					},
-					Signature: make([]byte, 96),
-				},
+				}),
 			},
 		},
 	}
@@ -255,64 +200,40 @@ func TestStore_SaveProposerSlashings(t *testing.T) {
 
 	ps := []*ethpb.ProposerSlashing{
 		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
+			Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
+			}),
+			Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 1,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
+			}),
 		},
 		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
+			Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 2,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
+			}),
+			Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 2,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
+			}),
 		},
 		{
-			Header_1: &ethpb.SignedBeaconBlockHeader{
+			Header_1: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
-			Header_2: &ethpb.SignedBeaconBlockHeader{
+			}),
+			Header_2: testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 				Header: &ethpb.BeaconBlockHeader{
 					ProposerIndex: 3,
-					ParentRoot:    make([]byte, 32),
-					StateRoot:     make([]byte, 32),
-					BodyRoot:      make([]byte, 32),
 				},
-				Signature: make([]byte, 96),
-			},
+			}),
 		},
 	}
 	err := db.SaveProposerSlashings(ctx, types.Active, ps)

slasher/rpc/server_test.go

@@ -202,16 +202,13 @@ func TestServer_IsSlashableBlock(t *testing.T) {
 		GenesisValidatorsRoot: bytesutil.PadTo([]byte("I am genesis"), 32),
 	}
 	nClient.EXPECT().GetGenesis(gomock.Any(), gomock.Any()).Return(wantedGenesis, nil).AnyTimes()
-	savedBlock := &ethpb.SignedBeaconBlockHeader{
+	savedBlock := testutil.HydrateSignedBeaconHeader(&ethpb.SignedBeaconBlockHeader{
 		Header: &ethpb.BeaconBlockHeader{
 			Slot:          1,
 			ProposerIndex: 1,
 			BodyRoot:      bytesutil.PadTo([]byte("body root"), 32),
-			StateRoot:     make([]byte, 32),
-			ParentRoot:    make([]byte, 32),
 		},
-		Signature: make([]byte, 96),
-	}
+	})
 
 	cfg := &detection.Config{
 		SlasherDB: db,

validator/client/attest.go

@@ -260,6 +260,7 @@ func (v *validator) waitOneThirdOrValidBlock(ctx context.Context, slot uint64) {
 			return
 
 		case <-t.C:
+			fmt.Println("Successfully waited 1/3. Slot ", slot)
 			return
 		}
 	}