AtHeartEngineer/prysm
1
0
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-09 13:28:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

Add flags to support new database, new sync (#3252)

Browse Source
This commit is contained in:
Preston Van Loon
2019-08-21 12:04:00 -04:00
committed by terence tsao
parent 0f123ae562
commit acb20e269c
65 changed files with 1006 additions and 776 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
beacon-chain/attestation/service.go
View File

@@ -37,7 +37,7 @@ type attestationStore struct {
type Service struct {
ctx context.Context
cancel context.CancelFunc
beaconDB *db.BeaconDB
beaconDB db.Database
incomingFeed *event.Feed
incomingChan chan *ethpb.Attestation
// store is the mapping of individual
@@ -49,7 +49,7 @@ type Service struct {
// Config options for the service.
type Config struct {
BeaconDB *db.BeaconDB
BeaconDB db.Database
}
// NewAttestationService instantiates a new service instance that will
@@ -118,11 +118,12 @@ func (a *Service) LatestAttestationTarget(beaconState *pb.BeaconState, index uin
return nil, nil
}
targetRoot := bytesutil.ToBytes32(attestation.Data.BeaconBlockRoot)
if !a.beaconDB.HasBlock(targetRoot) {
if !a.beaconDB.HasBlock(context.TODO(), targetRoot) {
return nil, nil
}
return a.beaconDB.AttestationTarget(targetRoot)
// TODO(3219): remove after fork choice service changes.
return a.beaconDB.(*db.BeaconDB).AttestationTarget(targetRoot)
}
// attestationPool takes an newly received attestation from sync service
@@ -133,7 +134,7 @@ func (a *Service) attestationPool() {
for {
select {
case <-a.ctx.Done():
log.Debug("Attestation pool closed, exiting goroutine")
log.Debug("AttestationDeprecated pool closed, exiting goroutine")
return
// Listen for a newly received incoming attestation from the sync service.
case attestations := <-a.incomingChan:

16
beacon-chain/attestation/service_test.go
View File

@@ -47,7 +47,7 @@ func TestUpdateLatestAttestation_UpdatesLatest(t *testing.T) {
block := &ethpb.BeaconBlock{
Slot: 1,
}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
@@ -117,7 +117,7 @@ func TestAttestationPool_UpdatesAttestationPool(t *testing.T) {
block := &ethpb.BeaconBlock{
Slot: 1,
}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
@@ -144,7 +144,7 @@ func TestLatestAttestationTarget_CantGetAttestation(t *testing.T) {
defer internal.TeardownDBDeprecated(t, beaconDB)
ctx := context.Background()
if err := beaconDB.SaveState(ctx, &pb.BeaconState{
if err := beaconDB.SaveStateDeprecated(ctx, &pb.BeaconState{
Validators: []*ethpb.Validator{{}},
}); err != nil {
t.Fatalf("could not save state: %v", err)
@@ -168,14 +168,14 @@ func TestLatestAttestationTarget_ReturnsLatestAttestedBlock(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := beaconDB.SaveState(ctx, &pb.BeaconState{
if err := beaconDB.SaveStateDeprecated(ctx, &pb.BeaconState{
Validators: []*ethpb.Validator{{PublicKey: pubKey}},
}); err != nil {
t.Fatalf("could not save state: %v", err)
}
block := &ethpb.BeaconBlock{Slot: 999}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatalf("could not save block: %v", err)
}
blockRoot, err := ssz.SigningRoot(block)
@@ -238,7 +238,7 @@ func TestUpdateLatestAttestation_InvalidIndex(t *testing.T) {
block := &ethpb.BeaconBlock{
Slot: 1,
}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
@@ -292,7 +292,7 @@ func TestBatchUpdate_FromSync(t *testing.T) {
block := &ethpb.BeaconBlock{
Slot: 1,
}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
@@ -343,7 +343,7 @@ func TestUpdateLatestAttestation_BatchUpdate(t *testing.T) {
block := &ethpb.BeaconBlock{
Slot: 1,
}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {

2
beacon-chain/blockchain/BUILD.bazel
View File

@@ -12,6 +12,7 @@ go_library(
deps = [
"//beacon-chain/attestation:go_default_library",
"//beacon-chain/cache:go_default_library",
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/blocks:go_default_library",
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/core/state:go_default_library",
@@ -47,6 +48,7 @@ go_test(
deps = [
"//beacon-chain/attestation:go_default_library",
"//beacon-chain/cache:go_default_library",
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/blocks:go_default_library",
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/core/state:go_default_library",

51
beacon-chain/blockchain/block_processing.go
View File

@@ -10,6 +10,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -56,15 +57,21 @@ func (c *ChainService) ReceiveBlockDeprecated(ctx context.Context, block *ethpb.
defer c.receiveBlockLock.Unlock()
ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.ReceiveBlock")
defer span.End()
// TODO(3219): Fix with new fork choice service.
db, isLegacyDB := c.beaconDB.(*db.BeaconDB)
if !isLegacyDB {
panic("Deprecated receive block only works with deprecated database impl.")
}
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
parent, err := c.beaconDB.Block(parentRoot)
parent, err := db.BlockDeprecated(parentRoot)
if err != nil {
return nil, errors.Wrap(err, "failed to get parent block")
}
if parent == nil {
return nil, errors.New("parent does not exist in DB")
}
beaconState, err := c.beaconDB.HistoricalStateFromSlot(ctx, parent.Slot, parentRoot)
beaconState, err := db.HistoricalStateFromSlot(ctx, parent.Slot, parentRoot)
if err != nil {
return nil, errors.Wrap(err, "could not retrieve beacon state")
}
@@ -94,8 +101,8 @@ func (c *ChainService) ReceiveBlockDeprecated(ctx context.Context, block *ethpb.
switch err.(type) {
case *BlockFailedProcessingErr:
// If the block fails processing, we mark it as blacklisted and delete it from our DB.
c.beaconDB.MarkEvilBlockHash(blockRoot)
if err := c.beaconDB.DeleteBlock(block); err != nil {
db.MarkEvilBlockHash(blockRoot)
if err := db.DeleteBlockDeprecated(block); err != nil {
return nil, errors.Wrap(err, "could not delete bad block from db")
}
return beaconState, err
@@ -155,15 +162,19 @@ func (c *ChainService) SaveAndBroadcastBlock(ctx context.Context, block *ethpb.B
if err != nil {
return errors.Wrap(err, "could not tree hash incoming block")
}
if err := c.beaconDB.SaveBlock(block); err != nil {
if err := c.beaconDB.SaveBlock(ctx, block); err != nil {
return errors.Wrap(err, "failed to save block")
}
if err := c.beaconDB.SaveAttestationTarget(ctx, &pb.AttestationTarget{
Slot: block.Slot,
BeaconBlockRoot: blockRoot[:],
ParentRoot: block.ParentRoot,
}); err != nil {
return errors.Wrap(err, "failed to save attestation target")
// TODO(3219): Update after new fork choice service.
db, isLegacyDB := c.beaconDB.(*db.BeaconDB)
if isLegacyDB {
if err := db.SaveAttestationTarget(ctx, &pb.AttestationTarget{
Slot: block.Slot,
BeaconBlockRoot: blockRoot[:],
ParentRoot: block.ParentRoot,
}); err != nil {
return errors.Wrap(err, "failed to save attestation target")
}
}
// Announce the new block to the network.
c.p2p.Broadcast(ctx, &pb.BeaconBlockAnnounce{
@@ -189,7 +200,7 @@ func (c *ChainService) CleanupBlockOperations(ctx context.Context, block *ethpb.
// Remove pending deposits from the deposit queue.
for _, dep := range block.Body.Deposits {
c.beaconDB.DepositCache.RemovePendingDeposit(ctx, dep)
c.depositCache.RemovePendingDeposit(ctx, dep)
}
return nil
}
@@ -214,7 +225,7 @@ func (c *ChainService) AdvanceStateDeprecated(
// Prune the block cache and helper caches on every new finalized epoch.
if newState.FinalizedCheckpoint.Epoch > finalizedEpoch {
helpers.ClearAllCaches()
c.beaconDB.ClearBlockCache()
c.beaconDB.(*db.BeaconDB).ClearBlockCache()
}
log.WithField(
@@ -231,18 +242,18 @@ func (c *ChainService) AdvanceStateDeprecated(
return nil, err
}
// Save Historical States.
if err := c.beaconDB.SaveHistoricalState(ctx, beaconState, blockRoot); err != nil {
if err := c.beaconDB.(*db.BeaconDB).SaveHistoricalState(ctx, beaconState, blockRoot); err != nil {
return nil, errors.Wrap(err, "could not save historical state")
}
}
if helpers.IsEpochStart(newState.Slot) {
// Save activated validators of this epoch to public key -> index DB.
if err := c.saveValidatorIdx(newState); err != nil {
if err := c.saveValidatorIdx(ctx, newState); err != nil {
return newState, errors.Wrap(err, "could not save validator index")
}
// Delete exited validators of this epoch to public key -> index DB.
if err := c.deleteValidatorIdx(newState); err != nil {
if err := c.deleteValidatorIdx(ctx, newState); err != nil {
return newState, errors.Wrap(err, "could not delete validator index")
}
// Update FFG checkpoints in DB.
@@ -257,7 +268,7 @@ func (c *ChainService) AdvanceStateDeprecated(
// saveValidatorIdx saves the validators public key to index mapping in DB, these
// validators were activated from current epoch. After it saves, current epoch key
// is deleted from ActivatedValidators mapping.
func (c *ChainService) saveValidatorIdx(state *pb.BeaconState) error {
func (c *ChainService) saveValidatorIdx(ctx context.Context, state *pb.BeaconState) error {
nextEpoch := helpers.CurrentEpoch(state) + 1
activatedValidators := validators.ActivatedValFromEpoch(nextEpoch)
var idxNotInState []uint64
@@ -269,7 +280,7 @@ func (c *ChainService) saveValidatorIdx(state *pb.BeaconState) error {
continue
}
pubKey := state.Validators[idx].PublicKey
if err := c.beaconDB.SaveValidatorIndex(pubKey, int(idx)); err != nil {
if err := c.beaconDB.SaveValidatorIndex(ctx, bytesutil.ToBytes48(pubKey), idx); err != nil {
return errors.Wrap(err, "could not save validator index")
}
}
@@ -283,11 +294,11 @@ func (c *ChainService) saveValidatorIdx(state *pb.BeaconState) error {
// deleteValidatorIdx deletes the validators public key to index mapping in DB, the
// validators were exited from current epoch. After it deletes, current epoch key
// is deleted from ExitedValidators mapping.
func (c *ChainService) deleteValidatorIdx(state *pb.BeaconState) error {
func (c *ChainService) deleteValidatorIdx(ctx context.Context, state *pb.BeaconState) error {
exitedValidators := validators.ExitedValFromEpoch(helpers.CurrentEpoch(state) + 1)
for _, idx := range exitedValidators {
pubKey := state.Validators[idx].PublicKey
if err := c.beaconDB.DeleteValidatorIndex(pubKey); err != nil {
if err := c.beaconDB.DeleteValidatorIndex(ctx, bytesutil.ToBytes48(pubKey)); err != nil {
return errors.Wrap(err, "could not delete validator index")
}
}

90
beacon-chain/blockchain/block_processing_test.go
View File

@@ -15,6 +15,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
v "github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -29,11 +30,11 @@ var _ = BlockProcessor(&ChainService{})
func initBlockStateRoot(t *testing.T, block *ethpb.BeaconBlock, chainService *ChainService) (*ethpb.BeaconBlock, error) {
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
parent, err := chainService.beaconDB.Block(parentRoot)
parent, err := chainService.beaconDB.Block(context.Background(), parentRoot)
if err != nil {
return nil, err
}
beaconState, err := chainService.beaconDB.HistoricalStateFromSlot(context.Background(), parent.Slot, parentRoot)
beaconState, err := chainService.beaconDB.(*db2.BeaconDB).HistoricalStateFromSlot(context.Background(), parent.Slot, parentRoot)
if err != nil {
return nil, err
}
@@ -56,6 +57,8 @@ func initBlockStateRoot(t *testing.T, block *ethpb.BeaconBlock, chainService *Ch
func TestReceiveBlock_FaultyPOWChain(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
chainService := setupBeaconChain(t, db, nil)
unixTime := uint64(time.Now().Unix())
deposits, _ := testutil.SetupInitialDeposits(t, 100)
@@ -76,7 +79,7 @@ func TestReceiveBlock_FaultyPOWChain(t *testing.T) {
t.Fatalf("Unable to tree hash block %v", err)
}
if err := chainService.beaconDB.SaveBlock(parentBlock); err != nil {
if err := chainService.beaconDB.SaveBlock(ctx, parentBlock); err != nil {
t.Fatalf("Unable to save block %v", err)
}
@@ -91,7 +94,7 @@ func TestReceiveBlock_FaultyPOWChain(t *testing.T) {
},
}
if err := chainService.beaconDB.SaveBlock(block); err != nil {
if err := chainService.beaconDB.SaveBlock(ctx, block); err != nil {
t.Fatal(err)
}
if _, err := chainService.ReceiveBlockDeprecated(context.Background(), block); err == nil {
@@ -122,7 +125,7 @@ func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
BodyRoot: bodyRoot[:],
}
beaconState.Eth1DepositIndex = 100
if err := chainService.beaconDB.SaveBlock(genesis); err != nil {
if err := chainService.beaconDB.SaveBlock(ctx, genesis); err != nil {
t.Fatalf("Could not save block to db: %v", err)
}
parentRoot, err := ssz.SigningRoot(genesis)
@@ -134,7 +137,7 @@ func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
t.Fatal(err)
}
if err := chainService.beaconDB.UpdateChainHead(ctx, genesis, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesis, beaconState); err != nil {
t.Fatal(err)
}
@@ -177,17 +180,17 @@ func TestReceiveBlock_ProcessCorrectly(t *testing.T) {
t.Error(err)
}
if err := chainService.beaconDB.SaveJustifiedBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(block); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveFinalizedBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(block); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if _, err := chainService.ReceiveBlockDeprecated(context.Background(), block); err != nil {
t.Errorf("Block failed processing: %v", err)
t.Errorf("BlockDeprecated failed processing: %v", err)
}
testutil.AssertLogsContain(t, hook, "Finished processing beacon block")
}
@@ -218,10 +221,10 @@ func TestReceiveBlock_UsesParentBlockState(t *testing.T) {
beaconState.Eth1DepositIndex = 100
parentHash, genesisBlock := setupGenesisBlock(t, chainService)
if err := chainService.beaconDB.UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
t.Fatal(err)
}
parentRoot, err := ssz.SigningRoot(beaconState.LatestBlockHeader)
@@ -268,7 +271,7 @@ func TestReceiveBlock_UsesParentBlockState(t *testing.T) {
t.Error(err)
}
if err := chainService.beaconDB.SaveBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if _, err := chainService.ReceiveBlockDeprecated(context.Background(), block); err != nil {
@@ -304,10 +307,10 @@ func TestReceiveBlock_DeletesBadBlock(t *testing.T) {
}
parentHash, genesisBlock := setupGenesisBlock(t, chainService)
if err := chainService.beaconDB.UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
t.Fatal(err)
}
@@ -348,7 +351,7 @@ func TestReceiveBlock_DeletesBadBlock(t *testing.T) {
t.Errorf("Expected block processing to fail, received: %v", err)
}
savedBlock, err := db.Block(blockRoot)
savedBlock, err := db.BlockDeprecated(blockRoot)
if err != nil {
t.Fatal(err)
}
@@ -389,11 +392,11 @@ func TestReceiveBlock_CheckBlockStateRoot_GoodState(t *testing.T) {
BodyRoot: bodyRoot[:],
}
parentHash, genesisBlock := setupGenesisBlock(t, chainService)
if err := chainService.beaconDB.SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
t.Fatal(err)
}
beaconState.Slot++
if err := chainService.beaconDB.UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
t.Fatal(err)
}
@@ -430,7 +433,7 @@ func TestReceiveBlock_CheckBlockStateRoot_GoodState(t *testing.T) {
t.Error(err)
}
if err := chainService.beaconDB.SaveBlock(goodStateBlock); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(goodStateBlock); err != nil {
t.Fatal(err)
}
@@ -464,11 +467,11 @@ func TestReceiveBlock_CheckBlockStateRoot_BadState(t *testing.T) {
BodyRoot: bodyRoot[:],
}
parentHash, genesisBlock := setupGenesisBlock(t, chainService)
if err := chainService.beaconDB.SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(ctx, beaconState, parentHash); err != nil {
t.Fatal(err)
}
beaconState.Slot++
if err := chainService.beaconDB.UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
t.Fatal(err)
}
@@ -535,7 +538,7 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
}
beaconState.Eth1Data.DepositCount = 1
beaconState.Eth1DepositIndex = 0
if err := chainService.beaconDB.SaveJustifiedState(beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedState(beaconState); err != nil {
t.Fatal(err)
}
if err := db.SaveFinalizedState(beaconState); err != nil {
@@ -548,7 +551,7 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
}
parentHash, genesisBlock := setupGenesisBlock(t, chainService)
beaconState.Slot++
if err := chainService.beaconDB.UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesisBlock, beaconState); err != nil {
t.Fatal(err)
}
@@ -611,7 +614,7 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
beaconState.Slot--
beaconState.Eth1DepositIndex = 0
if err := chainService.beaconDB.SaveState(ctx, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
block, err = initBlockStateRoot(t, block, chainService)
@@ -628,23 +631,23 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
t.Error(err)
}
if err := chainService.beaconDB.SaveJustifiedBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(block); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveFinalizedBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(block); err != nil {
t.Fatal(err)
}
for _, dep := range pendingDeposits {
db.DepositCache.InsertPendingDeposit(chainService.ctx, dep, big.NewInt(0), 0, [32]byte{})
chainService.depositCache.InsertPendingDeposit(chainService.ctx, dep, big.NewInt(0), 0, [32]byte{})
}
if len(db.DepositCache.PendingDeposits(chainService.ctx, nil)) != len(pendingDeposits) || len(pendingDeposits) == 0 {
if len(chainService.depositCache.PendingDeposits(chainService.ctx, nil)) != len(pendingDeposits) || len(pendingDeposits) == 0 {
t.Fatalf("Expected %d pending deposits", len(pendingDeposits))
}
beaconState.Slot--
if err := chainService.beaconDB.SaveState(ctx, beaconState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
if err := db.SaveHistoricalState(context.Background(), beaconState, blockRoot); err != nil {
@@ -666,8 +669,8 @@ func TestReceiveBlock_RemovesPendingDeposits(t *testing.T) {
t.Fatal(err)
}
if len(db.DepositCache.PendingDeposits(chainService.ctx, nil)) != 0 {
t.Fatalf("Expected 0 pending deposits, but there are %+v", db.DepositCache.PendingDeposits(chainService.ctx, nil))
if len(chainService.depositCache.PendingDeposits(chainService.ctx, nil)) != 0 {
t.Fatalf("Expected 0 pending deposits, but there are %+v", chainService.depositCache.PendingDeposits(chainService.ctx, nil))
}
testutil.AssertLogsContain(t, hook, "Executing state transition")
}
@@ -785,7 +788,7 @@ func TestReceiveBlock_OnChainSplit(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err = db.SaveBlock(block); err != nil {
if err = db.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err = db.UpdateChainHead(ctx, block, computedState); err != nil {
@@ -863,7 +866,7 @@ func TestReceiveBlock_OnChainSplit(t *testing.T) {
t.Fatal(err)
}
if err := db.SaveBlock(blockF); err != nil {
if err := db.SaveBlockDeprecated(blockF); err != nil {
t.Fatal(err)
}
@@ -954,7 +957,7 @@ func TestIsBlockReadyForProcessing_ValidBlock(t *testing.T) {
if err != nil {
t.Fatalf("Could not tree hash state: %v", err)
}
if err := chainService.beaconDB.SaveBlock(genesis); err != nil {
if err := chainService.beaconDB.SaveBlock(ctx, genesis); err != nil {
t.Fatalf("cannot save block: %v", err)
}
parentRoot, err := ssz.SigningRoot(genesis)
@@ -1007,6 +1010,7 @@ func TestIsBlockReadyForProcessing_ValidBlock(t *testing.T) {
func TestDeleteValidatorIdx_DeleteWorks(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
epoch := uint64(2)
v.InsertActivatedIndices(epoch+1, []uint64{0, 1, 2})
v.InsertExitedVal(epoch+1, []uint64{0, 2})
@@ -1023,14 +1027,14 @@ func TestDeleteValidatorIdx_DeleteWorks(t *testing.T) {
Slot: epoch * params.BeaconConfig().SlotsPerEpoch,
}
chainService := setupBeaconChain(t, db, nil)
if err := chainService.saveValidatorIdx(state); err != nil {
if err := chainService.saveValidatorIdx(ctx, state); err != nil {
t.Fatalf("Could not save validator idx: %v", err)
}
if err := chainService.deleteValidatorIdx(state); err != nil {
if err := chainService.deleteValidatorIdx(ctx, state); err != nil {
t.Fatalf("Could not delete validator idx: %v", err)
}
wantedIdx := uint64(1)
idx, err := chainService.beaconDB.ValidatorIndex(validators[wantedIdx].PublicKey)
idx, _, err := chainService.beaconDB.ValidatorIndex(ctx, bytesutil.ToBytes48(validators[wantedIdx].PublicKey))
if err != nil {
t.Fatalf("Could not get validator index: %v", err)
}
@@ -1039,7 +1043,7 @@ func TestDeleteValidatorIdx_DeleteWorks(t *testing.T) {
}
wantedIdx = uint64(2)
if chainService.beaconDB.HasValidator(validators[wantedIdx].PublicKey) {
if chainService.beaconDB.(*db2.BeaconDB).HasValidator(validators[wantedIdx].PublicKey) {
t.Errorf("Validator index %d should have been deleted", wantedIdx)
}
if v.ExitedValFromEpoch(epoch) != nil {
@@ -1050,6 +1054,7 @@ func TestDeleteValidatorIdx_DeleteWorks(t *testing.T) {
func TestSaveValidatorIdx_SaveRetrieveWorks(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
epoch := uint64(1)
v.InsertActivatedIndices(epoch+1, []uint64{0, 1, 2})
var validators []*ethpb.Validator
@@ -1065,12 +1070,12 @@ func TestSaveValidatorIdx_SaveRetrieveWorks(t *testing.T) {
Slot: epoch * params.BeaconConfig().SlotsPerEpoch,
}
chainService := setupBeaconChain(t, db, nil)
if err := chainService.saveValidatorIdx(state); err != nil {
if err := chainService.saveValidatorIdx(ctx, state); err != nil {
t.Fatalf("Could not save validator idx: %v", err)
}
wantedIdx := uint64(2)
idx, err := chainService.beaconDB.ValidatorIndex(validators[wantedIdx].PublicKey)
idx, _, err := chainService.beaconDB.ValidatorIndex(ctx, bytesutil.ToBytes48(validators[wantedIdx].PublicKey))
if err != nil {
t.Fatalf("Could not get validator index: %v", err)
}
@@ -1087,6 +1092,7 @@ func TestSaveValidatorIdx_IdxNotInState(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
epoch := uint64(100)
ctx := context.Background()
// Tried to insert 5 active indices to DB with only 3 validators in state
v.InsertActivatedIndices(epoch+1, []uint64{0, 1, 2, 3, 4})
@@ -1103,12 +1109,12 @@ func TestSaveValidatorIdx_IdxNotInState(t *testing.T) {
Slot: epoch * params.BeaconConfig().SlotsPerEpoch,
}
chainService := setupBeaconChain(t, db, nil)
if err := chainService.saveValidatorIdx(state); err != nil {
if err := chainService.saveValidatorIdx(ctx, state); err != nil {
t.Fatalf("Could not save validator idx: %v", err)
}
wantedIdx := uint64(2)
idx, err := chainService.beaconDB.ValidatorIndex(validators[wantedIdx].PublicKey)
idx, _, err := chainService.beaconDB.ValidatorIndex(ctx, bytesutil.ToBytes48(validators[wantedIdx].PublicKey))
if err != nil {
t.Fatalf("Could not get validator index: %v", err)
}

50
beacon-chain/blockchain/fork_choice_deprecated.go
View File

@@ -45,7 +45,7 @@ type TargetsFetcher interface {
// the db with the latest FFG check points, both justification and finalization.
func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconState) error {
lastJustifiedSlot := helpers.StartSlot(state.CurrentJustifiedCheckpoint.Epoch)
savedJustifiedBlock, err := c.beaconDB.JustifiedBlock()
savedJustifiedBlock, err := c.beaconDB.(*db.BeaconDB).JustifiedBlock()
if err != nil {
return err
}
@@ -53,7 +53,7 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
// the slot of justified block saved in DB.
if lastJustifiedSlot > savedJustifiedBlock.Slot {
// Retrieve the new justified block from DB using the new justified slot and save it.
newJustifiedBlock, err := c.beaconDB.CanonicalBlockBySlot(ctx, lastJustifiedSlot)
newJustifiedBlock, err := c.beaconDB.(*db.BeaconDB).CanonicalBlockBySlot(ctx, lastJustifiedSlot)
if err != nil {
return err
}
@@ -63,7 +63,7 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
for newJustifiedBlock == nil {
log.WithField("slot", lastAvailBlkSlot).Debug("Missing block in DB, looking one slot back")
lastAvailBlkSlot--
newJustifiedBlock, err = c.beaconDB.CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
newJustifiedBlock, err = c.beaconDB.(*db.BeaconDB).CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
if err != nil {
return err
}
@@ -74,20 +74,20 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
return err
}
// Fetch justified state from historical states db.
newJustifiedState, err := c.beaconDB.HistoricalStateFromSlot(ctx, newJustifiedBlock.Slot, newJustifiedRoot)
newJustifiedState, err := c.beaconDB.(*db.BeaconDB).HistoricalStateFromSlot(ctx, newJustifiedBlock.Slot, newJustifiedRoot)
if err != nil {
return err
}
if err := c.beaconDB.SaveJustifiedBlock(newJustifiedBlock); err != nil {
if err := c.beaconDB.(*db.BeaconDB).SaveJustifiedBlock(newJustifiedBlock); err != nil {
return err
}
if err := c.beaconDB.SaveJustifiedState(newJustifiedState); err != nil {
if err := c.beaconDB.(*db.BeaconDB).SaveJustifiedState(newJustifiedState); err != nil {
return err
}
}
lastFinalizedSlot := helpers.StartSlot(state.FinalizedCheckpoint.Epoch)
savedFinalizedBlock, err := c.beaconDB.FinalizedBlock()
savedFinalizedBlock, err := c.beaconDB.(*db.BeaconDB).FinalizedBlock()
// If the last processed finalized slot in state is greater than
// the slot of finalized block saved in DB.
if err != nil {
@@ -95,7 +95,7 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
}
if lastFinalizedSlot > savedFinalizedBlock.Slot {
// Retrieve the new finalized block from DB using the new finalized slot and save it.
newFinalizedBlock, err := c.beaconDB.CanonicalBlockBySlot(ctx, lastFinalizedSlot)
newFinalizedBlock, err := c.beaconDB.(*db.BeaconDB).CanonicalBlockBySlot(ctx, lastFinalizedSlot)
if err != nil {
return err
}
@@ -105,7 +105,7 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
for newFinalizedBlock == nil {
log.WithField("slot", lastAvailBlkSlot).Debug("Missing block in DB, looking one slot back")
lastAvailBlkSlot--
newFinalizedBlock, err = c.beaconDB.CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
newFinalizedBlock, err = c.beaconDB.(*db.BeaconDB).CanonicalBlockBySlot(ctx, lastAvailBlkSlot)
if err != nil {
return err
}
@@ -117,14 +117,14 @@ func (c *ChainService) updateFFGCheckPts(ctx context.Context, state *pb.BeaconSt
}
// Generate the new finalized state with using new finalized block and
// save it.
newFinalizedState, err := c.beaconDB.HistoricalStateFromSlot(ctx, lastFinalizedSlot, newFinalizedRoot)
newFinalizedState, err := c.beaconDB.(*db.BeaconDB).HistoricalStateFromSlot(ctx, lastFinalizedSlot, newFinalizedRoot)
if err != nil {
return err
}
if err := c.beaconDB.SaveFinalizedBlock(newFinalizedBlock); err != nil {
if err := c.beaconDB.(*db.BeaconDB).SaveFinalizedBlock(newFinalizedBlock); err != nil {
return err
}
if err := c.beaconDB.SaveFinalizedState(newFinalizedState); err != nil {
if err := c.beaconDB.(*db.BeaconDB).SaveFinalizedState(newFinalizedState); err != nil {
return err
}
}
@@ -144,7 +144,7 @@ func (c *ChainService) ApplyForkChoiceRuleDeprecated(
defer span.End()
log.Info("Applying LMD-GHOST Fork Choice Rule")
justifiedState, err := c.beaconDB.JustifiedState()
justifiedState, err := c.beaconDB.(*db.BeaconDB).JustifiedState()
if err != nil {
return errors.Wrap(err, "could not retrieve justified state")
}
@@ -152,7 +152,7 @@ func (c *ChainService) ApplyForkChoiceRuleDeprecated(
if err != nil {
return errors.Wrap(err, "could not retrieve attestation target")
}
justifiedHead, err := c.beaconDB.JustifiedBlock()
justifiedHead, err := c.beaconDB.(*db.BeaconDB).JustifiedBlock()
if err != nil {
return errors.Wrap(err, "could not retrieve justified head")
}
@@ -169,7 +169,7 @@ func (c *ChainService) ApplyForkChoiceRuleDeprecated(
defer c.canonicalBlocksLock.Unlock()
c.canonicalBlocks[newHead.Slot] = newHeadRoot[:]
currentHead, err := c.beaconDB.ChainHead()
currentHead, err := c.beaconDB.(*db.BeaconDB).ChainHead()
if err != nil {
return errors.Wrap(err, "could not retrieve chain head")
}
@@ -192,7 +192,7 @@ func (c *ChainService) ApplyForkChoiceRuleDeprecated(
"newRoot": fmt.Sprintf("%#x", bytesutil.Trunc(newHeadRoot[:])),
}).Warn("Reorg happened")
// Only regenerate head state if there was a reorg.
newState, err = c.beaconDB.HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
newState, err = c.beaconDB.(*db.BeaconDB).HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
if err != nil {
return errors.Wrap(err, "could not gen state")
}
@@ -212,13 +212,13 @@ func (c *ChainService) ApplyForkChoiceRuleDeprecated(
// If we receive forked blocks.
if newHead.Slot != newState.Slot {
newState, err = c.beaconDB.HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
newState, err = c.beaconDB.(*db.BeaconDB).HistoricalStateFromSlot(ctx, newHead.Slot, newHeadRoot)
if err != nil {
return errors.Wrap(err, "could not gen state")
}
}
if err := c.beaconDB.UpdateChainHead(ctx, newHead, newState); err != nil {
if err := c.beaconDB.(*db.BeaconDB).UpdateChainHead(ctx, newHead, newState); err != nil {
return errors.Wrap(err, "failed to update chain")
}
h, err := ssz.SigningRoot(newHead)
@@ -268,7 +268,7 @@ func (c *ChainService) lmdGhost(
startState *pb.BeaconState,
voteTargets map[uint64]*pb.AttestationTarget,
) (*ethpb.BeaconBlock, error) {
highestSlot := c.beaconDB.HighestBlockSlot()
highestSlot := c.beaconDB.(*db.BeaconDB).HighestBlockSlot()
head := startBlock
for {
children, err := c.BlockChildren(ctx, head, highestSlot)
@@ -280,12 +280,12 @@ func (c *ChainService) lmdGhost(
}
maxChild := children[0]
maxChildVotes, err := VoteCount(maxChild, startState, voteTargets, c.beaconDB)
maxChildVotes, err := VoteCount(maxChild, startState, voteTargets, c.beaconDB.(*db.BeaconDB))
if err != nil {
return nil, errors.Wrap(err, "unable to determine vote count for block")
}
for i := 1; i < len(children); i++ {
candidateChildVotes, err := VoteCount(children[i], startState, voteTargets, c.beaconDB)
candidateChildVotes, err := VoteCount(children[i], startState, voteTargets, c.beaconDB.(*db.BeaconDB))
if err != nil {
return nil, errors.Wrap(err, "unable to determine vote count for block")
}
@@ -326,7 +326,7 @@ func (c *ChainService) BlockChildren(ctx context.Context, block *ethpb.BeaconBlo
var children []*ethpb.BeaconBlock
startSlot := block.Slot + 1
for i := startSlot; i <= highestSlot; i++ {
kids, err := c.beaconDB.BlocksBySlot(ctx, i)
kids, err := c.beaconDB.(*db.BeaconDB).BlocksBySlot(ctx, i)
if err != nil {
return nil, errors.Wrap(err, "could not get block by slot")
}
@@ -353,7 +353,7 @@ func (c *ChainService) isDescendant(currentHead *ethpb.BeaconBlock, newHead *eth
if bytesutil.ToBytes32(newHead.ParentRoot) == currentHeadRoot {
return true, nil
}
newHead, err = c.beaconDB.Block(bytesutil.ToBytes32(newHead.ParentRoot))
newHead, err = c.beaconDB.(*db.BeaconDB).BlockDeprecated(bytesutil.ToBytes32(newHead.ParentRoot))
if err != nil {
return false, err
}
@@ -449,7 +449,7 @@ func BlockAncestor(targetBlock *pb.AttestationTarget, slot uint64, beaconDB *db.
return nil, nil
}
parentRoot := bytesutil.ToBytes32(targetBlock.ParentRoot)
parent, err := beaconDB.Block(parentRoot)
parent, err := beaconDB.BlockDeprecated(parentRoot)
if err != nil {
return nil, errors.Wrap(err, "could not get parent block")
}
@@ -480,7 +480,7 @@ func cachedAncestor(target *pb.AttestationTarget, height uint64, beaconDB *db.Be
if err != nil {
return nil, err
}
ancestor, err := beaconDB.Block(bytesutil.ToBytes32(ancestorRoot))
ancestor, err := beaconDB.BlockDeprecated(bytesutil.ToBytes32(ancestorRoot))
if err != nil {
return nil, err
}

225
beacon-chain/blockchain/fork_choice_deprecated_test.go
View File

@@ -15,6 +15,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -87,15 +88,15 @@ func TestApplyForkChoice_SetsCanonicalHead(t *testing.T) {
&attestation.Config{BeaconDB: beaconDb})
chainService := setupBeaconChain(t, beaconDb, attsService)
if err := chainService.beaconDB.SaveBlock(
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(
genesis); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveJustifiedBlock(
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(
genesis); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveJustifiedState(
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedState(
beaconState); err != nil {
t.Fatal(err)
}
@@ -119,10 +120,10 @@ func TestApplyForkChoice_SetsCanonicalHead(t *testing.T) {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveBlock(block); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveHistoricalState(context.Background(), beaconState, blockRoot); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(context.Background(), beaconState, blockRoot); err != nil {
t.Fatal(err)
}
if err := chainService.ApplyForkChoiceRuleDeprecated(context.Background(), block, tt.state); err != nil {
@@ -139,13 +140,13 @@ func TestVoteCount_ParentDoesNotExistNoVoteCount(t *testing.T) {
beaconDB := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, beaconDB)
genesisBlock := b.NewGenesisBlock([]byte("stateroot"))
if err := beaconDB.SaveBlock(genesisBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(genesisBlock); err != nil {
t.Fatal(err)
}
potentialHead := &ethpb.BeaconBlock{
ParentRoot: []byte{'A'}, // We give a bogus parent root hash.
}
if err := beaconDB.SaveBlock(potentialHead); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead); err != nil {
t.Fatal(err)
}
headRoot, err := ssz.SigningRoot(potentialHead)
@@ -176,7 +177,7 @@ func TestVoteCount_IncreaseCountCorrectly(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(genesisBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(genesisBlock); err != nil {
t.Fatal(err)
}
@@ -198,10 +199,10 @@ func TestVoteCount_IncreaseCountCorrectly(t *testing.T) {
t.Fatal(err)
}
// We store these potential heads in the DB.
if err := beaconDB.SaveBlock(potentialHead); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead); err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(potentialHead2); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead2); err != nil {
t.Fatal(err)
}
beaconState := &pb.BeaconState{Validators: []*ethpb.Validator{{EffectiveBalance: 1e9}, {EffectiveBalance: 1e9}}}
@@ -239,12 +240,12 @@ func TestAttestationTargets_RetrieveWorks(t *testing.T) {
ExitEpoch: params.BeaconConfig().FarFutureEpoch}},
}
if err := beaconDB.SaveState(ctx, beaconState); err != nil {
if err := beaconDB.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatalf("could not save state: %v", err)
}
block := &ethpb.BeaconBlock{Slot: 100}
if err := beaconDB.SaveBlock(block); err != nil {
if err := beaconDB.SaveBlockDeprecated(block); err != nil {
t.Fatalf("could not save block: %v", err)
}
blockRoot, err := ssz.SigningRoot(block)
@@ -303,10 +304,10 @@ func TestBlockChildren_2InARow(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -318,10 +319,10 @@ func TestBlockChildren_2InARow(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block2, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block2, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -329,10 +330,10 @@ func TestBlockChildren_2InARow(t *testing.T) {
Slot: 3,
ParentRoot: root2[:],
}
if err = chainService.beaconDB.SaveBlock(block3); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block3, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block3, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -373,10 +374,10 @@ func TestBlockChildren_ChainSplits(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -384,10 +385,10 @@ func TestBlockChildren_ChainSplits(t *testing.T) {
Slot: 2,
ParentRoot: root1[:],
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block2, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block2, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -395,10 +396,10 @@ func TestBlockChildren_ChainSplits(t *testing.T) {
Slot: 3,
ParentRoot: root1[:],
}
if err = chainService.beaconDB.SaveBlock(block3); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block3, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block3, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -406,10 +407,10 @@ func TestBlockChildren_ChainSplits(t *testing.T) {
Slot: 4,
ParentRoot: root1[:],
}
if err = chainService.beaconDB.SaveBlock(block4); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block4); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block4, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block4, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -448,10 +449,10 @@ func TestBlockChildren_SkipSlots(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -463,10 +464,10 @@ func TestBlockChildren_SkipSlots(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block5); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block5); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block5, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block5, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -474,10 +475,10 @@ func TestBlockChildren_SkipSlots(t *testing.T) {
Slot: 9,
ParentRoot: root2[:],
}
if err = chainService.beaconDB.SaveBlock(block9); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block9); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block9, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block9, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -518,10 +519,10 @@ func TestLMDGhost_TrivialHeadUpdate(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -533,10 +534,10 @@ func TestLMDGhost_TrivialHeadUpdate(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block2, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block2, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -592,10 +593,10 @@ func TestLMDGhost_3WayChainSplitsSameHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -607,10 +608,10 @@ func TestLMDGhost_3WayChainSplitsSameHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block2, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block2, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -622,10 +623,10 @@ func TestLMDGhost_3WayChainSplitsSameHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block3); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block3, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block3, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -637,10 +638,10 @@ func TestLMDGhost_3WayChainSplitsSameHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block4); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block4); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block4, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block4, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -699,7 +700,7 @@ func TestIsDescendant_Ok(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block2 := &ethpb.BeaconBlock{
@@ -710,7 +711,7 @@ func TestIsDescendant_Ok(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block3 := &ethpb.BeaconBlock{
@@ -721,7 +722,7 @@ func TestIsDescendant_Ok(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block3); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block4 := &ethpb.BeaconBlock{
@@ -732,7 +733,7 @@ func TestIsDescendant_Ok(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block4); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block4); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block5 := &ethpb.BeaconBlock{
@@ -743,7 +744,7 @@ func TestIsDescendant_Ok(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block5); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block5); err != nil {
t.Fatalf("Could not save block: %v", err)
}
@@ -797,10 +798,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block1); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block1, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block1, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -812,10 +813,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block2); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block2, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block2, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -827,10 +828,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block3); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block3, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block3, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -842,10 +843,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block4); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block4); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block4, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block4, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -857,10 +858,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block5); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block5); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block5, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block5, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -872,10 +873,10 @@ func TestLMDGhost_2WayChainSplitsDiffHeight(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(block6); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block6); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block6, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block6, beaconState); err != nil {
t.Fatalf("Could update chain head: %v", err)
}
@@ -937,10 +938,10 @@ func BenchmarkLMDGhost_8Slots_8Validators(b *testing.B) {
if err != nil {
b.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(genesis); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(genesis); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, genesis, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesis, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
@@ -950,10 +951,10 @@ func BenchmarkLMDGhost_8Slots_8Validators(b *testing.B) {
Slot: uint64(i),
ParentRoot: root[:],
}
if err = chainService.beaconDB.SaveBlock(block); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
root, err = ssz.SigningRoot(block)
@@ -1018,10 +1019,10 @@ func BenchmarkLMDGhost_32Slots_8Validators(b *testing.B) {
if err != nil {
b.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(genesis); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(genesis); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, genesis, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesis, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
@@ -1031,10 +1032,10 @@ func BenchmarkLMDGhost_32Slots_8Validators(b *testing.B) {
Slot: uint64(i),
ParentRoot: root[:],
}
if err = chainService.beaconDB.SaveBlock(block); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
root, err = ssz.SigningRoot(block)
@@ -1097,10 +1098,10 @@ func BenchmarkLMDGhost_32Slots_64Validators(b *testing.B) {
if err != nil {
b.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(genesis); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(genesis); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, genesis, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesis, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
@@ -1110,10 +1111,10 @@ func BenchmarkLMDGhost_32Slots_64Validators(b *testing.B) {
Slot: uint64(i),
ParentRoot: root[:],
}
if err = chainService.beaconDB.SaveBlock(block); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
root, err = ssz.SigningRoot(block)
@@ -1176,10 +1177,10 @@ func BenchmarkLMDGhost_64Slots_16384Validators(b *testing.B) {
if err != nil {
b.Fatalf("Could not hash block: %v", err)
}
if err = chainService.beaconDB.SaveBlock(genesis); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(genesis); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, genesis, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, genesis, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
@@ -1189,10 +1190,10 @@ func BenchmarkLMDGhost_64Slots_16384Validators(b *testing.B) {
Slot: uint64(i),
ParentRoot: root[:],
}
if err = chainService.beaconDB.SaveBlock(block); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
b.Fatalf("Could not save block: %v", err)
}
if err = chainService.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err = chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
b.Fatalf("Could update chain head: %v", err)
}
root, err = ssz.SigningRoot(block)
@@ -1270,24 +1271,24 @@ func TestUpdateFFGCheckPts_NewJustifiedSlot(t *testing.T) {
chainSvc := setupBeaconChain(t, beaconDB, nil)
gBlockRoot, gBlock, gState, privKeys := setupFFGTest(t)
if err := chainSvc.beaconDB.SaveBlock(gBlock); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(gBlock); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, gBlock, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, gBlock, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.SaveFinalizedState(gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedState(gState); err != nil {
t.Fatal(err)
}
// Last justified check point happened at slot 0.
if err := chainSvc.beaconDB.SaveJustifiedBlock(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(
&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
t.Fatal(err)
}
// Also saved finalized block to slot 0 to test justification case only.
if err := chainSvc.beaconDB.SaveFinalizedBlock(&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
t.Fatal(err)
}
@@ -1306,10 +1307,10 @@ func TestUpdateFFGCheckPts_NewJustifiedSlot(t *testing.T) {
Body: &ethpb.BeaconBlockBody{
RandaoReveal: epochSignature,
}}
if err := chainSvc.beaconDB.SaveBlock(block); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, block, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.updateFFGCheckPts(ctx, gState); err != nil {
@@ -1318,11 +1319,11 @@ func TestUpdateFFGCheckPts_NewJustifiedSlot(t *testing.T) {
// Getting latest justification check point from DB and
// verify they have been updated.
newJustifiedState, err := chainSvc.beaconDB.JustifiedState()
newJustifiedState, err := chainSvc.beaconDB.(*db2.BeaconDB).JustifiedState()
if err != nil {
t.Fatal(err)
}
newJustifiedBlock, err := chainSvc.beaconDB.JustifiedBlock()
newJustifiedBlock, err := chainSvc.beaconDB.(*db2.BeaconDB).JustifiedBlock()
if err != nil {
t.Fatal(err)
}
@@ -1346,22 +1347,22 @@ func TestUpdateFFGCheckPts_NewFinalizedSlot(t *testing.T) {
ctx := context.Background()
gBlockRoot, gBlock, gState, privKeys := setupFFGTest(t)
if err := chainSvc.beaconDB.SaveBlock(gBlock); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(gBlock); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, gBlock, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, gBlock, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.SaveFinalizedState(gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedState(gState); err != nil {
t.Fatal(err)
}
// Last finalized check point happened at slot 0.
if err := chainSvc.beaconDB.SaveFinalizedBlock(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(
gBlock); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.SaveFinalizedState(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedState(
gState); err != nil {
t.Fatal(err)
}
@@ -1370,7 +1371,7 @@ func TestUpdateFFGCheckPts_NewFinalizedSlot(t *testing.T) {
offset := uint64(64)
// Also saved justified block to slot 0 to test finalized case only.
if err := chainSvc.beaconDB.SaveJustifiedBlock(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(
&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
t.Fatal(err)
}
@@ -1388,10 +1389,10 @@ func TestUpdateFFGCheckPts_NewFinalizedSlot(t *testing.T) {
RandaoReveal: epochSignature,
}}
if err := chainSvc.beaconDB.SaveBlock(block); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, block, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.updateFFGCheckPts(ctx, gState); err != nil {
@@ -1400,11 +1401,11 @@ func TestUpdateFFGCheckPts_NewFinalizedSlot(t *testing.T) {
// Getting latest justification check point from DB and
// verify they have been updated.
newFinalizedState, err := chainSvc.beaconDB.FinalizedState()
newFinalizedState, err := chainSvc.beaconDB.(*db2.BeaconDB).FinalizedState()
if err != nil {
t.Fatal(err)
}
newFinalizedBlock, err := chainSvc.beaconDB.FinalizedBlock()
newFinalizedBlock, err := chainSvc.beaconDB.(*db2.BeaconDB).FinalizedBlock()
if err != nil {
t.Fatal(err)
}
@@ -1428,24 +1429,24 @@ func TestUpdateFFGCheckPts_NewJustifiedSkipSlot(t *testing.T) {
chainSvc := setupBeaconChain(t, beaconDB, nil)
gBlockRoot, gBlock, gState, privKeys := setupFFGTest(t)
if err := chainSvc.beaconDB.SaveBlock(gBlock); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(gBlock); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, gBlock, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, gBlock, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.SaveFinalizedState(gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedState(gState); err != nil {
t.Fatal(err)
}
// Last justified check point happened at slot 0.
if err := chainSvc.beaconDB.SaveJustifiedBlock(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(
&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
t.Fatal(err)
}
// Also saved finalized block to slot 0 to test justification case only.
if err := chainSvc.beaconDB.SaveFinalizedBlock(
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(
&ethpb.BeaconBlock{Slot: genesisSlot}); err != nil {
t.Fatal(err)
}
@@ -1465,7 +1466,7 @@ func TestUpdateFFGCheckPts_NewJustifiedSkipSlot(t *testing.T) {
Body: &ethpb.BeaconBlockBody{
RandaoReveal: epochSignature,
}}
if err := chainSvc.beaconDB.SaveBlock(block); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
blockHeader, err := b.HeaderFromBlock(block)
@@ -1476,10 +1477,10 @@ func TestUpdateFFGCheckPts_NewJustifiedSkipSlot(t *testing.T) {
Slot: genesisSlot + lastAvailableSlot,
LatestBlockHeader: blockHeader,
}
if err := chainSvc.beaconDB.SaveState(ctx, computedState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).SaveStateDeprecated(ctx, computedState); err != nil {
t.Fatal(err)
}
if err := chainSvc.beaconDB.UpdateChainHead(ctx, block, gState); err != nil {
if err := chainSvc.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, gState); err != nil {
t.Fatal(err)
}
if err := chainSvc.updateFFGCheckPts(ctx, gState); err != nil {
@@ -1488,11 +1489,11 @@ func TestUpdateFFGCheckPts_NewJustifiedSkipSlot(t *testing.T) {
// Getting latest justification check point from DB and
// verify they have been updated.
newJustifiedState, err := chainSvc.beaconDB.JustifiedState()
newJustifiedState, err := chainSvc.beaconDB.(*db2.BeaconDB).JustifiedState()
if err != nil {
t.Fatal(err)
}
newJustifiedBlock, err := chainSvc.beaconDB.JustifiedBlock()
newJustifiedBlock, err := chainSvc.beaconDB.(*db2.BeaconDB).JustifiedBlock()
if err != nil {
t.Fatal(err)
}
@@ -1582,7 +1583,7 @@ func TestVoteCount_CacheEnabledAndMiss(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(genesisBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(genesisBlock); err != nil {
t.Fatal(err)
}
@@ -1603,10 +1604,10 @@ func TestVoteCount_CacheEnabledAndMiss(t *testing.T) {
t.Fatal(err)
}
// We store these potential heads in the DB.
if err := beaconDB.SaveBlock(potentialHead); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead); err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(potentialHead2); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead2); err != nil {
t.Fatal(err)
}
beaconState := &pb.BeaconState{Validators: []*ethpb.Validator{{EffectiveBalance: 1e9}, {EffectiveBalance: 1e9}}}
@@ -1649,7 +1650,7 @@ func TestVoteCount_CacheEnabledAndHit(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(genesisBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(genesisBlock); err != nil {
t.Fatal(err)
}
@@ -1665,10 +1666,10 @@ func TestVoteCount_CacheEnabledAndHit(t *testing.T) {
pHeadHash2, _ := ssz.SigningRoot(potentialHead2)
// We store these potential heads in the DB.
if err := beaconDB.SaveBlock(potentialHead); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead); err != nil {
t.Fatal(err)
}
if err := beaconDB.SaveBlock(potentialHead2); err != nil {
if err := beaconDB.SaveBlockDeprecated(potentialHead2); err != nil {
t.Fatal(err)
}

23
beacon-chain/blockchain/fork_choice_reorg_deprecated_test.go
View File

@@ -7,6 +7,7 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -54,16 +55,16 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
// We then setup a canonical chain of the following blocks:
// B0->B1->B3->B5.
if err := chainService.beaconDB.SaveBlock(blocks[0]); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(blocks[0]); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveJustifiedState(justifiedState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedState(justifiedState); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveJustifiedBlock(blocks[0]); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveJustifiedBlock(blocks[0]); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.UpdateChainHead(ctx, blocks[0], justifiedState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, blocks[0], justifiedState); err != nil {
t.Fatal(err)
}
canonicalBlockIndices := []int{1, 3, 5}
@@ -73,15 +74,15 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveBlock(blocks[canonicalIndex]); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(blocks[canonicalIndex]); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.UpdateChainHead(ctx, blocks[canonicalIndex], postState); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, blocks[canonicalIndex], postState); err != nil {
t.Fatal(err)
}
}
chainHead, err := chainService.beaconDB.ChainHead()
chainHead, err := chainService.beaconDB.(*db2.BeaconDB).ChainHead()
if err != nil {
t.Fatal(err)
}
@@ -102,10 +103,10 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveBlock(blocks[forkIndex]); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(blocks[forkIndex]); err != nil {
t.Fatal(err)
}
if err := chainService.beaconDB.SaveHistoricalState(ctx, forkState, roots[forkIndex]); err != nil {
if err := chainService.beaconDB.(*db2.BeaconDB).SaveHistoricalState(ctx, forkState, roots[forkIndex]); err != nil {
t.Fatal(err)
}
}
@@ -129,7 +130,7 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
}
chainService.attsService = attHandler
block4State, err := chainService.beaconDB.HistoricalStateFromSlot(ctx, blocks[4].Slot, roots[4])
block4State, err := chainService.beaconDB.(*db2.BeaconDB).HistoricalStateFromSlot(ctx, blocks[4].Slot, roots[4])
if err != nil {
t.Fatal(err)
}
@@ -138,7 +139,7 @@ func TestApplyForkChoice_ChainSplitReorg(t *testing.T) {
t.Fatal(err)
}
newHead, err := chainService.beaconDB.ChainHead()
newHead, err := chainService.beaconDB.(*db2.BeaconDB).ChainHead()
if err != nil {
t.Fatal(err)
}

37
beacon-chain/blockchain/service.go
View File

@@ -14,6 +14,7 @@ import (
"github.com/pkg/errors"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/attestation"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/operations"
@@ -39,7 +40,8 @@ type ChainFeeds interface {
type ChainService struct {
ctx context.Context
cancel context.CancelFunc
beaconDB *db.BeaconDB
beaconDB db.Database
depositCache *depositcache.DepositCache
web3Service *powchain.Web3Service
attsService attestation.TargetHandler
opsPoolService operations.OperationFeeds
@@ -60,7 +62,8 @@ type Config struct {
BeaconBlockBuf int
Web3Service *powchain.Web3Service
AttsService attestation.TargetHandler
BeaconDB *db.BeaconDB
BeaconDB db.Database
DepositCache *depositcache.DepositCache
OpsPoolService operations.OperationFeeds
DevMode bool
P2p p2p.Broadcaster
@@ -75,6 +78,7 @@ func NewChainService(ctx context.Context, cfg *Config) (*ChainService, error) {
ctx: ctx,
cancel: cancel,
beaconDB: cfg.BeaconDB,
depositCache: cfg.DepositCache,
web3Service: cfg.Web3Service,
opsPoolService: cfg.OpsPoolService,
attsService: cfg.AttsService,
@@ -135,10 +139,16 @@ func (c *ChainService) initializeBeaconChain(genesisTime time.Time, deposits []*
log.Info("ChainStart time reached, starting the beacon chain!")
c.genesisTime = genesisTime
unixTime := uint64(genesisTime.Unix())
if err := c.beaconDB.InitializeState(c.ctx, unixTime, deposits, eth1data); err != nil {
// TODO(3219): Use new fork choice service.
db, isLegacyDB := c.beaconDB.(*db.BeaconDB)
if !isLegacyDB {
panic("Chain service cannot operate with the new database interface due to in-progress fork choice changes")
}
if err := db.InitializeState(ctx, unixTime, deposits, eth1data); err != nil {
return nil, errors.Wrap(err, "could not initialize beacon state to disk")
}
beaconState, err := c.beaconDB.HeadState(c.ctx)
beaconState, err := c.beaconDB.HeadState(ctx)
if err != nil {
return nil, errors.Wrap(err, "could not attempt fetch beacon state")
}
@@ -153,29 +163,30 @@ func (c *ChainService) initializeBeaconChain(genesisTime time.Time, deposits []*
return nil, errors.Wrap(err, "could not hash beacon block")
}
if err := c.beaconDB.SaveBlock(genBlock); err != nil {
if err := c.beaconDB.SaveBlock(ctx, genBlock); err != nil {
return nil, errors.Wrap(err, "could not save genesis block to disk")
}
if err := c.beaconDB.SaveAttestationTarget(ctx, &pb.AttestationTarget{
if err := db.SaveAttestationTarget(ctx, &pb.AttestationTarget{
Slot: genBlock.Slot,
BeaconBlockRoot: genBlockRoot[:],
ParentRoot: genBlock.ParentRoot,
}); err != nil {
return nil, errors.Wrap(err, "failed to save attestation target")
}
if err := c.beaconDB.UpdateChainHead(ctx, genBlock, beaconState); err != nil {
if err := db.UpdateChainHead(ctx, genBlock, beaconState); err != nil {
return nil, errors.Wrap(err, "could not set chain head")
}
if err := c.beaconDB.SaveJustifiedBlock(genBlock); err != nil {
if err := db.SaveJustifiedBlock(genBlock); err != nil {
return nil, errors.Wrap(err, "could not save genesis block as justified block")
}
if err := c.beaconDB.SaveFinalizedBlock(genBlock); err != nil {
if err := db.SaveFinalizedBlock(genBlock); err != nil {
return nil, errors.Wrap(err, "could not save genesis block as finalized block")
}
if err := c.beaconDB.SaveJustifiedState(beaconState); err != nil {
if err := db.SaveJustifiedState(beaconState); err != nil {
return nil, errors.Wrap(err, "could not save genesis state as justified state")
}
if err := c.beaconDB.SaveFinalizedState(beaconState); err != nil {
if err := db.SaveFinalizedState(beaconState); err != nil {
return nil, errors.Wrap(err, "could not save genesis state as finalized state")
}
return beaconState, nil
@@ -212,8 +223,8 @@ func (c *ChainService) StateInitializedFeed() *event.Feed {
// ChainHeadRoot returns the hash root of the last beacon block processed by the
// block chain service.
func (c *ChainService) ChainHeadRoot() ([32]byte, error) {
head, err := c.beaconDB.ChainHead()
func (c *ChainService) ChainHeadRoot(ctx context.Context) ([32]byte, error) {
head, err := c.beaconDB.HeadBlock(ctx)
if err != nil {
return [32]byte{}, errors.Wrap(err, "could not retrieve chain head")
}

6
beacon-chain/blockchain/service_test.go
View File

@@ -14,6 +14,7 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/attestation"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
@@ -148,7 +149,7 @@ var _ = p2p.Broadcaster(&mockBroadcaster{})
func setupGenesisBlock(t *testing.T, cs *ChainService) ([32]byte, *ethpb.BeaconBlock) {
genesis := b.NewGenesisBlock([]byte{})
if err := cs.beaconDB.SaveBlock(genesis); err != nil {
if err := cs.beaconDB.SaveBlock(context.Background(), genesis); err != nil {
t.Fatalf("could not save block to db: %v", err)
}
parentHash, err := ssz.SigningRoot(genesis)
@@ -178,6 +179,7 @@ func setupBeaconChain(t *testing.T, beaconDB *db.BeaconDB, attsService *attestat
cfg := &Config{
BeaconBlockBuf: 0,
BeaconDB: beaconDB,
DepositCache: depositcache.NewDepositCache(),
Web3Service: web3Service,
OpsPoolService: &mockOperationService{},
AttsService: attsService,
@@ -201,7 +203,7 @@ func SetSlotInState(service *ChainService, slot uint64) error {
}
bState.Slot = slot
return service.beaconDB.SaveState(context.Background(), bState)
return service.beaconDB.SaveState(context.Background(), bState, [32]byte{})
}
func TestChainStartStop_Uninitialized(t *testing.T) {

2
beacon-chain/core/blocks/block_operations_test.go
View File

@@ -1178,7 +1178,7 @@ func TestProcessAttestations_OK(t *testing.T) {
}
func TestProcessAttestationsNoVerify_OK(t *testing.T) {
// Attestation passes with an empty signature
// Attestation with an empty signature
helpers.ClearAllCaches()
deposits, _ := testutil.SetupInitialDeposits(t, 100)
beaconState, err := state.GenesisBeaconState(deposits, uint64(0), &ethpb.Eth1Data{})

4
beacon-chain/core/blocks/validity_conditions.go
View File

@@ -20,14 +20,14 @@ func IsValidBlock(
ctx context.Context,
state *pb.BeaconState,
block *ethpb.BeaconBlock,
HasBlock func(hash [32]byte) bool,
HasBlock func(ctx context.Context, hash [32]byte) bool,
GetPOWBlock func(ctx context.Context, hash common.Hash) (*gethTypes.Block, error),
genesisTime time.Time) error {
// Pre-Processing Condition 1:
// Check that the parent Block has been processed and saved.
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
parentBlock := HasBlock(parentRoot)
parentBlock := HasBlock(ctx, parentRoot)
if !parentBlock {
return fmt.Errorf("unprocessed parent block as it is not saved in the db: %#x", parentRoot)
}

2
beacon-chain/core/blocks/validity_conditions_test.go
View File

@@ -23,7 +23,7 @@ type mockDB struct {
hasBlock bool
}
func (f *mockDB) HasBlock(h [32]byte) bool {
func (f *mockDB) HasBlock(ctx context.Context, h [32]byte) bool {
return f.hasBlock
}

1
beacon-chain/db/BUILD.bazel
View File

@@ -17,7 +17,6 @@ go_library(
importpath = "github.com/prysmaticlabs/prysm/beacon-chain/db",
visibility = ["//beacon-chain:__subpackages__"],
deps = [
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/blocks:go_default_library",
"//beacon-chain/core/state:go_default_library",
"//beacon-chain/db/filters:go_default_library",

56
beacon-chain/db/attestation.go
View File

@@ -6,12 +6,23 @@ import (
"github.com/boltdb/bolt"
"github.com/gogo/protobuf/proto"
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/hashutil"
"go.opencensus.io/trace"
)
// SaveAttestations in the db.
func (db *BeaconDB) SaveAttestations(ctx context.Context, atts []*ethpb.Attestation) error {
for _, a := range atts {
if err := db.SaveAttestation(ctx, a); err != nil {
return err
}
}
return nil
}
// SaveAttestation puts the attestation record into the beacon chain db.
func (db *BeaconDB) SaveAttestation(ctx context.Context, attestation *ethpb.Attestation) error {
ctx, span := trace.StartSpan(ctx, "beaconDB.SaveAttestation")
@@ -52,20 +63,32 @@ func (db *BeaconDB) SaveAttestationTarget(ctx context.Context, attTarget *pb.Att
}
// DeleteAttestation deletes the attestation record into the beacon chain db.
func (db *BeaconDB) DeleteAttestation(attestation *ethpb.Attestation) error {
hash, err := hashutil.HashProto(attestation.Data)
if err != nil {
return err
}
func (db *BeaconDB) DeleteAttestation(_ context.Context, hash [32]byte) error {
return db.batch(func(tx *bolt.Tx) error {
a := tx.Bucket(attestationBucket)
return a.Delete(hash[:])
})
}
// DeleteAttestationDeprecated deletes the attestation record into the beacon chain db.
// DEPRECATED: Use DeleteAttestation.
func (db *BeaconDB) DeleteAttestationDeprecated(attestation *ethpb.Attestation) error {
hash, err := hashutil.HashProto(attestation.Data)
if err != nil {
return err
}
return db.DeleteAttestation(context.Background(), hash)
}
// Attestation retrieves an attestation record from the db using the hash of attestation.data.
func (db *BeaconDB) Attestation(hash [32]byte) (*ethpb.Attestation, error) {
func (db *BeaconDB) Attestation(_ context.Context, hash [32]byte) (*ethpb.Attestation, error) {
return db.AttestationDeprecated(hash)
}
// AttestationDeprecated retrieves an attestation record from the db using the hash of attestation.data.
// DEPRECATED: Use Attestation.
func (db *BeaconDB) AttestationDeprecated(hash [32]byte) (*ethpb.Attestation, error) {
var attestation *ethpb.Attestation
err := db.view(func(tx *bolt.Tx) error {
a := tx.Bucket(attestationBucket)
@@ -85,7 +108,14 @@ func (db *BeaconDB) Attestation(hash [32]byte) (*ethpb.Attestation, error) {
// Attestations retrieves all the attestation records from the db.
// These are the attestations that have not been seen on the beacon chain.
func (db *BeaconDB) Attestations() ([]*ethpb.Attestation, error) {
func (db *BeaconDB) Attestations(_ context.Context, _ *filters.QueryFilter) ([]*ethpb.Attestation, error) {
return db.AttestationsDeprecated()
}
// AttestationsDeprecated retrieves all the attestation records from the db.
// These are the attestations that have not been seen on the beacon chain.
// DEPRECATED: Use Attestations.
func (db *BeaconDB) AttestationsDeprecated() ([]*ethpb.Attestation, error) {
var attestations []*ethpb.Attestation
err := db.view(func(tx *bolt.Tx) error {
a := tx.Bucket(attestationBucket)
@@ -125,8 +155,8 @@ func (db *BeaconDB) AttestationTarget(hash [32]byte) (*pb.AttestationTarget, err
return attTgt, err
}
// HasAttestation checks if the attestation exists.
func (db *BeaconDB) HasAttestation(hash [32]byte) bool {
// HasAttestation checks if the attestaiton exists.
func (db *BeaconDB) HasAttestation(_ context.Context, hash [32]byte) bool {
exists := false
// #nosec G104
db.view(func(tx *bolt.Tx) error {
@@ -138,6 +168,12 @@ func (db *BeaconDB) HasAttestation(hash [32]byte) bool {
return exists
}
// HasAttestationDeprecated checks if the attestation exists.
// DEPRECATED: Use HasAttestation.
func (db *BeaconDB) HasAttestationDeprecated(hash [32]byte) bool {
return db.HasAttestation(context.Background(), hash)
}
func createAttestation(enc []byte) (*ethpb.Attestation, error) {
protoAttestation := &ethpb.Attestation{}
if err := proto.Unmarshal(enc, protoAttestation); err != nil {

30
beacon-chain/db/attestation_test.go
View File

@@ -30,11 +30,11 @@ func TestSaveAndRetrieveAttestation_OK(t *testing.T) {
aDataHash, err := hashutil.HashProto(a.Data)
if err != nil {
t.Fatalf("Failed to hash Attestation: %v", err)
t.Fatalf("Failed to hash AttestationDeprecated: %v", err)
}
aPrime, err := db.Attestation(aDataHash)
aPrime, err := db.AttestationDeprecated(aDataHash)
if err != nil {
t.Fatalf("Failed to call Attestation: %v", err)
t.Fatalf("Failed to call AttestationDeprecated: %v", err)
}
aEnc, err := proto.Marshal(a)
@@ -69,7 +69,7 @@ func TestRetrieveAttestations_OK(t *testing.T) {
}
}
retrievedAttestations, err := db.Attestations()
retrievedAttestations, err := db.AttestationsDeprecated()
if err != nil {
t.Fatalf("Could not retrieve attestations: %v", err)
}
@@ -101,22 +101,22 @@ func TestDeleteAttestation_OK(t *testing.T) {
aDataHash, err := hashutil.HashProto(a.Data)
if err != nil {
t.Fatalf("Failed to hash Attestation: %v", err)
t.Fatalf("Failed to hash AttestationDeprecated: %v", err)
}
aPrime, err := db.Attestation(aDataHash)
aPrime, err := db.AttestationDeprecated(aDataHash)
if err != nil {
t.Fatalf("Could not call Attestation: %v", err)
t.Fatalf("Could not call AttestationDeprecated: %v", err)
}
if !reflect.DeepEqual(aPrime, a) {
t.Errorf("Saved attestation and retrieved attestation are not equal")
}
if err := db.DeleteAttestation(a); err != nil {
if err := db.DeleteAttestationDeprecated(a); err != nil {
t.Fatalf("Could not delete attestation: %v", err)
}
if db.HasAttestation(aDataHash) {
if db.HasAttestationDeprecated(aDataHash) {
t.Error("Deleted attestation still there")
}
}
@@ -126,7 +126,7 @@ func TestNilAttestation_OK(t *testing.T) {
defer teardownDB(t, db)
nilHash := [32]byte{}
a, err := db.Attestation(nilHash)
a, err := db.AttestationDeprecated(nilHash)
if err != nil {
t.Fatalf("Failed to retrieve nilHash: %v", err)
}
@@ -148,17 +148,17 @@ func TestHasAttestation_OK(t *testing.T) {
}
aDataHash, err := hashutil.HashProto(a.Data)
if err != nil {
t.Fatalf("Failed to hash Attestation: %v", err)
t.Fatalf("Failed to hash AttestationDeprecated: %v", err)
}
if db.HasAttestation(aDataHash) {
t.Fatal("Expected HasAttestation to return false")
if db.HasAttestationDeprecated(aDataHash) {
t.Fatal("Expected HasAttestationDeprecated to return false")
}
if err := db.SaveAttestation(context.Background(), a); err != nil {
t.Fatalf("Failed to save attestation: %v", err)
}
if !db.HasAttestation(aDataHash) {
t.Fatal("Expected HasAttestation to return true")
if !db.HasAttestationDeprecated(aDataHash) {
t.Fatal("Expected HasAttestationDeprecated to return true")
}
}

72
beacon-chain/db/block.go
View File

@@ -11,6 +11,7 @@ import (
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"go.opencensus.io/trace"
@@ -46,7 +47,14 @@ func createBlock(enc []byte) (*ethpb.BeaconBlock, error) {
// Block accepts a block root and returns the corresponding block.
// Returns nil if the block does not exist.
func (db *BeaconDB) Block(root [32]byte) (*ethpb.BeaconBlock, error) {
func (db *BeaconDB) Block(_ context.Context, root [32]byte) (*ethpb.BeaconBlock, error) {
return db.BlockDeprecated(root)
}
// BlockDeprecated accepts a block root and returns the corresponding block.
// Returns nil if the block does not exist.
// DEPRECATED: Use Block.
func (db *BeaconDB) BlockDeprecated(root [32]byte) (*ethpb.BeaconBlock, error) {
db.blocksLock.RLock()
// Return block from cache if it exists
@@ -84,7 +92,7 @@ func (db *BeaconDB) Block(root [32]byte) (*ethpb.BeaconBlock, error) {
}
// HasBlock accepts a block root and returns true if the block does not exist.
func (db *BeaconDB) HasBlock(root [32]byte) bool {
func (db *BeaconDB) HasBlock(_ context.Context, root [32]byte) bool {
db.blocksLock.RLock()
defer db.blocksLock.RUnlock()
@@ -106,6 +114,17 @@ func (db *BeaconDB) HasBlock(root [32]byte) bool {
return hasBlock
}
// HasBlockDeprecated accepts a block root and returns true if the block does not exist.
func (db *BeaconDB) HasBlockDeprecated(root [32]byte) bool {
return db.HasBlock(context.Background(), root)
}
// HeadBlock is not implemented.
// DEPRECATED: Do not use. Not implemented.
func (db *BeaconDB) HeadBlock(_ context.Context) (*ethpb.BeaconBlock, error) {
return nil, errors.New("not implemented")
}
// IsEvilBlockHash determines if a certain block root has been blacklisted
// due to failing to process core state transitions.
func (db *BeaconDB) IsEvilBlockHash(root [32]byte) bool {
@@ -130,8 +149,29 @@ func (db *BeaconDB) MarkEvilBlockHash(root [32]byte) {
badBlockCount.Inc()
}
// SaveBlock accepts a block and writes it to disk.
func (db *BeaconDB) SaveBlock(block *ethpb.BeaconBlock) error {
// SaveHeadBlockRoot is not implemented.
func (db *BeaconDB) SaveHeadBlockRoot(_ context.Context, root [32]byte) error {
return errors.New("not implemented")
}
// SaveBlocks in db.
func (db *BeaconDB) SaveBlocks(ctx context.Context, blocks []*ethpb.BeaconBlock) error {
for _, blk := range blocks {
if err := db.SaveBlock(ctx, blk); err != nil {
return err
}
}
return nil
}
// SaveBlock in db.
func (db *BeaconDB) SaveBlock(_ context.Context, block *ethpb.BeaconBlock) error {
return db.SaveBlockDeprecated(block)
}
// SaveBlockDeprecated accepts a block and writes it to disk.
// DEPRECATED: Use SaveBlock.
func (db *BeaconDB) SaveBlockDeprecated(block *ethpb.BeaconBlock) error {
db.blocksLock.Lock()
defer db.blocksLock.Unlock()
@@ -168,7 +208,15 @@ func (db *BeaconDB) SaveBlock(block *ethpb.BeaconBlock) error {
}
// DeleteBlock deletes a block using the slot and its root as keys in their respective buckets.
func (db *BeaconDB) DeleteBlock(block *ethpb.BeaconBlock) error {
func (db *BeaconDB) DeleteBlock(_ context.Context, hash [32]byte) error {
return db.update(func(tx *bolt.Tx) error {
bucket := tx.Bucket(blockBucket)
return bucket.Delete(hash[:])
})
}
// DeleteBlockDeprecated deletes a block using the slot and its root as keys in their respective buckets.
func (db *BeaconDB) DeleteBlockDeprecated(block *ethpb.BeaconBlock) error {
db.blocksLock.Lock()
defer db.blocksLock.Unlock()
@@ -296,7 +344,7 @@ func (db *BeaconDB) UpdateChainHead(ctx context.Context, block *ethpb.BeaconBloc
db.highestBlockSlot = block.Slot
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
return errors.Wrap(err, "failed to save beacon state as canonical")
}
@@ -397,3 +445,15 @@ func (db *BeaconDB) ClearBlockCache() {
db.blocks = make(map[[32]byte]*ethpb.BeaconBlock)
blockCacheSize.Set(float64(len(db.blocks)))
}
// BlockRoots retrieves a list of beacon block roots by filter criteria.
// DEPRECATED: Not implemented at all. Use github.com/prysmaticlabs/prysm/db/kv
func (db *BeaconDB) BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][]byte, error) {
return nil, errors.New("not implemented")
}
// Blocks retrieves a list of beacon blocks by filter criteria.
// DEPRECATED: Not implemented at all. Use github.com/prysmaticlabs/prysm/db/kv
func (db *BeaconDB) Blocks(ctx context.Context, f *filters.QueryFilter) ([]*ethpb.BeaconBlock, error) {
return nil, errors.New("not implemented")
}

58
beacon-chain/db/block_test.go
View File

@@ -20,12 +20,12 @@ func TestNilDB_OK(t *testing.T) {
block := &ethpb.BeaconBlock{}
h, _ := ssz.SigningRoot(block)
hasBlock := db.HasBlock(h)
hasBlock := db.HasBlockDeprecated(h)
if hasBlock {
t.Fatal("HashBlock should return false")
}
bPrime, err := db.Block(h)
bPrime, err := db.BlockDeprecated(h)
if err != nil {
t.Fatalf("failed to get block: %v", err)
}
@@ -41,12 +41,12 @@ func TestSaveBlock_OK(t *testing.T) {
block1 := &ethpb.BeaconBlock{}
h1, _ := ssz.SigningRoot(block1)
err := db.SaveBlock(block1)
err := db.SaveBlockDeprecated(block1)
if err != nil {
t.Fatalf("save block failed: %v", err)
}
b1Prime, err := db.Block(h1)
b1Prime, err := db.BlockDeprecated(h1)
if err != nil {
t.Fatalf("failed to get block: %v", err)
}
@@ -61,12 +61,12 @@ func TestSaveBlock_OK(t *testing.T) {
}
h2, _ := ssz.SigningRoot(block2)
err = db.SaveBlock(block2)
err = db.SaveBlockDeprecated(block2)
if err != nil {
t.Fatalf("save block failed: %v", err)
}
b2Prime, err := db.Block(h2)
b2Prime, err := db.BlockDeprecated(h2)
if err != nil {
t.Fatalf("failed to get block: %v", err)
}
@@ -86,11 +86,11 @@ func TestSaveBlock_NilBlkInCache(t *testing.T) {
// Save a nil block to with block root.
db.blocks[h1] = nil
if err := db.SaveBlock(block); err != nil {
if err := db.SaveBlockDeprecated(block); err != nil {
t.Fatalf("save block failed: %v", err)
}
savedBlock, err := db.Block(h1)
savedBlock, err := db.BlockDeprecated(h1)
if err != nil {
t.Fatal(err)
}
@@ -111,7 +111,7 @@ func TestSaveBlockInCache_OK(t *testing.T) {
block := &ethpb.BeaconBlock{Slot: 999}
h, _ := ssz.SigningRoot(block)
err := db.SaveBlock(block)
err := db.SaveBlockDeprecated(block)
if err != nil {
t.Fatalf("save block failed: %v", err)
}
@@ -120,7 +120,7 @@ func TestSaveBlockInCache_OK(t *testing.T) {
t.Error("Could not save block in cache")
}
savedBlock, err := db.Block(h)
savedBlock, err := db.BlockDeprecated(h)
if err != nil {
t.Fatal(err)
}
@@ -136,22 +136,22 @@ func TestDeleteBlock_OK(t *testing.T) {
block := &ethpb.BeaconBlock{Slot: 0}
h, _ := ssz.SigningRoot(block)
err := db.SaveBlock(block)
err := db.SaveBlockDeprecated(block)
if err != nil {
t.Fatalf("save block failed: %v", err)
}
savedBlock, err := db.Block(h)
savedBlock, err := db.BlockDeprecated(h)
if err != nil {
t.Fatal(err)
}
if !proto.Equal(block, savedBlock) {
t.Fatal(err)
}
if err := db.DeleteBlock(block); err != nil {
if err := db.DeleteBlockDeprecated(block); err != nil {
t.Fatal(err)
}
savedBlock, err = db.Block(h)
savedBlock, err = db.BlockDeprecated(h)
if err != nil {
t.Fatal(err)
}
@@ -167,12 +167,12 @@ func TestDeleteBlockInCache_OK(t *testing.T) {
block := &ethpb.BeaconBlock{Slot: 0}
h, _ := ssz.SigningRoot(block)
err := db.SaveBlock(block)
err := db.SaveBlockDeprecated(block)
if err != nil {
t.Fatalf("save block failed: %v", err)
}
if err := db.DeleteBlock(block); err != nil {
if err := db.DeleteBlockDeprecated(block); err != nil {
t.Fatal(err)
}
@@ -217,13 +217,13 @@ func TestBlocksBySlot_MultipleBlocks(t *testing.T) {
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte("C"),
}}
if err := db.SaveBlock(b1); err != nil {
if err := db.SaveBlockDeprecated(b1); err != nil {
t.Fatal(err)
}
if err := db.SaveBlock(b2); err != nil {
if err := db.SaveBlockDeprecated(b2); err != nil {
t.Fatal(err)
}
if err := db.SaveBlock(b3); err != nil {
if err := db.SaveBlockDeprecated(b3); err != nil {
t.Fatal(err)
}
@@ -289,7 +289,7 @@ func TestUpdateChainHead_OK(t *testing.T) {
if err != nil {
t.Fatalf("failed to hash b2: %v", err)
}
if err := db.SaveBlock(block2); err != nil {
if err := db.SaveBlockDeprecated(block2); err != nil {
t.Fatalf("failed to save block: %v", err)
}
if err := db.UpdateChainHead(ctx, block2, beaconState); err != nil {
@@ -341,7 +341,7 @@ func TestChainProgress_OK(t *testing.T) {
cycleLength := params.BeaconConfig().SlotsPerEpoch
block1 := &ethpb.BeaconBlock{Slot: 1}
if err := db.SaveBlock(block1); err != nil {
if err := db.SaveBlockDeprecated(block1); err != nil {
t.Fatalf("failed to save block: %v", err)
}
if err := db.UpdateChainHead(ctx, block1, beaconState); err != nil {
@@ -356,7 +356,7 @@ func TestChainProgress_OK(t *testing.T) {
}
block2 := &ethpb.BeaconBlock{Slot: cycleLength}
if err := db.SaveBlock(block2); err != nil {
if err := db.SaveBlockDeprecated(block2); err != nil {
t.Fatalf("failed to save block: %v", err)
}
if err := db.UpdateChainHead(ctx, block2, beaconState); err != nil {
@@ -371,7 +371,7 @@ func TestChainProgress_OK(t *testing.T) {
}
block3 := &ethpb.BeaconBlock{Slot: 3}
if err := db.SaveBlock(block3); err != nil {
if err := db.SaveBlockDeprecated(block3); err != nil {
t.Fatalf("failed to save block: %v", err)
}
if err := db.UpdateChainHead(ctx, block3, beaconState); err != nil {
@@ -465,12 +465,12 @@ func TestHasBlock_returnsTrue(t *testing.T) {
t.Fatal(err)
}
if err := db.SaveBlock(block); err != nil {
if err := db.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
if !db.HasBlock(root) {
t.Fatal("db.HasBlock returned false for block just saved")
if !db.HasBlockDeprecated(root) {
t.Fatal("db.HasBlockDeprecated returned false for block just saved")
}
}
@@ -482,7 +482,7 @@ func TestHighestBlockSlot_UpdatedOnSaveBlock(t *testing.T) {
Slot: 23,
}
if err := db.SaveBlock(block); err != nil {
if err := db.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
@@ -491,7 +491,7 @@ func TestHighestBlockSlot_UpdatedOnSaveBlock(t *testing.T) {
}
block.Slot = 55
if err := db.SaveBlock(block); err != nil {
if err := db.SaveBlockDeprecated(block); err != nil {
t.Fatal(err)
}
@@ -506,7 +506,7 @@ func TestClearBlockCache_OK(t *testing.T) {
block := &ethpb.BeaconBlock{Slot: 0}
err := db.SaveBlock(block)
err := db.SaveBlockDeprecated(block)
if err != nil {
t.Fatalf("save block failed: %v", err)
}

24
beacon-chain/db/db.go
View File

@@ -10,7 +10,6 @@ import (
"github.com/boltdb/bolt"
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
"github.com/prysmaticlabs/prysm/beacon-chain/db/kv"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -54,11 +53,14 @@ type Database interface {
SaveValidatorIndex(ctx context.Context, publicKey [48]byte, validatorIdx uint64) error
}
var _ = Database(&BeaconDB{})
// BeaconDB manages the data layer of the beacon chain implementation.
// The exposed methods do not have an opinion of the underlying data engine,
// but instead reflect the beacon chain logic.
// For example, instead of defining get, put, remove
// This defines methods such as getBlock, saveBlocksAndAttestations, etc.
// DEPRECATED: Use github.com/prysmaticlabs/prysm/db/kv instead.
type BeaconDB struct {
// state objects and caches
stateLock sync.RWMutex
@@ -67,7 +69,7 @@ type BeaconDB struct {
validatorRegistry []*ethpb.Validator
validatorBalances []uint64
db *bolt.DB
DatabasePath string
databasePath string
// Beacon block info in memory.
highestBlockSlot uint64
@@ -76,9 +78,6 @@ type BeaconDB struct {
badBlocksLock sync.RWMutex
blocks map[[32]byte]*ethpb.BeaconBlock
blocksLock sync.RWMutex
// Beacon chain deposits in memory.
DepositCache *depositcache.DepositCache
}
// Close closes the underlying boltdb database.
@@ -107,6 +106,7 @@ func createBuckets(tx *bolt.Tx, buckets ...[]byte) error {
}
// NewDBDeprecated initializes a new DB. If the genesis block and states do not exist, this method creates it.
// DEPRECATED: Use github.com/prysmaticlabs/prysm/db.NewDB instead.
func NewDBDeprecated(dirPath string) (*BeaconDB, error) {
if err := os.MkdirAll(dirPath, 0700); err != nil {
return nil, err
@@ -120,9 +120,7 @@ func NewDBDeprecated(dirPath string) (*BeaconDB, error) {
return nil, err
}
depCache := depositcache.NewDepositCache()
db := &BeaconDB{db: boltDB, DatabasePath: dirPath, DepositCache: depCache}
db := &BeaconDB{db: boltDB, databasePath: dirPath}
db.blocks = make(map[[32]byte]*ethpb.BeaconBlock)
if err := db.update(func(tx *bolt.Tx) error {
@@ -147,3 +145,13 @@ func ClearDB(dirPath string) error {
}
return os.RemoveAll(dirPath)
}
// DatabasePath returns the filepath to the database directory.
func (db *BeaconDB) DatabasePath() string {
return db.databasePath
}
// ClearDB removes the previously stored directory at the data directory.
func (db *BeaconDB) ClearDB() error {
return ClearDB(db.databasePath)
}

6
beacon-chain/db/db_test.go
View File

@@ -40,19 +40,19 @@ func teardownDB(t testing.TB, db *BeaconDB) {
if err := db.Close(); err != nil {
t.Fatalf("Failed to close database: %v", err)
}
if err := os.RemoveAll(db.DatabasePath); err != nil {
if err := os.RemoveAll(db.DatabasePath()); err != nil {
t.Fatalf("Failed to remove directory: %v", err)
}
}
func TestClearDB(t *testing.T) {
beaconDB := setupDB(t)
path := strings.TrimSuffix(beaconDB.DatabasePath, "beaconchain.db")
path := strings.TrimSuffix(beaconDB.DatabasePath(), "beaconchain.db")
if err := ClearDB(path); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(beaconDB.DatabasePath); !os.IsNotExist(err) {
if _, err := os.Stat(beaconDB.DatabasePath()); !os.IsNotExist(err) {
t.Fatalf("db wasnt cleared %v", err)
}
}

11
beacon-chain/db/setup_db.go
View File

@@ -23,14 +23,3 @@ func SetupDB() (*BeaconDB, error) {
}
return NewDBDeprecated(path)
}
// TeardownDB cleans up a simulated backend BeaconDB instance.
// DEPRECATED: Use beacon-chain/db/testing.TeardownDB
func TeardownDB(db *BeaconDB) {
if err := db.Close(); err != nil {
log.Fatalf("failed to close database: %v", err)
}
if err := os.RemoveAll(db.DatabasePath); err != nil {
log.Fatalf("could not remove tmp db dir: %v", err)
}
}

23
beacon-chain/db/state.go
View File

@@ -52,7 +52,7 @@ func (db *BeaconDB) InitializeState(ctx context.Context, genesisTime uint64, dep
db.serializedState = stateEnc
db.stateHash = stateHash
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
return err
}
@@ -96,6 +96,11 @@ func (db *BeaconDB) InitializeState(ctx context.Context, genesisTime uint64, dep
})
}
// State is not implemented.
func (db *BeaconDB) State(ctx context.Context, blockRoot [32]byte) (*pb.BeaconState, error) {
return nil, errors.New("not implemented")
}
// HeadState fetches the canonical beacon chain's head state from the DB.
func (db *BeaconDB) HeadState(ctx context.Context) (*pb.BeaconState, error) {
if ctx.Err() != nil {
@@ -150,9 +155,14 @@ func (db *BeaconDB) HeadStateRoot() [32]byte {
return db.stateHash
}
// SaveState updates the beacon chain state.
func (db *BeaconDB) SaveState(ctx context.Context, beaconState *pb.BeaconState) error {
ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveState")
// SaveState in db.
func (db *BeaconDB) SaveState(ctx context.Context, state *pb.BeaconState, _ [32]byte) error {
return db.SaveStateDeprecated(ctx, state)
}
// SaveStateDeprecated updates the beacon chain state.
func (db *BeaconDB) SaveStateDeprecated(ctx context.Context, beaconState *pb.BeaconState) error {
ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveStateDeprecated")
defer span.End()
ctx, lockSpan := trace.StartSpan(ctx, "BeaconDB.stateLock.Lock")
@@ -383,6 +393,11 @@ func (db *BeaconDB) Validators(ctx context.Context) ([]*ethpb.Validator, error)
return beaconState.Validators, err
}
// ValidatorLatestVote is not implemented.
func (db *BeaconDB) ValidatorLatestVote(_ context.Context, _ uint64) (*pb.ValidatorLatestVote, error) {
return nil, errors.New("not implemented")
}
// ValidatorFromState fetches the validator with the desired index from the cached registry.
func (db *BeaconDB) ValidatorFromState(ctx context.Context, index uint64) (*ethpb.Validator, error) {
ctx, span := trace.StartSpan(ctx, "BeaconDB.ValidatorFromState")

2
beacon-chain/db/state_test.go
View File

@@ -110,7 +110,7 @@ func BenchmarkState_ReadingFromCache(b *testing.B) {
b.Fatalf("Could not read DV beacon state from DB: %v", err)
}
state.Slot++
err = db.SaveState(ctx, state)
err = db.SaveStateDeprecated(ctx, state)
if err != nil {
b.Fatalf("Could not save beacon state to cache from DB: %v", err)
}

52
beacon-chain/db/validator.go
View File

@@ -4,6 +4,7 @@ import (
"bytes"
"context"
"encoding/binary"
"errors"
"fmt"
"github.com/boltdb/bolt"
@@ -11,8 +12,13 @@ import (
"github.com/prysmaticlabs/prysm/shared/hashutil"
)
// SaveValidatorIndex accepts a public key and validator index and writes them to disk.
func (db *BeaconDB) SaveValidatorIndex(pubKey []byte, index int) error {
// SaveValidatorIndex in db.
func (db *BeaconDB) SaveValidatorIndex(ctx context.Context, pubkey [48]byte, idx uint64) error {
return db.SaveValidatorIndexDeprecated(pubkey[:], int(idx))
}
// SaveValidatorIndexDeprecated accepts a public key and validator index and writes them to disk.
func (db *BeaconDB) SaveValidatorIndexDeprecated(pubKey []byte, index int) error {
h := hashutil.Hash(pubKey)
return db.update(func(tx *bolt.Tx) error {
@@ -25,6 +31,11 @@ func (db *BeaconDB) SaveValidatorIndex(pubKey []byte, index int) error {
})
}
// SaveValidatorLatestVote not implemented.
func (db *BeaconDB) SaveValidatorLatestVote(_ context.Context, _ uint64, _ *pb.ValidatorLatestVote) error {
return errors.New("not implemented")
}
// SaveValidatorIndexBatch accepts a public key and validator index and writes them to disk.
func (db *BeaconDB) SaveValidatorIndexBatch(pubKey []byte, index int) error {
h := hashutil.Hash(pubKey)
@@ -38,10 +49,16 @@ func (db *BeaconDB) SaveValidatorIndexBatch(pubKey []byte, index int) error {
}
// ValidatorIndex accepts a public key and returns the corresponding validator index.
// ValidatorIndex returns validator index from database.
func (db *BeaconDB) ValidatorIndex(_ context.Context, pubkey [48]byte) (uint64, bool, error) {
idx, err := db.ValidatorIndexDeprecated(pubkey[:])
return idx, true, err
}
// ValidatorIndexDeprecated accepts a public key and returns the corresponding validator index.
// If the validator index is not found in DB, as a fail over, it searches the state and
// saves it to the DB when found.
func (db *BeaconDB) ValidatorIndex(pubKey []byte) (uint64, error) {
func (db *BeaconDB) ValidatorIndexDeprecated(pubKey []byte) (uint64, error) {
if !db.HasValidator(pubKey) {
state, err := db.HeadState(context.Background())
if err != nil {
@@ -50,7 +67,7 @@ func (db *BeaconDB) ValidatorIndex(pubKey []byte) (uint64, error) {
for i := 0; i < len(state.Validators); i++ {
v := state.Validators[i]
if bytes.Equal(v.PublicKey, pubKey) {
if err := db.SaveValidatorIndex(pubKey, i); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, i); err != nil {
return 0, err
}
return uint64(i), nil
@@ -78,7 +95,13 @@ func (db *BeaconDB) ValidatorIndex(pubKey []byte) (uint64, error) {
}
// DeleteValidatorIndex deletes the validator index map record.
func (db *BeaconDB) DeleteValidatorIndex(pubKey []byte) error {
func (db *BeaconDB) DeleteValidatorIndex(_ context.Context, pubkey [48]byte) error {
return db.DeleteValidatorIndexDeprecated(pubkey[:])
}
// DeleteValidatorIndexDeprecated deletes the validator index map record.
// DEPRECATED: Do not use.
func (db *BeaconDB) DeleteValidatorIndexDeprecated(pubKey []byte) error {
h := hashutil.Hash(pubKey)
return db.update(func(tx *bolt.Tx) error {
@@ -88,11 +111,22 @@ func (db *BeaconDB) DeleteValidatorIndex(pubKey []byte) error {
})
}
// HasValidatorIndex returns hasValidator(pubkey).
func (db *BeaconDB) HasValidatorIndex(_ context.Context, pubkey [48]byte) bool {
return db.HasValidator(pubkey[:])
}
// HasValidatorLatestVote always returns false. Don't use this.
// DEPRECATED: Do not use.
func (db *BeaconDB) HasValidatorLatestVote(_ context.Context, _ uint64) bool {
return false
}
// HasValidator checks if a validator index map exists.
func (db *BeaconDB) HasValidator(pubKey []byte) bool {
exists := false
h := hashutil.Hash(pubKey)
// #nosec G104, similar to HasBlock, HasAttestation... etc
// #nosec G104, similar to HasBlockDeprecated, HasAttestationDeprecated... etc
db.view(func(tx *bolt.Tx) error {
bkt := tx.Bucket(validatorBucket)
@@ -106,7 +140,7 @@ func (db *BeaconDB) HasValidator(pubKey []byte) bool {
// are in the bucket.
func (db *BeaconDB) HasAnyValidators(state *pb.BeaconState, pubKeys [][]byte) (bool, error) {
exists := false
// #nosec G104, similar to HasBlock, HasAttestation... etc
// #nosec G104, similar to HasBlockDeprecated, HasAttestationDeprecated... etc
db.view(func(tx *bolt.Tx) error {
bkt := tx.Bucket(validatorBucket)
for _, pk := range pubKeys {
@@ -122,7 +156,7 @@ func (db *BeaconDB) HasAnyValidators(state *pb.BeaconState, pubKeys [][]byte) (b
for i := 0; i < len(state.Validators); i++ {
v := state.Validators[i]
if bytes.Equal(v.PublicKey, pubKey) {
if err := db.SaveValidatorIndex(pubKey, i); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, i); err != nil {
return false, err
}
exists = true

22
beacon-chain/db/validator_test.go
View File

@@ -19,24 +19,24 @@ func TestSaveAndRetrieveValidatorIndex_OK(t *testing.T) {
p1 := []byte{'A', 'B', 'C'}
p2 := []byte{'D', 'E', 'F'}
if err := db.SaveValidatorIndex(p1, 1); err != nil {
if err := db.SaveValidatorIndexDeprecated(p1, 1); err != nil {
t.Fatalf("Failed to save vallidator index: %v", err)
}
if err := db.SaveValidatorIndex(p2, 2); err != nil {
if err := db.SaveValidatorIndexDeprecated(p2, 2); err != nil {
t.Fatalf("Failed to save vallidator index: %v", err)
}
index1, err := db.ValidatorIndex(p1)
index1, err := db.ValidatorIndexDeprecated(p1)
if err != nil {
t.Fatalf("Failed to call Attestation: %v", err)
t.Fatalf("Failed to call AttestationDeprecated: %v", err)
}
if index1 != 1 {
t.Fatalf("Saved index and retrieved index are not equal: %#x and %#x", 1, index1)
}
index2, err := db.ValidatorIndex(p2)
index2, err := db.ValidatorIndexDeprecated(p2)
if err != nil {
t.Fatalf("Failed to call Attestation: %v", err)
t.Fatalf("Failed to call AttestationDeprecated: %v", err)
}
if index2 != 2 {
t.Fatalf("Saved index and retrieved index are not equal: %#x and %#x", 2, index2)
@@ -49,13 +49,13 @@ func TestSaveAndDeleteValidatorIndex_OK(t *testing.T) {
p1 := []byte{'1', '2', '3'}
if err := db.SaveValidatorIndex(p1, 3); err != nil {
if err := db.SaveValidatorIndexDeprecated(p1, 3); err != nil {
t.Fatalf("Failed to save validator index: %v", err)
}
if err := db.SaveState(context.Background(), &pb.BeaconState{}); err != nil {
if err := db.SaveStateDeprecated(context.Background(), &pb.BeaconState{}); err != nil {
t.Fatalf("Failed to save state: %v", err)
}
index, err := db.ValidatorIndex(p1)
index, err := db.ValidatorIndexDeprecated(p1)
if err != nil {
t.Fatalf("Failed to call validator Index: %v", err)
}
@@ -63,10 +63,10 @@ func TestSaveAndDeleteValidatorIndex_OK(t *testing.T) {
t.Fatalf("Saved index and retrieved index are not equal: %#x and %#x", 3, index)
}
if err := db.DeleteValidatorIndex(p1); err != nil {
if err := db.DeleteValidatorIndexDeprecated(p1); err != nil {
t.Fatalf("Could not delete attestation: %v", err)
}
_, err = db.ValidatorIndex(p1)
_, err = db.ValidatorIndexDeprecated(p1)
want := fmt.Sprintf("validator %#x does not exist", p1)
if !strings.Contains(err.Error(), want) {
t.Errorf("Want: %v, got: %v", want, err.Error())

1
beacon-chain/deprecated-sync/BUILD.bazel
View File

@@ -14,6 +14,7 @@ go_library(
visibility = ["//beacon-chain:__subpackages__"],
deps = [
"//beacon-chain/blockchain:go_default_library",
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/db:go_default_library",
"//beacon-chain/deprecated-sync/initial-sync:go_default_library",

1
beacon-chain/deprecated-sync/initial-sync/BUILD.bazel
View File

@@ -14,6 +14,7 @@ go_library(
visibility = ["//beacon-chain:__subpackages__"],
deps = [
"//beacon-chain/blockchain:go_default_library",
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/core/validators:go_default_library",
"//beacon-chain/db:go_default_library",

2
beacon-chain/deprecated-sync/initial-sync/helpers.go
View File

@@ -27,7 +27,7 @@ func (s *InitialSync) checkBlockValidity(ctx context.Context, block *ethpb.Beaco
if block.Slot < helpers.StartSlot(beaconState.FinalizedCheckpoint.Epoch) {
return errors.New("discarding received block with a slot number smaller than the last finalized slot")
}
// Attestation from proposer not verified as, other nodes only store blocks not proposer
// AttestationDeprecated from proposer not verified as, other nodes only store blocks not proposer
// attestations.
return nil
}

10
beacon-chain/deprecated-sync/initial-sync/service.go
View File

@@ -22,6 +22,7 @@ import (
"github.com/pkg/errors"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -48,6 +49,7 @@ type Config struct {
BatchedBlockBufferSize int
StateBufferSize int
BeaconDB *db.BeaconDB
DepositCache *depositcache.DepositCache
P2P p2pAPI
SyncService syncService
ChainService chainService
@@ -96,6 +98,7 @@ type InitialSync struct {
syncService syncService
chainService chainService
db *db.BeaconDB
depositCache *depositcache.DepositCache
powchain powChainService
batchedBlockBuf chan deprecatedp2p.Message
stateBuf chan deprecatedp2p.Message
@@ -122,6 +125,7 @@ func NewInitialSyncService(ctx context.Context,
p2p: cfg.P2P,
syncService: cfg.SyncService,
db: cfg.BeaconDB,
depositCache: cfg.DepositCache,
powchain: cfg.PowChain,
chainService: cfg.ChainService,
stateBuf: stateBuf,
@@ -155,7 +159,7 @@ func (s *InitialSync) exitInitialSync(ctx context.Context, block *ethpb.BeaconBl
return nil
}
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
parent, err := s.db.Block(parentRoot)
parent, err := s.db.BlockDeprecated(parentRoot)
if err != nil {
return err
}
@@ -166,7 +170,7 @@ func (s *InitialSync) exitInitialSync(ctx context.Context, block *ethpb.BeaconBl
if err := s.chainService.VerifyBlockValidity(ctx, block, state); err != nil {
return err
}
if err := s.db.SaveBlock(block); err != nil {
if err := s.db.SaveBlockDeprecated(block); err != nil {
return err
}
root, err := ssz.SigningRoot(block)
@@ -186,7 +190,7 @@ func (s *InitialSync) exitInitialSync(ctx context.Context, block *ethpb.BeaconBl
switch err.(type) {
case *blockchain.BlockFailedProcessingErr:
// If the block fails processing, we delete it from our DB.
if err := s.db.DeleteBlock(block); err != nil {
if err := s.db.DeleteBlockDeprecated(block); err != nil {
return errors.Wrap(err, "could not delete bad block from db")
}
return errors.Wrap(err, "could not apply block state transition")

6
beacon-chain/deprecated-sync/initial-sync/service_test.go
View File

@@ -105,7 +105,7 @@ func setUpGenesisStateAndBlock(beaconDB *db.BeaconDB, t *testing.T) {
return
}
genBlock := b.NewGenesisBlock(stateRoot[:])
if err := beaconDB.SaveBlock(genBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(genBlock); err != nil {
t.Fatalf("could not save genesis block to disk: %v", err)
}
if err := beaconDB.UpdateChainHead(ctx, genBlock, beaconState); err != nil {
@@ -206,8 +206,8 @@ func TestProcessingBlocks_SkippedSlots(t *testing.T) {
// Save the block and set the parent hash of the next block
// as the hash of the current block.
if err := ss.db.SaveBlock(block); err != nil {
t.Fatalf("Block unable to be saved %v", err)
if err := ss.db.SaveBlockDeprecated(block); err != nil {
t.Fatalf("BlockDeprecated unable to be saved %v", err)
}
hash, err := ssz.SigningRoot(block)

6
beacon-chain/deprecated-sync/initial-sync/sync_blocks.go
View File

@@ -99,7 +99,7 @@ func (s *InitialSync) validateAndSaveNextBlock(ctx context.Context, block *ethpb
if err != nil {
return err
}
if s.db.HasBlock(root) {
if s.db.HasBlockDeprecated(root) {
log.WithField("block", fmt.Sprintf("%#x", root)).
Warn("Skipping block in db already")
return nil
@@ -116,7 +116,7 @@ func (s *InitialSync) validateAndSaveNextBlock(ctx context.Context, block *ethpb
s.mutex.Lock()
defer s.mutex.Unlock()
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
parentBlock, err := s.db.Block(parentRoot)
parentBlock, err := s.db.BlockDeprecated(parentRoot)
if err != nil {
return err
}
@@ -132,7 +132,7 @@ func (s *InitialSync) validateAndSaveNextBlock(ctx context.Context, block *ethpb
if err := s.chainService.VerifyBlockValidity(ctx, block, state); err != nil {
return err
}
if err := s.db.SaveBlock(block); err != nil {
if err := s.db.SaveBlockDeprecated(block); err != nil {
return err
}
if err := s.db.SaveAttestationTarget(ctx, &pb.AttestationTarget{

4
beacon-chain/deprecated-sync/initial-sync/sync_state.go
View File

@@ -30,7 +30,7 @@ func (s *InitialSync) processState(msg p2p.Message, chainHead *pb.ChainHeadRespo
return nil
}
if err := s.db.SaveBlock(finalizedBlock); err != nil {
if err := s.db.SaveBlockDeprecated(finalizedBlock); err != nil {
log.Errorf("Could not save block %v", err)
return nil
}
@@ -76,7 +76,7 @@ func (s *InitialSync) processState(msg p2p.Message, chainHead *pb.ChainHeadRespo
return nil
}
s.db.DepositCache.PrunePendingDeposits(ctx, int(finalizedState.Eth1DepositIndex))
s.depositCache.PrunePendingDeposits(ctx, int(finalizedState.Eth1DepositIndex))
if err := s.db.UpdateChainHead(ctx, finalizedBlock, finalizedState); err != nil {
log.Errorf("Could not update chain head: %v", err)

4
beacon-chain/deprecated-sync/querier_test.go
View File

@@ -249,10 +249,10 @@ func TestSyncedInRestarts(t *testing.T) {
bState := &pb.BeaconState{Slot: 0}
blk := &ethpb.BeaconBlock{Slot: 0}
if err := db.SaveState(context.Background(), bState); err != nil {
if err := db.SaveStateDeprecated(context.Background(), bState); err != nil {
t.Fatalf("Could not save state: %v", err)
}
if err := db.SaveBlock(blk); err != nil {
if err := db.SaveBlockDeprecated(blk); err != nil {
t.Fatalf("Could not save state: %v", err)
}
if err := db.UpdateChainHead(context.Background(), blk, bState); err != nil {

8
beacon-chain/deprecated-sync/receive_block.go
View File

@@ -42,7 +42,7 @@ func (rs *RegularSync) receiveBlockAnnounce(msg p2p.Message) error {
return nil
}
hasBlock := rs.db.HasBlock(h)
hasBlock := rs.db.HasBlockDeprecated(h)
span.AddAttributes(trace.BoolAttribute("hasBlock", hasBlock))
if hasBlock {
@@ -124,7 +124,7 @@ func (rs *RegularSync) validateAndProcessBlock(
log.WithField("blockRoot", fmt.Sprintf("%#x", bytesutil.Trunc(blockRoot[:]))).
Debug("Processing response to block request")
hasBlock := rs.db.HasBlock(blockRoot)
hasBlock := rs.db.HasBlockDeprecated(blockRoot)
if hasBlock {
log.Debug("Received a block that already exists. Exiting...")
span.AddAttributes(trace.BoolAttribute("invalidBlock", true))
@@ -151,7 +151,7 @@ func (rs *RegularSync) validateAndProcessBlock(
// We check if we have the block's parents saved locally.
parentRoot := bytesutil.ToBytes32(block.ParentRoot)
hasParent := rs.db.HasBlock(parentRoot)
hasParent := rs.db.HasBlockDeprecated(parentRoot)
span.AddAttributes(trace.BoolAttribute("hasParent", hasParent))
if !hasParent {
@@ -193,7 +193,7 @@ func (rs *RegularSync) validateAndProcessBlock(
log.WithFields(logrus.Fields{
"slot": block.Slot,
"root": fmt.Sprintf("%#x", bytesutil.Trunc(blockRoot[:]))},
).Warn("Received Block from a forked chain")
).Warn("Received BlockDeprecated from a forked chain")
if err := rs.db.SaveHistoricalState(ctx, beaconState, blockRoot); err != nil {
log.Errorf("Could not save historical state %v", err)
return nil, nil, false, err

4
beacon-chain/deprecated-sync/receive_block_test.go
View File

@@ -113,10 +113,10 @@ func TestReceiveBlock_RecursivelyProcessesChildren(t *testing.T) {
Slot: 0,
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 0},
}
if err := db.SaveBlock(genesisBlock); err != nil {
if err := db.SaveBlockDeprecated(genesisBlock); err != nil {
t.Fatal(err)
}
if err := db.SaveState(ctx, genesisState); err != nil {
if err := db.SaveStateDeprecated(ctx, genesisState); err != nil {
t.Fatal(err)
}
if err := db.UpdateChainHead(ctx, genesisBlock, genesisState); err != nil {

10
beacon-chain/deprecated-sync/regular_sync.go
View File

@@ -399,10 +399,10 @@ func (rs *RegularSync) receiveAttestation(msg deprecatedp2p.Message) error {
}).Debug("Received an attestation")
// Skip if attestation has been seen before.
hasAttestation := rs.db.HasAttestation(attestationDataHash)
hasAttestation := rs.db.HasAttestationDeprecated(attestationDataHash)
span.AddAttributes(trace.BoolAttribute("hasAttestation", hasAttestation))
if hasAttestation {
dbAttestation, err := rs.db.Attestation(attestationDataHash)
dbAttestation, err := rs.db.AttestationDeprecated(attestationDataHash)
if err != nil {
return err
}
@@ -478,7 +478,7 @@ func (rs *RegularSync) handleBlockRequestByHash(msg deprecatedp2p.Message) error
data := msg.Data.(*pb.BeaconBlockRequest)
root := bytesutil.ToBytes32(data.Hash)
block, err := rs.db.Block(root)
block, err := rs.db.BlockDeprecated(root)
if err != nil {
log.Error(err)
return err
@@ -541,7 +541,7 @@ func (rs *RegularSync) respondBatchedBlocks(ctx context.Context, finalizedRoot [
return nil, nil
}
b, err := rs.db.Block(bytesutil.ToBytes32(headRoot))
b, err := rs.db.BlockDeprecated(bytesutil.ToBytes32(headRoot))
if err != nil {
return nil, err
}
@@ -555,7 +555,7 @@ func (rs *RegularSync) respondBatchedBlocks(ctx context.Context, finalizedRoot [
if ctx.Err() != nil {
return nil, ctx.Err()
}
b, err = rs.db.Block(bytesutil.ToBytes32(parentRoot))
b, err = rs.db.BlockDeprecated(bytesutil.ToBytes32(parentRoot))
if err != nil {
return nil, err
}

26
beacon-chain/deprecated-sync/regular_sync_test.go
View File

@@ -74,7 +74,7 @@ func (ms *mockChainService) CanonicalBlockFeed() *event.Feed {
}
func (ms *mockChainService) ReceiveBlockDeprecated(ctx context.Context, block *ethpb.BeaconBlock) (*pb.BeaconState, error) {
if err := ms.db.SaveBlock(block); err != nil {
if err := ms.db.SaveBlockDeprecated(block); err != nil {
return nil, err
}
return &pb.BeaconState{}, nil
@@ -203,7 +203,7 @@ func TestProcessBlock_OK(t *testing.T) {
parentBlock := &ethpb.BeaconBlock{
Slot: 0,
}
if err := db.SaveBlock(parentBlock); err != nil {
if err := db.SaveBlockDeprecated(parentBlock); err != nil {
t.Fatalf("failed to save block: %v", err)
}
parentRoot, err := ssz.SigningRoot(parentBlock)
@@ -281,7 +281,7 @@ func TestProcessBlock_MultipleBlocksProcessedOK(t *testing.T) {
parentBlock := &ethpb.BeaconBlock{
Slot: 0,
}
if err := db.SaveBlock(parentBlock); err != nil {
if err := db.SaveBlockDeprecated(parentBlock); err != nil {
t.Fatalf("failed to save block: %v", err)
}
parentRoot, err := ssz.SigningRoot(parentBlock)
@@ -370,13 +370,13 @@ func TestReceiveAttestation_OK(t *testing.T) {
Slot: 2,
FinalizedCheckpoint: &ethpb.Checkpoint{},
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatalf("Could not save state: %v", err)
}
beaconBlock := &ethpb.BeaconBlock{
Slot: beaconState.Slot,
}
if err := db.SaveBlock(beaconBlock); err != nil {
if err := db.SaveBlockDeprecated(beaconBlock); err != nil {
t.Fatal(err)
}
if err := db.UpdateChainHead(ctx, beaconBlock, beaconState); err != nil {
@@ -427,11 +427,11 @@ func TestReceiveAttestation_OlderThanPrevEpoch(t *testing.T) {
Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1},
}
if err := db.SaveState(ctx, state); err != nil {
if err := db.SaveStateDeprecated(ctx, state); err != nil {
t.Fatalf("Could not save state: %v", err)
}
headBlock := &ethpb.BeaconBlock{Slot: state.Slot}
if err := db.SaveBlock(headBlock); err != nil {
if err := db.SaveBlockDeprecated(headBlock); err != nil {
t.Fatalf("failed to save block: %v", err)
}
if err := db.UpdateChainHead(ctx, headBlock, state); err != nil {
@@ -592,21 +592,21 @@ func TestCanonicalBlockList_CanRetrieveCanonical(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = ss.db.SaveBlock(block1); err != nil {
if err = ss.db.SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block2 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: root1[:]}
root2, _ := ssz.SigningRoot(block2)
if err = ss.db.SaveBlock(block2); err != nil {
if err = ss.db.SaveBlockDeprecated(block2); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: root1[:]}
if err = ss.db.SaveBlock(block3); err != nil {
if err = ss.db.SaveBlockDeprecated(block3); err != nil {
t.Fatalf("Could not save block: %v", err)
}
block4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: root2[:]}
root4, _ := ssz.SigningRoot(block4)
if err = ss.db.SaveBlock(block4); err != nil {
if err = ss.db.SaveBlockDeprecated(block4); err != nil {
t.Fatalf("Could not save block: %v", err)
}
@@ -633,7 +633,7 @@ func TestCanonicalBlockList_SameFinalizedAndHead(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = ss.db.SaveBlock(block1); err != nil {
if err = ss.db.SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}
@@ -668,7 +668,7 @@ func TestCanonicalBlockList_NilParentBlock(t *testing.T) {
if err != nil {
t.Fatalf("Could not hash block: %v", err)
}
if err = ss.db.SaveBlock(block1); err != nil {
if err = ss.db.SaveBlockDeprecated(block1); err != nil {
t.Fatalf("Could not save block: %v", err)
}

11
beacon-chain/deprecated-sync/service.go
View File

@@ -4,6 +4,7 @@ import (
"context"
"errors"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
initialsync "github.com/prysmaticlabs/prysm/beacon-chain/deprecated-sync/initial-sync"
"github.com/prysmaticlabs/prysm/beacon-chain/operations"
@@ -29,7 +30,8 @@ type Service struct {
// Config defines the configured services required for sync to work.
type Config struct {
ChainService chainService
BeaconDB *db.BeaconDB
BeaconDB db.Database
DepositCache *depositcache.DepositCache
P2P p2pAPI
AttsService attsService
OperationService operations.OperationFeeds
@@ -40,20 +42,21 @@ type Config struct {
// given.
func NewSyncService(ctx context.Context, cfg *Config) *Service {
sqCfg := DefaultQuerierConfig()
sqCfg.BeaconDB = cfg.BeaconDB
sqCfg.BeaconDB = cfg.BeaconDB.(*db.BeaconDB)
sqCfg.P2P = cfg.P2P
sqCfg.PowChain = cfg.PowChainService
sqCfg.ChainService = cfg.ChainService
isCfg := initialsync.DefaultConfig()
isCfg.BeaconDB = cfg.BeaconDB
isCfg.BeaconDB = cfg.BeaconDB.(*db.BeaconDB)
isCfg.DepositCache = cfg.DepositCache
isCfg.P2P = cfg.P2P
isCfg.PowChain = cfg.PowChainService
isCfg.ChainService = cfg.ChainService
rsCfg := DefaultRegularSyncConfig()
rsCfg.ChainService = cfg.ChainService
rsCfg.BeaconDB = cfg.BeaconDB
rsCfg.BeaconDB = cfg.BeaconDB.(*db.BeaconDB)
rsCfg.P2P = cfg.P2P
rsCfg.AttsService = cfg.AttsService
rsCfg.OperationService = cfg.OperationService

2
beacon-chain/deprecated-sync/service_test.go
View File

@@ -35,7 +35,7 @@ func initializeTestSyncService(ctx context.Context, cfg *Config, synced bool) *S
services := NewSyncService(ctx, cfg)
sqCfg.BeaconDB = cfg.BeaconDB
sqCfg.BeaconDB = cfg.BeaconDB.(*db.BeaconDB)
sqCfg.P2P = cfg.P2P
sq := NewQuerierService(ctx, sqCfg)

2
beacon-chain/internal/db_test_util.go
View File

@@ -38,7 +38,7 @@ func TeardownDBDeprecated(t testing.TB, db *db.BeaconDB) {
if err := db.Close(); err != nil {
t.Fatalf("Failed to close database: %v", err)
}
if err := os.RemoveAll(db.DatabasePath); err != nil {
if err := os.RemoveAll(db.DatabasePath()); err != nil {
t.Fatalf("Could not remove tmp db dir: %v", err)
}
}

2
beacon-chain/node/BUILD.bazel
View File

@@ -12,6 +12,7 @@ go_library(
deps = [
"//beacon-chain/attestation:go_default_library",
"//beacon-chain/blockchain:go_default_library",
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/db:go_default_library",
"//beacon-chain/deprecated-sync:go_default_library",
"//beacon-chain/flags:go_default_library",
@@ -20,6 +21,7 @@ go_library(
"//beacon-chain/p2p:go_default_library",
"//beacon-chain/powchain:go_default_library",
"//beacon-chain/rpc:go_default_library",
"//beacon-chain/sync:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
"//proto/eth/v1alpha1:go_default_library",
"//shared:go_default_library",

39
beacon-chain/node/node.go
View File

@@ -16,6 +16,7 @@ import (
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/beacon-chain/attestation"
"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
rbcsync "github.com/prysmaticlabs/prysm/beacon-chain/deprecated-sync"
"github.com/prysmaticlabs/prysm/beacon-chain/flags"
@@ -24,6 +25,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
"github.com/prysmaticlabs/prysm/beacon-chain/powchain"
"github.com/prysmaticlabs/prysm/beacon-chain/rpc"
prysmsync "github.com/prysmaticlabs/prysm/beacon-chain/sync"
"github.com/prysmaticlabs/prysm/shared"
"github.com/prysmaticlabs/prysm/shared/cmd"
"github.com/prysmaticlabs/prysm/shared/debug"
@@ -46,11 +48,12 @@ const testSkipPowFlag = "test-skip-pow"
// full PoS node. It handles the lifecycle of the entire system and registers
// services to a service registry.
type BeaconNode struct {
ctx *cli.Context
services *shared.ServiceRegistry
lock sync.RWMutex
stop chan struct{} // Channel to wait for termination notifications.
db *db.BeaconDB
ctx *cli.Context
services *shared.ServiceRegistry
lock sync.RWMutex
stop chan struct{} // Channel to wait for termination notifications.
db db.Database
depositCache *depositcache.DepositCache
}
// NewBeaconNode creates a new node instance, sets up configuration options, and registers
@@ -182,13 +185,20 @@ func (b *BeaconNode) startDB(ctx *cli.Context) error {
}
}
db, err := db.NewDBDeprecated(dbPath)
var d db.Database
var err error
if featureconfig.FeatureConfig().UseNewDatabase {
d, err = db.NewDB(dbPath)
} else {
d, err = db.NewDBDeprecated(dbPath)
}
if err != nil {
return err
}
log.WithField("path", dbPath).Info("Checking db")
b.db = db
b.db = d
b.depositCache = depositcache.NewDepositCache()
return nil
}
@@ -253,6 +263,7 @@ func (b *BeaconNode) registerBlockchainService(ctx *cli.Context) error {
blockchainService, err := blockchain.NewChainService(context.Background(), &blockchain.Config{
BeaconDB: b.db,
DepositCache: b.depositCache,
Web3Service: web3Service,
OpsPoolService: opsService,
AttsService: attsService,
@@ -316,13 +327,14 @@ func (b *BeaconNode) registerPOWChainService(cliCtx *cli.Context) error {
BlockFetcher: httpClient,
ContractBackend: httpClient,
BeaconDB: b.db,
DepositCache: b.depositCache,
}
web3Service, err := powchain.NewWeb3Service(ctx, cfg)
if err != nil {
return errors.Wrap(err, "could not register proof-of-work chain web3Service")
}
if err := b.db.VerifyContractAddress(ctx, cfg.DepositContract); err != nil {
if err := b.db.(*db.BeaconDB).VerifyContractAddress(ctx, cfg.DepositContract); err != nil {
return err
}
@@ -350,10 +362,21 @@ func (b *BeaconNode) registerSyncService(ctx *cli.Context) error {
return err
}
if featureconfig.FeatureConfig().UseNewSync {
rs := prysmsync.NewRegularSync(&prysmsync.Config{
DB: b.db,
P2P: b.fetchP2P(ctx),
Operations: operationService,
})
return b.services.RegisterService(rs)
}
cfg := &rbcsync.Config{
ChainService: chainService,
P2P: b.fetchP2P(ctx),
BeaconDB: b.db,
DepositCache: b.depositCache,
OperationService: operationService,
PowChainService: web3Service,
AttsService: attsService,

1
beacon-chain/operations/BUILD.bazel
View File

@@ -35,6 +35,7 @@ go_test(
deps = [
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/core/state:go_default_library",
"//beacon-chain/db:go_default_library",
"//beacon-chain/internal:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
"//proto/eth/v1alpha1:go_default_library",

58
beacon-chain/operations/service.go
View File

@@ -11,21 +11,22 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/pkg/errors"
"github.com/prysmaticlabs/go-ssz"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/sirupsen/logrus"
"go.opencensus.io/trace"
"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/db"
p2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/p2p"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/event"
"github.com/prysmaticlabs/prysm/shared/hashutil"
handler "github.com/prysmaticlabs/prysm/shared/messagehandler"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/sirupsen/logrus"
"go.opencensus.io/trace"
)
var log = logrus.WithField("prefix", "operation")
@@ -50,7 +51,7 @@ type OperationFeeds interface {
type Service struct {
ctx context.Context
cancel context.CancelFunc
beaconDB *db.BeaconDB
beaconDB db.Database
incomingExitFeed *event.Feed
incomingValidatorExits chan *ethpb.VoluntaryExit
incomingAttFeed *event.Feed
@@ -64,7 +65,7 @@ type Service struct {
// Config options for the service.
type Config struct {
BeaconDB *db.BeaconDB
BeaconDB db.Database
P2P p2p.Broadcaster
}
@@ -132,7 +133,7 @@ func (s *Service) IncomingProcessedBlockFeed() *event.Feed {
// capacity. The attestations get deleted in DB after they have been retrieved.
func (s *Service) AttestationPool(ctx context.Context, requestedSlot uint64) ([]*ethpb.Attestation, error) {
var attestations []*ethpb.Attestation
attestationsFromDB, err := s.beaconDB.Attestations()
attestationsFromDB, err := s.beaconDB.Attestations(ctx, nil /*filter*/)
if err != nil {
return nil, errors.New("could not retrieve attestations from DB")
}
@@ -159,7 +160,11 @@ func (s *Service) AttestationPool(ctx context.Context, requestedSlot uint64) ([]
// Delete the attestation if the attestation is one epoch older than head state,
// we don't want to pass these attestations to RPC for proposer to include.
if slot+params.BeaconConfig().SlotsPerEpoch <= bState.Slot {
if err := s.beaconDB.DeleteAttestation(att); err != nil {
hash, err := ssz.HashTreeRoot(att)
if err != nil {
return nil, err
}
if err := s.beaconDB.DeleteAttestation(ctx, hash); err != nil {
return nil, err
}
continue
@@ -212,7 +217,7 @@ func (s *Service) HandleValidatorExits(ctx context.Context, message proto.Messag
if err != nil {
return err
}
if err := s.beaconDB.SaveExit(ctx, exit); err != nil {
if err := s.beaconDB.(*db.BeaconDB).SaveExit(ctx, exit); err != nil {
return err
}
log.WithField("hash", fmt.Sprintf("%#x", hash)).Info("Exit request saved in DB")
@@ -251,8 +256,8 @@ func (s *Service) HandleAttestation(ctx context.Context, message proto.Message)
}
incomingAttBits := attestation.AggregationBits
if s.beaconDB.HasAttestation(hash) {
dbAtt, err := s.beaconDB.Attestation(hash)
if s.beaconDB.HasAttestation(ctx, hash) {
dbAtt, err := s.beaconDB.Attestation(ctx, hash)
if err != nil {
return err
}
@@ -290,14 +295,15 @@ func (s *Service) HandleAttestation(ctx context.Context, message proto.Message)
// 2.) retrieve the canonical block by using voted block's slot number
// 3.) return true if voted block root and the canonical block root are the same
func (s *Service) IsAttCanonical(ctx context.Context, att *ethpb.Attestation) (bool, error) {
votedBlk, err := s.beaconDB.Block(bytesutil.ToBytes32(att.Data.BeaconBlockRoot))
votedBlk, err := s.beaconDB.Block(ctx, bytesutil.ToBytes32(att.Data.BeaconBlockRoot))
if err != nil {
return false, errors.Wrap(err, "could not hash block")
}
if votedBlk == nil {
return false, nil
}
canonicalBlk, err := s.beaconDB.CanonicalBlockBySlot(ctx, votedBlk.Slot)
// TODO(3219): Replace with new fork choice service.
canonicalBlk, err := s.beaconDB.(*db.BeaconDB).CanonicalBlockBySlot(ctx, votedBlk.Slot)
if err != nil {
return false, errors.Wrap(err, "could not hash block")
}
@@ -329,18 +335,18 @@ func (s *Service) removeOperations() {
}
}
func (s *Service) handleProcessedBlock(_ context.Context, message proto.Message) error {
func (s *Service) handleProcessedBlock(ctx context.Context, message proto.Message) error {
block := message.(*ethpb.BeaconBlock)
// Removes the attestations from the pool that have been included
// in the received block.
if err := s.removeAttestationsFromPool(block.Body.Attestations); err != nil {
if err := s.removeAttestationsFromPool(ctx, block.Body.Attestations); err != nil {
return errors.Wrap(err, "could not remove processed attestations from DB")
}
state, err := s.beaconDB.HeadState(s.ctx)
if err != nil {
return errors.New("could not retrieve attestations from DB")
}
if err := s.removeEpochOldAttestations(state); err != nil {
if err := s.removeEpochOldAttestations(ctx, state); err != nil {
return errors.Wrapf(err, "could not remove old attestations from DB at slot %d", block.Slot)
}
return nil
@@ -348,25 +354,25 @@ func (s *Service) handleProcessedBlock(_ context.Context, message proto.Message)
// removeAttestationsFromPool removes a list of attestations from the DB
// after they have been included in a beacon block.
func (s *Service) removeAttestationsFromPool(attestations []*ethpb.Attestation) error {
func (s *Service) removeAttestationsFromPool(ctx context.Context, attestations []*ethpb.Attestation) error {
for _, attestation := range attestations {
hash, err := hashutil.HashProto(attestation.Data)
if err != nil {
return err
}
if s.beaconDB.HasAttestation(hash) {
if err := s.beaconDB.DeleteAttestation(attestation); err != nil {
if s.beaconDB.HasAttestation(ctx, hash) {
if err := s.beaconDB.DeleteAttestation(ctx, hash); err != nil {
return err
}
log.WithField("root", fmt.Sprintf("%#x", hash)).Debug("Attestation removed")
log.WithField("root", fmt.Sprintf("%#x", hash)).Debug("AttestationDeprecated removed")
}
}
return nil
}
// removeEpochOldAttestations removes attestations that's older than one epoch length from current slot.
func (s *Service) removeEpochOldAttestations(beaconState *pb.BeaconState) error {
attestations, err := s.beaconDB.Attestations()
func (s *Service) removeEpochOldAttestations(ctx context.Context, beaconState *pb.BeaconState) error {
attestations, err := s.beaconDB.Attestations(ctx, nil /*filter*/)
if err != nil {
return err
}
@@ -377,7 +383,11 @@ func (s *Service) removeEpochOldAttestations(beaconState *pb.BeaconState) error
}
// Remove attestation from DB if it's one epoch older than slot.
if slot-params.BeaconConfig().SlotsPerEpoch >= slot {
if err := s.beaconDB.DeleteAttestation(a); err != nil {
hash, err := ssz.HashTreeRoot(a)
if err != nil {
return err
}
if err := s.beaconDB.DeleteAttestation(ctx, hash); err != nil {
return err
}
}

39
beacon-chain/operations/service_test.go
View File

@@ -14,6 +14,7 @@ import (
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -144,7 +145,7 @@ func TestHandleAttestation_Saves_NewAttestation(t *testing.T) {
newBlock := &ethpb.BeaconBlock{
Slot: 0,
}
if err := beaconDB.SaveBlock(newBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(newBlock); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(context.Background(), newBlock, beaconState); err != nil {
@@ -167,6 +168,7 @@ func TestHandleAttestation_Saves_NewAttestation(t *testing.T) {
func TestHandleAttestation_Aggregates_SameAttestationData(t *testing.T) {
beaconDB := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, beaconDB)
ctx := context.Background()
broadcaster := &mockBroadcaster{}
service := NewOpsPoolService(context.Background(), &Config{
BeaconDB: beaconDB,
@@ -248,7 +250,7 @@ func TestHandleAttestation_Aggregates_SameAttestationData(t *testing.T) {
newBlock := &ethpb.BeaconBlock{
Slot: 0,
}
if err := beaconDB.SaveBlock(newBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(newBlock); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(context.Background(), newBlock, beaconState); err != nil {
@@ -268,7 +270,7 @@ func TestHandleAttestation_Aggregates_SameAttestationData(t *testing.T) {
if err != nil {
t.Error(err)
}
dbAtt, err := service.beaconDB.Attestation(attDataHash)
dbAtt, err := service.beaconDB.Attestation(ctx, attDataHash)
if err != nil {
t.Error(err)
}
@@ -296,6 +298,7 @@ func TestHandleAttestation_Aggregates_SameAttestationData(t *testing.T) {
func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T) {
beaconDB := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, beaconDB)
ctx := context.Background()
helpers.ClearAllCaches()
broadcaster := &mockBroadcaster{}
service := NewOpsPoolService(context.Background(), &Config{
@@ -401,7 +404,7 @@ func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T)
newBlock := &ethpb.BeaconBlock{
Slot: 0,
}
if err := beaconDB.SaveBlock(newBlock); err != nil {
if err := beaconDB.SaveBlockDeprecated(newBlock); err != nil {
t.Fatal(err)
}
if err := beaconDB.UpdateChainHead(context.Background(), newBlock, beaconState); err != nil {
@@ -425,7 +428,7 @@ func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T)
if err != nil {
t.Error(err)
}
dbAtt, err := service.beaconDB.Attestation(attDataHash)
dbAtt, err := service.beaconDB.Attestation(ctx, attDataHash)
if err != nil {
t.Error(err)
}
@@ -442,7 +445,7 @@ func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T)
if err := service.HandleAttestation(context.Background(), att2); err != nil {
t.Error(err)
}
dbAtt, err = service.beaconDB.Attestation(attDataHash)
dbAtt, err = service.beaconDB.Attestation(ctx, attDataHash)
if err != nil {
t.Error(err)
}
@@ -458,7 +461,7 @@ func TestHandleAttestation_Skips_PreviouslyAggregatedAttestations(t *testing.T)
if err := service.HandleAttestation(context.Background(), att3); err != nil {
t.Error(err)
}
dbAtt, err = service.beaconDB.Attestation(attDataHash)
dbAtt, err = service.beaconDB.Attestation(ctx, attDataHash)
if err != nil {
t.Error(err)
}
@@ -496,7 +499,7 @@ func TestRetrieveAttestations_OK(t *testing.T) {
t.Fatalf("Failed to save attestation: %v", err)
}
}
if err := beaconDB.SaveState(context.Background(), &pb.BeaconState{
if err := beaconDB.SaveStateDeprecated(context.Background(), &pb.BeaconState{
Slot: 64,
CurrentCrosslinks: []*ethpb.Crosslink{{
StartEpoch: 0,
@@ -543,7 +546,7 @@ func TestRetrieveAttestations_PruneInvalidAtts(t *testing.T) {
}
// At slot 200 only attestations up to from slot 137 to 139 are valid attestations.
if err := beaconDB.SaveState(context.Background(), &pb.BeaconState{
if err := beaconDB.SaveStateDeprecated(context.Background(), &pb.BeaconState{
Slot: 200,
CurrentCrosslinks: []*ethpb.Crosslink{{
StartEpoch: 2,
@@ -564,7 +567,7 @@ func TestRetrieveAttestations_PruneInvalidAtts(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if service.beaconDB.HasAttestation(hash) {
if service.beaconDB.HasAttestation(context.Background(), hash) {
t.Error("Invalid attestation is not deleted")
}
}
@@ -589,7 +592,7 @@ func TestRemoveProcessedAttestations_Ok(t *testing.T) {
t.Fatalf("Failed to save attestation: %v", err)
}
}
if err := db.SaveState(context.Background(), &pb.BeaconState{
if err := db.SaveStateDeprecated(context.Background(), &pb.BeaconState{
Slot: 15,
CurrentCrosslinks: []*ethpb.Crosslink{{
StartEpoch: 0,
@@ -605,7 +608,7 @@ func TestRemoveProcessedAttestations_Ok(t *testing.T) {
t.Error("Retrieved attestations did not match prev generated attestations")
}
if err := s.removeAttestationsFromPool(attestations); err != nil {
if err := s.removeAttestationsFromPool(context.Background(), attestations); err != nil {
t.Fatalf("Could not remove attestations: %v", err)
}
@@ -636,7 +639,7 @@ func TestReceiveBlkRemoveOps_Ok(t *testing.T) {
}
}
if err := db.SaveState(context.Background(), &pb.BeaconState{
if err := db.SaveStateDeprecated(context.Background(), &pb.BeaconState{
Slot: 15,
CurrentCrosslinks: []*ethpb.Crosslink{{
StartEpoch: 0,
@@ -675,10 +678,10 @@ func TestIsCanonical_CanGetCanonical(t *testing.T) {
s := NewOpsPoolService(context.Background(), &Config{BeaconDB: db})
cb1 := &ethpb.BeaconBlock{Slot: 999, ParentRoot: []byte{'A'}}
if err := s.beaconDB.SaveBlock(cb1); err != nil {
if err := s.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(cb1); err != nil {
t.Fatal(err)
}
if err := s.beaconDB.UpdateChainHead(context.Background(), cb1, &pb.BeaconState{}); err != nil {
if err := s.beaconDB.(*db2.BeaconDB).UpdateChainHead(context.Background(), cb1, &pb.BeaconState{}); err != nil {
t.Fatal(err)
}
r1, err := ssz.SigningRoot(cb1)
@@ -695,10 +698,10 @@ func TestIsCanonical_CanGetCanonical(t *testing.T) {
}
cb2 := &ethpb.BeaconBlock{Slot: 1000, ParentRoot: []byte{'B'}}
if err := s.beaconDB.SaveBlock(cb2); err != nil {
if err := s.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(cb2); err != nil {
t.Fatal(err)
}
if err := s.beaconDB.UpdateChainHead(context.Background(), cb2, &pb.BeaconState{}); err != nil {
if err := s.beaconDB.(*db2.BeaconDB).UpdateChainHead(context.Background(), cb2, &pb.BeaconState{}); err != nil {
t.Fatal(err)
}
canonical, err = s.IsAttCanonical(context.Background(), att1)
@@ -724,7 +727,7 @@ func TestIsCanonical_NilBlocks(t *testing.T) {
}
cb1 := &ethpb.BeaconBlock{Slot: 999, ParentRoot: []byte{'A'}}
if err := s.beaconDB.SaveBlock(cb1); err != nil {
if err := s.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(cb1); err != nil {
t.Fatal(err)
}
r1, err := ssz.SigningRoot(cb1)

1
beacon-chain/powchain/BUILD.bazel
View File

@@ -12,6 +12,7 @@ go_library(
importpath = "github.com/prysmaticlabs/prysm/beacon-chain/powchain",
visibility = ["//beacon-chain:__subpackages__"],
deps = [
"//beacon-chain/cache/depositcache:go_default_library",
"//beacon-chain/core/state:go_default_library",
"//beacon-chain/db:go_default_library",
"//contracts/deposit-contract:go_default_library",

10
beacon-chain/powchain/log_processing.go
View File

@@ -123,16 +123,16 @@ func (w *Web3Service) ProcessDepositLog(depositLog gethTypes.Log) error {
// Make sure duplicates are rejected pre-chainstart.
if !w.chainStarted && validData {
var pubkey = fmt.Sprintf("#%x", depositData.PublicKey)
if w.beaconDB.DepositCache.PubkeyInChainstart(w.ctx, pubkey) {
if w.depositCache.PubkeyInChainstart(w.ctx, pubkey) {
log.Warnf("Pubkey %#x has already been submitted for chainstart", pubkey)
} else {
w.beaconDB.DepositCache.MarkPubkeyForChainstart(w.ctx, pubkey)
w.depositCache.MarkPubkeyForChainstart(w.ctx, pubkey)
}
}
// We always store all historical deposits in the DB.
w.beaconDB.DepositCache.InsertDeposit(w.ctx, deposit, big.NewInt(int64(depositLog.BlockNumber)), int(index), w.depositTrie.Root())
w.depositCache.InsertDeposit(w.ctx, deposit, big.NewInt(int64(depositLog.BlockNumber)), int(index), w.depositTrie.Root())
if !w.chainStarted {
w.chainStartDeposits = append(w.chainStartDeposits, deposit)
@@ -146,7 +146,7 @@ func (w *Web3Service) ProcessDepositLog(depositLog gethTypes.Log) error {
validData = false
}
} else {
w.beaconDB.DepositCache.InsertPendingDeposit(w.ctx, deposit, big.NewInt(int64(depositLog.BlockNumber)), int(index), w.depositTrie.Root())
w.depositCache.InsertPendingDeposit(w.ctx, deposit, big.NewInt(int64(depositLog.BlockNumber)), int(index), w.depositTrie.Root())
}
if validData {
log.WithFields(logrus.Fields{
@@ -245,7 +245,7 @@ func (w *Web3Service) processPastLogs() error {
}
if currentState != nil && currentState.Eth1DepositIndex > 0 {
w.beaconDB.DepositCache.PrunePendingDeposits(w.ctx, int(currentState.Eth1DepositIndex))
w.depositCache.PrunePendingDeposits(w.ctx, int(currentState.Eth1DepositIndex))
}
return nil

35
beacon-chain/powchain/log_processing_test.go
View File

@@ -40,10 +40,9 @@ func TestProcessDepositLog_OK(t *testing.T) {
Logger: &goodLogger{},
HTTPLogger: &goodLogger{},
ContractBackend: testAcc.Backend,
BeaconDB: &db.BeaconDB{
DepositCache: depositcache.NewDepositCache(),
},
BlockFetcher: &goodFetcher{},
BeaconDB: &db.BeaconDB{},
DepositCache: depositcache.NewDepositCache(),
BlockFetcher: &goodFetcher{},
})
if err != nil {
t.Fatalf("unable to setup web3 ETH1.0 chain service: %v", err)
@@ -103,9 +102,8 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
Logger: &goodLogger{},
HTTPLogger: &goodLogger{},
ContractBackend: testAcc.Backend,
BeaconDB: &db.BeaconDB{
DepositCache: depositcache.NewDepositCache(),
},
BeaconDB: &db.BeaconDB{},
DepositCache: depositcache.NewDepositCache(),
})
if err != nil {
t.Fatalf("unable to setup web3 ETH1.0 chain service: %v", err)
@@ -154,7 +152,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
web3Service.ProcessDepositLog(logs[0])
web3Service.ProcessDepositLog(logs[1])
pendingDeposits := web3Service.beaconDB.DepositCache.PendingDeposits(context.Background(), nil /*blockNum*/)
pendingDeposits := web3Service.depositCache.PendingDeposits(context.Background(), nil /*blockNum*/)
if len(pendingDeposits) != 2 {
t.Errorf("Unexpected number of deposits. Wanted 2 deposit, got %+v", pendingDeposits)
}
@@ -251,10 +249,9 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
Logger: &goodLogger{},
HTTPLogger: &goodLogger{},
ContractBackend: testAcc.Backend,
BeaconDB: &db.BeaconDB{
DepositCache: depositcache.NewDepositCache(),
},
BlockFetcher: &goodFetcher{},
BeaconDB: &db.BeaconDB{},
DepositCache: depositcache.NewDepositCache(),
BlockFetcher: &goodFetcher{},
})
if err != nil {
t.Fatalf("unable to setup web3 ETH1.0 chain service: %v", err)
@@ -321,10 +318,9 @@ func TestProcessETH2GenesisLog(t *testing.T) {
Logger: &goodLogger{},
HTTPLogger: &goodLogger{},
ContractBackend: testAcc.Backend,
BeaconDB: &db.BeaconDB{
DepositCache: depositcache.NewDepositCache(),
},
BlockFetcher: &goodFetcher{},
BeaconDB: &db.BeaconDB{},
DepositCache: depositcache.NewDepositCache(),
BlockFetcher: &goodFetcher{},
})
if err != nil {
t.Fatalf("unable to setup web3 ETH1.0 chain service: %v", err)
@@ -402,10 +398,9 @@ func TestWeb3ServiceProcessDepositLog_RequestMissedDeposits(t *testing.T) {
Logger: &goodLogger{},
HTTPLogger: testAcc.Backend,
ContractBackend: testAcc.Backend,
BeaconDB: &db.BeaconDB{
DepositCache: depositcache.NewDepositCache(),
},
BlockFetcher: &goodFetcher{},
BeaconDB: &db.BeaconDB{},
DepositCache: depositcache.NewDepositCache(),
BlockFetcher: &goodFetcher{},
})
if err != nil {
t.Fatalf("unable to setup web3 ETH1.0 chain service: %v", err)

10
beacon-chain/powchain/service.go
View File

@@ -17,6 +17,7 @@ import (
"github.com/pkg/errors"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
contracts "github.com/prysmaticlabs/prysm/contracts/deposit-contract"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -93,7 +94,8 @@ type Web3Service struct {
chainStartDeposits []*ethpb.Deposit
chainStarted bool
chainStartBlockNumber *big.Int
beaconDB *db.BeaconDB
beaconDB db.Database
depositCache *depositcache.DepositCache
lastReceivedMerkleIndex int64 // Keeps track of the last received index to prevent log spam.
isRunning bool
runError error
@@ -115,7 +117,8 @@ type Web3ServiceConfig struct {
HTTPLogger bind.ContractFilterer
BlockFetcher POWBlockFetcher
ContractBackend bind.ContractBackend
BeaconDB *db.BeaconDB
BeaconDB db.Database
DepositCache *depositcache.DepositCache
}
// NewWeb3Service sets up a new instance with an ethclient when
@@ -158,6 +161,7 @@ func NewWeb3Service(ctx context.Context, config *Web3ServiceConfig) (*Web3Servic
depositContractCaller: depositContractCaller,
chainStartDeposits: make([]*ethpb.Deposit, 0),
beaconDB: config.BeaconDB,
depositCache: config.DepositCache,
lastReceivedMerkleIndex: -1,
lastRequestedBlock: big.NewInt(0),
chainStartETH1Data: &ethpb.Eth1Data{},
@@ -266,7 +270,7 @@ func (w *Web3Service) AreAllDepositsProcessed() (bool, error) {
return false, errors.Wrap(err, "could not get deposit count")
}
count := bytesutil.FromBytes8(countByte)
deposits := w.beaconDB.DepositCache.AllDeposits(w.ctx, nil)
deposits := w.depositCache.AllDeposits(w.ctx, nil)
if count != uint64(len(deposits)) {
return false, nil
}

1
beacon-chain/rpc/BUILD.bazel
View File

@@ -23,6 +23,7 @@ go_library(
"//beacon-chain/core/state:go_default_library",
"//beacon-chain/core/state/stateutils:go_default_library",
"//beacon-chain/db:go_default_library",
"//beacon-chain/db/filters:go_default_library",
"//beacon-chain/deprecated-sync:go_default_library",
"//beacon-chain/operations:go_default_library",
"//beacon-chain/p2p:go_default_library",

17
beacon-chain/rpc/attester_server.go
View File

@@ -23,7 +23,7 @@ import (
// providing RPC methods for validators acting as attesters to broadcast votes on beacon blocks.
type AttesterServer struct {
p2p p2p.Broadcaster
beaconDB *db.BeaconDB
beaconDB db.Database
operationService operationService
cache *cache.AttestationCache
}
@@ -37,7 +37,7 @@ func (as *AttesterServer) SubmitAttestation(ctx context.Context, att *ethpb.Atte
// Update attestation target for RPC server to run necessary fork choice.
// We need to retrieve the head block to get its parent root.
head, err := as.beaconDB.Block(bytesutil.ToBytes32(att.Data.BeaconBlockRoot))
head, err := as.beaconDB.Block(ctx, bytesutil.ToBytes32(att.Data.BeaconBlockRoot))
if err != nil {
return nil, err
}
@@ -52,11 +52,16 @@ func (as *AttesterServer) SubmitAttestation(ctx context.Context, att *ethpb.Atte
BeaconBlockRoot: att.Data.BeaconBlockRoot,
ParentRoot: head.ParentRoot,
}
if err := as.beaconDB.SaveAttestationTarget(ctx, attTarget); err != nil {
return nil, fmt.Errorf("could not save attestation target")
db, isLegacyDB := as.beaconDB.(*db.BeaconDB)
if isLegacyDB {
if err := db.SaveAttestationTarget(ctx, attTarget); err != nil {
return nil, fmt.Errorf("could not save attestation target")
}
}
as.p2p.Broadcast(ctx, att)
if err := as.p2p.Broadcast(ctx, att); err != nil {
return nil, err
}
hash, err := hashutil.HashProto(att)
if err != nil {
@@ -100,7 +105,7 @@ func (as *AttesterServer) RequestAttestation(ctx context.Context, req *pb.Attest
// Set the attestation data's beacon block root = hash_tree_root(head) where head
// is the validator's view of the head block of the beacon chain during the slot.
headBlock, err := as.beaconDB.ChainHead()
headBlock, err := as.beaconDB.(*db.BeaconDB).ChainHead()
if err != nil {
return nil, errors.Wrap(err, "failed to retrieve chain head")
}

31
beacon-chain/rpc/attester_server_test.go
View File

@@ -9,6 +9,7 @@ import (
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
pb "github.com/prysmaticlabs/prysm/proto/beacon/rpc/v1"
@@ -26,6 +27,8 @@ func (m *mockBroadcaster) Broadcast(ctx context.Context, msg proto.Message) erro
func TestSubmitAttestation_OK(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
mockOperationService := &mockOperationService{}
attesterServer := &AttesterServer{
operationService: mockOperationService,
@@ -37,7 +40,7 @@ func TestSubmitAttestation_OK(t *testing.T) {
Slot: 999,
ParentRoot: []byte{'a'},
}
if err := attesterServer.beaconDB.SaveBlock(head); err != nil {
if err := attesterServer.beaconDB.SaveBlock(ctx, head); err != nil {
t.Fatal(err)
}
root, err := ssz.SigningRoot(head)
@@ -60,7 +63,7 @@ func TestSubmitAttestation_OK(t *testing.T) {
ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
}
if err := db.SaveState(context.Background(), state); err != nil {
if err := db.SaveStateDeprecated(context.Background(), state); err != nil {
t.Fatal(err)
}
@@ -133,22 +136,22 @@ func TestRequestAttestation_OK(t *testing.T) {
p2p: &mockBroadcaster{},
cache: cache.NewAttestationCache(),
}
if err := attesterServer.beaconDB.SaveBlock(targetBlock); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(targetBlock); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, targetBlock, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, targetBlock, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
if err := attesterServer.beaconDB.SaveBlock(justifiedBlock); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(justifiedBlock); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, justifiedBlock, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, justifiedBlock, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
if err := attesterServer.beaconDB.SaveBlock(block); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
req := &pb.AttestationRequest{
@@ -253,22 +256,22 @@ func TestAttestationDataAtSlot_handlesFarAwayJustifiedEpoch(t *testing.T) {
p2p: &mockBroadcaster{},
cache: cache.NewAttestationCache(),
}
if err := attesterServer.beaconDB.SaveBlock(epochBoundaryBlock); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(epochBoundaryBlock); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, epochBoundaryBlock, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, epochBoundaryBlock, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
if err := attesterServer.beaconDB.SaveBlock(justifiedBlock); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(justifiedBlock); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, justifiedBlock, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, justifiedBlock, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
if err := attesterServer.beaconDB.SaveBlock(block); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).SaveBlockDeprecated(block); err != nil {
t.Fatalf("Could not save block in test db: %v", err)
}
if err := attesterServer.beaconDB.UpdateChainHead(ctx, block, beaconState); err != nil {
if err := attesterServer.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, block, beaconState); err != nil {
t.Fatalf("Could not update chain head in test db: %v", err)
}
req := &pb.AttestationRequest{

53
beacon-chain/rpc/beacon_chain_server.go
View File

@@ -8,6 +8,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
"github.com/prysmaticlabs/prysm/beacon-chain/operations"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -21,7 +22,7 @@ import (
// providing RPC endpoints to access data relevant to the Ethereum 2.0 phase 0
// beacon chain.
type BeaconChainServer struct {
beaconDB *db.BeaconDB
beaconDB db.Database
pool operations.Pool
}
@@ -60,7 +61,7 @@ func (bs *BeaconChainServer) ListAttestations(
case *ethpb.ListAttestationsRequest_Epoch:
return nil, status.Error(codes.Unimplemented, "not implemented")
}
atts, err := bs.beaconDB.Attestations()
atts, err := bs.beaconDB.Attestations(ctx, nil)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not fetch attestations: %v", err)
}
@@ -91,7 +92,7 @@ func (bs *BeaconChainServer) ListAttestations(
func (bs *BeaconChainServer) AttestationPool(
ctx context.Context, _ *ptypes.Empty,
) (*ethpb.AttestationPoolResponse, error) {
headBlock, err := bs.beaconDB.ChainHead()
headBlock, err := bs.beaconDB.(*db.BeaconDB).ChainHead()
if err != nil {
return nil, err
}
@@ -124,14 +125,21 @@ func (bs *BeaconChainServer) ListBlocks(
endSlot := startSlot + params.BeaconConfig().SlotsPerEpoch
var blks []*ethpb.BeaconBlock
for i := startSlot; i < endSlot; i++ {
b, err := bs.beaconDB.BlocksBySlot(ctx, i)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve blocks for slot %d: %v", i, err)
if d, isLegacyDB := bs.beaconDB.(*db.BeaconDB); isLegacyDB {
for i := startSlot; i < endSlot; i++ {
b, err := d.BlocksBySlot(ctx, i)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve blocks for slot %d: %v", i, err)
}
blks = append(blks, b...)
}
} else {
var err error
blks, err = bs.beaconDB.Blocks(ctx, filters.NewFilter().SetStartSlot(startSlot).SetEndSlot(endSlot))
if err != nil {
return nil, status.Errorf(codes.Internal, "failed to get blocks: %v", err)
}
blks = append(blks, b...)
}
numBlks := len(blks)
if numBlks == 0 {
return &ethpb.ListBlocksResponse{Blocks: []*ethpb.BeaconBlock{}, TotalSize: 0}, nil
@@ -149,7 +157,7 @@ func (bs *BeaconChainServer) ListBlocks(
}, nil
case *ethpb.ListBlocksRequest_Root:
blk, err := bs.beaconDB.Block(bytesutil.ToBytes32(q.Root))
blk, err := bs.beaconDB.Block(ctx, bytesutil.ToBytes32(q.Root))
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve block: %v", err)
}
@@ -164,7 +172,13 @@ func (bs *BeaconChainServer) ListBlocks(
}, nil
case *ethpb.ListBlocksRequest_Slot:
blks, err := bs.beaconDB.BlocksBySlot(ctx, q.Slot)
var blks []*ethpb.BeaconBlock
var err error
if d, isLegacyDB := bs.beaconDB.(*db.BeaconDB); isLegacyDB {
blks, err = d.BlocksBySlot(ctx, q.Slot)
} else {
blks, err = bs.beaconDB.Blocks(ctx, filters.NewFilter().SetStartSlot(q.Slot).SetEndSlot(q.Slot))
}
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve blocks for slot %d: %v", q.Slot, err)
}
@@ -212,11 +226,11 @@ func (bs *BeaconChainServer) ListValidatorBalances(
res := make([]*ethpb.ValidatorBalances_Balance, 0, len(req.PublicKeys)+len(req.Indices))
filtered := map[uint64]bool{} // track filtered validators to prevent duplication in the response.
balances, err := bs.beaconDB.Balances(ctx)
balances, err := bs.beaconDB.(*db.BeaconDB).Balances(ctx)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve validator balances: %v", err)
}
validators, err := bs.beaconDB.Validators(ctx)
validators, err := bs.beaconDB.(*db.BeaconDB).Validators(ctx)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve validators: %v", err)
}
@@ -227,7 +241,7 @@ func (bs *BeaconChainServer) ListValidatorBalances(
continue
}
index, err := bs.beaconDB.ValidatorIndex(pubKey)
index, err := bs.beaconDB.(*db.BeaconDB).ValidatorIndexDeprecated(pubKey)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve validator index: %v", err)
}
@@ -275,11 +289,12 @@ func (bs *BeaconChainServer) GetValidators(
req.PageSize, params.BeaconConfig().MaxPageSize)
}
validators, err := bs.beaconDB.Validators(ctx)
head, err := bs.beaconDB.HeadState(ctx)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve validators: %v", err)
return nil, status.Errorf(codes.Internal, "could not get head state %v", err)
}
validatorCount := len(validators)
validatorCount := len(head.Validators)
start, end, nextPageToken, err := pagination.StartAndEndPage(req.PageToken, int(req.PageSize), validatorCount)
if err != nil {
@@ -287,7 +302,7 @@ func (bs *BeaconChainServer) GetValidators(
}
res := &ethpb.Validators{
Validators: validators[start:end],
Validators: head.Validators[start:end],
TotalSize: int32(validatorCount),
NextPageToken: nextPageToken,
}
@@ -335,7 +350,7 @@ func (bs *BeaconChainServer) ListValidatorAssignments(
// Filter out assignments by public keys.
for _, pubKey := range req.PublicKeys {
index, err := bs.beaconDB.ValidatorIndex(pubKey)
index, err := bs.beaconDB.(*db.BeaconDB).ValidatorIndexDeprecated(pubKey)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve validator index: %v", err)
}

51
beacon-chain/rpc/beacon_chain_server_test.go
View File

@@ -13,6 +13,7 @@ import (
"github.com/prysmaticlabs/go-bitfield"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
db2 "github.com/prysmaticlabs/prysm/beacon-chain/db"
"github.com/prysmaticlabs/prysm/beacon-chain/internal"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -259,10 +260,10 @@ func TestBeaconChainServer_AttestationPool(t *testing.T) {
pool: &mockPool{},
beaconDB: db,
}
if err := bs.beaconDB.SaveBlock(&ethpb.BeaconBlock{Slot: 10}); err != nil {
if err := bs.beaconDB.SaveBlock(ctx, &ethpb.BeaconBlock{Slot: 10}); err != nil {
t.Fatal(err)
}
if err := bs.beaconDB.UpdateChainHead(ctx, &ethpb.BeaconBlock{Slot: 10}, &pbp2p.BeaconState{Slot: 10}); err != nil {
if err := bs.beaconDB.(*db2.BeaconDB).UpdateChainHead(ctx, &ethpb.BeaconBlock{Slot: 10}, &pbp2p.BeaconState{Slot: 10}); err != nil {
t.Fatal(err)
}
res, err := bs.AttestationPool(ctx, &ptypes.Empty{})
@@ -283,14 +284,14 @@ func TestBeaconChainServer_ListValidatorBalances(t *testing.T) {
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
balances[i] = uint64(i)
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators, Balances: balances}); err != nil {
t.Fatal(err)
@@ -352,14 +353,14 @@ func TestBeaconChainServer_ListValidatorBalancesOutOfRange(t *testing.T) {
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
balances[i] = uint64(i)
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators, Balances: balances}); err != nil {
t.Fatal(err)
@@ -383,13 +384,13 @@ func TestBeaconChainServer_GetValidatorsNoPagination(t *testing.T) {
count := 100
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators}); err != nil {
t.Fatal(err)
@@ -417,14 +418,14 @@ func TestBeaconChainServer_GetValidatorsPagination(t *testing.T) {
balances := make([]uint64, count)
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
balances[i] = uint64(i)
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators, Balances: balances}); err != nil {
t.Fatal(err)
@@ -488,13 +489,13 @@ func TestBeaconChainServer_GetValidatorsPaginationOutOfRange(t *testing.T) {
count := 1
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators}); err != nil {
t.Fatal(err)
@@ -529,13 +530,13 @@ func TestBeaconChainServer_GetValidatorsDefaultPageSize(t *testing.T) {
count := 1000
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators}); err != nil {
t.Fatal(err)
@@ -565,13 +566,13 @@ func TestBeaconChainServer_ListAssignmentsInputOutOfRange(t *testing.T) {
count := 1
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}})
}
if err := db.SaveState(
if err := db.SaveStateDeprecated(
context.Background(),
&pbp2p.BeaconState{Validators: validators}); err != nil {
t.Fatal(err)
@@ -603,7 +604,7 @@ func TestBeaconChainServer_ListAssignmentsDefaultPageSize(t *testing.T) {
count := 1000
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
// Mark the validators with index divisible by 3 inactive.
@@ -618,7 +619,7 @@ func TestBeaconChainServer_ListAssignmentsDefaultPageSize(t *testing.T) {
Validators: validators,
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)}
if err := db.SaveState(context.Background(), s); err != nil {
if err := db.SaveStateDeprecated(context.Background(), s); err != nil {
t.Fatal(err)
}
@@ -665,7 +666,7 @@ func TestBeaconChainServer_ListAssignmentsFilterPubkeysIndicesNoPage(t *testing.
count := 100
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}, ExitEpoch: params.BeaconConfig().FarFutureEpoch})
@@ -675,7 +676,7 @@ func TestBeaconChainServer_ListAssignmentsFilterPubkeysIndicesNoPage(t *testing.
Validators: validators,
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)}
if err := db.SaveState(context.Background(), s); err != nil {
if err := db.SaveStateDeprecated(context.Background(), s); err != nil {
t.Fatal(err)
}
@@ -723,7 +724,7 @@ func TestBeaconChainServer_ListAssignmentsCanFilterPubkeysIndicesWithPages(t *te
count := 100
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
if err := db.SaveValidatorIndex([]byte{byte(i)}, i); err != nil {
if err := db.SaveValidatorIndexDeprecated([]byte{byte(i)}, i); err != nil {
t.Fatal(err)
}
validators = append(validators, &ethpb.Validator{PublicKey: []byte{byte(i)}, ExitEpoch: params.BeaconConfig().FarFutureEpoch})
@@ -733,7 +734,7 @@ func TestBeaconChainServer_ListAssignmentsCanFilterPubkeysIndicesWithPages(t *te
Validators: validators,
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
ActiveIndexRoots: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)}
if err := db.SaveState(context.Background(), s); err != nil {
if err := db.SaveStateDeprecated(context.Background(), s); err != nil {
t.Fatal(err)
}
@@ -860,10 +861,10 @@ func TestBeaconChainServer_GetValidatorsParticipation(t *testing.T) {
beaconDB: db,
}
if err := bs.beaconDB.SaveState(context.Background(), s); err != nil {
if err := bs.beaconDB.(*db2.BeaconDB).SaveStateDeprecated(context.Background(), s); err != nil {
t.Fatal(err)
}
if err := bs.beaconDB.SaveFinalizedBlock(&ethpb.BeaconBlock{Slot: 1}); err != nil {
if err := bs.beaconDB.(*db2.BeaconDB).SaveFinalizedBlock(&ethpb.BeaconBlock{Slot: 1}); err != nil {
t.Fatal(err)
}
@@ -895,7 +896,7 @@ func TestBeaconChainServer_ListBlocksPagination(t *testing.T) {
b := &ethpb.BeaconBlock{
Slot: i,
}
if err := db.SaveBlock(b); err != nil {
if err := db.SaveBlockDeprecated(b); err != nil {
t.Fatal(err)
}
blks[i] = b

131
beacon-chain/rpc/beacon_server.go
View File

@@ -7,21 +7,21 @@ import (
ptypes "github.com/gogo/protobuf/types"
"github.com/pkg/errors"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/blockchain"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
pb "github.com/prysmaticlabs/prysm/proto/beacon/rpc/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/trieutil"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// BeaconServer defines a server implementation of the gRPC Beacon service,
// providing RPC endpoints for obtaining the canonical beacon chain head,
// fetching latest observed attestations, and more.
type BeaconServer struct {
beaconDB *db.BeaconDB
beaconDB db.Database
ctx context.Context
powChainService powChainService
chainService chainService
@@ -71,7 +71,7 @@ func (bs *BeaconServer) WaitForChainStart(req *ptypes.Empty, stream pb.BeaconSer
// CanonicalHead of the current beacon chain. This method is requested on-demand
// by a validator when it is their time to propose or attest.
func (bs *BeaconServer) CanonicalHead(ctx context.Context, req *ptypes.Empty) (*ethpb.BeaconBlock, error) {
block, err := bs.beaconDB.ChainHead()
block, err := bs.beaconDB.HeadBlock(ctx)
if err != nil {
return nil, errors.Wrap(err, "could not get canonical head block")
}
@@ -80,130 +80,15 @@ func (bs *BeaconServer) CanonicalHead(ctx context.Context, req *ptypes.Empty) (*
// BlockTree returns the current tree of saved blocks and their votes starting from the justified state.
func (bs *BeaconServer) BlockTree(ctx context.Context, _ *ptypes.Empty) (*pb.BlockTreeResponse, error) {
justifiedState, err := bs.beaconDB.JustifiedState()
if err != nil {
return nil, errors.Wrap(err, "could not retrieve justified state")
}
attestationTargets, err := bs.targetsFetcher.AttestationTargets(justifiedState)
if err != nil {
return nil, errors.Wrap(err, "could not retrieve attestation target")
}
justifiedBlock, err := bs.beaconDB.JustifiedBlock()
if err != nil {
return nil, err
}
highestSlot := bs.beaconDB.HighestBlockSlot()
fullBlockTree := []*ethpb.BeaconBlock{}
for i := justifiedBlock.Slot + 1; i < highestSlot; i++ {
if ctx.Err() != nil {
return nil, ctx.Err()
}
nextLayer, err := bs.beaconDB.BlocksBySlot(ctx, i)
if err != nil {
return nil, err
}
fullBlockTree = append(fullBlockTree, nextLayer...)
}
tree := []*pb.BlockTreeResponse_TreeNode{}
for _, kid := range fullBlockTree {
if ctx.Err() != nil {
return nil, ctx.Err()
}
participatedVotes, err := blockchain.VoteCount(kid, justifiedState, attestationTargets, bs.beaconDB)
if err != nil {
return nil, err
}
blockRoot, err := ssz.SigningRoot(kid)
if err != nil {
return nil, err
}
tree = append(tree, &pb.BlockTreeResponse_TreeNode{
BlockRoot: blockRoot[:],
Block: kid,
ParticipatedVotes: uint64(participatedVotes),
})
}
return &pb.BlockTreeResponse{
Tree: tree,
}, nil
// TODO(3219): Add after new fork choice service.
return nil, status.Error(codes.Unimplemented, "not implemented")
}
// BlockTreeBySlots returns the current tree of saved blocks and their
// votes starting from the justified state.
func (bs *BeaconServer) BlockTreeBySlots(ctx context.Context, req *pb.TreeBlockSlotRequest) (*pb.BlockTreeResponse, error) {
justifiedState, err := bs.beaconDB.JustifiedState()
if err != nil {
return nil, errors.Wrap(err, "could not retrieve justified state")
}
attestationTargets, err := bs.targetsFetcher.AttestationTargets(justifiedState)
if err != nil {
return nil, errors.Wrap(err, "could not retrieve attestation target")
}
justifiedBlock, err := bs.beaconDB.JustifiedBlock()
if err != nil {
return nil, err
}
if req == nil {
return nil, errors.New("argument 'TreeBlockSlotRequest' cannot be nil")
}
if !(req.SlotFrom <= req.SlotTo) {
return nil, fmt.Errorf("upper limit (%d) of slot range cannot be lower than the lower limit (%d)", req.SlotTo, req.SlotFrom)
}
highestSlot := bs.beaconDB.HighestBlockSlot()
fullBlockTree := []*ethpb.BeaconBlock{}
for i := justifiedBlock.Slot + 1; i < highestSlot; i++ {
if ctx.Err() != nil {
return nil, ctx.Err()
}
if i >= req.SlotFrom && i <= req.SlotTo {
nextLayer, err := bs.beaconDB.BlocksBySlot(ctx, i)
if err != nil {
return nil, err
}
if nextLayer != nil {
fullBlockTree = append(fullBlockTree, nextLayer...)
}
}
if i > req.SlotTo {
break
}
}
tree := []*pb.BlockTreeResponse_TreeNode{}
for _, kid := range fullBlockTree {
if ctx.Err() != nil {
return nil, ctx.Err()
}
participatedVotes, err := blockchain.VoteCount(kid, justifiedState, attestationTargets, bs.beaconDB)
if err != nil {
return nil, err
}
blockRoot, err := ssz.SigningRoot(kid)
if err != nil {
return nil, err
}
hState, err := bs.beaconDB.HistoricalStateFromSlot(ctx, kid.Slot, blockRoot)
if err != nil {
return nil, err
}
if kid.Slot >= req.SlotFrom && kid.Slot <= req.SlotTo {
activeValidatorIndices, err := helpers.ActiveValidatorIndices(hState, helpers.CurrentEpoch(hState))
if err != nil {
return nil, err
}
totalVotes := helpers.TotalBalance(hState, activeValidatorIndices)
tree = append(tree, &pb.BlockTreeResponse_TreeNode{
BlockRoot: blockRoot[:],
Block: kid,
ParticipatedVotes: uint64(participatedVotes),
TotalVotes: uint64(totalVotes),
})
}
}
return &pb.BlockTreeResponse{
Tree: tree,
}, nil
// TODO(3219): Add after new fork choice service.
return nil, status.Error(codes.Unimplemented, "not implemented")
}
func constructMerkleProof(trie *trieutil.MerkleTrie, index int, deposit *ethpb.Deposit) (*ethpb.Deposit, error) {

9
beacon-chain/rpc/beacon_server_test.go
View File

@@ -248,6 +248,7 @@ func TestWaitForChainStart_NotStartedThenLogFired(t *testing.T) {
}
func TestBlockTree_OK(t *testing.T) {
t.Skip() // TODO(3219): Add after new fork choice service.
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
@@ -439,7 +440,7 @@ func TestBlockTree_OK(t *testing.T) {
},
}
for _, node := range tree {
if err := db.SaveBlock(node.Block); err != nil {
if err := db.SaveBlockDeprecated(node.Block); err != nil {
t.Fatal(err)
}
}
@@ -469,6 +470,7 @@ func TestBlockTree_OK(t *testing.T) {
}
func TestBlockTreeBySlots_ArgsValildation(t *testing.T) {
t.Skip() // TODO(3219): Add after new fork choice service.
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
@@ -650,7 +652,7 @@ func TestBlockTreeBySlots_ArgsValildation(t *testing.T) {
},
}
for _, node := range tree {
if err := db.SaveBlock(node.Block); err != nil {
if err := db.SaveBlockDeprecated(node.Block); err != nil {
t.Fatal(err)
}
}
@@ -678,6 +680,7 @@ func TestBlockTreeBySlots_ArgsValildation(t *testing.T) {
}
}
func TestBlockTreeBySlots_OK(t *testing.T) {
t.Skip() // TODO(3219): Add after new fork choice service.
helpers.ClearAllCaches()
db := internal.SetupDBDeprecated(t)
@@ -865,7 +868,7 @@ func TestBlockTreeBySlots_OK(t *testing.T) {
},
}
for _, node := range tree {
if err := db.SaveBlock(node.Block); err != nil {
if err := db.SaveBlockDeprecated(node.Block); err != nil {
t.Fatal(err)
}
}

8
beacon-chain/rpc/node_server.go
View File

@@ -21,7 +21,7 @@ import (
type NodeServer struct {
syncChecker sync.Checker
server *grpc.Server
beaconDB *db.BeaconDB
beaconDB db.Database
}
// GetSyncStatus checks the current network sync status of the node.
@@ -33,11 +33,13 @@ func (ns *NodeServer) GetSyncStatus(ctx context.Context, _ *ptypes.Empty) (*ethp
// GetGenesis fetches genesis chain information of Ethereum 2.0.
func (ns *NodeServer) GetGenesis(ctx context.Context, _ *ptypes.Empty) (*ethpb.Genesis, error) {
beaconState, err := ns.beaconDB.FinalizedState()
// TODO(3045): Use the db.Database interface only.
beaconState, err := ns.beaconDB.(*db.BeaconDB).FinalizedState()
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve beacon state: %v", err)
}
address, err := ns.beaconDB.DepositContractAddress(ctx)
// TODO(3045): Use the db.Database interface only.
address, err := ns.beaconDB.(*db.BeaconDB).DepositContractAddress(ctx)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not retrieve deposit contract address: %v", err)
}

31
beacon-chain/rpc/proposer_server.go
View File

@@ -25,11 +25,12 @@ import (
// providing RPC endpoints for computing state transitions and state roots, proposing
// beacon blocks to a beacon node, and more.
type ProposerServer struct {
beaconDB *db.BeaconDB
beaconDB db.Database
chainService chainService
powChainService powChainService
operationService operationService
canonicalStateChan chan *pbp2p.BeaconState
depositCache *depositcache.DepositCache
}
// RequestBlock is called by a proposer during its assigned slot to request a block to sign
@@ -37,7 +38,7 @@ type ProposerServer struct {
func (ps *ProposerServer) RequestBlock(ctx context.Context, req *pb.BlockRequest) (*ethpb.BeaconBlock, error) {
// Retrieve the parent block as the current head of the canonical chain
parent, err := ps.beaconDB.ChainHead()
parent, err := ps.beaconDB.HeadBlock(ctx)
if err != nil {
return nil, errors.Wrap(err, "could not get canonical head block")
}
@@ -115,8 +116,11 @@ func (ps *ProposerServer) ProposeBlock(ctx context.Context, blk *ethpb.BeaconBlo
return nil, errors.Wrap(err, "could not process beacon block")
}
if err := ps.beaconDB.UpdateChainHead(ctx, blk, beaconState); err != nil {
return nil, errors.Wrap(err, "failed to update chain")
db, isLegacyDB := ps.beaconDB.(*db.BeaconDB)
if isLegacyDB {
if err := db.UpdateChainHead(ctx, blk, beaconState); err != nil {
return nil, errors.Wrap(err, "failed to update chain")
}
}
ps.chainService.UpdateCanonicalRoots(blk, root)
@@ -179,7 +183,12 @@ func (ps *ProposerServer) attestations(ctx context.Context, expectedSlot uint64)
"slot": slot,
"headRoot": fmt.Sprintf("%#x", bytesutil.Trunc(att.Data.BeaconBlockRoot))}).Info(
"Deleting failed pending attestation from DB")
if err := ps.beaconDB.DeleteAttestation(att); err != nil {
hash, err := ssz.HashTreeRoot(att)
if err != nil {
return nil, err
}
if err := ps.beaconDB.DeleteAttestation(ctx, hash); err != nil {
return nil, errors.Wrap(err, "could not delete failed attestation")
}
continue
@@ -187,7 +196,11 @@ func (ps *ProposerServer) attestations(ctx context.Context, expectedSlot uint64)
canonical, err := ps.operationService.IsAttCanonical(ctx, att)
if err != nil {
// Delete attestation that failed to verify as canonical.
if err := ps.beaconDB.DeleteAttestation(att); err != nil {
hash, err := ssz.HashTreeRoot(att)
if err != nil {
return nil, err
}
if err := ps.beaconDB.DeleteAttestation(ctx, hash); err != nil {
return nil, errors.Wrap(err, "could not delete failed attestation")
}
return nil, errors.Wrap(err, "could not verify canonical attestation")
@@ -268,7 +281,7 @@ func (ps *ProposerServer) deposits(ctx context.Context, currentVote *ethpb.Eth1D
return []*ethpb.Deposit{}, nil
}
upToEth1DataDeposits := ps.beaconDB.DepositCache.AllDeposits(ctx, latestEth1DataHeight)
upToEth1DataDeposits := ps.depositCache.AllDeposits(ctx, latestEth1DataHeight)
depositData := [][]byte{}
for _, dep := range upToEth1DataDeposits {
depHash, err := ssz.HashTreeRoot(dep.Data)
@@ -283,7 +296,7 @@ func (ps *ProposerServer) deposits(ctx context.Context, currentVote *ethpb.Eth1D
return nil, errors.Wrap(err, "could not generate historical deposit trie from deposits")
}
allPendingContainers := ps.beaconDB.DepositCache.PendingContainers(ctx, latestEth1DataHeight)
allPendingContainers := ps.depositCache.PendingContainers(ctx, latestEth1DataHeight)
// Deposits need to be received in order of merkle index root, so this has to make sure
// deposits are sorted from lowest to highest.
@@ -349,7 +362,7 @@ func (ps *ProposerServer) defaultEth1DataResponse(ctx context.Context, currentHe
return nil, errors.Wrap(err, "could not fetch ETH1_FOLLOW_DISTANCE ancestor")
}
// Fetch all historical deposits up to an ancestor height.
depositsTillHeight, depositRoot := ps.beaconDB.DepositCache.DepositsNumberAndRootAtHeight(ctx, ancestorHeight)
depositsTillHeight, depositRoot := ps.depositCache.DepositsNumberAndRootAtHeight(ctx, ancestorHeight)
if depositsTillHeight == 0 {
return ps.powChainService.ChainStartETH1Data(), nil
}

80
beacon-chain/rpc/proposer_server_test.go
View File

@@ -30,13 +30,14 @@ func init() {
}
func TestProposeBlock_OK(t *testing.T) {
helpers.ClearAllCaches()
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
mockChain := &mockChainService{}
ctx := context.Background()
genesis := b.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlock(context.Background(), genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
@@ -60,7 +61,7 @@ func TestProposeBlock_OK(t *testing.T) {
Slot: 5,
ParentRoot: []byte("parent-hash"),
}
if err := proposerServer.beaconDB.SaveBlock(req); err != nil {
if err := proposerServer.beaconDB.SaveBlock(ctx, req); err != nil {
t.Fatal(err)
}
if _, err := proposerServer.ProposeBlock(context.Background(), req); err != nil {
@@ -88,7 +89,7 @@ func TestComputeStateRoot_OK(t *testing.T) {
}
genesis := b.NewGenesisBlock(stateRoot[:])
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
@@ -235,7 +236,7 @@ func TestPendingAttestations_FiltersWithinInclusionDelay(t *testing.T) {
chainService: &mockChainService{},
beaconDB: db,
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -243,7 +244,7 @@ func TestPendingAttestations_FiltersWithinInclusionDelay(t *testing.T) {
Slot: beaconState.Slot,
}
if err := db.SaveBlock(blk); err != nil {
if err := db.SaveBlockDeprecated(blk); err != nil {
t.Fatalf("failed to save block %v", err)
}
@@ -396,7 +397,7 @@ func TestPendingAttestations_FiltersExpiredAttestations(t *testing.T) {
beaconDB: db,
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -404,7 +405,7 @@ func TestPendingAttestations_FiltersExpiredAttestations(t *testing.T) {
Slot: beaconState.Slot,
}
if err := db.SaveBlock(blk); err != nil {
if err := db.SaveBlockDeprecated(blk); err != nil {
t.Fatalf("failed to save block %v", err)
}
@@ -490,7 +491,7 @@ func TestPendingDeposits_Eth1DataVoteOK(t *testing.T) {
Eth1DepositIndex: 2,
Eth1DataVotes: votes,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -566,7 +567,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
},
Eth1DepositIndex: 2,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -619,6 +620,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
}},
},
}
depositCache := depositcache.NewDepositCache()
depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
@@ -633,16 +635,17 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
deposits, err := bs.deposits(ctx, &ethpb.Eth1Data{})
@@ -701,7 +704,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
Eth1DepositIndex: 1,
Eth1DataVotes: votes,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -754,6 +757,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
}},
},
}
depositCache := depositcache.NewDepositCache()
depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
@@ -768,16 +772,17 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
deposits, err := bs.deposits(ctx, &ethpb.Eth1Data{})
@@ -824,7 +829,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
},
Eth1DepositIndex: 10,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
@@ -868,6 +873,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
}
depositCache := depositcache.NewDepositCache()
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
if err != nil {
@@ -878,16 +884,17 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
// It should also return the recent deposits after their follow window.
@@ -926,7 +933,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
},
Eth1DepositIndex: 2,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
var mockSig [96]byte
@@ -969,6 +976,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
}
depositCache := depositcache.NewDepositCache()
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
if err != nil {
@@ -979,16 +987,17 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
// It should also return the recent deposits after their follow window.
@@ -1025,7 +1034,7 @@ func TestPendingDeposits_CantReturnMoreDepositCount(t *testing.T) {
},
Eth1DepositIndex: 2,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
var mockSig [96]byte
@@ -1068,6 +1077,7 @@ func TestPendingDeposits_CantReturnMoreDepositCount(t *testing.T) {
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
}
depositCache := depositcache.NewDepositCache()
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
if err != nil {
@@ -1078,16 +1088,17 @@ func TestPendingDeposits_CantReturnMoreDepositCount(t *testing.T) {
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
// It should also return the recent deposits after their follow window.
@@ -1122,7 +1133,7 @@ func TestEth1Data_EmptyVotesFetchBlockHashFailure(t *testing.T) {
},
Eth1DataVotes: []*ethpb.Eth1Data{},
}
if err := proposerServer.beaconDB.SaveState(ctx, beaconState); err != nil {
if err := proposerServer.beaconDB.SaveState(ctx, beaconState, [32]byte{}); err != nil {
t.Fatal(err)
}
want := "could not fetch ETH1_FOLLOW_DISTANCE ancestor"
@@ -1163,8 +1174,9 @@ func TestDefaultEth1Data_NoBlockExists(t *testing.T) {
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
}
depositCache := depositcache.NewDepositCache()
for _, dp := range deps {
beaconDB.DepositCache.InsertDeposit(context.Background(), dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
depositCache.InsertDeposit(context.Background(), dp.Deposit, dp.Block, dp.Index, depositTrie.Root())
}
powChainService := &mockPOWChainService{
@@ -1177,6 +1189,7 @@ func TestDefaultEth1Data_NoBlockExists(t *testing.T) {
proposerServer := &ProposerServer{
beaconDB: beaconDB,
powChainService: powChainService,
depositCache: depositCache,
}
defEth1Data := &ethpb.Eth1Data{
@@ -1216,7 +1229,8 @@ func TestEth1Data(t *testing.T) {
DepositCount: 55,
},
},
beaconDB: beaconDB,
beaconDB: beaconDB,
depositCache: depositcache.NewDepositCache(),
}
ctx := context.Background()
@@ -1266,10 +1280,11 @@ func Benchmark_Eth1Data(b *testing.B) {
},
}
depositCache := depositcache.NewDepositCache()
for i, dp := range deposits {
var root [32]byte
copy(root[:], []byte{'d', 'e', 'p', 'o', 's', 'i', 't', byte(i)})
beaconDB.DepositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, root)
depositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, root)
}
numOfVotes := 1000
for i := 0; i < numOfVotes; i++ {
@@ -1283,7 +1298,7 @@ func Benchmark_Eth1Data(b *testing.B) {
}
hashesByHeight[numOfVotes+1] = []byte("stub")
if err := beaconDB.SaveState(ctx, beaconState); err != nil {
if err := beaconDB.SaveStateDeprecated(ctx, beaconState); err != nil {
b.Fatal(err)
}
currentHeight := params.BeaconConfig().Eth1FollowDistance + 5
@@ -1293,6 +1308,7 @@ func Benchmark_Eth1Data(b *testing.B) {
latestBlockNumber: big.NewInt(int64(currentHeight)),
hashesByHeight: hashesByHeight,
},
depositCache: depositCache,
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
@@ -1322,7 +1338,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
},
Eth1DepositIndex: 2,
}
if err := d.SaveState(ctx, beaconState); err != nil {
if err := d.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatal(err)
}
var mockSig [96]byte
@@ -1365,6 +1381,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
if err != nil {
t.Fatalf("could not setup deposit trie: %v", err)
}
depositCache := depositcache.NewDepositCache()
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
if err != nil {
@@ -1375,16 +1392,17 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
t.Fatalf("Unable to insert deposit into trie %v", err)
}
d.DepositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
for _, dp := range recentDeposits {
d.DepositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
depositCache.InsertPendingDeposit(ctx, dp.Deposit, big.NewInt(int64(dp.Index)), dp.Index, depositTrie.Root())
}
bs := &ProposerServer{
beaconDB: d,
powChainService: p,
chainService: newMockChainService(),
depositCache: depositCache,
}
// It should also return the recent deposits after their follow window.

4
beacon-chain/rpc/service.go
View File

@@ -77,7 +77,7 @@ type syncService interface {
type Service struct {
ctx context.Context
cancel context.CancelFunc
beaconDB *db.BeaconDB
beaconDB db.Database
chainService chainService
powChainService powChainService
operationService operationService
@@ -98,7 +98,7 @@ type Config struct {
Port string
CertFlag string
KeyFlag string
BeaconDB *db.BeaconDB
BeaconDB db.Database
ChainService chainService
POWChainService powChainService
OperationService operationService

26
beacon-chain/rpc/validator_server.go
View File

@@ -8,6 +8,7 @@ import (
"time"
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"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"
@@ -25,10 +26,11 @@ import (
// and more.
type ValidatorServer struct {
ctx context.Context
beaconDB *db.BeaconDB
beaconDB db.Database
chainService chainService
canonicalStateChan chan *pbp2p.BeaconState
powChainService powChainService
depositCache *depositcache.DepositCache
}
// WaitForActivation checks if a validator public key exists in the active validator registry of the current
@@ -76,7 +78,7 @@ func (vs *ValidatorServer) WaitForActivation(req *pb.ValidatorActivationRequest,
// ValidatorIndex is called by a validator to get its index location that corresponds
// to the attestation bit fields.
func (vs *ValidatorServer) ValidatorIndex(ctx context.Context, req *pb.ValidatorIndexRequest) (*pb.ValidatorIndexResponse, error) {
index, err := vs.beaconDB.ValidatorIndex(req.PublicKey)
index, err := vs.beaconDB.(*db.BeaconDB).ValidatorIndexDeprecated(req.PublicKey)
if err != nil {
return nil, errors.Wrap(err, "could not get validator index")
}
@@ -89,7 +91,7 @@ func (vs *ValidatorServer) ValidatorIndex(ctx context.Context, req *pb.Validator
func (vs *ValidatorServer) ValidatorPerformance(
ctx context.Context, req *pb.ValidatorPerformanceRequest,
) (*pb.ValidatorPerformanceResponse, error) {
index, err := vs.beaconDB.ValidatorIndex(req.PublicKey)
index, _, err := vs.beaconDB.ValidatorIndex(ctx, bytesutil.ToBytes48(req.PublicKey))
if err != nil {
return nil, errors.Wrap(err, "could not get validator index")
}
@@ -97,11 +99,6 @@ func (vs *ValidatorServer) ValidatorPerformance(
if err != nil {
return nil, errors.Wrap(err, "could not get head")
}
Validators, err := vs.beaconDB.Validators(ctx)
if err != nil {
return nil, errors.Wrap(err, "could not retrieve beacon state")
}
activeCount, err := helpers.ActiveValidatorCount(head, helpers.SlotToEpoch(req.Slot))
if err != nil {
return nil, errors.Wrap(err, "could not retrieve active validator count")
@@ -112,17 +109,12 @@ func (vs *ValidatorServer) ValidatorPerformance(
return nil, errors.Wrap(err, "could not retrieve active balance")
}
validatorBalances, err := vs.beaconDB.Balances(ctx)
if err != nil {
return nil, errors.Wrap(err, "could not retrieve validator balances")
}
avgBalance := float32(totalActiveBalance / activeCount)
balance := validatorBalances[index]
balance := head.Balances[index]
return &pb.ValidatorPerformanceResponse{
Balance: balance,
AverageActiveValidatorBalance: avgBalance,
TotalValidators: uint64(len(Validators)),
TotalValidators: uint64(len(head.Validators)),
TotalActiveValidators: uint64(activeCount),
}, nil
}
@@ -195,7 +187,7 @@ func (vs *ValidatorServer) assignment(
)
}
idx, err := vs.beaconDB.ValidatorIndex(pubkey)
idx, _, err := vs.beaconDB.ValidatorIndex(context.TODO(), bytesutil.ToBytes48(pubkey))
if err != nil {
return nil, errors.Wrap(err, "could not get active validator index")
}
@@ -307,7 +299,7 @@ func (vs *ValidatorServer) validatorStatus(
beaconState *pbp2p.BeaconState) *pb.ValidatorStatusResponse {
pk := bytesutil.ToBytes32(pubKey)
valIdx, ok := idxMap[pk]
_, eth1BlockNumBigInt := vs.beaconDB.DepositCache.DepositByPubkey(ctx, pubKey)
_, eth1BlockNumBigInt := vs.depositCache.DepositByPubkey(ctx, pubKey)
if eth1BlockNumBigInt == nil {
return &pb.ValidatorStatusResponse{
Status: pb.ValidatorStatus_UNKNOWN_STATUS,

123
beacon-chain/rpc/validator_server_test.go
View File

@@ -16,6 +16,7 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/golang/mock/gomock"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
blk "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -33,9 +34,12 @@ import (
func TestValidatorIndex_OK(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
if err := db.SaveStateDeprecated(context.Background(), &pbp2p.BeaconState{}); err != nil {
t.Fatal(err)
}
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
@@ -52,8 +56,8 @@ func TestValidatorIndex_OK(t *testing.T) {
}
func TestValidatorIndex_InStateNotInDB(t *testing.T) {
db := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, db)
d := internal.SetupDBDeprecated(t)
defer internal.TeardownDBDeprecated(t, d)
pubKey := []byte{'A'}
@@ -62,12 +66,12 @@ func TestValidatorIndex_InStateNotInDB(t *testing.T) {
Validators: []*ethpb.Validator{{PublicKey: []byte{0}}, {PublicKey: []byte{'A'}}, {PublicKey: []byte{'B'}}},
}
if err := db.SaveState(context.Background(), s); err != nil {
if err := d.SaveStateDeprecated(context.Background(), s); err != nil {
t.Fatal(err)
}
validatorServer := &ValidatorServer{
beaconDB: db,
beaconDB: d,
}
req := &pb.ValidatorIndexRequest{
@@ -84,7 +88,7 @@ func TestValidatorIndex_InStateNotInDB(t *testing.T) {
}
// Verify index is also saved in DB.
idx, err := validatorServer.beaconDB.ValidatorIndex(pubKey)
idx, err := validatorServer.beaconDB.(*db.BeaconDB).ValidatorIndexDeprecated(pubKey)
if err != nil {
t.Fatal(err)
}
@@ -104,11 +108,11 @@ func TestNextEpochCommitteeAssignment_WrongPubkeyLength(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := db.SaveState(context.Background(), beaconState); err != nil {
if err := db.SaveStateDeprecated(context.Background(), beaconState); err != nil {
t.Fatal(err)
}
block := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(block); err != nil {
if err := db.SaveBlockDeprecated(block); err != nil {
t.Fatalf("Could not save block: %v", err)
}
if err := db.UpdateChainHead(ctx, block, beaconState); err != nil {
@@ -132,7 +136,7 @@ func TestNextEpochCommitteeAssignment_CantFindValidatorIdx(t *testing.T) {
defer internal.TeardownDBDeprecated(t, db)
ctx := context.Background()
genesis := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
deposits, _ := testutil.SetupInitialDeposits(t, params.BeaconConfig().MinGenesisActiveValidatorCount)
@@ -164,7 +168,7 @@ func TestCommitteeAssignment_OK(t *testing.T) {
ctx := context.Background()
genesis := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount / 16
@@ -245,7 +249,7 @@ func TestCommitteeAssignment_CurrentEpoch_ShouldNotFail(t *testing.T) {
ctx := context.Background()
genesis := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount / 16
@@ -301,7 +305,7 @@ func TestCommitteeAssignment_multipleKeys_OK(t *testing.T) {
ctx := context.Background()
genesis := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
t.Fatalf("Could not save genesis block: %v", err)
}
depChainStart := params.BeaconConfig().MinGenesisActiveValidatorCount / 16
@@ -359,12 +363,12 @@ func TestValidatorStatus_PendingActive(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
// Pending active because activation epoch is still defaulted at far future slot.
if err := db.SaveState(ctx, &pbp2p.BeaconState{Validators: []*ethpb.Validator{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{Validators: []*ethpb.Validator{
{ActivationEpoch: params.BeaconConfig().FarFutureEpoch, PublicKey: pubKey},
},
Slot: 5000,
@@ -384,7 +388,8 @@ func TestValidatorStatus_PendingActive(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
@@ -394,6 +399,7 @@ func TestValidatorStatus_PendingActive(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -416,7 +422,7 @@ func TestValidatorStatus_Active(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
@@ -433,11 +439,12 @@ func TestValidatorStatus_Active(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
// Active because activation epoch <= current epoch < exit epoch.
activeEpoch := helpers.DelayedActivationExitEpoch(0)
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
GenesisTime: uint64(time.Unix(0, 0).Unix()),
Slot: 10000,
Validators: []*ethpb.Validator{{
@@ -456,6 +463,7 @@ func TestValidatorStatus_Active(t *testing.T) {
int(params.BeaconConfig().Eth1FollowDistance): uint64(timestamp),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -481,7 +489,7 @@ func TestValidatorStatus_InitiatedExit(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
@@ -490,7 +498,7 @@ func TestValidatorStatus_InitiatedExit(t *testing.T) {
epoch := helpers.SlotToEpoch(slot)
exitEpoch := helpers.DelayedActivationExitEpoch(epoch)
withdrawableEpoch := exitEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
Slot: slot,
Validators: []*ethpb.Validator{{
PublicKey: pubKey,
@@ -513,7 +521,8 @@ func TestValidatorStatus_InitiatedExit(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
beaconDB: db,
@@ -522,6 +531,7 @@ func TestValidatorStatus_InitiatedExit(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -541,14 +551,14 @@ func TestValidatorStatus_Withdrawable(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
// Withdrawable exit because current epoch is after validator withdrawable epoch.
slot := uint64(10000)
epoch := helpers.SlotToEpoch(slot)
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
Slot: 10000,
Validators: []*ethpb.Validator{{
WithdrawableEpoch: epoch - 1,
@@ -570,7 +580,8 @@ func TestValidatorStatus_Withdrawable(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
beaconDB: db,
@@ -579,6 +590,7 @@ func TestValidatorStatus_Withdrawable(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -598,14 +610,14 @@ func TestValidatorStatus_ExitedSlashed(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
// Exit slashed because slashed is true, exit epoch is =< current epoch and withdrawable epoch > epoch .
slot := uint64(10000)
epoch := helpers.SlotToEpoch(slot)
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
Slot: slot,
Validators: []*ethpb.Validator{{
Slashed: true,
@@ -627,7 +639,8 @@ func TestValidatorStatus_ExitedSlashed(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
beaconDB: db,
@@ -636,6 +649,7 @@ func TestValidatorStatus_ExitedSlashed(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -655,14 +669,14 @@ func TestValidatorStatus_Exited(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
// Exit because only exit epoch is =< current epoch.
slot := uint64(10000)
epoch := helpers.SlotToEpoch(slot)
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
Slot: slot,
Validators: []*ethpb.Validator{{
PublicKey: pubKey,
@@ -683,7 +697,8 @@ func TestValidatorStatus_Exited(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
beaconDB: db,
@@ -692,6 +707,7 @@ func TestValidatorStatus_Exited(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -711,11 +727,11 @@ func TestValidatorStatus_UnknownStatus(t *testing.T) {
ctx := context.Background()
pubKey := []byte{'A'}
if err := db.SaveValidatorIndex(pubKey, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
if err := db.SaveState(ctx, &pbp2p.BeaconState{
if err := db.SaveStateDeprecated(ctx, &pbp2p.BeaconState{
Slot: 0,
Validators: []*ethpb.Validator{{
ActivationEpoch: 0,
@@ -737,7 +753,8 @@ func TestValidatorStatus_UnknownStatus(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(0) /*blockNum*/, 0, depositTrie.Root())
height := time.Unix(int64(params.BeaconConfig().Eth1FollowDistance), 0).Unix()
vs := &ValidatorServer{
beaconDB: db,
@@ -746,6 +763,7 @@ func TestValidatorStatus_UnknownStatus(t *testing.T) {
0: uint64(height),
},
},
depositCache: depositCache,
}
req := &pb.ValidatorIndexRequest{
PublicKey: pubKey,
@@ -768,7 +786,7 @@ func TestWaitForActivation_ContextClosed(t *testing.T) {
Slot: 0,
Validators: []*ethpb.Validator{},
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatalf("could not save state: %v", err)
}
@@ -779,6 +797,7 @@ func TestWaitForActivation_ContextClosed(t *testing.T) {
chainService: newMockChainService(),
powChainService: &mockPOWChainService{},
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
depositCache: depositcache.NewDepositCache(),
}
req := &pb.ValidatorActivationRequest{
PublicKeys: [][]byte{[]byte("A")},
@@ -821,10 +840,10 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
pubKey1 := priv1.PublicKey().Marshal()[:]
pubKey2 := priv2.PublicKey().Marshal()[:]
if err := db.SaveValidatorIndex(pubKey1, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey1, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
if err := db.SaveValidatorIndex(pubKey2, 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey2, 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
@@ -843,7 +862,7 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
},
},
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatalf("could not save state: %v", err)
}
depData := &ethpb.Deposit_Data{
@@ -864,11 +883,12 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, deposit, big.NewInt(10) /*blockNum*/, 0, depositTrie.Root())
if err := db.SaveValidatorIndex(pubKey1, 0); err != nil {
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, deposit, big.NewInt(10) /*blockNum*/, 0, depositTrie.Root())
if err := db.SaveValidatorIndexDeprecated(pubKey1, 0); err != nil {
t.Fatalf("could not save validator index: %v", err)
}
if err := db.SaveValidatorIndex(pubKey2, 1); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKey2, 1); err != nil {
t.Fatalf("could not save validator index: %v", err)
}
vs := &ValidatorServer{
@@ -877,6 +897,7 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
chainService: newMockChainService(),
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
powChainService: &mockPOWChainService{},
depositCache: depositCache,
}
req := &pb.ValidatorActivationRequest{
PublicKeys: [][]byte{pubKey1, pubKey2},
@@ -917,10 +938,10 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
ctx := context.Background()
pubKeys := [][]byte{{'A'}, {'B'}, {'C'}}
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKeys[0], 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
if err := db.SaveValidatorIndex(pubKeys[1], 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKeys[1], 0); err != nil {
t.Fatalf("Could not save validator index: %v", err)
}
@@ -940,7 +961,7 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
PublicKey: pubKeys[2]},
},
}
if err := db.SaveState(ctx, beaconState); err != nil {
if err := db.SaveStateDeprecated(ctx, beaconState); err != nil {
t.Fatalf("could not save state: %v", err)
}
depData := &ethpb.Deposit_Data{
@@ -957,7 +978,8 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
if err != nil {
t.Fatal(fmt.Errorf("could not setup deposit trie: %v", err))
}
db.DepositCache.InsertDeposit(ctx, dep, big.NewInt(10) /*blockNum*/, 0, depositTrie.Root())
depositCache := depositcache.NewDepositCache()
depositCache.InsertDeposit(ctx, dep, big.NewInt(10) /*blockNum*/, 0, depositTrie.Root())
depData = &ethpb.Deposit_Data{
PublicKey: []byte{'C'},
Signature: []byte("hi"),
@@ -969,15 +991,15 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
Data: depData,
}
depositTrie.InsertIntoTrie(dep.Data.Signature, 15)
db.DepositCache.InsertDeposit(context.Background(), dep, big.NewInt(15), 0, depositTrie.Root())
depositCache.InsertDeposit(context.Background(), dep, big.NewInt(15), 0, depositTrie.Root())
if err := db.SaveValidatorIndex(pubKeys[0], 0); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKeys[0], 0); err != nil {
t.Fatalf("could not save validator index: %v", err)
}
if err := db.SaveValidatorIndex(pubKeys[1], 1); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKeys[1], 1); err != nil {
t.Fatalf("could not save validator index: %v", err)
}
if err := db.SaveValidatorIndex(pubKeys[2], 2); err != nil {
if err := db.SaveValidatorIndexDeprecated(pubKeys[2], 2); err != nil {
t.Fatalf("could not save validator index: %v", err)
}
vs := &ValidatorServer{
@@ -986,6 +1008,7 @@ func TestMultipleValidatorStatus_OK(t *testing.T) {
chainService: newMockChainService(),
canonicalStateChan: make(chan *pbp2p.BeaconState, 1),
powChainService: &mockPOWChainService{},
depositCache: depositCache,
}
activeExists, response, err := vs.MultipleValidatorStatus(context.Background(), pubKeys)
if err != nil {
@@ -1016,10 +1039,10 @@ func BenchmarkAssignment(b *testing.B) {
path := path.Join(testutil.TempDir(), fmt.Sprintf("/%d", randPath))
db, _ := db.NewDBDeprecated(path)
defer db.Close()
os.RemoveAll(db.DatabasePath)
os.RemoveAll(db.DatabasePath())
genesis := blk.NewGenesisBlock([]byte{})
if err := db.SaveBlock(genesis); err != nil {
if err := db.SaveBlockDeprecated(genesis); err != nil {
b.Fatalf("Could not save genesis block: %v", err)
}
validatorCount := params.BeaconConfig().MinGenesisActiveValidatorCount * 4

19
beacon-chain/sync/service.go
View File

@@ -11,13 +11,30 @@ import (
var _ = shared.Service(&RegularSync{})
// Config to set up the regular sync service.
type Config struct {
P2P p2p.P2P
DB db.Database
Operations *operations.Service
}
// NewRegularSync service.
func NewRegularSync(cfg *Config) *RegularSync {
return &RegularSync{
ctx: context.Background(),
db: cfg.DB,
p2p: cfg.P2P,
operations: cfg.Operations,
}
}
// RegularSync service is responsible for handling all run time p2p related operations as the
// main entry point for network messages.
type RegularSync struct {
ctx context.Context
p2p p2p.P2P
db db.Database
operations operations.Service
operations *operations.Service
}
// Start the regular sync service by initializing all of the p2p sync handlers.

12
shared/featureconfig/config.go
View File

@@ -30,6 +30,8 @@ type FeatureFlagConfig struct {
EnableExcessDeposits bool // EnableExcessDeposits in validator balances.
NoGenesisDelay bool // NoGenesisDelay when processing a chain start genesis event.
UseNewP2P bool // UseNewP2P service.
UseNewSync bool // UseNewSync services.
UseNewDatabase bool // UseNewDatabase service.
// Cache toggles.
EnableActiveBalanceCache bool // EnableActiveBalanceCache; see https://github.com/prysmaticlabs/prysm/issues/3106.
@@ -72,10 +74,18 @@ func ConfigureBeaconFeatures(ctx *cli.Context) {
log.Warn("Using non standard genesis delay. This may cause problems in a multi-node environment.")
cfg.NoGenesisDelay = true
}
if ctx.GlobalBool(UseNewP2PFlag.Name) {
if ctx.GlobalBool(NextFlag.Name) || ctx.GlobalBool(UseNewP2PFlag.Name) {
log.Warn("Using new P2P service.")
cfg.UseNewP2P = true
}
if ctx.GlobalBool(NextFlag.Name) || ctx.GlobalBool(UseNewSyncFlag.Name) {
log.Warn("Using new sync services.")
cfg.UseNewSync = true
}
if ctx.GlobalBool(NextFlag.Name) || ctx.GlobalBool(UseNewDatabaseFlag.Name) {
log.Warn("Using new database service.")
cfg.UseNewDatabase = true
}
if ctx.GlobalBool(EnableActiveBalanceCacheFlag.Name) {
log.Warn("Enabled unsafe active balance cache")
cfg.EnableActiveBalanceCache = true

18
shared/featureconfig/flags.go
View File

@@ -36,6 +36,21 @@ var (
Name: "experimental-p2p",
Usage: "Use the new experimental p2p library. See issue #3147.",
}
// UseNewSyncFlag to start the beacon chain using the new sync library.
UseNewSyncFlag = cli.BoolFlag{
Name: "experimental-sync",
Usage: "Use the new experimental sync libraries. See issue #3147.",
}
// UseNewDatabaseFlag to start the beacon chain using new database library.
UseNewDatabaseFlag = cli.BoolFlag{
Name: "experimental-db",
Usage: "Use the new experimental database library.",
}
// NextFlag to enable all experimental features.
NextFlag = cli.BoolFlag{
Name: "next",
Usage: "Use next version experimental features.",
}
// EnableActiveBalanceCacheFlag see https://github.com/prysmaticlabs/prysm/issues/3106.
EnableActiveBalanceCacheFlag = cli.BoolFlag{
Name: "enable-active-balance-cache",
@@ -84,6 +99,9 @@ var BeaconChainFlags = []cli.Flag{
EnableExcessDepositsFlag,
NoGenesisDelayFlag,
UseNewP2PFlag,
UseNewSyncFlag,
UseNewDatabaseFlag,
NextFlag,
EnableActiveBalanceCacheFlag,
EnableAttestationCacheFlag,
EnableAncestorBlockCacheFlag,