Attestation Using Head State instead of Latest State

beacon-chain/attestation/service.go

@@ -91,7 +91,7 @@ func (a *Service) IncomingAttestationFeed() *event.Feed {
 //		Attestation` be the attestation with the highest slot number in `store`
 //		from the validator with the given `validator_index`
 func (a *Service) LatestAttestation(ctx context.Context, index uint64) (*pb.Attestation, error) {
-	state, err := a.beaconDB.State(ctx)
+	state, err := a.beaconDB.HeadState(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -173,7 +173,7 @@ func (a *Service) handleAttestation(ctx context.Context, msg proto.Message) erro
 func (a *Service) UpdateLatestAttestation(ctx context.Context, attestation *pb.Attestation) error {
 	// Potential improvement, instead of getting the state,
 	// we could get a mapping of validator index to public key.
-	state, err := a.beaconDB.State(ctx)
+	state, err := a.beaconDB.HeadState(ctx)
 	if err != nil {
 		return err
 	}

beacon-chain/blockchain/block_processing_test.go

@@ -424,7 +424,7 @@ func TestIsBlockReadyForProcessing_ValidBlock(t *testing.T) {
 	if err := db.InitializeState(unixTime, deposits, &pb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("Can't get genesis state: %v", err)
 	}

beacon-chain/blockchain/service.go

@@ -77,7 +77,7 @@ func NewChainService(ctx context.Context, cfg *Config) (*ChainService, error) {
 
 // Start a blockchain service's main event loop.
 func (c *ChainService) Start() {
-	beaconState, err := c.beaconDB.State(c.ctx)
+	beaconState, err := c.beaconDB.HeadState(c.ctx)
 	if err != nil {
 		log.Fatalf("Could not fetch beacon state: %v", err)
 	}
@@ -138,7 +138,7 @@ func (c *ChainService) initializeBeaconChain(genesisTime time.Time, deposits []*
 	if err := c.beaconDB.InitializeState(unixTime, deposits, eth1data); err != nil {
 		return nil, fmt.Errorf("could not initialize beacon state to disk: %v", err)
 	}
-	beaconState, err := c.beaconDB.State(c.ctx)
+	beaconState, err := c.beaconDB.HeadState(c.ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not attempt fetch beacon state: %v", err)
 	}

beacon-chain/blockchain/service_test.go

@@ -251,7 +251,7 @@ func setupBeaconChain(t *testing.T, beaconDB *db.BeaconDB, attsService *attestat
 }
 
 func SetSlotInState(service *ChainService, slot uint64) error {
-	bState, err := service.beaconDB.State(context.Background())
+	bState, err := service.beaconDB.HeadState(context.Background())
 	if err != nil {
 		return err
 	}
@@ -281,7 +281,7 @@ func TestChainStartStop_Uninitialized(t *testing.T) {
 		)
 	}
 
-	beaconState, err := db.State(context.Background())
+	beaconState, err := db.HeadState(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -312,7 +312,7 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	if err := db.InitializeState(unixTime, deposits, &pb.Eth1Data{}); err != nil {
 		t.Fatalf("Could not initialize beacon state to disk: %v", err)
 	}
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("Could not fetch beacon state: %v", err)
 	}

beacon-chain/db/block_test.go

@@ -95,7 +95,7 @@ func TestUpdateChainHead_NoBlock(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to initialize state: %v", err)
 	}
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("failed to get beacon state: %v", err)
 	}
@@ -127,7 +127,7 @@ func TestUpdateChainHead_OK(t *testing.T) {
 		t.Fatalf("failed to get hash of b: %v", err)
 	}
 
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("failed to get beacon state: %v", err)
 	}
@@ -185,7 +185,7 @@ func TestChainProgress_OK(t *testing.T) {
 		t.Fatalf("failed to initialize state: %v", err)
 	}
 
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("Failed to get beacon state: %v", err)
 	}

beacon-chain/db/state.go

@@ -86,8 +86,8 @@ func (db *BeaconDB) InitializeState(genesisTime uint64, deposits []*pb.Deposit,
 	})
 }
 
-// State fetches the canonical beacon chain's state from the DB.
-func (db *BeaconDB) State(ctx context.Context) (*pb.BeaconState, error) {
+// HeadState fetches the canonical beacon chain's head state from the DB.
+func (db *BeaconDB) HeadState(ctx context.Context) (*pb.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.State")
 	defer span.End()
 
@@ -358,7 +358,7 @@ func createState(enc []byte) (*pb.BeaconState, error) {
 
 // GenesisTime returns the genesis timestamp for the state.
 func (db *BeaconDB) GenesisTime(ctx context.Context) (time.Time, error) {
-	state, err := db.State(ctx)
+	state, err := db.HeadState(ctx)
 	if err != nil {
 		return time.Time{}, fmt.Errorf("could not retrieve state: %v", err)
 	}

beacon-chain/db/state_test.go

@@ -55,7 +55,7 @@ func TestInitializeState_OK(t *testing.T) {
 		t.Fatalf("Expected block height to equal 1. Got %d", b.GetSlot())
 	}
 
-	beaconState, err := db.State(ctx)
+	beaconState, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("Failed to get state: %v", err)
 	}
@@ -67,7 +67,7 @@ func TestInitializeState_OK(t *testing.T) {
 		t.Fatalf("Failed to encode state: %v", err)
 	}
 
-	statePrime, err := db.State(ctx)
+	statePrime, err := db.HeadState(ctx)
 	if err != nil {
 		t.Fatalf("Failed to get state: %v", err)
 	}
@@ -120,7 +120,7 @@ func TestFinalizeState_OK(t *testing.T) {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 
-	state, err := db.State(context.Background())
+	state, err := db.HeadState(context.Background())
 	if err != nil {
 		t.Fatalf("Failed to retrieve state: %v", err)
 	}
@@ -150,7 +150,7 @@ func TestCurrentAndFinalizeState_OK(t *testing.T) {
 		t.Fatalf("Failed to initialize state: %v", err)
 	}
 
-	state, err := db.State(context.Background())
+	state, err := db.HeadState(context.Background())
 	if err != nil {
 		t.Fatalf("Failed to retrieve state: %v", err)
 	}
@@ -167,7 +167,7 @@ func TestCurrentAndFinalizeState_OK(t *testing.T) {
 		t.Fatalf("Unable to retrieve finalized state")
 	}
 
-	cState, err := db.State(context.Background())
+	cState, err := db.HeadState(context.Background())
 	if err != nil {
 		t.Fatalf("Unable to retrieve state")
 	}
@@ -192,7 +192,7 @@ func BenchmarkState_ReadingFromCache(b *testing.B) {
 		b.Fatalf("Failed to initialize state: %v", err)
 	}
 
-	state, err := db.State(ctx)
+	state, err := db.HeadState(ctx)
 	if err != nil {
 		b.Fatalf("Could not read DV beacon state from DB: %v", err)
 	}
@@ -210,7 +210,7 @@ func BenchmarkState_ReadingFromCache(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := db.State(ctx)
+		_, err := db.HeadState(ctx)
 		if err != nil {
 			b.Fatalf("Could not read beacon state from cache: %v", err)
 		}

beacon-chain/rpc/attester_server.go

@@ -46,22 +46,26 @@ func (as *AttesterServer) AttestationDataAtSlot(ctx context.Context, req *pb.Att
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve chain head: %v", err)
 	}
-	blockRoot, err := hashutil.HashBeaconBlock(head)
+	headRoot, err := hashutil.HashBeaconBlock(head)
 	if err != nil {
 		return nil, fmt.Errorf("could not tree hash beacon block: %v", err)
 	}
-	beaconState, err := as.beaconDB.State(ctx)
+
+	// Let head state be the state of head block processed through empty slots up to assigned slot.
+	headState, err := as.beaconDB.HeadState(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("could not fetch beacon state: %v", err)
+		return nil, fmt.Errorf("could not fetch head state: %v", err)
 	}
-	for beaconState.Slot < req.Slot {
-		beaconState, err = state.ExecuteStateTransition(
-			ctx, beaconState, nil /* block */, blockRoot, state.DefaultConfig(),
+
+	for headState.Slot < req.Slot {
+		headState, err = state.ExecuteStateTransition(
+			ctx, headState, nil /* block */, headRoot, state.DefaultConfig(),
 		)
 		if err != nil {
 			return nil, fmt.Errorf("could not execute head transition: %v", err)
 		}
 	}
+
 	// Fetch the epoch boundary root = hash_tree_root(epoch_boundary)
 	// where epoch_boundary is the block at the most recent epoch boundary in the
 	// chain defined by head -- i.e. the BeaconBlock where block.slot == get_epoch_start_slot(head.slot).
@@ -70,15 +74,12 @@ func (as *AttesterServer) AttestationDataAtSlot(ctx context.Context, req *pb.Att
 	epochBoundaryRoot := make([]byte, 32)
 	epochStartSlot := helpers.StartSlot(helpers.SlotToEpoch(head.Slot))
 	if epochStartSlot == head.Slot {
-		hash, err := hashutil.HashBeaconBlock(head)
-		if err != nil {
-			return nil, fmt.Errorf("could not tree hash head block: %v", err)
-		}
-		epochBoundaryRoot = hash[:]
+		epochBoundaryRoot = headRoot[:]
 	} else {
-		epochBoundaryRoot, err = blocks.BlockRoot(beaconState, epochStartSlot)
+		epochBoundaryRoot, err = blocks.BlockRoot(headState, epochStartSlot)
 		if err != nil {
-			return nil, fmt.Errorf("could not get epoch boundary block: %v", err)
+			return nil, fmt.Errorf("could not get epoch boundary block for slot %d: %v",
+				epochStartSlot, err)
 		}
 	}
 	// epoch_start_slot = get_epoch_start_slot(slot_to_epoch(head.slot))
@@ -87,15 +88,12 @@ func (as *AttesterServer) AttestationDataAtSlot(ctx context.Context, req *pb.Att
 	// On the server side, this is fetched by calling get_block_root(state, justified_epoch).
 	// If the last justified boundary slot is the same as state current slot (ex: slot 0),
 	// we set justified block root to an empty root.
-	lastJustifiedSlot := helpers.StartSlot(beaconState.JustifiedEpoch)
+	lastJustifiedSlot := helpers.StartSlot(headState.JustifiedEpoch)
 	justifiedBlockRoot := make([]byte, 32)
-	if lastJustifiedSlot != beaconState.Slot {
-		var justifiedBlock *pbp2p.BeaconBlock
-		for i := uint64(0); justifiedBlock == nil && i < params.BeaconConfig().SlotsPerEpoch; i++ {
-			justifiedBlock, err = as.beaconDB.BlockBySlot(lastJustifiedSlot - i)
-			if err != nil {
-				return nil, fmt.Errorf("could not get justified block: %v", err)
-			}
+	if lastJustifiedSlot != headState.Slot {
+		justifiedBlock, err := as.beaconDB.BlockBySlot(lastJustifiedSlot)
+		if err != nil {
+			return nil, fmt.Errorf("could not get justified block: %v", err)
 		}
 
 		justifiedBlockRoot32, err := hashutil.HashBeaconBlock(justifiedBlock)
@@ -105,15 +103,18 @@ func (as *AttesterServer) AttestationDataAtSlot(ctx context.Context, req *pb.Att
 		justifiedBlockRoot = justifiedBlockRoot32[:]
 	}
 
-	if beaconState.Slot == params.BeaconConfig().GenesisSlot {
-		epochBoundaryRoot = blockRoot[:]
-		justifiedBlockRoot = blockRoot[:]
+	// If an attester has to attest for gensis block.
+	if headState.Slot == params.BeaconConfig().GenesisSlot {
+		epochBoundaryRoot = headRoot[:]
+		justifiedBlockRoot = headRoot[:]
 	}
+
 	return &pb.AttestationDataResponse{
-		BeaconBlockRootHash32:    blockRoot[:],
+		HeadSlot:                 headState.Slot,
+		BeaconBlockRootHash32:    headRoot[:],
 		EpochBoundaryRootHash32:  epochBoundaryRoot,
-		JustifiedEpoch:           beaconState.JustifiedEpoch,
+		JustifiedEpoch:           headState.JustifiedEpoch,
 		JustifiedBlockRootHash32: justifiedBlockRoot,
-		LatestCrosslink:          beaconState.LatestCrosslinks[req.Shard],
+		LatestCrosslink:          headState.LatestCrosslinks[req.Shard],
 	}, nil
 }

beacon-chain/rpc/attester_server_test.go

@@ -65,6 +65,10 @@ func TestAttestationDataAtSlot_JustifiedBlockFailure(t *testing.T) {
 	defer internal.TeardownDB(t, db)
 	ctx := context.Background()
 
+	finalizedState := &pbp2p.BeaconState{
+		Slot:                   params.BeaconConfig().GenesisSlot + 1,
+		LatestBlockRootHash32S: make([][]byte, params.BeaconConfig().LatestBlockRootsLength),
+	}
 	beaconState := &pbp2p.BeaconState{
 		Slot:                   params.BeaconConfig().GenesisSlot + params.BeaconConfig().SlotsPerEpoch + 2,
 		LatestBlockRootHash32S: make([][]byte, params.BeaconConfig().LatestBlockRootsLength),
@@ -81,6 +85,9 @@ func TestAttestationDataAtSlot_JustifiedBlockFailure(t *testing.T) {
 	if err := attesterServer.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
 		t.Fatalf("Could not update chain head in test db: %v", err)
 	}
+	if err := attesterServer.beaconDB.SaveHistoricalState(finalizedState); err != nil {
+		t.Fatalf("Could not save historical state in test db: %v", err)
+	}
 	epochBoundaryBlock := &pbp2p.BeaconBlock{
 		Slot: params.BeaconConfig().GenesisSlot + 1,
 	}
@@ -123,6 +130,7 @@ func TestAttestationDataAtSlot_OK(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Could not hash justified block: %v", err)
 	}
+
 	beaconState := &pbp2p.BeaconState{
 		Slot:                   3*params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().GenesisSlot + 1,
 		JustifiedEpoch:         2 + params.BeaconConfig().GenesisEpoch,
@@ -165,6 +173,7 @@ func TestAttestationDataAtSlot_OK(t *testing.T) {
 		t.Fatalf("Could not get attestation info at slot: %v", err)
 	}
 	expectedInfo := &pb.AttestationDataResponse{
+		HeadSlot:                 beaconState.Slot,
 		BeaconBlockRootHash32:    blockRoot[:],
 		JustifiedEpoch:           2 + params.BeaconConfig().GenesisEpoch,
 		JustifiedBlockRootHash32: justifiedBlockRoot[:],
@@ -202,7 +211,7 @@ func TestAttestationDataAtSlot_handlesFarAwayJustifiedEpoch(t *testing.T) {
 		Slot: helpers.StartSlot(helpers.SlotToEpoch(10000 + params.BeaconConfig().GenesisSlot)),
 	}
 	justifiedBlock := &pbp2p.BeaconBlock{
-		Slot: helpers.StartSlot(helpers.SlotToEpoch(1500+params.BeaconConfig().GenesisSlot)) - 2, // Imagine two skip blocks
+		Slot: helpers.StartSlot(helpers.SlotToEpoch(1500 + params.BeaconConfig().GenesisSlot)),
 	}
 	blockRoot, err := hashutil.HashBeaconBlock(block)
 	if err != nil {
@@ -258,6 +267,7 @@ func TestAttestationDataAtSlot_handlesFarAwayJustifiedEpoch(t *testing.T) {
 		t.Fatalf("Could not get attestation info at slot: %v", err)
 	}
 	expectedInfo := &pb.AttestationDataResponse{
+		HeadSlot:                 10000 + params.BeaconConfig().GenesisSlot,
 		BeaconBlockRootHash32:    blockRoot[:],
 		JustifiedEpoch:           helpers.SlotToEpoch(1500 + params.BeaconConfig().GenesisSlot),
 		JustifiedBlockRootHash32: justifiedBlockRoot[:],

beacon-chain/rpc/beacon_server.go

@@ -99,7 +99,7 @@ func (bs *BeaconServer) LatestAttestation(req *ptypes.Empty, stream pb.BeaconSer
 
 // ForkData fetches the current fork information from the beacon state.
 func (bs *BeaconServer) ForkData(ctx context.Context, _ *ptypes.Empty) (*pbp2p.Fork, error) {
-	state, err := bs.beaconDB.State(ctx)
+	state, err := bs.beaconDB.HeadState(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not retrieve beacon state: %v", err)
 	}
@@ -112,7 +112,7 @@ func (bs *BeaconServer) ForkData(ctx context.Context, _ *ptypes.Empty) (*pbp2p.F
 // The deposit root can be calculated by calling the get_deposit_root() function of
 // the deposit contract using the post-state of the block hash.
 func (bs *BeaconServer) Eth1Data(ctx context.Context, _ *ptypes.Empty) (*pb.Eth1DataResponse, error) {
-	beaconState, err := bs.beaconDB.State(ctx)
+	beaconState, err := bs.beaconDB.HeadState(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not fetch beacon state: %v", err)
 	}
@@ -217,7 +217,7 @@ func (bs *BeaconServer) PendingDeposits(ctx context.Context, _ *ptypes.Empty) (*
 	pendingDeps := bs.beaconDB.PendingDeposits(ctx, bNum)
 	// Need to fetch if the deposits up to the state's latest eth 1 data matches
 	// the number of all deposits in this RPC call. If not, then we return nil.
-	beaconState, err := bs.beaconDB.State(ctx)
+	beaconState, err := bs.beaconDB.HeadState(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not fetch beacon state: %v", err)
 	}