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

wrapper: Remove deprecated fork specific wrapper methods for signed beacon blocks (#10369)

Browse Source 
* Remove deprecated wrappers, lots of refactoring

* Revert proto/prysm/v1alpha1/validator.proto

* fix tests

* fix test

* fix conversion in e2e

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>
This commit is contained in:
Preston Van Loon
2022-03-25 18:00:44 -05:00
committed by GitHub
parent bfbf693660
commit b697463da9
116 changed files with 1754 additions and 862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -43,16 +43,18 @@ func TestHeadRoot_DataRace(t *testing.T) {
func TestHeadBlock_DataRace(t *testing.T) { func TestHeadBlock_DataRace(t *testing.T) {
beaconDB := testDB.SetupDB(t) beaconDB := testDB.SetupDB(t)
wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
require.NoError(t, err)
s := &Service{ s := &Service{
cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)}, cfg: &config{BeaconDB: beaconDB, StateGen: stategen.New(beaconDB)},
head: &head{block: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{})}, head: &head{block: wsb},
} }
wait := make(chan struct{}) wait := make(chan struct{})
go func() { go func() {
defer close(wait) defer close(wait)
require.NoError(t, s.saveHead(context.Background(), [32]byte{})) require.NoError(t, s.saveHead(context.Background(), [32]byte{}))
}() }()
_, err := s.HeadBlock(context.Background()) _, err = s.HeadBlock(context.Background())
require.NoError(t, err) require.NoError(t, err)
<-wait <-wait
} }

36
beacon-chain/blockchain/chain_info_test.go
View File

@@ -133,7 +133,9 @@ func TestHeadRoot_UseDB(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
br, err := b.Block.HashTreeRoot() br, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:]})) require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:]}))
require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br)) require.NoError(t, beaconDB.SaveHeadBlockRoot(context.Background(), br))
r, err := c.HeadRoot(context.Background()) r, err := c.HeadRoot(context.Background())
@@ -146,8 +148,10 @@ func TestHeadBlock_CanRetrieve(t *testing.T) {
b.Block.Slot = 1 b.Block.Slot = 1
s, err := v1.InitializeFromProto(&ethpb.BeaconState{}) s, err := v1.InitializeFromProto(&ethpb.BeaconState{})
require.NoError(t, err) require.NoError(t, err)
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
c := &Service{} c := &Service{}
c.head = &head{block: wrapper.WrappedPhase0SignedBeaconBlock(b), state: s} c.head = &head{block: wsb, state: s}
recevied, err := c.HeadBlock(context.Background()) recevied, err := c.HeadBlock(context.Background())
require.NoError(t, err) require.NoError(t, err)
@@ -229,7 +233,9 @@ func TestIsCanonical_Ok(t *testing.T) {
blk.Block.Slot = 0 blk.Block.Slot = 0
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
can, err := c.IsCanonical(ctx, root) can, err := c.IsCanonical(ctx, root)
require.NoError(t, err) require.NoError(t, err)
@@ -447,20 +453,26 @@ func TestService_IsOptimisticForRoot_DB_ProtoArray(t *testing.T) {
b.Block.Slot = 10 b.Block.Slot = 10
br, err := b.Block.HashTreeRoot() br, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10})) require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
optimisticBlock := util.NewBeaconBlock() optimisticBlock := util.NewBeaconBlock()
optimisticBlock.Block.Slot = 11 optimisticBlock.Block.Slot = 11
optimisticRoot, err := optimisticBlock.Block.HashTreeRoot() optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(optimisticBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
validatedBlock := util.NewBeaconBlock() validatedBlock := util.NewBeaconBlock()
validatedBlock.Block.Slot = 9 validatedBlock.Block.Slot = 9
validatedRoot, err := validatedBlock.Block.HashTreeRoot() validatedRoot, err := validatedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(validatedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]} validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint)) require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))
@@ -485,20 +497,26 @@ func TestService_IsOptimisticForRoot__DB_DoublyLinkedTree(t *testing.T) {
b.Block.Slot = 10 b.Block.Slot = 10
br, err := b.Block.HashTreeRoot() br, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10})) require.NoError(t, beaconDB.SaveStateSummary(context.Background(), &ethpb.StateSummary{Root: br[:], Slot: 10}))
optimisticBlock := util.NewBeaconBlock() optimisticBlock := util.NewBeaconBlock()
optimisticBlock.Block.Slot = 11 optimisticBlock.Block.Slot = 11
optimisticRoot, err := optimisticBlock.Block.HashTreeRoot() optimisticRoot, err := optimisticBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(optimisticBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(optimisticBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
validatedBlock := util.NewBeaconBlock() validatedBlock := util.NewBeaconBlock()
validatedBlock.Block.Slot = 9 validatedBlock.Block.Slot = 9
validatedRoot, err := validatedBlock.Block.HashTreeRoot() validatedRoot, err := validatedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(validatedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(validatedBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]} validatedCheckpoint := &ethpb.Checkpoint{Root: br[:]}
require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint)) require.NoError(t, beaconDB.SaveLastValidatedCheckpoint(ctx, validatedCheckpoint))

26
beacon-chain/blockchain/head_test.go
View File

@@ -39,9 +39,10 @@ func TestSaveHead_Different(t *testing.T) {
service := setupBeaconChain(t, beaconDB) service := setupBeaconChain(t, beaconDB)
util.NewBeaconBlock() util.NewBeaconBlock()
oldBlock := wrapper.WrappedPhase0SignedBeaconBlock( oldBlock, err := wrapper.WrappedSignedBeaconBlock(
util.NewBeaconBlock(), util.NewBeaconBlock(),
) )
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock)) require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
oldRoot, err := oldBlock.Block().HashTreeRoot() oldRoot, err := oldBlock.Block().HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -55,7 +56,9 @@ func TestSaveHead_Different(t *testing.T) {
newHeadSignedBlock.Block.Slot = 1 newHeadSignedBlock.Block.Slot = 1
newHeadBlock := newHeadSignedBlock.Block newHeadBlock := newHeadSignedBlock.Block
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(newHeadSignedBlock)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
newRoot, err := newHeadBlock.HashTreeRoot() newRoot, err := newHeadBlock.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
headState, err := util.NewBeaconState() headState, err := util.NewBeaconState()
@@ -80,9 +83,10 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
beaconDB := testDB.SetupDB(t) beaconDB := testDB.SetupDB(t)
service := setupBeaconChain(t, beaconDB) service := setupBeaconChain(t, beaconDB)
oldBlock := wrapper.WrappedPhase0SignedBeaconBlock( oldBlock, err := wrapper.WrappedSignedBeaconBlock(
util.NewBeaconBlock(), util.NewBeaconBlock(),
) )
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock)) require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), oldBlock))
oldRoot, err := oldBlock.Block().HashTreeRoot() oldRoot, err := oldBlock.Block().HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -98,7 +102,9 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:] newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
newHeadBlock := newHeadSignedBlock.Block newHeadBlock := newHeadSignedBlock.Block
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(newHeadSignedBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(newHeadSignedBlock)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
newRoot, err := newHeadBlock.HashTreeRoot() newRoot, err := newHeadBlock.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
headState, err := util.NewBeaconState() headState, err := util.NewBeaconState()
@@ -139,7 +145,9 @@ func TestUpdateHead_MissingJustifiedRoot(t *testing.T) {
service := setupBeaconChain(t, beaconDB) service := setupBeaconChain(t, beaconDB)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(context.Background(), wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -233,7 +241,9 @@ func TestSaveOrphanedAtts(t *testing.T) {
service := setupBeaconChain(t, beaconDB) service := setupBeaconChain(t, beaconDB)
service.genesisTime = time.Now() service.genesisTime = time.Now()
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.saveOrphanedAtts(ctx, r)) require.NoError(t, service.saveOrphanedAtts(ctx, r))
require.Equal(t, len(b.Block.Body.Attestations), service.cfg.AttPool.AggregatedAttestationCount()) require.Equal(t, len(b.Block.Body.Attestations), service.cfg.AttPool.AggregatedAttestationCount())
@@ -259,7 +269,9 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
service := setupBeaconChain(t, beaconDB) service := setupBeaconChain(t, beaconDB)
service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second) service.genesisTime = time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SlotsPerEpoch+1)*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.saveOrphanedAtts(ctx, r)) require.NoError(t, service.saveOrphanedAtts(ctx, r))
require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount()) require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())

14
beacon-chain/blockchain/optimistic_sync_test.go
View File

@@ -424,7 +424,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128) service.genesisTime = time.Now().Add(-time.Second * 12 * 2 * 128)
parentBlk := util.NewBeaconBlockBellatrix() parentBlk := util.NewBeaconBlockBellatrix()
wrappedParentBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(parentBlk) wrappedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlk)
require.NoError(t, err) require.NoError(t, err)
parentRoot, err := wrappedParentBlock.Block().HashTreeRoot() parentRoot, err := wrappedParentBlock.Block().HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -449,7 +449,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
blk := util.NewBeaconBlockBellatrix() blk := util.NewBeaconBlockBellatrix()
blk.Block.Slot = 32 blk.Block.Slot = 32
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk) wr, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(tt, err) require.NoError(tt, err)
return wr return wr
}(t), }(t),
@@ -469,7 +469,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
blk := util.NewBeaconBlockAltair() blk := util.NewBeaconBlockAltair()
blk.Block.Slot = 32 blk.Block.Slot = 32
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
wr, err := wrapper.WrappedAltairSignedBeaconBlock(blk) wr, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(tt, err) require.NoError(tt, err)
return wr return wr
}(t), }(t),
@@ -489,7 +489,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
blk := util.NewBeaconBlockBellatrix() blk := util.NewBeaconBlockBellatrix()
blk.Block.Slot = 32 blk.Block.Slot = 32
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk) wr, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(tt, err) require.NoError(tt, err)
return wr return wr
}(t), }(t),
@@ -517,7 +517,7 @@ func Test_IsOptimisticCandidateBlock(t *testing.T) {
blk.Block.Body.ExecutionPayload.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength) blk.Block.Body.ExecutionPayload.PrevRandao = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
blk.Block.Body.ExecutionPayload.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength) blk.Block.Body.ExecutionPayload.BaseFeePerGas = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
blk.Block.Body.ExecutionPayload.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength) blk.Block.Body.ExecutionPayload.BlockHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk) wr, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(tt, err) require.NoError(tt, err)
return wr return wr
}(t), }(t),
@@ -572,7 +572,7 @@ func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
block := &ethpb.BeaconBlockBellatrix{Body: body, Slot: 200} block := &ethpb.BeaconBlockBellatrix{Body: body, Slot: 200}
rawSigned := &ethpb.SignedBeaconBlockBellatrix{Block: block} rawSigned := &ethpb.SignedBeaconBlockBellatrix{Block: block}
blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned) blk := util.HydrateSignedBeaconBlockBellatrix(rawSigned)
wr, err := wrapper.WrappedBellatrixSignedBeaconBlock(blk) wr, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr)) require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr))
blkRoot, err := wr.Block().HashTreeRoot() blkRoot, err := wr.Block().HashTreeRoot()
@@ -582,7 +582,7 @@ func Test_IsOptimisticShallowExecutionParent(t *testing.T) {
childBlock.Block.ParentRoot = blkRoot[:] childBlock.Block.ParentRoot = blkRoot[:]
// shallow block // shallow block
childBlock.Block.Slot = 201 childBlock.Block.Slot = 201
wrappedChild, err := wrapper.WrappedBellatrixSignedBeaconBlock(childBlock) wrappedChild, err := wrapper.WrappedSignedBeaconBlock(childBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedChild)) require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrappedChild))
candidate, err := service.optimisticCandidateBlock(ctx, wrappedChild.Block()) candidate, err := service.optimisticCandidateBlock(ctx, wrappedChild.Block())

56
beacon-chain/blockchain/process_attestation_test.go
View File

@@ -39,13 +39,17 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
BlkWithOutState := util.NewBeaconBlock() BlkWithOutState := util.NewBeaconBlock()
BlkWithOutState.Block.Slot = 0 BlkWithOutState.Block.Slot = 0
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState))) wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot() BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
BlkWithStateBadAtt := util.NewBeaconBlock() BlkWithStateBadAtt := util.NewBeaconBlock()
BlkWithStateBadAtt.Block.Slot = 1 BlkWithStateBadAtt.Block.Slot = 1
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt))) wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot() BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -56,7 +60,9 @@ func TestStore_OnAttestation_ErrorConditions_ProtoArray(t *testing.T) {
BlkWithValidState := util.NewBeaconBlock() BlkWithValidState := util.NewBeaconBlock()
BlkWithValidState.Block.Slot = 2 BlkWithValidState.Block.Slot = 2
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState))) wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot() BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -145,13 +151,17 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
BlkWithOutState := util.NewBeaconBlock() BlkWithOutState := util.NewBeaconBlock()
BlkWithOutState.Block.Slot = 0 BlkWithOutState.Block.Slot = 0
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithOutState))) wsb, err := wrapper.WrappedSignedBeaconBlock(BlkWithOutState)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot() BlkWithOutStateRoot, err := BlkWithOutState.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
BlkWithStateBadAtt := util.NewBeaconBlock() BlkWithStateBadAtt := util.NewBeaconBlock()
BlkWithStateBadAtt.Block.Slot = 1 BlkWithStateBadAtt.Block.Slot = 1
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithStateBadAtt))) wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithStateBadAtt)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot() BlkWithStateBadAttRoot, err := BlkWithStateBadAtt.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -162,7 +172,9 @@ func TestStore_OnAttestation_ErrorConditions_DoublyLinkedTree(t *testing.T) {
BlkWithValidState := util.NewBeaconBlock() BlkWithValidState := util.NewBeaconBlock()
BlkWithValidState.Block.Slot = 2 BlkWithValidState.Block.Slot = 2
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(BlkWithValidState))) wsb, err = wrapper.WrappedSignedBeaconBlock(BlkWithValidState)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot() BlkWithValidStateRoot, err := BlkWithValidState.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -438,7 +450,9 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 2 b.Block.Slot = 2
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]} d := &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: r[:]}
@@ -455,7 +469,9 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 2 b.Block.Slot = 2
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]} d := &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: r[:]}
@@ -478,7 +494,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
b32 := util.NewBeaconBlock() b32 := util.NewBeaconBlock()
b32.Block.Slot = 32 b32.Block.Slot = 32
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32))) wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r32, err := b32.Block.HashTreeRoot() r32, err := b32.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -486,7 +504,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_ProtoArray(t *testing.T) {
b33 := util.NewBeaconBlock() b33 := util.NewBeaconBlock()
b33.Block.Slot = 33 b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:] b33.Block.ParentRoot = r32[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33))) wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r33, err := b33.Block.HashTreeRoot() r33, err := b33.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -509,7 +529,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
b32 := util.NewBeaconBlock() b32 := util.NewBeaconBlock()
b32.Block.Slot = 32 b32.Block.Slot = 32
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32))) wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r32, err := b32.Block.HashTreeRoot() r32, err := b32.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -517,7 +539,9 @@ func TestVerifyFinalizedConsistency_InconsistentRoot_DoublyLinkedTree(t *testing
b33 := util.NewBeaconBlock() b33 := util.NewBeaconBlock()
b33.Block.Slot = 33 b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:] b33.Block.ParentRoot = r32[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33))) wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r33, err := b33.Block.HashTreeRoot() r33, err := b33.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -534,7 +558,9 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
b32 := util.NewBeaconBlock() b32 := util.NewBeaconBlock()
b32.Block.Slot = 32 b32.Block.Slot = 32
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32))) wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r32, err := b32.Block.HashTreeRoot() r32, err := b32.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -543,7 +569,9 @@ func TestVerifyFinalizedConsistency_OK(t *testing.T) {
b33 := util.NewBeaconBlock() b33 := util.NewBeaconBlock()
b33.Block.Slot = 33 b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:] b33.Block.ParentRoot = r32[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33))) wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r33, err := b33.Block.HashTreeRoot() r33, err := b33.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)

269
beacon-chain/blockchain/process_block_test.go
View File

@@ -50,7 +50,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -61,7 +63,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
random := util.NewBeaconBlock() random := util.NewBeaconBlock()
random.Block.Slot = 1 random.Block.Slot = 1
random.Block.ParentRoot = validGenesisRoot[:] random.Block.ParentRoot = validGenesisRoot[:]
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random))) wsb, err = wrapper.WrappedSignedBeaconBlock(random)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
randomParentRoot, err := random.Block.HashTreeRoot() randomParentRoot, err := random.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]})) require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -126,7 +130,9 @@ func TestStore_OnBlock_ProtoArray(t *testing.T) {
root, err := tt.blk.Block.HashTreeRoot() root, err := tt.blk.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root) wsb, err = wrapper.WrappedSignedBeaconBlock(tt.blk)
require.NoError(t, err)
err = service.onBlock(ctx, wsb, root)
assert.ErrorContains(t, tt.wantErrString, err) assert.ErrorContains(t, tt.wantErrString, err)
}) })
} }
@@ -147,7 +153,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -158,7 +166,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
random := util.NewBeaconBlock() random := util.NewBeaconBlock()
random.Block.Slot = 1 random.Block.Slot = 1
random.Block.ParentRoot = validGenesisRoot[:] random.Block.ParentRoot = validGenesisRoot[:]
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(random))) wsb, err = wrapper.WrappedSignedBeaconBlock(random)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
randomParentRoot, err := random.Block.HashTreeRoot() randomParentRoot, err := random.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]})) require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: st.Slot(), Root: randomParentRoot[:]}))
@@ -223,7 +233,9 @@ func TestStore_OnBlock_DoublyLinkedTree(t *testing.T) {
root, err := tt.blk.Block.HashTreeRoot() root, err := tt.blk.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
err = service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.blk), root) wsb, err := wrapper.WrappedSignedBeaconBlock(tt.blk)
require.NoError(t, err)
err = service.onBlock(ctx, wsb, root)
assert.ErrorContains(t, tt.wantErrString, err) assert.ErrorContains(t, tt.wantErrString, err)
}) })
} }
@@ -260,13 +272,17 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{}) service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
service.saveInitSyncBlock(gRoot, wsb)
st, keys := util.DeterministicGenesisState(t, 64) st, keys := util.DeterministicGenesisState(t, 64)
@@ -278,15 +294,21 @@ func TestStore_OnBlockBatch_ProtoArray(t *testing.T) {
for i := 1; i < 10; i++ { for i := 1; i < 10; i++ {
b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i)) b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
require.NoError(t, err) require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
require.NoError(t, err) require.NoError(t, err)
if i == 1 { if i == 1 {
firstState = bState.Copy() firstState = bState.Copy()
} }
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b)) require.NoError(t, err)
service.saveInitSyncBlock(root, wsb)
wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
blks = append(blks, wsb)
blkRoots = append(blkRoots, root) blkRoots = append(blkRoots, root)
} }
@@ -314,13 +336,17 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0) service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
service.saveInitSyncBlock(gRoot, wsb)
st, keys := util.DeterministicGenesisState(t, 64) st, keys := util.DeterministicGenesisState(t, 64)
@@ -332,15 +358,21 @@ func TestStore_OnBlockBatch_DoublyLinkedTree(t *testing.T) {
for i := 1; i < 10; i++ { for i := 1; i < 10; i++ {
b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i)) b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
require.NoError(t, err) require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
require.NoError(t, err) require.NoError(t, err)
if i == 1 { if i == 1 {
firstState = bState.Copy() firstState = bState.Copy()
} }
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b)) require.NoError(t, err)
service.saveInitSyncBlock(root, wsb)
wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
blks = append(blks, wsb)
blkRoots = append(blkRoots, root) blkRoots = append(blkRoots, root)
} }
@@ -366,12 +398,14 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
service, err := NewService(ctx, opts...) service, err := NewService(ctx, opts...)
require.NoError(t, err) require.NoError(t, err)
genesis := blocks.NewGenesisBlock(params.BeaconConfig().ZeroHash[:]) genesis := blocks.NewGenesisBlock(params.BeaconConfig().ZeroHash[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0) service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) service.saveInitSyncBlock(gRoot, wsb)
st, keys := util.DeterministicGenesisState(t, 64) st, keys := util.DeterministicGenesisState(t, 64)
bState := st.Copy() bState := st.Copy()
@@ -382,15 +416,17 @@ func TestStore_OnBlockBatch_NotifyNewPayload(t *testing.T) {
for i := 1; i <= blkCount; i++ { for i := 1; i <= blkCount; i++ {
b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i)) b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), types.Slot(i))
require.NoError(t, err) require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(ctx, bState, wsb)
require.NoError(t, err) require.NoError(t, err)
if i == 1 { if i == 1 {
firstState = bState.Copy() firstState = bState.Copy()
} }
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.saveInitSyncBlock(root, wrapper.WrappedPhase0SignedBeaconBlock(b)) service.saveInitSyncBlock(root, wsb)
blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(b)) blks = append(blks, wsb)
blkRoots = append(blkRoots, root) blkRoots = append(blkRoots, root)
} }
@@ -427,8 +463,12 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32) newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot() newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk))) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot) diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0) service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -455,8 +495,12 @@ func TestShouldUpdateJustified_ReturnFalse_ProtoArray(t *testing.T) {
newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32) newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot() newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk))) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot) diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0) service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -484,8 +528,12 @@ func TestShouldUpdateJustified_ReturnFalse_DoublyLinkedTree(t *testing.T) {
newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32) newJustifiedBlk.Block.ParentRoot = bytesutil.PadTo(lastJustifiedRoot[:], 32)
newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot() newJustifiedRoot, err := newJustifiedBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(newJustifiedBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(newJustifiedBlk)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(lastJustifiedBlk))) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(lastJustifiedBlk)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot) diff := params.BeaconConfig().SlotsPerEpoch.Sub(1).Mul(params.BeaconConfig().SecondsPerSlot)
service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0) service.genesisTime = time.Unix(time.Now().Unix()-int64(diff), 0)
@@ -512,12 +560,16 @@ func TestCachedPreState_CanGetFromStateSummary_ProtoArray(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{}) service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
service.saveInitSyncBlock(gRoot, wsb)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
@@ -543,12 +595,16 @@ func TestCachedPreState_CanGetFromStateSummary_DoublyLinkedTree(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0) service.cfg.ForkChoiceStore = doublylinkedtree.New(0, 0)
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
service.saveInitSyncBlock(gRoot, wsb)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
@@ -571,12 +627,16 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) service.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{}) service.cfg.ForkChoiceStore = protoarray.New(0, 0, [32]byte{})
service.saveInitSyncBlock(gRoot, wrapper.WrappedPhase0SignedBeaconBlock(genesis)) wsb, err = wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
service.saveInitSyncBlock(gRoot, wsb)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
@@ -590,7 +650,9 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]})) require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: gRoot[:]}))
require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s)) require.NoError(t, service.cfg.StateGen.SaveState(ctx, gRoot, s))
require.NoError(t, service.verifyBlkPreState(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b).Block())) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
} }
func TestUpdateJustified_CouldUpdateBest(t *testing.T) { func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
@@ -606,7 +668,9 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
signedBlock := util.NewBeaconBlock() signedBlock := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(signedBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
r, err := signedBlock.Block.HashTreeRoot() r, err := signedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}}) service.store.SetJustifiedCheckpt(&ethpb.Checkpoint{Root: []byte{'A'}})
@@ -645,7 +709,9 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -656,12 +722,14 @@ func TestFillForkChoiceMissingBlocks_CanSave_ProtoArray(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
block := util.NewBeaconBlock() blk := util.NewBeaconBlock()
block.Block.Slot = 9 blk.Block.Slot = 9
block.Block.ParentRoot = roots[8] blk.Block.ParentRoot = roots[8]
wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8 // 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -686,7 +754,9 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -697,12 +767,15 @@ func TestFillForkChoiceMissingBlocks_CanSave_DoublyLinkedTree(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
block := util.NewBeaconBlock() blk := util.NewBeaconBlock()
block.Block.Slot = 9 blk.Block.Slot = 9
block.Block.ParentRoot = roots[8] blk.Block.ParentRoot = roots[8]
wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8 // 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -727,7 +800,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -738,12 +813,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_ProtoArray(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
block := util.NewBeaconBlock() blk := util.NewBeaconBlock()
block.Block.Slot = 9 blk.Block.Slot = 9
block.Block.ParentRoot = roots[8] blk.Block.ParentRoot = roots[8]
wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8 // 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -771,7 +849,9 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -782,12 +862,15 @@ func TestFillForkChoiceMissingBlocks_RootsMatch_DoublyLinkedTree(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
block := util.NewBeaconBlock() blk := util.NewBeaconBlock()
block.Block.Slot = 9 blk.Block.Slot = 9
block.Block.ParentRoot = roots[8] blk.Block.ParentRoot = roots[8]
wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8 // 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -816,7 +899,9 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -827,23 +912,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_ProtoArray(t *testing.T) {
// Define a tree branch, slot 63 <- 64 <- 65 // Define a tree branch, slot 63 <- 64 <- 65
b63 := util.NewBeaconBlock() b63 := util.NewBeaconBlock()
b63.Block.Slot = 63 b63.Block.Slot = 63
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63))) wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r63, err := b63.Block.HashTreeRoot() r63, err := b63.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b64 := util.NewBeaconBlock() b64 := util.NewBeaconBlock()
b64.Block.Slot = 64 b64.Block.Slot = 64
b64.Block.ParentRoot = r63[:] b64.Block.ParentRoot = r63[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64))) wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r64, err := b64.Block.HashTreeRoot() r64, err := b64.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b65 := util.NewBeaconBlock() b65 := util.NewBeaconBlock()
b65.Block.Slot = 65 b65.Block.Slot = 65
b65.Block.ParentRoot = r64[:] b65.Block.ParentRoot = r64[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65))) wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// There should be 2 nodes, block 65 and block 64. // There should be 2 nodes, block 65 and block 64.
@@ -869,7 +960,9 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
genesisStateRoot := [32]byte{} genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
validGenesisRoot, err := genesis.Block.HashTreeRoot() validGenesisRoot, err := genesis.Block.HashTreeRoot()
assert.NoError(t, err) assert.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -880,23 +973,29 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized_DoublyLinkedTree(t *testing
// Define a tree branch, slot 63 <- 64 <- 65 // Define a tree branch, slot 63 <- 64 <- 65
b63 := util.NewBeaconBlock() b63 := util.NewBeaconBlock()
b63.Block.Slot = 63 b63.Block.Slot = 63
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b63))) wsb, err = wrapper.WrappedSignedBeaconBlock(b63)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r63, err := b63.Block.HashTreeRoot() r63, err := b63.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b64 := util.NewBeaconBlock() b64 := util.NewBeaconBlock()
b64.Block.Slot = 64 b64.Block.Slot = 64
b64.Block.ParentRoot = r63[:] b64.Block.ParentRoot = r63[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b64))) wsb, err = wrapper.WrappedSignedBeaconBlock(b64)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r64, err := b64.Block.HashTreeRoot() r64, err := b64.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b65 := util.NewBeaconBlock() b65 := util.NewBeaconBlock()
b65.Block.Slot = 65 b65.Block.Slot = 65
b65.Block.ParentRoot = r64[:] b65.Block.ParentRoot = r64[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b65))) wsb, err = wrapper.WrappedSignedBeaconBlock(b65)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
err = service.fillInForkChoiceMissingBlocks( err = service.fillInForkChoiceMissingBlocks(
context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b65).Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint()) context.Background(), wsb.Block(), beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err) require.NoError(t, err)
// There should be 2 nodes, block 65 and block 64. // There should be 2 nodes, block 65 and block 64.
@@ -976,7 +1075,9 @@ func blockTree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][]byt
beaconBlock := util.NewBeaconBlock() beaconBlock := util.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
return nil, err return nil, err
} }
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil { if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -1044,7 +1145,9 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
beaconBlock := util.NewBeaconBlock() beaconBlock := util.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
} }
// Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block. // Slots 100 to 200 are skip slots. Requesting root at 150 will yield root at 100. The last physical block.
@@ -1131,7 +1234,9 @@ func TestAncestor_CanUseDB(t *testing.T) {
beaconBlock := util.NewBeaconBlock() beaconBlock := util.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock))) // Saves blocks to DB. wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb)) // Saves blocks to DB.
} }
require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, 0, 0)) require.NoError(t, service.cfg.ForkChoiceStore.InsertOptimisticBlock(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, 0, 0))
@@ -1171,14 +1276,18 @@ func TestVerifyBlkDescendant(t *testing.T) {
b.Block.Slot = 1 b.Block.Slot = 1
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
b1.Block.Slot = 1 b1.Block.Slot = 1
b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32) b1.Block.Body.Graffiti = bytesutil.PadTo([]byte{'a'}, 32)
r1, err := b1.Block.HashTreeRoot() r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
type args struct { type args struct {
parentRoot [32]byte parentRoot [32]byte
@@ -1242,7 +1351,9 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
gBlk := util.NewBeaconBlock() gBlk := util.NewBeaconBlock()
gRoot, err := gBlk.Block.HashTreeRoot() gRoot, err := gBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(gBlk)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gRoot))
require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]})) require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: gRoot[:]}))
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
@@ -1318,7 +1429,9 @@ func TestOnBlock_CanFinalize(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
r, err := blk.Block.HashTreeRoot() r, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, service.onBlock(ctx, wsb, r))
testState, err = service.cfg.StateGen.StateByRoot(ctx, r) testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
require.NoError(t, err) require.NoError(t, err)
} }
@@ -1370,7 +1483,9 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
r, err := blk.Block.HashTreeRoot() r, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.onBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, service.onBlock(ctx, wsb, r))
testState, err = service.cfg.StateGen.StateByRoot(ctx, r) testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
require.NoError(t, err) require.NoError(t, err)
} }
@@ -1434,7 +1549,9 @@ func TestRemoveBlockAttestationsInPool_Canonical(t *testing.T) {
atts := b.Block.Body.Attestations atts := b.Block.Body.Attestations
require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts)) require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount()) require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
} }
@@ -1456,7 +1573,9 @@ func TestRemoveBlockAttestationsInPool_NonCanonical(t *testing.T) {
atts := b.Block.Body.Attestations atts := b.Block.Body.Attestations
require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts)) require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.pruneCanonicalAttsFromPool(ctx, r, wsb))
require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount()) require.Equal(t, 1, service.cfg.AttPool.AggregatedAttestationCount())
} }

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

@@ -47,13 +47,17 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
b32 := util.NewBeaconBlock() b32 := util.NewBeaconBlock()
b32.Block.Slot = 32 b32.Block.Slot = 32
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32))) wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r32, err := b32.Block.HashTreeRoot() r32, err := b32.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b33 := util.NewBeaconBlock() b33 := util.NewBeaconBlock()
b33.Block.Slot = 33 b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:] b33.Block.ParentRoot = r32[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33))) wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r33, err := b33.Block.HashTreeRoot() r33, err := b33.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -74,13 +78,17 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
b32 := util.NewBeaconBlock() b32 := util.NewBeaconBlock()
b32.Block.Slot = 32 b32.Block.Slot = 32
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b32))) wsb, err := wrapper.WrappedSignedBeaconBlock(b32)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r32, err := b32.Block.HashTreeRoot() r32, err := b32.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b33 := util.NewBeaconBlock() b33 := util.NewBeaconBlock()
b33.Block.Slot = 33 b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:] b33.Block.ParentRoot = r32[:]
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b33))) wsb, err = wrapper.WrappedSignedBeaconBlock(b33)
require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r33, err := b33.Block.HashTreeRoot() r33, err := b33.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -137,15 +145,16 @@ func TestNotifyEngineIfChangedHead(t *testing.T) {
hook.Reset() hook.Reset()
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
wr := wrapper.WrappedPhase0SignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wr)) require.NoError(t, err)
require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
finalized := &ethpb.Checkpoint{Root: r[:], Epoch: 0} finalized := &ethpb.Checkpoint{Root: r[:], Epoch: 0}
service.head = &head{ service.head = &head{
slot: 1, slot: 1,
root: r, root: r,
block: wr, block: wsb,
} }
service.store.SetFinalizedCheckpt(finalized) service.store.SetFinalizedCheckpt(finalized)
service.notifyEngineIfChangedHead([32]byte{'b'}) service.notifyEngineIfChangedHead([32]byte{'b'})

16
beacon-chain/blockchain/receive_block_test.go
View File

@@ -144,7 +144,9 @@ func TestService_ReceiveBlock(t *testing.T) {
s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
root, err := tt.args.block.Block.HashTreeRoot() root, err := tt.args.block.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
err = s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block), root) wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
require.NoError(t, err)
err = s.ReceiveBlock(ctx, wsb, root)
if tt.wantedErr != "" { if tt.wantedErr != "" {
assert.ErrorContains(t, tt.wantedErr, err) assert.ErrorContains(t, tt.wantedErr, err)
} else { } else {
@@ -185,7 +187,9 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
wg := sync.WaitGroup{} wg := sync.WaitGroup{}
wg.Add(1) wg.Add(1)
go func() { go func() {
require.NoError(t, s.ReceiveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b), root)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, s.ReceiveBlock(ctx, wsb, root))
wg.Done() wg.Done()
}() }()
wg.Wait() wg.Wait()
@@ -261,7 +265,9 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]}) s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Root: gRoot[:]})
root, err := tt.args.block.Block.HashTreeRoot() root, err := tt.args.block.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
blks := []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(tt.args.block)} wsb, err := wrapper.WrappedSignedBeaconBlock(tt.args.block)
require.NoError(t, err)
blks := []block.SignedBeaconBlock{wsb}
roots := [][32]byte{root} roots := [][32]byte{root}
err = s.ReceiveBlockBatch(ctx, blks, roots) err = s.ReceiveBlockBatch(ctx, blks, roots)
if tt.wantedErr != "" { if tt.wantedErr != "" {
@@ -283,7 +289,9 @@ func TestService_HasInitSyncBlock(t *testing.T) {
if s.HasInitSyncBlock(r) { if s.HasInitSyncBlock(r) {
t.Error("Should not have block") t.Error("Should not have block")
} }
s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
s.saveInitSyncBlock(r, wsb)
if !s.HasInitSyncBlock(r) { if !s.HasInitSyncBlock(r) {
t.Error("Should have block") t.Error("Should have block")
} }

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

@@ -144,7 +144,9 @@ func TestChainStartStop_Initialized(t *testing.T) {
genesisBlk := util.NewBeaconBlock() genesisBlk := util.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot() blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.SetSlot(1)) require.NoError(t, s.SetSlot(1))
@@ -179,12 +181,14 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
genesisBlk := util.NewBeaconBlock() genesisBlk := util.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot() blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot)) require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk))) require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]})) require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]})) require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
chainService.cfg.FinalizedStateAtStartUp = s chainService.cfg.FinalizedStateAtStartUp = s
@@ -250,7 +254,9 @@ func TestChainService_CorrectGenesisRoots(t *testing.T) {
genesisBlk := util.NewBeaconBlock() genesisBlk := util.NewBeaconBlock()
blkRoot, err := genesisBlk.Block.HashTreeRoot() blkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.SetSlot(0)) require.NoError(t, s.SetSlot(0))
@@ -277,7 +283,9 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
genesisRoot, err := genesis.Block.HashTreeRoot() genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1 finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
headBlock := util.NewBeaconBlock() headBlock := util.NewBeaconBlock()
@@ -291,7 +299,9 @@ func TestChainService_InitializeChainInfo(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot)) require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot)) require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]})) require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Epoch: slots.ToEpoch(finalizedSlot), Root: headRoot[:]}))
attSrv, err := attestations.NewService(ctx, &attestations.Config{}) attSrv, err := attestations.NewService(ctx, &attestations.Config{})
require.NoError(t, err) require.NoError(t, err)
@@ -323,7 +333,9 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
genesisRoot, err := genesis.Block.HashTreeRoot() genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1 finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
headBlock := util.NewBeaconBlock() headBlock := util.NewBeaconBlock()
@@ -337,7 +349,9 @@ func TestChainService_InitializeChainInfo_SetHeadAtGenesis(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot)) require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot)) require.NoError(t, beaconDB.SaveState(ctx, headState, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
attSrv, err := attestations.NewService(ctx, &attestations.Config{}) attSrv, err := attestations.NewService(ctx, &attestations.Config{})
require.NoError(t, err) require.NoError(t, err)
ss := &ethpb.StateSummary{ ss := &ethpb.StateSummary{
@@ -376,14 +390,18 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
finalizedBlock := util.NewBeaconBlock() finalizedBlock := util.NewBeaconBlock()
finalizedBlock.Block.Slot = finalizedSlot finalizedBlock.Block.Slot = finalizedSlot
finalizedBlock.Block.ParentRoot = genesisRoot[:] finalizedBlock.Block.ParentRoot = genesisRoot[:]
finalizedRoot, err := finalizedBlock.Block.HashTreeRoot() finalizedRoot, err := finalizedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(finalizedBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
// Set head slot close to the finalization point, no head sync is triggered. // Set head slot close to the finalization point, no head sync is triggered.
headBlock := util.NewBeaconBlock() headBlock := util.NewBeaconBlock()
@@ -391,7 +409,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
headBlock.Block.ParentRoot = finalizedRoot[:] headBlock.Block.ParentRoot = finalizedRoot[:]
headRoot, err := headBlock.Block.HashTreeRoot() headRoot, err := headBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
headState, err := util.NewBeaconState() headState, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
@@ -426,7 +446,9 @@ func TestChainService_InitializeChainInfo_HeadSync(t *testing.T) {
headBlock.Block.ParentRoot = finalizedRoot[:] headBlock.Block.ParentRoot = finalizedRoot[:]
headRoot, err = headBlock.Block.HashTreeRoot() headRoot, err = headBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(headBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot)) require.NoError(t, beaconDB.SaveState(ctx, headState, headRoot))
require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot)) require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, headRoot))
@@ -455,7 +477,9 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
newState, err := util.NewBeaconState() newState, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState)) require.NoError(t, s.cfg.StateGen.SaveState(ctx, r, newState))
require.NoError(t, s.saveHeadNoDB(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk), r, newState)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, s.saveHeadNoDB(ctx, wsb, r, newState))
newB, err := s.cfg.BeaconDB.HeadBlock(ctx) newB, err := s.cfg.BeaconDB.HeadBlock(ctx)
require.NoError(t, err) require.NoError(t, err)
@@ -477,7 +501,9 @@ func TestHasBlock_ForkChoiceAndDB_ProtoArray(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, err := util.NewBeaconState() beaconState, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block") assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block") assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -496,7 +522,9 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, err := util.NewBeaconState() beaconState, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block") assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block") assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -514,7 +542,9 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
block := util.NewBeaconBlock() block := util.NewBeaconBlock()
r, err := block.Block.HashTreeRoot() r, err := block.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
s.saveInitSyncBlock(r, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
s.saveInitSyncBlock(r, wsb)
require.NoError(t, s.Stop()) require.NoError(t, s.Stop())
require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r)) require.Equal(t, true, s.cfg.BeaconDB.HasBlock(ctx, r))
} }
@@ -540,7 +570,9 @@ func BenchmarkHasBlockDB(b *testing.B) {
cfg: &config{BeaconDB: beaconDB}, cfg: &config{BeaconDB: beaconDB},
} }
block := util.NewBeaconBlock() block := util.NewBeaconBlock()
require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block))) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(b, err)
require.NoError(b, s.cfg.BeaconDB.SaveBlock(ctx, wsb))
r, err := block.Block.HashTreeRoot() r, err := block.Block.HashTreeRoot()
require.NoError(b, err) require.NoError(b, err)
@@ -558,13 +590,15 @@ func BenchmarkHasBlockForkChoiceStore_ProtoArray(b *testing.B) {
store: &store.Store{}, store: &store.Store{},
} }
s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}) s.store.SetFinalizedCheckpt(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})
block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}} blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
r, err := block.Block.HashTreeRoot() r, err := blk.Block.HashTreeRoot()
require.NoError(b, err) require.NoError(b, err)
bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}} bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
beaconState, err := v1.InitializeFromProto(bs) beaconState, err := v1.InitializeFromProto(bs)
require.NoError(b, err) require.NoError(b, err)
require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(b, err)
require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
@@ -585,7 +619,9 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}} bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
beaconState, err := v1.InitializeFromProto(bs) beaconState, err := v1.InitializeFromProto(bs)
require.NoError(b, err) require.NoError(b, err)
require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block).Block(), r, beaconState)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(b, err)
require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, wsb.Block(), r, beaconState))
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {

4
beacon-chain/blockchain/weak_subjectivity_checks_test.go
View File

@@ -21,7 +21,9 @@ func TestService_VerifyWeakSubjectivityRoot(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 32 b.Block.Slot = 32
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
tests := []struct { tests := []struct {

18
beacon-chain/core/altair/attestation_test.go
View File

@@ -48,7 +48,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
params.BeaconConfig().MinAttestationInclusionDelay, params.BeaconConfig().MinAttestationInclusionDelay,
beaconState.Slot(), beaconState.Slot(),
) )
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
@@ -79,7 +79,7 @@ func TestProcessAttestations_NeitherCurrentNorPrevEpoch(t *testing.T) {
time.PrevEpoch(beaconState), time.PrevEpoch(beaconState),
time.CurrentEpoch(beaconState), time.CurrentEpoch(beaconState),
) )
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
@@ -108,13 +108,13 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc)) require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
want := "source check point not equal to current justified checkpoint" want := "source check point not equal to current justified checkpoint"
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
b.Block.Body.Attestations[0].Data.Source.Epoch = time.CurrentEpoch(beaconState) b.Block.Body.Attestations[0].Data.Source.Epoch = time.CurrentEpoch(beaconState)
b.Block.Body.Attestations[0].Data.Source.Root = []byte{} b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
@@ -149,14 +149,14 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc)) require.NoError(t, beaconState.SetPreviousJustifiedCheckpoint(pfc))
want := "source check point not equal to previous justified checkpoint" want := "source check point not equal to previous justified checkpoint"
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
b.Block.Body.Attestations[0].Data.Source.Epoch = time.PrevEpoch(beaconState) b.Block.Body.Attestations[0].Data.Source.Epoch = time.PrevEpoch(beaconState)
b.Block.Body.Attestations[0].Data.Target.Epoch = time.PrevEpoch(beaconState) b.Block.Body.Attestations[0].Data.Target.Epoch = time.PrevEpoch(beaconState)
b.Block.Body.Attestations[0].Data.Source.Root = []byte{} b.Block.Body.Attestations[0].Data.Source.Root = []byte{}
wsb, err = wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, want, err) require.ErrorContains(t, want, err)
@@ -188,7 +188,7 @@ func TestProcessAttestations_InvalidAggregationBitsLength(t *testing.T) {
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc)) require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4" expected := "failed to verify aggregation bitfield: wanted participants bitfield length 3, got: 4"
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.ErrorContains(t, expected, err) require.ErrorContains(t, expected, err)
@@ -232,7 +232,7 @@ func TestProcessAttestations_OK(t *testing.T) {
err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay) err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
require.NoError(t, err) require.NoError(t, err)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
_, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb) _, err = altair.ProcessAttestationsNoVerifySignature(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -421,7 +421,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
} }
s, err := stateAltair.InitializeFromProtoUnsafe(state) s, err := stateAltair.InitializeFromProtoUnsafe(state)
require.NoError(t, err) require.NoError(t, err)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb) r, err := altair.ProcessAttestationsNoVerifySignature(context.Background(), s, wsb)
if err != nil && r != nil { if err != nil && r != nil {

12
beacon-chain/core/blocks/block_operations_fuzz_test.go
View File

@@ -42,7 +42,9 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
s, err := v1.InitializeFromProtoUnsafe(state) s, err := v1.InitializeFromProtoUnsafe(state)
require.NoError(t, err) require.NoError(t, err)
_, err = ProcessBlockHeader(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = ProcessBlockHeader(context.Background(), s, wsb)
_ = err _ = err
} }
} }
@@ -141,7 +143,9 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
fuzzer.Fuzz(b) fuzzer.Fuzz(b)
s, err := v1.InitializeFromProtoUnsafe(state) s, err := v1.InitializeFromProtoUnsafe(state)
require.NoError(t, err) require.NoError(t, err)
r, err := ProcessRandao(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
r, err := ProcessRandao(context.Background(), s, wsb)
if err != nil && r != nil { if err != nil && r != nil {
t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b) t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
} }
@@ -260,7 +264,9 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
fuzzer.Fuzz(b) fuzzer.Fuzz(b)
s, err := v1.InitializeFromProtoUnsafe(state) s, err := v1.InitializeFromProtoUnsafe(state)
require.NoError(t, err) require.NoError(t, err)
r, err := ProcessAttestationsNoVerifySignature(ctx, s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
r, err := ProcessAttestationsNoVerifySignature(ctx, s, wsb)
if err != nil && r != nil { if err != nil && r != nil {
t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b) t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, b)
} }

24
beacon-chain/core/blocks/header_test.go
View File

@@ -68,7 +68,9 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx]) err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
require.NoError(t, err) require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err) assert.ErrorContains(t, "block.Slot 10 must be greater than state.LatestBlockHeader.Slot 10", err)
} }
@@ -94,7 +96,9 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
block.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1]) block.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
require.NoError(t, err) require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), beaconState, wsb)
want := "signature did not verify" want := "signature did not verify"
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -136,7 +140,9 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
Signature: blockSig, Signature: blockSig,
}) })
_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
want := "is different than block slot" want := "is different than block slot"
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -175,7 +181,9 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32) block.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, 32)
block.Signature = blockSig block.Signature = blockSig
_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
want := "does not match" want := "does not match"
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -217,7 +225,9 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
block.Block.ParentRoot = parentRoot[:] block.Block.ParentRoot = parentRoot[:]
block.Signature = blockSig block.Signature = blockSig
_, err = blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = blocks.ProcessBlockHeader(context.Background(), state, wsb)
want := "was previously slashed" want := "was previously slashed"
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -266,7 +276,9 @@ func TestProcessBlockHeader_OK(t *testing.T) {
err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx]) err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
require.NoError(t, err) require.NoError(t, err)
newState, err := blocks.ProcessBlockHeader(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
newState, err := blocks.ProcessBlockHeader(context.Background(), state, wsb)
require.NoError(t, err, "Failed to process block header got") require.NoError(t, err, "Failed to process block header got")
var zeroHash [32]byte var zeroHash [32]byte
nsh := newState.LatestBlockHeader() nsh := newState.LatestBlockHeader()

9
beacon-chain/core/blocks/randao_test.go
View File

@@ -40,7 +40,9 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
} }
want := "block randao: signature did not verify" want := "block randao: signature did not verify"
_, err = blocks.ProcessRandao(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = blocks.ProcessRandao(context.Background(), beaconState, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -57,11 +59,12 @@ func TestProcessRandao_SignatureVerifiesAndUpdatesLatestStateMixes(t *testing.T)
RandaoReveal: epochSignature, RandaoReveal: epochSignature,
}, },
} }
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
newState, err := blocks.ProcessRandao( newState, err := blocks.ProcessRandao(
context.Background(), context.Background(),
beaconState, beaconState,
wrapper.WrappedPhase0SignedBeaconBlock(b), wsb,
) )
require.NoError(t, err, "Unexpected error processing block randao") require.NoError(t, err, "Unexpected error processing block randao")
currentEpoch := time.CurrentEpoch(beaconState) currentEpoch := time.CurrentEpoch(beaconState)

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

@@ -83,7 +83,7 @@ func TestVerifyBlockSignatureUsingCurrentFork(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
sig := keys[0].Sign(rt[:]).Marshal() sig := keys[0].Sign(rt[:]).Marshal()
altairBlk.Signature = sig altairBlk.Signature = sig
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(altairBlk) wsb, err := wrapper.WrappedSignedBeaconBlock(altairBlk)
require.NoError(t, err) require.NoError(t, err)
assert.NoError(t, blocks.VerifyBlockSignatureUsingCurrentFork(bState, wsb)) assert.NoError(t, blocks.VerifyBlockSignatureUsingCurrentFork(bState, wsb))
} }

10
beacon-chain/core/transition/altair_transition_no_verify_sig_test.go
View File

@@ -90,7 +90,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
SyncCommitteeSignature: aggregatedSig, SyncCommitteeSignature: aggregatedSig,
} }
block.Block.Body.SyncAggregate = syncAggregate block.Block.Body.SyncAggregate = syncAggregate
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb) stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -101,7 +101,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
wsb, err = wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb) set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -178,7 +178,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
} }
block.Block.Body.SyncAggregate = syncAggregate block.Block.Body.SyncAggregate = syncAggregate
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb) stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -190,7 +190,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32) block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
wsb, err = wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb) _, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.ErrorContains(t, "could not validate state root", err) require.ErrorContains(t, "could not validate state root", err)
@@ -198,7 +198,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
func TestExecuteStateTransitionNoVerifyAnySig_PassesProcessingConditions(t *testing.T) { func TestExecuteStateTransitionNoVerifyAnySig_PassesProcessingConditions(t *testing.T) {
beaconState, block := createFullAltairBlockWithOperations(t) beaconState, block := createFullAltairBlockWithOperations(t)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb) set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)

8
beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go
View File

@@ -92,7 +92,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
SyncCommitteeSignature: aggregatedSig, SyncCommitteeSignature: aggregatedSig,
} }
block.Block.Body.SyncAggregate = syncAggregate block.Block.Body.SyncAggregate = syncAggregate
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb) stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -103,7 +103,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
wsb, err = wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb) set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -180,7 +180,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
} }
block.Block.Body.SyncAggregate = syncAggregate block.Block.Body.SyncAggregate = syncAggregate
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb) stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -192,7 +192,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32) block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
wsb, err = wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb) _, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.ErrorContains(t, "could not validate state root", err) require.ErrorContains(t, "could not validate state root", err)

12
beacon-chain/core/transition/benchmarks_test.go
View File

@@ -29,7 +29,9 @@ func BenchmarkExecuteStateTransition_FullBlock(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(b, err)
_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
require.NoError(b, err) require.NoError(b, err)
} }
} }
@@ -50,12 +52,16 @@ func BenchmarkExecuteStateTransition_WithCache(b *testing.B) {
require.NoError(b, helpers.UpdateCommitteeCache(beaconState, time.CurrentEpoch(beaconState))) require.NoError(b, helpers.UpdateCommitteeCache(beaconState, time.CurrentEpoch(beaconState)))
require.NoError(b, beaconState.SetSlot(currentSlot)) require.NoError(b, beaconState.SetSlot(currentSlot))
// Run the state transition once to populate the cache. // Run the state transition once to populate the cache.
_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(b, err)
_, err = coreState.ExecuteStateTransition(context.Background(), beaconState, wsb)
require.NoError(b, err, "Failed to process block, benchmarks will fail") require.NoError(b, err, "Failed to process block, benchmarks will fail")
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
_, err := coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(b, err)
_, err = coreState.ExecuteStateTransition(context.Background(), cleanStates[i], wsb)
require.NoError(b, err, "Failed to process block, benchmarks will fail") require.NoError(b, err, "Failed to process block, benchmarks will fail")
} }
} }

20
beacon-chain/core/transition/skip_slot_cache_test.go
View File

@@ -32,10 +32,14 @@ func TestSkipSlotCache_OK(t *testing.T) {
// with the state // with the state
blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10) blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
require.NoError(t, err) require.NoError(t, err)
executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wsb)
require.NoError(t, err, "Could not run state transition") require.NoError(t, err, "Could not run state transition")
require.Equal(t, true, executedState.Version() == version.Phase0) require.Equal(t, true, executedState.Version() == version.Phase0)
bState, err = transition.ExecuteStateTransition(context.Background(), bState, wrapper.WrappedPhase0SignedBeaconBlock(blk)) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
bState, err = transition.ExecuteStateTransition(context.Background(), bState, wsb)
require.NoError(t, err, "Could not process state transition") require.NoError(t, err, "Could not process state transition")
assert.DeepEqual(t, originalState.CloneInnerState(), bState.CloneInnerState(), "Skipped slots cache leads to different states") assert.DeepEqual(t, originalState.CloneInnerState(), bState.CloneInnerState(), "Skipped slots cache leads to different states")
@@ -57,7 +61,9 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
// with the state // with the state
blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10) blk, err := util.GenerateFullBlock(bState, privs, blkCfg, originalState.Slot()+10)
require.NoError(t, err) require.NoError(t, err)
executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wrapper.WrappedPhase0SignedBeaconBlock(blk)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
executedState, err := transition.ExecuteStateTransition(context.Background(), originalState, wsb)
require.NoError(t, err, "Could not run state transition") require.NoError(t, err, "Could not run state transition")
require.Equal(t, true, executedState.Version() == version.Phase0) require.Equal(t, true, executedState.Version() == version.Phase0)
@@ -70,7 +76,9 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
signature, err := util.BlockSignature(originalState, blk.Block, privs) signature, err := util.BlockSignature(originalState, blk.Block, privs)
require.NoError(t, err) require.NoError(t, err)
blk.Signature = signature.Marshal() blk.Signature = signature.Marshal()
s1, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wrapper.WrappedPhase0SignedBeaconBlock(blk)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
s1, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wsb)
require.NoError(t, err, "Could not run state transition") require.NoError(t, err, "Could not run state transition")
} }
@@ -81,7 +89,9 @@ func TestSkipSlotCache_ConcurrentMixup(t *testing.T) {
signature, err := util.BlockSignature(originalState, blk.Block, privs) signature, err := util.BlockSignature(originalState, blk.Block, privs)
require.NoError(t, err) require.NoError(t, err)
blk.Signature = signature.Marshal() blk.Signature = signature.Marshal()
s0, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wrapper.WrappedPhase0SignedBeaconBlock(blk)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
s0, err = transition.ExecuteStateTransition(context.Background(), originalState.Copy(), wsb)
require.NoError(t, err, "Could not run state transition") require.NoError(t, err, "Could not run state transition")
} }

20
beacon-chain/core/transition/transition_fuzz_test.go
View File

@@ -25,7 +25,9 @@ func TestFuzzExecuteStateTransition_1000(t *testing.T) {
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
fuzzer.Fuzz(state) fuzzer.Fuzz(state)
fuzzer.Fuzz(sb) fuzzer.Fuzz(sb)
s, err := ExecuteStateTransition(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb)) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err)
s, err := ExecuteStateTransition(ctx, state, wsb)
if err != nil && s != nil { if err != nil && s != nil {
t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and signed block: %v", s, err, state, sb) t.Fatalf("state should be nil on err. found: %v on error: %v for state: %v and signed block: %v", s, err, state, sb)
} }
@@ -44,7 +46,9 @@ func TestFuzzCalculateStateRoot_1000(t *testing.T) {
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
fuzzer.Fuzz(state) fuzzer.Fuzz(state)
fuzzer.Fuzz(sb) fuzzer.Fuzz(sb)
stateRoot, err := CalculateStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb)) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err)
stateRoot, err := CalculateStateRoot(ctx, state, wsb)
if err != nil && stateRoot != [32]byte{} { if err != nil && stateRoot != [32]byte{} {
t.Fatalf("state root should be empty on err. found: %v on error: %v for signed block: %v", stateRoot, err, sb) t.Fatalf("state root should be empty on err. found: %v on error: %v for signed block: %v", stateRoot, err, sb)
} }
@@ -99,7 +103,9 @@ func TestFuzzprocessOperationsNoVerify_1000(t *testing.T) {
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
fuzzer.Fuzz(state) fuzzer.Fuzz(state)
fuzzer.Fuzz(bb) fuzzer.Fuzz(bb)
s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(bb)) wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
require.NoError(t, err)
s, err := ProcessOperationsNoVerifyAttsSigs(ctx, state, wsb)
if err != nil && s != nil { if err != nil && s != nil {
t.Fatalf("state should be nil on err. found: %v on error: %v for block body: %v", s, err, bb) t.Fatalf("state should be nil on err. found: %v on error: %v for block body: %v", s, err, bb)
} }
@@ -117,7 +123,9 @@ func TestFuzzverifyOperationLengths_10000(t *testing.T) {
for i := 0; i < 10000; i++ { for i := 0; i < 10000; i++ {
fuzzer.Fuzz(state) fuzzer.Fuzz(state)
fuzzer.Fuzz(bb) fuzzer.Fuzz(bb)
_, err := VerifyOperationLengths(context.Background(), state, wrapper.WrappedPhase0SignedBeaconBlock(bb)) wsb, err := wrapper.WrappedSignedBeaconBlock(bb)
require.NoError(t, err)
_, err = VerifyOperationLengths(context.Background(), state, wsb)
_ = err _ = err
} }
} }
@@ -164,7 +172,9 @@ func TestFuzzProcessBlockForStateRoot_1000(t *testing.T) {
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
fuzzer.Fuzz(state) fuzzer.Fuzz(state)
fuzzer.Fuzz(sb) fuzzer.Fuzz(sb)
s, err := ProcessBlockForStateRoot(ctx, state, wrapper.WrappedPhase0SignedBeaconBlock(sb)) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err)
s, err := ProcessBlockForStateRoot(ctx, state, wsb)
if err != nil && s != nil { if err != nil && s != nil {
t.Fatalf("state should be nil on err. found: %v on error: %v for signed block: %v", s, err, sb) t.Fatalf("state should be nil on err. found: %v on error: %v for signed block: %v", s, err, sb)
} }

30
beacon-chain/core/transition/transition_no_verify_sig_test.go
View File

@@ -52,7 +52,9 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
block.Block.Body.RandaoReveal = randaoReveal block.Block.Body.RandaoReveal = randaoReveal
block.Block.Body.Eth1Data = eth1Data block.Block.Body.Eth1Data = eth1Data
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
block.Block.StateRoot = stateRoot[:] block.Block.StateRoot = stateRoot[:]
@@ -61,7 +63,9 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
set, _, err := transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
assert.NoError(t, err) assert.NoError(t, err)
verified, err := set.Verify() verified, err := set.Verify()
assert.NoError(t, err) assert.NoError(t, err)
@@ -104,7 +108,9 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
block.Block.Body.RandaoReveal = randaoReveal block.Block.Body.RandaoReveal = randaoReveal
block.Block.Body.Eth1Data = eth1Data block.Block.Body.Eth1Data = eth1Data
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
block.Block.StateRoot = stateRoot[:] block.Block.StateRoot = stateRoot[:]
@@ -114,13 +120,17 @@ func TestExecuteStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t *test
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32) block.Block.StateRoot = bytesutil.PadTo([]byte{'a'}, 32)
_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, _, err = transition.ExecuteStateTransitionNoVerifyAnySig(context.Background(), beaconState, wsb)
require.ErrorContains(t, "could not validate state root", err) require.ErrorContains(t, "could not validate state root", err)
} }
func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) { func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
beaconState, block, _, _, _ := createFullBlockWithOperations(t) beaconState, block, _, _, _ := createFullBlockWithOperations(t)
set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
set, _, err := transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
// Test Signature set verifies. // Test Signature set verifies.
verified, err := set.Verify() verified, err := set.Verify()
@@ -130,7 +140,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) { func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
beaconState, block := createFullAltairBlockWithOperations(t) beaconState, block := createFullAltairBlockWithOperations(t)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot()) beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
require.NoError(t, err) require.NoError(t, err)
@@ -143,7 +153,7 @@ func TestProcessBlockNoVerifyAnySigAltair_OK(t *testing.T) {
func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) { func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
beaconState, block := createFullAltairBlockWithOperations(t) beaconState, block := createFullAltairBlockWithOperations(t)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot()) beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
require.NoError(t, err) require.NoError(t, err)
@@ -153,7 +163,7 @@ func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) { func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
beaconState, block := createFullBellatrixBlockWithOperations(t) beaconState, block := createFullBellatrixBlockWithOperations(t)
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot()) beaconState, err = transition.ProcessSlots(context.Background(), beaconState, wsb.Block().Slot())
require.NoError(t, err) require.NoError(t, err)
@@ -163,7 +173,7 @@ func TestProcessOperationsNoVerifyAttsSigsBellatrix_OK(t *testing.T) {
func TestCalculateStateRootAltair_OK(t *testing.T) { func TestCalculateStateRootAltair_OK(t *testing.T) {
beaconState, block := createFullAltairBlockWithOperations(t) beaconState, block := createFullAltairBlockWithOperations(t)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
r, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb) r, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
@@ -173,7 +183,7 @@ func TestCalculateStateRootAltair_OK(t *testing.T) {
func TestProcessBlockDifferentVersion(t *testing.T) { func TestProcessBlockDifferentVersion(t *testing.T) {
beaconState, _ := util.DeterministicGenesisState(t, 64) // Phase 0 state beaconState, _ := util.DeterministicGenesisState(t, 64) // Phase 0 state
_, block := createFullAltairBlockWithOperations(t) _, block := createFullAltairBlockWithOperations(t)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) // Altair block wsb, err := wrapper.WrappedSignedBeaconBlock(block) // Altair block
require.NoError(t, err) require.NoError(t, err)
_, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb) _, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
require.ErrorContains(t, "state and block are different version. 0 != 1", err) require.ErrorContains(t, "state and block are different version. 0 != 1", err)

36
beacon-chain/core/transition/transition_test.go
View File

@@ -44,7 +44,9 @@ func TestExecuteStateTransition_IncorrectSlot(t *testing.T) {
}, },
} }
want := "expected state.slot" want := "expected state.slot"
_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -87,7 +89,9 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
block.Block.Body.RandaoReveal = randaoReveal block.Block.Body.RandaoReveal = randaoReveal
block.Block.Body.Eth1Data = eth1Data block.Block.Body.Eth1Data = eth1Data
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
stateRoot, err := transition.CalculateStateRoot(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
block.Block.StateRoot = stateRoot[:] block.Block.StateRoot = stateRoot[:]
@@ -96,7 +100,9 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
block.Signature = sig.Marshal() block.Signature = sig.Marshal()
beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
beaconState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, beaconState.Slot(), "Unexpected Slot number") assert.Equal(t, params.BeaconConfig().SlotsPerEpoch, beaconState.Slot(), "Unexpected Slot number")
@@ -183,7 +189,9 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
cp.Root = []byte("hello-world") cp.Root = []byte("hello-world")
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp)) require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cp))
require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{})) require.NoError(t, beaconState.AppendCurrentEpochAttestations(&ethpb.PendingAttestation{}))
_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wrapper.WrappedPhase0SignedBeaconBlock(block)) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), beaconState, wsb)
wanted := "number of voluntary exits (17) in block body exceeds allowed threshold of 16" wanted := "number of voluntary exits (17) in block body exceeds allowed threshold of 16"
assert.ErrorContains(t, wanted, err) assert.ErrorContains(t, wanted, err)
} }
@@ -396,7 +404,9 @@ func TestProcessBlock_OverMaxProposerSlashings(t *testing.T) {
len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings) len(b.Block.Body.ProposerSlashings), params.BeaconConfig().MaxProposerSlashings)
s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{}) s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
require.NoError(t, err) require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -413,7 +423,9 @@ func TestProcessBlock_OverMaxAttesterSlashings(t *testing.T) {
len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings) len(b.Block.Body.AttesterSlashings), params.BeaconConfig().MaxAttesterSlashings)
s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{}) s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
require.NoError(t, err) require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -429,7 +441,9 @@ func TestProcessBlock_OverMaxAttestations(t *testing.T) {
len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations) len(b.Block.Body.Attestations), params.BeaconConfig().MaxAttestations)
s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{}) s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
require.NoError(t, err) require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -446,7 +460,9 @@ func TestProcessBlock_OverMaxVoluntaryExits(t *testing.T) {
len(b.Block.Body.VoluntaryExits), maxExits) len(b.Block.Body.VoluntaryExits), maxExits)
s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{}) s, err := v1.InitializeFromProtoUnsafe(&ethpb.BeaconState{})
require.NoError(t, err) require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }
@@ -466,7 +482,9 @@ func TestProcessBlock_IncorrectDeposits(t *testing.T) {
} }
want := fmt.Sprintf("incorrect outstanding deposits in block body, wanted: %d, got: %d", want := fmt.Sprintf("incorrect outstanding deposits in block body, wanted: %d, got: %d",
s.Eth1Data().DepositCount-s.Eth1DepositIndex(), len(b.Block.Body.Deposits)) s.Eth1Data().DepositCount-s.Eth1DepositIndex(), len(b.Block.Body.Deposits))
_, err = transition.VerifyOperationLengths(context.Background(), s, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
_, err = transition.VerifyOperationLengths(context.Background(), s, wsb)
assert.ErrorContains(t, want, err) assert.ErrorContains(t, want, err)
} }

8
beacon-chain/db/kv/backup_test.go
View File

@@ -21,7 +21,9 @@ func TestStore_Backup(t *testing.T) {
head := util.NewBeaconBlock() head := util.NewBeaconBlock()
head.Block.Slot = 5000 head.Block.Slot = 5000
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head))) wsb, err := wrapper.WrappedSignedBeaconBlock(head)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
root, err := head.Block.HashTreeRoot() root, err := head.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -61,7 +63,9 @@ func TestStore_BackupMultipleBuckets(t *testing.T) {
for i := startSlot; i < 5200; i++ { for i := startSlot; i < 5200; i++ {
head := util.NewBeaconBlock() head := util.NewBeaconBlock()
head.Block.Slot = i head.Block.Slot = i
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head))) wsb, err := wrapper.WrappedSignedBeaconBlock(head)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
root, err := head.Block.HashTreeRoot() root, err := head.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()

21
beacon-chain/db/kv/blocks.go
View File

@@ -6,6 +6,7 @@ import (
"fmt" "fmt"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
ssz "github.com/ferranbt/fastssz"
"github.com/golang/snappy" "github.com/golang/snappy"
"github.com/pkg/errors" "github.com/pkg/errors"
types "github.com/prysmaticlabs/eth2-types" types "github.com/prysmaticlabs/eth2-types"
@@ -641,31 +642,27 @@ func unmarshalBlock(_ context.Context, enc []byte) (block.SignedBeaconBlock, err
if err != nil { if err != nil {
return nil, err return nil, err
} }
var rawBlock ssz.Unmarshaler
switch { switch {
case hasAltairKey(enc): case hasAltairKey(enc):
// Marshal block bytes to altair beacon block. // Marshal block bytes to altair beacon block.
rawBlock := &ethpb.SignedBeaconBlockAltair{} rawBlock = &ethpb.SignedBeaconBlockAltair{}
err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]) if err := rawBlock.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
if err != nil {
return nil, err return nil, err
} }
return wrapper.WrappedAltairSignedBeaconBlock(rawBlock)
case hasBellatrixKey(enc): case hasBellatrixKey(enc):
rawBlock := &ethpb.SignedBeaconBlockBellatrix{} rawBlock = &ethpb.SignedBeaconBlockBellatrix{}
err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]) if err := rawBlock.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
if err != nil {
return nil, err return nil, err
} }
return wrapper.WrappedBellatrixSignedBeaconBlock(rawBlock)
default: default:
// Marshal block bytes to phase 0 beacon block. // Marshal block bytes to phase 0 beacon block.
rawBlock := &ethpb.SignedBeaconBlock{} rawBlock = &ethpb.SignedBeaconBlock{}
err = rawBlock.UnmarshalSSZ(enc) if err := rawBlock.UnmarshalSSZ(enc); err != nil {
if err != nil {
return nil, err return nil, err
} }
return wrapper.WrappedPhase0SignedBeaconBlock(rawBlock), nil
} }
return wrapper.WrappedSignedBeaconBlock(rawBlock)
} }
// marshal versioned beacon block from struct type down to bytes. // marshal versioned beacon block from struct type down to bytes.

10
beacon-chain/db/kv/blocks_test.go
View File

@@ -31,7 +31,7 @@ var blockTests = []struct {
if root != nil { if root != nil {
b.Block.ParentRoot = root b.Block.ParentRoot = root
} }
return wrapper.WrappedPhase0SignedBeaconBlock(b), nil return wrapper.WrappedSignedBeaconBlock(b)
}, },
}, },
{ {
@@ -42,7 +42,7 @@ var blockTests = []struct {
if root != nil { if root != nil {
b.Block.ParentRoot = root b.Block.ParentRoot = root
} }
return wrapper.WrappedAltairSignedBeaconBlock(b) return wrapper.WrappedSignedBeaconBlock(b)
}, },
}, },
{ {
@@ -53,7 +53,7 @@ var blockTests = []struct {
if root != nil { if root != nil {
b.Block.ParentRoot = root b.Block.ParentRoot = root
} }
return wrapper.WrappedBellatrixSignedBeaconBlock(b) return wrapper.WrappedSignedBeaconBlock(b)
}, },
}, },
} }
@@ -212,7 +212,9 @@ func TestStore_GenesisBlock(t *testing.T) {
blockRoot, err := genesisBlock.Block.HashTreeRoot() blockRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, blockRoot))
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
retrievedBlock, err := db.GenesisBlock(ctx) retrievedBlock, err := db.GenesisBlock(ctx)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlock.Proto()), "Wanted: %v, received: %v", genesisBlock, retrievedBlock) assert.Equal(t, true, proto.Equal(genesisBlock, retrievedBlock.Proto()), "Wanted: %v, received: %v", genesisBlock, retrievedBlock)

4
beacon-chain/db/kv/checkpoint_test.go
View File

@@ -53,7 +53,9 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
} }
// a valid chain is required to save finalized checkpoint. // a valid chain is required to save finalized checkpoint.
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))

9
beacon-chain/db/kv/finalized_block_roots_test.go
View File

@@ -63,7 +63,9 @@ func TestStore_IsFinalizedBlockGenesis(t *testing.T) {
blk.Block.Slot = 0 blk.Block.Slot = 0
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
assert.Equal(t, true, db.IsFinalizedBlock(ctx, root), "Finalized genesis block doesn't exist in db") assert.Equal(t, true, db.IsFinalizedBlock(ctx, root), "Finalized genesis block doesn't exist in db")
} }
@@ -207,7 +209,8 @@ func makeBlocks(t *testing.T, i, n uint64, previousRoot [32]byte) []block.Signed
var err error var err error
previousRoot, err = blocks[j-i].Block.HashTreeRoot() previousRoot, err = blocks[j-i].Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
ifaceBlocks[j-i] = wrapper.WrappedPhase0SignedBeaconBlock(blocks[j-i]) ifaceBlocks[j-i], err = wrapper.WrappedSignedBeaconBlock(blocks[j-i])
require.NoError(t, err)
} }
return ifaceBlocks return ifaceBlocks
} }
@@ -224,7 +227,7 @@ func makeBlocksAltair(t *testing.T, startIdx, num uint64, previousRoot [32]byte)
var err error var err error
previousRoot, err = blocks[j-startIdx].Block.HashTreeRoot() previousRoot, err = blocks[j-startIdx].Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
ifaceBlocks[j-startIdx], err = wrapper.WrappedAltairSignedBeaconBlock(blocks[j-startIdx]) ifaceBlocks[j-startIdx], err = wrapper.WrappedSignedBeaconBlock(blocks[j-startIdx])
require.NoError(t, err) require.NoError(t, err)
} }
return ifaceBlocks return ifaceBlocks

6
beacon-chain/db/kv/genesis.go
View File

@@ -28,7 +28,11 @@ func (s *Store) SaveGenesisData(ctx context.Context, genesisState state.BeaconSt
if err != nil { if err != nil {
return errors.Wrap(err, "could not get genesis block root") return errors.Wrap(err, "could not get genesis block root")
} }
if err := s.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
if err != nil {
return errors.Wrap(err, "could not wrap genesis block")
}
if err := s.SaveBlock(ctx, wsb); err != nil {
return errors.Wrap(err, "could not save genesis block") return errors.Wrap(err, "could not save genesis block")
} }
if err := s.SaveState(ctx, genesisState, genesisBlkRoot); err != nil { if err := s.SaveState(ctx, genesisState, genesisBlkRoot); err != nil {

6
beacon-chain/db/kv/state.go
View File

@@ -638,7 +638,11 @@ func (s *Store) slotByBlockRoot(ctx context.Context, tx *bolt.Tx, blockRoot []by
if err != nil { if err != nil {
return 0, err return 0, err
} }
if err := helpers.BeaconBlockIsNil(wrapper.WrappedPhase0SignedBeaconBlock(b)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(b)
if err != nil {
return 0, err
}
if err := helpers.BeaconBlockIsNil(wsb); err != nil {
return 0, err return 0, err
} }
return b.Block.Slot, nil return b.Block.Slot, nil

40
beacon-chain/db/kv/state_test.go
View File

@@ -374,7 +374,9 @@ func TestStore_StatesBatchDelete(t *testing.T) {
for i := 0; i < len(totalBlocks); i++ { for i := 0; i < len(totalBlocks); i++ {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = types.Slot(i) b.Block.Slot = types.Slot(i)
totalBlocks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) var err error
totalBlocks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
r, err := totalBlocks[i].Block().HashTreeRoot() r, err := totalBlocks[i].Block().HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -425,7 +427,9 @@ func TestStore_DeleteFinalizedState(t *testing.T) {
blk.Block.ParentRoot = genesis[:] blk.Block.ParentRoot = genesis[:]
blk.Block.Slot = 100 blk.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
finalizedBlockRoot, err := blk.Block.HashTreeRoot() finalizedBlockRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -450,7 +454,9 @@ func TestStore_DeleteHeadState(t *testing.T) {
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.ParentRoot = genesis[:] blk.Block.ParentRoot = genesis[:]
blk.Block.Slot = 100 blk.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
headBlockRoot, err := blk.Block.HashTreeRoot() headBlockRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -470,7 +476,9 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
b.Block.Slot = 1 b.Block.Slot = 1
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))
@@ -480,7 +488,9 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
b.Block.Slot = 100 b.Block.Slot = 100
r1, err := b.Block.HashTreeRoot() r1, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
st, err = util.NewBeaconState() st, err = util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(100)) require.NoError(t, st.SetSlot(100))
@@ -490,7 +500,9 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
b.Block.Slot = 1000 b.Block.Slot = 1000
r2, err := b.Block.HashTreeRoot() r2, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
st, err = util.NewBeaconState() st, err = util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1000)) require.NoError(t, st.SetSlot(1000))
@@ -524,7 +536,9 @@ func TestStore_GenesisState_CanGetHighestBelow(t *testing.T) {
b.Block.Slot = 1 b.Block.Slot = 1
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
@@ -561,7 +575,9 @@ func TestStore_CleanUpDirtyStates_AboveThreshold(t *testing.T) {
b.Block.ParentRoot = prevRoot[:] b.Block.ParentRoot = prevRoot[:]
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
bRoots = append(bRoots, r) bRoots = append(bRoots, r)
prevRoot = r prevRoot = r
@@ -600,7 +616,9 @@ func TestStore_CleanUpDirtyStates_Finalized(t *testing.T) {
b.Block.Slot = i b.Block.Slot = i
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
@@ -628,7 +646,9 @@ func TestStore_CleanUpDirtyStates_DontDeleteNonFinalized(t *testing.T) {
b.Block.Slot = i b.Block.Slot = i
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
unfinalizedRoots = append(unfinalizedRoots, r) unfinalizedRoots = append(unfinalizedRoots, r)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()

4
beacon-chain/db/kv/validated_checkpoint_test.go
View File

@@ -52,7 +52,9 @@ func TestStore_LastValidatedCheckpoint_DefaultIsFinalized(t *testing.T) {
} }
// a valid chain is required to save finalized checkpoint. // a valid chain is required to save finalized checkpoint.
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))

4
beacon-chain/db/restore_test.go
View File

@@ -27,7 +27,9 @@ func TestRestore(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
head := util.NewBeaconBlock() head := util.NewBeaconBlock()
head.Block.Slot = 5000 head.Block.Slot = 5000
require.NoError(t, backupDb.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(head))) wsb, err := wrapper.WrappedSignedBeaconBlock(head)
require.NoError(t, err)
require.NoError(t, backupDb.SaveBlock(ctx, wsb))
root, err := head.Block.HashTreeRoot() root, err := head.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()

2
beacon-chain/monitor/process_block_test.go
View File

@@ -223,7 +223,7 @@ func TestProcessBlock_AllEventsTrackedVals(t *testing.T) {
wanted2 := fmt.Sprintf("\"Proposer slashing was included\" BodyRoot1=0x000100000000 BodyRoot2=0x000200000000 ProposerIndex=%d SlashingSlot=0 Slot=1 prefix=monitor", idx) wanted2 := fmt.Sprintf("\"Proposer slashing was included\" BodyRoot1=0x000100000000 BodyRoot2=0x000200000000 ProposerIndex=%d SlashingSlot=0 Slot=1 prefix=monitor", idx)
wanted3 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=3 ExpectedContribCount=3 NewBalance=32000000000 ValidatorIndex=1 prefix=monitor" wanted3 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=3 ExpectedContribCount=3 NewBalance=32000000000 ValidatorIndex=1 prefix=monitor"
wanted4 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=1 ExpectedContribCount=1 NewBalance=32000000000 ValidatorIndex=2 prefix=monitor" wanted4 := "\"Sync committee contribution included\" BalanceChange=0 ContribCount=1 ExpectedContribCount=1 NewBalance=32000000000 ValidatorIndex=2 prefix=monitor"
wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(b) wrapped, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
s.processBlock(ctx, wrapped) s.processBlock(ctx, wrapped)
require.LogsContain(t, hook, wanted1) require.LogsContain(t, hook, wanted1)

2
beacon-chain/monitor/service_test.go
View File

@@ -244,7 +244,7 @@ func TestMonitorRoutine(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, s.config.StateGen.SaveState(ctx, root, genesis)) require.NoError(t, s.config.StateGen.SaveState(ctx, root, genesis))
wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(block) wrapped, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
stateChannel <- &feed.Event{ stateChannel <- &feed.Event{

6
beacon-chain/p2p/types/object_mapping.go
View File

@@ -33,13 +33,13 @@ func InitializeDataMaps() {
// Reset our block map. // Reset our block map.
BlockMap = map[[4]byte]func() (block.SignedBeaconBlock, error){ BlockMap = map[[4]byte]func() (block.SignedBeaconBlock, error){
bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (block.SignedBeaconBlock, error) { bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (block.SignedBeaconBlock, error) {
return wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{}), nil return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
}, },
bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (block.SignedBeaconBlock, error) { bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (block.SignedBeaconBlock, error) {
return wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}) return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
}, },
bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (block.SignedBeaconBlock, error) { bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (block.SignedBeaconBlock, error) {
return wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}}) return wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
}, },
} }

167
beacon-chain/rpc/eth/beacon/blocks_test.go
View File

@@ -28,7 +28,9 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (
genBlk.Block.ParentRoot = parentRoot[:] genBlk.Block.ParentRoot = parentRoot[:]
root, err := genBlk.Block.HashTreeRoot() root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
count := types.Slot(100) count := types.Slot(100)
@@ -47,7 +49,8 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (
b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2} b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
blkContainers[i] = &ethpbalpha.BeaconBlockContainer{ blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
Block: &ethpbalpha.BeaconBlockContainer_Phase0Block{Phase0Block: b}, Block: &ethpbalpha.BeaconBlockContainer_Phase0Block{Phase0Block: b},
BlockRoot: root[:], BlockRoot: root[:],
@@ -70,7 +73,7 @@ func fillDBTestBlocksAltair(ctx context.Context, t *testing.T, beaconDB db.Datab
genBlk.Block.ParentRoot = parentRoot[:] genBlk.Block.ParentRoot = parentRoot[:]
root, err := genBlk.Block.HashTreeRoot() root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(genBlk) signedBlk, err := wrapper.WrappedSignedBeaconBlock(genBlk)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
@@ -91,7 +94,7 @@ func fillDBTestBlocksAltair(ctx context.Context, t *testing.T, beaconDB db.Datab
b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2} b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
signedB, err := wrapper.WrappedAltairSignedBeaconBlock(b) signedB, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
blks[i] = signedB blks[i] = signedB
blkContainers[i] = &ethpbalpha.BeaconBlockContainer{ blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
@@ -114,7 +117,7 @@ func fillDBTestBlocksBellatrix(ctx context.Context, t *testing.T, beaconDB db.Da
genBlk.Block.ParentRoot = parentRoot[:] genBlk.Block.ParentRoot = parentRoot[:]
root, err := genBlk.Block.HashTreeRoot() root, err := genBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(genBlk) signedBlk, err := wrapper.WrappedSignedBeaconBlock(genBlk)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, root))
@@ -135,7 +138,7 @@ func fillDBTestBlocksBellatrix(ctx context.Context, t *testing.T, beaconDB db.Da
b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2} b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
signedB, err := wrapper.WrappedBellatrixSignedBeaconBlock(b) signedB, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
blks[i] = signedB blks[i] = signedB
blkContainers[i] = &ethpbalpha.BeaconBlockContainer{ blkContainers[i] = &ethpbalpha.BeaconBlockContainer{
@@ -164,15 +167,21 @@ func TestServer_GetBlockHeader(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
} }
@@ -267,9 +276,11 @@ func TestServer_GetBlockHeader(t *testing.T) {
} }
t.Run("execution optimistic", func(t *testing.T) { t.Run("execution optimistic", func(t *testing.T) {
wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
Optimistic: true, Optimistic: true,
@@ -291,9 +302,11 @@ func TestServer_ListBlockHeaders(t *testing.T) {
_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) _, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1] headBlock := blkContainers[len(blkContainers)-1]
wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainFetcher := &mock.ChainService{ mockChainFetcher := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
} }
@@ -306,19 +319,27 @@ func TestServer_ListBlockHeaders(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b4 := util.NewBeaconBlock() b4 := util.NewBeaconBlock()
b4.Block.Slot = 31 b4.Block.Slot = 31
b4.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b4.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b4))) wsb, err = wrapper.WrappedSignedBeaconBlock(b4)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b5 := util.NewBeaconBlock() b5 := util.NewBeaconBlock()
b5.Block.Slot = 28 b5.Block.Slot = 28
b5.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b5.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b5))) wsb, err = wrapper.WrappedSignedBeaconBlock(b5)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
tests := []struct { tests := []struct {
name string name string
@@ -384,9 +405,11 @@ func TestServer_ListBlockHeaders(t *testing.T) {
} }
t.Run("execution optimistic", func(t *testing.T) { t.Run("execution optimistic", func(t *testing.T) {
wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainFetcher := &mock.ChainService{ mockChainFetcher := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
Optimistic: true, Optimistic: true,
@@ -411,7 +434,9 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
ctx := context.Background() ctx := context.Background()
genesis := util.NewBeaconBlock() genesis := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb), "Could not save genesis block")
numDeposits := uint64(64) numDeposits := uint64(64)
beaconState, _ := util.DeterministicGenesisState(t, numDeposits) beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
@@ -435,7 +460,9 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
req.Block.ParentRoot = bsRoot[:] req.Block.ParentRoot = bsRoot[:]
v1Block, err := migration.V1Alpha1ToV1SignedBlock(req) v1Block, err := migration.V1Alpha1ToV1SignedBlock(req)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(req))) wsb, err = wrapper.WrappedSignedBeaconBlock(req)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
blockReq := &ethpbv2.SignedBeaconBlockContainerV2{ blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
Message: &ethpbv2.SignedBeaconBlockContainerV2_Phase0Block{Phase0Block: v1Block.Block}, Message: &ethpbv2.SignedBeaconBlockContainerV2_Phase0Block{Phase0Block: v1Block.Block},
Signature: v1Block.Signature, Signature: v1Block.Signature,
@@ -449,7 +476,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
ctx := context.Background() ctx := context.Background()
genesis := util.NewBeaconBlockAltair() genesis := util.NewBeaconBlockAltair()
wrapped, err := wrapper.WrappedAltairSignedBeaconBlock(genesis) wrapped, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block") require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block")
@@ -475,7 +502,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
req.Block.ParentRoot = bsRoot[:] req.Block.ParentRoot = bsRoot[:]
v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block) v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block)
require.NoError(t, err) require.NoError(t, err)
wrapped, err = wrapper.WrappedAltairSignedBeaconBlock(req) wrapped, err = wrapper.WrappedSignedBeaconBlock(req)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapped)) require.NoError(t, beaconDB.SaveBlock(ctx, wrapped))
blockReq := &ethpbv2.SignedBeaconBlockContainerV2{ blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
@@ -491,7 +518,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
ctx := context.Background() ctx := context.Background()
genesis := util.NewBeaconBlockBellatrix() genesis := util.NewBeaconBlockBellatrix()
wrapped, err := wrapper.WrappedBellatrixSignedBeaconBlock(genesis) wrapped, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block") require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapped), "Could not save genesis block")
@@ -517,7 +544,7 @@ func TestServer_ProposeBlock_OK(t *testing.T) {
req.Block.ParentRoot = bsRoot[:] req.Block.ParentRoot = bsRoot[:]
v2Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(req.Block) v2Block, err := migration.V1Alpha1BeaconBlockBellatrixToV2(req.Block)
require.NoError(t, err) require.NoError(t, err)
wrapped, err = wrapper.WrappedBellatrixSignedBeaconBlock(req) wrapped, err = wrapper.WrappedSignedBeaconBlock(req)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapped)) require.NoError(t, beaconDB.SaveBlock(ctx, wrapped))
blockReq := &ethpbv2.SignedBeaconBlockContainerV2{ blockReq := &ethpbv2.SignedBeaconBlockContainerV2{
@@ -539,17 +566,23 @@ func TestServer_GetBlock(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: beaconDB, BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{ ChainInfoFetcher: &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
}, },
@@ -648,15 +681,22 @@ func TestServer_GetBlockV2(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
} }
@@ -761,17 +801,17 @@ func TestServer_GetBlockV2(t *testing.T) {
b2 := util.NewBeaconBlockAltair() b2 := util.NewBeaconBlockAltair()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b2) signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
b3 := util.NewBeaconBlockAltair() b3 := util.NewBeaconBlockAltair()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
signedBlk, err = wrapper.WrappedAltairSignedBeaconBlock(b2) signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
chainBlk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.GetAltairBlock()) chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetAltairBlock())
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
@@ -880,17 +920,17 @@ func TestServer_GetBlockV2(t *testing.T) {
b2 := util.NewBeaconBlockBellatrix() b2 := util.NewBeaconBlockBellatrix()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2) signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
b3 := util.NewBeaconBlockBellatrix() b3 := util.NewBeaconBlockBellatrix()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
signedBlk, err = wrapper.WrappedBellatrixSignedBeaconBlock(b2) signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock()) chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
@@ -999,17 +1039,17 @@ func TestServer_GetBlockV2(t *testing.T) {
b2 := util.NewBeaconBlockBellatrix() b2 := util.NewBeaconBlockBellatrix()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2) signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
b3 := util.NewBeaconBlockBellatrix() b3 := util.NewBeaconBlockBellatrix()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
signedBlk, err = wrapper.WrappedBellatrixSignedBeaconBlock(b2) signedBlk, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock()) chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
@@ -1042,13 +1082,18 @@ func TestServer_GetBlockSSZ(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: beaconDB, BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{ ChainInfoFetcher: &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
}, },
@@ -1077,13 +1122,18 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: beaconDB, BeaconDB: beaconDB,
ChainInfoFetcher: &mock.ChainService{ ChainInfoFetcher: &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
}, },
@@ -1112,11 +1162,11 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
b2 := util.NewBeaconBlockAltair() b2 := util.NewBeaconBlockAltair()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
signedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b2) signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
chainBlk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.GetAltairBlock()) chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetAltairBlock())
require.NoError(t, err) require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: beaconDB, BeaconDB: beaconDB,
@@ -1151,11 +1201,11 @@ func TestServer_GetBlockSSZV2(t *testing.T) {
b2 := util.NewBeaconBlockBellatrix() b2 := util.NewBeaconBlockBellatrix()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
signedBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(b2) signedBlk, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk)) require.NoError(t, beaconDB.SaveBlock(ctx, signedBlk))
chainBlk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.GetBellatrixBlock()) chainBlk, err := wrapper.WrappedSignedBeaconBlock(headBlock.GetBellatrixBlock())
require.NoError(t, err) require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: beaconDB, BeaconDB: beaconDB,
@@ -1190,15 +1240,22 @@ func TestServer_GetBlockRoot(t *testing.T) {
b2 := util.NewBeaconBlock() b2 := util.NewBeaconBlock()
b2.Block.Slot = 30 b2.Block.Slot = 30
b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32) b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err := wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 30 b3.Block.Slot = 30
b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32) b3.Block.ParentRoot = bytesutil.PadTo([]byte{4}, 32)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainFetcher := &mock.ChainService{ mockChainFetcher := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
} }
@@ -1283,9 +1340,11 @@ func TestServer_GetBlockRoot(t *testing.T) {
} }
t.Run("execution optimistic", func(t *testing.T) { t.Run("execution optimistic", func(t *testing.T) {
wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainFetcher := &mock.ChainService{ mockChainFetcher := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
Optimistic: true, Optimistic: true,
@@ -1310,9 +1369,11 @@ func TestServer_ListBlockAttestations(t *testing.T) {
_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB) _, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1] headBlock := blkContainers[len(blkContainers)-1]
wsb, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
Block: wrapper.WrappedPhase0SignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block), Block: wsb,
Root: headBlock.BlockRoot, Root: headBlock.BlockRoot,
FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot}, FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
} }
@@ -1410,7 +1471,7 @@ func TestServer_ListBlockAttestations(t *testing.T) {
_, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB) _, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1] headBlock := blkContainers[len(blkContainers)-1]
blk, err := wrapper.WrappedAltairSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock) blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_AltairBlock).AltairBlock)
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
@@ -1512,7 +1573,7 @@ func TestServer_ListBlockAttestations(t *testing.T) {
_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB) _, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1] headBlock := blkContainers[len(blkContainers)-1]
blk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock) blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,
@@ -1614,7 +1675,7 @@ func TestServer_ListBlockAttestations(t *testing.T) {
_, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB) _, blkContainers := fillDBTestBlocksBellatrix(ctx, t, beaconDB)
headBlock := blkContainers[len(blkContainers)-1] headBlock := blkContainers[len(blkContainers)-1]
blk, err := wrapper.WrappedBellatrixSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock) blk, err := wrapper.WrappedSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_BellatrixBlock).BellatrixBlock)
require.NoError(t, err) require.NoError(t, err)
mockChainService := &mock.ChainService{ mockChainService := &mock.ChainService{
DB: beaconDB, DB: beaconDB,

12
beacon-chain/rpc/eth/beacon/state_test.go
View File

@@ -102,7 +102,9 @@ func TestGetStateRoot(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
server := &Server{ server := &Server{
@@ -160,7 +162,9 @@ func TestGetStateFork(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
server := &Server{ server := &Server{
@@ -226,7 +230,9 @@ func TestGetFinalityCheckpoints(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
server := &Server{ server := &Server{

4
beacon-chain/rpc/eth/beacon/sync_committee_test.go
View File

@@ -200,7 +200,9 @@ func TestListSyncCommittees(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
s := &Server{ s := &Server{

16
beacon-chain/rpc/eth/beacon/validator_test.go
View File

@@ -88,7 +88,9 @@ func TestGetValidator(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
s := Server{ s := Server{
@@ -254,7 +256,9 @@ func TestListValidators(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
s := Server{ s := Server{
@@ -604,7 +608,9 @@ func TestListValidatorBalances(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
s := Server{ s := Server{
@@ -753,7 +759,9 @@ func TestListCommittees(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
s := Server{ s := Server{

4
beacon-chain/rpc/eth/debug/debug_test.go
View File

@@ -92,7 +92,9 @@ func TestGetBeaconStateV2(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
fakeState, _ := util.DeterministicGenesisStateBellatrix(t, 1) fakeState, _ := util.DeterministicGenesisStateBellatrix(t, 1)

5
beacon-chain/rpc/eth/events/events_test.go
View File

@@ -66,7 +66,8 @@ func TestStreamEvents_BlockEvents(t *testing.T) {
Event: BlockTopic, Event: BlockTopic,
Data: genericResponse, Data: genericResponse,
} }
wsb, err := wrapper.WrappedSignedBeaconBlock(wantedBlock)
require.NoError(t, err)
assertFeedSendAndReceive(ctx, &assertFeedArgs{ assertFeedSendAndReceive(ctx, &assertFeedArgs{
t: t, t: t,
srv: srv, srv: srv,
@@ -76,7 +77,7 @@ func TestStreamEvents_BlockEvents(t *testing.T) {
itemToSend: &feed.Event{ itemToSend: &feed.Event{
Type: blockfeed.ReceivedBlock, Type: blockfeed.ReceivedBlock,
Data: &blockfeed.ReceivedBlockData{ Data: &blockfeed.ReceivedBlockData{
SignedBlock: wrapper.WrappedPhase0SignedBeaconBlock(wantedBlock), SignedBlock: wsb,
IsOptimistic: true, IsOptimistic: true,
}, },
}, },

24
beacon-chain/rpc/eth/validator/validator_test.go
View File

@@ -222,7 +222,9 @@ func TestGetAttesterDuties(t *testing.T) {
blk.Block.Slot = 31 blk.Block.Slot = 31
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
chainSlot := types.Slot(0) chainSlot := types.Slot(0)
@@ -375,7 +377,9 @@ func TestGetProposerDuties(t *testing.T) {
blk.Block.Slot = 31 blk.Block.Slot = 31
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
chainSlot := types.Slot(0) chainSlot := types.Slot(0)
@@ -596,7 +600,9 @@ func TestGetSyncCommitteeDuties(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
mockChainService := &mockChain.ChainService{Genesis: genesisTime, Optimistic: true} mockChainService := &mockChain.ChainService{Genesis: genesisTime, Optimistic: true}
@@ -652,7 +658,9 @@ func TestProduceBlock(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := blocks.NewGenesisBlock(stateRoot[:]) genesis := blocks.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root") require.NoError(t, err, "Could not get signing root")
@@ -754,7 +762,9 @@ func TestProduceBlockV2(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := blocks.NewGenesisBlock(stateRoot[:]) genesis := blocks.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root") require.NoError(t, err, "Could not get signing root")
@@ -857,7 +867,7 @@ func TestProduceBlockV2(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesisBlock := util.NewBeaconBlockAltair() genesisBlock := util.NewBeaconBlockAltair()
genesisBlock.Block.StateRoot = stateRoot[:] genesisBlock.Block.StateRoot = stateRoot[:]
wrappedAltairBlock, err := wrapper.WrappedAltairSignedBeaconBlock(genesisBlock) wrappedAltairBlock, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrappedAltairBlock)) require.NoError(t, db.SaveBlock(ctx, wrappedAltairBlock))
parentRoot, err := genesisBlock.Block.HashTreeRoot() parentRoot, err := genesisBlock.Block.HashTreeRoot()
@@ -1000,7 +1010,7 @@ func TestProduceBlockV2(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesisBlock := util.NewBeaconBlockBellatrix() genesisBlock := util.NewBeaconBlockBellatrix()
genesisBlock.Block.StateRoot = stateRoot[:] genesisBlock.Block.StateRoot = stateRoot[:]
wrappedBellatrixBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(genesisBlock) wrappedBellatrixBlock, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrappedBellatrixBlock)) require.NoError(t, db.SaveBlock(ctx, wrappedBellatrixBlock))
parentRoot, err := genesisBlock.Block.HashTreeRoot() parentRoot, err := genesisBlock.Block.HashTreeRoot()

4
beacon-chain/rpc/prysm/v1alpha1/beacon/assignments_test.go
View File

@@ -52,7 +52,9 @@ func TestServer_ListAssignments_NoResults(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))

148
beacon-chain/rpc/prysm/v1alpha1/beacon/attestations_test.go
View File

@@ -95,7 +95,9 @@ func TestServer_ListAttestations_Genesis(t *testing.T) {
signedBlock.Block.Body.Attestations = []*ethpb.Attestation{att} signedBlock.Block.Body.Attestations = []*ethpb.Attestation{att}
root, err := signedBlock.Block.HashTreeRoot() root, err := signedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(signedBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(signedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
wanted := &ethpb.ListAttestationsResponse{ wanted := &ethpb.ListAttestationsResponse{
Attestations: []*ethpb.Attestation{att}, Attestations: []*ethpb.Attestation{att},
@@ -132,7 +134,9 @@ func TestServer_ListAttestations_NoPagination(t *testing.T) {
AggregationBits: bitfield.Bitlist{0b11}, AggregationBits: bitfield.Bitlist{0b11},
}, },
} }
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} }
@@ -159,38 +163,11 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
targetRoot := [32]byte{7, 8, 9} targetRoot := [32]byte{7, 8, 9}
targetEpoch := types.Epoch(7) targetEpoch := types.Epoch(7)
blocks := []block.SignedBeaconBlock{ unwrappedBlocks := []*ethpb.SignedBeaconBlock{
wrapper.WrappedPhase0SignedBeaconBlock( util.HydrateSignedBeaconBlock(
util.HydrateSignedBeaconBlock( &ethpb.SignedBeaconBlock{
&ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: 4,
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
BeaconBlockRoot: someRoot[:],
Source: &ethpb.Checkpoint{
Root: sourceRoot[:],
Epoch: sourceEpoch,
},
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
Epoch: targetEpoch,
},
Slot: 3,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength),
},
},
},
},
})),
wrapper.WrappedPhase0SignedBeaconBlock(
util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{ Block: &ethpb.BeaconBlock{
Slot: 5 + params.BeaconConfig().SlotsPerEpoch, Slot: 4,
Body: &ethpb.BeaconBlockBody{ Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{ Attestations: []*ethpb.Attestation{
{ {
@@ -204,7 +181,7 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
Root: targetRoot[:], Root: targetRoot[:],
Epoch: targetEpoch, Epoch: targetEpoch,
}, },
Slot: 4 + params.BeaconConfig().SlotsPerEpoch, Slot: 3,
}, },
AggregationBits: bitfield.Bitlist{0b11}, AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength), Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength),
@@ -212,34 +189,65 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
}, },
}, },
}, },
})), }),
wrapper.WrappedPhase0SignedBeaconBlock( util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{
util.HydrateSignedBeaconBlock( Block: &ethpb.BeaconBlock{
&ethpb.SignedBeaconBlock{ Slot: 5 + params.BeaconConfig().SlotsPerEpoch,
Block: &ethpb.BeaconBlock{ Body: &ethpb.BeaconBlockBody{
Slot: 5, Attestations: []*ethpb.Attestation{
Body: &ethpb.BeaconBlockBody{ {
Attestations: []*ethpb.Attestation{ Data: &ethpb.AttestationData{
{ BeaconBlockRoot: someRoot[:],
Data: &ethpb.AttestationData{ Source: &ethpb.Checkpoint{
BeaconBlockRoot: someRoot[:], Root: sourceRoot[:],
Source: &ethpb.Checkpoint{ Epoch: sourceEpoch,
Root: sourceRoot[:],
Epoch: sourceEpoch,
},
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
Epoch: targetEpoch,
},
Slot: 4,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength),
}, },
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
Epoch: targetEpoch,
},
Slot: 4 + params.BeaconConfig().SlotsPerEpoch,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength),
},
},
},
},
}),
util.HydrateSignedBeaconBlock(
&ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: 5,
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
BeaconBlockRoot: someRoot[:],
Source: &ethpb.Checkpoint{
Root: sourceRoot[:],
Epoch: sourceEpoch,
},
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
Epoch: targetEpoch,
},
Slot: 4,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), fieldparams.BLSSignatureLength),
}, },
}, },
}, },
})), },
}),
}
var blocks []block.SignedBeaconBlock
for _, b := range unwrappedBlocks {
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
blocks = append(blocks, wsb)
} }
require.NoError(t, db.SaveBlocks(ctx, blocks)) require.NoError(t, db.SaveBlocks(ctx, blocks))
@@ -279,7 +287,9 @@ func TestServer_ListAttestations_Pagination_CustomPageParameters(t *testing.T) {
AggregationBits: bitfield.Bitlist{0b11}, AggregationBits: bitfield.Bitlist{0b11},
}), }),
} }
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} }
} }
@@ -388,7 +398,9 @@ func TestServer_ListAttestations_Pagination_OutOfRange(t *testing.T) {
}, },
}, },
}) })
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} }
@@ -439,7 +451,9 @@ func TestServer_ListAttestations_Pagination_DefaultPageSize(t *testing.T) {
AggregationBits: bitfield.Bitlist{0b11}, AggregationBits: bitfield.Bitlist{0b11},
}, },
} }
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} }
@@ -529,7 +543,9 @@ func TestServer_ListIndexedAttestations_GenesisEpoch(t *testing.T) {
AggregationBits: bitfield.NewBitlist(128 / uint64(params.BeaconConfig().SlotsPerEpoch)), AggregationBits: bitfield.NewBitlist(128 / uint64(params.BeaconConfig().SlotsPerEpoch)),
}, },
} }
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
if i%2 == 0 { if i%2 == 0 {
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} else { } else {
@@ -634,7 +650,9 @@ func TestServer_ListIndexedAttestations_OldEpoch(t *testing.T) {
}, },
}, },
} }
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blockExample))) wsb, err := wrapper.WrappedSignedBeaconBlock(blockExample)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
atts = append(atts, blockExample.Block.Body.Attestations...) atts = append(atts, blockExample.Block.Body.Attestations...)
} }
@@ -858,7 +876,9 @@ func TestServer_StreamIndexedAttestations_OK(t *testing.T) {
numValidators := 64 numValidators := 64
headState, privKeys := util.DeterministicGenesisState(t, uint64(numValidators)) headState, privKeys := util.DeterministicGenesisState(t, uint64(numValidators))
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))

109
beacon-chain/rpc/prysm/v1alpha1/beacon/blocks_test.go
View File

@@ -93,7 +93,9 @@ func TestServer_ListBlocks_Genesis(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
wanted := &ethpb.ListBlocksResponse{ wanted := &ethpb.ListBlocksResponse{
BlockContainers: []*ethpb.BeaconBlockContainer{ BlockContainers: []*ethpb.BeaconBlockContainer{
@@ -130,7 +132,9 @@ func TestServer_ListBlocks_Genesis_MultiBlocks(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
count := types.Slot(100) count := types.Slot(100)
@@ -139,7 +143,8 @@ func TestServer_ListBlocks_Genesis_MultiBlocks(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = i b.Block.Slot = i
require.NoError(t, err) require.NoError(t, err)
blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
} }
require.NoError(t, db.SaveBlocks(ctx, blks)) require.NoError(t, db.SaveBlocks(ctx, blks))
@@ -171,7 +176,8 @@ func TestServer_ListBlocks_Pagination(t *testing.T) {
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
chain.CanonicalRoots[root] = true chain.CanonicalRoots[root] = true
blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
blkContainers[i] = &ethpb.BeaconBlockContainer{ blkContainers[i] = &ethpb.BeaconBlockContainer{
Block: &ethpb.BeaconBlockContainer_Phase0Block{Phase0Block: b}, Block: &ethpb.BeaconBlockContainer_Phase0Block{Phase0Block: b},
BlockRoot: root[:], BlockRoot: root[:],
@@ -184,7 +190,9 @@ func TestServer_ListBlocks_Pagination(t *testing.T) {
orphanedBlk.Block.Slot = 300 orphanedBlk.Block.Slot = 300
orphanedBlkRoot, err := orphanedBlk.Block.HashTreeRoot() orphanedBlkRoot, err := orphanedBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(orphanedBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(orphanedBlk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bs := &Server{ bs := &Server{
BeaconDB: db, BeaconDB: db,
@@ -376,7 +384,9 @@ func TestServer_GetChainHead_NoGenesis(t *testing.T) {
genBlock := util.NewBeaconBlock() genBlock := util.NewBeaconBlock()
genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength) genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
gRoot, err := genBlock.Block.HashTreeRoot() gRoot, err := genBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
cases := []struct { cases := []struct {
@@ -407,9 +417,11 @@ func TestServer_GetChainHead_NoGenesis(t *testing.T) {
require.NoError(t, s.SetFinalizedCheckpoint(finalized)) require.NoError(t, s.SetFinalizedCheckpoint(finalized))
require.NoError(t, c.zeroSetter(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]})) require.NoError(t, c.zeroSetter(&ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]}))
}) })
wsb, err := wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: db, BeaconDB: db,
HeadFetcher: &chainMock.ChainService{Block: wrapper.WrappedPhase0SignedBeaconBlock(genBlock), State: s}, HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
FinalizationFetcher: &chainMock.ChainService{ FinalizationFetcher: &chainMock.ChainService{
FinalizedCheckPoint: s.FinalizedCheckpoint(), FinalizedCheckPoint: s.FinalizedCheckpoint(),
CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(), CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(),
@@ -432,14 +444,19 @@ func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
genBlock := util.NewBeaconBlock() genBlock := util.NewBeaconBlock()
genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength) genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
gRoot, err := genBlock.Block.HashTreeRoot() gRoot, err := genBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot))
wsb, err = wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: db, BeaconDB: db,
HeadFetcher: &chainMock.ChainService{Block: wrapper.WrappedPhase0SignedBeaconBlock(genBlock), State: s}, HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
FinalizationFetcher: &chainMock.ChainService{ FinalizationFetcher: &chainMock.ChainService{
FinalizedCheckPoint: s.FinalizedCheckpoint(), FinalizedCheckPoint: s.FinalizedCheckpoint(),
CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(), CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(),
@@ -465,7 +482,9 @@ func TestServer_GetChainHead(t *testing.T) {
db := dbTest.SetupDB(t) db := dbTest.SetupDB(t)
genBlock := util.NewBeaconBlock() genBlock := util.NewBeaconBlock()
genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength) genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
gRoot, err := genBlock.Block.HashTreeRoot() gRoot, err := genBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot))
@@ -473,21 +492,27 @@ func TestServer_GetChainHead(t *testing.T) {
finalizedBlock := util.NewBeaconBlock() finalizedBlock := util.NewBeaconBlock()
finalizedBlock.Block.Slot = 1 finalizedBlock.Block.Slot = 1
finalizedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength) finalizedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(finalizedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
fRoot, err := finalizedBlock.Block.HashTreeRoot() fRoot, err := finalizedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
justifiedBlock := util.NewBeaconBlock() justifiedBlock := util.NewBeaconBlock()
justifiedBlock.Block.Slot = 2 justifiedBlock.Block.Slot = 2
justifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength) justifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(justifiedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(justifiedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
jRoot, err := justifiedBlock.Block.HashTreeRoot() jRoot, err := justifiedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
prevJustifiedBlock := util.NewBeaconBlock() prevJustifiedBlock := util.NewBeaconBlock()
prevJustifiedBlock.Block.Slot = 3 prevJustifiedBlock.Block.Slot = 3
prevJustifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength) prevJustifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(prevJustifiedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(prevJustifiedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
pjRoot, err := prevJustifiedBlock.Block.HashTreeRoot() pjRoot, err := prevJustifiedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -503,9 +528,11 @@ func TestServer_GetChainHead(t *testing.T) {
b.Block.Slot, err = slots.EpochStart(s.PreviousJustifiedCheckpoint().Epoch) b.Block.Slot, err = slots.EpochStart(s.PreviousJustifiedCheckpoint().Epoch)
require.NoError(t, err) require.NoError(t, err)
b.Block.Slot++ b.Block.Slot++
wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
bs := &Server{ bs := &Server{
BeaconDB: db, BeaconDB: db,
HeadFetcher: &chainMock.ChainService{Block: wrapper.WrappedPhase0SignedBeaconBlock(b), State: s}, HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
FinalizationFetcher: &chainMock.ChainService{ FinalizationFetcher: &chainMock.ChainService{
FinalizedCheckPoint: s.FinalizedCheckpoint(), FinalizedCheckPoint: s.FinalizedCheckpoint(),
CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(), CurrentJustifiedCheckPoint: s.CurrentJustifiedCheckpoint(),
@@ -556,7 +583,9 @@ func TestServer_StreamChainHead_OnHeadUpdated(t *testing.T) {
db := dbTest.SetupDB(t) db := dbTest.SetupDB(t)
genBlock := util.NewBeaconBlock() genBlock := util.NewBeaconBlock()
genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength) genBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'G'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
gRoot, err := genBlock.Block.HashTreeRoot() gRoot, err := genBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), gRoot))
@@ -564,21 +593,27 @@ func TestServer_StreamChainHead_OnHeadUpdated(t *testing.T) {
finalizedBlock := util.NewBeaconBlock() finalizedBlock := util.NewBeaconBlock()
finalizedBlock.Block.Slot = 32 finalizedBlock.Block.Slot = 32
finalizedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength) finalizedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(finalizedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(finalizedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
fRoot, err := finalizedBlock.Block.HashTreeRoot() fRoot, err := finalizedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
justifiedBlock := util.NewBeaconBlock() justifiedBlock := util.NewBeaconBlock()
justifiedBlock.Block.Slot = 64 justifiedBlock.Block.Slot = 64
justifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength) justifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'B'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(justifiedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(justifiedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
jRoot, err := justifiedBlock.Block.HashTreeRoot() jRoot, err := justifiedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
prevJustifiedBlock := util.NewBeaconBlock() prevJustifiedBlock := util.NewBeaconBlock()
prevJustifiedBlock.Block.Slot = 96 prevJustifiedBlock.Block.Slot = 96
prevJustifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength) prevJustifiedBlock.Block.ParentRoot = bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(prevJustifiedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(prevJustifiedBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
pjRoot, err := prevJustifiedBlock.Block.HashTreeRoot() pjRoot, err := prevJustifiedBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -599,9 +634,11 @@ func TestServer_StreamChainHead_OnHeadUpdated(t *testing.T) {
chainService := &chainMock.ChainService{} chainService := &chainMock.ChainService{}
ctx := context.Background() ctx := context.Background()
wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
server := &Server{ server := &Server{
Ctx: ctx, Ctx: ctx,
HeadFetcher: &chainMock.ChainService{Block: wrapper.WrappedPhase0SignedBeaconBlock(b), State: s}, HeadFetcher: &chainMock.ChainService{Block: wsb, State: s},
BeaconDB: db, BeaconDB: db,
StateNotifier: chainService.StateNotifier(), StateNotifier: chainService.StateNotifier(),
FinalizationFetcher: &chainMock.ChainService{ FinalizationFetcher: &chainMock.ChainService{
@@ -729,9 +766,11 @@ func TestServer_StreamBlocks_OnHeadUpdated(t *testing.T) {
// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed). // Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
for sent := 0; sent == 0; { for sent := 0; sent == 0; {
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
sent = server.BlockNotifier.BlockFeed().Send(&feed.Event{ sent = server.BlockNotifier.BlockFeed().Send(&feed.Event{
Type: blockfeed.ReceivedBlock, Type: blockfeed.ReceivedBlock,
Data: &blockfeed.ReceivedBlockData{SignedBlock: wrapper.WrappedPhase0SignedBeaconBlock(b)}, Data: &blockfeed.ReceivedBlockData{SignedBlock: wsb},
}) })
} }
<-exitRoutine <-exitRoutine
@@ -747,7 +786,9 @@ func TestServer_StreamBlocksVerified_OnHeadUpdated(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
chainService := &chainMock.ChainService{State: beaconState} chainService := &chainMock.ChainService{State: beaconState}
server := &Server{ server := &Server{
Ctx: ctx, Ctx: ctx,
@@ -772,9 +813,11 @@ func TestServer_StreamBlocksVerified_OnHeadUpdated(t *testing.T) {
// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed). // Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
for sent := 0; sent == 0; { for sent := 0; sent == 0; {
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
sent = server.StateNotifier.StateFeed().Send(&feed.Event{ sent = server.StateNotifier.StateFeed().Send(&feed.Event{
Type: statefeed.BlockProcessed, Type: statefeed.BlockProcessed,
Data: &statefeed.BlockProcessedData{Slot: b.Block.Slot, BlockRoot: r, SignedBlock: wrapper.WrappedPhase0SignedBeaconBlock(b)}, Data: &statefeed.BlockProcessedData{Slot: b.Block.Slot, BlockRoot: r, SignedBlock: wsb},
}) })
} }
<-exitRoutine <-exitRoutine
@@ -843,9 +886,13 @@ func TestServer_ListBlocksAltair_Genesis(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
ctr, err := convertToBlockContainer(wrapper.WrappedPhase0SignedBeaconBlock(blk), root, true) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
ctr, err := convertToBlockContainer(wsb, root, true)
assert.NoError(t, err) assert.NoError(t, err)
wanted := &ethpb.ListBeaconBlocksResponse{ wanted := &ethpb.ListBeaconBlocksResponse{
BlockContainers: []*ethpb.BeaconBlockContainer{ctr}, BlockContainers: []*ethpb.BeaconBlockContainer{ctr},
@@ -876,7 +923,9 @@ func TestServer_ListBlocksAltair_Genesis_MultiBlocks(t *testing.T) {
blk.Block.ParentRoot = parentRoot[:] blk.Block.ParentRoot = parentRoot[:]
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
count := types.Slot(100) count := types.Slot(100)
@@ -885,7 +934,8 @@ func TestServer_ListBlocksAltair_Genesis_MultiBlocks(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = i b.Block.Slot = i
require.NoError(t, err) require.NoError(t, err)
blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
} }
require.NoError(t, db.SaveBlocks(ctx, blks)) require.NoError(t, db.SaveBlocks(ctx, blks))
@@ -917,7 +967,8 @@ func TestServer_ListBlocksAltair_Pagination(t *testing.T) {
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
chain.CanonicalRoots[root] = true chain.CanonicalRoots[root] = true
blks[i] = wrapper.WrappedPhase0SignedBeaconBlock(b) blks[i], err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
ctr, err := convertToBlockContainer(blks[i], root, true) ctr, err := convertToBlockContainer(blks[i], root, true)
require.NoError(t, err) require.NoError(t, err)
blkContainers[i] = ctr blkContainers[i] = ctr
@@ -928,7 +979,9 @@ func TestServer_ListBlocksAltair_Pagination(t *testing.T) {
orphanedBlk.Block.Slot = 300 orphanedBlk.Block.Slot = 300
orphanedBlkRoot, err := orphanedBlk.Block.HashTreeRoot() orphanedBlkRoot, err := orphanedBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(orphanedBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(orphanedBlk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bs := &Server{ bs := &Server{
BeaconDB: db, BeaconDB: db,

8
beacon-chain/rpc/prysm/v1alpha1/beacon/committees_test.go
View File

@@ -44,7 +44,9 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
StateGen: stategen.New(db), StateGen: stategen.New(db),
} }
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
@@ -171,7 +173,9 @@ func TestRetrieveCommitteesForRoot(t *testing.T) {
StateGen: stategen.New(db), StateGen: stategen.New(db),
} }
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))

52
beacon-chain/rpc/prysm/v1alpha1/beacon/validators_test.go
View File

@@ -111,7 +111,9 @@ func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
headState, err := util.NewBeaconState() headState, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -165,7 +167,9 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
require.NoError(t, st.SetValidators(validators)) require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances)) require.NoError(t, st.SetBalances(balances))
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -569,7 +573,9 @@ func TestServer_ListValidators_OnlyActiveValidators(t *testing.T) {
} }
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -637,7 +643,9 @@ func TestServer_ListValidators_InactiveInTheMiddle(t *testing.T) {
} }
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -1118,7 +1126,9 @@ func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
require.NoError(t, st.SetValidators(validators)) require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances)) require.NoError(t, st.SetBalances(balances))
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveState(ctx, st, gRoot)) require.NoError(t, beaconDB.SaveState(ctx, st, gRoot))
@@ -1272,7 +1282,9 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
} }
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -1539,7 +1551,9 @@ func TestServer_GetValidatorParticipation_CurrentAndPrevEpoch(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 16 b.Block.Slot = 16
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
bRoot, err := b.Block.HashTreeRoot() bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bRoot[:]})) require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bRoot[:]}))
require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]})) require.NoError(t, beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: params.BeaconConfig().ZeroHash[:]}))
@@ -1620,7 +1634,9 @@ func TestServer_GetValidatorParticipation_OrphanedUntilGenesis(t *testing.T) {
require.NoError(t, headState.AppendPreviousEpochAttestations(atts[0])) require.NoError(t, headState.AppendPreviousEpochAttestations(atts[0]))
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
bRoot, err := b.Block.HashTreeRoot() bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
require.NoError(t, err) require.NoError(t, err)
@@ -2124,7 +2140,9 @@ func TestServer_GetIndividualVotes_ValidatorsDontExist(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = slot b.Block.Slot = slot
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
gen := stategen.New(beaconDB) gen := stategen.New(beaconDB)
@@ -2220,7 +2238,9 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 0 b.Block.Slot = 0
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
gen := stategen.New(beaconDB) gen := stategen.New(beaconDB)
@@ -2285,7 +2305,9 @@ func TestServer_GetIndividualVotes_WorkingAltair(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = slot b.Block.Slot = slot
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
gen := stategen.New(beaconDB) gen := stategen.New(beaconDB)
@@ -2349,7 +2371,9 @@ func TestServer_GetIndividualVotes_AltairEndOfEpoch(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = startSlot b.Block.Slot = startSlot
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
gen := stategen.New(beaconDB) gen := stategen.New(beaconDB)
@@ -2372,7 +2396,9 @@ func TestServer_GetIndividualVotes_AltairEndOfEpoch(t *testing.T) {
require.NoError(t, beaconState.SetPreviousParticipationBits(pb)) require.NoError(t, beaconState.SetPreviousParticipationBits(pb))
b.Block.Slot = endSlot b.Block.Slot = endSlot
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err = b.Block.HashTreeRoot() gRoot, err = b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)

8
beacon-chain/rpc/prysm/v1alpha1/debug/block_test.go
View File

@@ -25,7 +25,9 @@ func TestServer_GetBlock(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 100 b.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
blockRoot, err := b.Block.HashTreeRoot() blockRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
bs := &Server{ bs := &Server{
@@ -77,7 +79,9 @@ func TestServer_GetAttestationInclusionSlot(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 2 b.Block.Slot = 2
b.Block.Body.Attestations = []*ethpb.Attestation{a} b.Block.Body.Attestations = []*ethpb.Attestation{a}
require.NoError(t, bs.BeaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, bs.BeaconDB.SaveBlock(ctx, wsb))
res, err := bs.GetInclusionSlot(ctx, &ethpb.InclusionSlotRequest{Slot: 1, Id: uint64(c[0])}) res, err := bs.GetInclusionSlot(ctx, &ethpb.InclusionSlotRequest{Slot: 1, Id: uint64(c[0])})
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, b.Block.Slot, res.Slot) require.Equal(t, b.Block.Slot, res.Slot)

4
beacon-chain/rpc/prysm/v1alpha1/debug/state_test.go
View File

@@ -33,7 +33,9 @@ func TestServer_GetBeaconState(t *testing.T) {
require.NoError(t, st.SetSlot(slot)) require.NoError(t, st.SetSlot(slot))
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = slot b.Block.Slot = slot
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
gen := stategen.New(db) gen := stategen.New(db)

8
beacon-chain/rpc/prysm/v1alpha1/validator/attester_test.go
View File

@@ -380,7 +380,9 @@ func TestServer_GetAttestationData_HeadStateSlotGreaterThanRequestSlot(t *testin
require.NoError(t, err, "Could not hash beacon block") require.NoError(t, err, "Could not hash beacon block")
blockRoot2, err := block2.HashTreeRoot() blockRoot2, err := block2.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block2))) wsb, err := wrapper.WrappedSignedBeaconBlock(block2)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
justifiedRoot, err := justifiedBlock.Block.HashTreeRoot() justifiedRoot, err := justifiedBlock.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root for justified block") require.NoError(t, err, "Could not get signing root for justified block")
targetRoot, err := targetBlock.Block.HashTreeRoot() targetRoot, err := targetBlock.Block.HashTreeRoot()
@@ -425,7 +427,9 @@ func TestServer_GetAttestationData_HeadStateSlotGreaterThanRequestSlot(t *testin
StateGen: stategen.New(db), StateGen: stategen.New(db),
} }
require.NoError(t, db.SaveState(ctx, beaconState, blockRoot)) require.NoError(t, db.SaveState(ctx, beaconState, blockRoot))
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(block))) wsb, err = wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot)) require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot))
req := &ethpb.AttestationDataRequest{ req := &ethpb.AttestationDataRequest{

4
beacon-chain/rpc/prysm/v1alpha1/validator/blocks_test.go
View File

@@ -100,7 +100,7 @@ func TestServer_StreamAltairBlocks_OnHeadUpdated(t *testing.T) {
go func(tt *testing.T) { go func(tt *testing.T) {
assert.NoError(tt, server.StreamBlocksAltair(&ethpb.StreamBlocksRequest{}, mockStream), "Could not call RPC method") assert.NoError(tt, server.StreamBlocksAltair(&ethpb.StreamBlocksRequest{}, mockStream), "Could not call RPC method")
}(t) }(t)
wrappedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b) wrappedBlk, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed). // Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
for sent := 0; sent == 0; { for sent := 0; sent == 0; {
@@ -126,7 +126,7 @@ func TestServer_StreamAltairBlocksVerified_OnHeadUpdated(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
wrappedBlk, err := wrapper.WrappedAltairSignedBeaconBlock(b) wrappedBlk, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrappedBlk)) require.NoError(t, db.SaveBlock(ctx, wrappedBlk))
chainService := &chainMock.ChainService{State: beaconState} chainService := &chainMock.ChainService{State: beaconState}

25
beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go
View File

@@ -87,23 +87,9 @@ func (vs *Server) GetBlock(ctx context.Context, req *ethpb.BlockRequest) (*ethpb
func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) { func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBeaconBlock") ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBeaconBlock")
defer span.End() defer span.End()
var blk block.SignedBeaconBlock blk, err := wrapper.WrappedSignedBeaconBlock(req.Block)
var err error if err != nil {
switch b := req.Block.(type) { return nil, status.Errorf(codes.InvalidArgument, "Could not decode block: %v", err)
case *ethpb.GenericSignedBeaconBlock_Phase0:
blk = wrapper.WrappedPhase0SignedBeaconBlock(b.Phase0)
case *ethpb.GenericSignedBeaconBlock_Altair:
blk, err = wrapper.WrappedAltairSignedBeaconBlock(b.Altair)
if err != nil {
return nil, status.Error(codes.Internal, "could not wrap altair beacon block")
}
case *ethpb.GenericSignedBeaconBlock_Bellatrix:
blk, err = wrapper.WrappedBellatrixSignedBeaconBlock(b.Bellatrix)
if err != nil {
return nil, status.Error(codes.Internal, "could not wrap Bellatrix beacon block")
}
default:
return nil, status.Error(codes.Internal, "block version not supported")
} }
return vs.proposeGenericBeaconBlock(ctx, blk) return vs.proposeGenericBeaconBlock(ctx, blk)
} }
@@ -115,7 +101,10 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
func (vs *Server) ProposeBlock(ctx context.Context, rBlk *ethpb.SignedBeaconBlock) (*ethpb.ProposeResponse, error) { func (vs *Server) ProposeBlock(ctx context.Context, rBlk *ethpb.SignedBeaconBlock) (*ethpb.ProposeResponse, error) {
ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBlock") ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBlock")
defer span.End() defer span.End()
blk := wrapper.WrappedPhase0SignedBeaconBlock(rBlk) blk, err := wrapper.WrappedSignedBeaconBlock(rBlk)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "Could not decode block: %v", err)
}
return vs.proposeGenericBeaconBlock(ctx, blk) return vs.proposeGenericBeaconBlock(ctx, blk)
} }

2
beacon-chain/rpc/prysm/v1alpha1/validator/proposer_altair.go
View File

@@ -60,7 +60,7 @@ func (vs *Server) getAltairBeaconBlock(ctx context.Context, req *ethpb.BlockRequ
return nil, fmt.Errorf("could not build block data: %v", err) return nil, fmt.Errorf("could not build block data: %v", err)
} }
// Compute state root with the newly constructed block. // Compute state root with the newly constructed block.
wsb, err := wrapper.WrappedAltairSignedBeaconBlock( wsb, err := wrapper.WrappedSignedBeaconBlock(
&ethpb.SignedBeaconBlockAltair{Block: blk, Signature: make([]byte, 96)}, &ethpb.SignedBeaconBlockAltair{Block: blk, Signature: make([]byte, 96)},
) )
if err != nil { if err != nil {

2
beacon-chain/rpc/prysm/v1alpha1/validator/proposer_bellatrix.go
View File

@@ -40,7 +40,7 @@ func (vs *Server) getBellatrixBeaconBlock(ctx context.Context, req *ethpb.BlockR
}, },
} }
// Compute state root with the newly constructed block. // Compute state root with the newly constructed block.
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock( wsb, err := wrapper.WrappedSignedBeaconBlock(
&ethpb.SignedBeaconBlockBellatrix{Block: blk, Signature: make([]byte, 96)}, &ethpb.SignedBeaconBlockBellatrix{Block: blk, Signature: make([]byte, 96)},
) )
if err != nil { if err != nil {

15
beacon-chain/rpc/prysm/v1alpha1/validator/proposer_phase0.go
View File

@@ -4,6 +4,7 @@ import (
"context" "context"
"fmt" "fmt"
"github.com/pkg/errors"
types "github.com/prysmaticlabs/eth2-types" types "github.com/prysmaticlabs/eth2-types"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks" "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers" "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -59,14 +60,14 @@ func (vs *Server) getPhase0BeaconBlock(ctx context.Context, req *ethpb.BlockRequ
} }
// Compute state root with the newly constructed block. // Compute state root with the newly constructed block.
stateRoot, err = vs.computeStateRoot( wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: blk, Signature: make([]byte, 96)})
ctx, wrapper.WrappedPhase0SignedBeaconBlock(
&ethpb.SignedBeaconBlock{Block: blk, Signature: make([]byte, 96)},
),
)
if err != nil { if err != nil {
interop.WriteBlockToDisk(wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: blk}), true /*failed*/) return nil, err
return nil, fmt.Errorf("could not compute state root: %v", err) }
stateRoot, err = vs.computeStateRoot(ctx, wsb)
if err != nil {
interop.WriteBlockToDisk(wsb, true /*failed*/)
return nil, errors.Wrap(err, "could not compute state root")
} }
blk.StateRoot = stateRoot blk.StateRoot = stateRoot
return blk, nil return blk, nil

30
beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go
View File

@@ -60,7 +60,9 @@ func TestProposer_GetBlock_OK(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root") require.NoError(t, err, "Could not get signing root")
@@ -141,7 +143,9 @@ func TestProposer_GetBlock_AddsUnaggregatedAtts(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root") require.NoError(t, err, "Could not get signing root")
@@ -260,7 +264,9 @@ func TestProposer_ProposeBlock_OK(t *testing.T) {
params.OverrideBeaconConfig(params.MainnetConfig()) params.OverrideBeaconConfig(params.MainnetConfig())
genesis := util.NewBeaconBlock() genesis := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb), "Could not save genesis block")
numDeposits := uint64(64) numDeposits := uint64(64)
beaconState, _ := util.DeterministicGenesisState(t, numDeposits) beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
@@ -302,7 +308,9 @@ func TestProposer_ComputeStateRoot_OK(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root") require.NoError(t, err, "Could not get signing root")
@@ -330,7 +338,9 @@ func TestProposer_ComputeStateRoot_OK(t *testing.T) {
req.Signature, err = signing.ComputeDomainAndSign(beaconState, currentEpoch, req.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx]) req.Signature, err = signing.ComputeDomainAndSign(beaconState, currentEpoch, req.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
require.NoError(t, err) require.NoError(t, err)
_, err = proposerServer.computeStateRoot(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(req)) wsb, err = wrapper.WrappedSignedBeaconBlock(req)
require.NoError(t, err)
_, err = proposerServer.computeStateRoot(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
} }
@@ -2040,7 +2050,7 @@ func TestProposer_GetBeaconBlock_PreForkEpoch(t *testing.T) {
}, },
Signature: genesis.Signature, Signature: genesis.Signature,
} }
wsb := wrapper.WrappedPhase0SignedBeaconBlock(genBlk) wsb, err := wrapper.WrappedSignedBeaconBlock(genBlk)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block") require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
@@ -2132,7 +2142,7 @@ func TestProposer_GetBeaconBlock_PostForkEpoch(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
wsb := wrapper.WrappedPhase0SignedBeaconBlock(genesis) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block") require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
@@ -2251,7 +2261,7 @@ func TestProposer_GetBeaconBlock_BellatrixEpoch(t *testing.T) {
require.NoError(t, err, "Could not hash genesis state") require.NoError(t, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
wsb := wrapper.WrappedPhase0SignedBeaconBlock(genesis) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block") require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
@@ -2551,7 +2561,9 @@ func setupGetBlock(bm *testing.B) (*Server, state.BeaconState, []bls.SecretKey)
require.NoError(bm, err, "Could not hash genesis state") require.NoError(bm, err, "Could not hash genesis state")
genesis := b.NewGenesisBlock(stateRoot[:]) genesis := b.NewGenesisBlock(stateRoot[:])
require.NoError(bm, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis)), "Could not save genesis block") wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(bm, err)
require.NoError(bm, db.SaveBlock(ctx, wsb), "Could not save genesis block")
parentRoot, err := genesis.Block.HashTreeRoot() parentRoot, err := genesis.Block.HashTreeRoot()
require.NoError(bm, err, "Could not get signing root") require.NoError(bm, err, "Could not get signing root")

24
beacon-chain/rpc/statefetcher/fetcher_test.go
View File

@@ -57,7 +57,9 @@ func TestGetState(t *testing.T) {
db := testDB.SetupDB(t) db := testDB.SetupDB(t)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.StateRoot = bytesutil.PadTo([]byte("foo"), 32) b.Block.StateRoot = bytesutil.PadTo([]byte("foo"), 32)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -209,10 +211,12 @@ func TestGetStateRoot(t *testing.T) {
t.Run("head", func(t *testing.T) { t.Run("head", func(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.StateRoot = stateRoot[:] b.Block.StateRoot = stateRoot[:]
wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
p := StateProvider{ p := StateProvider{
ChainInfoFetcher: &chainMock.ChainService{ ChainInfoFetcher: &chainMock.ChainService{
State: newBeaconState, State: newBeaconState,
Block: wrapper.WrappedPhase0SignedBeaconBlock(b), Block: wsb,
}, },
} }
@@ -224,7 +228,9 @@ func TestGetStateRoot(t *testing.T) {
t.Run("genesis", func(t *testing.T) { t.Run("genesis", func(t *testing.T) {
db := testDB.SetupDB(t) db := testDB.SetupDB(t)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -263,7 +269,9 @@ func TestGetStateRoot(t *testing.T) {
Root: root[:], Root: root[:],
} }
// a valid chain is required to save finalized checkpoint. // a valid chain is required to save finalized checkpoint.
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))
@@ -294,7 +302,9 @@ func TestGetStateRoot(t *testing.T) {
Root: root[:], Root: root[:],
} }
// a valid chain is required to save finalized checkpoint. // a valid chain is required to save finalized checkpoint.
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))
@@ -343,7 +353,9 @@ func TestGetStateRoot(t *testing.T) {
blk.Block.Slot = 40 blk.Block.Slot = 40
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, st.SetSlot(1)) require.NoError(t, st.SetSlot(1))

76
beacon-chain/state/stategen/getter_test.go
View File

@@ -26,7 +26,9 @@ func TestStateByRoot_GenesisState(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot)) require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot)) require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
loadedState, err := service.StateByRoot(ctx, params.BeaconConfig().ZeroHash) // Zero hash is genesis state root. loadedState, err := service.StateByRoot(ctx, params.BeaconConfig().ZeroHash) // Zero hash is genesis state root.
require.NoError(t, err) require.NoError(t, err)
@@ -43,13 +45,17 @@ func TestStateByRoot_ColdState(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
bRoot, err := b.Block.HashTreeRoot() bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(1)) require.NoError(t, beaconState.SetSlot(1))
require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot)) require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot)) require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
loadedState, err := service.StateByRoot(ctx, bRoot) loadedState, err := service.StateByRoot(ctx, bRoot)
require.NoError(t, err) require.NoError(t, err)
@@ -81,13 +87,17 @@ func TestStateByRootIfCachedNoCopy_ColdState(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 1 b.Block.Slot = 1
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
bRoot, err := b.Block.HashTreeRoot() bRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(1)) require.NoError(t, beaconState.SetSlot(1))
require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot)) require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err = wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot)) require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
loadedState := service.StateByRootIfCachedNoCopy(bRoot) loadedState := service.StateByRootIfCachedNoCopy(bRoot)
require.NoError(t, err) require.NoError(t, err)
@@ -128,7 +138,9 @@ func TestStateByRoot_HotStateUsingEpochBoundaryCacheWithReplay(t *testing.T) {
targetBlock.Block.Slot = 11 targetBlock.Block.Slot = 11
targetBlock.Block.ParentRoot = blkRoot[:] targetBlock.Block.ParentRoot = blkRoot[:]
targetBlock.Block.ProposerIndex = 8 targetBlock.Block.ProposerIndex = 8
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(targetBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(targetBlock)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
targetRoot, err := targetBlock.Block.HashTreeRoot() targetRoot, err := targetBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: targetSlot, Root: targetRoot[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: targetSlot, Root: targetRoot[:]}))
@@ -163,7 +175,9 @@ func TestStateByRoot_StateByRootInitialSync(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)
require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot)) require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, bRoot))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot)) require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, bRoot))
loadedState, err := service.StateByRootInitialSync(ctx, params.BeaconConfig().ZeroHash) // Zero hash is genesis state root. loadedState, err := service.StateByRootInitialSync(ctx, params.BeaconConfig().ZeroHash) // Zero hash is genesis state root.
require.NoError(t, err) require.NoError(t, err)
@@ -223,7 +237,9 @@ func TestStateByRootInitialSync_CanProcessUpTo(t *testing.T) {
targetBlk.Block.ParentRoot = blkRoot[:] targetBlk.Block.ParentRoot = blkRoot[:]
targetRoot, err := targetBlk.Block.HashTreeRoot() targetRoot, err := targetBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(targetBlk))) wsb, err := wrapper.WrappedSignedBeaconBlock(targetBlk)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: targetSlot, Root: targetRoot[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: targetSlot, Root: targetRoot[:]}))
loadedState, err := service.StateByRootInitialSync(ctx, targetRoot) loadedState, err := service.StateByRootInitialSync(ctx, targetRoot)
@@ -255,7 +271,9 @@ func TestLoadeStateByRoot_FinalizedState(t *testing.T) {
genesisStateRoot, err := beaconState.HashTreeRoot(ctx) genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err) require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 0, Root: gRoot[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 0, Root: gRoot[:]}))
@@ -285,7 +303,9 @@ func TestLoadeStateByRoot_EpochBoundaryStateCanProcess(t *testing.T) {
blk.Block.Slot = 11 blk.Block.Slot = 11
blk.Block.ProposerIndex = 8 blk.Block.ProposerIndex = 8
blk.Block.ParentRoot = gBlkRoot[:] blk.Block.ParentRoot = gBlkRoot[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
blkRoot, err := blk.Block.HashTreeRoot() blkRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 10, Root: blkRoot[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 10, Root: blkRoot[:]}))
@@ -311,7 +331,9 @@ func TestLoadeStateByRoot_FromDBBoundaryCase(t *testing.T) {
blk.Block.Slot = 11 blk.Block.Slot = 11
blk.Block.ProposerIndex = 8 blk.Block.ProposerIndex = 8
blk.Block.ParentRoot = gBlkRoot[:] blk.Block.ParentRoot = gBlkRoot[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
blkRoot, err := blk.Block.HashTreeRoot() blkRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 10, Root: blkRoot[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 10, Root: blkRoot[:]}))
@@ -351,10 +373,18 @@ func TestLastAncestorState_CanGetUsingDB(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, b1State.SetSlot(1)) require.NoError(t, b1State.SetSlot(1))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1))) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveState(ctx, b1State, r1)) require.NoError(t, service.beaconDB.SaveState(ctx, b1State, r1))
lastState, err := service.LastAncestorState(ctx, r3) lastState, err := service.LastAncestorState(ctx, r3)
@@ -391,10 +421,18 @@ func TestLastAncestorState_CanGetUsingCache(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, b1State.SetSlot(1)) require.NoError(t, b1State.SetSlot(1))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1))) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b2))) require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
service.hotStateCache.put(r1, b1State) service.hotStateCache.put(r1, b1State)
lastState, err := service.LastAncestorState(ctx, r3) lastState, err := service.LastAncestorState(ctx, r3)

24
beacon-chain/state/stategen/migrate_test.go
View File

@@ -24,7 +24,9 @@ func TestMigrateToCold_CanSaveFinalizedInfo(t *testing.T) {
b.Block.Slot = 1 b.Block.Slot = 1
br, err := b.Block.HashTreeRoot() br, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.epochBoundaryStateCache.put(br, beaconState)) require.NoError(t, service.epochBoundaryStateCache.put(br, beaconState))
require.NoError(t, service.MigrateToCold(ctx, br)) require.NoError(t, service.MigrateToCold(ctx, br))
@@ -46,7 +48,9 @@ func TestMigrateToCold_HappyPath(t *testing.T) {
b.Block.Slot = 2 b.Block.Slot = 2
fRoot, err := b.Block.HashTreeRoot() fRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.epochBoundaryStateCache.put(fRoot, beaconState)) require.NoError(t, service.epochBoundaryStateCache.put(fRoot, beaconState))
require.NoError(t, service.MigrateToCold(ctx, fRoot)) require.NoError(t, service.MigrateToCold(ctx, fRoot))
@@ -73,7 +77,9 @@ func TestMigrateToCold_RegeneratePath(t *testing.T) {
genesisStateRoot, err := beaconState.HashTreeRoot(ctx) genesisStateRoot, err := beaconState.HashTreeRoot(ctx)
require.NoError(t, err) require.NoError(t, err)
genesis := blocks.NewGenesisBlock(genesisStateRoot[:]) genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
assert.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(genesis))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesis)
require.NoError(t, err)
assert.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := genesis.Block.HashTreeRoot() gRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
assert.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot)) assert.NoError(t, beaconDB.SaveState(ctx, beaconState, gRoot))
@@ -83,14 +89,18 @@ func TestMigrateToCold_RegeneratePath(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
r1, err := b1.Block.HashTreeRoot() r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b1))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: r1[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: r1[:]}))
b4, err := util.GenerateFullBlock(beaconState, pks, util.DefaultBlockGenConfig(), 4) b4, err := util.GenerateFullBlock(beaconState, pks, util.DefaultBlockGenConfig(), 4)
require.NoError(t, err) require.NoError(t, err)
r4, err := b4.Block.HashTreeRoot() r4, err := b4.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b4))) wsb, err = wrapper.WrappedSignedBeaconBlock(b4)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 4, Root: r4[:]})) require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 4, Root: r4[:]}))
service.finalizedInfo = &finalizedInfo{ service.finalizedInfo = &finalizedInfo{
slot: 0, slot: 0,
@@ -126,7 +136,9 @@ func TestMigrateToCold_StateExistsInDB(t *testing.T) {
b.Block.Slot = 2 b.Block.Slot = 2
fRoot, err := b.Block.HashTreeRoot() fRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, service.epochBoundaryStateCache.put(fRoot, beaconState)) require.NoError(t, service.epochBoundaryStateCache.put(fRoot, beaconState))
require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, fRoot)) require.NoError(t, service.beaconDB.SaveState(ctx, beaconState, fRoot))

24
beacon-chain/state/stategen/replay_test.go
View File

@@ -104,7 +104,9 @@ func TestReplayBlocks_LowerSlotBlock(t *testing.T) {
targetSlot := beaconState.Slot() targetSlot := beaconState.Slot()
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = beaconState.Slot() - 1 b.Block.Slot = beaconState.Slot() - 1
newState, err := service.ReplayBlocks(context.Background(), beaconState, []block.SignedBeaconBlock{wrapper.WrappedPhase0SignedBeaconBlock(b)}, targetSlot) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
newState, err := service.ReplayBlocks(context.Background(), beaconState, []block.SignedBeaconBlock{wsb}, targetSlot)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, targetSlot, newState.Slot(), "Did not advance slots") assert.Equal(t, targetSlot, newState.Slot(), "Did not advance slots")
} }
@@ -419,7 +421,9 @@ func tree1(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][32]byte,
beaconBlock := util.NewBeaconBlock() beaconBlock := util.NewBeaconBlock()
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
return nil, nil, err return nil, nil, err
} }
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil { if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -499,7 +503,9 @@ func tree2(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][32]byte,
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32) beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
return nil, nil, err return nil, nil, err
} }
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil { if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -572,7 +578,9 @@ func tree3(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][32]byte,
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32) beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
return nil, nil, err return nil, nil, err
} }
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil { if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -639,7 +647,9 @@ func tree4(t *testing.T, beaconDB db.Database, genesisRoot []byte) ([][32]byte,
beaconBlock.Block.Slot = b.Block.Slot beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32) beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32) beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(beaconBlock)); err != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(beaconBlock)
require.NoError(t, err)
if err := beaconDB.SaveBlock(context.Background(), wsb); err != nil {
return nil, nil, err return nil, nil, err
} }
if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil { if err := beaconDB.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
@@ -660,7 +670,9 @@ func TestLoadFinalizedBlocks(t *testing.T) {
gBlock := util.NewBeaconBlock() gBlock := util.NewBeaconBlock()
gRoot, err := gBlock.Block.HashTreeRoot() gRoot, err := gBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(gBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(gBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, [32]byte{})) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, [32]byte{}))
roots, _, err := tree1(t, beaconDB, gRoot[:]) roots, _, err := tree1(t, beaconDB, gRoot[:])
require.NoError(t, err) require.NoError(t, err)

4
beacon-chain/state/stategen/service_test.go
View File

@@ -19,7 +19,9 @@ func TestResume(t *testing.T) {
service := New(beaconDB) service := New(beaconDB)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, service.beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
beaconState, _ := util.DeterministicGenesisState(t, 32) beaconState, _ := util.DeterministicGenesisState(t, 32)

8
beacon-chain/state/stategen/setter_test.go
View File

@@ -123,7 +123,9 @@ func TestSaveState_NoSaveNotEpochBoundary(t *testing.T) {
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1)) require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1))
r := [32]byte{'A'} r := [32]byte{'A'}
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
gRoot, err := b.Block.HashTreeRoot() gRoot, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot)) require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, gRoot))
@@ -183,7 +185,9 @@ func TestEnableSaveHotStateToDB_Disabled(t *testing.T) {
service := New(beaconDB) service := New(beaconDB)
service.saveHotStateDB.enabled = true service.saveHotStateDB.enabled = true
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
r, err := b.Block.HashTreeRoot() r, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
service.saveHotStateDB.savedStateRoots = [][32]byte{r} service.saveHotStateDB.savedStateRoots = [][32]byte{r}

7
beacon-chain/sync/decode_pubsub_test.go
View File

@@ -17,6 +17,7 @@ import (
p2ptesting "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" p2ptesting "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
"github.com/prysmaticlabs/prysm/config/params" "github.com/prysmaticlabs/prysm/config/params"
ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
"github.com/prysmaticlabs/prysm/testing/require" "github.com/prysmaticlabs/prysm/testing/require"
"github.com/prysmaticlabs/prysm/testing/util" "github.com/prysmaticlabs/prysm/testing/util"
@@ -71,7 +72,11 @@ func TestService_decodePubsubMessage(t *testing.T) {
}, },
}, },
wantErr: nil, wantErr: nil,
want: wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
return wsb
}(),
}, },
} }
for _, tt := range tests { for _, tt := range tests {

22
beacon-chain/sync/initial-sync/BUILD.bazel
View File

@@ -101,6 +101,7 @@ go_test(
"blocks_fetcher_test.go", "blocks_fetcher_test.go",
"blocks_fetcher_utils_test.go", "blocks_fetcher_utils_test.go",
"blocks_queue_test.go", "blocks_queue_test.go",
"fsm_benchmark_test.go",
"fsm_test.go", "fsm_test.go",
"initial_sync_test.go", "initial_sync_test.go",
"round_robin_test.go", "round_robin_test.go",
@@ -146,24 +147,3 @@ go_test(
"@com_github_sirupsen_logrus//hooks/test:go_default_library", "@com_github_sirupsen_logrus//hooks/test:go_default_library",
], ],
) )
# gazelle:exclude fsm_benchmark_test.go
go_test(
name = "go_benchmark_test",
size = "small",
srcs = ["fsm_benchmark_test.go"],
args = [
"-test.bench=.",
"-test.benchmem",
"-test.v",
],
embed = [":go_default_library"],
local = True,
tags = [
"benchmark",
"manual",
"no-cache",
],
deps = [
],
)

60
beacon-chain/sync/initial-sync/blocks_fetcher_test.go
View File

@@ -267,7 +267,9 @@ func TestBlocksFetcher_RoundRobin(t *testing.T) {
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]
cache.RUnlock() cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -613,7 +615,9 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = i blk.Block.Slot = i
mchain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} mchain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, mchain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, mchain, p1.Encoding(), wsb))
} }
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
@@ -635,7 +639,9 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = i blk.Block.Slot = i
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
} }
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
@@ -657,11 +663,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = 163 blk.Block.Slot = 163
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
blk = util.NewBeaconBlock() blk = util.NewBeaconBlock()
blk.Block.Slot = 162 blk.Block.Slot = 162
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
}, },
@@ -683,11 +693,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk.Block.Slot = 160 blk.Block.Slot = 160
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
blk = util.NewBeaconBlock() blk = util.NewBeaconBlock()
blk.Block.Slot = 160 blk.Block.Slot = 160
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
}, },
@@ -714,11 +728,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
// Patch mid block, with invalid slot number. // Patch mid block, with invalid slot number.
if i == req.StartSlot.Add(req.Count*req.Step/2) { if i == req.StartSlot.Add(req.Count*req.Step/2) {
blk.Block.Slot = req.StartSlot - 1 blk.Block.Slot = req.StartSlot - 1
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
break break
} }
blk.Block.Slot = i blk.Block.Slot = i
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
} }
} }
}, },
@@ -745,11 +763,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
// Patch mid block, with invalid slot number. // Patch mid block, with invalid slot number.
if i == req.StartSlot.Add(req.Count*req.Step/2) { if i == req.StartSlot.Add(req.Count*req.Step/2) {
blk.Block.Slot = req.StartSlot.Add(req.Count * req.Step) blk.Block.Slot = req.StartSlot.Add(req.Count * req.Step)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
break break
} }
blk.Block.Slot = i blk.Block.Slot = i
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
} }
} }
}, },
@@ -770,11 +792,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = 100 blk.Block.Slot = 100
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
blk = util.NewBeaconBlock() blk = util.NewBeaconBlock()
blk.Block.Slot = 105 blk.Block.Slot = 105
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
}, },
@@ -794,11 +820,15 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = 100 blk.Block.Slot = 100
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
blk = util.NewBeaconBlock() blk = util.NewBeaconBlock()
blk.Block.Slot = 103 blk.Block.Slot = 103
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err = wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p1.Encoding(), wsb))
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
} }
}, },

33
beacon-chain/sync/initial-sync/blocks_fetcher_utils_test.go
View File

@@ -163,7 +163,9 @@ func TestBlocksFetcher_findFork(t *testing.T) {
finalizedEpoch := slots.ToEpoch(finalizedSlot) finalizedEpoch := slots.ToEpoch(finalizedSlot)
genesisBlock := chain1[0] genesisBlock := chain1[0]
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -259,7 +261,9 @@ func TestBlocksFetcher_findFork(t *testing.T) {
require.Equal(t, curForkMoreBlocksPeer, fork.peer) require.Equal(t, curForkMoreBlocksPeer, fork.peer)
// Save all chain1b blocks (so that they do not interfere with alternative fork) // Save all chain1b blocks (so that they do not interfere with alternative fork)
for _, blk := range chain1b { for _, blk := range chain1b {
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(blk.Block.Slot)) require.NoError(t, st.SetSlot(blk.Block.Slot))
} }
forkSlot := types.Slot(129) forkSlot := types.Slot(129)
@@ -296,7 +300,9 @@ func TestBlocksFetcher_findFork(t *testing.T) {
// Only save is parent block exists. // Only save is parent block exists.
parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot) parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot)
if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) { if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) {
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(blk.Block.Slot)) require.NoError(t, st.SetSlot(blk.Block.Slot))
} }
} }
@@ -315,7 +321,9 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
knownBlocks := extendBlockSequence(t, []*ethpb.SignedBeaconBlock{}, 128) knownBlocks := extendBlockSequence(t, []*ethpb.SignedBeaconBlock{}, 128)
genesisBlock := knownBlocks[0] genesisBlock := knownBlocks[0]
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -342,7 +350,9 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
fetcher.rateLimiter = leakybucket.NewCollector(6400, 6400, false) fetcher.rateLimiter = leakybucket.NewCollector(6400, 6400, false)
for _, blk := range knownBlocks { for _, blk := range knownBlocks {
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(blk.Block.Slot)) require.NoError(t, st.SetSlot(blk.Block.Slot))
} }
@@ -427,7 +437,9 @@ func TestBlocksFetcher_findAncestor(t *testing.T) {
finalizedEpoch := slots.ToEpoch(finalizedSlot) finalizedEpoch := slots.ToEpoch(finalizedSlot)
genesisBlock := knownBlocks[0] genesisBlock := knownBlocks[0]
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -462,7 +474,9 @@ func TestBlocksFetcher_findAncestor(t *testing.T) {
p2 := p2pt.NewTestP2P(t) p2 := p2pt.NewTestP2P(t)
p2p.Connect(p2) p2p.Connect(p2)
_, err := fetcher.findAncestor(ctx, p2.PeerID(), wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[4])) wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[4])
require.NoError(t, err)
_, err = fetcher.findAncestor(ctx, p2.PeerID(), wsb)
assert.ErrorContains(t, "protocol not supported", err) assert.ErrorContains(t, "protocol not supported", err)
}) })
@@ -474,7 +488,10 @@ func TestBlocksFetcher_findAncestor(t *testing.T) {
assert.NoError(t, stream.Close()) assert.NoError(t, stream.Close())
}) })
fork, err := fetcher.findAncestor(ctx, p2.PeerID(), wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[4])) wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[4])
require.NoError(t, err)
fork, err := fetcher.findAncestor(ctx, p2.PeerID(), wsb)
assert.ErrorContains(t, "no common ancestor found", err) assert.ErrorContains(t, "no common ancestor found", err)
assert.Equal(t, (*forkData)(nil), fork) assert.Equal(t, (*forkData)(nil), fork)
}) })

39
beacon-chain/sync/initial-sync/blocks_queue_test.go
View File

@@ -521,13 +521,14 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
chain: mc, chain: mc,
highestExpectedSlot: types.Slot(blockBatchLimit), highestExpectedSlot: types.Slot(blockBatchLimit),
}) })
wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
handlerFn := queue.onDataReceivedEvent(ctx) handlerFn := queue.onDataReceivedEvent(ctx)
response := &fetchRequestResponse{ response := &fetchRequestResponse{
pid: "abc", pid: "abc",
blocks: []block.SignedBeaconBlock{ blocks: []block.SignedBeaconBlock{
wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), wsb,
wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), wsb.Copy(),
}, },
} }
fsm := &stateMachine{ fsm := &stateMachine{
@@ -617,12 +618,14 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
chain: mc, chain: mc,
highestExpectedSlot: types.Slot(blockBatchLimit), highestExpectedSlot: types.Slot(blockBatchLimit),
}) })
wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
queue.smm.addStateMachine(256) queue.smm.addStateMachine(256)
queue.smm.addStateMachine(320) queue.smm.addStateMachine(320)
queue.smm.machines[256].state = stateDataParsed queue.smm.machines[256].state = stateDataParsed
queue.smm.machines[256].pid = pidDataParsed queue.smm.machines[256].pid = pidDataParsed
queue.smm.machines[256].blocks = []block.SignedBeaconBlock{ queue.smm.machines[256].blocks = []block.SignedBeaconBlock{
wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), wsb,
} }
handlerFn := queue.onReadyToSendEvent(ctx) handlerFn := queue.onReadyToSendEvent(ctx)
@@ -642,6 +645,8 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
chain: mc, chain: mc,
highestExpectedSlot: types.Slot(blockBatchLimit), highestExpectedSlot: types.Slot(blockBatchLimit),
}) })
wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
queue.smm.addStateMachine(128) queue.smm.addStateMachine(128)
queue.smm.machines[128].state = stateNew queue.smm.machines[128].state = stateNew
queue.smm.addStateMachine(192) queue.smm.addStateMachine(192)
@@ -652,7 +657,7 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
queue.smm.machines[320].state = stateDataParsed queue.smm.machines[320].state = stateDataParsed
queue.smm.machines[320].pid = pidDataParsed queue.smm.machines[320].pid = pidDataParsed
queue.smm.machines[320].blocks = []block.SignedBeaconBlock{ queue.smm.machines[320].blocks = []block.SignedBeaconBlock{
wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), wsb,
} }
handlerFn := queue.onReadyToSendEvent(ctx) handlerFn := queue.onReadyToSendEvent(ctx)
@@ -673,13 +678,15 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
chain: mc, chain: mc,
highestExpectedSlot: types.Slot(blockBatchLimit), highestExpectedSlot: types.Slot(blockBatchLimit),
}) })
wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
queue.smm.addStateMachine(256) queue.smm.addStateMachine(256)
queue.smm.machines[256].state = stateSkipped queue.smm.machines[256].state = stateSkipped
queue.smm.addStateMachine(320) queue.smm.addStateMachine(320)
queue.smm.machines[320].state = stateDataParsed queue.smm.machines[320].state = stateDataParsed
queue.smm.machines[320].pid = pidDataParsed queue.smm.machines[320].pid = pidDataParsed
queue.smm.machines[320].blocks = []block.SignedBeaconBlock{ queue.smm.machines[320].blocks = []block.SignedBeaconBlock{
wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()), wsb,
} }
handlerFn := queue.onReadyToSendEvent(ctx) handlerFn := queue.onReadyToSendEvent(ctx)
@@ -1038,7 +1045,9 @@ func TestBlocksQueue_stuckInUnfavourableFork(t *testing.T) {
finalizedEpoch := slots.ToEpoch(finalizedSlot) finalizedEpoch := slots.ToEpoch(finalizedSlot)
genesisBlock := chain1[0] genesisBlock := chain1[0]
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -1080,7 +1089,9 @@ func TestBlocksQueue_stuckInUnfavourableFork(t *testing.T) {
parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot) parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot)
// Save block only if parent root is already in database or cache. // Save block only if parent root is already in database or cache.
if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) { if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) {
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(blk.Block.Slot)) require.NoError(t, st.SetSlot(blk.Block.Slot))
} }
} }
@@ -1239,7 +1250,9 @@ func TestBlocksQueue_stuckWhenHeadIsSetToOrphanedBlock(t *testing.T) {
finalizedEpoch := slots.ToEpoch(finalizedSlot) finalizedEpoch := slots.ToEpoch(finalizedSlot)
genesisBlock := chain[0] genesisBlock := chain[0]
require.NoError(t, beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(context.Background(), wsb))
genesisRoot, err := genesisBlock.Block.HashTreeRoot() genesisRoot, err := genesisBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -1262,7 +1275,9 @@ func TestBlocksQueue_stuckWhenHeadIsSetToOrphanedBlock(t *testing.T) {
parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot) parentRoot := bytesutil.ToBytes32(blk.Block.ParentRoot)
// Save block only if parent root is already in database or cache. // Save block only if parent root is already in database or cache.
if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) { if beaconDB.HasBlock(ctx, parentRoot) || mc.HasInitSyncBlock(parentRoot) {
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(blk.Block.Slot)) require.NoError(t, st.SetSlot(blk.Block.Slot))
} }
} }
@@ -1274,7 +1289,9 @@ func TestBlocksQueue_stuckWhenHeadIsSetToOrphanedBlock(t *testing.T) {
orphanedBlock := util.NewBeaconBlock() orphanedBlock := util.NewBeaconBlock()
orphanedBlock.Block.Slot = 85 orphanedBlock.Block.Slot = 85
orphanedBlock.Block.StateRoot = util.Random32Bytes(t) orphanedBlock.Block.StateRoot = util.Random32Bytes(t)
require.NoError(t, beaconDB.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(orphanedBlock))) wsb, err = wrapper.WrappedSignedBeaconBlock(orphanedBlock)
require.NoError(t, err)
require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
require.NoError(t, st.SetSlot(orphanedBlock.Block.Slot)) require.NoError(t, st.SetSlot(orphanedBlock.Block.Slot))
require.Equal(t, types.Slot(85), mc.HeadSlot()) require.Equal(t, types.Slot(85), mc.HeadSlot())

12
beacon-chain/sync/initial-sync/initial_sync_test.go
View File

@@ -82,7 +82,9 @@ func initializeTestServices(t *testing.T, slots []types.Slot, peers []*peerData)
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]
cache.RUnlock() cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -219,7 +221,9 @@ func connectPeer(t *testing.T, host *p2pt.TestP2P, datum *peerData, peerStatus *
mChain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} mChain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
for i := 0; i < len(ret); i++ { for i := 0; i < len(ret); i++ {
assert.NoError(t, beaconsync.WriteBlockChunk(stream, mChain, p.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(ret[i]))) wsb, err := wrapper.WrappedSignedBeaconBlock(ret[i])
require.NoError(t, err)
assert.NoError(t, beaconsync.WriteBlockChunk(stream, mChain, p.Encoding(), wsb))
} }
}) })
@@ -289,7 +293,9 @@ func connectPeerHavingBlocks(
break break
} }
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
require.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(blocks[i]))) wsb, err := wrapper.WrappedSignedBeaconBlock(blocks[i])
require.NoError(t, err)
require.NoError(t, beaconsync.WriteBlockChunk(stream, chain, p.Encoding(), wsb))
} }
}) })

48
beacon-chain/sync/initial-sync/round_robin_test.go
View File

@@ -283,7 +283,9 @@ func TestService_roundRobinSync(t *testing.T) {
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]
cache.RUnlock() cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -326,7 +328,9 @@ func TestService_processBlock(t *testing.T) {
genesisBlk := util.NewBeaconBlock() genesisBlk := util.NewBeaconBlock()
genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot() genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
@@ -359,7 +363,9 @@ func TestService_processBlock(t *testing.T) {
blk2.Block.ParentRoot = blk1Root[:] blk2.Block.ParentRoot = blk1Root[:]
// Process block normally. // Process block normally.
err = s.processBlock(ctx, genesis, wrapper.WrappedPhase0SignedBeaconBlock(blk1), func( wsb, err := wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err)
err = s.processBlock(ctx, genesis, wsb, func(
ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error { ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error {
assert.NoError(t, s.cfg.Chain.ReceiveBlock(ctx, block, blockRoot)) assert.NoError(t, s.cfg.Chain.ReceiveBlock(ctx, block, blockRoot))
return nil return nil
@@ -367,14 +373,18 @@ func TestService_processBlock(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
// Duplicate processing should trigger error. // Duplicate processing should trigger error.
err = s.processBlock(ctx, genesis, wrapper.WrappedPhase0SignedBeaconBlock(blk1), func( wsb, err = wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err)
err = s.processBlock(ctx, genesis, wsb, func(
ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error { ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error {
return nil return nil
}) })
assert.ErrorContains(t, errBlockAlreadyProcessed.Error(), err) assert.ErrorContains(t, errBlockAlreadyProcessed.Error(), err)
// Continue normal processing, should proceed w/o errors. // Continue normal processing, should proceed w/o errors.
err = s.processBlock(ctx, genesis, wrapper.WrappedPhase0SignedBeaconBlock(blk2), func( wsb, err = wrapper.WrappedSignedBeaconBlock(blk2)
require.NoError(t, err)
err = s.processBlock(ctx, genesis, wsb, func(
ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error { ctx context.Context, block block.SignedBeaconBlock, blockRoot [32]byte) error {
assert.NoError(t, s.cfg.Chain.ReceiveBlock(ctx, block, blockRoot)) assert.NoError(t, s.cfg.Chain.ReceiveBlock(ctx, block, blockRoot))
return nil return nil
@@ -389,7 +399,9 @@ func TestService_processBlockBatch(t *testing.T) {
genesisBlk := util.NewBeaconBlock() genesisBlk := util.NewBeaconBlock()
genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot() genesisBlkRoot, err := genesisBlk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(genesisBlk)) wsb, err := wrapper.WrappedSignedBeaconBlock(genesisBlk)
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
require.NoError(t, err) require.NoError(t, err)
@@ -419,9 +431,13 @@ func TestService_processBlockBatch(t *testing.T) {
blk1.Block.ParentRoot = parentRoot[:] blk1.Block.ParentRoot = parentRoot[:]
blk1Root, err := blk1.Block.HashTreeRoot() blk1Root, err := blk1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk1)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err) require.NoError(t, err)
batch = append(batch, wrapper.WrappedPhase0SignedBeaconBlock(blk1)) err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err)
wsb, err = wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err)
batch = append(batch, wsb)
currBlockRoot = blk1Root currBlockRoot = blk1Root
} }
@@ -433,9 +449,13 @@ func TestService_processBlockBatch(t *testing.T) {
blk1.Block.ParentRoot = parentRoot[:] blk1.Block.ParentRoot = parentRoot[:]
blk1Root, err := blk1.Block.HashTreeRoot() blk1Root, err := blk1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk1)) wsb, err := wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err) require.NoError(t, err)
batch2 = append(batch2, wrapper.WrappedPhase0SignedBeaconBlock(blk1)) err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err)
wsb, err = wrapper.WrappedSignedBeaconBlock(blk1)
require.NoError(t, err)
batch2 = append(batch2, wsb)
currBlockRoot = blk1Root currBlockRoot = blk1Root
} }
@@ -517,7 +537,9 @@ func TestService_blockProviderScoring(t *testing.T) {
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]
cache.RUnlock() cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()
@@ -583,7 +605,9 @@ func TestService_syncToFinalizedEpoch(t *testing.T) {
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]
cache.RUnlock() cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
st, err := util.NewBeaconState() st, err := util.NewBeaconState()

4
beacon-chain/sync/initial-sync/service_test.go
View File

@@ -378,7 +378,9 @@ func TestService_Resync(t *testing.T) {
}, p.Peers()) }, p.Peers())
cache.initializeRootCache(makeSequence(1, 160), t) cache.initializeRootCache(makeSequence(1, 160), t)
beaconDB := dbtest.SetupDB(t) beaconDB := dbtest.SetupDB(t)
err := beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock())) wsb, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
require.NoError(t, err)
err = beaconDB.SaveBlock(context.Background(), wsb)
require.NoError(t, err) require.NoError(t, err)
cache.RLock() cache.RLock()
genesisRoot := cache.rootCache[0] genesisRoot := cache.rootCache[0]

12
beacon-chain/sync/pending_attestations_queue_test.go
View File

@@ -64,7 +64,9 @@ func TestProcessPendingAtts_HasBlockSaveUnAggregatedAtt(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, validators) beaconState, privKeys := util.DeterministicGenesisState(t, validators)
sb := util.NewBeaconBlock() sb := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(sb))) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := sb.Block.HashTreeRoot() root, err := sb.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -166,7 +168,9 @@ func TestProcessPendingAtts_NoBroadcastWithBadSignature(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
r32, err := b.Block.HashTreeRoot() r32, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, r.cfg.beaconDB.SaveState(context.Background(), s, r32)) require.NoError(t, r.cfg.beaconDB.SaveState(context.Background(), s, r32))
r.blkRootToPendingAtts[r32] = []*ethpb.SignedAggregateAttestationAndProof{{Message: a, Signature: make([]byte, fieldparams.BLSSignatureLength)}} r.blkRootToPendingAtts[r32] = []*ethpb.SignedAggregateAttestationAndProof{{Message: a, Signature: make([]byte, fieldparams.BLSSignatureLength)}}
@@ -247,7 +251,9 @@ func TestProcessPendingAtts_HasBlockSaveAggregatedAtt(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, validators) beaconState, privKeys := util.DeterministicGenesisState(t, validators)
sb := util.NewBeaconBlock() sb := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(sb))) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := sb.Block.HashTreeRoot() root, err := sb.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)

176
beacon-chain/sync/pending_blocks_queue_test.go
View File

@@ -54,13 +54,17 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks1(t *testing.T) {
r.initCaches() r.initCaches()
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
b3.Block.Slot = 3 b3.Block.Slot = 3
b3.Block.ParentRoot = b0Root[:] b3.Block.ParentRoot = b0Root[:]
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
// Incomplete block link // Incomplete block link
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
b1.Block.Slot = 1 b1.Block.Slot = 1
@@ -74,15 +78,21 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks1(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// Add b2 to the cache // Add b2 to the cache
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b2), b2Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wsb, b2Root))
require.NoError(t, r.processPendingBlocks(context.Background())) require.NoError(t, r.processPendingBlocks(context.Background()))
assert.Equal(t, 1, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache") assert.Equal(t, 1, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
assert.Equal(t, 1, len(r.seenPendingBlocks), "Incorrect size for seen pending block") assert.Equal(t, 1, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
// Add b1 to the cache // Add b1 to the cache
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b1), b1Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b1))) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wsb, b1Root))
wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
nBlock := util.NewBeaconBlock() nBlock := util.NewBeaconBlock()
nBlock.Block.Slot = b1.Block.Slot nBlock.Block.Slot = b1.Block.Slot
@@ -90,7 +100,9 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks1(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// Insert bad b1 in the cache to verify the good one doesn't get replaced. // Insert bad b1 in the cache to verify the good one doesn't get replaced.
require.NoError(t, r.insertBlockToPendingQueue(nBlock.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(nBlock), nRoot)) wsb, err = wrapper.WrappedSignedBeaconBlock(nBlock)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(nBlock.Block.Slot, wsb, nRoot))
require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad
require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
@@ -120,7 +132,9 @@ func TestRegularSync_InsertDuplicateBlocks(t *testing.T) {
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
b0r := [32]byte{'a'} b0r := [32]byte{'a'}
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
@@ -128,18 +142,26 @@ func TestRegularSync_InsertDuplicateBlocks(t *testing.T) {
b1.Block.ParentRoot = b0Root[:] b1.Block.ParentRoot = b0Root[:]
b1r := [32]byte{'b'} b1r := [32]byte{'b'}
require.NoError(t, r.insertBlockToPendingQueue(b0.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b0), b0r)) wsb, err = wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b0.Block.Slot, wsb, b0r))
require.Equal(t, 1, len(r.pendingBlocksInCache(b0.Block.Slot)), "Block was not added to map") require.Equal(t, 1, len(r.pendingBlocksInCache(b0.Block.Slot)), "Block was not added to map")
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b1), b1r)) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wsb, b1r))
require.Equal(t, 1, len(r.pendingBlocksInCache(b1.Block.Slot)), "Block was not added to map") require.Equal(t, 1, len(r.pendingBlocksInCache(b1.Block.Slot)), "Block was not added to map")
// Add duplicate block which should not be saved. // Add duplicate block which should not be saved.
require.NoError(t, r.insertBlockToPendingQueue(b0.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b0), b0r)) wsb, err = wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b0.Block.Slot, wsb, b0r))
require.Equal(t, 1, len(r.pendingBlocksInCache(b0.Block.Slot)), "Block was added to map") require.Equal(t, 1, len(r.pendingBlocksInCache(b0.Block.Slot)), "Block was added to map")
// Add duplicate block which should not be saved. // Add duplicate block which should not be saved.
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b1), b1r)) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wsb, b1r))
require.Equal(t, 1, len(r.pendingBlocksInCache(b1.Block.Slot)), "Block was added to map") require.Equal(t, 1, len(r.pendingBlocksInCache(b1.Block.Slot)), "Block was added to map")
} }
@@ -165,7 +187,9 @@ func TestRegularSyncBeaconBlockSubscriber_DoNotReprocessBlock(t *testing.T) {
r.initCaches() r.initCaches()
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b3 := util.NewBeaconBlock() b3 := util.NewBeaconBlock()
@@ -174,10 +198,14 @@ func TestRegularSyncBeaconBlockSubscriber_DoNotReprocessBlock(t *testing.T) {
b3Root, err := b3.Block.HashTreeRoot() b3Root, err := b3.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b3))) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
// Add b3 to the cache // Add b3 to the cache
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b3), b3Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wsb, b3Root))
require.NoError(t, r.processPendingBlocks(context.Background())) require.NoError(t, r.processPendingBlocks(context.Background()))
assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache") assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
@@ -232,13 +260,17 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
p1.Peers().SetChainState(p2.PeerID(), &ethpb.Status{}) p1.Peers().SetChainState(p2.PeerID(), &ethpb.Status{})
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
b1.Block.Slot = 1 b1.Block.Slot = 1
b1.Block.ParentRoot = b0Root[:] b1.Block.ParentRoot = b0Root[:]
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b1))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b1Root, err := b1.Block.HashTreeRoot() b1Root, err := b1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -264,8 +296,12 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
b4Root, err := b4.Block.HashTreeRoot() b4Root, err := b4.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b4.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b4), b4Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b4)
require.NoError(t, r.insertBlockToPendingQueue(b5.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b5), b5Root)) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b4.Block.Slot, wsb, b4Root))
wsb, err = wrapper.WrappedSignedBeaconBlock(b5)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b5.Block.Slot, wsb, b5Root))
require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad
require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
@@ -274,8 +310,12 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
assert.Equal(t, 2, len(r.seenPendingBlocks), "Incorrect size for seen pending block") assert.Equal(t, 2, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
// Add b3 to the cache // Add b3 to the cache
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b3), b3Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b3))) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wsb, b3Root))
wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad
require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
@@ -284,9 +324,13 @@ func TestRegularSyncBeaconBlockSubscriber_ProcessPendingBlocks_2Chains(t *testin
assert.Equal(t, 1, len(r.seenPendingBlocks), "Incorrect size for seen pending block") assert.Equal(t, 1, len(r.seenPendingBlocks), "Incorrect size for seen pending block")
// Add b2 to the cache // Add b2 to the cache
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b2), b2Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wsb, b2Root))
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b2))) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad require.NoError(t, r.processPendingBlocks(context.Background())) // Marks a block as bad
require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run require.NoError(t, r.processPendingBlocks(context.Background())) // Bad block removed on second run
@@ -323,13 +367,17 @@ func TestRegularSyncBeaconBlockSubscriber_PruneOldPendingBlocks(t *testing.T) {
p1.Peers().SetChainState(p1.PeerID(), &ethpb.Status{}) p1.Peers().SetChainState(p1.PeerID(), &ethpb.Status{})
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
b1.Block.Slot = 1 b1.Block.Slot = 1
b1.Block.ParentRoot = b0Root[:] b1.Block.ParentRoot = b0Root[:]
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b1))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b1Root, err := b1.Block.HashTreeRoot() b1Root, err := b1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -355,10 +403,18 @@ func TestRegularSyncBeaconBlockSubscriber_PruneOldPendingBlocks(t *testing.T) {
b4Root, err := b4.Block.HashTreeRoot() b4Root, err := b4.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b2), b2Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b3), b3Root)) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b4.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b4), b4Root)) require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wsb, b2Root))
require.NoError(t, r.insertBlockToPendingQueue(b5.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b5), b5Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wsb, b3Root))
wsb, err = wrapper.WrappedSignedBeaconBlock(b4)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b4.Block.Slot, wsb, b4Root))
wsb, err = wrapper.WrappedSignedBeaconBlock(b5)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b5.Block.Slot, wsb, b5Root))
require.NoError(t, r.processPendingBlocks(context.Background())) require.NoError(t, r.processPendingBlocks(context.Background()))
assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache") assert.Equal(t, 0, len(r.slotToPendingBlocks.Items()), "Incorrect size for slot to pending blocks cache")
@@ -372,10 +428,18 @@ func TestService_sortedPendingSlots(t *testing.T) {
} }
var lastSlot types.Slot = math.MaxUint64 var lastSlot types.Slot = math.MaxUint64
require.NoError(t, r.insertBlockToPendingQueue(lastSlot, wrapper.WrappedPhase0SignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot}})), [32]byte{1})) wsb, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot}}))
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-3, wrapper.WrappedPhase0SignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 3}})), [32]byte{2})) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-5, wrapper.WrappedPhase0SignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 5}})), [32]byte{3})) require.NoError(t, r.insertBlockToPendingQueue(lastSlot, wsb, [32]byte{1}))
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-2, wrapper.WrappedPhase0SignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 2}})), [32]byte{4})) wsb, err = wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 3}}))
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-3, wsb, [32]byte{2}))
wsb, err = wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 5}}))
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-5, wsb, [32]byte{3}))
wsb, err = wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: lastSlot - 2}}))
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(lastSlot-2, wsb, [32]byte{4}))
want := []types.Slot{lastSlot - 5, lastSlot - 3, lastSlot - 2, lastSlot} want := []types.Slot{lastSlot - 5, lastSlot - 3, lastSlot - 2, lastSlot}
assert.DeepEqual(t, want, r.sortedPendingSlots(), "Unexpected pending slots list") assert.DeepEqual(t, want, r.sortedPendingSlots(), "Unexpected pending slots list")
@@ -411,13 +475,17 @@ func TestService_BatchRootRequest(t *testing.T) {
p1.Peers().SetChainState(p2.PeerID(), &ethpb.Status{FinalizedEpoch: 2}) p1.Peers().SetChainState(p2.PeerID(), &ethpb.Status{FinalizedEpoch: 2})
b0 := util.NewBeaconBlock() b0 := util.NewBeaconBlock()
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b0))) wsb, err := wrapper.WrappedSignedBeaconBlock(b0)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b0Root, err := b0.Block.HashTreeRoot() b0Root, err := b0.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
b1 := util.NewBeaconBlock() b1 := util.NewBeaconBlock()
b1.Block.Slot = 1 b1.Block.Slot = 1
b1.Block.ParentRoot = b0Root[:] b1.Block.ParentRoot = b0Root[:]
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b1))) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.cfg.beaconDB.SaveBlock(context.Background(), wsb))
b1Root, err := b1.Block.HashTreeRoot() b1Root, err := b1.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -484,13 +552,21 @@ func TestService_AddPendingBlockToQueueOverMax(t *testing.T) {
b1.Block.StateRoot = []byte{'a'} b1.Block.StateRoot = []byte{'a'}
b2 := ethpb.CopySignedBeaconBlock(b) b2 := ethpb.CopySignedBeaconBlock(b)
b2.Block.StateRoot = []byte{'b'} b2.Block.StateRoot = []byte{'b'}
require.NoError(t, r.insertBlockToPendingQueue(0, wrapper.WrappedPhase0SignedBeaconBlock(b), [32]byte{})) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, r.insertBlockToPendingQueue(0, wrapper.WrappedPhase0SignedBeaconBlock(b1), [32]byte{1})) require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(0, wrapper.WrappedPhase0SignedBeaconBlock(b2), [32]byte{2})) require.NoError(t, r.insertBlockToPendingQueue(0, wsb, [32]byte{}))
wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(0, wsb, [32]byte{1}))
wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(0, wsb, [32]byte{2}))
b3 := ethpb.CopySignedBeaconBlock(b) b3 := ethpb.CopySignedBeaconBlock(b)
b3.Block.StateRoot = []byte{'c'} b3.Block.StateRoot = []byte{'c'}
require.NoError(t, r.insertBlockToPendingQueue(0, wrapper.WrappedPhase0SignedBeaconBlock(b2), [32]byte{3})) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(0, wsb, [32]byte{3}))
require.Equal(t, maxBlocksPerSlot, len(r.pendingBlocksInCache(0))) require.Equal(t, maxBlocksPerSlot, len(r.pendingBlocksInCache(0)))
} }
@@ -517,7 +593,9 @@ func TestService_ProcessPendingBlockOnCorrectSlot(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -554,11 +632,17 @@ func TestService_ProcessPendingBlockOnCorrectSlot(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// Add block1 for slot1 // Add block1 for slot1
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b1), b1Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b1)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b1.Block.Slot, wsb, b1Root))
// Add block2 for slot2 // Add block2 for slot2
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b2), b2Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b2)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b2.Block.Slot, wsb, b2Root))
// Add block3 for slot3 // Add block3 for slot3
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wrapper.WrappedPhase0SignedBeaconBlock(b3), b3Root)) wsb, err = wrapper.WrappedSignedBeaconBlock(b3)
require.NoError(t, err)
require.NoError(t, r.insertBlockToPendingQueue(b3.Block.Slot, wsb, b3Root))
// processPendingBlocks should process only blocks of the current slot. i.e. slot 1. // processPendingBlocks should process only blocks of the current slot. i.e. slot 1.
// Then check if the other two blocks are still in the pendingQueue. // Then check if the other two blocks are still in the pendingQueue.
@@ -589,7 +673,9 @@ func TestService_ProcessBadPendingBlocks(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -616,12 +702,12 @@ func TestService_ProcessBadPendingBlocks(t *testing.T) {
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
b.Block.Slot = 55 b.Block.Slot = 55
b.Block.ParentRoot = []byte{'A', 'B', 'C'} b.Block.ParentRoot = []byte{'A', 'B', 'C'}
bA := wrapper.WrappedPhase0SignedBeaconBlock(b) bA, err := wrapper.WrappedSignedBeaconBlock(b)
assert.NoError(t, err) assert.NoError(t, err)
// Add block1 for slot 55 // Add block1 for slot 55
require.NoError(t, r.insertBlockToPendingQueue(b.Block.Slot, bA, b1Root)) require.NoError(t, r.insertBlockToPendingQueue(b.Block.Slot, bA, b1Root))
bB := wrapper.WrappedPhase0SignedBeaconBlock(util.NewBeaconBlock()) bB, err := wrapper.WrappedSignedBeaconBlock(util.NewBeaconBlock())
assert.NoError(t, err) assert.NoError(t, err)
// remove with a different block from the same slot. // remove with a different block from the same slot.
require.NoError(t, r.deleteBlockFromPendingQueue(b.Block.Slot, bB, b1Root)) require.NoError(t, r.deleteBlockFromPendingQueue(b.Block.Slot, bB, b1Root))

40
beacon-chain/sync/rpc_beacon_blocks_by_range_test.go
View File

@@ -48,7 +48,9 @@ func TestRPCBeaconBlocksByRange_RPCHandlerReturnsBlocks(t *testing.T) {
for i := req.StartSlot; i < req.StartSlot.Add(req.Step*req.Count); i += types.Slot(req.Step) { for i := req.StartSlot; i < req.StartSlot.Add(req.Step*req.Count); i += types.Slot(req.Step) {
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = i blk.Block.Slot = i
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
} }
// Start service with 160 as allowed blocks capacity (and almost zero capacity recovery). // Start service with 160 as allowed blocks capacity (and almost zero capacity recovery).
@@ -109,7 +111,9 @@ func TestRPCBeaconBlocksByRange_ReturnCorrectNumberBack(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
genRoot = rt genRoot = rt
} }
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
} }
require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), genRoot)) require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), genRoot))
@@ -173,7 +177,9 @@ func TestRPCBeaconBlocksByRange_RPCHandlerReturnsSortedBlocks(t *testing.T) {
rt, err := blk.Block.HashTreeRoot() rt, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
expectedRoots[j] = rt expectedRoots[j] = rt
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
j-- j--
} }
@@ -239,7 +245,9 @@ func TestRPCBeaconBlocksByRange_ReturnsGenesisBlock(t *testing.T) {
if i == 0 { if i == 0 {
require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), rt)) require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), rt))
} }
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
prevRoot = rt prevRoot = rt
} }
@@ -284,7 +292,9 @@ func TestRPCBeaconBlocksByRange_RPCHandlerRateLimitOverflow(t *testing.T) {
if req.Step == 1 { if req.Step == 1 {
block.Block.ParentRoot = parentRoot[:] block.Block.ParentRoot = parentRoot[:]
} }
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block))) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
rt, err := block.Block.HashTreeRoot() rt, err := block.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
parentRoot = rt parentRoot = rt
@@ -543,7 +553,9 @@ func TestRPCBeaconBlocksByRange_EnforceResponseInvariants(t *testing.T) {
block := util.NewBeaconBlock() block := util.NewBeaconBlock()
block.Block.Slot = i block.Block.Slot = i
block.Block.ParentRoot = parentRoot[:] block.Block.ParentRoot = parentRoot[:]
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(block))) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
rt, err := block.Block.HashTreeRoot() rt, err := block.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
parentRoot = rt parentRoot = rt
@@ -618,7 +630,9 @@ func TestRPCBeaconBlocksByRange_FilterBlocks(t *testing.T) {
previousRoot, err := blk.Block.HashTreeRoot() previousRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), previousRoot)) require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), previousRoot))
blocks := make([]*ethpb.SignedBeaconBlock, req.Count) blocks := make([]*ethpb.SignedBeaconBlock, req.Count)
// Populate the database with blocks that would match the request. // Populate the database with blocks that would match the request.
@@ -631,7 +645,9 @@ func TestRPCBeaconBlocksByRange_FilterBlocks(t *testing.T) {
var err error var err error
previousRoot, err = blocks[j].Block.HashTreeRoot() previousRoot, err = blocks[j].Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blocks[j]))) wsb, err := wrapper.WrappedSignedBeaconBlock(blocks[j])
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
j++ j++
} }
stateSummaries := make([]*ethpb.StateSummary, len(blocks)) stateSummaries := make([]*ethpb.StateSummary, len(blocks))
@@ -664,7 +680,9 @@ func TestRPCBeaconBlocksByRange_FilterBlocks(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
genRoot := previousRoot genRoot := previousRoot
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), previousRoot)) require.NoError(t, d.SaveGenesisBlockRoot(context.Background(), previousRoot))
blocks := make([]*ethpb.SignedBeaconBlock, req.Count) blocks := make([]*ethpb.SignedBeaconBlock, req.Count)
// Populate the database with blocks with non linear roots. // Populate the database with blocks with non linear roots.
@@ -681,7 +699,9 @@ func TestRPCBeaconBlocksByRange_FilterBlocks(t *testing.T) {
var err error var err error
previousRoot, err = blocks[j].Block.HashTreeRoot() previousRoot, err = blocks[j].Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blocks[j]))) wsb, err := wrapper.WrappedSignedBeaconBlock(blocks[j])
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
j++ j++
} }
stateSummaries := make([]*ethpb.StateSummary, len(blocks)) stateSummaries := make([]*ethpb.StateSummary, len(blocks))

4
beacon-chain/sync/rpc_beacon_blocks_by_root_test.go
View File

@@ -39,7 +39,9 @@ func TestRecentBeaconBlocksRPCHandler_ReturnsBlocks(t *testing.T) {
blk.Block.Slot = i blk.Block.Slot = i
root, err := blk.Block.HashTreeRoot() root, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, d.SaveBlock(context.Background(), wsb))
blkRoots = append(blkRoots, root) blkRoots = append(blkRoots, root)
} }

17
beacon-chain/sync/rpc_chunked_response_test.go
View File

@@ -39,7 +39,12 @@ func TestExtractBlockDataType(t *testing.T) {
digest: []byte{}, digest: []byte{},
chain: &mock.ChainService{ValidatorsRoot: [32]byte{}}, chain: &mock.ChainService{ValidatorsRoot: [32]byte{}},
}, },
want: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{}),
want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
require.NoError(t, err)
return wsb
}(),
wantErr: false, wantErr: false,
}, },
{ {
@@ -66,7 +71,11 @@ func TestExtractBlockDataType(t *testing.T) {
digest: genDigest[:], digest: genDigest[:],
chain: &mock.ChainService{ValidatorsRoot: [32]byte{}}, chain: &mock.ChainService{ValidatorsRoot: [32]byte{}},
}, },
want: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{}), want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
require.NoError(t, err)
return wsb
}(),
wantErr: false, wantErr: false,
}, },
{ {
@@ -76,7 +85,7 @@ func TestExtractBlockDataType(t *testing.T) {
chain: &mock.ChainService{ValidatorsRoot: [32]byte{}}, chain: &mock.ChainService{ValidatorsRoot: [32]byte{}},
}, },
want: func() block.SignedBeaconBlock { want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
require.NoError(t, err) require.NoError(t, err)
return wsb return wsb
}(), }(),
@@ -89,7 +98,7 @@ func TestExtractBlockDataType(t *testing.T) {
chain: &mock.ChainService{ValidatorsRoot: [32]byte{}}, chain: &mock.ChainService{ValidatorsRoot: [32]byte{}},
}, },
want: func() block.SignedBeaconBlock { want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
require.NoError(t, err) require.NoError(t, err)
return wsb return wsb
}(), }(),

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

@@ -66,7 +66,9 @@ func TestSendRequest_SendBeaconBlocksByRangeRequest(t *testing.T) {
for i := req.StartSlot; i < req.StartSlot.Add(req.Count*req.Step); i += types.Slot(req.Step) { for i := req.StartSlot; i < req.StartSlot.Add(req.Count*req.Step); i += types.Slot(req.Step) {
if processor != nil { if processor != nil {
if processorErr := processor(wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[i])); processorErr != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[i])
require.NoError(t, err)
if processorErr := processor(wsb); processorErr != nil {
if errors.Is(processorErr, io.EOF) { if errors.Is(processorErr, io.EOF) {
// Close stream, w/o any errors written. // Close stream, w/o any errors written.
return return
@@ -83,7 +85,9 @@ func TestSendRequest_SendBeaconBlocksByRangeRequest(t *testing.T) {
break break
} }
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
err = WriteBlockChunk(stream, chain, p2pProvider.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[i])) wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[i])
require.NoError(t, err)
err = WriteBlockChunk(stream, chain, p2pProvider.Encoding(), wsb)
if err != nil && err.Error() != mux.ErrReset.Error() { if err != nil && err.Error() != mux.ErrReset.Error() {
require.NoError(t, err) require.NoError(t, err)
} }
@@ -236,7 +240,8 @@ func TestSendRequest_SendBeaconBlocksByRangeRequest(t *testing.T) {
break break
} }
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
err = WriteBlockChunk(stream, chain, p2.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[i])) wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[i])
err = WriteBlockChunk(stream, chain, p2.Encoding(), wsb)
if err != nil && err.Error() != mux.ErrReset.Error() { if err != nil && err.Error() != mux.ErrReset.Error() {
require.NoError(t, err) require.NoError(t, err)
} }
@@ -279,7 +284,9 @@ func TestSendRequest_SendBeaconBlocksByRangeRequest(t *testing.T) {
break break
} }
chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}} chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
err = WriteBlockChunk(stream, chain, p2.Encoding(), wrapper.WrappedPhase0SignedBeaconBlock(knownBlocks[i])) wsb, err := wrapper.WrappedSignedBeaconBlock(knownBlocks[i])
require.NoError(t, err)
err = WriteBlockChunk(stream, chain, p2.Encoding(), wsb)
if err != nil && err.Error() != mux.ErrReset.Error() { if err != nil && err.Error() != mux.ErrReset.Error() {
require.NoError(t, err) require.NoError(t, err)
} }
@@ -340,7 +347,9 @@ func TestSendRequest_SendBeaconBlocksByRootRequest(t *testing.T) {
for _, root := range *req { for _, root := range *req {
if blk, ok := knownBlocks[root]; ok { if blk, ok := knownBlocks[root]; ok {
if processor != nil { if processor != nil {
if processorErr := processor(wrapper.WrappedPhase0SignedBeaconBlock(blk)); processorErr != nil { wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
if processorErr := processor(wsb); processorErr != nil {
if errors.Is(processorErr, io.EOF) { if errors.Is(processorErr, io.EOF) {
// Close stream, w/o any errors written. // Close stream, w/o any errors written.
return return

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

@@ -177,7 +177,9 @@ func TestStatusRPCHandler_ReturnsHelloMessage(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, genesisState.SetSlot(111)) require.NoError(t, genesisState.SetSlot(111))
require.NoError(t, genesisState.UpdateBlockRootAtIndex(111%uint64(params.BeaconConfig().SlotsPerHistoricalRoot), headRoot)) require.NoError(t, genesisState.UpdateBlockRootAtIndex(111%uint64(params.BeaconConfig().SlotsPerHistoricalRoot), headRoot))
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(finalized))) wsb, err := wrapper.WrappedSignedBeaconBlock(finalized)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot))
finalizedCheckpt := &ethpb.Checkpoint{ finalizedCheckpt := &ethpb.Checkpoint{
Epoch: 3, Epoch: 3,
@@ -267,7 +269,9 @@ func TestHandshakeHandlers_Roundtrip(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = 0 blk.Block.Slot = 0
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
finalizedRoot, err := blk.Block.HashTreeRoot() finalizedRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot))
@@ -479,7 +483,9 @@ func TestStatusRPCRequest_FinalizedBlockExists(t *testing.T) {
require.NoError(t, genesisState.UpdateBlockRootAtIndex(111%uint64(params.BeaconConfig().SlotsPerHistoricalRoot), headRoot)) require.NoError(t, genesisState.UpdateBlockRootAtIndex(111%uint64(params.BeaconConfig().SlotsPerHistoricalRoot), headRoot))
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = blkSlot blk.Block.Slot = blkSlot
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), finalizedRoot))
finalizedCheckpt := &ethpb.Checkpoint{ finalizedCheckpt := &ethpb.Checkpoint{
Epoch: 3, Epoch: 3,
@@ -560,7 +566,9 @@ func TestStatusRPCRequest_FinalizedBlockSkippedSlots(t *testing.T) {
genRoot, err := blk.Block.HashTreeRoot() genRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genRoot)) require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genRoot))
blocksTillHead := makeBlocks(t, 1, 1000, genRoot) blocksTillHead := makeBlocks(t, 1, 1000, genRoot)
require.NoError(t, db.SaveBlocks(context.Background(), blocksTillHead)) require.NoError(t, db.SaveBlocks(context.Background(), blocksTillHead))
@@ -939,7 +947,8 @@ func makeBlocks(t *testing.T, i, n uint64, previousRoot [32]byte) []block.Signed
var err error var err error
previousRoot, err = blocks[j-i].Block.HashTreeRoot() previousRoot, err = blocks[j-i].Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
ifaceBlocks[j-i] = wrapper.WrappedPhase0SignedBeaconBlock(blocks[j-i]) ifaceBlocks[j-i], err = wrapper.WrappedSignedBeaconBlock(blocks[j-i])
require.NoError(t, err)
} }
return ifaceBlocks return ifaceBlocks
} }

17
beacon-chain/sync/subscriber_beacon_blocks.go
View File

@@ -3,18 +3,16 @@ package sync
import ( import (
"context" "context"
"github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers" "github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/transition/interop" "github.com/prysmaticlabs/prysm/beacon-chain/core/transition/interop"
"github.com/prysmaticlabs/prysm/config/features" "github.com/prysmaticlabs/prysm/config/features"
ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper" "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
"google.golang.org/protobuf/proto" "google.golang.org/protobuf/proto"
) )
func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message) error { func (s *Service) beaconBlockSubscriber(ctx context.Context, msg proto.Message) error {
signed, err := blockFromProto(msg) signed, err := wrapper.WrappedSignedBeaconBlock(msg)
if err != nil { if err != nil {
return err return err
} }
@@ -64,16 +62,3 @@ func (s *Service) deleteAttsInPool(atts []*ethpb.Attestation) error {
} }
return nil return nil
} }
func blockFromProto(msg proto.Message) (block.SignedBeaconBlock, error) {
switch t := msg.(type) {
case *ethpb.SignedBeaconBlock:
return wrapper.WrappedPhase0SignedBeaconBlock(t), nil
case *ethpb.SignedBeaconBlockAltair:
return wrapper.WrappedAltairSignedBeaconBlock(t)
case *ethpb.SignedBeaconBlockBellatrix:
return wrapper.WrappedBellatrixSignedBeaconBlock(t)
default:
return nil, errors.Errorf("message has invalid underlying type: %T", msg)
}
}

65
beacon-chain/sync/subscriber_beacon_blocks_test.go
View File

@@ -2,7 +2,6 @@ package sync
import ( import (
"context" "context"
"reflect"
"testing" "testing"
"github.com/prysmaticlabs/go-bitfield" "github.com/prysmaticlabs/go-bitfield"
@@ -11,8 +10,6 @@ import (
dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing" dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations" "github.com/prysmaticlabs/prysm/beacon-chain/operations/attestations"
ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1" ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/block"
"github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1/wrapper"
"github.com/prysmaticlabs/prysm/testing/assert" "github.com/prysmaticlabs/prysm/testing/assert"
"github.com/prysmaticlabs/prysm/testing/require" "github.com/prysmaticlabs/prysm/testing/require"
"github.com/prysmaticlabs/prysm/testing/util" "github.com/prysmaticlabs/prysm/testing/util"
@@ -111,65 +108,3 @@ func TestService_beaconBlockSubscriber(t *testing.T) {
}) })
} }
} }
func TestBlockFromProto(t *testing.T) {
tests := []struct {
name string
msgCreator func(t *testing.T) proto.Message
want block.SignedBeaconBlock
wantErr bool
}{
{
name: "invalid type provided",
msgCreator: func(t *testing.T) proto.Message {
return &ethpb.SignedAggregateAttestationAndProof{}
},
want: nil,
wantErr: true,
},
{
name: "phase 0 type provided",
msgCreator: func(t *testing.T) proto.Message {
return &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 100}}
},
want: wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 100}}),
wantErr: false,
},
{
name: "altair type provided",
msgCreator: func(t *testing.T) proto.Message {
return &ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{Slot: 100}}
},
want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{Slot: 100}})
require.NoError(t, err)
return wsb
}(),
wantErr: false,
},
{
name: "bellatrix type provided",
msgCreator: func(t *testing.T) proto.Message {
return &ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{Slot: 100}}
},
want: func() block.SignedBeaconBlock {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{Slot: 100}})
require.NoError(t, err)
return wsb
}(),
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := blockFromProto(tt.msgCreator(t))
if (err != nil) != tt.wantErr {
t.Errorf("blockFromProto() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("blockFromProto() got = %v, want %v", got, tt.want)
}
})
}
}

7
beacon-chain/sync/utils_test.go
View File

@@ -23,7 +23,8 @@ func TestSortedObj_SortBlocksRoots(t *testing.T) {
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
slot := types.Slot(randFunc()) slot := types.Slot(randFunc())
newBlk := wrapper.WrappedPhase0SignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}}) newBlk, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}})
require.NoError(t, err)
blks = append(blks, newBlk) blks = append(blks, newBlk)
root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot))) root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))
roots = append(roots, root) roots = append(roots, root)
@@ -58,7 +59,9 @@ func TestSortedObj_NoDuplicates(t *testing.T) {
slot := types.Slot(randFunc()) slot := types.Slot(randFunc())
newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}} newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}}
// append twice // append twice
blks = append(blks, wrapper.WrappedPhase0SignedBeaconBlock(newBlk), wrapper.WrappedPhase0SignedBeaconBlock(newBlk)) wsb, err := wrapper.WrappedSignedBeaconBlock(newBlk)
require.NoError(t, err)
blks = append(blks, wsb, wsb.Copy())
// append twice // append twice
root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot))) root := bytesutil.ToBytes32(bytesutil.Bytes32(uint64(slot)))

20
beacon-chain/sync/validate_aggregate_proof_test.go
View File

@@ -153,7 +153,9 @@ func TestValidateAggregateAndProof_NotWithinSlotRange(t *testing.T) {
beaconState, _ := util.DeterministicGenesisState(t, validators) beaconState, _ := util.DeterministicGenesisState(t, validators)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
@@ -240,7 +242,9 @@ func TestValidateAggregateAndProof_ExistedInPool(t *testing.T) {
beaconState, _ := util.DeterministicGenesisState(t, validators) beaconState, _ := util.DeterministicGenesisState(t, validators)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -306,7 +310,9 @@ func TestValidateAggregateAndProof_CanValidate(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, validators) beaconState, privKeys := util.DeterministicGenesisState(t, validators)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
@@ -401,7 +407,9 @@ func TestVerifyIndexInCommittee_SeenAggregatorEpoch(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, validators) beaconState, privKeys := util.DeterministicGenesisState(t, validators)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
s, err := util.NewBeaconState() s, err := util.NewBeaconState()
@@ -605,7 +613,9 @@ func TestValidateAggregateAndProof_RejectWhenAttEpochDoesntEqualTargetEpoch(t *t
beaconState, privKeys := util.DeterministicGenesisState(t, validators) beaconState, privKeys := util.DeterministicGenesisState(t, validators)
b := util.NewBeaconBlock() b := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(b))) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
root, err := b.Block.HashTreeRoot() root, err := b.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
s, err := util.NewBeaconState() s, err := util.NewBeaconState()

4
beacon-chain/sync/validate_beacon_attestation_test.go
View File

@@ -61,7 +61,9 @@ func TestService_validateCommitteeIndexBeaconAttestation(t *testing.T) {
blk := util.NewBeaconBlock() blk := util.NewBeaconBlock()
blk.Block.Slot = 1 blk.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(blk))) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
validBlockRoot, err := blk.Block.HashTreeRoot() validBlockRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)

56
beacon-chain/sync/validate_beacon_blocks_test.go
View File

@@ -48,7 +48,9 @@ func TestValidateBeaconBlockPubSub_InvalidSignature(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, _ := util.DeterministicGenesisState(t, 100) beaconState, _ := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -106,7 +108,9 @@ func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInDB(t *testing.T) {
msg := util.NewBeaconBlock() msg := util.NewBeaconBlock()
msg.Block.Slot = 100 msg.Block.Slot = 100
msg.Block.ParentRoot = util.Random32Bytes(t) msg.Block.ParentRoot = util.Random32Bytes(t)
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(msg))) wsb, err := wrapper.WrappedSignedBeaconBlock(msg)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
chainService := &mock.ChainService{Genesis: time.Now()} chainService := &mock.ChainService{Genesis: time.Now()}
r := &Service{ r := &Service{
@@ -122,7 +126,7 @@ func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInDB(t *testing.T) {
} }
buf := new(bytes.Buffer) buf := new(bytes.Buffer)
_, err := p.Encoding().EncodeGossip(buf, msg) _, err = p.Encoding().EncodeGossip(buf, msg)
require.NoError(t, err) require.NoError(t, err)
topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)] topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
@@ -144,7 +148,9 @@ func TestValidateBeaconBlockPubSub_CanRecoverStateSummary(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -271,7 +277,9 @@ func TestValidateBeaconBlockPubSub_ValidProposerSignature(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -335,7 +343,9 @@ func TestValidateBeaconBlockPubSub_WithLookahead(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -402,7 +412,9 @@ func TestValidateBeaconBlockPubSub_AdvanceEpochsForState(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -511,7 +523,9 @@ func TestValidateBeaconBlockPubSub_AcceptBlocksFromNearFuture(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -671,7 +685,9 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -730,7 +746,9 @@ func TestValidateBeaconBlockPubSub_FilterByFinalizedEpoch(t *testing.T) {
p := p2ptest.NewTestP2P(t) p := p2ptest.NewTestP2P(t)
parent := util.NewBeaconBlock() parent := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(context.Background(), wrapper.WrappedPhase0SignedBeaconBlock(parent))) wsb, err := wrapper.WrappedSignedBeaconBlock(parent)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), wsb))
parentRoot, err := parent.Block.HashTreeRoot() parentRoot, err := parent.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
chain := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0), chain := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
@@ -796,7 +814,9 @@ func TestValidateBeaconBlockPubSub_ParentNotFinalizedDescendant(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -859,7 +879,9 @@ func TestValidateBeaconBlockPubSub_InvalidParentBlock(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -948,7 +970,9 @@ func TestValidateBeaconBlockPubSub_RejectEvilBlocksFromFuture(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisState(t, 100) beaconState, privKeys := util.DeterministicGenesisState(t, 100)
parentBlock := util.NewBeaconBlock() parentBlock := util.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, wrapper.WrappedPhase0SignedBeaconBlock(parentBlock))) wsb, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, wsb))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveState(ctx, beaconState, bRoot)) require.NoError(t, db.SaveState(ctx, beaconState, bRoot))
@@ -1053,7 +1077,7 @@ func TestValidateBeaconBlockPubSub_ValidExecutionPayload(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100) beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
parentBlock := util.NewBeaconBlockBellatrix() parentBlock := util.NewBeaconBlockBellatrix()
signedParentBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(parentBlock) signedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, signedParentBlock)) require.NoError(t, db.SaveBlock(ctx, signedParentBlock))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
@@ -1127,7 +1151,7 @@ func TestValidateBeaconBlockPubSub_InvalidPayloadTimestamp(t *testing.T) {
ctx := context.Background() ctx := context.Background()
beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100) beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
parentBlock := util.NewBeaconBlockBellatrix() parentBlock := util.NewBeaconBlockBellatrix()
signedParentBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(parentBlock) signedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, signedParentBlock)) require.NoError(t, db.SaveBlock(ctx, signedParentBlock))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()
@@ -1232,7 +1256,7 @@ func Test_validateBellatrixBeaconBlockParentValidation(t *testing.T) {
beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100) beaconState, privKeys := util.DeterministicGenesisStateBellatrix(t, 100)
parentBlock := util.NewBeaconBlockBellatrix() parentBlock := util.NewBeaconBlockBellatrix()
signedParentBlock, err := wrapper.WrappedBellatrixSignedBeaconBlock(parentBlock) signedParentBlock, err := wrapper.WrappedSignedBeaconBlock(parentBlock)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, signedParentBlock)) require.NoError(t, db.SaveBlock(ctx, signedParentBlock))
bRoot, err := parentBlock.Block.HashTreeRoot() bRoot, err := parentBlock.Block.HashTreeRoot()

2
beacon-chain/sync/validate_sync_contribution_proof_test.go
View File

@@ -1073,7 +1073,7 @@ func fillUpBlocksAndState(ctx context.Context, t *testing.T, beaconDB db.Databas
require.NoError(t, err) require.NoError(t, err)
r, err := blk.Block.HashTreeRoot() r, err := blk.Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(blk) wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
require.NoError(t, err) require.NoError(t, err)
_, testState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, testState, wsb) _, testState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, testState, wsb)
assert.NoError(t, err) assert.NoError(t, err)

8
proto/migration/v1alpha1_to_v1_test.go
View File

@@ -55,7 +55,9 @@ func Test_BlockIfaceToV1BlockHeader(t *testing.T) {
alphaBlock.Block.StateRoot = stateRoot alphaBlock.Block.StateRoot = stateRoot
alphaBlock.Signature = signature alphaBlock.Signature = signature
v1Header, err := BlockIfaceToV1BlockHeader(wrapper.WrappedPhase0SignedBeaconBlock(alphaBlock)) wsb, err := wrapper.WrappedSignedBeaconBlock(alphaBlock)
require.NoError(t, err)
v1Header, err := BlockIfaceToV1BlockHeader(wsb)
require.NoError(t, err) require.NoError(t, err)
bodyRoot, err := alphaBlock.Block.Body.HashTreeRoot() bodyRoot, err := alphaBlock.Block.Body.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)
@@ -362,7 +364,9 @@ func Test_BlockInterfaceToV1Block(t *testing.T) {
} }
v1Alpha1Block.Signature = signature v1Alpha1Block.Signature = signature
v1Block, err := SignedBeaconBlock(wrapper.WrappedPhase0SignedBeaconBlock(v1Alpha1Block)) wsb, err := wrapper.WrappedSignedBeaconBlock(v1Alpha1Block)
require.NoError(t, err)
v1Block, err := SignedBeaconBlock(wsb)
require.NoError(t, err) require.NoError(t, err)
v1Root, err := v1Block.HashTreeRoot() v1Root, err := v1Block.HashTreeRoot()
require.NoError(t, err) require.NoError(t, err)

5
proto/prysm/v1alpha1/block/block_utils_test.go
View File

@@ -174,8 +174,9 @@ func TestSignedBeaconBlockHeaderFromBlockInterface(t *testing.T) {
}, },
Signature: blk.Signature, Signature: blk.Signature,
} }
wsb, err := wrapper.WrappedSignedBeaconBlock(blk)
bh, err := block.SignedBeaconBlockHeaderFromBlockInterface(wrapper.WrappedPhase0SignedBeaconBlock(blk)) require.NoError(t, err)
bh, err := block.SignedBeaconBlockHeaderFromBlockInterface(wsb)
require.NoError(t, err) require.NoError(t, err)
assert.DeepEqual(t, want, bh) assert.DeepEqual(t, want, bh)
} }

14
proto/prysm/v1alpha1/wrapper/beacon_block.go
View File

@@ -30,12 +30,20 @@ var (
// signed beacon block interface. // signed beacon block interface.
func WrappedSignedBeaconBlock(i interface{}) (block.SignedBeaconBlock, error) { func WrappedSignedBeaconBlock(i interface{}) (block.SignedBeaconBlock, error) {
switch b := i.(type) { switch b := i.(type) {
case *eth.GenericSignedBeaconBlock_Phase0:
return wrappedPhase0SignedBeaconBlock(b.Phase0), nil
case *eth.SignedBeaconBlock: case *eth.SignedBeaconBlock:
return WrappedPhase0SignedBeaconBlock(b), nil return wrappedPhase0SignedBeaconBlock(b), nil
case *eth.GenericSignedBeaconBlock_Altair:
return wrappedAltairSignedBeaconBlock(b.Altair)
case *eth.SignedBeaconBlockAltair: case *eth.SignedBeaconBlockAltair:
return WrappedAltairSignedBeaconBlock(b) return wrappedAltairSignedBeaconBlock(b)
case *eth.GenericSignedBeaconBlock_Bellatrix:
return wrappedBellatrixSignedBeaconBlock(b.Bellatrix)
case *eth.SignedBeaconBlockBellatrix: case *eth.SignedBeaconBlockBellatrix:
return WrappedBellatrixSignedBeaconBlock(b) return wrappedBellatrixSignedBeaconBlock(b)
case nil:
return nil, ErrNilObjectWrapped
default: default:
return nil, errors.Wrapf(ErrUnsupportedSignedBeaconBlock, "unable to wrap block of type %T", i) return nil, errors.Wrapf(ErrUnsupportedSignedBeaconBlock, "unable to wrap block of type %T", i)
} }

5
proto/prysm/v1alpha1/wrapper/beacon_block_altair.go
View File

@@ -25,10 +25,9 @@ type altairSignedBeaconBlock struct {
b *eth.SignedBeaconBlockAltair b *eth.SignedBeaconBlockAltair
} }
// WrappedAltairSignedBeaconBlock is constructor which wraps a protobuf altair block // wrappedAltairSignedBeaconBlock is constructor which wraps a protobuf altair block
// with the block wrapper. // with the block wrapper.
// Deprecated: use WrappedSignedBeaconBlock instead. func wrappedAltairSignedBeaconBlock(b *eth.SignedBeaconBlockAltair) (block.SignedBeaconBlock, error) {
func WrappedAltairSignedBeaconBlock(b *eth.SignedBeaconBlockAltair) (block.SignedBeaconBlock, error) {
w := altairSignedBeaconBlock{b: b} w := altairSignedBeaconBlock{b: b}
if w.IsNil() { if w.IsNil() {
return nil, ErrNilObjectWrapped return nil, ErrNilObjectWrapped

20
proto/prysm/v1alpha1/wrapper/beacon_block_altair_test.go
View File

@@ -16,7 +16,7 @@ import (
func TestAltairSignedBeaconBlock_Signature(t *testing.T) { func TestAltairSignedBeaconBlock_Signature(t *testing.T) {
sig := []byte{0x11, 0x22} sig := []byte{0x11, 0x22}
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}, Signature: sig}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}, Signature: sig})
require.NoError(t, err) require.NoError(t, err)
if !bytes.Equal(sig, wsb.Signature()) { if !bytes.Equal(sig, wsb.Signature()) {
@@ -26,17 +26,17 @@ func TestAltairSignedBeaconBlock_Signature(t *testing.T) {
func TestAltairSignedBeaconBlock_Block(t *testing.T) { func TestAltairSignedBeaconBlock_Block(t *testing.T) {
blk := &ethpb.BeaconBlockAltair{Slot: 54} blk := &ethpb.BeaconBlockAltair{Slot: 54}
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: blk}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: blk})
require.NoError(t, err) require.NoError(t, err)
assert.DeepEqual(t, blk, wsb.Block().Proto()) assert.DeepEqual(t, blk, wsb.Block().Proto())
} }
func TestAltairSignedBeaconBlock_IsNil(t *testing.T) { func TestAltairSignedBeaconBlock_IsNil(t *testing.T) {
_, err := wrapper.WrappedAltairSignedBeaconBlock(nil) _, err := wrapper.WrappedSignedBeaconBlock(nil)
require.Equal(t, wrapper.ErrNilObjectWrapped, err) require.Equal(t, wrapper.ErrNilObjectWrapped, err)
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, false, wsb.IsNil()) assert.Equal(t, false, wsb.IsNil())
@@ -51,14 +51,14 @@ func TestAltairSignedBeaconBlock_Proto(t *testing.T) {
Block: &ethpb.BeaconBlockAltair{Slot: 66}, Block: &ethpb.BeaconBlockAltair{Slot: 66},
Signature: []byte{0x11, 0x22}, Signature: []byte{0x11, 0x22},
} }
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(sb) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, sb, wsb.Proto()) assert.Equal(t, sb, wsb.Proto())
} }
func TestAltairSignedBeaconBlock_PbPhase0Block(t *testing.T) { func TestAltairSignedBeaconBlock_PbPhase0Block(t *testing.T) {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
require.NoError(t, err) require.NoError(t, err)
if _, err := wsb.PbPhase0Block(); err != wrapper.ErrUnsupportedPhase0Block { if _, err := wsb.PbPhase0Block(); err != wrapper.ErrUnsupportedPhase0Block {
@@ -71,7 +71,7 @@ func TestAltairSignedBeaconBlock_PbAltairBlock(t *testing.T) {
Block: &ethpb.BeaconBlockAltair{Slot: 66}, Block: &ethpb.BeaconBlockAltair{Slot: 66},
Signature: []byte{0x11, 0x22}, Signature: []byte{0x11, 0x22},
} }
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(sb) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err) require.NoError(t, err)
got, err := wsb.PbAltairBlock() got, err := wsb.PbAltairBlock()
@@ -80,7 +80,7 @@ func TestAltairSignedBeaconBlock_PbAltairBlock(t *testing.T) {
} }
func TestAltairSignedBeaconBlock_MarshalSSZTo(t *testing.T) { func TestAltairSignedBeaconBlock_MarshalSSZTo(t *testing.T) {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(util.HydrateSignedBeaconBlockAltair(&ethpb.SignedBeaconBlockAltair{})) wsb, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockAltair(&ethpb.SignedBeaconBlockAltair{}))
assert.NoError(t, err) assert.NoError(t, err)
var b []byte var b []byte
@@ -90,7 +90,7 @@ func TestAltairSignedBeaconBlock_MarshalSSZTo(t *testing.T) {
} }
func TestAltairSignedBeaconBlock_SSZ(t *testing.T) { func TestAltairSignedBeaconBlock_SSZ(t *testing.T) {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(util.HydrateSignedBeaconBlockAltair(&ethpb.SignedBeaconBlockAltair{})) wsb, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockAltair(&ethpb.SignedBeaconBlockAltair{}))
assert.NoError(t, err) assert.NoError(t, err)
b, err := wsb.MarshalSSZ() b, err := wsb.MarshalSSZ()
@@ -103,7 +103,7 @@ func TestAltairSignedBeaconBlock_SSZ(t *testing.T) {
} }
func TestAltairSignedBeaconBlock_Version(t *testing.T) { func TestAltairSignedBeaconBlock_Version(t *testing.T) {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, version.Altair, wsb.Version()) assert.Equal(t, version.Altair, wsb.Version())

5
proto/prysm/v1alpha1/wrapper/beacon_block_bellatrix.go
View File

@@ -25,9 +25,8 @@ type bellatrixSignedBeaconBlock struct {
b *eth.SignedBeaconBlockBellatrix b *eth.SignedBeaconBlockBellatrix
} }
// WrappedBellatrixSignedBeaconBlock is constructor which wraps a protobuf Bellatrix block with the block wrapper. // wrappedBellatrixSignedBeaconBlock is constructor which wraps a protobuf Bellatrix block with the block wrapper.
// Deprecated: use WrappedSignedBeaconBlock instead. func wrappedBellatrixSignedBeaconBlock(b *eth.SignedBeaconBlockBellatrix) (block.SignedBeaconBlock, error) {
func WrappedBellatrixSignedBeaconBlock(b *eth.SignedBeaconBlockBellatrix) (block.SignedBeaconBlock, error) {
w := bellatrixSignedBeaconBlock{b: b} w := bellatrixSignedBeaconBlock{b: b}
if w.IsNil() { if w.IsNil() {
return nil, ErrNilObjectWrapped return nil, ErrNilObjectWrapped

22
proto/prysm/v1alpha1/wrapper/beacon_block_bellatrix_test.go
View File

@@ -33,7 +33,7 @@ func TestBellatrixSignedBeaconBlock_Header(t *testing.T) {
}, },
Signature: signature, Signature: signature,
} }
wrapped, err := wrapper.WrappedBellatrixSignedBeaconBlock(block) wrapped, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
header, err := wrapped.Header() header, err := wrapped.Header()
@@ -48,7 +48,7 @@ func TestBellatrixSignedBeaconBlock_Header(t *testing.T) {
func TestBellatrixSignedBeaconBlock_Signature(t *testing.T) { func TestBellatrixSignedBeaconBlock_Signature(t *testing.T) {
sig := []byte{0x11, 0x22} sig := []byte{0x11, 0x22}
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}, Signature: sig}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}, Signature: sig})
require.NoError(t, err) require.NoError(t, err)
if !bytes.Equal(sig, wsb.Signature()) { if !bytes.Equal(sig, wsb.Signature()) {
@@ -58,17 +58,17 @@ func TestBellatrixSignedBeaconBlock_Signature(t *testing.T) {
func TestBellatrixSignedBeaconBlock_Block(t *testing.T) { func TestBellatrixSignedBeaconBlock_Block(t *testing.T) {
blk := &ethpb.BeaconBlockBellatrix{Slot: 54} blk := &ethpb.BeaconBlockBellatrix{Slot: 54}
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: blk}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: blk})
require.NoError(t, err) require.NoError(t, err)
assert.DeepEqual(t, blk, wsb.Block().Proto()) assert.DeepEqual(t, blk, wsb.Block().Proto())
} }
func TestBellatrixSignedBeaconBlock_IsNil(t *testing.T) { func TestBellatrixSignedBeaconBlock_IsNil(t *testing.T) {
_, err := wrapper.WrappedBellatrixSignedBeaconBlock(nil) _, err := wrapper.WrappedSignedBeaconBlock(nil)
require.Equal(t, wrapper.ErrNilObjectWrapped, err) require.Equal(t, wrapper.ErrNilObjectWrapped, err)
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, false, wsb.IsNil()) assert.Equal(t, false, wsb.IsNil())
@@ -83,14 +83,14 @@ func TestBellatrixSignedBeaconBlock_Proto(t *testing.T) {
Block: &ethpb.BeaconBlockBellatrix{Slot: 66}, Block: &ethpb.BeaconBlockBellatrix{Slot: 66},
Signature: []byte{0x11, 0x22}, Signature: []byte{0x11, 0x22},
} }
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(sb) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, sb, wsb.Proto()) assert.Equal(t, sb, wsb.Proto())
} }
func TestBellatrixSignedBeaconBlock_PbPhase0Block(t *testing.T) { func TestBellatrixSignedBeaconBlock_PbPhase0Block(t *testing.T) {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
require.NoError(t, err) require.NoError(t, err)
if _, err := wsb.PbPhase0Block(); err != wrapper.ErrUnsupportedPhase0Block { if _, err := wsb.PbPhase0Block(); err != wrapper.ErrUnsupportedPhase0Block {
@@ -103,7 +103,7 @@ func TestBellatrixSignedBeaconBlock_PbBellatrixBlock(t *testing.T) {
Block: &ethpb.BeaconBlockBellatrix{Slot: 66}, Block: &ethpb.BeaconBlockBellatrix{Slot: 66},
Signature: []byte{0x11, 0x22}, Signature: []byte{0x11, 0x22},
} }
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(sb) wsb, err := wrapper.WrappedSignedBeaconBlock(sb)
require.NoError(t, err) require.NoError(t, err)
got, err := wsb.PbBellatrixBlock() got, err := wsb.PbBellatrixBlock()
@@ -112,7 +112,7 @@ func TestBellatrixSignedBeaconBlock_PbBellatrixBlock(t *testing.T) {
} }
func TestBellatrixSignedBeaconBlock_MarshalSSZTo(t *testing.T) { func TestBellatrixSignedBeaconBlock_MarshalSSZTo(t *testing.T) {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&ethpb.SignedBeaconBlockBellatrix{})) wsb, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&ethpb.SignedBeaconBlockBellatrix{}))
assert.NoError(t, err) assert.NoError(t, err)
var b []byte var b []byte
@@ -122,7 +122,7 @@ func TestBellatrixSignedBeaconBlock_MarshalSSZTo(t *testing.T) {
} }
func TestBellatrixSignedBeaconBlock_SSZ(t *testing.T) { func TestBellatrixSignedBeaconBlock_SSZ(t *testing.T) {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&ethpb.SignedBeaconBlockBellatrix{})) wsb, err := wrapper.WrappedSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&ethpb.SignedBeaconBlockBellatrix{}))
assert.NoError(t, err) assert.NoError(t, err)
b, err := wsb.MarshalSSZ() b, err := wsb.MarshalSSZ()
@@ -135,7 +135,7 @@ func TestBellatrixSignedBeaconBlock_SSZ(t *testing.T) {
} }
func TestBellatrixSignedBeaconBlock_Version(t *testing.T) { func TestBellatrixSignedBeaconBlock_Version(t *testing.T) {
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}}) wsb, err := wrapper.WrappedSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{}})
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, version.Bellatrix, wsb.Version()) assert.Equal(t, version.Bellatrix, wsb.Version())

7
proto/prysm/v1alpha1/wrapper/beacon_block_phase0.go
View File

@@ -25,10 +25,9 @@ type Phase0SignedBeaconBlock struct {
b *eth.SignedBeaconBlock b *eth.SignedBeaconBlock
} }
// WrappedPhase0SignedBeaconBlock is constructor which wraps a protobuf phase 0 block // wrappedPhase0SignedBeaconBlock is constructor which wraps a protobuf phase 0 block
// with the block wrapper. // with the block wrapper.
// Deprecated: use WrappedSignedBeaconBlock instead. func wrappedPhase0SignedBeaconBlock(b *eth.SignedBeaconBlock) block.SignedBeaconBlock {
func WrappedPhase0SignedBeaconBlock(b *eth.SignedBeaconBlock) block.SignedBeaconBlock {
return Phase0SignedBeaconBlock{b: b} return Phase0SignedBeaconBlock{b: b}
} }
@@ -51,7 +50,7 @@ func (w Phase0SignedBeaconBlock) IsNil() bool {
// Copy performs a deep copy of the signed beacon block // Copy performs a deep copy of the signed beacon block
// object. // object.
func (w Phase0SignedBeaconBlock) Copy() block.SignedBeaconBlock { func (w Phase0SignedBeaconBlock) Copy() block.SignedBeaconBlock {
return WrappedPhase0SignedBeaconBlock(eth.CopySignedBeaconBlock(w.b)) return wrappedPhase0SignedBeaconBlock(eth.CopySignedBeaconBlock(w.b))
} }
// MarshalSSZ marshals the signed beacon block to its relevant ssz // MarshalSSZ marshals the signed beacon block to its relevant ssz

2
proto/prysm/v1alpha1/wrapper/beacon_block_phase0_test.go
View File

@@ -30,7 +30,7 @@ func TestPhase0SignedBeaconBlock_Header(t *testing.T) {
}, },
Signature: signature, Signature: signature,
} }
wrapped := wrapper.WrappedPhase0SignedBeaconBlock(block) wrapped, _ := wrapper.WrappedSignedBeaconBlock(block)
header, err := wrapped.Header() header, err := wrapped.Header()
require.NoError(t, err) require.NoError(t, err)

2
testing/endtoend/evaluators/fork.go
View File

@@ -50,7 +50,7 @@ func forkOccurs(conns ...*grpc.ClientConn) error {
if res.GetPhase0Block() != nil { if res.GetPhase0Block() != nil {
return errors.New("phase 0 block returned after altair fork has occurred") return errors.New("phase 0 block returned after altair fork has occurred")
} }
blk, err := wrapperv2.WrappedAltairSignedBeaconBlock(res.GetAltairBlock()) blk, err := wrapperv2.WrappedSignedBeaconBlock(res.GetAltairBlock())
if err != nil { if err != nil {
return err return err
} }

7
testing/endtoend/evaluators/operations.go
View File

@@ -407,10 +407,13 @@ var expectedEth1DataVote []byte
func convertToBlockInterface(obj *ethpb.BeaconBlockContainer) (block.SignedBeaconBlock, error) { func convertToBlockInterface(obj *ethpb.BeaconBlockContainer) (block.SignedBeaconBlock, error) {
if obj.GetPhase0Block() != nil { if obj.GetPhase0Block() != nil {
return wrapper.WrappedPhase0SignedBeaconBlock(obj.GetPhase0Block()), nil return wrapper.WrappedSignedBeaconBlock(obj.GetPhase0Block())
} }
if obj.GetAltairBlock() != nil { if obj.GetAltairBlock() != nil {
return wrapper.WrappedAltairSignedBeaconBlock(obj.GetAltairBlock()) return wrapper.WrappedSignedBeaconBlock(obj.GetAltairBlock())
}
if obj.GetBellatrixBlock() != nil {
return wrapper.WrappedSignedBeaconBlock(obj.GetBellatrixBlock())
} }
return nil, errors.New("container has no block") return nil, errors.New("container has no block")
} }

2
testing/spectest/shared/altair/finality/finality.go
View File

@@ -59,7 +59,7 @@ func RunFinalityTest(t *testing.T, config string) {
require.NoError(t, err, "Failed to decompress") require.NoError(t, err, "Failed to decompress")
block := &ethpb.SignedBeaconBlockAltair{} block := &ethpb.SignedBeaconBlockAltair{}
require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal") require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
processedState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb) processedState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)

6
testing/spectest/shared/altair/fork/transition.go
View File

@@ -100,14 +100,16 @@ func RunForkTransitionTest(t *testing.T, config string) {
ctx := context.Background() ctx := context.Background()
var ok bool var ok bool
for _, b := range preforkBlocks { for _, b := range preforkBlocks {
st, err := transition.ExecuteStateTransition(ctx, beaconState, wrapper.WrappedPhase0SignedBeaconBlock(b)) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err)
st, err := transition.ExecuteStateTransition(ctx, beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)
beaconState, ok = st.(*v1.BeaconState) beaconState, ok = st.(*v1.BeaconState)
require.Equal(t, true, ok) require.Equal(t, true, ok)
} }
altairState := state.BeaconStateAltair(beaconState) altairState := state.BeaconStateAltair(beaconState)
for _, b := range postforkBlocks { for _, b := range postforkBlocks {
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
st, err := transition.ExecuteStateTransition(ctx, altairState, wsb) st, err := transition.ExecuteStateTransition(ctx, altairState, wsb)
require.NoError(t, err) require.NoError(t, err)

2
testing/spectest/shared/altair/operations/helpers.go
View File

@@ -54,7 +54,7 @@ func RunBlockOperationTest(
helpers.ClearCache() helpers.ClearCache()
b := util.NewBeaconBlockAltair() b := util.NewBeaconBlockAltair()
b.Block.Body = body b.Block.Body = body
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(b) wsb, err := wrapper.WrappedSignedBeaconBlock(b)
require.NoError(t, err) require.NoError(t, err)
beaconState, err := operationFn(context.Background(), preState, wsb) beaconState, err := operationFn(context.Background(), preState, wsb)
if postSSZExists { if postSSZExists {

2
testing/spectest/shared/altair/sanity/block_processing.go
View File

@@ -61,7 +61,7 @@ func RunBlockProcessingTest(t *testing.T, config, folderPath string) {
require.NoError(t, err, "Failed to decompress") require.NoError(t, err, "Failed to decompress")
block := &ethpb.SignedBeaconBlockAltair{} block := &ethpb.SignedBeaconBlockAltair{}
require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal") require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
wsb, err := wrapper.WrappedAltairSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
processedState, transitionError = transition.ExecuteStateTransition(context.Background(), beaconState, wsb) processedState, transitionError = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
if transitionError != nil { if transitionError != nil {

2
testing/spectest/shared/bellatrix/finality/finality.go
View File

@@ -59,7 +59,7 @@ func RunFinalityTest(t *testing.T, config string) {
require.NoError(t, err, "Failed to decompress") require.NoError(t, err, "Failed to decompress")
block := &ethpb.SignedBeaconBlockBellatrix{} block := &ethpb.SignedBeaconBlockBellatrix{}
require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal") require.NoError(t, block.UnmarshalSSZ(blockSSZ), "Failed to unmarshal")
wsb, err := wrapper.WrappedBellatrixSignedBeaconBlock(block) wsb, err := wrapper.WrappedSignedBeaconBlock(block)
require.NoError(t, err) require.NoError(t, err)
processedState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb) processedState, err = transition.ExecuteStateTransition(context.Background(), beaconState, wsb)
require.NoError(t, err) require.NoError(t, err)

Some files were not shown because too many files have changed in this diff Show More