Refactor Core/Types Package to Align With Spec

beacon-chain/core/types/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
         "//shared/hashutil:go_default_library",
         "//shared/params:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
-        "@com_github_gogo_protobuf//proto:go_default_library",
         "@com_github_golang_protobuf//proto:go_default_library",
         "@com_github_golang_protobuf//ptypes:go_default_library_gen",
     ],
@@ -33,7 +32,6 @@ go_test(
     deps = [
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared/params:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_golang_protobuf//ptypes:go_default_library_gen",
     ],
 )

beacon-chain/core/types/block.go

@@ -4,8 +4,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/gogo/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/ptypes"
 	"github.com/prysmaticlabs/prysm/beacon-chain/utils"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -30,7 +29,6 @@ func NewBlock(data *pb.BeaconBlock) *Block {
 			data: &pb.BeaconBlock{
 				AncestorHashes: ancestorHashes,
 				RandaoReveal:   []byte{0},
-				PowChainRef:    []byte{0},
 				StateRoot:      []byte{0},
 				Specials:       []*pb.SpecialRecord{},
 			},
@@ -102,11 +100,6 @@ func (b *Block) Attestations() []*pb.AggregatedAttestation {
 	return b.data.Attestations
 }
 
-// PowChainRef returns a keccak256 hash corresponding to a PoW chain block.
-func (b *Block) PowChainRef() common.Hash {
-	return common.BytesToHash(b.data.PowChainRef)
-}
-
 // RandaoReveal returns the blake2b randao hash.
 func (b *Block) RandaoReveal() [32]byte {
 	var h [32]byte

beacon-chain/core/types/block_test.go

@@ -5,7 +5,6 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/golang/protobuf/ptypes"
 	"github.com/prysmaticlabs/prysm/shared/params"
 )
@@ -43,10 +42,6 @@ func TestGenesisBlock(t *testing.T) {
 		t.Error("genesis block missing RandaoReveal field")
 	}
 
-	if b1.PowChainRef() != common.BytesToHash([]byte{}) {
-		t.Error("genesis block missing PowChainRef field")
-	}
-
 	if b1.StateRoot() != stateHash {
 		t.Error("genesis block StateRoot isn't initialized correctly")
 	}

beacon-chain/core/types/state.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/gogo/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 	v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
 	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/hashutil"
@@ -55,19 +55,19 @@ func NewGenesisBeaconState(genesisValidators []*pb.ValidatorRecord) (*BeaconStat
 	return &BeaconState{
 		data: &pb.BeaconState{
 			LastStateRecalculationSlot: 0,
-			JustifiedStreak:            0,
-			LastJustifiedSlot:          0,
 			LastFinalizedSlot:          0,
 			ValidatorSetChangeSlot:     0,
-			ForkSlotNumber:             0,
 			Crosslinks:                 crosslinks,
 			Validators:                 genesisValidators,
 			ShardAndCommitteesForSlots: shardAndCommitteesForSlots,
-			PreForkVersion:             uint64(params.BeaconConfig().InitialForkVersion),
-			PostForkVersion:            uint64(params.BeaconConfig().InitialForkVersion),
-			PendingAttestations:        []*pb.AggregatedAttestation{},
-			RecentBlockHashes:          recentBlockHashes,
-			RandaoMix:                  make([]byte, 0, 32),
+			ForkData: &pb.ForkData{
+				PreForkVersion:  uint64(params.BeaconConfig().InitialForkVersion),
+				PostForkVersion: uint64(params.BeaconConfig().InitialForkVersion),
+				ForkSlotNumber:  0,
+			},
+			PendingAttestations: []*pb.ProcessedAttestation{},
+			RecentBlockHashes:   recentBlockHashes,
+			RandaoMix:           make([]byte, 0, 32),
 		},
 	}, nil
 }
@@ -85,13 +85,12 @@ func (b *BeaconState) CopyState() *BeaconState {
 	validators := make([]*pb.ValidatorRecord, len(b.Validators()))
 	for index, validator := range b.Validators() {
 		validators[index] = &pb.ValidatorRecord{
-			Pubkey:            validator.GetPubkey(),
-			WithdrawalShard:   validator.GetWithdrawalShard(),
-			WithdrawalAddress: validator.GetWithdrawalAddress(),
-			RandaoCommitment:  validator.GetRandaoCommitment(),
-			Balance:           validator.GetBalance(),
-			Status:            validator.GetStatus(),
-			ExitSlot:          validator.GetExitSlot(),
+			Pubkey:                validator.GetPubkey(),
+			WithdrawalCredentials: validator.GetWithdrawalCredentials(),
+			RandaoCommitment:      validator.GetRandaoCommitment(),
+			Balance:               validator.GetBalance(),
+			Status:                validator.GetStatus(),
+			LastStatusChangeSlot:  validator.GetLastStatusChangeSlot(),
 		}
 	}
 
@@ -111,17 +110,18 @@ func (b *BeaconState) CopyState() *BeaconState {
 
 	newState := BeaconState{&pb.BeaconState{
 		LastStateRecalculationSlot: b.LastStateRecalculationSlot(),
-		JustifiedStreak:            b.JustifiedStreak(),
-		LastJustifiedSlot:          b.LastJustifiedSlot(),
 		LastFinalizedSlot:          b.LastFinalizedSlot(),
 		ValidatorSetChangeSlot:     b.ValidatorSetChangeSlot(),
 		Crosslinks:                 crosslinks,
 		Validators:                 validators,
 		ShardAndCommitteesForSlots: shardAndCommitteesForSlots,
 		DepositsPenalizedInPeriod:  b.DepositsPenalizedInPeriod(),
-		PreForkVersion:             b.data.PreForkVersion,
-		PostForkVersion:            b.data.PostForkVersion,
-		ForkSlotNumber:             b.data.ForkSlotNumber,
+		PendingAttestations:        b.PendingAttestations(),
+		ForkData: &pb.ForkData{
+			PreForkVersion:  b.data.ForkData.PreForkVersion,
+			PostForkVersion: b.data.ForkData.PostForkVersion,
+			ForkSlotNumber:  b.data.ForkData.ForkSlotNumber,
+		},
 	}}
 
 	return &newState
@@ -199,6 +199,23 @@ func (b *BeaconState) Validators() []*pb.ValidatorRecord {
 	return b.data.Validators
 }
 
+// JustifiedSlotBitfield returns the bitfield of justified slots corresponding to
+// this beacon block.
+func (b *BeaconState) JustifiedSlotBitfield() []byte {
+	return b.data.JustifiedSlotBitfield
+}
+
+// JustificationSource returns the beacon block's justification source.
+func (b *BeaconState) JustificationSource() uint64 {
+	return b.data.JustificationSource
+}
+
+// PrevCycleJustificationSource returns the previous cycle's justification source
+// for this block.
+func (b *BeaconState) PrevCycleJustificationSource() uint64 {
+	return b.data.PrevCycleJustificationSource
+}
+
 // LastStateRecalculationSlot returns when the last time crystallized state recalculated.
 func (b *BeaconState) LastStateRecalculationSlot() uint64 {
 	return b.data.LastStateRecalculationSlot
@@ -209,34 +226,24 @@ func (b *BeaconState) LastFinalizedSlot() uint64 {
 	return b.data.LastFinalizedSlot
 }
 
-// LastJustifiedSlot return the last justified slot of the beacon chain.
-func (b *BeaconState) LastJustifiedSlot() uint64 {
-	return b.data.LastJustifiedSlot
-}
-
-// JustifiedStreak returns number of consecutive justified slots ending at head.
-func (b *BeaconState) JustifiedStreak() uint64 {
-	return b.data.JustifiedStreak
-}
-
 // DepositsPenalizedInPeriod returns total deposits penalized in the given withdrawal period.
 func (b *BeaconState) DepositsPenalizedInPeriod() []uint64 {
 	return b.data.DepositsPenalizedInPeriod
 }
 
 // ForkSlotNumber returns the slot of last fork.
 func (b *BeaconState) ForkSlotNumber() uint64 {
-	return b.data.ForkSlotNumber
+	return b.data.ForkData.ForkSlotNumber
 }
 
 // PreForkVersion returns the last pre fork version.
 func (b *BeaconState) PreForkVersion() uint64 {
-	return b.data.PreForkVersion
+	return b.data.ForkData.PreForkVersion
 }
 
 // PostForkVersion returns the last post fork version.
 func (b *BeaconState) PostForkVersion() uint64 {
-	return b.data.PostForkVersion
+	return b.data.ForkData.PostForkVersion
 }
 
 // RecentBlockHashes returns the most recent 2*EPOCH_LENGTH block hashes.
@@ -249,7 +256,7 @@ func (b *BeaconState) RecentBlockHashes() [][32]byte {
 }
 
 // PendingAttestations returns attestations that have not yet been processed.
-func (b *BeaconState) PendingAttestations() []*pb.AggregatedAttestation {
+func (b *BeaconState) PendingAttestations() []*pb.ProcessedAttestation {
 	return b.data.PendingAttestations
 }
 
@@ -277,6 +284,14 @@ func (b *BeaconState) PenalizedETH(period uint64) uint64 {
 	return totalPenalty
 }
 
+<<<<<<< HEAD
+// ClearAttestations removes attestations older than last state recalc slot.
+func (b *BeaconState) ClearAttestations(lastStateRecalc uint64) {
+	existing := b.data.PendingAttestations
+	update := make([]*pb.ProcessedAttestation, 0, len(existing))
+	for _, a := range existing {
+		if a.SignedData.Slot >= lastStateRecalc {
+=======
 // SignedParentHashes returns all the parent hashes stored in active state up to last cycle length.
 func (b *BeaconState) SignedParentHashes(block *Block, attestation *pb.AggregatedAttestation) ([][32]byte, error) {
 	recentBlockHashes := b.RecentBlockHashes()
@@ -307,6 +322,7 @@ func (b *BeaconState) ClearAttestations(lastStateRecalc uint64) {
 	update := make([]*pb.AggregatedAttestation, 0, len(existing))
 	for _, a := range existing {
 		if a.GetSlot() >= lastStateRecalc {
+>>>>>>> master
 			update = append(update, a)
 		}
 	}
@@ -357,28 +373,37 @@ func (b *BeaconState) SetDepositsPenalizedInPeriod(penalizedDeposits []uint64) {
 	b.data.DepositsPenalizedInPeriod = penalizedDeposits
 }
 
-// SetLastJustifiedSlot updates the inner proto's last justified slot.
-func (b *BeaconState) SetLastJustifiedSlot(justifiedSlot uint64) {
-	b.data.LastJustifiedSlot = justifiedSlot
+// SetJustificationSource updates the inner proto's justification source.
+func (b *BeaconState) SetJustificationSource(justificationSource uint64) {
+	b.data.JustificationSource = justificationSource
+}
+
+// SetPrevCycleJustificationSource updates the inner proto's previous cycle justification source.
+func (b *BeaconState) SetPrevCycleJustificationSource(justificationSource uint64) {
+	b.data.PrevCycleJustificationSource = justificationSource
+}
+
+// SetJustifiedSlotBitfield updates the inner proto's justified slot bitfield.
+func (b *BeaconState) SetJustifiedSlotBitfield(bitfield []byte) {
+	b.data.JustifiedSlotBitfield = bitfield
 }
 
 // SetLastFinalizedSlot updates the inner proto's last finalized slot.
 func (b *BeaconState) SetLastFinalizedSlot(finalizedSlot uint64) {
 	b.data.LastFinalizedSlot = finalizedSlot
 }
 
-// SetJustifiedStreak updates the inner proto's justified streak.
-func (b *BeaconState) SetJustifiedStreak(justifiedSlot uint64) {
-	b.data.JustifiedStreak = justifiedSlot
-}
-
 // SetLastStateRecalculationSlot updates the inner proto's last state recalc slot.
 func (b *BeaconState) SetLastStateRecalculationSlot(slot uint64) {
 	b.data.LastStateRecalculationSlot = slot
 }
 
 // SetPendingAttestations updates the inner proto's pending attestations.
+<<<<<<< HEAD
+func (b *BeaconState) SetPendingAttestations(pendingAttestations []*pb.ProcessedAttestation) {
+=======
 func (b *BeaconState) SetPendingAttestations(pendingAttestations []*pb.AggregatedAttestation) {
+>>>>>>> master
 	b.data.PendingAttestations = pendingAttestations
 }
 
@@ -412,6 +437,5 @@ func getPenaltyForPeriod(penalties []uint64, period uint64) uint64 {
 	if numPeriods < period+1 {
 		return 0
 	}
-
 	return penalties[period]
 }

beacon-chain/core/validators/committees.go

@@ -48,12 +48,12 @@ func AttesterIndices(
 ) ([]uint32, error) {
 	shardCommitteesArray := shardCommittees.ArrayShardAndCommittee
 	for _, shardCommittee := range shardCommitteesArray {
-		if attestation.Shard == shardCommittee.Shard {
+		if attestation.SignedData.Shard == shardCommittee.Shard {
 			return shardCommittee.Committee, nil
 		}
 	}
 
-	return nil, fmt.Errorf("unable to find committee for shard %d", attestation.Shard)
+	return nil, fmt.Errorf("unable to find committee for shard %d", attestation.SignedData.Shard)
 }
 
 // splitBySlotShard splits the validator list into evenly sized committees and assigns each