Add back error handling

beacon-chain/blockchain/forkchoice/process_block_test.go

@@ -125,7 +125,10 @@ func TestStore_UpdateBlockAttestationVote(t *testing.T) {
 	defer testDB.TeardownDB(t, db)
 	params.UseMinimalConfig()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	store := NewForkChoiceService(ctx, db)
 	r := [32]byte{'A'}
@@ -168,7 +171,10 @@ func TestStore_UpdateBlockAttestationsVote(t *testing.T) {
 	defer testDB.TeardownDB(t, db)
 	params.UseMinimalConfig()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	store := NewForkChoiceService(ctx, db)
 	r := [32]byte{'A'}

beacon-chain/blockchain/receive_block_test.go

@@ -20,10 +20,12 @@ func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
 	db := testDB.SetupDB(t)
 	defer testDB.TeardownDB(t, db)
 	ctx := context.Background()
-
 	chainService := setupBeaconChain(t, db)
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	genesis, _ := testutil.GenerateFullBlock(beaconState, privKeys, nil, beaconState.Slot+1)
 	beaconState, err := state.ExecuteStateTransition(ctx, beaconState, genesis)
 	if err != nil {
@@ -133,7 +135,10 @@ func TestReceiveBlockNoPubsubForkchoice_ProcessCorrectly(t *testing.T) {
 	ctx := context.Background()
 
 	chainService := setupBeaconChain(t, db)
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, beaconState.Slot)
 	if err != nil {

beacon-chain/blockchain/service_test.go

@@ -240,7 +240,10 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
 
 	// Set up 10 deposits pre chain start for validators to register
 	count := uint64(10)
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(count)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(count)
+	if err != nil {
+		t.Fatal(err)
+	}
 	if err := bc.initializeBeaconChain(ctx, time.Unix(0, 0), deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatal(err)
 	}

beacon-chain/core/blocks/block_operations_test.go

@@ -31,7 +31,10 @@ func init() {
 }
 
 func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.LatestBlockHeader = &ethpb.BeaconBlockHeader{Slot: 9}
 
 	lbhsr, err := ssz.SigningRoot(beaconState.LatestBlockHeader)
@@ -274,7 +277,10 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	// We fetch the proposer's index as that is whom the RANDAO will be verified against.
 	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
 	if err != nil {
@@ -303,7 +309,10 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 }
 
 func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	epoch := helpers.CurrentEpoch(beaconState)
 	epochSignature, err := testutil.RandaoReveal(beaconState, epoch, privKeys)
@@ -474,7 +483,10 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	// We test the case when data is correct and verify the validator
 	// registry has been updated.
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	proposerIdx := uint64(1)
 
 	domain := helpers.Domain(beaconState.Fork, 0, params.BeaconConfig().DomainBeaconProposer)
@@ -647,7 +659,10 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 }
 
 func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	for _, vv := range beaconState.Validators {
 		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
 	}
@@ -743,7 +758,10 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 			Attestations: attestations,
 		},
 	}
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	want := fmt.Sprintf(
 		"attestation slot %d + inclusion delay %d > state slot %d",
@@ -770,7 +788,10 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 			Attestations: []*ethpb.Attestation{att},
 		},
 	}
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	helpers.ClearAllCaches()
 	beaconState.Slot += params.BeaconConfig().SlotsPerEpoch*4 + params.BeaconConfig().MinAttestationInclusionDelay
 	beaconState.PreviousJustifiedCheckpoint.Root = []byte("hello-world")
@@ -807,7 +828,10 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 			Attestations: attestations,
 		},
 	}
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.Slot += params.BeaconConfig().MinAttestationInclusionDelay
 	beaconState.CurrentJustifiedCheckpoint.Root = []byte("hello-world")
 	beaconState.CurrentEpochAttestations = []*pb.PendingAttestation{}
@@ -836,7 +860,11 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 
 func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 	helpers.ClearAllCaches()
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	aggBits := bitfield.NewBitlist(3)
 	aggBits.SetBitAt(0, true)
@@ -890,7 +918,10 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	aggBits := bitfield.NewBitlist(4)
 	custodyBits := bitfield.NewBitlist(4)
@@ -914,7 +945,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 	beaconState.CurrentEpochAttestations = []*pb.PendingAttestation{}
 
 	expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
-	_, err := blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
+	_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
 	if !strings.Contains(err.Error(), expected) {
 		t.Errorf("Did not receive wanted error")
 	}
@@ -923,7 +954,10 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
 func TestProcessAttestations_OK(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	aggBits := bitfield.NewBitlist(3)
 	aggBits.SetBitAt(0, true)
@@ -976,7 +1010,10 @@ func TestProcessAttestations_OK(t *testing.T) {
 func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	domain := helpers.Domain(beaconState.Fork, 0, params.BeaconConfig().DomainBeaconAttester)
 	data := &ethpb.AttestationData{
@@ -1053,7 +1090,10 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
 
 func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
 	helpers.ClearAllCaches()
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(300)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(300)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	domain := helpers.Domain(beaconState.Fork, 0, params.BeaconConfig().DomainBeaconAttester)
 	data := &ethpb.AttestationData{
@@ -1142,7 +1182,10 @@ func TestProcessAttestationsNoVerify_OK(t *testing.T) {
 	// Attestation with an empty signature
 	helpers.ClearAllCaches()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	aggBits := bitfield.NewBitlist(3)
 	aggBits.SetBitAt(1, true)
@@ -1244,7 +1287,10 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 
 	numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch
 	validators := make([]*ethpb.Validator, numOfValidators)
-	_, keys, _ := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	_, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators)
+	if err != nil {
+		t.Fatal(err)
+	}
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
@@ -1388,7 +1434,10 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 }
 
 func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
-	dep, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
 	if err != nil {
 		t.Fatal(err)
@@ -1493,7 +1542,10 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
 
 func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
 	//Similar to TestProcessDeposits_AddsNewValidatorDeposit except that this test directly calls ProcessDeposit
-	dep, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(dep))
 	if err != nil {
 		t.Fatal(err)
@@ -1540,7 +1592,10 @@ func TestProcessDeposit_AddsNewValidatorDeposit(t *testing.T) {
 
 func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 	// Same test settings as in TestProcessDeposit_AddsNewValidatorDeposit, except that we use an invalid signature
-	dep, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	dep, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	dep[0].Data.Signature = make([]byte, 96)
 	trie, _, err := testutil.DepositTrieFromDeposits(dep)
 	if err != nil {

beacon-chain/core/epoch/precompute/attestation_test.go

@@ -73,7 +73,11 @@ func TestUpdateBalance(t *testing.T) {
 
 func TestSameHead(t *testing.T) {
 	helpers.ClearAllCaches()
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	beaconState.Slot = 1
 	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 0}}}
@@ -98,7 +102,10 @@ func TestSameHead(t *testing.T) {
 }
 
 func TestSameTarget(t *testing.T) {
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.Slot = 1
 	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 0}}}
@@ -123,7 +130,10 @@ func TestSameTarget(t *testing.T) {
 }
 
 func TestAttestedPrevEpoch(t *testing.T) {
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.Slot = params.BeaconConfig().SlotsPerEpoch
 	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 0}}}
@@ -147,7 +157,10 @@ func TestAttestedPrevEpoch(t *testing.T) {
 }
 
 func TestAttestedCurrentEpoch(t *testing.T) {
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.Slot = params.BeaconConfig().SlotsPerEpoch + 1
 	att := &ethpb.Attestation{Data: &ethpb.AttestationData{
 		Target: &ethpb.Checkpoint{Epoch: 1}}}
@@ -174,7 +187,10 @@ func TestProcessAttestations(t *testing.T) {
 	defer params.UseMainnetConfig()
 
 	validators := uint64(64)
-	beaconState, _, _ := testutil.DeterministicGenesisState(validators)
+	beaconState, _, err := testutil.DeterministicGenesisState(validators)
+	if err != nil {
+		t.Fatal(err)
+	}
 	beaconState.Slot = params.BeaconConfig().SlotsPerEpoch
 
 	bf := []byte{0xff}
@@ -198,7 +214,7 @@ func TestProcessAttestations(t *testing.T) {
 		vp[i] = &precompute.Validator{CurrentEpochEffectiveBalance: 100}
 	}
 	bp := &precompute.Balance{}
-	vp, bp, err := precompute.ProcessAttestations(context.Background(), beaconState, vp, bp)
+	vp, bp, err = precompute.ProcessAttestations(context.Background(), beaconState, vp, bp)
 	if err != nil {
 		t.Fatal(err)
 	}

beacon-chain/core/helpers/attestation_test.go

@@ -227,7 +227,10 @@ func TestSlotSignature_Verify(t *testing.T) {
 }
 
 func TestIsAggregator_True(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	sig := privKeys[0].Sign([]byte{}, 0)
 	agg, err := helpers.IsAggregator(beaconState, 0, 0, sig)
 	if err != nil {
@@ -241,7 +244,10 @@ func TestIsAggregator_True(t *testing.T) {
 func TestIsAggregator_False(t *testing.T) {
 	params.UseMinimalConfig()
 	defer params.UseMainnetConfig()
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(2048)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(2048)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	sig := privKeys[0].Sign([]byte{}, 0)
 	agg, err := helpers.IsAggregator(beaconState, 0, 0, sig)

beacon-chain/core/state/skip_slot_cache_test.go

@@ -14,7 +14,11 @@ import (
 )
 
 func TestSkipSlotCache_OK(t *testing.T) {
-	bState, privs, _ := testutil.DeterministicGenesisState(params.MinimalSpecConfig().MinGenesisActiveValidatorCount)
+	bState, privs, err := testutil.DeterministicGenesisState(params.MinimalSpecConfig().MinGenesisActiveValidatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	originalState := proto.Clone(bState).(*pb.BeaconState)
 
 	blkCfg := testutil.DefaultBlockGenConfig()

beacon-chain/core/state/state_test.go

@@ -42,7 +42,10 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 	}
 
 	genesisTime := uint64(99999)
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(uint64(depositsForChainStart))
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(uint64(depositsForChainStart))
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -131,7 +134,10 @@ func TestGenesisBeaconState_OK(t *testing.T) {
 
 func TestGenesisState_HashEquality(t *testing.T) {
 	helpers.ClearAllCaches()
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(100)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	state1, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{BlockHash: make([]byte, 32)})
 	if err != nil {
 		t.Error(err)

beacon-chain/core/state/transition_test.go

@@ -39,7 +39,10 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
 func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	eth1Data := &ethpb.Eth1Data{
 		DepositCount: 100,
@@ -102,7 +105,10 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
 	if err != nil {
@@ -139,7 +145,10 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 }
 
 func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	att := &ethpb.Attestation{
 		Data: &ethpb.AttestationData{
@@ -183,7 +192,10 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
 func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(100)
+	beaconState, _, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	proposerSlashings := []*ethpb.ProposerSlashing{
 		{
@@ -272,7 +284,10 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 }
 
 func TestProcessBlock_PassesProcessingConditions(t *testing.T) {
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(32)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(32)
+	if err != nil {
+		t.Fatal(err)
+	}
 	genesisBlock := blocks.NewGenesisBlock([]byte{})
 	bodyRoot, err := ssz.HashTreeRoot(genesisBlock)
 	if err != nil {
@@ -774,7 +789,10 @@ func TestProcessBlk_AttsBasedOnValidatorCount(t *testing.T) {
 
 	// Default at 256 validators, can raise this number with faster BLS.
 	validatorCount := uint64(256)
-	s, privKeys, _ := testutil.DeterministicGenesisState(validatorCount)
+	s, privKeys, err := testutil.DeterministicGenesisState(validatorCount)
+	if err != nil {
+		t.Fatal(err)
+	}
 	s.Slot = params.BeaconConfig().SlotsPerEpoch
 
 	bitCount := validatorCount / params.BeaconConfig().SlotsPerEpoch
@@ -834,7 +852,8 @@ func TestProcessBlk_AttsBasedOnValidatorCount(t *testing.T) {
 	config.MinAttestationInclusionDelay = 0
 	params.OverrideBeaconConfig(config)
 
-	if _, err := state.ProcessBlock(context.Background(), s, blk); err != nil {
+	_, err = state.ProcessBlock(context.Background(), s, blk)
+	if err != nil {
 		t.Fatal(err)
 	}
 }

beacon-chain/operations/attestation_test.go

@@ -28,7 +28,10 @@ func TestHandleAttestation_Saves_NewAttestation(t *testing.T) {
 		BeaconDB: beaconDB,
 	})
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	att := &ethpb.Attestation{
 		Data: &ethpb.AttestationData{
@@ -114,7 +117,10 @@ func TestHandleAttestation_Aggregates_LargeNumValidators(t *testing.T) {
 	}
 
 	// We setup the genesis state with 256 validators.
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(256)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(256)
+	if err != nil {
+		t.Fatal(err)
+	}
 	stateRoot, err := ssz.HashTreeRoot(beaconState)
 	if err != nil {
 		t.Fatal(err)
@@ -199,7 +205,10 @@ func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T)
 	})
 	service.attestationPool = make(map[[32]byte]*dbpb.AttestationContainer)
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(200)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(200)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	beaconState.CurrentJustifiedCheckpoint.Root = []byte("hello-world")
 
@@ -339,7 +348,11 @@ func TestRetrieveAttestations_OK(t *testing.T) {
 	service := NewService(context.Background(), &Config{BeaconDB: beaconDB})
 	service.attestationPool = make(map[[32]byte]*dbpb.AttestationContainer)
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(32)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(32)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	aggBits := bitfield.NewBitlist(1)
 	aggBits.SetBitAt(0, true)
 	custodyBits := bitfield.NewBitlist(1)

beacon-chain/powchain/deposit_test.go

@@ -28,7 +28,10 @@ func TestProcessDeposit_OK(t *testing.T) {
 	}
 	web3Service = setDefaultMocks(web3Service)
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
@@ -54,7 +57,10 @@ func TestProcessDeposit_InvalidMerkleBranch(t *testing.T) {
 	}
 	web3Service = setDefaultMocks(web3Service)
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
@@ -86,7 +92,10 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
 	}
 	web3Service = setDefaultMocks(web3Service)
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	deposits[0].Data.PublicKey = []byte("junk")
 
 	leaf, err := ssz.HashTreeRoot(deposits[0].Data)
@@ -129,7 +138,10 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) {
 	}
 	web3Service = setDefaultMocks(web3Service)
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	var fakeSig [96]byte
 	copy(fakeSig[:], []byte{'F', 'A', 'K', 'E'})
 	deposits[0].Data.Signature = fakeSig[:]
@@ -174,7 +186,10 @@ func TestProcessDeposit_UnableToVerify(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	testutil.ResetCache()
 
-	deposits, keys, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, keys, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	sig := keys[0].Sign([]byte{'F', 'A', 'K', 'E'}, bls.ComputeDomain(params.BeaconConfig().DomainDeposit))
 	deposits[0].Data.Signature = sig.Marshal()[:]
 
@@ -271,7 +286,10 @@ func TestProcessDeposit_AllDepositedSuccessfully(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	testutil.ResetCache()
 
-	deposits, keys, _ := testutil.DeterministicDepositsAndKeys(10)
+	deposits, keys, err := testutil.DeterministicDepositsAndKeys(10)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
 		t.Fatal(err)

beacon-chain/powchain/log_processing_test.go

@@ -50,7 +50,10 @@ func TestProcessDepositLog_OK(t *testing.T) {
 	}
 
 	testAcc.Backend.Commit()
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -117,7 +120,10 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
 
 	testAcc.Backend.Commit()
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -183,7 +189,10 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
 		t.Fatalf("Could not init from contract: %v", err)
 	}
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -259,7 +268,10 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 	testAcc.Backend.Commit()
 	testAcc.Backend.AdjustTime(time.Duration(int64(time.Now().Nanosecond())))
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(1)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -331,7 +343,10 @@ func TestProcessETH2GenesisLog(t *testing.T) {
 	testAcc.Backend.Commit()
 	testAcc.Backend.AdjustTime(time.Duration(int64(time.Now().Nanosecond())))
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(uint64(depositsReqForChainStart))
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(uint64(depositsReqForChainStart))
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	_, roots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
@@ -446,7 +461,10 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 
 	totalNumOfDeposits := depositsReqForChainStart + 30
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(uint64(totalNumOfDeposits))
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(uint64(totalNumOfDeposits))
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -536,7 +554,10 @@ func TestWeb3ServiceProcessDepositLog_RequestMissedDeposits(t *testing.T) {
 	testAcc.Backend.Commit()
 	testAcc.Backend.AdjustTime(time.Duration(int64(time.Now().Nanosecond())))
 	depositsWanted := 10
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(uint64(depositsWanted))
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(uint64(depositsWanted))
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, depositRoots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)

beacon-chain/rpc/proposer/server_test.go

@@ -39,7 +39,10 @@ func TestProposeBlock_OK(t *testing.T) {
 	}
 
 	numDeposits := params.BeaconConfig().MinGenesisActiveValidatorCount
-	beaconState, _, _ := testutil.DeterministicGenesisState(numDeposits)
+	beaconState, _, err := testutil.DeterministicGenesisState(numDeposits)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	genesisRoot, err := ssz.SigningRoot(genesis)
 	if err != nil {
@@ -79,7 +82,10 @@ func TestComputeStateRoot_OK(t *testing.T) {
 	ctx := context.Background()
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := testutil.DeterministicGenesisState(100)
+	beaconState, privKeys, err := testutil.DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	stateRoot, err := ssz.HashTreeRoot(beaconState)
 	if err != nil {

beacon-chain/rpc/testing/beacon_chain_service_mock.go

@@ -6,10 +6,11 @@ package testing
 
 import (
 	context "context"
+	reflect "reflect"
+
 	gomock "github.com/golang/mock/gomock"
 	v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	metadata "google.golang.org/grpc/metadata"
-	reflect "reflect"
 )
 
 // MockBeaconChain_StreamChainHeadServer is a mock of BeaconChain_StreamChainHeadServer interface

beacon-chain/rpc/validator/assignments_test.go

@@ -26,7 +26,10 @@ func TestCommitteeAssignment_NextEpoch_WrongPubkeyLength(t *testing.T) {
 	ctx := context.Background()
 	helpers.ClearAllCaches()
 
-	beaconState, _, _ := testutil.DeterministicGenesisState(8)
+	beaconState, _, err := testutil.DeterministicGenesisState(8)
+	if err != nil {
+		t.Fatal(err)
+	}
 	block := blk.NewGenesisBlock([]byte{})
 	if err := db.SaveBlock(ctx, block); err != nil {
 		t.Fatalf("Could not save genesis block: %v", err)
@@ -55,8 +58,10 @@ func TestNextEpochCommitteeAssignment_CantFindValidatorIdx(t *testing.T) {
 	db := dbutil.SetupDB(t)
 	defer dbutil.TeardownDB(t, db)
 	ctx := context.Background()
-	beaconState, _, _ := testutil.DeterministicGenesisState(10)
-
+	beaconState, _, err := testutil.DeterministicGenesisState(10)
+	if err != nil {
+		t.Fatal(err)
+	}
 	genesis := blk.NewGenesisBlock([]byte{})
 	genesisRoot, err := ssz.SigningRoot(genesis)
 	if err != nil {
@@ -88,7 +93,10 @@ func TestCommitteeAssignment_OK(t *testing.T) {
 
 	genesis := blk.NewGenesisBlock([]byte{})
 	depChainStart := uint64(64)
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(depChainStart)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(depChainStart)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -164,7 +172,10 @@ func TestCommitteeAssignment_CurrentEpoch_ShouldNotFail(t *testing.T) {
 
 	genesis := blk.NewGenesisBlock([]byte{})
 	depChainStart := uint64(64)
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(depChainStart)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(depChainStart)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
 		t.Fatal(err)
@@ -225,7 +236,10 @@ func TestCommitteeAssignment_MultipleKeys_OK(t *testing.T) {
 
 	genesis := blk.NewGenesisBlock([]byte{})
 	depChainStart := uint64(64)
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(depChainStart)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(depChainStart)
+	if err != nil {
+		t.Fatal(err)
+	}
 	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
 	if err != nil {
 		t.Fatal(err)

beacon-chain/rpc/validator/server_test.go

@@ -339,7 +339,10 @@ func BenchmarkAssignment(b *testing.B) {
 		b.Fatalf("Could not save genesis block: %v", err)
 	}
 	validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount * 4
-	state, _, _ := testutil.DeterministicGenesisState(validatorCount)
+	state, _, err := testutil.DeterministicGenesisState(validatorCount)
+	if err != nil {
+		b.Fatalf("Could not setup genesis state: %v", err)
+	}
 	genesisRoot, err := ssz.SigningRoot(genesis)
 	if err != nil {
 		b.Fatalf("Could not get signing root %v", err)

beacon-chain/sync/validate_attester_slashing_test.go

@@ -19,7 +19,10 @@ import (
 )
 
 func setupValidAttesterSlashing(t *testing.T) (*ethpb.AttesterSlashing, *pb.BeaconState) {
-	state, privKeys, _ := testutil.DeterministicGenesisState(5)
+	state, privKeys, err := testutil.DeterministicGenesisState(5)
+	if err != nil {
+		t.Fatal(err)
+	}
 	for _, vv := range state.Validators {
 		vv.WithdrawableEpoch = 1 * params.BeaconConfig().SlotsPerEpoch
 	}

endtoend/validator.go

@@ -94,7 +94,10 @@ func initializeValidators(
 		t.Fatal(err)
 	}
 
-	deposits, _, _ := testutil.DeterministicDepositsAndKeys(validatorNum)
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(validatorNum)
+	if err != nil {
+		t.Fatal(err)
+	}
 	_, roots, err := testutil.DeterministicDepositTrie(len(deposits))
 	if err != nil {
 		t.Fatal(err)

proto/beacon/rpc/v1/slasher.pb.go

@@ -901,7 +901,7 @@ func (m *EpochSpanMap) MarshalTo(dAtA []byte) (int, error) {
 	var l int
 	_ = l
 	if len(m.EpochSpanMap) > 0 {
-		for k, _ := range m.EpochSpanMap {
+		for k := range m.EpochSpanMap {
 			dAtA[i] = 0xa
 			i++
 			v := m.EpochSpanMap[k]

shared/testutil/block_test.go

@@ -12,7 +12,10 @@ import (
 )
 
 func TestGenerateFullBlock_PassesStateTransition(t *testing.T) {
-	beaconState, privs, _ := DeterministicGenesisState(128)
+	beaconState, privs, err := DeterministicGenesisState(128)
+	if err != nil {
+		t.Fatal(err)
+	}
 	conf := &BlockGenConfig{
 		NumAttestations: 1,
 	}
@@ -30,7 +33,10 @@ func TestGenerateFullBlock_ThousandValidators(t *testing.T) {
 	helpers.ClearAllCaches()
 	params.OverrideBeaconConfig(params.MinimalSpecConfig())
 	defer params.OverrideBeaconConfig(params.MainnetConfig())
-	beaconState, privs, _ := DeterministicGenesisState(1024)
+	beaconState, privs, err := DeterministicGenesisState(1024)
+	if err != nil {
+		t.Fatal(err)
+	}
 	conf := &BlockGenConfig{
 		NumAttestations: 4,
 	}
@@ -49,7 +55,10 @@ func TestGenerateFullBlock_Passes4Epochs(t *testing.T) {
 	// Changing to minimal config as this will process 4 epochs of blocks.
 	params.OverrideBeaconConfig(params.MinimalSpecConfig())
 	defer params.OverrideBeaconConfig(params.MainnetConfig())
-	beaconState, privs, _ := DeterministicGenesisState(64)
+	beaconState, privs, err := DeterministicGenesisState(64)
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	conf := &BlockGenConfig{
 		NumAttestations: 2,
@@ -81,7 +90,10 @@ func TestGenerateFullBlock_Passes4Epochs(t *testing.T) {
 func TestGenerateFullBlock_ValidProposerSlashings(t *testing.T) {
 	params.OverrideBeaconConfig(params.MinimalSpecConfig())
 	defer params.OverrideBeaconConfig(params.MainnetConfig())
-	beaconState, privs, _ := DeterministicGenesisState(32)
+	beaconState, privs, err := DeterministicGenesisState(32)
+	if err != nil {
+		t.Fatal(err)
+	}
 	conf := &BlockGenConfig{
 		NumProposerSlashings: 1,
 	}
@@ -103,7 +115,10 @@ func TestGenerateFullBlock_ValidProposerSlashings(t *testing.T) {
 func TestGenerateFullBlock_ValidAttesterSlashings(t *testing.T) {
 	params.OverrideBeaconConfig(params.MinimalSpecConfig())
 	defer params.OverrideBeaconConfig(params.MainnetConfig())
-	beaconState, privs, _ := DeterministicGenesisState(32)
+	beaconState, privs, err := DeterministicGenesisState(32)
+	if err != nil {
+		t.Fatal(err)
+	}
 	conf := &BlockGenConfig{
 		NumAttesterSlashings: 1,
 	}
@@ -127,7 +142,10 @@ func TestGenerateFullBlock_ValidAttestations(t *testing.T) {
 	defer params.OverrideBeaconConfig(params.MainnetConfig())
 	helpers.ClearAllCaches()
 
-	beaconState, privs, _ := DeterministicGenesisState(256)
+	beaconState, privs, err := DeterministicGenesisState(256)
+	if err != nil {
+		t.Fatal(err)
+	}
 	conf := &BlockGenConfig{
 		NumAttestations: 4,
 	}
@@ -145,7 +163,10 @@ func TestGenerateFullBlock_ValidAttestations(t *testing.T) {
 }
 
 func TestGenerateFullBlock_ValidDeposits(t *testing.T) {
-	beaconState, privs, _ := DeterministicGenesisState(256)
+	beaconState, privs, err := DeterministicGenesisState(256)
+	if err != nil {
+		t.Fatal(err)
+	}
 	deposits, _, err := DeterministicDepositsAndKeys(257)
 	if err != nil {
 		t.Fatal(err)
@@ -179,7 +200,10 @@ func TestGenerateFullBlock_ValidDeposits(t *testing.T) {
 }
 
 func TestGenerateFullBlock_ValidVoluntaryExits(t *testing.T) {
-	beaconState, privs, _ := DeterministicGenesisState(256)
+	beaconState, privs, err := DeterministicGenesisState(256)
+	if err != nil {
+		t.Fatal(err)
+	}
 	// Moving the state 2048 epochs forward due to PERSISTENT_COMMITTEE_PERIOD.
 	beaconState.Slot = 3 + params.BeaconConfig().PersistentCommitteePeriod*params.BeaconConfig().SlotsPerEpoch
 	conf := &BlockGenConfig{

shared/testutil/helpers_test.go

@@ -13,8 +13,10 @@ import (
 func TestBlockSignature(t *testing.T) {
 	helpers.ClearAllCaches()
 
-	beaconState, privKeys, _ := DeterministicGenesisState(100)
-
+	beaconState, privKeys, err := DeterministicGenesisState(100)
+	if err != nil {
+		t.Fatal(err)
+	}
 	block, err := GenerateFullBlock(beaconState, privKeys, nil, 0)
 	if err != nil {
 		t.Fatal(err)