Remove optional verifyTree argument (#3047)

* remove optional verifyTree argument

* remove fmt

* do not provide a default eth1data, return an error instead

* add a test for this new logic

* gaz

beacon-chain/blockchain/block_processing_test.go

@@ -67,7 +67,7 @@ func TestReceiveBlock_FaultyPOWChain(t *testing.T) {
 	chainService := setupBeaconChain(t, db, nil)
 	unixTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), unixTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), unixTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 
@@ -115,7 +115,7 @@ func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
 
 	chainService := setupBeaconChain(t, db, nil)
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -201,7 +201,7 @@ func TestReceiveBlock_UsesParentBlockState(t *testing.T) {
 
 	chainService := setupBeaconChain(t, db, nil)
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -275,7 +275,7 @@ func TestReceiveBlock_DeletesBadBlock(t *testing.T) {
 		&attestation.Config{BeaconDB: db})
 	chainService := setupBeaconChain(t, db, attsService)
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -360,7 +360,7 @@ func TestReceiveBlock_CheckBlockStateRoot_GoodState(t *testing.T) {
 		&attestation.Config{BeaconDB: db})
 	chainService := setupBeaconChain(t, db, attsService)
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -424,7 +424,7 @@ func TestReceiveBlock_CheckBlockStateRoot_BadState(t *testing.T) {
 	ctx := context.Background()
 	chainService := setupBeaconChain(t, db, nil)
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -491,7 +491,7 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
 		&attestation.Config{BeaconDB: db})
 	chainService := setupBeaconChain(t, db, attsService)
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -675,7 +675,7 @@ func TestReceiveBlock_OnChainSplit(t *testing.T) {
 
 	chainService := setupBeaconChain(t, db, nil)
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}
@@ -844,7 +844,7 @@ func TestIsBlockReadyForProcessing_ValidBlock(t *testing.T) {
 	chainService := setupBeaconChain(t, db, nil)
 	unixTime := uint64(time.Now().Unix())
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	if err := db.InitializeState(context.Background(), unixTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), unixTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 	beaconState, err := db.HeadState(ctx)

beacon-chain/blockchain/fork_choice_reorg_test.go

@@ -36,7 +36,7 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
 
 	ctx := context.Background()
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	justifiedState, err := state.GenesisBeaconState(deposits, 0, nil)
+	justifiedState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Can't generate genesis state: %v", err)
 	}

beacon-chain/blockchain/fork_choice_test.go

@@ -34,7 +34,7 @@ func TestApplyForkChoice_SetsCanonicalHead(t *testing.T) {
 	helpers.ClearAllCaches()
 
 	deposits, _ := testutil.SetupInitialDeposits(t, 5, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Cannot create genesis beacon state: %v", err)
 	}
@@ -100,7 +100,7 @@ func TestApplyForkChoice_SetsCanonicalHead(t *testing.T) {
 		}
 		unixTime := uint64(time.Now().Unix())
 		deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-		if err := beaconDb.InitializeState(context.Background(), unixTime, deposits, nil); err != nil {
+		if err := beaconDb.InitializeState(context.Background(), unixTime, deposits, &ethpb.Eth1Data{}); err != nil {
 			t.Fatalf("Could not initialize beacon state to disk: %v", err)
 		}
 

beacon-chain/blockchain/service_test.go

@@ -261,7 +261,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 
 	unixTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), unixTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), unixTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 	setupGenesisBlock(t, chainService)

beacon-chain/core/blocks/BUILD.bazel

@@ -44,7 +44,6 @@ go_test(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/state:go_default_library",
-        "//beacon-chain/core/state/stateutils:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//proto/eth/v1alpha1:go_default_library",
         "//shared/bls:go_default_library",

beacon-chain/core/blocks/block_operations.go

@@ -792,7 +792,7 @@ func ProcessDeposits(
 
 	valIndexMap := stateutils.ValidatorIndexMap(beaconState)
 	for _, deposit := range deposits {
-		beaconState, err = ProcessDeposit(beaconState, deposit, valIndexMap, verifySignatures, true)
+		beaconState, err = ProcessDeposit(beaconState, deposit, valIndexMap, verifySignatures)
 		if err != nil {
 			return nil, fmt.Errorf("could not process deposit from %#x: %v", bytesutil.Trunc(deposit.Data.PublicKey), err)
 		}
@@ -845,14 +845,8 @@ func ProcessDeposits(
 //         # Increase balance by deposit amount
 //         index = validator_pubkeys.index(pubkey)
 //         increase_balance(state, index, amount)
-func ProcessDeposit(
-	beaconState *pb.BeaconState,
-	deposit *ethpb.Deposit,
-	valIndexMap map[[32]byte]int,
-	verifySignatures bool,
-	verifyTree bool,
-) (*pb.BeaconState, error) {
-	if err := verifyDeposit(beaconState, deposit, verifyTree); err != nil {
+func ProcessDeposit(beaconState *pb.BeaconState, deposit *ethpb.Deposit, valIndexMap map[[32]byte]int, verifySignatures bool) (*pb.BeaconState, error) {
+	if err := verifyDeposit(beaconState, deposit); err != nil {
 		return nil, fmt.Errorf("could not verify deposit from #%x: %v", bytesutil.Trunc(deposit.Data.PublicKey), err)
 	}
 	beaconState.Eth1DepositIndex++
@@ -888,25 +882,23 @@ func ProcessDeposit(
 	return beaconState, nil
 }
 
-func verifyDeposit(beaconState *pb.BeaconState, deposit *ethpb.Deposit, verifyTree bool) error {
-	if verifyTree {
-		// Verify Merkle proof of deposit and deposit trie root.
-		receiptRoot := beaconState.Eth1Data.DepositRoot
-		leaf, err := hashutil.DepositHash(deposit.Data)
-		if err != nil {
-			return fmt.Errorf("could not tree hash deposit data: %v", err)
-		}
-		if ok := trieutil.VerifyMerkleProof(
+func verifyDeposit(beaconState *pb.BeaconState, deposit *ethpb.Deposit) error {
+	// Verify Merkle proof of deposit and deposit trie root.
+	receiptRoot := beaconState.Eth1Data.DepositRoot
+	leaf, err := hashutil.DepositHash(deposit.Data)
+	if err != nil {
+		return fmt.Errorf("could not tree hash deposit data: %v", err)
+	}
+	if ok := trieutil.VerifyMerkleProof(
+		receiptRoot,
+		leaf[:],
+		int(beaconState.Eth1DepositIndex),
+		deposit.Proof,
+	); !ok {
+		return fmt.Errorf(
+			"deposit merkle branch of deposit root did not verify for root: %#x",
 			receiptRoot,
-			leaf[:],
-			int(beaconState.Eth1DepositIndex),
-			deposit.Proof,
-		); !ok {
-			return fmt.Errorf(
-				"deposit merkle branch of deposit root did not verify for root: %#x",
-				receiptRoot,
-			)
-		}
+		)
 	}
 
 	return nil

beacon-chain/core/blocks/block_operations_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
-	"github.com/prysmaticlabs/prysm/beacon-chain/core/state/stateutils"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
@@ -338,7 +337,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 	helpers.ClearAllCaches()
 
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -372,7 +371,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
 
 func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T) {
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -893,7 +892,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -940,7 +939,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -982,7 +981,7 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1045,7 +1044,7 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1109,7 +1108,7 @@ func TestProcessAttestations_CrosslinkMismatches(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1180,7 +1179,7 @@ func TestProcessAttestations_OK(t *testing.T) {
 		},
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount/8, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1356,14 +1355,23 @@ func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
 	}
 }
 
-func TestProcessDeposits_ProcessCorrectly(t *testing.T) {
+func TestProcessDeposits_AddsNewValidatorDeposit(t *testing.T) {
+	sk, err := bls.RandKey(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
-			PublicKey: []byte{1, 2, 3},
+			PublicKey: sk.PublicKey().Marshal(),
 			Amount:    params.BeaconConfig().MaxEffectiveBalance,
-			Signature: make([]byte, 96),
 		},
 	}
+	sr, err := ssz.SigningRoot(deposit.Data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := sk.Sign(sr[:], 3)
+	deposit.Data.Signature = sig.Marshal()
 	leaf, err := hashutil.DepositHash(deposit.Data)
 	if err != nil {
 		t.Fatal(err)
@@ -1413,140 +1421,81 @@ func TestProcessDeposits_ProcessCorrectly(t *testing.T) {
 		t.Errorf(
 			"Expected state validator balances index 0 to equal %d, received %d",
 			deposit.Data.Amount,
-			newState.Balances[0],
+			newState.Balances[1],
 		)
 	}
 }
 
-func TestProcessDeposit_RepeatedDeposit(t *testing.T) {
+func TestProcessDeposit_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T) {
+	sk, err := bls.RandKey(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	deposit := &ethpb.Deposit{
+		Data: &ethpb.Deposit_Data{
+			PublicKey: sk.PublicKey().Marshal(),
+			Amount:    1000,
+		},
+	}
+	sr, err := ssz.SigningRoot(deposit.Data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := sk.Sign(sr[:], 3)
+	deposit.Data.Signature = sig.Marshal()
+	leaf, err := hashutil.DepositHash(deposit.Data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We then create a merkle branch for the test.
+	depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
+	if err != nil {
+		t.Fatalf("Could not generate trie: %v", err)
+	}
+	proof, err := depositTrie.MerkleProof(0)
+	if err != nil {
+		t.Fatalf("Could not generate proof: %v", err)
+	}
+
+	deposit.Proof = proof
+	block := &ethpb.BeaconBlock{
+		Body: &ethpb.BeaconBlockBody{
+			Deposits: []*ethpb.Deposit{deposit},
+		},
+	}
 	registry := []*ethpb.Validator{
 		{
 			PublicKey: []byte{1, 2, 3},
 		},
 		{
-			PublicKey:             []byte{4, 5, 6},
+			PublicKey:             sk.PublicKey().Marshal(),
 			WithdrawalCredentials: []byte{1},
 		},
 	}
 	balances := []uint64{0, 50}
+	root := depositTrie.Root()
 	beaconState := &pb.BeaconState{
-		Balances:   balances,
 		Validators: registry,
-	}
-
-	deposit := &ethpb.Deposit{
-		Proof: [][]byte{},
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             []byte{4, 5, 6},
-			WithdrawalCredentials: []byte{1},
-			Amount:                uint64(1000),
+		Balances:   balances,
+		Eth1Data: &ethpb.Eth1Data{
+			DepositRoot: root[:],
+			BlockHash:   root[:],
 		},
 	}
-
-	newState, err := blocks.ProcessDeposit(
+	newState, err := blocks.ProcessDeposits(
 		beaconState,
-		deposit,
-		stateutils.ValidatorIndexMap(beaconState),
-		false,
-		false,
+		block.Body,
+		false, /* verifySignatures */
 	)
 	if err != nil {
 		t.Fatalf("Process deposit failed: %v", err)
 	}
-	if newState.Balances[1] != 1050 {
+	if newState.Balances[1] != 1000+50 {
 		t.Errorf("Expected balance at index 1 to be 1050, received %d", newState.Balances[1])
 	}
 }
 
-func TestProcessDeposit_PublicKeyDoesNotExist(t *testing.T) {
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1, 2, 3},
-			WithdrawalCredentials: []byte{2},
-		},
-		{
-			PublicKey:             []byte{4, 5, 6},
-			WithdrawalCredentials: []byte{1},
-		},
-	}
-	balances := []uint64{1000, 1000}
-	beaconState := &pb.BeaconState{
-		Balances:   balances,
-		Validators: registry,
-	}
-
-	deposit := &ethpb.Deposit{
-		Proof: [][]byte{},
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             []byte{7, 8, 9},
-			WithdrawalCredentials: []byte{1},
-			Amount:                uint64(2000),
-		},
-	}
-
-	newState, err := blocks.ProcessDeposit(
-		beaconState,
-		deposit,
-		stateutils.ValidatorIndexMap(beaconState),
-		false,
-		false,
-	)
-	if err != nil {
-		t.Fatalf("Process deposit failed: %v", err)
-	}
-	if len(newState.Balances) != 3 {
-		t.Errorf("Expected validator balances list to increase by 1, received len %d", len(newState.Balances))
-	}
-	if newState.Balances[2] != 2000 {
-		t.Errorf("Expected new validator have balance of %d, received %d", 2000, newState.Balances[2])
-	}
-}
-
-func TestProcessDeposit_PublicKeyDoesNotExistAndEmptyValidator(t *testing.T) {
-	registry := []*ethpb.Validator{
-		{
-			PublicKey:             []byte{1, 2, 3},
-			WithdrawalCredentials: []byte{2},
-		},
-		{
-			PublicKey:             []byte{4, 5, 6},
-			WithdrawalCredentials: []byte{1},
-		},
-	}
-	balances := []uint64{0, 1000}
-	beaconState := &pb.BeaconState{
-		Slot:       params.BeaconConfig().SlotsPerEpoch,
-		Balances:   balances,
-		Validators: registry,
-	}
-
-	deposit := &ethpb.Deposit{
-		Proof: [][]byte{},
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             []byte{7, 8, 9},
-			WithdrawalCredentials: []byte{1},
-			Amount:                uint64(2000),
-		},
-	}
-
-	newState, err := blocks.ProcessDeposit(
-		beaconState,
-		deposit,
-		stateutils.ValidatorIndexMap(beaconState),
-		false,
-		false,
-	)
-	if err != nil {
-		t.Fatalf("Process deposit failed: %v", err)
-	}
-	if len(newState.Balances) != 3 {
-		t.Errorf("Expected validator balances list to be 3, received len %d", len(newState.Balances))
-	}
-	if newState.Balances[len(newState.Balances)-1] != 2000 {
-		t.Errorf("Expected validator at last index to have balance of %d, received %d", 2000, newState.Balances[0])
-	}
-}
-
 func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) {
 	exits := []*ethpb.VoluntaryExit{
 		{

beacon-chain/core/blocks/spectest/deposit_test.go

@@ -41,7 +41,7 @@ func runDepositTest(t *testing.T, filename string) {
 			}
 
 			valMap := stateutils.ValidatorIndexMap(tt.Pre)
-			post, err := blocks.ProcessDeposit(tt.Pre, tt.Deposit, valMap, true, true)
+			post, err := blocks.ProcessDeposit(tt.Pre, tt.Deposit, valMap, true)
 			// Note: This doesn't test anything worthwhile. It essentially tests
 			// that *any* error has occurred, not any specific error.
 			if tt.Post == nil {

beacon-chain/core/helpers/attestation_test.go

@@ -16,7 +16,7 @@ func TestAttestationDataSlot_OK(t *testing.T) {
 	db := internal.SetupDB(t)
 	defer internal.TeardownDB(t, db)
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), uint64(0), deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), uint64(0), deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 	beaconState, err := db.HeadState(context.Background())
@@ -65,7 +65,7 @@ func TestAttestationDataSlot_ReturnsErrorWithErroneousTargetEpoch(t *testing.T)
 	db := internal.SetupDB(t)
 	defer internal.TeardownDB(t, db)
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), uint64(0), deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), uint64(0), deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 	beaconState, err := db.HeadState(context.Background())
@@ -85,7 +85,7 @@ func TestAttestationDataSlot_ReturnsErrorWhenTargetEpochLessThanCurrentEpoch(t *
 	db := internal.SetupDB(t)
 	defer internal.TeardownDB(t, db)
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), uint64(0), deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), uint64(0), deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
 	beaconState, err := db.HeadState(context.Background())

beacon-chain/core/state/state.go

@@ -4,6 +4,7 @@
 package state
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/prysmaticlabs/go-ssz"
@@ -90,7 +91,7 @@ func GenesisBeaconState(deposits []*ethpb.Deposit, genesisTime uint64, eth1Data
 	slashings := make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector)
 
 	if eth1Data == nil {
-		eth1Data = &ethpb.Eth1Data{}
+		return nil, errors.New("no eth1data provided for genesis state")
 	}
 
 	eth1Data.DepositCount = uint64(len(deposits))
@@ -184,13 +185,7 @@ func GenesisBeaconState(deposits []*ethpb.Deposit, genesisTime uint64, eth1Data
 	depositRoot := trie.Root()
 	state.Eth1Data.DepositRoot = depositRoot[:]
 	for i, deposit := range deposits {
-		state, err = b.ProcessDeposit(
-			state,
-			deposit,
-			validatorMap,
-			false, /* verify signature */
-			false, /* verify tree */
-		)
+		state, err = b.ProcessDeposit(state, deposit, validatorMap, false)
 		if err != nil {
 			return nil, fmt.Errorf("could not process validator deposit %d: %v", i, err)
 		}

beacon-chain/core/state/state_test.go

@@ -203,7 +203,7 @@ func TestGenesisState_HashEquality(t *testing.T) {
 
 func TestGenesisState_InitializesLatestBlockHashes(t *testing.T) {
 	helpers.ClearAllCaches()
-	s, err := state.GenesisBeaconState(nil, 0, nil)
+	s, err := state.GenesisBeaconState(nil, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Error(err)
 	}
@@ -223,3 +223,11 @@ func TestGenesisState_InitializesLatestBlockHashes(t *testing.T) {
 		}
 	}
 }
+
+func TestGenesisState_FailsWithoutEth1data(t *testing.T) {
+	helpers.ClearAllCaches()
+	_, err := state.GenesisBeaconState(nil, 0, nil)
+	if err == nil || err.Error() != "no eth1data provided for genesis state" {
+		t.Errorf("Did not receive eth1data error with nil eth1data, got %v", err)
+	}
+}

beacon-chain/core/state/transition_test.go

@@ -39,7 +39,7 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
 
 func TestExecuteStateTransition_FullProcess(t *testing.T) {
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -89,7 +89,7 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
 func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 	helpers.ClearAllCaches()
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -139,7 +139,7 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
 
 func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
 	deposits, privKeys := testutil.SetupInitialDeposits(t, 100, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -259,7 +259,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 	helpers.ClearAllCaches()
 
 	deposits, _ := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount/8, false)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -378,7 +378,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
 
 func TestProcessBlock_PassesProcessingConditions(t *testing.T) {
 	deposits, privKeys := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount/8, true)
-	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), nil)
+	beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}

beacon-chain/db/block_test.go

@@ -240,7 +240,7 @@ func TestUpdateChainHead_NoBlock(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 10, false)
-	err := db.InitializeState(context.Background(), genesisTime, deposits, nil)
+	err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("failed to initialize state: %v", err)
 	}
@@ -262,7 +262,7 @@ func TestUpdateChainHead_OK(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 10, false)
-	err := db.InitializeState(context.Background(), genesisTime, deposits, nil)
+	err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("failed to initialize state: %v", err)
 	}
@@ -329,7 +329,7 @@ func TestChainProgress_OK(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	err := db.InitializeState(context.Background(), genesisTime, deposits, nil)
+	err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("failed to initialize state: %v", err)
 	}

beacon-chain/db/state_test.go

@@ -28,7 +28,7 @@ func TestInitializeState_OK(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 10, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 	b, err := db.ChainHead()
@@ -71,7 +71,7 @@ func TestFinalizeState_OK(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 20, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 
@@ -101,7 +101,7 @@ func BenchmarkState_ReadingFromCache(b *testing.B) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(b, 10, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		b.Fatalf("Failed to initialize state: %v", err)
 	}
 

beacon-chain/rpc/proposer_server_test.go

@@ -36,7 +36,7 @@ func TestProposeBlock_OK(t *testing.T) {
 
 	numDeposits := params.BeaconConfig().MinGenesisActiveValidatorCount
 	deposits, _ := testutil.SetupInitialDeposits(t, numDeposits, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Could not instantiate genesis state: %v", err)
 	}
@@ -71,7 +71,7 @@ func TestComputeStateRoot_OK(t *testing.T) {
 	mockChain := &mockChainService{}
 
 	deposits, _ := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Could not instantiate genesis state: %v", err)
 	}

beacon-chain/rpc/validator_server_test.go

@@ -98,7 +98,7 @@ func TestNextEpochCommitteeAssignment_WrongPubkeyLength(t *testing.T) {
 	helpers.ClearAllCaches()
 
 	deposits, _ := testutil.SetupInitialDeposits(t, 8, false)
-	beaconState, err := state.GenesisBeaconState(deposits, 0, nil)
+	beaconState, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -134,7 +134,7 @@ func TestNextEpochCommitteeAssignment_CantFindValidatorIdx(t *testing.T) {
 		t.Fatalf("Could not save genesis block: %v", err)
 	}
 	deposits, _ := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount, false)
-	state, err := state.GenesisBeaconState(deposits, 0, nil)
+	state, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Could not setup genesis state: %v", err)
 	}
@@ -168,7 +168,7 @@ func TestCommitteeAssignment_OK(t *testing.T) {
 	depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount / 16
 
 	deposits, _ := testutil.SetupInitialDeposits(t, depChainStart, false)
-	state, err := state.GenesisBeaconState(deposits, 0, nil)
+	state, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Could not setup genesis state: %v", err)
 	}
@@ -246,7 +246,7 @@ func TestCommitteeAssignment_multipleKeys_OK(t *testing.T) {
 	}
 	depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount / 16
 	deposits, _ := testutil.SetupInitialDeposits(t, depChainStart, false)
-	state, err := state.GenesisBeaconState(deposits, 0, nil)
+	state, err := state.GenesisBeaconState(deposits, 0, &ethpb.Eth1Data{})
 	if err != nil {
 		t.Fatalf("Could not setup genesis state: %v", err)
 	}
@@ -1013,5 +1013,5 @@ func genesisState(validators uint64) (*pbp2p.BeaconState, error) {
 
 		deposits[i] = &ethpb.Deposit{Data: depositData}
 	}
-	return state.GenesisBeaconState(deposits, uint64(genesisTime), nil)
+	return state.GenesisBeaconState(deposits, uint64(genesisTime), &ethpb.Eth1Data{})
 }

beacon-chain/sync/initial-sync/service_test.go

@@ -92,7 +92,7 @@ func setUpGenesisStateAndBlock(beaconDB *db.BeaconDB, t *testing.T) {
 	ctx := context.Background()
 	genesisTime := time.Now()
 	unixTime := uint64(genesisTime.Unix())
-	if err := beaconDB.InitializeState(context.Background(), unixTime, []*ethpb.Deposit{}, nil); err != nil {
+	if err := beaconDB.InitializeState(context.Background(), unixTime, []*ethpb.Deposit{}, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("could not initialize beacon state to disk: %v", err)
 	}
 	beaconState, err := beaconDB.HeadState(ctx)

beacon-chain/sync/regular_sync_test.go

@@ -183,7 +183,7 @@ func TestProcessBlock_OK(t *testing.T) {
 	}
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 
@@ -261,7 +261,7 @@ func TestProcessBlock_MultipleBlocksProcessedOK(t *testing.T) {
 	}
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatal(err)
 	}
 
@@ -657,7 +657,7 @@ func TestHandleStateReq_NOState(t *testing.T) {
 
 	genesisTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), genesisTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), genesisTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 

beacon-chain/sync/service_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/prysmaticlabs/prysm/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/beacon-chain/internal"
+	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
 	"github.com/prysmaticlabs/prysm/shared/featureconfig"
 	"github.com/prysmaticlabs/prysm/shared/testutil"
 )
@@ -46,7 +47,7 @@ func setupTestSyncService(t *testing.T, synced bool) (*Service, *db.BeaconDB) {
 
 	unixTime := uint64(time.Now().Unix())
 	deposits, _ := testutil.SetupInitialDeposits(t, 100, false)
-	if err := db.InitializeState(context.Background(), unixTime, deposits, nil); err != nil {
+	if err := db.InitializeState(context.Background(), unixTime, deposits, &ethpb.Eth1Data{}); err != nil {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}