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

Update fastssz (#6760)

Browse Source 
* Update fastssz
* Merge branch 'master' of github.com:prysmaticlabs/prysm into update-fssz
* fmt
* gaz
* Merge refs/heads/master into update-fssz
* goimports
* Merge refs/heads/master into update-fssz
* Merge refs/heads/master into update-fssz
* Merge refs/heads/master into update-fssz
* Merge refs/heads/master into update-fssz
* Merge refs/heads/master into update-fssz
* Fix
* fix ethereumapis
* fix again
* kafka
* fix gen file
* fix compute signing root
* gofmt
* checkpoint progress
* progress
* checkpoint
* progress
* Fix build
* checkpoint
* helpers
* Another test fixed
* gaz
* another test fix
* gofmt
* some fixes
* Merge branch 'master' of github.com:prysmaticlabs/prysm into update-fssz
* fix one test
* Merge branch 'master' of github.com:prysmaticlabs/prysm into update-fssz
* fill empty checkpoint roots
* more padding
* more padding
* Fix //beacon-chain/rpc/debug:go_default_test
* fix //beacon-chain/core/state:go_default_test
* fix //beacon-chain/core/state:go_default_test
* fix some htr errors
* fix //slasher/rpc:go_default_test
* Progress on //beacon-chain/core/blocks:go_default_test
* Progress on //beacon-chain/core/blocks:go_default_test
* Progress on //beacon-chain/core/blocks:go_default_test
* fix //slasher/db/kv:go_default_test
* progress
* fix //beacon-chain/sync/initial-sync:go_raceon_test
* gofmt and gaz
* fix one more test, taking a break
* Fix //beacon-chain/core/blocks:go_default_test
* Complete beacon-chain/powchain
* Do most of beacon-chain/rpc/beacon/
* Do most of beacon-chain/blockchain
* fix //beacon-chain/operations/attestations/kv:go_default_test
* Fix //beacon-chain/cache/depositcache:go_default_test
* Fix //slasher/detection:go_default_test
* Progress
* fix //beacon-chain/rpc/validator:go_default_test
* gofmt
* fix //validator/client:go_default_test
* fix
* fix //beacon-chain/blockchain:go_raceoff_test
* fix //beacon-chain/rpc/beacon:go_default_test
* fix 1 of 4 shards in //beacon-chain/sync:go_default_test
* Fix //beacon-chain/sync:go_default_test and gofmt
* prevent panic
* fix //beacon-chain/state/stategen:go_default_test
* fix
* Merge branch 'master' of github.com:prysmaticlabs/prysm into update-fssz
* fix most tests
* Self review, go mod tidy, run regen scripts
* fix slasher
* Update ethereumapis
* disable spawn strategy override
* Merge refs/heads/master into update-fssz
* Merge refs/heads/master into update-fssz
* Remove extra line in imports
* Remove extra line in imports
* Gofmt
* PR feedback from @nisdas
This commit is contained in:
Preston Van Loon
2020-08-23 18:46:17 -07:00
committed by GitHub
parent 706f375aed
commit 78a25f99c3
153 changed files with 4314 additions and 2560 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
.buildkite-bazelrc
View File

@@ -3,10 +3,10 @@
#
# This config is loaded from https://github.com/bazelbuild/bazel-toolchains/blob/master/bazelrc/latest.bazelrc
build:remote-cache --remote_timeout=3600
build:remote-cache --spawn_strategy=standalone
build:remote-cache --strategy=Javac=standalone
build:remote-cache --strategy=Closure=standalone
build:remote-cache --strategy=Genrule=standalone
#build:remote-cache --spawn_strategy=standalone
#build:remote-cache --strategy=Javac=standalone
#build:remote-cache --strategy=Closure=standalone
#build:remote-cache --strategy=Genrule=standalone
# Prysm specific remote-cache properties.
#build:remote-cache --disk_cache=

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

@@ -11,7 +11,9 @@ import (
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
@@ -42,7 +44,7 @@ func TestHeadRoot_Nil(t *testing.T) {
func TestFinalizedCheckpt_CanRetrieve(t *testing.T) {
db, sc := testDB.SetupDB(t)
cp := &ethpb.Checkpoint{Epoch: 5, Root: []byte("foo")}
cp := &ethpb.Checkpoint{Epoch: 5, Root: bytesutil.PadTo([]byte("foo"), 32)}
c := setupBeaconChain(t, db, sc)
c.finalizedCheckpt = cp
@@ -66,7 +68,7 @@ func TestFinalizedCheckpt_GenesisRootOk(t *testing.T) {
func TestCurrentJustifiedCheckpt_CanRetrieve(t *testing.T) {
db, sc := testDB.SetupDB(t)
cp := &ethpb.Checkpoint{Epoch: 6, Root: []byte("foo")}
cp := &ethpb.Checkpoint{Epoch: 6, Root: bytesutil.PadTo([]byte("foo"), 32)}
c := setupBeaconChain(t, db, sc)
c.justifiedCheckpt = cp
@@ -90,7 +92,7 @@ func TestJustifiedCheckpt_GenesisRootOk(t *testing.T) {
func TestPreviousJustifiedCheckpt_CanRetrieve(t *testing.T) {
db, sc := testDB.SetupDB(t)
cp := &ethpb.Checkpoint{Epoch: 7, Root: []byte("foo")}
cp := &ethpb.Checkpoint{Epoch: 7, Root: bytesutil.PadTo([]byte("foo"), 32)}
c := setupBeaconChain(t, db, sc)
c.prevJustifiedCheckpt = cp
@@ -128,7 +130,8 @@ func TestHeadRoot_CanRetrieve(t *testing.T) {
}
func TestHeadBlock_CanRetrieve(t *testing.T) {
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
s, err := state.InitializeFromProto(&pb.BeaconState{})
require.NoError(t, err)
c := &Service{}

2
beacon-chain/blockchain/checkpoint_info_cache_test.go
View File

@@ -34,7 +34,7 @@ func TestHotStateCache_RoundTrip(t *testing.T) {
func TestHotStateCache_CanPrune(t *testing.T) {
c := newCheckPointInfoCache()
for i := 0; i < maxInfoSize+1; i++ {
cp := &ethpb.Checkpoint{Epoch: uint64(i)}
cp := &ethpb.Checkpoint{Epoch: uint64(i), Root: make([]byte, 32)}
require.NoError(t, c.put(cp, &pb.CheckPtInfo{}))
}
require.Equal(t, len(c.cache.Keys()), maxInfoSize)

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

@@ -5,7 +5,6 @@ import (
"context"
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -35,8 +34,9 @@ func TestSaveHead_Different(t *testing.T) {
oldRoot := [32]byte{'A'}
service.head = &head{slot: 0, root: oldRoot}
newHeadBlock := &ethpb.BeaconBlock{Slot: 1}
newHeadSignedBlock := &ethpb.SignedBeaconBlock{Block: newHeadBlock}
newHeadSignedBlock := testutil.NewBeaconBlock()
newHeadSignedBlock.Block.Slot = 1
newHeadBlock := newHeadSignedBlock.Block
require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
newRoot, err := stateutil.BlockRoot(newHeadBlock)
@@ -68,11 +68,10 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
service.head = &head{slot: 0, root: oldRoot}
reorgChainParent := [32]byte{'B'}
newHeadBlock := &ethpb.BeaconBlock{
Slot: 1,
ParentRoot: reorgChainParent[:],
}
newHeadSignedBlock := &ethpb.SignedBeaconBlock{Block: newHeadBlock}
newHeadSignedBlock := testutil.NewBeaconBlock()
newHeadSignedBlock.Block.Slot = 1
newHeadSignedBlock.Block.ParentRoot = reorgChainParent[:]
newHeadBlock := newHeadSignedBlock.Block
require.NoError(t, service.beaconDB.SaveBlock(context.Background(), newHeadSignedBlock))
newRoot, err := stateutil.BlockRoot(newHeadBlock)

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

@@ -11,7 +11,6 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -37,12 +36,14 @@ func TestStore_OnAttestation(t *testing.T) {
_, err = blockTree1(db, []byte{'g'})
require.NoError(t, err)
BlkWithOutState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
BlkWithOutState := testutil.NewBeaconBlock()
BlkWithOutState.Block.Slot = 0
require.NoError(t, db.SaveBlock(ctx, BlkWithOutState))
BlkWithOutStateRoot, err := stateutil.BlockRoot(BlkWithOutState.Block)
require.NoError(t, err)
BlkWithStateBadAtt := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
BlkWithStateBadAtt := testutil.NewBeaconBlock()
BlkWithStateBadAtt.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, BlkWithStateBadAtt))
BlkWithStateBadAttRoot, err := stateutil.BlockRoot(BlkWithStateBadAtt.Block)
require.NoError(t, err)
@@ -51,7 +52,8 @@ func TestStore_OnAttestation(t *testing.T) {
require.NoError(t, s.SetSlot(100*params.BeaconConfig().SlotsPerEpoch))
require.NoError(t, service.beaconDB.SaveState(ctx, s, BlkWithStateBadAttRoot))
BlkWithValidState := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
BlkWithValidState := testutil.NewBeaconBlock()
BlkWithValidState.Block.Slot = 2
require.NoError(t, db.SaveBlock(ctx, BlkWithValidState))
BlkWithValidStateRoot, err := stateutil.BlockRoot(BlkWithValidState.Block)
@@ -69,28 +71,24 @@ func TestStore_OnAttestation(t *testing.T) {
tests := []struct {
name string
a *ethpb.Attestation
s *pb.BeaconState
wantErr bool
wantErrString string
}{
{
name: "attestation's data slot not aligned with target vote",
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{}}},
s: &pb.BeaconState{},
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}},
wantErr: true,
wantErrString: "data slot is not in the same epoch as target 1 != 0",
},
{
name: "attestation's target root not in db",
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: []byte{'A'}}}},
s: &pb.BeaconState{},
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)}}},
wantErr: true,
wantErrString: "target root does not exist in db",
},
{
name: "no pre state for attestations's target block",
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: BlkWithOutStateRoot[:]}}},
s: &pb.BeaconState{},
wantErr: true,
wantErrString: "could not get pre state for slot 0",
},
@@ -98,28 +96,32 @@ func TestStore_OnAttestation(t *testing.T) {
name: "process attestation doesn't match current epoch",
a: &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 100 * params.BeaconConfig().SlotsPerEpoch, Target: &ethpb.Checkpoint{Epoch: 100,
Root: BlkWithStateBadAttRoot[:]}}},
s: &pb.BeaconState{Slot: 100 * params.BeaconConfig().SlotsPerEpoch},
wantErr: true,
wantErrString: "target epoch 100 does not match current epoch",
},
{
name: "process nil field (a.Target) in attestation",
name: "process nil attestation",
a: nil,
s: &pb.BeaconState{},
wantErr: true,
wantErrString: "nil attestation",
},
{
name: "process nil field (a.Data) in attestation",
a: &ethpb.Attestation{},
s: &pb.BeaconState{},
wantErr: true,
wantErrString: "nil attestation.Data field",
},
{
name: "process nil field (a.Target) in attestation",
a: &ethpb.Attestation{Data: &ethpb.AttestationData{}},
s: &pb.BeaconState{},
name: "process nil field (a.Target) in attestation",
a: &ethpb.Attestation{
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: nil,
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: make([]byte, 1),
Signature: make([]byte, 96),
},
wantErr: true,
wantErrString: "nil attestation.Data.Target field",
},
@@ -150,22 +152,16 @@ func TestStore_SaveCheckpointState(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
s, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Fork: &pb.Fork{
Epoch: 0,
CurrentVersion: params.BeaconConfig().GenesisForkVersion,
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
StateRoots: make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
BlockRoots: make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot),
LatestBlockHeader: &ethpb.BeaconBlockHeader{},
JustificationBits: []byte{0},
Slashings: make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
FinalizedCheckpoint: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
Validators: []*ethpb.Validator{{PublicKey: bytesutil.PadTo([]byte("foo"), 48)}},
Balances: []uint64{0},
})
s := testutil.NewBeaconState()
err = s.SetFinalizedCheckpoint(&ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)})
require.NoError(t, err)
val := &ethpb.Validator{
PublicKey: bytesutil.PadTo([]byte("foo"), 48),
WithdrawalCredentials: bytesutil.PadTo([]byte("bar"), 32),
}
err = s.SetValidators([]*ethpb.Validator{val})
require.NoError(t, err)
err = s.SetBalances([]uint64{0})
require.NoError(t, err)
r := [32]byte{'g'}
require.NoError(t, service.beaconDB.SaveState(ctx, s, r))
@@ -230,7 +226,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
epoch := uint64(1)
baseState, _ := testutil.DeterministicGenesisState(t, 1)
require.NoError(t, baseState.SetSlot(epoch*params.BeaconConfig().SlotsPerEpoch))
checkpoint := &ethpb.Checkpoint{Epoch: epoch}
checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("hi"), 32)}
require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
returned, err := service.getAttPreState(ctx, checkpoint)
require.NoError(t, err)
@@ -241,7 +237,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
assert.NotNil(t, cached, "State should have been cached")
epoch = uint64(2)
newCheckpoint := &ethpb.Checkpoint{Epoch: epoch}
newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: bytesutil.PadTo([]byte("bye"), 32)}
require.NoError(t, service.beaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
returned, err = service.getAttPreState(ctx, newCheckpoint)
require.NoError(t, err)
@@ -268,7 +264,7 @@ func TestAttEpoch_MatchPrevEpoch(t *testing.T) {
ctx,
0,
params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
&ethpb.Checkpoint{}); err != nil {
&ethpb.Checkpoint{Root: make([]byte, 32)}); err != nil {
t.Error(err)
}
}
@@ -302,7 +298,7 @@ func TestAttEpoch_NotMatch(t *testing.T) {
ctx,
0,
2*params.BeaconConfig().SlotsPerEpoch*params.BeaconConfig().SecondsPerSlot,
&ethpb.Checkpoint{}); !strings.Contains(err.Error(),
&ethpb.Checkpoint{Root: make([]byte, 32)}); !strings.Contains(err.Error(),
"target epoch 0 does not match current epoch 2 or prev epoch 1") {
t.Error("Did not receive wanted error")
}
@@ -316,8 +312,12 @@ func TestVerifyBeaconBlock_NoBlock(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
d := &ethpb.AttestationData{}
assert.ErrorContains(t, "beacon block does not exist", service.verifyBeaconBlock(ctx, d))
d := &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
assert.ErrorContains(t, "beacon block 0x000000000000 does not exist", service.verifyBeaconBlock(ctx, d))
}
func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
@@ -328,7 +328,8 @@ func TestVerifyBeaconBlock_futureBlock(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 2
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
r, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -345,7 +346,8 @@ func TestVerifyBeaconBlock_OK(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 2
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
r, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -362,11 +364,14 @@ func TestVerifyLMDFFGConsistent_NotOK(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
b32 := testutil.NewBeaconBlock()
b32.Block.Slot = 32
require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
r32, err := stateutil.BlockRoot(b32.Block)
require.NoError(t, err)
b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
b33 := testutil.NewBeaconBlock()
b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
r33, err := stateutil.BlockRoot(b33.Block)
require.NoError(t, err)
@@ -383,11 +388,14 @@ func TestVerifyLMDFFGConsistent_OK(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
b32 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 32}}
b32 := testutil.NewBeaconBlock()
b32.Block.Slot = 32
require.NoError(t, service.beaconDB.SaveBlock(ctx, b32))
r32, err := stateutil.BlockRoot(b32.Block)
require.NoError(t, err)
b33 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 33, ParentRoot: r32[:]}}
b33 := testutil.NewBeaconBlock()
b33.Block.Slot = 33
b33.Block.ParentRoot = r32[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, b33))
r33, err := stateutil.BlockRoot(b33.Block)
require.NoError(t, err)

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

@@ -6,8 +6,8 @@ import (
"testing"
"time"
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -48,7 +48,9 @@ func TestStore_OnBlock(t *testing.T) {
require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
roots, err := blockTree1(db, validGenesisRoot[:])
require.NoError(t, err)
random := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1, ParentRoot: validGenesisRoot[:]}}
random := testutil.NewBeaconBlock()
random.Block.Slot = 1
random.Block.ParentRoot = validGenesisRoot[:]
assert.NoError(t, db.SaveBlock(ctx, random))
randomParentRoot, err := stateutil.BlockRoot(random.Block)
assert.NoError(t, err)
@@ -60,32 +62,46 @@ func TestStore_OnBlock(t *testing.T) {
tests := []struct {
name string
blk *ethpb.BeaconBlock
blk *ethpb.SignedBeaconBlock
s *stateTrie.BeaconState
time uint64
wantErrString string
}{
{
name: "parent block root does not have a state",
blk: &ethpb.BeaconBlock{},
blk: testutil.NewBeaconBlock(),
s: st.Copy(),
wantErrString: "could not reconstruct parent state",
},
{
name: "block is from the future",
blk: &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:], Slot: params.BeaconConfig().FarFutureEpoch},
name: "block is from the future",
blk: func() *ethpb.SignedBeaconBlock {
b := testutil.NewBeaconBlock()
b.Block.ParentRoot = randomParentRoot[:]
b.Block.Slot = params.BeaconConfig().FarFutureEpoch
return b
}(),
s: st.Copy(),
wantErrString: "far distant future",
},
{
name: "could not get finalized block",
blk: &ethpb.BeaconBlock{ParentRoot: randomParentRoot[:]},
name: "could not get finalized block",
blk: func() *ethpb.SignedBeaconBlock {
b := testutil.NewBeaconBlock()
b.Block.ParentRoot = randomParentRoot[:]
return b
}(),
s: st.Copy(),
wantErrString: "is not a descendent of the current finalized block",
},
{
name: "same slot as finalized block",
blk: &ethpb.BeaconBlock{Slot: 0, ParentRoot: randomParentRoot2},
name: "same slot as finalized block",
blk: func() *ethpb.SignedBeaconBlock {
b := testutil.NewBeaconBlock()
b.Block.Slot = 0
b.Block.ParentRoot = randomParentRoot2
return b
}(),
s: st.Copy(),
wantErrString: "block is equal or earlier than finalized block, slot 0 < slot 0",
},
@@ -99,9 +115,9 @@ func TestStore_OnBlock(t *testing.T) {
service.prevFinalizedCheckpt = &ethpb.Checkpoint{Root: validGenesisRoot[:]}
service.finalizedCheckpt.Root = roots[0]
root, err := stateutil.BlockRoot(tt.blk)
root, err := stateutil.BlockRoot(tt.blk.Block)
assert.NoError(t, err)
err = service.onBlock(ctx, &ethpb.SignedBeaconBlock{Block: tt.blk}, root)
err = service.onBlock(ctx, tt.blk, root)
assert.ErrorContains(t, tt.wantErrString, err)
})
}
@@ -159,7 +175,7 @@ func TestRemoveStateSinceLastFinalized_EmptyStartSlot(t *testing.T) {
require.NoError(t, err)
service.genesisTime = time.Now()
update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{})
update, err := service.shouldUpdateCurrentJustified(ctx, &ethpb.Checkpoint{Root: make([]byte, 32)})
require.NoError(t, err)
assert.Equal(t, true, update, "Should be able to update justified")
lastJustifiedBlk := testutil.NewBeaconBlock()
@@ -228,10 +244,12 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
s, err := stateTrie.InitializeFromProto(&pb.BeaconState{Slot: 1, GenesisValidatorsRoot: params.BeaconConfig().ZeroHash[:]})
require.NoError(t, err)
r := [32]byte{'A'}
b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
b.Block.ParentRoot = r[:]
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
require.NoError(t, service.stateGen.SaveState(ctx, r, s))
require.NoError(t, service.verifyBlkPreState(ctx, b))
require.NoError(t, service.verifyBlkPreState(ctx, b.Block))
}
func TestCachedPreState_CanGetFromDB(t *testing.T) {
@@ -249,10 +267,12 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
require.NoError(t, err)
r := [32]byte{'A'}
b := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r[:]}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
b.Block.ParentRoot = r[:]
service.finalizedCheckpt = &ethpb.Checkpoint{Root: r[:]}
err = service.verifyBlkPreState(ctx, b)
err = service.verifyBlkPreState(ctx, b.Block)
wanted := "could not reconstruct parent state"
assert.ErrorContains(t, wanted, err)
@@ -260,7 +280,7 @@ func TestCachedPreState_CanGetFromDB(t *testing.T) {
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Slot: 1, Root: r[:]}))
require.NoError(t, service.stateGen.SaveState(ctx, r, s))
require.NoError(t, service.verifyBlkPreState(ctx, b))
require.NoError(t, service.verifyBlkPreState(ctx, b.Block))
}
func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
@@ -271,7 +291,7 @@ func TestUpdateJustified_CouldUpdateBest(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
signedBlock := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
signedBlock := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, signedBlock))
r, err := stateutil.BlockRoot(signedBlock.Block)
require.NoError(t, err)
@@ -303,7 +323,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
service.forkChoiceStore = protoarray.New(0, 0, [32]byte{'A'})
service.finalizedCheckpt = &ethpb.Checkpoint{}
service.finalizedCheckpt = &ethpb.Checkpoint{Root: make([]byte, 32)}
genesisStateRoot := [32]byte{}
genesis := blocks.NewGenesisBlock(genesisStateRoot[:])
@@ -317,10 +337,12 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
require.NoError(t, err)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
block := &ethpb.BeaconBlock{Slot: 9, ParentRoot: roots[8], Body: &ethpb.BeaconBlockBody{Graffiti: []byte{}}}
block := testutil.NewBeaconBlock()
block.Block.Slot = 9
block.Block.ParentRoot = roots[8]
err = service.fillInForkChoiceMissingBlocks(
context.Background(), block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
context.Background(), block.Block, beaconState.FinalizedCheckpoint(), beaconState.CurrentJustifiedCheckpoint())
require.NoError(t, err)
// 5 nodes from the block tree 1. B0 - B3 - B4 - B6 - B8
@@ -351,15 +373,20 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
require.NoError(t, service.beaconDB.SaveState(ctx, st.Copy(), validGenesisRoot))
// Define a tree branch, slot 63 <- 64 <- 65
b63 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 63, Body: &ethpb.BeaconBlockBody{}}}
b63 := testutil.NewBeaconBlock()
b63.Block.Slot = 63
require.NoError(t, service.beaconDB.SaveBlock(ctx, b63))
r63, err := stateutil.BlockRoot(b63.Block)
require.NoError(t, err)
b64 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 64, ParentRoot: r63[:], Body: &ethpb.BeaconBlockBody{}}}
b64 := testutil.NewBeaconBlock()
b64.Block.Slot = 64
b64.Block.ParentRoot = r63[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, b64))
r64, err := stateutil.BlockRoot(b64.Block)
require.NoError(t, err)
b65 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 65, ParentRoot: r64[:], Body: &ethpb.BeaconBlockBody{}}}
b65 := testutil.NewBeaconBlock()
b65.Block.Slot = 65
b65.Block.ParentRoot = r64[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, b65))
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
@@ -380,58 +407,74 @@ func TestFillForkChoiceMissingBlocks_FilterFinalized(t *testing.T) {
// \- B3 - B4 - B6 - B8
// (B1, and B3 are all from the same slots)
func blockTree1(db db.Database, genesisRoot []byte) ([][]byte, error) {
b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
r0, err := ssz.HashTreeRoot(b0)
genesisRoot = bytesutil.PadTo(genesisRoot, 32)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
r0, err := b0.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = r0[:]
r1, err := b1.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r0[:]}
r3, err := ssz.HashTreeRoot(b3)
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 3
b3.Block.ParentRoot = r0[:]
r3, err := b3.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r3[:]}
r4, err := ssz.HashTreeRoot(b4)
b4 := testutil.NewBeaconBlock()
b4.Block.Slot = 4
b4.Block.ParentRoot = r3[:]
r4, err := b4.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r4[:]}
r5, err := ssz.HashTreeRoot(b5)
b5 := testutil.NewBeaconBlock()
b5.Block.Slot = 5
b5.Block.ParentRoot = r4[:]
r5, err := b5.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r4[:]}
r6, err := ssz.HashTreeRoot(b6)
b6 := testutil.NewBeaconBlock()
b6.Block.Slot = 6
b6.Block.ParentRoot = r4[:]
r6, err := b6.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r5[:]}
r7, err := ssz.HashTreeRoot(b7)
b7 := testutil.NewBeaconBlock()
b7.Block.Slot = 7
b7.Block.ParentRoot = r5[:]
r7, err := b7.Block.HashTreeRoot()
if err != nil {
return nil, err
}
b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r6[:]}
r8, err := ssz.HashTreeRoot(b8)
b8 := testutil.NewBeaconBlock()
b8.Block.Slot = 8
b8.Block.ParentRoot = r6[:]
r8, err := b8.Block.HashTreeRoot()
if err != nil {
return nil, err
}
st := testutil.NewBeaconState()
for _, b := range []*ethpb.BeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b3, b4, b5, b6, b7, b8} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, err
}
if err := db.SaveState(context.Background(), st.Copy(), bytesutil.ToBytes32(beaconBlock.Block.ParentRoot)); err != nil {
return nil, err
return nil, errors.Wrap(err, "could not save state")
}
}
if err := db.SaveState(context.Background(), st.Copy(), r1); err != nil {
@@ -461,20 +504,25 @@ func TestAncestor_HandleSkipSlot(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
r100, err := ssz.HashTreeRoot(b100)
b100 := testutil.NewBeaconBlock()
b100.Block.Slot = 100
b100.Block.ParentRoot = r1[:]
r100, err := b100.Block.HashTreeRoot()
require.NoError(t, err)
b200 := &ethpb.BeaconBlock{Slot: 200, ParentRoot: r100[:]}
r200, err := ssz.HashTreeRoot(b200)
b200 := testutil.NewBeaconBlock()
b200.Block.Slot = 200
b200.Block.ParentRoot = r100[:]
r200, err := b200.Block.HashTreeRoot()
require.NoError(t, err)
for _, b := range []*ethpb.BeaconBlock{b1, b100, b200} {
for _, b := range []*ethpb.SignedBeaconBlock{b1, b100, b200} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.Body = &ethpb.BeaconBlockBody{}
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, db.SaveBlock(context.Background(), beaconBlock))
}
@@ -557,16 +605,20 @@ func TestFinalizedImpliesNewJustified(t *testing.T) {
require.NoError(t, service.beaconDB.SaveState(ctx, genesisState, bytesutil.ToBytes32(test.want.Root)))
if test.args.diffFinalizedCheckPoint {
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'a'}}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
b100 := &ethpb.BeaconBlock{Slot: 100, ParentRoot: r1[:]}
r100, err := ssz.HashTreeRoot(b100)
b100 := testutil.NewBeaconBlock()
b100.Block.Slot = 100
b100.Block.ParentRoot = r1[:]
r100, err := b100.Block.HashTreeRoot()
require.NoError(t, err)
for _, b := range []*ethpb.BeaconBlock{b1, b100} {
for _, b := range []*ethpb.SignedBeaconBlock{b1, b100} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
require.NoError(t, service.beaconDB.SaveBlock(context.Background(), beaconBlock))
}
service.finalizedCheckpt = &ethpb.Checkpoint{Root: []byte{'c'}, Epoch: 1}
@@ -665,7 +717,7 @@ func TestUpdateJustifiedInitSync(t *testing.T) {
service, err := NewService(ctx, cfg)
require.NoError(t, err)
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, gBlk))

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

@@ -17,6 +17,6 @@ func TestVerifyCheckpointEpoch_Ok(t *testing.T) {
chainService := setupBeaconChain(t, db, sc)
chainService.genesisTime = time.Now()
assert.Equal(t, true, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{}))
assert.Equal(t, true, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Root: make([]byte, 32)}))
assert.Equal(t, false, chainService.verifyCheckpointEpoch(&ethpb.Checkpoint{Epoch: 1}))
}

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

@@ -322,8 +322,8 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db, stateSummaryCache := testDB.SetupDB(t)
genesisBlockRoot := bytesutil.ToBytes32(nil)
genesisBlockRoot, err := genesis.HashTreeRoot(ctx)
require.NoError(t, err)
cfg := &Config{
BeaconDB: db,
ForkChoiceStore: protoarray.New(

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

@@ -11,7 +11,6 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -179,11 +178,12 @@ func TestChainService_InitializeBeaconChain(t *testing.T) {
err = genState.SetEth1Data(&ethpb.Eth1Data{
DepositRoot: hashTreeRoot[:],
DepositCount: uint64(len(deposits)),
BlockHash: make([]byte, 32),
})
genState, err = b.ProcessPreGenesisDeposits(ctx, genState, deposits)
require.NoError(t, err)
_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:]})
_, err = bc.initializeBeaconChain(ctx, time.Unix(0, 0), genState, &ethpb.Eth1Data{DepositRoot: hashTreeRoot[:], BlockHash: make([]byte, 32)})
require.NoError(t, err)
_, err = bc.HeadState(ctx)
@@ -275,8 +275,9 @@ func TestChainService_SaveHeadNoDB(t *testing.T) {
beaconDB: db,
stateGen: stategen.New(db, sc),
}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
r, err := ssz.HashTreeRoot(b)
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
r, err := b.HashTreeRoot()
require.NoError(t, err)
newState := testutil.NewBeaconState()
require.NoError(t, s.stateGen.SaveState(ctx, r, newState))
@@ -294,13 +295,13 @@ func TestHasBlock_ForkChoiceAndDB(t *testing.T) {
db, _ := testDB.SetupDB(t)
s := &Service{
forkChoiceStore: protoarray.New(0, 0, [32]byte{}),
finalizedCheckpt: &ethpb.Checkpoint{},
finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
beaconDB: db,
}
block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
r, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err)
bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
state, err := beaconstate.InitializeFromProto(bs)
require.NoError(t, err)
require.NoError(t, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))
@@ -315,7 +316,7 @@ func BenchmarkHasBlockDB(b *testing.B) {
s := &Service{
beaconDB: db,
}
block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
block := testutil.NewBeaconBlock()
require.NoError(b, s.beaconDB.SaveBlock(ctx, block))
r, err := stateutil.BlockRoot(block.Block)
require.NoError(b, err)
@@ -331,13 +332,13 @@ func BenchmarkHasBlockForkChoiceStore(b *testing.B) {
db, _ := testDB.SetupDB(b)
s := &Service{
forkChoiceStore: protoarray.New(0, 0, [32]byte{}),
finalizedCheckpt: &ethpb.Checkpoint{},
finalizedCheckpt: &ethpb.Checkpoint{Root: make([]byte, 32)},
beaconDB: db,
}
block := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}}
r, err := stateutil.BlockRoot(block.Block)
require.NoError(b, err)
bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{}}
bs := &pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
state, err := beaconstate.InitializeFromProto(bs)
require.NoError(b, err)
require.NoError(b, s.insertBlockAndAttestationsToForkChoiceStore(ctx, block.Block, r, state))

6
beacon-chain/blockchain/testing/mock.go
View File

@@ -233,8 +233,10 @@ func (ms *ChainService) HeadSlot() uint64 {
// HeadRoot mocks HeadRoot method in chain service.
func (ms *ChainService) HeadRoot(ctx context.Context) ([]byte, error) {
return ms.Root, nil
if len(ms.Root) > 0 {
return ms.Root, nil
}
return make([]byte, 32), nil
}
// HeadBlock mocks HeadBlock method in chain service.

2
beacon-chain/cache/attestation_data_test.go vendored
View File

@@ -26,7 +26,7 @@ func TestAttestationCache_RoundTrip(t *testing.T) {
assert.NoError(t, c.MarkInProgress(req))
res := &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 5},
Target: &ethpb.Checkpoint{Epoch: 5, Root: make([]byte, 32)},
}
assert.NoError(t, c.Put(ctx, req, res))

2
beacon-chain/cache/checkpoint_state_test.go vendored
View File

@@ -61,7 +61,7 @@ func TestCheckpointStateCache_MaxSize(t *testing.T) {
for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
require.NoError(t, st.SetSlot(i))
require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i}, st))
require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: i, Root: make([]byte, 32)}, st))
}
assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))

2
beacon-chain/cache/depositcache/BUILD.bazel vendored
View File

@@ -18,7 +18,6 @@ go_library(
"@com_github_prometheus_client_golang//prometheus:go_default_library",
"@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@io_opencensus_go//trace:go_default_library",
],
@@ -40,7 +39,6 @@ go_test(
"//shared/trieutil:go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//hooks/test:go_default_library",
],
)

3
beacon-chain/cache/depositcache/deposits_cache.go vendored
View File

@@ -15,7 +15,6 @@ import (
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
@@ -128,7 +127,7 @@ func (dc *DepositCache) InsertFinalizedDeposits(ctx context.Context, eth1Deposit
if d.Index > eth1DepositIndex {
break
}
depHash, err := ssz.HashTreeRoot(d.Deposit.Data)
depHash, err := d.Deposit.Data.HashTreeRoot()
if err != nil {
log.WithError(err).Error("Could not hash deposit data. Finalized deposit cache not updated.")
return

164
beacon-chain/cache/depositcache/deposits_cache_test.go vendored
View File

@@ -8,7 +8,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
@@ -162,32 +161,74 @@ func TestDepositsNumberAndRootAtHeight_ReturnsAppropriateCountAndRoot(t *testing
dc.deposits = []*dbpb.DepositContainer{
{
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
{
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
{
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
{
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
{
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{},
DepositRoot: []byte("root"),
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
{
Eth1BlockHeight: 12,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
{
Eth1BlockHeight: 12,
Deposit: &ethpb.Deposit{},
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
}
@@ -203,13 +244,25 @@ func TestDepositsNumberAndRootAtHeight_ReturnsEmptyTrieIfBlockHeightLessThanOlde
dc.deposits = []*dbpb.DepositContainer{
{
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{},
DepositRoot: []byte("root"),
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
{
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{},
DepositRoot: []byte("root"),
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
}
@@ -227,7 +280,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
Eth1BlockHeight: 9,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("pk0"),
PublicKey: bytesutil.PadTo([]byte("pk0"), 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
@@ -235,7 +290,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("pk1"),
PublicKey: bytesutil.PadTo([]byte("pk1"), 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
@@ -243,7 +300,9 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("pk1"),
PublicKey: bytesutil.PadTo([]byte("pk1"), 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
@@ -251,15 +310,18 @@ func TestDepositByPubkey_ReturnsFirstMatchingDeposit(t *testing.T) {
Eth1BlockHeight: 12,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("pk2"),
PublicKey: bytesutil.PadTo([]byte("pk2"), 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
},
}
dep, blkNum := dc.DepositByPubkey(context.Background(), []byte("pk1"))
pk1 := bytesutil.PadTo([]byte("pk1"), 48)
dep, blkNum := dc.DepositByPubkey(context.Background(), pk1)
if !bytes.Equal(dep.Data.PublicKey, []byte("pk1")) {
if dep == nil || !bytes.Equal(dep.Data.PublicKey, pk1) {
t.Error("Returned wrong deposit")
}
assert.Equal(t, 0, blkNum.Cmp(big.NewInt(10)),
@@ -274,7 +336,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{0},
PublicKey: bytesutil.PadTo([]byte{0}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 0,
@@ -282,7 +346,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{1},
PublicKey: bytesutil.PadTo([]byte{1}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 1,
@@ -290,7 +356,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{2},
PublicKey: bytesutil.PadTo([]byte{2}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 2,
@@ -299,7 +367,9 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
dc.deposits = append(finalizedDeposits, &dbpb.DepositContainer{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{3},
PublicKey: bytesutil.PadTo([]byte{3}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 3,
@@ -313,7 +383,7 @@ func TestFinalizedDeposits_DepositsCachedCorrectly(t *testing.T) {
var deps [][]byte
for _, d := range finalizedDeposits {
hash, err := ssz.HashTreeRoot(d.Deposit.Data)
hash, err := d.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Could not hash deposit data")
deps = append(deps, hash[:])
}
@@ -330,7 +400,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{0},
PublicKey: bytesutil.PadTo([]byte{0}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 0,
@@ -338,7 +410,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{1},
PublicKey: bytesutil.PadTo([]byte{1}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 1,
@@ -347,7 +421,9 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
newFinalizedDeposit := dbpb.DepositContainer{
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{2},
PublicKey: bytesutil.PadTo([]byte{2}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 2,
@@ -365,7 +441,7 @@ func TestFinalizedDeposits_UtilizesPreviouslyCachedDeposits(t *testing.T) {
var deps [][]byte
for _, d := range append(oldFinalizedDeposits, &newFinalizedDeposit) {
hash, err := ssz.HashTreeRoot(d.Deposit.Data)
hash, err := d.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Could not hash deposit data")
deps = append(deps, hash[:])
}
@@ -393,7 +469,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{0},
PublicKey: bytesutil.PadTo([]byte{0}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 0,
@@ -402,7 +480,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{1},
PublicKey: bytesutil.PadTo([]byte{1}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 1,
@@ -413,7 +493,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{2},
PublicKey: bytesutil.PadTo([]byte{2}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 2,
@@ -422,7 +504,9 @@ func TestNonFinalizedDeposits_ReturnsAllNonFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{3},
PublicKey: bytesutil.PadTo([]byte{3}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 3,
@@ -442,7 +526,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{0},
PublicKey: bytesutil.PadTo([]byte{0}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 0,
@@ -451,7 +537,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{1},
PublicKey: bytesutil.PadTo([]byte{1}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 1,
@@ -462,7 +550,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{2},
PublicKey: bytesutil.PadTo([]byte{2}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 2,
@@ -471,7 +561,9 @@ func TestNonFinalizedDeposits_ReturnsNonFinalizedDepositsUpToBlockNumber(t *test
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{3},
PublicKey: bytesutil.PadTo([]byte{3}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
},
Index: 3,

32
beacon-chain/cache/depositcache/pending_deposits_test.go vendored
View File

@@ -29,14 +29,28 @@ func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
assert.Equal(t, 0, len(dc.pendingDeposits))
}
func makeDepositProof() [][]byte {
proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
for i := range proof {
proof[i] = make([]byte, 32)
}
return proof
}
func TestRemovePendingDeposit_OK(t *testing.T) {
db := DepositCache{}
proof1 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
proof1 := makeDepositProof()
proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
proof2 := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
proof2 := makeDepositProof()
proof2[0] = bytesutil.PadTo([]byte{'A'}, 32)
depToRemove := &ethpb.Deposit{Proof: proof1}
otherDep := &ethpb.Deposit{Proof: proof2}
data := &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Amount: 0,
Signature: make([]byte, 96),
}
depToRemove := &ethpb.Deposit{Proof: proof1, Data: data}
otherDep := &ethpb.Deposit{Proof: proof2, Data: data}
db.pendingDeposits = []*dbpb.DepositContainer{
{Deposit: depToRemove, Index: 1},
{Deposit: otherDep, Index: 5},
@@ -57,9 +71,15 @@ func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
func TestPendingDeposit_RoundTrip(t *testing.T) {
dc := DepositCache{}
proof := make([][]byte, int(params.BeaconConfig().DepositContractTreeDepth)+1)
proof := makeDepositProof()
proof[0] = bytesutil.PadTo([]byte{'A'}, 32)
dep := &ethpb.Deposit{Proof: proof}
data := &ethpb.Deposit_Data{
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
Amount: 0,
Signature: make([]byte, 96),
}
dep := &ethpb.Deposit{Proof: proof, Data: data}
dc.InsertPendingDeposit(context.Background(), dep, 111, 100, [32]byte{})
dc.RemovePendingDeposit(context.Background(), dep)
assert.Equal(t, 0, len(dc.pendingDeposits), "Failed to insert & delete a pending deposit")

2
beacon-chain/core/blocks/BUILD.bazel
View File

@@ -63,6 +63,7 @@ go_test(
"randao_test.go",
],
embed = [":go_default_library"],
shard_count = 2,
deps = [
"//beacon-chain/core/helpers:go_default_library",
"//beacon-chain/state:go_default_library",
@@ -82,7 +83,6 @@ go_test(
"@com_github_google_gofuzz//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_bitfield//:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
],
)

207
beacon-chain/core/blocks/attestation_test.go
View File

@@ -15,6 +15,7 @@ import (
attaggregation "github.com/prysmaticlabs/prysm/shared/aggregation/attestations"
"github.com/prysmaticlabs/prysm/shared/attestationutil"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -25,7 +26,7 @@ func TestProcessAttestations_InclusionDelayFailure(t *testing.T) {
attestations := []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Slot: 5,
},
},
@@ -81,8 +82,8 @@ func TestProcessAttestations_CurrentEpochFFGDataMismatches(t *testing.T) {
attestations := []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
},
AggregationBits: aggBits,
},
@@ -127,8 +128,8 @@ func TestProcessAttestations_PrevEpochFFGDataMismatches(t *testing.T) {
attestations := []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 1},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Slot: params.BeaconConfig().SlotsPerEpoch,
},
AggregationBits: aggBits,
@@ -207,10 +208,12 @@ func TestProcessAttestations_OK(t *testing.T) {
copy(mockRoot[:], "hello-world")
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
cfc := beaconState.CurrentJustifiedCheckpoint()
@@ -232,23 +235,21 @@ func TestProcessAttestations_OK(t *testing.T) {
}
att.Signature = bls.AggregateSignatures(sigs).Marshal()[:]
block := &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{att},
},
}
block := testutil.NewBeaconBlock()
block.Block.Body.Attestations = []*ethpb.Attestation{att}
err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
require.NoError(t, err)
_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Block.Body)
assert.NoError(t, err)
}
func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
data := &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
Target: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
Source: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: bytesutil.PadTo([]byte("hello-world"), 32)},
BeaconBlockRoot: make([]byte, 32),
}
aggBits1 := bitfield.NewBitlist(4)
aggBits1.SetBitAt(0, true)
@@ -260,7 +261,7 @@ func TestProcessAggregatedAttestation_OverlappingBits(t *testing.T) {
}
cfc := beaconState.CurrentJustifiedCheckpoint()
cfc.Root = []byte("hello-world")
cfc.Root = bytesutil.PadTo([]byte("hello-world"), 32)
require.NoError(t, beaconState.SetCurrentJustifiedCheckpoint(cfc))
require.NoError(t, beaconState.SetCurrentEpochAttestations([]*pb.PendingAttestation{}))
@@ -311,8 +312,9 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
var mockRoot [32]byte
copy(mockRoot[:], "hello-world")
data := &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
BeaconBlockRoot: make([]byte, 32),
}
aggBits1 := bitfield.NewBitlist(9)
aggBits1.SetBitAt(0, true)
@@ -320,6 +322,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
att1 := &ethpb.Attestation{
Data: data,
AggregationBits: aggBits1,
Signature: make([]byte, 32),
}
cfc := beaconState.CurrentJustifiedCheckpoint()
@@ -347,6 +350,7 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
att2 := &ethpb.Attestation{
Data: data,
AggregationBits: aggBits2,
Signature: make([]byte, 32),
}
committee, err = helpers.BeaconCommitteeFromState(beaconState, att2.Data.Slot, att2.Data.CommitteeIndex)
@@ -365,16 +369,13 @@ func TestProcessAggregatedAttestation_NoOverlappingBits(t *testing.T) {
aggregatedAtt, err := attaggregation.AggregatePair(att1, att2)
require.NoError(t, err)
block := &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{aggregatedAtt},
},
}
block := testutil.NewBeaconBlock()
block.Block.Body.Attestations = []*ethpb.Attestation{aggregatedAtt}
err = beaconState.SetSlot(beaconState.Slot() + params.BeaconConfig().MinAttestationInclusionDelay)
require.NoError(t, err)
_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Body)
_, err = blocks.ProcessAttestations(context.Background(), beaconState, block.Block.Body)
assert.NoError(t, err)
}
@@ -384,7 +385,7 @@ func TestProcessAttestationsNoVerify_IncorrectSlotTargetEpoch(t *testing.T) {
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: params.BeaconConfig().SlotsPerEpoch,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
}
wanted := fmt.Sprintf("data slot is not in the same epoch as target %d != %d", helpers.SlotToEpoch(att.Data.Slot), att.Data.Target.Epoch)
@@ -404,7 +405,7 @@ func TestProcessAttestationsNoVerify_OK(t *testing.T) {
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
AggregationBits: aggBits,
}
@@ -433,7 +434,7 @@ func TestProcessAttestationsNoVerify_BadAttIdx(t *testing.T) {
Data: &ethpb.AttestationData{
CommitteeIndex: 100,
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot[:]},
Target: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
AggregationBits: aggBits,
}
@@ -486,8 +487,8 @@ func TestConvertToIndexed_OK(t *testing.T) {
attestation := &ethpb.Attestation{
Signature: sig[:],
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
}
for _, tt := range tests {
@@ -512,8 +513,9 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
require.NoError(t, err)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
WithdrawalCredentials: make([]byte, 32),
}
}
@@ -535,33 +537,57 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{
Epoch: 2,
Root: make([]byte, 32),
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{1},
Signature: make([]byte, 96),
}},
{attestation: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{
Epoch: 1,
Root: make([]byte, 32),
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{47, 99, 101},
Signature: make([]byte, 96),
}},
{attestation: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{
Epoch: 4,
Root: make([]byte, 32),
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{21, 72},
Signature: make([]byte, 96),
}},
{attestation: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{
Epoch: 7,
Root: make([]byte, 32),
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{100, 121, 122},
Signature: make([]byte, 96),
}},
}
@@ -653,32 +679,28 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
require.NoError(t, err)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
WithdrawalCredentials: make([]byte, 32),
}
}
st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Slot: 5,
Validators: validators,
Fork: &pb.Fork{
Epoch: 0,
CurrentVersion: params.BeaconConfig().GenesisForkVersion,
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(5))
require.NoError(t, st.SetValidators(validators))
comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
require.NoError(t, err)
att1 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
Target: new(ethpb.Checkpoint),
Slot: 1,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
require.NoError(t, err)
@@ -696,11 +718,13 @@ func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) {
att2 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 1,
Target: new(ethpb.Checkpoint),
Slot: 1,
CommitteeIndex: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
root, err = helpers.ComputeSigningRoot(att2.Data, domain)
require.NoError(t, err)
@@ -723,32 +747,33 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
require.NoError(t, err)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
WithdrawalCredentials: make([]byte, 32),
}
}
st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Slot: 35,
Validators: validators,
Fork: &pb.Fork{
Epoch: 1,
CurrentVersion: []byte{0, 1, 2, 3},
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(35))
require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetFork(&pb.Fork{
Epoch: 1,
CurrentVersion: []byte{0, 1, 2, 3},
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
}))
comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
require.NoError(t, err)
att1 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
Target: new(ethpb.Checkpoint),
Slot: 1,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
prevDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch-1, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
require.NoError(t, err)
@@ -766,11 +791,13 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
att2 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
Data: &ethpb.AttestationData{
Slot: 1*params.BeaconConfig().SlotsPerEpoch + 1,
CommitteeIndex: 1,
Target: new(ethpb.Checkpoint),
Slot: 1*params.BeaconConfig().SlotsPerEpoch + 1,
CommitteeIndex: 1,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
currDomain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
root, err = helpers.ComputeSigningRoot(att2.Data, currDomain)
@@ -793,32 +820,28 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
require.NoError(t, err)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: keys[i].PublicKey().Marshal(),
WithdrawalCredentials: make([]byte, 32),
}
}
st, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Slot: 5,
Validators: validators,
Fork: &pb.Fork{
Epoch: 0,
CurrentVersion: params.BeaconConfig().GenesisForkVersion,
PreviousVersion: params.BeaconConfig().GenesisForkVersion,
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(5))
require.NoError(t, st.SetValidators(validators))
comm1, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 0 /*committeeIndex*/)
require.NoError(t, err)
att1 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm1))),
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
Target: new(ethpb.Checkpoint),
Slot: 1,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot())
require.NoError(t, err)
@@ -836,11 +859,13 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
att2 := &ethpb.Attestation{
AggregationBits: bitfield.NewBitlist(uint64(len(comm2))),
Data: &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 1,
Target: new(ethpb.Checkpoint),
Slot: 1,
CommitteeIndex: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
Signature: nil,
Signature: make([]byte, 96),
}
root, err = helpers.ComputeSigningRoot(att2.Data, domain)
require.NoError(t, err)

45
beacon-chain/core/blocks/attester_slashing_test.go
View File

@@ -11,6 +11,7 @@ import (
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -19,12 +20,14 @@ import (
func TestSlashableAttestationData_CanSlash(t *testing.T) {
att1 := &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 1},
Source: &ethpb.Checkpoint{Root: []byte{'A'}},
Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'A'}, 32)},
BeaconBlockRoot: make([]byte, 32),
}
att2 := &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 1},
Source: &ethpb.Checkpoint{Root: []byte{'B'}},
Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{'B'}, 32)},
BeaconBlockRoot: make([]byte, 32),
}
assert.Equal(t, true, blocks.IsSlashableAttestationData(att1, att2), "Atts should have been slashable")
att1.Target.Epoch = 4
@@ -38,15 +41,19 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
{
Attestation_1: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
},
Attestation_2: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 1},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
},
},
}
@@ -82,17 +89,21 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
{
Attestation_1: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
Signature: make([]byte, 96),
},
Attestation_2: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: make([]uint64, params.BeaconConfig().MaxValidatorsPerCommittee+1),
Signature: make([]byte, 96),
},
},
}
@@ -116,8 +127,9 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
att1 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{0, 1},
}
@@ -132,8 +144,9 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
att2 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{0, 1},
}

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

@@ -39,10 +39,12 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
root1 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '1'}
att1 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: root1[:]},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: setA,
Signature: make([]byte, 96),
}
domain, err := helpers.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
require.NoError(t, err)
@@ -59,10 +61,12 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
root2 := [32]byte{'d', 'o', 'u', 'b', 'l', 'e', '2'}
att2 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: root2[:]},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: root2[:]},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: setB,
Signature: make([]byte, 96),
}
signingRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
assert.NoError(t, err, "Could not get signing root of beacon block header")

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

@@ -197,7 +197,7 @@ func verifyDeposit(beaconState *stateTrie.BeaconState, deposit *ethpb.Deposit) e
}
receiptRoot := eth1Data.DepositRoot
leaf, err := ssz.HashTreeRoot(deposit.Data)
leaf, err := deposit.Data.HashTreeRoot()
if err != nil {
return errors.Wrap(err, "could not tree hash deposit data")
}
@@ -253,7 +253,7 @@ func verifyDepositDataWithDomain(ctx context.Context, deps []*ethpb.Deposit, dom
ObjectRoot: root[:],
Domain: domain,
}
ctrRoot, err := ssz.HashTreeRoot(signingData)
ctrRoot, err := signingData.HashTreeRoot()
if err != nil {
return errors.Wrap(err, "could not get container root")
}

18
beacon-chain/core/blocks/deposit_test.go
View File

@@ -5,7 +5,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -58,11 +57,12 @@ func TestProcessDeposits_SameValidatorMultipleDepositsSameBlock(t *testing.T) {
func TestProcessDeposits_MerkleBranchFailsVerification(t *testing.T) {
deposit := &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{1, 2, 3},
Signature: make([]byte, 96),
PublicKey: bytesutil.PadTo([]byte{1, 2, 3}, 48),
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
}
leaf, err := ssz.HashTreeRoot(deposit.Data)
leaf, err := deposit.Data.HashTreeRoot()
require.NoError(t, err)
// We then create a merkle branch for the test.
@@ -132,15 +132,17 @@ func TestProcessDeposits_RepeatedDeposit_IncreasesValidatorBalance(t *testing.T)
sk := bls.RandKey()
deposit := &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: sk.PublicKey().Marshal(),
Amount: 1000,
PublicKey: sk.PublicKey().Marshal(),
Amount: 1000,
WithdrawalCredentials: make([]byte, 32),
Signature: make([]byte, 96),
},
}
sr, err := helpers.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 8))
sr, err := helpers.ComputeSigningRoot(deposit.Data, bytesutil.ToBytes(3, 32))
require.NoError(t, err)
sig := sk.Sign(sr[:])
deposit.Data.Signature = sig.Marshal()
leaf, err := ssz.HashTreeRoot(deposit.Data)
leaf, err := deposit.Data.HashTreeRoot()
require.NoError(t, err)
// We then create a merkle branch for the test.

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

@@ -9,6 +9,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -19,7 +20,7 @@ func FakeDeposits(n uint64) []*ethpb.Eth1Data {
for i := uint64(0); i < n; i++ {
deposits[i] = &ethpb.Eth1Data{
DepositCount: 1,
DepositRoot: []byte("root"),
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
}
}
return deposits
@@ -36,7 +37,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
data: &ethpb.Eth1Data{
DepositCount: 1,
DepositRoot: []byte("root"),
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
hasSupport: true,
votingPeriodLength: 7,
@@ -44,7 +45,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
data: &ethpb.Eth1Data{
DepositCount: 1,
DepositRoot: []byte("root"),
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
hasSupport: false,
votingPeriodLength: 8,
@@ -52,7 +53,7 @@ func TestEth1DataHasEnoughSupport(t *testing.T) {
stateVotes: FakeDeposits(4 * params.BeaconConfig().SlotsPerEpoch),
data: &ethpb.Eth1Data{
DepositCount: 1,
DepositRoot: []byte("root"),
DepositRoot: bytesutil.PadTo([]byte("root"), 32),
},
hasSupport: false,
votingPeriodLength: 10,

21
beacon-chain/core/blocks/genesis.go
View File

@@ -10,13 +10,20 @@ import (
// NewGenesisBlock returns the canonical, genesis block for the beacon chain protocol.
func NewGenesisBlock(stateRoot []byte) *ethpb.SignedBeaconBlock {
zeroHash := params.BeaconConfig().ZeroHash[:]
genBlock := &ethpb.BeaconBlock{
ParentRoot: zeroHash,
StateRoot: stateRoot,
Body: &ethpb.BeaconBlockBody{},
}
return &ethpb.SignedBeaconBlock{
Block: genBlock,
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: zeroHash,
StateRoot: stateRoot,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: make([]byte, 96),
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: make([]byte, 32),
},
Graffiti: make([]byte, 32),
},
},
Signature: params.BeaconConfig().EmptySignature[:],
}
return block
}

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

@@ -6,13 +6,13 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -28,22 +28,22 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Validators: validators,
Slot: 10,
LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 10}, // Must be less than block.Slot
Fork: &pb.Fork{
PreviousVersion: []byte{0, 0, 0, 0},
CurrentVersion: []byte{0, 0, 0, 0},
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
require.NoError(t, err)
state := testutil.NewBeaconState()
require.NoError(t, state.SetSlot(10))
require.NoError(t, state.SetValidators(validators))
require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
Slot: 10, // Must be less than block.Slot
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
}))
latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
require.NoError(t, err)
@@ -52,16 +52,11 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
priv := bls.RandKey()
pID, err := helpers.BeaconProposerIndex(state)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: pID,
Slot: 10,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte{'A', 'B', 'C'},
},
ParentRoot: latestBlockSignedRoot[:],
},
}
block := testutil.NewBeaconBlock()
block.Block.ProposerIndex = pID
block.Block.Slot = 10
block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
block.Block.ParentRoot = latestBlockSignedRoot[:]
block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
require.NoError(t, err)
@@ -79,7 +74,12 @@ func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
testutil.ResetCache()
beaconState, privKeys := testutil.DeterministicGenesisState(t, 100)
require.NoError(t, beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{Slot: 9}))
require.NoError(t, beaconState.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
Slot: 9,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
}))
require.NoError(t, beaconState.SetSlot(10))
lbhdr, err := stateutil.BlockHeaderRoot(beaconState.LatestBlockHeader())
@@ -88,16 +88,11 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
proposerIdx, err := helpers.BeaconProposerIndex(beaconState)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: proposerIdx,
Slot: 10,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte{'A', 'B', 'C'},
},
ParentRoot: lbhdr[:],
},
}
block := testutil.NewBeaconBlock()
block.Block.ProposerIndex = proposerIdx
block.Block.Slot = 10
block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
block.Block.ParentRoot = lbhdr[:]
block.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx+1])
require.NoError(t, err)
@@ -110,24 +105,25 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Validators: validators,
Slot: 10,
LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
Fork: &pb.Fork{
PreviousVersion: []byte{0, 0, 0, 0},
CurrentVersion: []byte{0, 0, 0, 0},
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
require.NoError(t, err)
state := testutil.NewBeaconState()
require.NoError(t, state.SetValidators(validators))
require.NoError(t, state.SetSlot(10))
require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
Slot: 9,
ProposerIndex: 0,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
}))
lbhsr, err := ssz.HashTreeRoot(state.LatestBlockHeader())
lbhsr, err := state.LatestBlockHeader().HashTreeRoot()
require.NoError(t, err)
currentEpoch := helpers.CurrentEpoch(state)
@@ -155,8 +151,10 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
@@ -200,8 +198,10 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
@@ -248,22 +248,23 @@ func TestProcessBlockHeader_OK(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Validators: validators,
Slot: 10,
LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
Fork: &pb.Fork{
PreviousVersion: []byte{0, 0, 0, 0},
CurrentVersion: []byte{0, 0, 0, 0},
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
require.NoError(t, err)
state := testutil.NewBeaconState()
require.NoError(t, state.SetValidators(validators))
require.NoError(t, state.SetSlot(10))
require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
Slot: 9,
ProposerIndex: 0,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
}))
latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
require.NoError(t, err)
@@ -272,16 +273,11 @@ func TestProcessBlockHeader_OK(t *testing.T) {
priv := bls.RandKey()
pID, err := helpers.BeaconProposerIndex(state)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: pID,
Slot: 10,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte{'A', 'B', 'C'},
},
ParentRoot: latestBlockSignedRoot[:],
},
}
block := testutil.NewBeaconBlock()
block.Block.ProposerIndex = pID
block.Block.Slot = 10
block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
block.Block.ParentRoot = latestBlockSignedRoot[:]
block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
require.NoError(t, err)
bodyRoot, err := stateutil.BlockBodyRoot(block.Block.Body)
@@ -312,22 +308,23 @@ func TestBlockSignatureSet_OK(t *testing.T) {
validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
PublicKey: make([]byte, 32),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
Slashed: true,
}
}
state, err := stateTrie.InitializeFromProto(&pb.BeaconState{
Validators: validators,
Slot: 10,
LatestBlockHeader: &ethpb.BeaconBlockHeader{Slot: 9},
Fork: &pb.Fork{
PreviousVersion: []byte{0, 0, 0, 0},
CurrentVersion: []byte{0, 0, 0, 0},
},
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
})
require.NoError(t, err)
state := testutil.NewBeaconState()
require.NoError(t, state.SetValidators(validators))
require.NoError(t, state.SetSlot(10))
require.NoError(t, state.SetLatestBlockHeader(&ethpb.BeaconBlockHeader{
Slot: 9,
ProposerIndex: 0,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
}))
latestBlockSignedRoot, err := stateutil.BlockHeaderRoot(state.LatestBlockHeader())
require.NoError(t, err)
@@ -336,16 +333,11 @@ func TestBlockSignatureSet_OK(t *testing.T) {
priv := bls.RandKey()
pID, err := helpers.BeaconProposerIndex(state)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: pID,
Slot: 10,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte{'A', 'B', 'C'},
},
ParentRoot: latestBlockSignedRoot[:],
},
}
block := testutil.NewBeaconBlock()
block.Block.Slot = 10
block.Block.ProposerIndex = pID
block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
block.Block.ParentRoot = latestBlockSignedRoot[:]
block.Signature, err = helpers.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
require.NoError(t, err)
proposerIdx, err := helpers.BeaconProposerIndex(state)

21
beacon-chain/core/blocks/proposer_slashing_test.go
View File

@@ -98,14 +98,14 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
ProposerIndex: 0,
Slot: 0,
},
Signature: []byte("A"),
Signature: bytesutil.PadTo([]byte("A"), 96),
},
Header_2: &ethpb.SignedBeaconBlockHeader{
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: 0,
Slot: 0,
},
Signature: []byte("B"),
Signature: bytesutil.PadTo([]byte("B"), 96),
},
},
}
@@ -138,7 +138,9 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: proposerIdx,
Slot: 0,
StateRoot: []byte("A"),
ParentRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
StateRoot: bytesutil.PadTo([]byte("A"), 32),
},
}
var err error
@@ -149,7 +151,9 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: proposerIdx,
Slot: 0,
StateRoot: []byte("B"),
ParentRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
StateRoot: bytesutil.PadTo([]byte("B"), 32),
},
}
header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, 0, header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
@@ -162,13 +166,10 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
},
}
block := &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{
ProposerSlashings: slashings,
},
}
block := testutil.NewBeaconBlock()
block.Block.Body.ProposerSlashings = slashings
newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Body)
newState, err := blocks.ProcessProposerSlashings(context.Background(), beaconState, block.Block.Body)
require.NoError(t, err)
newStateVals := newState.Validators()

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

@@ -6,7 +6,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -26,7 +25,7 @@ func TestProcessRandao_IncorrectProposerFailsVerification(t *testing.T) {
binary.LittleEndian.PutUint64(buf, epoch)
domain, err := helpers.Domain(beaconState.Fork(), epoch, params.BeaconConfig().DomainRandao, beaconState.GenesisValidatorRoot())
require.NoError(t, err)
root, err := ssz.HashTreeRoot(&pb.SigningData{ObjectRoot: buf, Domain: domain})
root, err := (&pb.SigningData{ObjectRoot: buf, Domain: domain}).HashTreeRoot()
require.NoError(t, err)
// We make the previous validator's index sign the message instead of the proposer.
epochSignature := privKeys[proposerIdx-1].Sign(root[:])

3
beacon-chain/core/blocks/signature.go
View File

@@ -6,7 +6,6 @@ import (
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
@@ -29,7 +28,7 @@ func retrieveSignatureSet(signedData []byte, pub []byte, signature []byte, domai
ObjectRoot: signedData,
Domain: domain,
}
root, err := ssz.HashTreeRoot(signingData)
root, err := signingData.HashTreeRoot()
if err != nil {
return nil, errors.Wrap(err, "could not hash container")
}

2
beacon-chain/core/epoch/BUILD.bazel
View File

@@ -16,7 +16,6 @@ go_library(
"//shared/params:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
],
)
@@ -33,6 +32,7 @@ go_test(
"//beacon-chain/state:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
"//shared/params:go_default_library",
"//shared/testutil:go_default_library",
"//shared/testutil/assert:go_default_library",
"//shared/testutil/require:go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",

9
beacon-chain/core/epoch/epoch_processing.go
View File

@@ -10,7 +10,6 @@ import (
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/validators"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -46,7 +45,7 @@ func (s sortableIndices) Less(i, j int) bool {
// def get_attesting_balance(state: BeaconState, attestations: List[PendingAttestation]) -> Gwei:
// return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))
func AttestingBalance(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) (uint64, error) {
indices, err := unslashedAttestingIndices(state, atts)
indices, err := UnslashedAttestingIndices(state, atts)
if err != nil {
return 0, errors.Wrap(err, "could not get attesting indices")
}
@@ -311,7 +310,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
BlockRoots: state.BlockRoots(),
StateRoots: state.StateRoots(),
}
batchRoot, err := ssz.HashTreeRoot(historicalBatch)
batchRoot, err := historicalBatch.HashTreeRoot()
if err != nil {
return nil, errors.Wrap(err, "could not hash historical batch")
}
@@ -330,7 +329,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
return state, nil
}
// unslashedAttestingIndices returns all the attesting indices from a list of attestations,
// UnslashedAttestingIndices returns all the attesting indices from a list of attestations,
// it sorts the indices and filters out the slashed ones.
//
// Spec pseudocode definition:
@@ -340,7 +339,7 @@ func ProcessFinalUpdates(state *stateTrie.BeaconState) (*stateTrie.BeaconState,
// for a in attestations:
// output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
// return set(filter(lambda index: not state.validators[index].slashed, output))
func unslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]uint64, error) {
func UnslashedAttestingIndices(state *stateTrie.BeaconState, atts []*pb.PendingAttestation) ([]uint64, error) {
var setIndices []uint64
seen := make(map[uint64]bool)

84
beacon-chain/core/epoch/epoch_processing_test.go
View File

@@ -1,4 +1,4 @@
package epoch
package epoch_test
import (
"bytes"
@@ -7,10 +7,12 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/state"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
@@ -20,8 +22,8 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
atts := make([]*pb.PendingAttestation, 2)
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Epoch: 0},
Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
}
@@ -42,7 +44,7 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
indices, err := unslashedAttestingIndices(state, atts)
indices, err := epoch.UnslashedAttestingIndices(state, atts)
require.NoError(t, err)
for i := 0; i < len(indices)-1; i++ {
if indices[i] >= indices[i+1] {
@@ -55,7 +57,7 @@ func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
validators = state.Validators()
validators[slashedValidator].Slashed = true
require.NoError(t, state.SetValidators(validators))
indices, err = unslashedAttestingIndices(state, atts)
indices, err = epoch.UnslashedAttestingIndices(state, atts)
require.NoError(t, err)
for i := 0; i < len(indices); i++ {
assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
@@ -67,7 +69,7 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
atts := make([]*pb.PendingAttestation, 5)
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{},
Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0}},
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF},
}
@@ -88,7 +90,7 @@ func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
indices, err := unslashedAttestingIndices(state, atts)
indices, err := epoch.UnslashedAttestingIndices(state, atts)
require.NoError(t, err)
for i := 0; i < len(indices)-1; i++ {
@@ -105,8 +107,8 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Slot: uint64(i),
},
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -134,7 +136,7 @@ func TestAttestingBalance_CorrectBalance(t *testing.T) {
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
balance, err := AttestingBalance(state, atts)
balance, err := epoch.AttestingBalance(state, atts)
require.NoError(t, err)
wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
assert.Equal(t, wanted, balance)
@@ -159,9 +161,9 @@ func TestBaseReward_AccurateRewards(t *testing.T) {
}
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
c, err := BaseReward(state, 0)
c, err := epoch.BaseReward(state, 0)
require.NoError(t, err)
assert.Equal(t, tt.c, c, "BaseReward(%d)", tt.a)
assert.Equal(t, tt.c, c, "epoch.BaseReward(%d)", tt.a)
}
}
@@ -174,7 +176,7 @@ func TestProcessSlashings_NotSlashed(t *testing.T) {
}
s, err := state.InitializeFromProto(base)
require.NoError(t, err)
newState, err := ProcessSlashings(s)
newState, err := epoch.ProcessSlashings(s)
require.NoError(t, err)
wanted := params.BeaconConfig().MaxEffectiveBalance
assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
@@ -252,7 +254,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
original := proto.Clone(tt.state)
s, err := state.InitializeFromProto(tt.state)
require.NoError(t, err)
newState, err := ProcessSlashings(s)
newState, err := epoch.ProcessSlashings(s)
require.NoError(t, err)
assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
})
@@ -260,7 +262,7 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
}
func TestProcessFinalUpdates_CanProcess(t *testing.T) {
s := buildState(params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
s := buildState(t, params.BeaconConfig().SlotsPerHistoricalRoot-1, params.BeaconConfig().SlotsPerEpoch)
ce := helpers.CurrentEpoch(s)
ne := ce + 1
require.NoError(t, s.SetEth1DataVotes([]*ethpb.Eth1Data{}))
@@ -275,7 +277,7 @@ func TestProcessFinalUpdates_CanProcess(t *testing.T) {
mixes := s.RandaoMixes()
mixes[ce] = []byte{'A'}
require.NoError(t, s.SetRandaoMixes(mixes))
newS, err := ProcessFinalUpdates(s)
newS, err := epoch.ProcessFinalUpdates(s)
require.NoError(t, err)
// Verify effective balance is correctly updated.
@@ -306,11 +308,11 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
params.BeaconConfig().MaxEffectiveBalance,
params.BeaconConfig().MaxEffectiveBalance,
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
newState, err := ProcessRegistryUpdates(state)
newState, err := epoch.ProcessRegistryUpdates(state)
require.NoError(t, err)
for i, validator := range newState.Validators() {
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d", i)
@@ -320,7 +322,7 @@ func TestProcessRegistryUpdates_NoRotation(t *testing.T) {
func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
base := &pb.BeaconState{
Slot: 5 * params.BeaconConfig().SlotsPerEpoch,
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6},
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 6, Root: make([]byte, 32)},
}
limit, err := helpers.ValidatorChurnLimit(0)
require.NoError(t, err)
@@ -333,7 +335,7 @@ func TestProcessRegistryUpdates_EligibleToActivate(t *testing.T) {
}
state, err := state.InitializeFromProto(base)
currentEpoch := helpers.CurrentEpoch(state)
newState, err := ProcessRegistryUpdates(state)
newState, err := epoch.ProcessRegistryUpdates(state)
require.NoError(t, err)
for i, validator := range newState.Validators() {
assert.Equal(t, currentEpoch+1, validator.ActivationEligibilityEpoch, "Could not update registry %d, unexpected activation eligibility epoch", i)
@@ -357,11 +359,11 @@ func TestProcessRegistryUpdates_ActivationCompletes(t *testing.T) {
{ExitEpoch: params.BeaconConfig().MaxSeedLookahead,
ActivationEpoch: 5 + params.BeaconConfig().MaxSeedLookahead + 1},
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
newState, err := ProcessRegistryUpdates(state)
newState, err := epoch.ProcessRegistryUpdates(state)
require.NoError(t, err)
for i, validator := range newState.Validators() {
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -381,11 +383,11 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
EffectiveBalance: params.BeaconConfig().EjectionBalance - 1,
},
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
newState, err := ProcessRegistryUpdates(state)
newState, err := epoch.ProcessRegistryUpdates(state)
require.NoError(t, err)
for i, validator := range newState.Validators() {
assert.Equal(t, params.BeaconConfig().MaxSeedLookahead+1, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
@@ -393,11 +395,11 @@ func TestProcessRegistryUpdates_ValidatorsEjected(t *testing.T) {
}
func TestProcessRegistryUpdates_CanExits(t *testing.T) {
epoch := uint64(5)
exitEpoch := helpers.ActivationExitEpoch(epoch)
e := uint64(5)
exitEpoch := helpers.ActivationExitEpoch(e)
minWithdrawalDelay := params.BeaconConfig().MinValidatorWithdrawabilityDelay
base := &pb.BeaconState{
Slot: epoch * params.BeaconConfig().SlotsPerEpoch,
Slot: e * params.BeaconConfig().SlotsPerEpoch,
Validators: []*ethpb.Validator{
{
ExitEpoch: exitEpoch,
@@ -406,18 +408,18 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
ExitEpoch: exitEpoch,
WithdrawableEpoch: exitEpoch + minWithdrawalDelay},
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
state, err := state.InitializeFromProto(base)
require.NoError(t, err)
newState, err := ProcessRegistryUpdates(state)
newState, err := epoch.ProcessRegistryUpdates(state)
require.NoError(t, err)
for i, validator := range newState.Validators() {
assert.Equal(t, exitEpoch, validator.ExitEpoch, "Could not update registry %d, unexpected exit slot", i)
}
}
func buildState(slot uint64, validatorCount uint64) *state.BeaconState {
func buildState(t testing.TB, slot uint64, validatorCount uint64) *state.BeaconState {
validators := make([]*ethpb.Validator, validatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
@@ -443,19 +445,15 @@ func buildState(slot uint64, validatorCount uint64) *state.BeaconState {
for i := 0; i < len(latestRandaoMixes); i++ {
latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
}
s, err := state.InitializeFromProto(&pb.BeaconState{
Slot: slot,
Balances: validatorBalances,
Validators: validators,
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
Slashings: make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
BlockRoots: make([][]byte, params.BeaconConfig().SlotsPerEpoch*10),
FinalizedCheckpoint: &ethpb.Checkpoint{},
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{},
})
if err != nil {
panic(err)
s := testutil.NewBeaconState()
if err := s.SetSlot(slot); err != nil {
t.Error(err)
}
if err := s.SetBalances(validatorBalances); err != nil {
t.Error(err)
}
if err := s.SetValidators(validators); err != nil {
t.Error(err)
}
return s
}

6
beacon-chain/core/epoch/precompute/justification_finalization_test.go
View File

@@ -30,7 +30,7 @@ func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *test
Epoch: 0,
Root: params.BeaconConfig().ZeroHash[:],
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
JustificationBits: bitfield.Bitvector4{0x0F}, // 0b1111
Validators: []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
Balances: []uint64{a, a, a, a}, // validator total balance should be 128000000000
@@ -67,7 +67,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *te
Epoch: 0,
Root: params.BeaconConfig().ZeroHash[:],
},
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
JustificationBits: bitfield.Bitvector4{0x03}, // 0b0011
Validators: []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
Balances: []uint64{a, a, a, a}, // validator total balance should be 128000000000
@@ -107,7 +107,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
JustificationBits: bitfield.Bitvector4{0x03}, // 0b0011
Validators: []*ethpb.Validator{{ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}, {ExitEpoch: e}},
Balances: []uint64{a, a, a, a}, // validator total balance should be 128000000000
BlockRoots: blockRoots, FinalizedCheckpoint: &ethpb.Checkpoint{},
BlockRoots: blockRoots, FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
state, err := beaconstate.InitializeFromProto(base)
require.NoError(t, err)

14
beacon-chain/core/epoch/precompute/reward_penalty_test.go
View File

@@ -24,8 +24,8 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
InclusionDelay: 1,
@@ -214,8 +214,8 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
InclusionDelay: 1,
@@ -287,9 +287,9 @@ func buildState(slot uint64, validatorCount uint64) *pb.BeaconState {
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
Slashings: make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector),
BlockRoots: make([][]byte, params.BeaconConfig().SlotsPerEpoch*10),
FinalizedCheckpoint: &ethpb.Checkpoint{},
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
}
}

2
beacon-chain/core/feed/state/events.go
View File

@@ -45,7 +45,7 @@ type SyncedData struct {
type InitializedData struct {
// StartTime is the time at which the chain started.
StartTime time.Time
// GenesisValidatorsRoot represents ssz.HashTreeRoot(state.validators).
// GenesisValidatorsRoot represents state.validators.HashTreeRoot().
GenesisValidatorsRoot []byte
}

2
beacon-chain/core/helpers/BUILD.bazel
View File

@@ -40,6 +40,7 @@ go_library(
"//shared/params:go_default_library",
"//shared/roughtime:go_default_library",
"//shared/sliceutil:go_default_library",
"@com_github_ferranbt_fastssz//:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_bitfield//:go_default_library",
@@ -66,7 +67,6 @@ go_test(
deps = [
"//beacon-chain/cache:go_default_library",
"//beacon-chain/state:go_default_library",
"//beacon-chain/state/stateutil:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
"//shared/bls:go_default_library",
"//shared/bytesutil:go_default_library",

12
beacon-chain/core/helpers/committee_test.go
View File

@@ -263,7 +263,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0x05},
Data: &ethpb.AttestationData{
CommitteeIndex: 5,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 5,
@@ -274,7 +274,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0x06},
Data: &ethpb.AttestationData{
CommitteeIndex: 10,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 10,
@@ -284,7 +284,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0x06},
Data: &ethpb.AttestationData{
CommitteeIndex: 20,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 20,
@@ -294,7 +294,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0x06},
Data: &ethpb.AttestationData{
CommitteeIndex: 20,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 20,
@@ -304,7 +304,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0xFF, 0xC0, 0x01},
Data: &ethpb.AttestationData{
CommitteeIndex: 5,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 5,
@@ -315,7 +315,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
AggregationBits: bitfield.Bitlist{0xFF, 0x01},
Data: &ethpb.AttestationData{
CommitteeIndex: 20,
Target: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
stateSlot: 20,

21
beacon-chain/core/helpers/signing_root.go
View File

@@ -1,6 +1,7 @@
package helpers
import (
fssz "github.com/ferranbt/fastssz"
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
@@ -48,16 +49,14 @@ func ComputeDomainAndSign(state *state.BeaconState, epoch uint64, obj interface{
// domain=domain,
// ))
func ComputeSigningRoot(object interface{}, domain []byte) ([32]byte, error) {
if object == nil {
return [32]byte{}, errors.New("cannot compute signing root of nil")
}
return signingData(func() ([32]byte, error) {
switch t := object.(type) {
case *ethpb.BeaconBlock:
return stateutil.BlockRoot(t)
case *ethpb.AttestationData:
return stateutil.AttestationDataRoot(t)
default:
// utilise generic ssz library
return ssz.HashTreeRoot(object)
if v, ok := object.(fssz.HashRoot); ok {
return v.HashTreeRoot()
}
return ssz.HashTreeRoot(object)
}, domain)
}
@@ -72,7 +71,7 @@ func signingData(rootFunc func() ([32]byte, error), domain []byte) ([32]byte, er
ObjectRoot: objRoot[:],
Domain: domain,
}
return ssz.HashTreeRoot(container)
return container.HashTreeRoot()
}
// ComputeDomainVerifySigningRoot computes domain and verifies signing root of an object given the beacon state, validator index and signature.
@@ -225,10 +224,10 @@ func domain(domainType [DomainByteLength]byte, forkDataRoot []byte) []byte {
// genesis_validators_root=genesis_validators_root,
// ))
func computeForkDataRoot(version []byte, root []byte) ([32]byte, error) {
r, err := ssz.HashTreeRoot(&pb.ForkData{
r, err := (&pb.ForkData{
CurrentVersion: version,
GenesisValidatorsRoot: root,
})
}).HashTreeRoot()
if err != nil {
return [32]byte{}, err
}

53
beacon-chain/core/helpers/signing_root_test.go
View File

@@ -1,21 +1,21 @@
package helpers
package helpers_test
import (
"bytes"
"testing"
fuzz "github.com/google/gofuzz"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
ethereum_beacon_p2p_v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
func TestSigningRoot_ComputeOK(t *testing.T) {
emptyBlock := &ethpb.BeaconBlock{}
_, err := ComputeSigningRoot(emptyBlock, []byte{'T', 'E', 'S', 'T'})
emptyBlock := testutil.NewBeaconBlock()
_, err := helpers.ComputeSigningRoot(emptyBlock, bytesutil.PadTo([]byte{'T', 'E', 'S', 'T'}, 32))
assert.NoError(t, err, "Could not compute signing root of block")
}
@@ -25,38 +25,21 @@ func TestComputeDomain_OK(t *testing.T) {
domainType [4]byte
domain []byte
}{
{epoch: 1, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{epoch: 2, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{epoch: 2, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{epoch: 3, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{epoch: 3, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{epoch: 1, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}},
{epoch: 2, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}},
{epoch: 2, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}},
{epoch: 3, domainType: [4]byte{4, 0, 0, 0}, domain: []byte{4, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}},
{epoch: 3, domainType: [4]byte{5, 0, 0, 0}, domain: []byte{5, 0, 0, 0, 245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169}},
}
for _, tt := range tests {
if !bytes.Equal(domain(tt.domainType, params.BeaconConfig().ZeroHash[:]), tt.domain) {
t.Errorf("wanted domain version: %d, got: %d", tt.domain, domain(tt.domainType, params.BeaconConfig().ZeroHash[:]))
if got, err := helpers.ComputeDomain(tt.domainType, nil, nil); !bytes.Equal(got, tt.domain) {
t.Errorf("wanted domain version: %d, got: %d", tt.domain, got)
} else {
require.NoError(t, err)
}
}
}
func TestSigningRoot_Compatibility(t *testing.T) {
parRoot := [32]byte{'A'}
stateRoot := [32]byte{'B'}
blk := &ethpb.BeaconBlock{
Slot: 20,
ProposerIndex: 20,
ParentRoot: parRoot[:],
StateRoot: stateRoot[:],
Body: &ethpb.BeaconBlockBody{},
}
root, err := ComputeSigningRoot(blk, params.BeaconConfig().DomainBeaconProposer[:])
require.NoError(t, err)
newRoot, err := signingData(func() ([32]byte, error) {
return stateutil.BlockRoot(blk)
}, params.BeaconConfig().DomainBeaconProposer[:])
require.NoError(t, err)
assert.Equal(t, root, newRoot, "Wanted root of %#x but got %#x", root, newRoot)
}
func TestComputeForkDigest_OK(t *testing.T) {
tests := []struct {
version []byte
@@ -68,7 +51,7 @@ func TestComputeForkDigest_OK(t *testing.T) {
{version: []byte{'b', 'w', 'r', 't'}, root: [32]byte{'r', 'd', 'c'}, result: [4]byte{0x83, 0x34, 0x38, 0x88}},
}
for _, tt := range tests {
digest, err := ComputeForkDigest(tt.version, tt.root[:])
digest, err := helpers.ComputeForkDigest(tt.version, tt.root[:])
require.NoError(t, err)
assert.Equal(t, tt.result, digest, "Wanted domain version: %#x, got: %#x", digest, tt.result)
}
@@ -92,8 +75,8 @@ func TestFuzzverifySigningRoot_10000(t *testing.T) {
fuzzer.Fuzz(&p)
fuzzer.Fuzz(&s)
fuzzer.Fuzz(&d)
err := VerifySigningRoot(state, pubkey[:], sig[:], domain[:])
err = VerifySigningRoot(state, p, s, d)
err := helpers.VerifySigningRoot(state, pubkey[:], sig[:], domain[:])
err = helpers.VerifySigningRoot(state, p, s, d)
_ = err
}
}

2
beacon-chain/core/helpers/validators_test.go
View File

@@ -731,7 +731,7 @@ func TestIsIsEligibleForActivation(t *testing.T) {
true},
{"Not yet finalized",
&ethpb.Validator{ActivationEligibilityEpoch: 1, ActivationEpoch: params.BeaconConfig().FarFutureEpoch},
&pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{}},
&pb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}},
false},
{"Incorrect activation epoch",
&ethpb.Validator{ActivationEligibilityEpoch: 1},

2
beacon-chain/core/state/BUILD.bazel
View File

@@ -38,7 +38,6 @@ go_library(
"//shared/trieutil:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@io_opencensus_go//trace:go_default_library",
],
@@ -70,6 +69,7 @@ go_test(
"//shared/attestationutil:go_default_library",
"//shared/benchutil:go_default_library",
"//shared/bls:go_default_library",
"//shared/bytesutil:go_default_library",
"//shared/hashutil:go_default_library",
"//shared/params:go_default_library",
"//shared/testutil:go_default_library",

3
beacon-chain/core/state/benchmarks_test.go
View File

@@ -5,7 +5,6 @@ import (
"testing"
"github.com/gogo/protobuf/proto"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
beaconstate "github.com/prysmaticlabs/prysm/beacon-chain/state"
@@ -101,7 +100,7 @@ func BenchmarkHashTreeRoot_FullState(b *testing.B) {
b.N = 50
b.ResetTimer()
for i := 0; i < b.N; i++ {
if _, err := ssz.HashTreeRoot(beaconState); err != nil {
if _, err := beaconState.HashTreeRoot(context.Background()); err != nil {
b.Fatal(err)
}
}

3
beacon-chain/core/state/state.go
View File

@@ -9,7 +9,6 @@ import (
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
@@ -70,7 +69,7 @@ func GenesisBeaconState(deposits []*ethpb.Deposit, genesisTime uint64, eth1Data
if deposit == nil || deposit.Data == nil {
return nil, fmt.Errorf("nil deposit or deposit with nil data cannot be processed: %v", deposit)
}
hash, err := ssz.HashTreeRoot(deposit.Data)
hash, err := deposit.Data.HashTreeRoot()
if err != nil {
return nil, err
}

187
beacon-chain/core/state/transition_test.go
View File

@@ -9,7 +9,6 @@ import (
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
@@ -18,6 +17,7 @@ import (
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/attestationutil"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/hashutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
@@ -52,7 +52,8 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
eth1Data := &ethpb.Eth1Data{
DepositCount: 100,
DepositRoot: []byte{2},
DepositRoot: bytesutil.PadTo([]byte{2}, 32),
BlockHash: make([]byte, 32),
}
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1))
e := beaconState.Eth1Data()
@@ -76,17 +77,12 @@ func TestExecuteStateTransition_FullProcess(t *testing.T) {
require.NoError(t, nextSlotState.SetSlot(beaconState.Slot()+1))
proposerIdx, err := helpers.BeaconProposerIndex(nextSlotState)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: proposerIdx,
Slot: beaconState.Slot() + 1,
ParentRoot: parentRoot[:],
Body: &ethpb.BeaconBlockBody{
RandaoReveal: randaoReveal,
Eth1Data: eth1Data,
},
},
}
block := testutil.NewBeaconBlock()
block.Block.ProposerIndex = proposerIdx
block.Block.Slot = beaconState.Slot() + 1
block.Block.ParentRoot = parentRoot[:]
block.Block.Body.RandaoReveal = randaoReveal
block.Block.Body.Eth1Data = eth1Data
stateRoot, err := state.CalculateStateRoot(context.Background(), beaconState, block)
require.NoError(t, err)
@@ -114,7 +110,8 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
eth1Data := &ethpb.Eth1Data{
DepositCount: 100,
DepositRoot: []byte{2},
DepositRoot: bytesutil.PadTo([]byte{2}, 32),
BlockHash: make([]byte, 32),
}
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1))
e := beaconState.Eth1Data()
@@ -135,17 +132,12 @@ func TestExecuteStateTransitionNoVerify_FullProcess(t *testing.T) {
require.NoError(t, nextSlotState.SetSlot(beaconState.Slot()+1))
proposerIdx, err := helpers.BeaconProposerIndex(nextSlotState)
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: proposerIdx,
Slot: beaconState.Slot() + 1,
ParentRoot: parentRoot[:],
Body: &ethpb.BeaconBlockBody{
RandaoReveal: randaoReveal,
Eth1Data: eth1Data,
},
},
}
block := testutil.NewBeaconBlock()
block.Block.ProposerIndex = proposerIdx
block.Block.Slot = beaconState.Slot() + 1
block.Block.ParentRoot = parentRoot[:]
block.Block.Body.RandaoReveal = randaoReveal
block.Block.Body.Eth1Data = eth1Data
stateRoot, err := state.CalculateStateRoot(context.Background(), beaconState, block)
require.NoError(t, err)
@@ -169,8 +161,24 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
require.NoError(t, err)
slashing := &ethpb.ProposerSlashing{
Header_1: &ethpb.SignedBeaconBlockHeader{Header: &ethpb.BeaconBlockHeader{Slot: params.BeaconConfig().SlotsPerEpoch}},
Header_2: &ethpb.SignedBeaconBlockHeader{Header: &ethpb.BeaconBlockHeader{Slot: params.BeaconConfig().SlotsPerEpoch * 2}},
Header_1: &ethpb.SignedBeaconBlockHeader{
Header: &ethpb.BeaconBlockHeader{
Slot: params.BeaconConfig().SlotsPerEpoch,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
},
Header_2: &ethpb.SignedBeaconBlockHeader{
Header: &ethpb.BeaconBlockHeader{
Slot: params.BeaconConfig().SlotsPerEpoch * 2,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
},
}
block.Block.Body.ProposerSlashings = []*ethpb.ProposerSlashing{slashing}
@@ -193,10 +201,12 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: bitfield.NewBitlist(3),
Signature: bls.RandKey().Sign([]byte("foo")).Marshal(),
}
block, err := testutil.GenerateFullBlock(beaconState, privKeys, nil, 1)
@@ -212,7 +222,7 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
beaconState, err = state.ProcessSlots(context.Background(), beaconState, 1)
require.NoError(t, err)
want := "could not process block attestations"
want := "could not verify attestations"
_, err = state.ProcessBlock(context.Background(), beaconState, block)
assert.ErrorContains(t, want, err)
}
@@ -226,15 +236,21 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: 3,
Slot: 1,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
Signature: []byte("A"),
Signature: bytesutil.PadTo([]byte("A"), 96),
},
Header_2: &ethpb.SignedBeaconBlockHeader{
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: 3,
Slot: 1,
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
Signature: []byte("B"),
Signature: bytesutil.PadTo([]byte("B"), 96),
},
},
}
@@ -242,17 +258,19 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
{
Attestation_1: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
AttestingIndices: []uint64{0, 1},
Signature: make([]byte, 96),
},
Attestation_2: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 1},
Target: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 1, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
AttestingIndices: []uint64{0, 1},
Signature: make([]byte, 96),
},
},
}
@@ -263,7 +281,7 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
require.NoError(t, beaconState.SetBlockRoots(blockRoots))
blockAtt := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0},
Source: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Epoch: 0, Root: []byte("hello-world")},
},
AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
@@ -280,23 +298,24 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
Slot: genesisBlock.Block.Slot,
ParentRoot: genesisBlock.Block.ParentRoot,
BodyRoot: bodyRoot[:],
StateRoot: make([]byte, 32),
})
require.NoError(t, err)
parentRoot, err := ssz.HashTreeRoot(beaconState.LatestBlockHeader())
parentRoot, err := beaconState.LatestBlockHeader().HashTreeRoot()
require.NoError(t, err)
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: parentRoot[:],
Slot: 1,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: []byte{},
RandaoReveal: make([]byte, 96),
ProposerSlashings: proposerSlashings,
AttesterSlashings: attesterSlashings,
Attestations: attestations,
VoluntaryExits: exits,
Eth1Data: &ethpb.Eth1Data{
DepositRoot: []byte{2},
BlockHash: []byte{3},
DepositRoot: bytesutil.PadTo([]byte{2}, 32),
BlockHash: bytesutil.PadTo([]byte{3}, 32),
},
},
},
@@ -343,7 +362,9 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: proposerSlashIdx,
Slot: 1,
StateRoot: []byte("A"),
StateRoot: bytesutil.PadTo([]byte("A"), 32),
ParentRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
}
header1.Signature, err = helpers.ComputeDomainAndSign(beaconState, currentEpoch, header1.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
@@ -353,7 +374,9 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: proposerSlashIdx,
Slot: 1,
StateRoot: []byte("B"),
StateRoot: bytesutil.PadTo([]byte("B"), 32),
ParentRoot: make([]byte, 32),
BodyRoot: make([]byte, 32),
},
}
header2.Signature, err = helpers.ComputeDomainAndSign(beaconState, helpers.CurrentEpoch(beaconState), header2.Header, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerSlashIdx])
@@ -372,9 +395,12 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
mockRoot2 := [32]byte{'A'}
att1 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot2[:]},
Target: &ethpb.Checkpoint{Epoch: 0}},
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot2[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{0, 1},
Signature: make([]byte, 96),
}
domain, err := helpers.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorRoot())
require.NoError(t, err)
@@ -388,9 +414,12 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
mockRoot3 := [32]byte{'B'}
att2 := &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot3[:]},
Target: &ethpb.Checkpoint{Epoch: 0}},
Source: &ethpb.Checkpoint{Epoch: 0, Root: mockRoot3[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AttestingIndices: []uint64{0, 1},
Signature: make([]byte, 96),
}
hashTreeRoot, err = helpers.ComputeSigningRoot(att2.Data, domain)
@@ -417,13 +446,15 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
aggBits.SetBitAt(0, true)
blockAtt := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: beaconState.Slot(),
Target: &ethpb.Checkpoint{Epoch: helpers.CurrentEpoch(beaconState)},
Slot: beaconState.Slot(),
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Epoch: helpers.CurrentEpoch(beaconState), Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: mockRoot[:],
}},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
committee, err := helpers.BeaconCommitteeFromState(beaconState, blockAtt.Data.Slot, blockAtt.Data.CommitteeIndex)
@@ -467,14 +498,15 @@ func createFullBlockWithOperations(t *testing.T) (*beaconstate.BeaconState,
Slot: beaconState.Slot() + 1,
ProposerIndex: proposerIndex,
Body: &ethpb.BeaconBlockBody{
Graffiti: make([]byte, 32),
RandaoReveal: randaoReveal,
ProposerSlashings: proposerSlashings,
AttesterSlashings: attesterSlashings,
Attestations: []*ethpb.Attestation{blockAtt},
VoluntaryExits: []*ethpb.SignedVoluntaryExit{exit},
Eth1Data: &ethpb.Eth1Data{
DepositRoot: []byte{2},
BlockHash: []byte{3},
DepositRoot: bytesutil.PadTo([]byte{2}, 32),
BlockHash: bytesutil.PadTo([]byte{3}, 32),
},
},
},
@@ -522,7 +554,7 @@ func TestProcessBlockNoVerify_PassesProcessingConditions(t *testing.T) {
func TestProcessEpochPrecompute_CanProcess(t *testing.T) {
epoch := uint64(1)
atts := []*pb.PendingAttestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{}}, InclusionDelay: 1}}
atts := []*pb.PendingAttestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{Root: make([]byte, 32)}}, InclusionDelay: 1}}
slashing := make([]uint64, params.BeaconConfig().EpochsPerSlashingsVector)
base := &pb.BeaconState{
Slot: epoch*params.BeaconConfig().SlotsPerEpoch + 1,
@@ -530,9 +562,9 @@ func TestProcessEpochPrecompute_CanProcess(t *testing.T) {
Slashings: slashing,
RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
CurrentEpochAttestations: atts,
FinalizedCheckpoint: &ethpb.Checkpoint{},
FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
JustificationBits: bitfield.Bitvector4{0x00},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)},
Validators: []*ethpb.Validator{},
}
s, err := beaconstate.InitializeFromProto(base)
@@ -592,14 +624,14 @@ func BenchmarkProcessBlk_65536Validators_FullBlock(b *testing.B) {
ProposerIndex: 1,
Slot: 0,
},
Signature: []byte("A"),
Signature: bytesutil.PadTo([]byte("A"), 96),
},
Header_2: &ethpb.SignedBeaconBlockHeader{
Header: &ethpb.BeaconBlockHeader{
ProposerIndex: 1,
Slot: 0,
},
Signature: []byte("B"),
Signature: bytesutil.PadTo([]byte("B"), 96),
},
},
}
@@ -608,11 +640,19 @@ func BenchmarkProcessBlk_65536Validators_FullBlock(b *testing.B) {
attesterSlashings := []*ethpb.AttesterSlashing{
{
Attestation_1: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{},
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AttestingIndices: []uint64{2, 3},
},
Attestation_2: &ethpb.IndexedAttestation{
Data: &ethpb.AttestationData{},
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AttestingIndices: []uint64{2, 3},
},
},
@@ -625,7 +665,7 @@ func BenchmarkProcessBlk_65536Validators_FullBlock(b *testing.B) {
Amount: params.BeaconConfig().MaxEffectiveBalance,
},
}
leaf, err := ssz.HashTreeRoot(deposit.Data)
leaf, err := deposit.Data.HashTreeRoot()
require.NoError(b, err)
depositTrie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
require.NoError(b, err, "Could not generate trie")
@@ -648,7 +688,7 @@ func BenchmarkProcessBlk_65536Validators_FullBlock(b *testing.B) {
ObjectRoot: buf,
Domain: domain,
}
root, err = ssz.HashTreeRoot(ctr)
root, err = ctr.HashTreeRoot()
require.NoError(b, err)
epochSignature := priv.Sign(root[:])
@@ -725,10 +765,13 @@ func TestProcessBlk_AttsBasedOnValidatorCount(t *testing.T) {
for i := 0; i < len(atts); i++ {
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0}},
Slot: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
committee, err := helpers.BeaconCommitteeFromState(s, att.Data.Slot, att.Data.CommitteeIndex)
@@ -764,18 +807,12 @@ func TestProcessBlk_AttsBasedOnValidatorCount(t *testing.T) {
require.NoError(t, nextSlotState.SetSlot(s.Slot()+1))
proposerIdx, err := helpers.BeaconProposerIndex(nextSlotState)
require.NoError(t, err)
blk := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: proposerIdx,
Slot: s.Slot() + 1,
ParentRoot: parentRoot[:],
Body: &ethpb.BeaconBlockBody{
Eth1Data: &ethpb.Eth1Data{},
RandaoReveal: epochSignature,
Attestations: atts,
},
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ProposerIndex = proposerIdx
blk.Block.Slot = s.Slot() + 1
blk.Block.ParentRoot = parentRoot[:]
blk.Block.Body.RandaoReveal = epochSignature
blk.Block.Body.Attestations = atts
sig, err := testutil.BlockSignature(s, blk.Block, privKeys)
require.NoError(t, err)
blk.Signature = sig.Marshal()

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

@@ -18,6 +18,7 @@ go_library(
"//shared/featureconfig:go_default_library",
"//shared/traceutil:go_default_library",
"@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_ferranbt_fastssz//:go_default_library",
"@com_github_golang_protobuf//jsonpb:go_default_library_gen",
"@com_github_golang_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",

9
beacon-chain/db/kafka/export_wrapper.go
View File

@@ -6,6 +6,7 @@ import (
"bytes"
"context"
fssz "github.com/ferranbt/fastssz"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
@@ -55,7 +56,13 @@ func (e Exporter) publish(ctx context.Context, topic string, msg proto.Message)
return err
}
key, err := ssz.HashTreeRoot(msg)
var key [32]byte
var err error
if v, ok := msg.(fssz.HashRoot); ok {
key, err = v.HashTreeRoot()
} else {
key, err = ssz.HashTreeRoot(msg)
}
if err != nil {
traceutil.AnnotateError(span, err)
return err

2
beacon-chain/db/kv/BUILD.bazel
View File

@@ -50,7 +50,6 @@ go_library(
"@com_github_pkg_errors//:go_default_library",
"@com_github_prometheus_client_golang//prometheus:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_prysmaticlabs_prombbolt//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@io_etcd_go_bbolt//:go_default_library",
@@ -94,7 +93,6 @@ go_test(
"@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
"@io_etcd_go_bbolt//:go_default_library",
],

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

@@ -6,7 +6,6 @@ import (
"path"
"testing"
eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
@@ -16,7 +15,8 @@ func TestStore_Backup(t *testing.T) {
db := setupDB(t)
ctx := context.Background()
head := &eth.SignedBeaconBlock{Block: &eth.BeaconBlock{Slot: 5000}}
head := testutil.NewBeaconBlock()
head.Block.Slot = 5000
require.NoError(t, db.SaveBlock(ctx, head))
root, err := stateutil.BlockRoot(head.Block)

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

@@ -22,19 +22,14 @@ func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
slot := uint64(20)
ctx := context.Background()
// First we save a previous block to ensure the cache max size is reached.
prevBlock := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: slot - 1,
ParentRoot: bytesutil.PadTo([]byte{1, 2, 3}, 32),
},
}
prevBlock := testutil.NewBeaconBlock()
prevBlock.Block.Slot = slot - 1
prevBlock.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
require.NoError(t, db.SaveBlock(ctx, prevBlock))
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: slot,
ParentRoot: bytesutil.PadTo([]byte{1, 2, 3}, 32),
},
}
block := testutil.NewBeaconBlock()
block.Block.Slot = slot
block.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
// Even with a full cache, saving new blocks should not cause
// duplicated blocks in the DB.
for i := 0; i < 100; i++ {
@@ -51,12 +46,11 @@ func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
func TestStore_BlocksCRUD(t *testing.T) {
db := setupDB(t)
ctx := context.Background()
block := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: 20,
ParentRoot: bytesutil.PadTo([]byte{1, 2, 3}, 32),
},
}
block := testutil.NewBeaconBlock()
block.Block.Slot = 20
block.Block.ParentRoot = bytesutil.PadTo([]byte{1, 2, 3}, 32)
blockRoot, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err)
retrievedBlock, err := db.Block(ctx, blockRoot)
@@ -372,12 +366,10 @@ func TestStore_SaveBlocks_HasCachedBlocks(t *testing.T) {
b := make([]*ethpb.SignedBeaconBlock, 500)
for i := 0; i < 500; i++ {
b[i] = &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: bytesutil.PadTo([]byte("parent"), 32),
Slot: uint64(i),
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ParentRoot = bytesutil.PadTo([]byte("parent"), 32)
blk.Block.Slot = uint64(i)
b[i] = blk
}
require.NoError(t, db.SaveBlock(ctx, b[0]))

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

@@ -39,12 +39,9 @@ func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
genesis := bytesutil.ToBytes32([]byte{'G', 'E', 'N', 'E', 'S', 'I', 'S'})
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesis))
blk := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: genesis[:],
Slot: 40,
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ParentRoot = genesis[:]
blk.Block.Slot = 40
root, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)

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

@@ -55,7 +55,8 @@ func TestStore_IsFinalizedBlockGenesis(t *testing.T) {
db := setupDB(t)
ctx := context.Background()
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 0}}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = 0
root, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, blk))
@@ -139,12 +140,9 @@ func makeBlocks(t *testing.T, i, n uint64, previousRoot [32]byte) []*ethpb.Signe
for j := i; j < n+i; j++ {
parentRoot := make([]byte, 32)
copy(parentRoot, previousRoot[:])
blocks[j-i] = &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: j + 1,
ParentRoot: parentRoot,
},
}
blocks[j-i] = testutil.NewBeaconBlock()
blocks[j-i].Block.Slot = j + 1
blocks[j-i].Block.ParentRoot = parentRoot
var err error
previousRoot, err = stateutil.BlockRoot(blocks[j-i].Block)
require.NoError(t, err)

7
beacon-chain/db/kv/migration_archived_index_test.go
View File

@@ -6,8 +6,8 @@ import (
"fmt"
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"go.etcd.io/bbolt"
)
@@ -53,8 +53,9 @@ func Test_migrateArchivedIndex(t *testing.T) {
if err := tx.Bucket(archivedRootBucket).Put(bytesutil.Uint64ToBytesLittleEndian(2048), []byte("foo")); err != nil {
return err
}
b, err := encode(context.Background(), &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2048}})
sb := testutil.NewBeaconBlock()
sb.Block.Slot = 2048
b, err := encode(context.Background(), sb)
if err != nil {
return err
}

3
beacon-chain/db/kv/operations.go
View File

@@ -4,7 +4,6 @@ import (
"context"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
bolt "go.etcd.io/bbolt"
"go.opencensus.io/trace"
)
@@ -42,7 +41,7 @@ func (kv *Store) HasVoluntaryExit(ctx context.Context, exitRoot [32]byte) bool {
func (kv *Store) SaveVoluntaryExit(ctx context.Context, exit *ethpb.VoluntaryExit) error {
ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveVoluntaryExit")
defer span.End()
exitRoot, err := ssz.HashTreeRoot(exit)
exitRoot, err := exit.HashTreeRoot()
if err != nil {
return err
}

3
beacon-chain/db/kv/operations_test.go
View File

@@ -6,7 +6,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
@@ -17,7 +16,7 @@ func TestStore_VoluntaryExits_CRUD(t *testing.T) {
exit := &ethpb.VoluntaryExit{
Epoch: 5,
}
exitRoot, err := ssz.HashTreeRoot(exit)
exitRoot, err := exit.HashTreeRoot()
require.NoError(t, err)
retrieved, err := db.VoluntaryExit(ctx, exitRoot)
require.NoError(t, err)

5
beacon-chain/db/kv/slashings.go
View File

@@ -4,7 +4,6 @@ import (
"context"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
bolt "go.etcd.io/bbolt"
"go.opencensus.io/trace"
)
@@ -42,7 +41,7 @@ func (kv *Store) HasProposerSlashing(ctx context.Context, slashingRoot [32]byte)
func (kv *Store) SaveProposerSlashing(ctx context.Context, slashing *ethpb.ProposerSlashing) error {
ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveProposerSlashing")
defer span.End()
slashingRoot, err := ssz.HashTreeRoot(slashing)
slashingRoot, err := slashing.HashTreeRoot()
if err != nil {
return err
}
@@ -111,7 +110,7 @@ func (kv *Store) HasAttesterSlashing(ctx context.Context, slashingRoot [32]byte)
func (kv *Store) SaveAttesterSlashing(ctx context.Context, slashing *ethpb.AttesterSlashing) error {
ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveAttesterSlashing")
defer span.End()
slashingRoot, err := ssz.HashTreeRoot(slashing)
slashingRoot, err := slashing.HashTreeRoot()
if err != nil {
return err
}

5
beacon-chain/db/kv/slashings_test.go
View File

@@ -6,7 +6,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
@@ -34,7 +33,7 @@ func TestStore_ProposerSlashing_CRUD(t *testing.T) {
Signature: make([]byte, 96),
},
}
slashingRoot, err := ssz.HashTreeRoot(prop)
slashingRoot, err := prop.HashTreeRoot()
require.NoError(t, err)
retrieved, err := db.ProposerSlashing(ctx, slashingRoot)
require.NoError(t, err)
@@ -83,7 +82,7 @@ func TestStore_AttesterSlashing_CRUD(t *testing.T) {
Signature: make([]byte, 96),
},
}
slashingRoot, err := ssz.HashTreeRoot(att)
slashingRoot, err := att.HashTreeRoot()
require.NoError(t, err)
retrieved, err := db.AttesterSlashing(ctx, slashingRoot)
require.NoError(t, err)

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

@@ -132,12 +132,10 @@ func TestStore_DeleteFinalizedState(t *testing.T) {
genesis := bytesutil.ToBytes32([]byte{'G', 'E', 'N', 'E', 'S', 'I', 'S'})
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesis))
blk := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: genesis[:],
Slot: 100,
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ParentRoot = genesis[:]
blk.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, blk))
finalizedBlockRoot, err := stateutil.BlockRoot(blk.Block)
@@ -159,12 +157,9 @@ func TestStore_DeleteHeadState(t *testing.T) {
genesis := bytesutil.ToBytes32([]byte{'G', 'E', 'N', 'E', 'S', 'I', 'S'})
require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesis))
blk := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ParentRoot: genesis[:],
Slot: 100,
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ParentRoot = genesis[:]
blk.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, blk))
headBlockRoot, err := stateutil.BlockRoot(blk.Block)
@@ -180,7 +175,8 @@ func TestStore_DeleteHeadState(t *testing.T) {
func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
db := setupDB(t)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
r, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), b))
@@ -189,7 +185,7 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
s0 := st.InnerStateUnsafe()
require.NoError(t, db.SaveState(context.Background(), st, r))
b = &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 100}}
b.Block.Slot = 100
r1, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), b))
@@ -198,7 +194,7 @@ func TestStore_SaveDeleteState_CanGetHighestBelow(t *testing.T) {
s1 := st.InnerStateUnsafe()
require.NoError(t, db.SaveState(context.Background(), st, r1))
b = &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1000}}
b.Block.Slot = 1000
r2, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), b))
@@ -229,7 +225,8 @@ func TestStore_GenesisState_CanGetHighestBelow(t *testing.T) {
require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genesisRoot))
require.NoError(t, db.SaveState(context.Background(), genesisState, genesisRoot))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
r, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(context.Background(), b))

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

@@ -42,6 +42,7 @@ go_test(
"//shared/bls:go_default_library",
"//shared/testutil/assert:go_default_library",
"//shared/testutil/require:go_default_library",
"@com_github_ferranbt_fastssz//:go_default_library",
"@com_github_patrickmn_go_cache//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_bitfield//:go_default_library",

190
beacon-chain/operations/attestations/kv/aggregated_test.go
View File

@@ -5,6 +5,7 @@ import (
"sort"
"testing"
fssz "github.com/ferranbt/fastssz"
c "github.com/patrickmn/go-cache"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
@@ -18,14 +19,14 @@ func TestKV_Aggregated_AggregateUnaggregatedAttestations(t *testing.T) {
priv := bls.RandKey()
sig1 := priv.Sign([]byte{'a'})
sig2 := priv.Sign([]byte{'b'})
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig1.Marshal()}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1010}, Signature: sig1.Marshal()}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1100}, Signature: sig1.Marshal()}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig2.Marshal()}
att5 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig1.Marshal()}
att6 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1010}, Signature: sig1.Marshal()}
att7 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1100}, Signature: sig1.Marshal()}
att8 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig2.Marshal()}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig1.Marshal()}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1010}, Signature: sig1.Marshal()}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1100}, Signature: sig1.Marshal()}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig2.Marshal()}
att5 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig1.Marshal()}
att6 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1010}, Signature: sig1.Marshal()}
att7 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1100}, Signature: sig1.Marshal()}
att8 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig2.Marshal()}
atts := []*ethpb.Attestation{att1, att2, att3, att4, att5, att6, att7, att8}
if err := cache.SaveUnaggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -60,7 +61,11 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
{
name: "not aggregated",
att: &ethpb.Attestation{
Data: &ethpb.AttestationData{}, AggregationBits: bitfield.Bitlist{0b10100}},
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
}, AggregationBits: bitfield.Bitlist{0b10100}},
wantErrString: "attestation is not aggregated",
},
{
@@ -71,15 +76,19 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
},
AggregationBits: bitfield.Bitlist{0b10111},
},
wantErrString: "could not tree hash attestation: incorrect fixed bytes marshalling",
wantErrString: "could not tree hash attestation: " + fssz.ErrBytesLength.Error(),
},
{
name: "already seen",
att: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 100,
Slot: 100,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b11101001},
Signature: make([]byte, 96),
},
count: 0,
},
@@ -87,15 +96,22 @@ func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
name: "normal save",
att: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1101},
Signature: make([]byte, 96),
},
count: 1,
},
}
r, err := hashFn(&ethpb.AttestationData{
Slot: 100,
Slot: 100,
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
})
require.NoError(t, err)
@@ -136,9 +152,9 @@ func TestKV_Aggregated_SaveAggregatedAttestations(t *testing.T) {
{
name: "no duplicates",
atts: []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 1},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}},
AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 1},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}},
AggregationBits: bitfield.Bitlist{0b1101}},
},
count: 1,
@@ -169,9 +185,9 @@ func TestKV_Aggregated_SaveAggregatedAttestations(t *testing.T) {
func TestKV_Aggregated_AggregatedAttestations(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {
@@ -193,7 +209,7 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
if err := cache.DeleteAggregatedAttestation(nil); err != nil {
t.Error(err)
}
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10101}}
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10101}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}}
if err := cache.DeleteAggregatedAttestation(att); err != nil {
t.Error(err)
}
@@ -201,7 +217,7 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
t.Run("non aggregated attestation", func(t *testing.T) {
cache := NewAttCaches()
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1001}, Data: &ethpb.AttestationData{Slot: 2}}
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1001}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}}
err := cache.DeleteAggregatedAttestation(att)
wantErr := "attestation is not aggregated"
if err == nil || err.Error() != wantErr {
@@ -214,12 +230,11 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
att := &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b1111},
Data: &ethpb.AttestationData{
Slot: 2,
BeaconBlockRoot: []byte{0b0},
Slot: 2,
},
}
err := cache.DeleteAggregatedAttestation(att)
wantErr := "could not tree hash attestation data: incorrect fixed bytes marshalling"
wantErr := "could not tree hash attestation data: " + fssz.ErrBytesLength.Error()
if err == nil || err.Error() != wantErr {
t.Errorf("Did not receive wanted error, want: %q, got: %v", wantErr, err)
}
@@ -227,7 +242,7 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
t.Run("nonexistent attestation", func(t *testing.T) {
cache := NewAttCaches()
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2}}
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}}
if err := cache.DeleteAggregatedAttestation(att); err != nil {
t.Error(err)
}
@@ -235,10 +250,10 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
t.Run("non-filtered deletion", func(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b10101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b10101}}
atts := []*ethpb.Attestation{att1, att2, att3, att4}
if err := cache.SaveAggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -258,10 +273,10 @@ func TestKV_Aggregated_DeleteAggregatedAttestation(t *testing.T) {
t.Run("filtered deletion", func(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b110101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b110111}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b110100}}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b110101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110111}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110100}}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110101}}
atts := []*ethpb.Attestation{att1, att2, att3, att4}
if err := cache.SaveAggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -298,14 +313,23 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
{
name: "nil attestation data",
input: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b1111}},
AggregationBits: bitfield.Bitlist{0b1111},
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
},
want: false,
},
{
name: "empty cache aggregated",
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111}},
want: false,
@@ -314,7 +338,10 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
name: "empty cache unaggregated",
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1001}},
want: false,
@@ -323,13 +350,19 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
name: "single attestation in cache with exact match",
existing: []*ethpb.Attestation{{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111}},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111}},
want: true,
@@ -338,13 +371,19 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
name: "single attestation in cache with subset aggregation",
existing: []*ethpb.Attestation{{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111}},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1110}},
want: true,
@@ -353,13 +392,19 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
name: "single attestation in cache with superset aggregation",
existing: []*ethpb.Attestation{{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1110}},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111}},
want: false,
@@ -369,20 +414,29 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
existing: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111000},
},
{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1100111},
},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1100000}},
want: true,
@@ -392,20 +446,29 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
existing: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111000},
},
{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1100111},
},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111111}},
want: false,
@@ -415,20 +478,29 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
existing: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Slot: 2,
Slot: 2,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111000},
},
{
Data: &ethpb.AttestationData{
Slot: 3,
Slot: 3,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1100111},
},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 1,
Slot: 1,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111111}},
want: false,
@@ -438,14 +510,20 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
existing: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
Slot: 2,
Slot: 2,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111000},
},
},
input: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 2,
Slot: 2,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b1111},
},
@@ -460,6 +538,10 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
t.Error(err)
}
if tt.input != nil && tt.input.Signature == nil {
tt.input.Signature = make([]byte, 96)
}
result, err := cache.HasAggregatedAttestation(tt.input)
require.NoError(t, err)
if result != tt.want {
@@ -484,8 +566,8 @@ func TestKV_Aggregated_HasAggregatedAttestation(t *testing.T) {
func TestKV_Aggregated_DuplicateAggregatedAttestations(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1111}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1111}}
atts := []*ethpb.Attestation{att1, att2}
for _, att := range atts {

12
beacon-chain/operations/attestations/kv/block_test.go
View File

@@ -12,9 +12,9 @@ import (
func TestKV_BlockAttestation_CanSaveRetrieve(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {
@@ -35,9 +35,9 @@ func TestKV_BlockAttestation_CanSaveRetrieve(t *testing.T) {
func TestKV_BlockAttestation_CanDelete(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {

12
beacon-chain/operations/attestations/kv/forkchoice_test.go
View File

@@ -12,9 +12,9 @@ import (
func TestKV_Forkchoice_CanSaveRetrieve(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {
@@ -35,9 +35,9 @@ func TestKV_Forkchoice_CanSaveRetrieve(t *testing.T) {
func TestKV_Forkchoice_CanDelete(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}, Signature: make([]byte, 96)}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {

22
beacon-chain/operations/attestations/kv/seen_bits_test.go
View File

@@ -10,21 +10,25 @@ import (
func TestAttCaches_hasSeenBit(t *testing.T) {
c := NewAttCaches()
d := &ethpb.AttestationData{}
seenA1 := &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000011}}
seenA2 := &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11100000}}
d := &ethpb.AttestationData{
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
}
seenA1 := &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000011}, Signature: make([]byte, 96)}
seenA2 := &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11100000}, Signature: make([]byte, 96)}
require.NoError(t, c.insertSeenBit(seenA1))
require.NoError(t, c.insertSeenBit(seenA2))
tests := []struct {
att *ethpb.Attestation
want bool
}{
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000000}}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000001}}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11100000}}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000011}}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b00001000}}, want: false},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11110111}}, want: false},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000000}, Signature: make([]byte, 96)}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000001}, Signature: make([]byte, 96)}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11100000}, Signature: make([]byte, 96)}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b10000011}, Signature: make([]byte, 96)}, want: true},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b00001000}, Signature: make([]byte, 96)}, want: false},
{att: &ethpb.Attestation{Data: d, AggregationBits: bitfield.Bitlist{0b11110111}, Signature: make([]byte, 96)}, want: false},
}
for _, tt := range tests {
got, err := c.hasSeenBit(tt.att)

55
beacon-chain/operations/attestations/kv/unaggregated_test.go
View File

@@ -3,6 +3,7 @@ package kv
import (
"testing"
fssz "github.com/ferranbt/fastssz"
c "github.com/patrickmn/go-cache"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
@@ -23,7 +24,7 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
},
{
name: "already aggregated",
att: &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10101}},
att: &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10101}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}},
wantErrString: "attestation is aggregated",
},
{
@@ -33,31 +34,33 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
BeaconBlockRoot: []byte{0b0},
},
},
wantErrString: "incorrect fixed bytes marshalling",
wantErrString: fssz.ErrBytesLength.Error(),
},
{
name: "normal save",
att: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 100,
},
AggregationBits: bitfield.Bitlist{0b0001},
},
name: "normal save",
att: &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b0001}, Data: &ethpb.AttestationData{BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}},
count: 1,
},
{
name: "already seen",
att: &ethpb.Attestation{
Data: &ethpb.AttestationData{
Slot: 100,
Slot: 100,
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b10000001},
Signature: make([]byte, 96),
},
count: 0,
},
}
r, err := hashFn(&ethpb.AttestationData{
Slot: 100,
Slot: 100,
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
})
require.NoError(t, err)
@@ -69,6 +72,10 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
t.Errorf("Invalid start pool, atts: %d", len(cache.unAggregatedAtt))
}
if tt.att != nil && tt.att.Signature == nil {
tt.att.Signature = make([]byte, 96)
}
err := cache.SaveUnaggregatedAttestation(tt.att)
if tt.wantErrString != "" && (err == nil || err.Error() != tt.wantErrString) {
t.Errorf("Did not receive wanted error, want: %q, got: %v", tt.wantErrString, err)
@@ -98,18 +105,18 @@ func TestKV_Unaggregated_SaveUnaggregatedAttestations(t *testing.T) {
{
name: "unaggregated only",
atts: []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 1}},
{Data: &ethpb.AttestationData{Slot: 2}},
{Data: &ethpb.AttestationData{Slot: 3}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
},
count: 3,
},
{
name: "has aggregated",
atts: []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 1}},
{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2}},
{Data: &ethpb.AttestationData{Slot: 3}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)},
},
wantErrString: "attestation is aggregated",
count: 1,
@@ -150,7 +157,7 @@ func TestKV_Unaggregated_DeleteUnaggregatedAttestation(t *testing.T) {
t.Run("aggregated attestation", func(t *testing.T) {
cache := NewAttCaches()
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2}}
att := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}, Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, Signature: make([]byte, 96)}
err := cache.DeleteUnaggregatedAttestation(att)
wantErr := "attestation is aggregated"
if err == nil || err.Error() != wantErr {
@@ -160,9 +167,9 @@ func TestKV_Unaggregated_DeleteUnaggregatedAttestation(t *testing.T) {
t.Run("successful deletion", func(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b110}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b110}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b101}, Signature: make([]byte, 96)}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110}, Signature: make([]byte, 96)}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110}, Signature: make([]byte, 96)}
atts := []*ethpb.Attestation{att1, att2, att3}
if err := cache.SaveUnaggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -181,9 +188,9 @@ func TestKV_Unaggregated_DeleteUnaggregatedAttestation(t *testing.T) {
func TestKV_Unaggregated_UnaggregatedAttestationsBySlotIndex(t *testing.T) {
cache := NewAttCaches()
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}, AggregationBits: bitfield.Bitlist{0b101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 2}, AggregationBits: bitfield.Bitlist{0b110}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}, AggregationBits: bitfield.Bitlist{0b110}}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b101}, Signature: make([]byte, 96)}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110}, Signature: make([]byte, 96)}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b110}, Signature: make([]byte, 96)}
atts := []*ethpb.Attestation{att1, att2, att3}
for _, att := range atts {

70
beacon-chain/operations/attestations/prepare_forkchoice_test.go
View File

@@ -2,6 +2,7 @@ package attestations
import (
"context"
"fmt"
"sort"
"testing"
@@ -262,21 +263,34 @@ func TestSeenAttestations_PresentInCache(t *testing.T) {
s, err := NewService(context.Background(), &Config{Pool: NewPool()})
require.NoError(t, err)
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x13} /* 0b00010011 */}
ad1 := &ethpb.AttestationData{
Slot: 0,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
att1 := &ethpb.Attestation{Data: ad1, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x13} /* 0b00010011 */}
got, err := s.seen(att1)
require.NoError(t, err)
if got {
t.Error("Wanted false, got true")
}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x17} /* 0b00010111 */}
att2 := &ethpb.Attestation{Data: ad1, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x17} /* 0b00010111 */}
got, err = s.seen(att2)
require.NoError(t, err)
if got {
t.Error("Wanted false, got true")
}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{}, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x17} /* 0b00010111 */}
att3 := &ethpb.Attestation{Data: ad1, Signature: []byte{'A'}, AggregationBits: bitfield.Bitlist{0x17} /* 0b00010111 */}
got, err = s.seen(att3)
require.NoError(t, err)
if !got {
@@ -285,6 +299,34 @@ func TestSeenAttestations_PresentInCache(t *testing.T) {
}
func TestService_seen(t *testing.T) {
ad1 := &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
ad2 := &ethpb.AttestationData{
Slot: 2,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
// Attestation are checked in order of this list.
tests := []struct {
att *ethpb.Attestation
@@ -293,42 +335,42 @@ func TestService_seen(t *testing.T) {
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b11011},
Data: &ethpb.AttestationData{Slot: 1},
Data: ad1,
},
want: false,
},
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b11011},
Data: &ethpb.AttestationData{Slot: 1},
Data: ad1,
},
want: true, // Exact same attestation should return true
},
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b10101},
Data: &ethpb.AttestationData{Slot: 1},
Data: ad1,
},
want: false, // Haven't seen the bit at index 2 yet.
},
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b11111},
Data: &ethpb.AttestationData{Slot: 1},
Data: ad1,
},
want: true, // We've full committee at this point.
},
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b11111},
Data: &ethpb.AttestationData{Slot: 2},
Data: ad2,
},
want: false, // Different root is different bitlist.
},
{
att: &ethpb.Attestation{
AggregationBits: bitfield.Bitlist{0b11111001},
Data: &ethpb.AttestationData{Slot: 1},
Data: ad1,
},
want: false, // Sanity test that an attestation of different lengths does not panic.
},
@@ -337,9 +379,11 @@ func TestService_seen(t *testing.T) {
s, err := NewService(context.Background(), &Config{Pool: NewPool()})
require.NoError(t, err)
for _, tt := range tests {
got, err := s.seen(tt.att)
require.NoError(t, err)
assert.Equal(t, tt.want, got)
for i, tt := range tests {
t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
got, err := s.seen(tt.att)
require.NoError(t, err)
assert.Equal(t, tt.want, got)
})
}
}

72
beacon-chain/operations/attestations/prune_expired_test.go
View File

@@ -24,9 +24,37 @@ func TestPruneExpired_Ticker(t *testing.T) {
})
require.NoError(t, err)
ad1 := &ethpb.AttestationData{
Slot: 0,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
ad2 := &ethpb.AttestationData{
Slot: 1,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
atts := []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 0}, AggregationBits: bitfield.Bitlist{0b1000, 0b1}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1000, 0b1}},
{Data: ad1, AggregationBits: bitfield.Bitlist{0b1000, 0b1}, Signature: make([]byte, 96)},
{Data: ad2, AggregationBits: bitfield.Bitlist{0b1000, 0b1}, Signature: make([]byte, 96)},
}
if err := s.pool.SaveUnaggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -35,8 +63,8 @@ func TestPruneExpired_Ticker(t *testing.T) {
t.Fatalf("Unexpected number of attestations: %d", s.pool.UnaggregatedAttestationCount())
}
atts = []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 0}, AggregationBits: bitfield.Bitlist{0b1101, 0b1}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101, 0b1}},
{Data: ad1, AggregationBits: bitfield.Bitlist{0b1101, 0b1}, Signature: make([]byte, 96)},
{Data: ad2, AggregationBits: bitfield.Bitlist{0b1101, 0b1}, Signature: make([]byte, 96)},
}
if err := s.pool.SaveAggregatedAttestations(atts); err != nil {
t.Fatal(err)
@@ -87,10 +115,38 @@ func TestPruneExpired_PruneExpiredAtts(t *testing.T) {
s, err := NewService(context.Background(), &Config{Pool: NewPool()})
require.NoError(t, err)
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 0}, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 0}, AggregationBits: bitfield.Bitlist{0b1111}}
att3 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}}
att4 := &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1110}}
ad1 := &ethpb.AttestationData{
Slot: 0,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
ad2 := &ethpb.AttestationData{
Slot: 0,
CommitteeIndex: 0,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: make([]byte, 32),
},
}
att1 := &ethpb.Attestation{Data: ad1, AggregationBits: bitfield.Bitlist{0b1101}}
att2 := &ethpb.Attestation{Data: ad1, AggregationBits: bitfield.Bitlist{0b1111}}
att3 := &ethpb.Attestation{Data: ad2, AggregationBits: bitfield.Bitlist{0b1101}}
att4 := &ethpb.Attestation{Data: ad2, AggregationBits: bitfield.Bitlist{0b1110}}
atts := []*ethpb.Attestation{att1, att2, att3, att4}
if err := s.pool.SaveAggregatedAttestations(atts); err != nil {
t.Fatal(err)

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

@@ -118,6 +118,7 @@ go_test(
"//beacon-chain/p2p/testing:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
"//proto/testing:go_default_library",
"//shared/bytesutil:go_default_library",
"//shared/featureconfig:go_default_library",
"//shared/iputils:go_default_library",
"//shared/p2putils:go_default_library",

3
beacon-chain/p2p/discovery_test.go
View File

@@ -17,6 +17,7 @@ import (
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/iputils"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -217,7 +218,7 @@ func TestHostIsResolved(t *testing.T) {
HostDNS: exampleHost,
},
genesisTime: time.Now(),
genesisValidatorsRoot: []byte{'A'},
genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
}
ip, key := createAddrAndPrivKey(t)
list, err := s.createListener(ip, key)

4
beacon-chain/p2p/subnets_test.go
View File

@@ -115,7 +115,9 @@ func TestStartDiscV5_DiscoverPeersWithSubnets(t *testing.T) {
// Update ENR of a peer.
testService := &Service{
dv5Listener: listeners[0],
metaData: &pb.MetaData{},
metaData: &pb.MetaData{
Attnets: bitfield.NewBitvector64(),
},
}
cache.SubnetIDs.AddAttesterSubnetID(0, 10)
testService.RefreshENR()

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

@@ -42,7 +42,6 @@ go_library(
"@com_github_prometheus_client_golang//prometheus:go_default_library",
"@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@io_k8s_client_go//tools/cache:go_default_library",
"@io_opencensus_go//trace:go_default_library",
@@ -85,7 +84,6 @@ go_test(
"@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
"@com_github_ethereum_go_ethereum//core/types:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@com_github_sirupsen_logrus//hooks/test:go_default_library",
"@in_gopkg_d4l3k_messagediff_v1//:go_default_library",

13
beacon-chain/powchain/deposit_test.go
View File

@@ -6,10 +6,10 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -81,9 +81,9 @@ func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
require.NoError(t, err)
deposits[0].Data.PublicKey = []byte("junk")
deposits[0].Data.PublicKey = bytesutil.PadTo([]byte("junk"), 48)
leaf, err := ssz.HashTreeRoot(deposits[0].Data)
leaf, err := deposits[0].Data.HashTreeRoot()
require.NoError(t, err, "Could not hash deposit")
trie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
@@ -121,7 +121,7 @@ func TestProcessDeposit_InvalidSignature(t *testing.T) {
copy(fakeSig[:], []byte{'F', 'A', 'K', 'E'})
deposits[0].Data.Signature = fakeSig[:]
leaf, err := ssz.HashTreeRoot(deposits[0].Data)
leaf, err := deposits[0].Data.HashTreeRoot()
require.NoError(t, err, "Could not hash deposit")
trie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, int(params.BeaconConfig().DepositContractTreeDepth))
@@ -186,7 +186,8 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
deposit := &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
Amount: params.BeaconConfig().EffectiveBalanceIncrement, // incomplete deposit
WithdrawalCredentials: []byte("testing"),
WithdrawalCredentials: bytesutil.PadTo([]byte("testing"), 32),
Signature: bytesutil.PadTo([]byte("test"), 96),
},
}
@@ -209,7 +210,7 @@ func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
}
proof, err := trie.MerkleProof(0)
require.NoError(t, err)
dataRoot, err := ssz.HashTreeRoot(deposit.Data)
dataRoot, err := deposit.Data.HashTreeRoot()
require.NoError(t, err)
deposit.Proof = proof

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

@@ -13,7 +13,6 @@ import (
gethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
statefeed "github.com/prysmaticlabs/prysm/beacon-chain/core/feed/state"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -135,7 +134,7 @@ func (s *Service) ProcessDepositLog(ctx context.Context, depositLog gethTypes.Lo
WithdrawalCredentials: withdrawalCredentials,
}
depositHash, err := ssz.HashTreeRoot(depositData)
depositHash, err := depositData.HashTreeRoot()
if err != nil {
return errors.Wrap(err, "Unable to determine hashed value of deposit")
}

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

@@ -111,7 +111,6 @@ go_test(
"@com_github_golang_mock//gomock:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_bitfield//:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@in_gopkg_d4l3k_messagediff_v1//:go_default_library",
],
)

58
beacon-chain/rpc/beacon/assignments_test.go
View File

@@ -10,7 +10,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
@@ -55,7 +54,7 @@ func TestServer_ListAssignments_NoResults(t *testing.T) {
ctx := context.Background()
st := testutil.NewBeaconState()
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -96,7 +95,7 @@ func TestServer_ListAssignments_Pagination_InputOutOfRange(t *testing.T) {
headState, err := db.HeadState(ctx)
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -141,29 +140,30 @@ func TestServer_ListAssignments_Pagination_DefaultPageSize_NoArchive(t *testing.
validators := make([]*ethpb.Validator, 0, count)
for i := 0; i < count; i++ {
pubKey := make([]byte, params.BeaconConfig().BLSPubkeyLength)
withdrawalCred := make([]byte, 32)
binary.LittleEndian.PutUint64(pubKey, uint64(i))
// Mark the validators with index divisible by 3 inactive.
if i%3 == 0 {
validators = append(validators, &ethpb.Validator{
PublicKey: pubKey,
ExitEpoch: 0,
ActivationEpoch: 0,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
PublicKey: pubKey,
WithdrawalCredentials: withdrawalCred,
ExitEpoch: 0,
ActivationEpoch: 0,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
})
} else {
validators = append(validators, &ethpb.Validator{
PublicKey: pubKey,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
ActivationEpoch: 0,
PublicKey: pubKey,
WithdrawalCredentials: withdrawalCred,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
ActivationEpoch: 0,
})
}
}
blk := &ethpb.BeaconBlock{
Slot: 0,
}
blockRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock().Block
blockRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
s := testutil.NewBeaconState()
@@ -221,16 +221,20 @@ func TestServer_ListAssignments_FilterPubkeysIndices_NoPagination(t *testing.T)
ctx := context.Background()
count := 100
validators := make([]*ethpb.Validator, 0, count)
withdrawCreds := make([]byte, 32)
for i := 0; i < count; i++ {
pubKey := make([]byte, params.BeaconConfig().BLSPubkeyLength)
binary.LittleEndian.PutUint64(pubKey, uint64(i))
validators = append(validators, &ethpb.Validator{PublicKey: pubKey, ExitEpoch: params.BeaconConfig().FarFutureEpoch})
val := &ethpb.Validator{
PublicKey: pubKey,
WithdrawalCredentials: withdrawCreds,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
}
validators = append(validators, val)
}
blk := &ethpb.BeaconBlock{
Slot: 0,
}
blockRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock().Block
blockRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
s := testutil.NewBeaconState()
require.NoError(t, s.SetValidators(validators))
@@ -285,16 +289,20 @@ func TestServer_ListAssignments_CanFilterPubkeysIndices_WithPagination(t *testin
ctx := context.Background()
count := 100
validators := make([]*ethpb.Validator, 0, count)
withdrawCred := make([]byte, 32)
for i := 0; i < count; i++ {
pubKey := make([]byte, params.BeaconConfig().BLSPubkeyLength)
binary.LittleEndian.PutUint64(pubKey, uint64(i))
validators = append(validators, &ethpb.Validator{PublicKey: pubKey, ExitEpoch: params.BeaconConfig().FarFutureEpoch})
val := &ethpb.Validator{
PublicKey: pubKey,
WithdrawalCredentials: withdrawCred,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
}
validators = append(validators, val)
}
blk := &ethpb.BeaconBlock{
Slot: 0,
}
blockRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock().Block
blockRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
s := testutil.NewBeaconState()
require.NoError(t, s.SetValidators(validators))

223
beacon-chain/rpc/beacon/attestations_test.go
View File

@@ -88,7 +88,8 @@ func TestServer_ListAttestations_Genesis(t *testing.T) {
t.Fatal(err)
}
att := &ethpb.Attestation{
Signature: make([]byte, 96),
AggregationBits: bitfield.NewBitlist(0),
Signature: make([]byte, 96),
Data: &ethpb.AttestationData{
Slot: 2,
CommitteeIndex: 1,
@@ -99,17 +100,12 @@ func TestServer_ListAttestations_Genesis(t *testing.T) {
}
parentRoot := [32]byte{1, 2, 3}
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{
Slot: 0,
ParentRoot: parentRoot[:],
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{att},
},
},
}
root, err := stateutil.BlockRoot(blk.Block)
signedBlock := testutil.NewBeaconBlock()
signedBlock.Block.ParentRoot = bytesutil.PadTo(parentRoot[:], 32)
signedBlock.Block.Body.Attestations = []*ethpb.Attestation{att}
root, err := stateutil.BlockRoot(signedBlock.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, blk))
require.NoError(t, db.SaveBlock(ctx, signedBlock))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
wanted := &ethpb.ListAttestationsResponse{
Attestations: []*ethpb.Attestation{att},
@@ -129,7 +125,7 @@ func TestServer_ListAttestations_Genesis(t *testing.T) {
// Should throw an error if there is more than 1 block
// for the genesis slot.
require.NoError(t, db.SaveBlock(ctx, blk))
require.NoError(t, db.SaveBlock(ctx, signedBlock))
if _, err := bs.ListAttestations(ctx, &ethpb.ListAttestationsRequest{
QueryFilter: &ethpb.ListAttestationsRequest_GenesisEpoch{
GenesisEpoch: true,
@@ -146,23 +142,17 @@ func TestServer_ListAttestations_NoPagination(t *testing.T) {
count := uint64(8)
atts := make([]*ethpb.Attestation, 0, count)
for i := uint64(0); i < count; i++ {
blockExample := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: i,
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{
{
Signature: make([]byte, 96),
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Slot: i,
},
AggregationBits: bitfield.Bitlist{0b11},
},
},
blockExample := testutil.NewBeaconBlock()
blockExample.Block.Body.Attestations = []*ethpb.Attestation{
{
Signature: make([]byte, 96),
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Slot: i,
},
AggregationBits: bitfield.Bitlist{0b11},
},
}
require.NoError(t, db.SaveBlock(ctx, blockExample))
@@ -216,8 +206,14 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
Slot: 3,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), 96),
},
},
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: make([]byte, 32),
},
Graffiti: make([]byte, 32),
},
},
},
@@ -244,8 +240,14 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
Slot: 4 + params.BeaconConfig().SlotsPerEpoch,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), 96),
},
},
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: make([]byte, 32),
},
Graffiti: make([]byte, 32),
},
},
},
@@ -272,8 +274,14 @@ func TestServer_ListAttestations_FiltersCorrectly(t *testing.T) {
Slot: 4,
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: bytesutil.PadTo([]byte("sig"), 96),
},
},
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: make([]byte, 32),
},
Graffiti: make([]byte, 32),
},
},
},
@@ -305,24 +313,19 @@ func TestServer_ListAttestations_Pagination_CustomPageParameters(t *testing.T) {
atts := make([]*ethpb.Attestation, 0, count)
for i := uint64(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
for s := uint64(0); s < 4; s++ {
blockExample := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: i,
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
CommitteeIndex: s,
Slot: i,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: make([]byte, 96),
},
},
blockExample := testutil.NewBeaconBlock()
blockExample.Block.Slot = i
blockExample.Block.Body.Attestations = []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
CommitteeIndex: s,
Slot: i,
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: make([]byte, 96),
},
}
require.NoError(t, db.SaveBlock(ctx, blockExample))
@@ -424,17 +427,24 @@ func TestServer_ListAttestations_Pagination_OutOfRange(t *testing.T) {
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
Body: &ethpb.BeaconBlockBody{
Graffiti: make([]byte, 32),
RandaoReveal: make([]byte, 96),
Attestations: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Slot: i,
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0b11},
Signature: make([]byte, 96),
},
},
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: make([]byte, 32),
},
Graffiti: make([]byte, 32),
},
},
}
@@ -476,26 +486,17 @@ func TestServer_ListAttestations_Pagination_DefaultPageSize(t *testing.T) {
count := uint64(params.BeaconConfig().DefaultPageSize)
atts := make([]*ethpb.Attestation, 0, count)
for i := uint64(0); i < count; i++ {
blockExample := &ethpb.SignedBeaconBlock{
Signature: make([]byte, 96),
Block: &ethpb.BeaconBlock{
ParentRoot: make([]byte, 32),
StateRoot: make([]byte, 32),
Body: &ethpb.BeaconBlockBody{
RandaoReveal: make([]byte, 96),
Attestations: []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Slot: i,
},
Signature: bytesutil.PadTo([]byte("root"), 96),
AggregationBits: bitfield.Bitlist{0b11},
},
},
blockExample := testutil.NewBeaconBlock()
blockExample.Block.Body.Attestations = []*ethpb.Attestation{
{
Data: &ethpb.AttestationData{
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte("root"), 32)},
Slot: i,
},
Signature: bytesutil.PadTo([]byte("root"), 96),
AggregationBits: bitfield.Bitlist{0b11},
},
}
require.NoError(t, db.SaveBlock(ctx, blockExample))
@@ -569,27 +570,22 @@ func TestServer_ListIndexedAttestations_GenesisEpoch(t *testing.T) {
} else {
targetRoot = targetRoot2
}
blockExample := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{
{
Signature: make([]byte, 96),
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
Slot: i,
CommitteeIndex: 0,
},
AggregationBits: bitfield.Bitlist{0b11},
},
blockExample := testutil.NewBeaconBlock()
blockExample.Block.Body.Attestations = []*ethpb.Attestation{
{
Signature: make([]byte, 96),
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Target: &ethpb.Checkpoint{
Root: targetRoot[:],
},
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
Slot: i,
CommitteeIndex: 0,
},
AggregationBits: bitfield.Bitlist{0b11},
},
}
require.NoError(t, db.SaveBlock(ctx, blockExample))
@@ -757,9 +753,36 @@ func TestServer_AttestationPool_Pagination_OutOfRange(t *testing.T) {
}
atts := []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}},
{
Data: &ethpb.AttestationData{
Slot: 1,
BeaconBlockRoot: bytesutil.PadTo([]byte{1}, 32),
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{1}, 32)},
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{1}, 32)},
},
AggregationBits: bitfield.Bitlist{0b1101},
Signature: bytesutil.PadTo([]byte{1}, 96),
},
{
Data: &ethpb.AttestationData{
Slot: 2,
BeaconBlockRoot: bytesutil.PadTo([]byte{2}, 32),
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{2}, 32)},
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{2}, 32)},
},
AggregationBits: bitfield.Bitlist{0b1101},
Signature: bytesutil.PadTo([]byte{2}, 96),
},
{
Data: &ethpb.AttestationData{
Slot: 3,
BeaconBlockRoot: bytesutil.PadTo([]byte{3}, 32),
Source: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{3}, 32)},
Target: &ethpb.Checkpoint{Root: bytesutil.PadTo([]byte{3}, 32)},
},
AggregationBits: bitfield.Bitlist{0b1101},
Signature: bytesutil.PadTo([]byte{3}, 96),
},
}
require.NoError(t, bs.AttestationsPool.SaveAggregatedAttestations(atts))
@@ -780,10 +803,9 @@ func TestServer_AttestationPool_Pagination_DefaultPageSize(t *testing.T) {
atts := make([]*ethpb.Attestation, params.BeaconConfig().DefaultPageSize+1)
for i := 0; i < len(atts); i++ {
atts[i] = &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: uint64(i)},
AggregationBits: bitfield.Bitlist{0b1101},
}
att := testutil.NewAttestation()
att.Data.Slot = uint64(i)
atts[i] = att
}
require.NoError(t, bs.AttestationsPool.SaveAggregatedAttestations(atts))
@@ -803,10 +825,9 @@ func TestServer_AttestationPool_Pagination_CustomPageSize(t *testing.T) {
numAtts := 100
atts := make([]*ethpb.Attestation, numAtts)
for i := 0; i < len(atts); i++ {
atts[i] = &ethpb.Attestation{
Data: &ethpb.AttestationData{Slot: uint64(i)},
AggregationBits: bitfield.Bitlist{0b1101},
}
att := testutil.NewAttestation()
att.Data.Slot = uint64(i)
atts[i] = att
}
require.NoError(t, bs.AttestationsPool.SaveAggregatedAttestations(atts))
tests := []struct {
@@ -893,7 +914,7 @@ func TestServer_StreamIndexedAttestations_OK(t *testing.T) {
numValidators := 64
headState, privKeys := testutil.DeterministicGenesisState(t, uint64(numValidators))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -936,6 +957,10 @@ func TestServer_StreamIndexedAttestations_OK(t *testing.T) {
Data: &ethpb.AttestationData{
BeaconBlockRoot: bytesutil.PadTo([]byte("root"), 32),
Slot: i,
Source: &ethpb.Checkpoint{
Epoch: 0,
Root: gRoot[:],
},
Target: &ethpb.Checkpoint{
Epoch: 0,
Root: gRoot[:],
@@ -1059,9 +1084,9 @@ func TestServer_StreamAttestations_OnSlotTick(t *testing.T) {
}
atts := []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}},
{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1101}},
}
mockStream := mock.NewMockBeaconChain_StreamAttestationsServer(ctrl)

15
beacon-chain/rpc/beacon/blocks_test.go
View File

@@ -123,12 +123,8 @@ func TestServer_ListBlocks_Genesis_MultiBlocks(t *testing.T) {
}
// Should return the proper genesis block if it exists.
parentRoot := [32]byte{1, 2, 3}
blk := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: 0,
ParentRoot: parentRoot[:],
},
}
blk := testutil.NewBeaconBlock()
blk.Block.ParentRoot = parentRoot[:]
root, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, blk))
@@ -138,11 +134,8 @@ func TestServer_ListBlocks_Genesis_MultiBlocks(t *testing.T) {
blks := make([]*ethpb.SignedBeaconBlock, count)
blkContainers := make([]*ethpb.BeaconBlockContainer, count)
for i := uint64(0); i < count; i++ {
b := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: i,
},
}
b := testutil.NewBeaconBlock()
b.Block.Slot = i
root, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
blks[i] = b

6
beacon-chain/rpc/beacon/committees_test.go
View File

@@ -44,7 +44,7 @@ func TestServer_ListBeaconCommittees_CurrentEpoch(t *testing.T) {
GenesisTimeFetcher: m,
StateGen: stategen.New(db, sc),
}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -89,7 +89,7 @@ func TestServer_ListBeaconCommittees_PreviousEpoch(t *testing.T) {
require.NoError(t, headState.SetRandaoMixes(mixes))
require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch*2))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -159,7 +159,7 @@ func TestRetrieveCommitteesForRoot(t *testing.T) {
GenesisTimeFetcher: m,
StateGen: stategen.New(db, sc),
}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)

77
beacon-chain/rpc/beacon/validators_test.go
View File

@@ -14,7 +14,6 @@ import (
ptypes "github.com/gogo/protobuf/types"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
"github.com/prysmaticlabs/go-ssz"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/epoch/precompute"
@@ -103,7 +102,7 @@ func TestServer_ListValidatorBalances_NoResults(t *testing.T) {
}
headState := testutil.NewBeaconState()
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -153,7 +152,7 @@ func TestServer_ListValidatorBalances_DefaultResponse_NoArchive(t *testing.T) {
require.NoError(t, st.SetSlot(0))
require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -181,7 +180,7 @@ func TestServer_ListValidatorBalances_PaginationOutOfRange(t *testing.T) {
ctx := context.Background()
setupValidators(t, db, 3)
st := testutil.NewBeaconState()
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -230,7 +229,7 @@ func TestServer_ListValidatorBalances_Pagination_Default(t *testing.T) {
setupValidators(t, db, 100)
headState, err := db.HeadState(context.Background())
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
@@ -315,7 +314,7 @@ func TestServer_ListValidatorBalances_Pagination_CustomPageSizes(t *testing.T) {
setupValidators(t, db, count)
headState, err := db.HeadState(context.Background())
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
@@ -386,7 +385,7 @@ func TestServer_ListValidatorBalances_OutOfRange(t *testing.T) {
headState, err := db.HeadState(context.Background())
require.NoError(t, err)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, db.SaveGenesisBlockRoot(ctx, gRoot))
@@ -525,7 +524,7 @@ func TestServer_ListValidators_OnlyActiveValidators(t *testing.T) {
StateGen: stategen.New(db, cache.NewStateSummaryCache()),
}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -896,7 +895,7 @@ func TestServer_ListValidators_FromOldEpoch(t *testing.T) {
st := testutil.NewBeaconState()
require.NoError(t, st.SetSlot(helpers.StartSlot(30)))
require.NoError(t, st.SetValidators(validators))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -962,7 +961,7 @@ func TestServer_ListValidators_ProcessHeadStateSlots(t *testing.T) {
require.NoError(t, st.SetSlot(headSlot))
require.NoError(t, st.SetValidators(validators))
require.NoError(t, st.SetBalances(balances))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -1124,7 +1123,7 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
})
require.NoError(t, err)
}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
@@ -1134,7 +1133,7 @@ func TestServer_GetValidatorActiveSetChanges(t *testing.T) {
bs := &Server{
FinalizationFetcher: &mock.ChainService{
FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0},
FinalizedCheckPoint: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
},
GenesisTimeFetcher: &mock.ChainService{},
StateGen: stategen.New(db, sc),
@@ -1234,19 +1233,19 @@ func TestServer_GetValidatorQueue_ExitedValidatorLeavesQueue(t *testing.T) {
ActivationEpoch: 0,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: []byte("1"),
PublicKey: bytesutil.PadTo([]byte("1"), 48),
},
{
ActivationEpoch: 0,
ExitEpoch: 4,
WithdrawableEpoch: 6,
PublicKey: []byte("2"),
PublicKey: bytesutil.PadTo([]byte("2"), 48),
},
}
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetValidators(validators))
require.NoError(t, headState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 0}))
require.NoError(t, headState.SetFinalizedCheckpoint(&ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)}))
bs := &Server{
HeadFetcher: &mock.ChainService{
State: headState,
@@ -1257,7 +1256,7 @@ func TestServer_GetValidatorQueue_ExitedValidatorLeavesQueue(t *testing.T) {
res, err := bs.GetValidatorQueue(context.Background(), &ptypes.Empty{})
require.NoError(t, err)
wanted := [][]byte{
[]byte("2"),
bytesutil.PadTo([]byte("2"), 48),
}
activeValidatorCount, err := helpers.ActiveValidatorCount(headState, helpers.CurrentEpoch(headState))
require.NoError(t, err)
@@ -1369,20 +1368,35 @@ func TestServer_GetValidatorParticipation_PrevEpoch(t *testing.T) {
balances := make([]uint64, validatorCount)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
PublicKey: bytesutil.ToBytes(uint64(i), 48),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
}
balances[i] = params.BeaconConfig().MaxEffectiveBalance
}
atts := []*pbp2p.PendingAttestation{{Data: &ethpb.AttestationData{Target: &ethpb.Checkpoint{}}, InclusionDelay: 1}}
atts := []*pbp2p.PendingAttestation{{
Data: &ethpb.AttestationData{
BeaconBlockRoot: make([]byte, 32),
Source: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
Target: &ethpb.Checkpoint{
Root: make([]byte, 32),
},
},
InclusionDelay: 1,
AggregationBits: bitfield.NewBitlist(2),
}}
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
require.NoError(t, headState.SetValidators(validators))
require.NoError(t, headState.SetBalances(balances))
require.NoError(t, headState.SetPreviousEpochAttestations(atts))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: params.BeaconConfig().SlotsPerEpoch}}
b := testutil.NewBeaconBlock()
b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
require.NoError(t, db.SaveBlock(ctx, b))
bRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -1412,7 +1426,8 @@ func TestServer_GetValidatorParticipation_DoesntExist(t *testing.T) {
headState := testutil.NewBeaconState()
require.NoError(t, headState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: params.BeaconConfig().SlotsPerEpoch}}
b := testutil.NewBeaconBlock()
b.Block.Slot = params.BeaconConfig().SlotsPerEpoch
require.NoError(t, db.SaveBlock(ctx, b))
bRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -1456,8 +1471,8 @@ func TestGetValidatorPerformance_OK(t *testing.T) {
for i := 0; i < len(atts); i++ {
atts[i] = &pb.PendingAttestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x01},
InclusionDelay: 1,
@@ -1701,10 +1716,8 @@ func setupValidators(t testing.TB, db db.Database, count int) ([]*ethpb.Validato
WithdrawalCredentials: make([]byte, 32),
})
}
blk := &ethpb.BeaconBlock{
Slot: 0,
}
blockRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock().Block
blockRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
s := testutil.NewBeaconState()
require.NoError(t, s.SetValidators(validators))
@@ -1817,12 +1830,10 @@ func TestServer_GetIndividualVotes_Working(t *testing.T) {
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch))
bf := []byte{0xff}
att1 := &ethpb.Attestation{Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 0}},
AggregationBits: bf}
att2 := &ethpb.Attestation{Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 0}},
AggregationBits: bf}
att1 := testutil.NewAttestation()
att1.AggregationBits = bf
att2 := testutil.NewAttestation()
att2.AggregationBits = bf
rt := [32]byte{'A'}
att1.Data.Target.Root = rt[:]
att1.Data.BeaconBlockRoot = rt[:]

24
beacon-chain/rpc/debug/block_test.go
View File

@@ -22,9 +22,9 @@ import (
func TestServer_GetBlock(t *testing.T) {
db, _ := dbTest.SetupDB(t)
ctx := context.Background()
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{
Slot: 100,
}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 100
require.NoError(t, db.SaveBlock(ctx, b))
blockRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -66,19 +66,17 @@ func TestServer_GetAttestationInclusionSlot(t *testing.T) {
a := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Root: tr[:]},
Slot: 1,
Target: &ethpb.Checkpoint{Root: tr[:]},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
Slot: 1,
},
AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
Signature: make([]byte, 96),
}
b := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
Slot: 2,
Body: &ethpb.BeaconBlockBody{
Attestations: []*ethpb.Attestation{a},
},
},
}
b := testutil.NewBeaconBlock()
b.Block.Slot = 2
b.Block.Body.Attestations = []*ethpb.Attestation{a}
require.NoError(t, bs.BeaconDB.SaveBlock(ctx, b))
res, err := bs.GetInclusionSlot(ctx, &pbrpc.InclusionSlotRequest{Slot: 1, Id: c[0]})
require.NoError(t, err)

6
beacon-chain/rpc/debug/state_test.go
View File

@@ -4,7 +4,6 @@ import (
"context"
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
@@ -25,9 +24,8 @@ func TestServer_GetBeaconState(t *testing.T) {
st := testutil.NewBeaconState()
slot := uint64(100)
require.NoError(t, st.SetSlot(slot))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{
Slot: slot,
}}
b := testutil.NewBeaconBlock()
b.Block.Slot = slot
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)

2
beacon-chain/rpc/validator/BUILD.bazel
View File

@@ -54,7 +54,6 @@ go_library(
"@com_github_gogo_protobuf//types:go_default_library",
"@com_github_pkg_errors//:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@io_opencensus_go//trace:go_default_library",
"@org_golang_google_grpc//codes:go_default_library",
@@ -117,7 +116,6 @@ go_test(
"@com_github_golang_mock//gomock:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_bitfield//:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library",
"@com_github_sirupsen_logrus//hooks/test:go_default_library",
],

16
beacon-chain/rpc/validator/aggregator_test.go
View File

@@ -218,11 +218,13 @@ func generateAtt(state *beaconstate.BeaconState, index uint64, privKeys []bls.Se
aggBits.SetBitAt(index+1, true)
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
CommitteeIndex: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0},
CommitteeIndex: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
committee, err := helpers.BeaconCommitteeFromState(state, att.Data.Slot, att.Data.CommitteeIndex)
if err != nil {
@@ -256,11 +258,13 @@ func generateUnaggregatedAtt(state *beaconstate.BeaconState, index uint64, privK
aggBits.SetBitAt(index, true)
att := &ethpb.Attestation{
Data: &ethpb.AttestationData{
CommitteeIndex: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0},
CommitteeIndex: 1,
Source: &ethpb.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash[:]},
Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
committee, err := helpers.BeaconCommitteeFromState(state, att.Data.Slot, att.Data.CommitteeIndex)
if err != nil {

5
beacon-chain/rpc/validator/assignments_test.go
View File

@@ -10,7 +10,6 @@ import (
"github.com/golang/mock/gomock"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
mockChain "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
@@ -266,7 +265,7 @@ func TestStreamDuties_OK(t *testing.T) {
require.NoError(t, err)
bs, err := state.GenesisBeaconState(deposits, 0, eth1Data)
require.NoError(t, err, "Could not setup genesis bs")
genesisRoot, err := ssz.HashTreeRoot(genesis.Block)
genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root")
pubKeys := make([][]byte, len(deposits))
@@ -325,7 +324,7 @@ func TestStreamDuties_OK_ChainReorg(t *testing.T) {
require.NoError(t, err)
bs, err := state.GenesisBeaconState(deposits, 0, eth1Data)
require.NoError(t, err, "Could not setup genesis bs")
genesisRoot, err := ssz.HashTreeRoot(genesis.Block)
genesisRoot, err := genesis.Block.HashTreeRoot()
require.NoError(t, err, "Could not get signing root")
pubKeys := make([][]byte, len(deposits))

118
beacon-chain/rpc/validator/attester_test.go
View File

@@ -9,7 +9,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
@@ -52,8 +51,10 @@ func TestProposeAttestation_OK(t *testing.T) {
validators := make([]*ethpb.Validator, 64)
for i := 0; i < len(validators); i++ {
validators[i] = &ethpb.Validator{
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
PublicKey: make([]byte, 48),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
}
}
@@ -69,8 +70,8 @@ func TestProposeAttestation_OK(t *testing.T) {
Signature: sig.Marshal(),
Data: &ethpb.AttestationData{
BeaconBlockRoot: root[:],
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
},
}
_, err = attesterServer.ProposeAttestation(context.Background(), req)
@@ -91,9 +92,11 @@ func TestProposeAttestation_IncorrectSignature(t *testing.T) {
req := &ethpb.Attestation{
Data: &ethpb.AttestationData{
Source: &ethpb.Checkpoint{},
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
}
wanted := "Incorrect attestation signature"
_, err := attesterServer.ProposeAttestation(context.Background(), req)
@@ -104,20 +107,17 @@ func TestGetAttestationData_OK(t *testing.T) {
ctx := context.Background()
db, _ := dbutil.SetupDB(t)
block := &ethpb.BeaconBlock{
Slot: 3*params.BeaconConfig().SlotsPerEpoch + 1,
}
targetBlock := &ethpb.BeaconBlock{
Slot: 1 * params.BeaconConfig().SlotsPerEpoch,
}
justifiedBlock := &ethpb.BeaconBlock{
Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
}
blockRoot, err := stateutil.BlockRoot(block)
block := testutil.NewBeaconBlock()
block.Block.Slot = 3*params.BeaconConfig().SlotsPerEpoch + 1
targetBlock := testutil.NewBeaconBlock()
targetBlock.Block.Slot = 1 * params.BeaconConfig().SlotsPerEpoch
justifiedBlock := testutil.NewBeaconBlock()
justifiedBlock.Block.Slot = 2 * params.BeaconConfig().SlotsPerEpoch
blockRoot, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err, "Could not hash beacon block")
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock)
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock.Block)
require.NoError(t, err, "Could not get signing root for justified block")
targetRoot, err := stateutil.BlockRoot(targetBlock)
targetRoot, err := stateutil.BlockRoot(targetBlock.Block)
require.NoError(t, err, "Could not get signing root for target block")
slot := 3*params.BeaconConfig().SlotsPerEpoch + 1
beaconState := testutil.NewBeaconState()
@@ -153,7 +153,7 @@ func TestGetAttestationData_OK(t *testing.T) {
StateNotifier: chainService.StateNotifier(),
}
require.NoError(t, db.SaveState(ctx, beaconState, blockRoot))
require.NoError(t, db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block}))
require.NoError(t, db.SaveBlock(ctx, block))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot))
req := &ethpb.AttestationDataRequest{
@@ -206,20 +206,17 @@ func TestAttestationDataAtSlot_HandlesFarAwayJustifiedEpoch(t *testing.T) {
cfg.HistoricalRootsLimit = 8192
params.OverrideBeaconConfig(cfg)
block := &ethpb.BeaconBlock{
Slot: 10000,
}
epochBoundaryBlock := &ethpb.BeaconBlock{
Slot: helpers.StartSlot(helpers.SlotToEpoch(10000)),
}
justifiedBlock := &ethpb.BeaconBlock{
Slot: helpers.StartSlot(helpers.SlotToEpoch(1500)) - 2, // Imagine two skip block
}
blockRoot, err := stateutil.BlockRoot(block)
block := testutil.NewBeaconBlock()
block.Block.Slot = 10000
epochBoundaryBlock := testutil.NewBeaconBlock()
epochBoundaryBlock.Block.Slot = helpers.StartSlot(helpers.SlotToEpoch(10000))
justifiedBlock := testutil.NewBeaconBlock()
justifiedBlock.Block.Slot = helpers.StartSlot(helpers.SlotToEpoch(1500)) - 2 // Imagine two skip block
blockRoot, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err, "Could not hash beacon block")
justifiedBlockRoot, err := stateutil.BlockRoot(justifiedBlock)
justifiedBlockRoot, err := stateutil.BlockRoot(justifiedBlock.Block)
require.NoError(t, err, "Could not hash justified block")
epochBoundaryRoot, err := stateutil.BlockRoot(epochBoundaryBlock)
epochBoundaryRoot, err := stateutil.BlockRoot(epochBoundaryBlock.Block)
require.NoError(t, err, "Could not hash justified block")
slot := uint64(10000)
@@ -251,7 +248,7 @@ func TestAttestationDataAtSlot_HandlesFarAwayJustifiedEpoch(t *testing.T) {
StateNotifier: chainService.StateNotifier(),
}
require.NoError(t, db.SaveState(ctx, beaconState, blockRoot))
require.NoError(t, db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block}))
require.NoError(t, db.SaveBlock(ctx, block))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot))
req := &ethpb.AttestationDataRequest{
@@ -302,7 +299,7 @@ func TestAttestationDataSlot_handlesInProgressRequest(t *testing.T) {
}
res := &ethpb.AttestationData{
Target: &ethpb.Checkpoint{Epoch: 55},
Target: &ethpb.Checkpoint{Epoch: 55, Root: make([]byte, 32)},
}
require.NoError(t, server.AttestationCache.MarkInProgress(req))
@@ -355,24 +352,22 @@ func TestServer_GetAttestationData_HeadStateSlotGreaterThanRequestSlot(t *testin
db, sc := dbutil.SetupDB(t)
slot := 3*params.BeaconConfig().SlotsPerEpoch + 1
block := &ethpb.BeaconBlock{
Slot: slot,
}
block2 := &ethpb.BeaconBlock{Slot: slot - 1}
targetBlock := &ethpb.BeaconBlock{
Slot: 1 * params.BeaconConfig().SlotsPerEpoch,
}
justifiedBlock := &ethpb.BeaconBlock{
Slot: 2 * params.BeaconConfig().SlotsPerEpoch,
}
blockRoot, err := stateutil.BlockRoot(block)
block := testutil.NewBeaconBlock()
block.Block.Slot = slot
block2 := testutil.NewBeaconBlock()
block2.Block.Slot = slot - 1
targetBlock := testutil.NewBeaconBlock()
targetBlock.Block.Slot = 1 * params.BeaconConfig().SlotsPerEpoch
justifiedBlock := testutil.NewBeaconBlock()
justifiedBlock.Block.Slot = 2 * params.BeaconConfig().SlotsPerEpoch
blockRoot, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err, "Could not hash beacon block")
blockRoot2, err := ssz.HashTreeRoot(block2)
blockRoot2, err := block2.HashTreeRoot()
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block2}))
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock)
require.NoError(t, db.SaveBlock(ctx, block2))
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock.Block)
require.NoError(t, err, "Could not get signing root for justified block")
targetRoot, err := stateutil.BlockRoot(targetBlock)
targetRoot, err := stateutil.BlockRoot(targetBlock.Block)
require.NoError(t, err, "Could not get signing root for target block")
beaconState := testutil.NewBeaconState()
@@ -414,7 +409,7 @@ func TestServer_GetAttestationData_HeadStateSlotGreaterThanRequestSlot(t *testin
StateGen: stategen.New(db, sc),
}
require.NoError(t, db.SaveState(ctx, beaconState, blockRoot))
require.NoError(t, db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block}))
require.NoError(t, db.SaveBlock(ctx, block))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot))
req := &ethpb.AttestationDataRequest{
@@ -447,20 +442,17 @@ func TestGetAttestationData_SucceedsInFirstEpoch(t *testing.T) {
db, _ := dbutil.SetupDB(t)
slot := uint64(5)
block := &ethpb.BeaconBlock{
Slot: slot,
}
targetBlock := &ethpb.BeaconBlock{
Slot: 0,
}
justifiedBlock := &ethpb.BeaconBlock{
Slot: 0,
}
blockRoot, err := stateutil.BlockRoot(block)
block := testutil.NewBeaconBlock()
block.Block.Slot = slot
targetBlock := testutil.NewBeaconBlock()
targetBlock.Block.Slot = 0
justifiedBlock := testutil.NewBeaconBlock()
justifiedBlock.Block.Slot = 0
blockRoot, err := stateutil.BlockRoot(block.Block)
require.NoError(t, err, "Could not hash beacon block")
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock)
justifiedRoot, err := stateutil.BlockRoot(justifiedBlock.Block)
require.NoError(t, err, "Could not get signing root for justified block")
targetRoot, err := stateutil.BlockRoot(targetBlock)
targetRoot, err := stateutil.BlockRoot(targetBlock.Block)
require.NoError(t, err, "Could not get signing root for target block")
beaconState := testutil.NewBeaconState()
@@ -493,7 +485,7 @@ func TestGetAttestationData_SucceedsInFirstEpoch(t *testing.T) {
StateNotifier: chainService.StateNotifier(),
}
require.NoError(t, db.SaveState(ctx, beaconState, blockRoot))
require.NoError(t, db.SaveBlock(ctx, &ethpb.SignedBeaconBlock{Block: block}))
require.NoError(t, db.SaveBlock(ctx, block))
require.NoError(t, db.SaveHeadBlockRoot(ctx, blockRoot))
req := &ethpb.AttestationDataRequest{

5
beacon-chain/rpc/validator/proposer.go
View File

@@ -12,7 +12,6 @@ import (
fastssz "github.com/ferranbt/fastssz"
"github.com/pkg/errors"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/core/feed"
@@ -541,7 +540,7 @@ func (vs *Server) depositTrie(ctx context.Context, canonicalEth1DataHeight *big.
insertIndex := finalizedDeposits.MerkleTrieIndex + 1
for _, dep := range upToEth1DataDeposits {
depHash, err := ssz.HashTreeRoot(dep.Data)
depHash, err := dep.Data.HashTreeRoot()
if err != nil {
return nil, errors.Wrap(err, "could not hash deposit data")
}
@@ -555,7 +554,7 @@ func (vs *Server) depositTrie(ctx context.Context, canonicalEth1DataHeight *big.
upToEth1DataDeposits := vs.DepositFetcher.AllDeposits(ctx, canonicalEth1DataHeight)
depositData := [][]byte{}
for _, dep := range upToEth1DataDeposits {
depHash, err := ssz.HashTreeRoot(dep.Data)
depHash, err := dep.Data.HashTreeRoot()
if err != nil {
return nil, errors.Wrap(err, "could not hash deposit data")
}

281
beacon-chain/rpc/validator/proposer_test.go
View File

@@ -11,7 +11,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-bitfield"
"github.com/prysmaticlabs/go-ssz"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/cache/depositcache"
b "github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
@@ -277,19 +276,10 @@ func TestComputeStateRoot_OK(t *testing.T) {
Eth1BlockFetcher: &mockPOW.POWChain{},
StateGen: stategen.New(db, sc),
}
req := &ethpb.SignedBeaconBlock{
Block: &ethpb.BeaconBlock{
ProposerIndex: 21,
ParentRoot: parentRoot[:],
Slot: 1,
Body: &ethpb.BeaconBlockBody{
RandaoReveal: nil,
ProposerSlashings: nil,
AttesterSlashings: nil,
Eth1Data: &ethpb.Eth1Data{},
},
},
}
req := testutil.NewBeaconBlock()
req.Block.ProposerIndex = 21
req.Block.ParentRoot = parentRoot[:]
req.Block.Slot = 1
require.NoError(t, beaconState.SetSlot(beaconState.Slot()+1))
randaoReveal, err := testutil.RandaoReveal(beaconState, 0, privKeys)
require.NoError(t, err)
@@ -334,22 +324,17 @@ func TestPendingDeposits_Eth1DataVoteOK(t *testing.T) {
blockHash = make([]byte, 32)
copy(blockHash, "0x0")
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: blockHash,
DepositCount: 2,
},
Eth1DepositIndex: 2,
Eth1DataVotes: votes,
})
require.NoError(t, err)
beaconState := testutil.NewBeaconState()
require.NoError(t, beaconState.SetEth1DepositIndex(2))
require.NoError(t, beaconState.SetEth1Data(&ethpb.Eth1Data{
DepositRoot: make([]byte, 32),
BlockHash: blockHash,
DepositCount: 2,
}))
require.NoError(t, beaconState.SetEth1DataVotes(votes))
blk := &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{Eth1Data: &ethpb.Eth1Data{}},
}
blkRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock()
blkRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
bs := &Server{
@@ -367,7 +352,7 @@ func TestPendingDeposits_Eth1DataVoteOK(t *testing.T) {
assert.Equal(t, 0, eth1Height.Cmp(height))
newState, err := b.ProcessEth1DataInBlock(beaconState, blk)
newState, err := b.ProcessEth1DataInBlock(beaconState, blk.Block)
require.NoError(t, err)
if proto.Equal(newState.Eth1Data(), vote) {
@@ -375,15 +360,13 @@ func TestPendingDeposits_Eth1DataVoteOK(t *testing.T) {
"have majority: Got %v", vote)
}
blk = &ethpb.BeaconBlock{
Body: &ethpb.BeaconBlockBody{Eth1Data: vote},
}
blk.Block.Body.Eth1Data = vote
_, eth1Height, err = bs.canonicalEth1Data(ctx, beaconState, vote)
require.NoError(t, err)
assert.Equal(t, 0, eth1Height.Cmp(newHeight))
newState, err = b.ProcessEth1DataInBlock(beaconState, blk)
newState, err = b.ProcessEth1DataInBlock(beaconState, blk.Block)
require.NoError(t, err)
if !proto.Equal(newState.Eth1Data(), vote) {
@@ -404,7 +387,8 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
},
Eth1DepositIndex: 2,
})
@@ -420,7 +404,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
Eth1BlockHeight: 2,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -430,7 +414,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
Eth1BlockHeight: 8,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -443,7 +427,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
Eth1BlockHeight: 400,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("c"),
PublicKey: bytesutil.PadTo([]byte("c"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -453,7 +437,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
Eth1BlockHeight: 600,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("d"),
PublicKey: bytesutil.PadTo([]byte("d"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -466,7 +450,7 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
require.NoError(t, err, "Could not setup deposit trie")
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -476,11 +460,10 @@ func TestPendingDeposits_OutsideEth1FollowWindow(t *testing.T) {
depositCache.InsertPendingDeposit(ctx, dp.Deposit, dp.Eth1BlockHeight, dp.Index, depositTrie.Root())
}
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := ssz.HashTreeRoot(blk)
blkRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
bs := &Server{
@@ -521,7 +504,8 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
var votes []*ethpb.Eth1Data
vote := &ethpb.Eth1Data{
BlockHash: []byte("0x1"),
BlockHash: bytesutil.PadTo([]byte("0x1"), 32),
DepositRoot: make([]byte, 32),
DepositCount: 7,
}
period := params.BeaconConfig().EpochsPerEth1VotingPeriod * params.BeaconConfig().SlotsPerEpoch
@@ -532,17 +516,17 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
DepositRoot: make([]byte, 32),
DepositCount: 5,
},
Eth1DepositIndex: 1,
Eth1DataVotes: votes,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := ssz.HashTreeRoot(blk)
blkRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
@@ -555,7 +539,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
Eth1BlockHeight: 8,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -565,7 +549,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
Eth1BlockHeight: 14,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -578,7 +562,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
Eth1BlockHeight: 5000,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("c"),
PublicKey: bytesutil.PadTo([]byte("c"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -588,7 +572,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
Eth1BlockHeight: 6000,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("d"),
PublicKey: bytesutil.PadTo([]byte("d"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -601,7 +585,7 @@ func TestPendingDeposits_FollowsCorrectEth1Block(t *testing.T) {
depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
require.NoError(t, err, "Could not setup deposit trie")
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -644,18 +628,16 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
},
}
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
DepositCount: 100,
},
Eth1DepositIndex: 10,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blkRoot, err := ssz.HashTreeRoot(blk)
beaconState := testutil.NewBeaconState()
require.NoError(t, beaconState.SetEth1Data(&ethpb.Eth1Data{
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
DepositCount: 100,
}))
require.NoError(t, beaconState.SetEth1DepositIndex(10))
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
@@ -666,7 +648,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
Index: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -675,7 +657,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
Index: 1,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -688,7 +670,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
Index: i,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{byte(i)},
PublicKey: bytesutil.PadTo([]byte{byte(i)}, 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -701,7 +683,7 @@ func TestPendingDeposits_CantReturnBelowStateEth1DepositIndex(t *testing.T) {
require.NoError(t, err)
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -743,16 +725,16 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
DepositCount: 100,
},
Eth1DepositIndex: 2,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blkRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
var mockCreds [32]byte
@@ -762,7 +744,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
Index: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -771,7 +753,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
Index: 1,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -784,7 +766,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
Index: i,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{byte(i)},
PublicKey: bytesutil.PadTo([]byte{byte(i)}, 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -797,7 +779,7 @@ func TestPendingDeposits_CantReturnMoreThanMax(t *testing.T) {
require.NoError(t, err)
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -837,16 +819,16 @@ func TestPendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
DepositCount: 5,
},
Eth1DepositIndex: 2,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blkRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := blk.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
var mockCreds [32]byte
@@ -856,7 +838,7 @@ func TestPendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
Index: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -865,7 +847,7 @@ func TestPendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
Index: 1,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -878,7 +860,7 @@ func TestPendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
Index: i,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{byte(i)},
PublicKey: bytesutil.PadTo([]byte{byte(i)}, 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -891,7 +873,7 @@ func TestPendingDeposits_CantReturnMoreThanDepositCount(t *testing.T) {
require.NoError(t, err)
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -933,17 +915,17 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
DepositCount: 4,
},
Eth1DepositIndex: 1,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := ssz.HashTreeRoot(blk)
blkRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
@@ -956,7 +938,7 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -966,7 +948,7 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 10,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -979,7 +961,7 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("c"),
PublicKey: bytesutil.PadTo([]byte("c"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -989,7 +971,7 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
Eth1BlockHeight: 11,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("d"),
PublicKey: bytesutil.PadTo([]byte("d"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1002,7 +984,7 @@ func TestDepositTrie_UtilizesCachedFinalizedDeposits(t *testing.T) {
depositTrie, err := trieutil.NewTrie(int(params.BeaconConfig().DepositContractTreeDepth))
require.NoError(t, err, "Could not setup deposit trie")
for _, dp := range append(finalizedDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -1063,7 +1045,7 @@ func TestDefaultEth1Data_NoBlockExists(t *testing.T) {
Eth1BlockHeight: 8,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1073,7 +1055,7 @@ func TestDefaultEth1Data_NoBlockExists(t *testing.T) {
Eth1BlockHeight: 14,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1162,7 +1144,7 @@ func TestEth1Data_SmallerDepositCount(t *testing.T) {
Eth1BlockHeight: 8,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1172,7 +1154,7 @@ func TestEth1Data_SmallerDepositCount(t *testing.T) {
Eth1BlockHeight: 14,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1277,7 +1259,7 @@ func TestEth1DataMajorityVote_ChooseHighestCount(t *testing.T) {
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1338,7 +1320,7 @@ func TestEth1DataMajorityVote_HighestCountBeforeRange_ChooseHighestCountWithinRa
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1398,7 +1380,7 @@ func TestEth1DataMajorityVote_HighestCountAfterRange_ChooseHighestCountWithinRan
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1458,7 +1440,7 @@ func TestEth1DataMajorityVote_HighestCountOnUnknownBlock_ChooseKnownBlockWithHig
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1520,7 +1502,7 @@ func TestEth1DataMajorityVote_NoVotesInRange_ChooseDefault(t *testing.T) {
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1580,7 +1562,7 @@ func TestEth1DataMajorityVote_NoVotes_ChooseDefault(t *testing.T) {
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1635,7 +1617,7 @@ func TestEth1DataMajorityVote_SameCount_ChooseMoreRecentBlock(t *testing.T) {
Eth1BlockHeight: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: make([]byte, 96),
WithdrawalCredentials: make([]byte, 32),
}},
@@ -1702,9 +1684,14 @@ func TestFilterAttestation_OK(t *testing.T) {
atts := make([]*ethpb.Attestation, 10)
for i := 0; i < len(atts); i++ {
atts[i] = &ethpb.Attestation{Data: &ethpb.AttestationData{
CommitteeIndex: uint64(i),
Target: &ethpb.Checkpoint{}},
atts[i] = &ethpb.Attestation{
Data: &ethpb.AttestationData{
CommitteeIndex: uint64(i),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: make([]byte, 32)},
BeaconBlockRoot: make([]byte, 32),
},
Signature: make([]byte, 96),
}
}
received, err := proposerServer.filterAttestationsForBlockInclusion(context.Background(), state, atts)
@@ -1716,11 +1703,15 @@ func TestFilterAttestation_OK(t *testing.T) {
for i := 0; i < len(atts); i++ {
aggBits := bitfield.NewBitlist(2)
aggBits.SetBitAt(0, true)
atts[i] = &ethpb.Attestation{Data: &ethpb.AttestationData{
CommitteeIndex: uint64(i),
Target: &ethpb.Checkpoint{},
Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}},
atts[i] = &ethpb.Attestation{
Data: &ethpb.AttestationData{
CommitteeIndex: uint64(i),
Target: &ethpb.Checkpoint{Root: make([]byte, 32)},
Source: &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]},
BeaconBlockRoot: make([]byte, 32),
},
AggregationBits: aggBits,
Signature: make([]byte, 96),
}
committee, err := helpers.BeaconCommitteeFromState(state, atts[i].Data.Slot, atts[i].Data.CommitteeIndex)
assert.NoError(t, err)
@@ -1765,7 +1756,7 @@ func Benchmark_Eth1Data(b *testing.B) {
Index: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1774,7 +1765,7 @@ func Benchmark_Eth1Data(b *testing.B) {
Index: 1,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1802,10 +1793,9 @@ func Benchmark_Eth1Data(b *testing.B) {
}
hashesByHeight[numOfVotes+1] = []byte("stub")
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blkRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := blk.HashTreeRoot()
require.NoError(b, err)
currentHeight := params.BeaconConfig().Eth1FollowDistance + 5
@@ -1843,15 +1833,15 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
beaconState, err := beaconstate.InitializeFromProto(&pbp2p.BeaconState{
Eth1Data: &ethpb.Eth1Data{
BlockHash: []byte("0x0"),
BlockHash: bytesutil.PadTo([]byte("0x0"), 32),
DepositRoot: make([]byte, 32),
},
Eth1DepositIndex: 2,
})
require.NoError(t, err)
blk := &ethpb.BeaconBlock{
Slot: beaconState.Slot(),
}
blkRoot, err := ssz.HashTreeRoot(blk)
blk := testutil.NewBeaconBlock()
blk.Block.Slot = beaconState.Slot()
blkRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
var mockSig [96]byte
@@ -1862,7 +1852,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
Index: 0,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("a"),
PublicKey: bytesutil.PadTo([]byte("a"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1871,7 +1861,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
Index: 1,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte("b"),
PublicKey: bytesutil.PadTo([]byte("b"), 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1884,7 +1874,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
Index: i,
Deposit: &ethpb.Deposit{
Data: &ethpb.Deposit_Data{
PublicKey: []byte{byte(i)},
PublicKey: bytesutil.PadTo([]byte{byte(i)}, 48),
Signature: mockSig[:],
WithdrawalCredentials: mockCreds[:],
}},
@@ -1897,7 +1887,7 @@ func TestDeposits_ReturnsEmptyList_IfLatestEth1DataEqGenesisEth1Block(t *testing
require.NoError(t, err)
for _, dp := range append(readyDeposits, recentDeposits...) {
depositHash, err := ssz.HashTreeRoot(dp.Deposit.Data)
depositHash, err := dp.Deposit.Data.HashTreeRoot()
require.NoError(t, err, "Unable to determine hashed value of deposit")
depositTrie.Insert(depositHash[:], int(dp.Index))
@@ -1930,9 +1920,8 @@ func TestDeleteAttsInPool_Aggregated(t *testing.T) {
}
sig := bls.RandKey().Sign([]byte("foo")).Marshal()
d := &ethpb.AttestationData{}
aggregatedAtts := []*ethpb.Attestation{{Data: d, AggregationBits: bitfield.Bitlist{0b10101}, Signature: sig}, {Data: d, AggregationBits: bitfield.Bitlist{0b11010}, Signature: sig}}
unaggregatedAtts := []*ethpb.Attestation{{Data: d, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig}, {Data: d, AggregationBits: bitfield.Bitlist{0b0001}, Signature: sig}}
aggregatedAtts := []*ethpb.Attestation{{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b10101}, Signature: sig}, {Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11010}, Signature: sig}}
unaggregatedAtts := []*ethpb.Attestation{{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b1001}, Signature: sig}, {Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b0001}, Signature: sig}}
require.NoError(t, s.AttPool.SaveAggregatedAttestations(aggregatedAtts))
require.NoError(t, s.AttPool.SaveUnaggregatedAttestations(unaggregatedAtts))
@@ -1948,21 +1937,21 @@ func TestDeleteAttsInPool_Aggregated(t *testing.T) {
func TestSortProfitableAtts(t *testing.T) {
atts := []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11110000}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 4, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 4, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11110000}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11000000}},
}
sort.Sort(profitableAtts{atts: atts})
want := []*ethpb.Attestation{
{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11110000}},
{Data: &ethpb.AttestationData{Slot: 4}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 3}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 2}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 4, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11110000}},
{Data: &ethpb.AttestationData{Slot: 4, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 3, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11000000}},
{Data: &ethpb.AttestationData{Slot: 2, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11100000}},
{Data: &ethpb.AttestationData{Slot: 1, BeaconBlockRoot: make([]byte, 32), Target: &ethpb.Checkpoint{Root: make([]byte, 32)}, Source: &ethpb.Checkpoint{Root: make([]byte, 32)}}, AggregationBits: bitfield.Bitlist{0b11000000}},
}
require.DeepEqual(t, want, atts)
}

11
beacon-chain/rpc/validator/server_test.go
View File

@@ -20,6 +20,7 @@ import (
mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/event"
"github.com/prysmaticlabs/prysm/shared/mock"
"github.com/prysmaticlabs/prysm/shared/params"
@@ -118,9 +119,10 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
Slot: 4000,
Validators: []*ethpb.Validator{
{
ActivationEpoch: 0,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: pubKey1,
ActivationEpoch: 0,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: pubKey1,
WithdrawalCredentials: make([]byte, 32),
},
},
}
@@ -129,7 +131,8 @@ func TestWaitForActivation_ValidatorOriginallyExists(t *testing.T) {
require.NoError(t, err, "Could not get signing root")
depData := &ethpb.Deposit_Data{
PublicKey: pubKey1,
WithdrawalCredentials: []byte("hey"),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
Signature: make([]byte, 96),
}
domain, err := helpers.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
require.NoError(t, err)

105
beacon-chain/rpc/validator/status_test.go
View File

@@ -17,6 +17,7 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -71,8 +72,8 @@ func TestValidatorStatus_Deposited(t *testing.T) {
pubKey1 := pubKey(1)
depData := &ethpb.Deposit_Data{
PublicKey: pubKey1,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
Data: depData,
@@ -129,10 +130,11 @@ func TestValidatorStatus_Pending(t *testing.T) {
require.NoError(t, state.SetSlot(5000))
err = state.SetValidators([]*ethpb.Validator{
{
ActivationEpoch: params.BeaconConfig().FarFutureEpoch,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: pubKey,
ActivationEpoch: params.BeaconConfig().FarFutureEpoch,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
PublicKey: pubKey,
WithdrawalCredentials: make([]byte, 32),
},
})
require.NoError(t, err)
@@ -141,8 +143,8 @@ func TestValidatorStatus_Pending(t *testing.T) {
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -188,8 +190,8 @@ func TestValidatorStatus_Active(t *testing.T) {
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -279,8 +281,8 @@ func TestValidatorStatus_Exiting(t *testing.T) {
require.NoError(t, err)
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -339,8 +341,8 @@ func TestValidatorStatus_Slashing(t *testing.T) {
require.NoError(t, err)
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -396,14 +398,15 @@ func TestValidatorStatus_Exited(t *testing.T) {
state := testutil.NewBeaconState()
require.NoError(t, state.SetSlot(slot))
err = state.SetValidators([]*ethpb.Validator{{
PublicKey: pubKey,
WithdrawableEpoch: epoch + 1},
PublicKey: pubKey,
WithdrawableEpoch: epoch + 1,
WithdrawalCredentials: make([]byte, 32)},
})
require.NoError(t, err)
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -563,40 +566,46 @@ func TestValidatorStatus_CorrectActivationQueue(t *testing.T) {
// Pending active because activation epoch is still defaulted at far future slot.
validators := []*ethpb.Validator{
{
ActivationEpoch: 0,
PublicKey: pubKey(0),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: 0,
PublicKey: pubKey(0),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
{
ActivationEpoch: 0,
PublicKey: pubKey(1),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: 0,
PublicKey: pubKey(1),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
{
ActivationEpoch: 0,
PublicKey: pubKey(2),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: 0,
PublicKey: pubKey(2),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
{
ActivationEpoch: 0,
PublicKey: pubKey(3),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: 0,
PublicKey: pubKey(3),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
{
ActivationEpoch: currentSlot/params.BeaconConfig().SlotsPerEpoch + 1,
PublicKey: pbKey,
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: currentSlot/params.BeaconConfig().SlotsPerEpoch + 1,
PublicKey: pbKey,
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
{
ActivationEpoch: currentSlot/params.BeaconConfig().SlotsPerEpoch + 4,
PublicKey: pubKey(5),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
ActivationEpoch: currentSlot/params.BeaconConfig().SlotsPerEpoch + 4,
PublicKey: pubKey(5),
WithdrawalCredentials: make([]byte, 32),
ExitEpoch: params.BeaconConfig().FarFutureEpoch,
WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
},
}
state := testutil.NewBeaconState()
@@ -613,8 +622,8 @@ func TestValidatorStatus_CorrectActivationQueue(t *testing.T) {
for i := 0; i < 6; i++ {
depData := &ethpb.Deposit_Data{
PublicKey: pubKey(uint64(i)),
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -655,8 +664,8 @@ func TestDepositBlockSlotAfterGenesisTime(t *testing.T) {
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{
@@ -718,8 +727,8 @@ func TestDepositBlockSlotBeforeGenesisTime(t *testing.T) {
depData := &ethpb.Deposit_Data{
PublicKey: pubKey,
Signature: []byte("hi"),
WithdrawalCredentials: []byte("hey"),
Signature: bytesutil.PadTo([]byte("hi"), 96),
WithdrawalCredentials: bytesutil.PadTo([]byte("hey"), 32),
}
deposit := &ethpb.Deposit{

5
beacon-chain/state/state_trie_test.go
View File

@@ -6,7 +6,6 @@ import (
"testing"
eth "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/state"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -160,7 +159,7 @@ func TestBeaconState_HashTreeRoot(t *testing.T) {
if err == nil && tt.error != "" {
t.Errorf("Expected error, expected %v, recevied %v", tt.error, err)
}
genericHTR, err := ssz.HashTreeRoot(testState.InnerStateUnsafe())
genericHTR, err := testState.InnerStateUnsafe().HashTreeRoot()
if err == nil && tt.error != "" {
t.Errorf("Expected error, expected %v, recevied %v", tt.error, err)
}
@@ -231,7 +230,7 @@ func TestBeaconState_HashTreeRoot_FieldTrie(t *testing.T) {
if err == nil && tt.error != "" {
t.Errorf("Expected error, expected %v, recevied %v", tt.error, err)
}
genericHTR, err := ssz.HashTreeRoot(testState.InnerStateUnsafe())
genericHTR, err := testState.InnerStateUnsafe().HashTreeRoot()
if err == nil && tt.error != "" {
t.Errorf("Expected error, expected %v, recevied %v", tt.error, err)
}

1
beacon-chain/state/stategen/BUILD.bazel
View File

@@ -66,7 +66,6 @@ go_test(
"//shared/testutil/require:go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
"@com_github_sirupsen_logrus//hooks/test:go_default_library",
],
)

5
beacon-chain/state/stategen/cold_test.go
View File

@@ -4,7 +4,6 @@ import (
"context"
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
@@ -58,7 +57,7 @@ func TestLoadStateByRoot_CanGet(t *testing.T) {
service.slotsPerArchivedPoint = 1
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
@@ -84,7 +83,7 @@ func TestLoadColdStateBySlot_CanGet(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))

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

@@ -5,7 +5,6 @@ import (
"testing"
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
@@ -24,7 +23,8 @@ func TestStateByRoot_ColdState(t *testing.T) {
service.finalizedInfo.slot = 2
service.slotsPerArchivedPoint = 1
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, b))
bRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -55,7 +55,7 @@ func TestStateByRoot_HotStateUsingEpochBoundaryCacheNoReplay(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(10))
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveStateSummary(ctx, &pb.StateSummary{Root: blkRoot[:]}))
@@ -72,12 +72,15 @@ func TestStateByRoot_HotStateUsingEpochBoundaryCacheWithReplay(t *testing.T) {
service := New(db, ssc)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.epochBoundaryStateCache.put(blkRoot, beaconState))
targetSlot := uint64(10)
targetBlock := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 11, ParentRoot: blkRoot[:], ProposerIndex: 8}}
targetBlock := testutil.NewBeaconBlock()
targetBlock.Block.Slot = 11
targetBlock.Block.ParentRoot = blkRoot[:]
targetBlock.Block.ProposerIndex = 8
require.NoError(t, service.beaconDB.SaveBlock(ctx, targetBlock))
targetRoot, err := stateutil.BlockRoot(targetBlock.Block)
require.NoError(t, err)
@@ -119,7 +122,7 @@ func TestStateByRootInitialSync_UseEpochStateCache(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
targetSlot := uint64(10)
require.NoError(t, beaconState.SetSlot(targetSlot))
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.epochBoundaryStateCache.put(blkRoot, beaconState))
@@ -155,12 +158,14 @@ func TestStateByRootInitialSync_CanProcessUpTo(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.epochBoundaryStateCache.put(blkRoot, beaconState))
targetSlot := uint64(10)
targetBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 11, ParentRoot: blkRoot[:]}}
targetBlk := testutil.NewBeaconBlock()
targetBlk.Block.Slot = 11
targetBlk.Block.ParentRoot = blkRoot[:]
targetRoot, err := stateutil.BlockRoot(targetBlk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, targetBlk))
@@ -186,7 +191,8 @@ func TestStateBySlot_ColdState(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(1))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
require.NoError(t, db.SaveBlock(ctx, b))
bRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -214,7 +220,7 @@ func TestStateBySlot_HotStateDB(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
bRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)

31
beacon-chain/state/stategen/hot_test.go
View File

@@ -5,8 +5,6 @@ import (
"testing"
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
@@ -66,7 +64,7 @@ func TestSaveHotState_NoSaveNotEpochBoundary(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
require.NoError(t, beaconState.SetSlot(params.BeaconConfig().SlotsPerEpoch-1))
r := [32]byte{'A'}
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, db.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -103,12 +101,15 @@ func TestLoadHoteStateByRoot_EpochBoundaryStateCanProcess(t *testing.T) {
service := New(db, ssc)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gBlkRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
require.NoError(t, service.epochBoundaryStateCache.put(gBlkRoot, beaconState))
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 11, ParentRoot: gBlkRoot[:], ProposerIndex: 8}}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = 11
blk.Block.ProposerIndex = 8
blk.Block.ParentRoot = gBlkRoot[:]
require.NoError(t, service.beaconDB.SaveBlock(ctx, blk))
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
@@ -131,7 +132,7 @@ func TestLoadHoteStateByRoot_FromDBBoundaryCase(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
blk := testutil.NewBeaconBlock()
blkRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.epochBoundaryStateCache.put(blkRoot, beaconState))
@@ -155,7 +156,7 @@ func TestLoadHoteStateBySlot_CanAdvanceSlotUsingDB(t *testing.T) {
db, _ := testDB.SetupDB(t)
service := New(db, cache.NewStateSummaryCache())
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
b := testutil.NewBeaconBlock()
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
gRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
@@ -175,22 +176,22 @@ func TestLastAncestorState_CanGetUsingDB(t *testing.T) {
b0 := testutil.NewBeaconBlock()
b0.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
r0, err := ssz.HashTreeRoot(b0.Block)
r0, err := b0.Block.HashTreeRoot()
require.NoError(t, err)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = bytesutil.PadTo(r0[:], 32)
r1, err := ssz.HashTreeRoot(b1.Block)
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 2
b2.Block.ParentRoot = bytesutil.PadTo(r1[:], 32)
r2, err := ssz.HashTreeRoot(b2.Block)
r2, err := b2.Block.HashTreeRoot()
require.NoError(t, err)
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 3
b3.Block.ParentRoot = bytesutil.PadTo(r2[:], 32)
r3, err := ssz.HashTreeRoot(b3.Block)
r3, err := b3.Block.HashTreeRoot()
require.NoError(t, err)
b1State := testutil.NewBeaconState()
@@ -214,22 +215,22 @@ func TestLastAncestorState_CanGetUsingHotCache(t *testing.T) {
b0 := testutil.NewBeaconBlock()
b0.Block.ParentRoot = bytesutil.PadTo([]byte{'a'}, 32)
r0, err := ssz.HashTreeRoot(b0.Block)
r0, err := b0.Block.HashTreeRoot()
require.NoError(t, err)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = bytesutil.PadTo(r0[:], 32)
r1, err := ssz.HashTreeRoot(b1.Block)
r1, err := b1.Block.HashTreeRoot()
require.NoError(t, err)
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 2
b2.Block.ParentRoot = bytesutil.PadTo(r1[:], 32)
r2, err := ssz.HashTreeRoot(b2.Block)
r2, err := b2.Block.HashTreeRoot()
require.NoError(t, err)
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 3
b3.Block.ParentRoot = bytesutil.PadTo(r2[:], 32)
r3, err := ssz.HashTreeRoot(b3.Block)
r3, err := b3.Block.HashTreeRoot()
require.NoError(t, err)
b1State := testutil.NewBeaconState()

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

@@ -4,7 +4,6 @@ import (
"context"
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
@@ -20,7 +19,8 @@ func TestMigrateToCold_CanSaveFinalizedInfo(t *testing.T) {
db, c := testDB.SetupDB(t)
service := New(db, c)
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 1}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 1
br, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
@@ -41,7 +41,8 @@ func TestMigrateToCold_HappyPath(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
stateSlot := uint64(1)
require.NoError(t, beaconState.SetSlot(stateSlot))
b := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
b := testutil.NewBeaconBlock()
b.Block.Slot = 2
fRoot, err := stateutil.BlockRoot(b.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, b))
@@ -70,7 +71,8 @@ func TestMigrateToCold_RegeneratePath(t *testing.T) {
beaconState, _ := testutil.DeterministicGenesisState(t, 32)
stateSlot := uint64(1)
require.NoError(t, beaconState.SetSlot(stateSlot))
blk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 2}}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = 2
fRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, blk))

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

@@ -6,7 +6,6 @@ import (
"github.com/gogo/protobuf/proto"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/cache"
"github.com/prysmaticlabs/prysm/beacon-chain/core/blocks"
"github.com/prysmaticlabs/prysm/beacon-chain/db"
@@ -26,7 +25,7 @@ func TestComputeStateUpToSlot_GenesisState(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, gBlk))
@@ -48,7 +47,7 @@ func TestComputeStateUpToSlot_CanProcessUpTo(t *testing.T) {
service := New(db, cache.NewStateSummaryCache())
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
require.NoError(t, service.beaconDB.SaveBlock(ctx, gBlk))
@@ -156,7 +155,7 @@ func TestLoadBlocks_SecondBranch(t *testing.T) {
beaconDB: db,
}
roots, savedBlocks, err := tree1(db, []byte{'A'})
roots, savedBlocks, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 5, roots[5])
@@ -183,7 +182,7 @@ func TestLoadBlocks_ThirdBranch(t *testing.T) {
beaconDB: db,
}
roots, savedBlocks, err := tree1(db, []byte{'A'})
roots, savedBlocks, err := tree1(db, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 7, roots[7])
@@ -212,7 +211,7 @@ func TestLoadBlocks_SameSlots(t *testing.T) {
beaconDB: db,
}
roots, savedBlocks, err := tree2(db, []byte{'A'})
roots, savedBlocks, err := tree2(db, bytesutil.PadTo([]byte{'A'}, 32))
require.NoError(t, err)
filteredBlocks, err := s.LoadBlocks(ctx, 0, 3, roots[6])
@@ -304,7 +303,7 @@ func TestLastSavedBlock_Genesis(t *testing.T) {
finalizedInfo: &finalizedInfo{slot: 128},
}
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
require.NoError(t, s.beaconDB.SaveBlock(ctx, gBlk))
@@ -324,11 +323,14 @@ func TestLastSavedBlock_CanGet(t *testing.T) {
finalizedInfo: &finalizedInfo{slot: 128},
}
b1 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 5}}
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = s.finalizedInfo.slot + 5
require.NoError(t, s.beaconDB.SaveBlock(ctx, b1))
b2 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 10}}
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = s.finalizedInfo.slot + 10
require.NoError(t, s.beaconDB.SaveBlock(ctx, b2))
b3 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 20}}
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = s.finalizedInfo.slot + 20
require.NoError(t, s.beaconDB.SaveBlock(ctx, b3))
savedRoot, savedSlot, err := s.lastSavedBlock(ctx, s.finalizedInfo.slot+100)
@@ -362,7 +364,7 @@ func TestLastSavedState_Genesis(t *testing.T) {
finalizedInfo: &finalizedInfo{slot: 128},
}
gBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{}}
gBlk := testutil.NewBeaconBlock()
gState := testutil.NewBeaconState()
gRoot, err := stateutil.BlockRoot(gBlk.Block)
require.NoError(t, err)
@@ -383,9 +385,11 @@ func TestLastSavedState_CanGet(t *testing.T) {
finalizedInfo: &finalizedInfo{slot: 128},
}
b1 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 5}}
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = s.finalizedInfo.slot + 5
require.NoError(t, s.beaconDB.SaveBlock(ctx, b1))
b2 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 10}}
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = s.finalizedInfo.slot + 10
require.NoError(t, s.beaconDB.SaveBlock(ctx, b2))
b2Root, err := stateutil.BlockRoot(b2.Block)
require.NoError(t, err)
@@ -393,7 +397,8 @@ func TestLastSavedState_CanGet(t *testing.T) {
require.NoError(t, st.SetSlot(s.finalizedInfo.slot+10))
require.NoError(t, s.beaconDB.SaveState(ctx, st, b2Root))
b3 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: s.finalizedInfo.slot + 20}}
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = s.finalizedInfo.slot + 20
require.NoError(t, s.beaconDB.SaveBlock(ctx, b3))
savedState, err := s.lastSavedState(ctx, s.finalizedInfo.slot+100)
@@ -411,7 +416,8 @@ func TestLastSavedState_NoSavedBlockState(t *testing.T) {
finalizedInfo: &finalizedInfo{slot: 128},
}
b1 := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: 127}}
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 127
require.NoError(t, s.beaconDB.SaveBlock(ctx, b1))
_, err := s.lastSavedState(ctx, s.finalizedInfo.slot+1)
@@ -465,58 +471,76 @@ func TestProcessStateUpToSlot_CanProcess(t *testing.T) {
// \- B2 -- B4 -- B6 ----- B8
// \- B7
func tree1(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
r0, err := ssz.HashTreeRoot(b0)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
r0, err := b0.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = r0[:]
r1, err := b1.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b2 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:]}
r2, err := ssz.HashTreeRoot(b2)
b2 := testutil.NewBeaconBlock()
b2.Block.Slot = 2
b2.Block.ParentRoot = r1[:]
r2, err := b2.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r1[:]}
r3, err := ssz.HashTreeRoot(b3)
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 3
b3.Block.ParentRoot = r1[:]
r3, err := b3.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b4 := &ethpb.BeaconBlock{Slot: 4, ParentRoot: r2[:]}
r4, err := ssz.HashTreeRoot(b4)
b4 := testutil.NewBeaconBlock()
b4.Block.Slot = 4
b4.Block.ParentRoot = r2[:]
r4, err := b4.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b5 := &ethpb.BeaconBlock{Slot: 5, ParentRoot: r3[:]}
r5, err := ssz.HashTreeRoot(b5)
b5 := testutil.NewBeaconBlock()
b5.Block.Slot = 5
b5.Block.ParentRoot = r3[:]
r5, err := b5.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b6 := &ethpb.BeaconBlock{Slot: 6, ParentRoot: r4[:]}
r6, err := ssz.HashTreeRoot(b6)
b6 := testutil.NewBeaconBlock()
b6.Block.Slot = 6
b6.Block.ParentRoot = r4[:]
r6, err := b6.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b7 := &ethpb.BeaconBlock{Slot: 7, ParentRoot: r6[:]}
r7, err := ssz.HashTreeRoot(b7)
b7 := testutil.NewBeaconBlock()
b7.Block.Slot = 7
b7.Block.ParentRoot = r6[:]
r7, err := b7.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b8 := &ethpb.BeaconBlock{Slot: 8, ParentRoot: r6[:]}
r8, err := ssz.HashTreeRoot(b8)
b8 := testutil.NewBeaconBlock()
b8.Block.Slot = 8
b8.Block.ParentRoot = r6[:]
r8, err := b8.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
st := testutil.NewBeaconState()
returnedBlocks := make([]*ethpb.SignedBeaconBlock, 0)
for _, b := range []*ethpb.BeaconBlock{b0, b1, b2, b3, b4, b5, b6, b7, b8} {
for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b2, b3, b4, b5, b6, b7, b8} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
@@ -535,49 +559,67 @@ func tree1(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2 -- B3
func tree2(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
r0, err := ssz.HashTreeRoot(b0)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
r0, err := b0.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = r0[:]
r1, err := b1.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b21 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'A'}}
r21, err := ssz.HashTreeRoot(b21)
b21 := testutil.NewBeaconBlock()
b21.Block.Slot = 2
b21.Block.ParentRoot = r1[:]
b21.Block.StateRoot = bytesutil.PadTo([]byte{'A'}, 32)
r21, err := b21.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b22 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'B'}}
r22, err := ssz.HashTreeRoot(b22)
b22 := testutil.NewBeaconBlock()
b22.Block.Slot = 2
b22.Block.ParentRoot = r1[:]
b22.Block.StateRoot = bytesutil.PadTo([]byte{'B'}, 32)
r22, err := b22.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b23 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'C'}}
r23, err := ssz.HashTreeRoot(b23)
b23 := testutil.NewBeaconBlock()
b23.Block.Slot = 2
b23.Block.ParentRoot = r1[:]
b23.Block.StateRoot = bytesutil.PadTo([]byte{'C'}, 32)
r23, err := b23.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b24 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'D'}}
r24, err := ssz.HashTreeRoot(b24)
b24 := testutil.NewBeaconBlock()
b24.Block.Slot = 2
b24.Block.ParentRoot = r1[:]
b24.Block.StateRoot = bytesutil.PadTo([]byte{'D'}, 32)
r24, err := b24.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b3 := &ethpb.BeaconBlock{Slot: 3, ParentRoot: r24[:]}
r3, err := ssz.HashTreeRoot(b3)
b3 := testutil.NewBeaconBlock()
b3.Block.Slot = 3
b3.Block.ParentRoot = r24[:]
r3, err := b3.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
st := testutil.NewBeaconState()
returnedBlocks := make([]*ethpb.SignedBeaconBlock, 0)
for _, b := range []*ethpb.BeaconBlock{b0, b1, b21, b22, b23, b24, b3} {
for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b21, b22, b23, b24, b3} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.StateRoot, 32)
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
@@ -596,44 +638,60 @@ func tree2(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2
func tree3(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
r0, err := ssz.HashTreeRoot(b0)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
r0, err := b0.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b1 := &ethpb.BeaconBlock{Slot: 1, ParentRoot: r0[:]}
r1, err := ssz.HashTreeRoot(b1)
b1 := testutil.NewBeaconBlock()
b1.Block.Slot = 1
b1.Block.ParentRoot = r0[:]
r1, err := b1.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b21 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'A'}}
r21, err := ssz.HashTreeRoot(b21)
b21 := testutil.NewBeaconBlock()
b21.Block.Slot = 2
b21.Block.ParentRoot = r1[:]
b21.Block.StateRoot = bytesutil.PadTo([]byte{'A'}, 32)
r21, err := b21.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b22 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'B'}}
r22, err := ssz.HashTreeRoot(b22)
b22 := testutil.NewBeaconBlock()
b22.Block.Slot = 2
b22.Block.ParentRoot = r1[:]
b22.Block.StateRoot = bytesutil.PadTo([]byte{'B'}, 32)
r22, err := b22.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b23 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'C'}}
r23, err := ssz.HashTreeRoot(b23)
b23 := testutil.NewBeaconBlock()
b23.Block.Slot = 2
b23.Block.ParentRoot = r1[:]
b23.Block.StateRoot = bytesutil.PadTo([]byte{'C'}, 32)
r23, err := b23.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b24 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r1[:], StateRoot: []byte{'D'}}
r24, err := ssz.HashTreeRoot(b24)
b24 := testutil.NewBeaconBlock()
b24.Block.Slot = 2
b24.Block.ParentRoot = r1[:]
b24.Block.StateRoot = bytesutil.PadTo([]byte{'D'}, 32)
r24, err := b24.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
st := testutil.NewBeaconState()
returnedBlocks := make([]*ethpb.SignedBeaconBlock, 0)
for _, b := range []*ethpb.BeaconBlock{b0, b1, b21, b22, b23, b24} {
for _, b := range []*ethpb.SignedBeaconBlock{b0, b1, b21, b22, b23, b24} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.StateRoot, 32)
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
@@ -653,39 +711,53 @@ func tree3(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaco
// \- B2
// \- B2
func tree4(db db.Database, genesisRoot []byte) ([][32]byte, []*ethpb.SignedBeaconBlock, error) {
b0 := &ethpb.BeaconBlock{Slot: 0, ParentRoot: genesisRoot}
r0, err := ssz.HashTreeRoot(b0)
b0 := testutil.NewBeaconBlock()
b0.Block.Slot = 0
b0.Block.ParentRoot = genesisRoot
r0, err := b0.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b21 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r0[:], StateRoot: []byte{'A'}}
r21, err := ssz.HashTreeRoot(b21)
b21 := testutil.NewBeaconBlock()
b21.Block.Slot = 2
b21.Block.ParentRoot = r0[:]
b21.Block.StateRoot = bytesutil.PadTo([]byte{'A'}, 32)
r21, err := b21.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b22 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r0[:], StateRoot: []byte{'B'}}
r22, err := ssz.HashTreeRoot(b22)
b22 := testutil.NewBeaconBlock()
b22.Block.Slot = 2
b22.Block.ParentRoot = r0[:]
b22.Block.StateRoot = bytesutil.PadTo([]byte{'B'}, 32)
r22, err := b22.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b23 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r0[:], StateRoot: []byte{'C'}}
r23, err := ssz.HashTreeRoot(b23)
b23 := testutil.NewBeaconBlock()
b23.Block.Slot = 2
b23.Block.ParentRoot = r0[:]
b23.Block.StateRoot = bytesutil.PadTo([]byte{'C'}, 32)
r23, err := b23.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
b24 := &ethpb.BeaconBlock{Slot: 2, ParentRoot: r0[:], StateRoot: []byte{'D'}}
r24, err := ssz.HashTreeRoot(b24)
b24 := testutil.NewBeaconBlock()
b24.Block.Slot = 2
b24.Block.ParentRoot = r0[:]
b24.Block.StateRoot = bytesutil.PadTo([]byte{'D'}, 32)
r24, err := b24.Block.HashTreeRoot()
if err != nil {
return nil, nil, err
}
st := testutil.NewBeaconState()
returnedBlocks := make([]*ethpb.SignedBeaconBlock, 0)
for _, b := range []*ethpb.BeaconBlock{b0, b21, b22, b23, b24} {
for _, b := range []*ethpb.SignedBeaconBlock{b0, b21, b22, b23, b24} {
beaconBlock := testutil.NewBeaconBlock()
beaconBlock.Block.Slot = b.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.StateRoot, 32)
beaconBlock.Block.Slot = b.Block.Slot
beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
beaconBlock.Block.StateRoot = bytesutil.PadTo(b.Block.StateRoot, 32)
if err := db.SaveBlock(context.Background(), beaconBlock); err != nil {
return nil, nil, err
}
@@ -704,10 +776,11 @@ func TestLoadFinalizedBlocks(t *testing.T) {
s := &State{
beaconDB: db,
}
gBlock := &ethpb.SignedBeaconBlock{}
gBlock := testutil.NewBeaconBlock()
gRoot, err := stateutil.BlockRoot(gBlock.Block)
require.NoError(t, err)
require.NoError(t, db.SaveBlock(ctx, gBlock))
require.NoError(t, db.SaveGenesisBlockRoot(ctx, [32]byte{}))
roots, _, err := tree1(db, gRoot[:])
require.NoError(t, err)

1
beacon-chain/state/stateutil/BUILD.bazel
View File

@@ -61,7 +61,6 @@ go_test(
"//shared/testutil/assert:go_default_library",
"//shared/testutil/require:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
"@com_github_prysmaticlabs_go_ssz//:go_default_library",
],
)

5
beacon-chain/state/stateutil/attestations_test.go
View File

@@ -5,7 +5,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
)
@@ -24,7 +23,7 @@ func TestAttestationDataRoot_EqualGeneric(t *testing.T) {
Epoch: 9,
},
}
genericHtr, err := ssz.HashTreeRoot(attData)
genericHtr, err := attData.HashTreeRoot()
require.NoError(t, err)
dataHtr, err := AttestationDataRoot(attData)
require.NoError(t, err)
@@ -50,7 +49,7 @@ func BenchmarkAttestationDataRoot(b *testing.B) {
}
b.Run("generic", func(b *testing.B) {
for i := 0; i < b.N; i++ {
_, err := ssz.HashTreeRoot(attData)
_, err := attData.HashTreeRoot()
require.NoError(b, err)
}
})

15
beacon-chain/state/stateutil/blocks_test.go
View File

@@ -4,7 +4,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
@@ -15,14 +14,14 @@ func TestBlockRoot(t *testing.T) {
genState, keys := testutil.DeterministicGenesisState(t, 100)
blk, err := testutil.GenerateFullBlock(genState, keys, testutil.DefaultBlockGenConfig(), 10)
require.NoError(t, err)
expectedRoot, err := ssz.HashTreeRoot(blk.Block)
expectedRoot, err := blk.Block.HashTreeRoot()
require.NoError(t, err)
receivedRoot, err := stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
require.Equal(t, expectedRoot, receivedRoot)
blk, err = testutil.GenerateFullBlock(genState, keys, testutil.DefaultBlockGenConfig(), 100)
require.NoError(t, err)
expectedRoot, err = ssz.HashTreeRoot(blk.Block)
expectedRoot, err = blk.Block.HashTreeRoot()
require.NoError(t, err)
receivedRoot, err = stateutil.BlockRoot(blk.Block)
require.NoError(t, err)
@@ -30,7 +29,15 @@ func TestBlockRoot(t *testing.T) {
}
func TestBlockBodyRoot_NilIsSameAsEmpty(t *testing.T) {
a, err := ssz.HashTreeRoot(&ethpb.BeaconBlockBody{})
a, err := (&ethpb.BeaconBlockBody{
RandaoReveal: make([]byte, 96),
Graffiti: make([]byte, 32),
Eth1Data: &ethpb.Eth1Data{
BlockHash: make([]byte, 32),
DepositCount: 0,
DepositRoot: make([]byte, 32),
},
}).HashTreeRoot()
require.NoError(t, err)
b, err := stateutil.BlockBodyRoot(nil)
require.NoError(t, err)

7
beacon-chain/state/stateutil/state_root_test.go
View File

@@ -7,7 +7,6 @@ import (
"testing"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/go-ssz"
pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/interop"
"github.com/prysmaticlabs/prysm/shared/params"
@@ -33,7 +32,7 @@ func BenchmarkHashTreeRoot_Generic_512(b *testing.B) {
genesisState := setupGenesisState(b, 512)
b.StartTimer()
for i := 0; i < b.N; i++ {
_, err := ssz.HashTreeRoot(genesisState)
_, err := genesisState.HashTreeRoot()
require.NoError(b, err)
}
}
@@ -43,7 +42,7 @@ func BenchmarkHashTreeRoot_Generic_16384(b *testing.B) {
genesisState := setupGenesisState(b, 16384)
b.StartTimer()
for i := 0; i < b.N; i++ {
_, err := ssz.HashTreeRoot(genesisState)
_, err := genesisState.HashTreeRoot()
require.NoError(b, err)
}
}
@@ -53,7 +52,7 @@ func BenchmarkHashTreeRoot_Generic_300000(b *testing.B) {
genesisState := setupGenesisState(b, 300000)
b.StartTimer()
for i := 0; i < b.N; i++ {
_, err := ssz.HashTreeRoot(genesisState)
_, err := genesisState.HashTreeRoot()
require.NoError(b, err)
}
}

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

@@ -112,7 +112,6 @@ go_test(
"//beacon-chain/p2p:go_default_library",
"//beacon-chain/p2p/peers:go_default_library",
"//beacon-chain/p2p/testing:go_default_library",
"//beacon-chain/state:go_default_library",
"//beacon-chain/state/stateutil:go_default_library",
"//beacon-chain/sync:go_default_library",
"//proto/beacon/p2p/v1:go_default_library",
@@ -122,6 +121,7 @@ go_test(
"//shared/params:go_default_library",
"//shared/roughtime:go_default_library",
"//shared/sliceutil:go_default_library",
"//shared/testutil:go_default_library",
"//shared/testutil/assert:go_default_library",
"//shared/testutil/require:go_default_library",
"@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",

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

@@ -21,11 +21,11 @@ import (
p2pm "github.com/prysmaticlabs/prysm/beacon-chain/p2p"
"github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers"
p2pt "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
p2ppb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/roughtime"
"github.com/prysmaticlabs/prysm/shared/sliceutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
"github.com/sirupsen/logrus"
@@ -256,11 +256,10 @@ func TestBlocksFetcher_RoundRobin(t *testing.T) {
genesisRoot := cache.rootCache[0]
cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), &eth.SignedBeaconBlock{Block: &eth.BeaconBlock{Slot: 0}})
err := beaconDB.SaveBlock(context.Background(), testutil.NewBeaconBlock())
require.NoError(t, err)
st, err := stateTrie.InitializeFromProto(&p2ppb.BeaconState{})
require.NoError(t, err)
st := testutil.NewBeaconState()
mc := &mock.ChainService{
State: st,

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

@@ -20,15 +20,16 @@ import (
"github.com/prysmaticlabs/prysm/beacon-chain/flags"
"github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers"
p2pt "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
stateTrie "github.com/prysmaticlabs/prysm/beacon-chain/state"
"github.com/prysmaticlabs/prysm/beacon-chain/state/stateutil"
beaconsync "github.com/prysmaticlabs/prysm/beacon-chain/sync"
p2ppb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/featureconfig"
"github.com/prysmaticlabs/prysm/shared/hashutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/roughtime"
"github.com/prysmaticlabs/prysm/shared/sliceutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
"github.com/prysmaticlabs/prysm/shared/testutil/assert"
"github.com/prysmaticlabs/prysm/shared/testutil/require"
"github.com/sirupsen/logrus"
@@ -82,11 +83,10 @@ func initializeTestServices(t *testing.T, blocks []uint64, peers []*peerData) (*
genesisRoot := cache.rootCache[0]
cache.RUnlock()
err := beaconDB.SaveBlock(context.Background(), &eth.SignedBeaconBlock{Block: &eth.BeaconBlock{Slot: 0}})
err := beaconDB.SaveBlock(context.Background(), testutil.NewBeaconBlock())
require.NoError(t, err)
st, err := stateTrie.InitializeFromProto(&p2ppb.BeaconState{})
require.NoError(t, err)
st := testutil.NewBeaconState()
return &mock.ChainService{
State: st,
@@ -202,12 +202,9 @@ func connectPeer(t *testing.T, host *p2pt.TestP2P, datum *peerData, peerStatus *
cache.RLock()
parentRoot := cache.rootCache[cache.parentSlotCache[slot]]
cache.RUnlock()
blk := &eth.SignedBeaconBlock{
Block: &eth.BeaconBlock{
Slot: slot,
ParentRoot: parentRoot[:],
},
}
blk := testutil.NewBeaconBlock()
blk.Block.Slot = slot
blk.Block.ParentRoot = parentRoot[:]
// If forked peer, give a different parent root.
if datum.forkedPeer {
newRoot := hashutil.Hash(parentRoot[:])
@@ -236,7 +233,7 @@ func connectPeer(t *testing.T, host *p2pt.TestP2P, datum *peerData, peerStatus *
ForkDigest: params.BeaconConfig().GenesisForkVersion,
FinalizedRoot: []byte(fmt.Sprintf("finalized_root %d", datum.finalizedEpoch)),
FinalizedEpoch: datum.finalizedEpoch,
HeadRoot: []byte("head_root"),
HeadRoot: bytesutil.PadTo([]byte("head_root"), 32),
HeadSlot: datum.headSlot,
})

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