V0.11 run time fixes to use interop config

beacon-chain/blockchain/service.go

@@ -157,8 +157,7 @@ func (s *Service) Start() {
 	attestationProcessorSubscribed := make(chan struct{}, 1)
 
 	// If the chain has already been initialized, simply start the block processing routine.
-	// A node should still initialize rest of the chain service if the finalized state's slot is 0.
-	if beaconState != nil && beaconState.Slot() != 0 {
+	if beaconState != nil {
 		log.Info("Blockchain data already exists in DB, initializing...")
 		s.genesisTime = time.Unix(int64(beaconState.GenesisTime()), 0)
 		s.opsService.SetGenesisTime(beaconState.GenesisTime())

beacon-chain/interop-cold-start/service.go

@@ -166,6 +166,12 @@ func (s *Service) saveGenesisState(ctx context.Context, genesisState *stateTrie.
 	if err := s.beaconDB.SaveBlock(ctx, genesisBlk); err != nil {
 		return errors.Wrap(err, "could not save genesis block")
 	}
+	if err := s.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{
+		Slot: 0,
+		Root: genesisBlkRoot[:],
+	}); err != nil {
+		return err
+	}
 	if err := s.beaconDB.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {
 		return errors.Wrap(err, "could not save genesis state")
 	}

beacon-chain/node/node.go

@@ -443,6 +443,7 @@ func (b *BeaconNode) registerSyncService(ctx *cli.Context) error {
 		ExitPool:            b.exitPool,
 		SlashingPool:        b.slashingsPool,
 		StateSummaryCache:   b.stateSummaryCache,
+		StateGen:            b.stateGen,
 	})
 
 	return b.services.RegisterService(rs)

beacon-chain/sync/BUILD.bazel

@@ -53,6 +53,7 @@ go_library(
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//shared:go_default_library",
         "//shared/attestationutil:go_default_library",
@@ -127,6 +128,7 @@ go_test(
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync/initial-sync/testing:go_default_library",
         "//proto/beacon/p2p/v1:go_default_library",
         "//proto/testing:go_default_library",

beacon-chain/sync/service.go

@@ -20,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/shared"
 	"github.com/prysmaticlabs/prysm/shared/runutil"
 )
@@ -47,6 +48,7 @@ type Config struct {
 	BlockNotifier       blockfeed.Notifier
 	AttestationNotifier operation.Notifier
 	StateSummaryCache   *cache.StateSummaryCache
+	StateGen            *stategen.State
 }
 
 // This defines the interface for interacting with block chain service
@@ -79,6 +81,7 @@ func NewRegularSync(cfg *Config) *Service {
 		stateNotifier:        cfg.StateNotifier,
 		blockNotifier:        cfg.BlockNotifier,
 		stateSummaryCache:    cfg.StateSummaryCache,
+		stateGen:             cfg.StateGen,
 		blocksRateLimiter:    leakybucket.NewCollector(allowedBlocksPerSecond, allowedBlocksBurst, false /* deleteEmptyBuckets */),
 	}
 
@@ -122,6 +125,7 @@ type Service struct {
 	seenAttesterSlashingLock  sync.RWMutex
 	seenAttesterSlashingCache *lru.Cache
 	stateSummaryCache         *cache.StateSummaryCache
+	stateGen                  *stategen.State
 }
 
 // Start the regular sync service.

beacon-chain/sync/subscriber_beacon_blocks.go

@@ -6,12 +6,10 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/block"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/state/interop"
-	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 )
 
 func (r *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message) error {
@@ -25,21 +23,6 @@ func (r *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 
 	block := signed.Block
 
-	blockRoot, err := ssz.HashTreeRoot(block)
-	if err != nil {
-		log.Errorf("Could not sign root block: %v", err)
-		return nil
-	}
-
-	// Handle block when the parent is unknown.
-	if !r.db.HasBlock(ctx, bytesutil.ToBytes32(block.ParentRoot)) {
-		r.pendingQueueLock.Lock()
-		r.slotToPendingBlocks[block.Slot] = signed
-		r.seenPendingBlocks[blockRoot] = true
-		r.pendingQueueLock.Unlock()
-		return nil
-	}
-
 	// Broadcast the block on a feed to notify other services in the beacon node
 	// of a received block (even if it does not process correctly through a state transition).
 	r.blockNotifier.BlockFeed().Send(&feed.Event{
@@ -49,7 +32,7 @@ func (r *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message)
 		},
 	})
 
-	err = r.chain.ReceiveBlockNoPubsub(ctx, signed)
+	err := r.chain.ReceiveBlockNoPubsub(ctx, signed)
 	if err != nil {
 		interop.WriteBlockToDisk(signed, true /*failed*/)
 	}

beacon-chain/sync/validate_beacon_blocks.go

@@ -80,13 +80,24 @@ func (r *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		return false
 	}
 
-	parentState, err := r.db.State(ctx, bytesutil.ToBytes32(blk.Block.ParentRoot))
-	if err != nil {
-		log.WithError(err).WithField("blockSlot", blk.Block.Slot).Warn("Could not get parent state")
+	// Handle block when the parent is unknown.
+	if !r.db.HasBlock(ctx, bytesutil.ToBytes32(blk.Block.ParentRoot)) {
+		r.pendingQueueLock.Lock()
+		r.slotToPendingBlocks[blk.Block.Slot] = blk
+		r.seenPendingBlocks[blockRoot] = true
+		r.pendingQueueLock.Unlock()
 		return false
 	}
-	if parentState == nil {
-		log.WithError(err).WithField("blockSlot", blk.Block.Slot).Warn("Parent state is nil")
+
+	hasStateSummaryDB := r.db.HasStateSummary(ctx, bytesutil.ToBytes32(blk.Block.ParentRoot))
+	hasStateSummaryCache := r.stateSummaryCache.Has(bytesutil.ToBytes32(blk.Block.ParentRoot))
+	if !hasStateSummaryDB && !hasStateSummaryCache {
+		log.WithError(err).WithField("blockSlot", blk.Block.Slot).Warn("No access to parent state")
+		return false
+	}
+	parentState, err := r.stateGen.StateByRoot(ctx, bytesutil.ToBytes32(blk.Block.ParentRoot))
+	if err != nil {
+		log.WithError(err).WithField("blockSlot", blk.Block.Slot).Warn("Could not get parent state")
 		return false
 	}
 

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -13,12 +13,15 @@ import (
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/prysmaticlabs/go-ssz"
 	mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
 	p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
+	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
+	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
 	"github.com/prysmaticlabs/prysm/shared/bls"
 	"github.com/prysmaticlabs/prysm/shared/bytesutil"
 	"github.com/prysmaticlabs/prysm/shared/params"
@@ -93,11 +96,12 @@ func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInDB(t *testing.T) {
 
 	c, _ := lru.New(10)
 	r := &Service{
-		db:             db,
-		p2p:            p,
-		initialSync:    &mockSync.Sync{IsSyncing: false},
-		chain:          &mock.ChainService{Genesis: time.Now()},
-		seenBlockCache: c,
+		db:                db,
+		p2p:               p,
+		initialSync:       &mockSync.Sync{IsSyncing: false},
+		chain:             &mock.ChainService{Genesis: time.Now()},
+		seenBlockCache:    c,
+		stateSummaryCache: cache.NewStateSummaryCache(),
 	}
 
 	buf := new(bytes.Buffer)
@@ -114,7 +118,6 @@ func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInDB(t *testing.T) {
 		},
 	}
 	result := r.validateBeaconBlockPubSub(ctx, "", m)
-
 	if result {
 		t.Error("Expected false result, got true")
 	}
@@ -126,10 +129,24 @@ func TestValidateBeaconBlockPubSub_ValidProposerSignature(t *testing.T) {
 	p := p2ptest.NewTestP2P(t)
 	ctx := context.Background()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	bRoot := [32]byte{'a'}
+	parentBlock := &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			ProposerIndex: 0,
+			Slot:          0,
+		},
+	}
+	if err := db.SaveBlock(ctx, parentBlock); err != nil {
+		t.Fatal(err)
+	}
+	bRoot, err := ssz.HashTreeRoot(parentBlock.Block)
 	if err := db.SaveState(ctx, beaconState, bRoot); err != nil {
 		t.Fatal(err)
 	}
+	if err := db.SaveStateSummary(ctx, &pb.StateSummary{
+		Root: bRoot[:],
+	}); err != nil {
+		t.Fatal(err)
+	}
 	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
 	if err != nil {
 		t.Fatal(err)
@@ -154,6 +171,8 @@ func TestValidateBeaconBlockPubSub_ValidProposerSignature(t *testing.T) {
 	msg.Signature = blockSig[:]
 
 	c, _ := lru.New(10)
+	stateSummaryCache := cache.NewStateSummaryCache()
+	stateGen := stategen.New(db, stateSummaryCache)
 	r := &Service{
 		db:          db,
 		p2p:         p,
@@ -163,7 +182,11 @@ func TestValidateBeaconBlockPubSub_ValidProposerSignature(t *testing.T) {
 			FinalizedCheckPoint: &ethpb.Checkpoint{
 				Epoch: 0,
 			}},
-		seenBlockCache: c,
+		seenBlockCache:      c,
+		slotToPendingBlocks: make(map[uint64]*ethpb.SignedBeaconBlock),
+		seenPendingBlocks:   make(map[[32]byte]bool),
+		stateSummaryCache:   stateSummaryCache,
+		stateGen:            stateGen,
 	}
 
 	buf := new(bytes.Buffer)
@@ -256,11 +279,13 @@ func TestValidateBeaconBlockPubSub_RejectBlocksFromFuture(t *testing.T) {
 
 	c, _ := lru.New(10)
 	r := &Service{
-		p2p:            p,
-		db:             db,
-		initialSync:    &mockSync.Sync{IsSyncing: false},
-		chain:          &mock.ChainService{Genesis: time.Now()},
-		seenBlockCache: c,
+		p2p:                 p,
+		db:                  db,
+		initialSync:         &mockSync.Sync{IsSyncing: false},
+		chain:               &mock.ChainService{Genesis: time.Now()},
+		seenBlockCache:      c,
+		slotToPendingBlocks: make(map[uint64]*ethpb.SignedBeaconBlock),
+		seenPendingBlocks:   make(map[[32]byte]bool),
 	}
 
 	buf := new(bytes.Buffer)
@@ -339,10 +364,22 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 	p := p2ptest.NewTestP2P(t)
 	ctx := context.Background()
 	beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
-	bRoot := [32]byte{'a'}
+	parentBlock := &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			ProposerIndex: 0,
+			Slot:          0,
+		},
+	}
+	if err := db.SaveBlock(ctx, parentBlock); err != nil {
+		t.Fatal(err)
+	}
+	bRoot, err := ssz.HashTreeRoot(parentBlock.Block)
 	if err := db.SaveState(ctx, beaconState, bRoot); err != nil {
 		t.Fatal(err)
 	}
+	if err != nil {
+		t.Fatal(err)
+	}
 	proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
 	if err != nil {
 		t.Fatal(err)
@@ -377,7 +414,10 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 			FinalizedCheckPoint: &ethpb.Checkpoint{
 				Epoch: 0,
 			}},
-		seenBlockCache: c,
+		seenBlockCache:      c,
+		slotToPendingBlocks: make(map[uint64]*ethpb.SignedBeaconBlock),
+		seenPendingBlocks:   make(map[[32]byte]bool),
+		stateSummaryCache:   cache.NewStateSummaryCache(),
 	}
 
 	buf := new(bytes.Buffer)
@@ -392,13 +432,9 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 			},
 		},
 	}
-	result := r.validateBeaconBlockPubSub(ctx, "", m)
-	if !result {
-		t.Error("Expected true result, got false")
-	}
 	r.setSeenBlockIndexSlot(msg.Block.Slot, msg.Block.ProposerIndex)
 	time.Sleep(10 * time.Millisecond) // Wait for cached value to pass through buffers.
-	result = r.validateBeaconBlockPubSub(ctx, "", m)
+	result := r.validateBeaconBlockPubSub(ctx, "", m)
 	if result {
 		t.Error("Expected false result, got true")
 	}