From 4bed8d4ed40336b41420b09d139a84181d71755c Mon Sep 17 00:00:00 2001 From: terence tsao Date: Mon, 15 Feb 2021 14:50:50 -0800 Subject: [PATCH] Remove unused core functions (#8449) Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com> --- beacon-chain/core/blocks/attestation.go | 74 ------------------- beacon-chain/core/blocks/attestation_test.go | 66 ----------------- beacon-chain/core/blocks/exit.go | 33 --------- beacon-chain/core/blocks/exit_test.go | 77 -------------------- 4 files changed, 250 deletions(-) diff --git a/beacon-chain/core/blocks/attestation.go b/beacon-chain/core/blocks/attestation.go index 31641febd..ce92c7df4 100644 --- a/beacon-chain/core/blocks/attestation.go +++ b/beacon-chain/core/blocks/attestation.go @@ -201,60 +201,6 @@ func ProcessAttestationNoVerifySignature( return beaconState, nil } -// VerifyAttestationsSignatures will verify the signatures of the provided attestations. This method performs -// a single BLS verification call to verify the signatures of all of the provided attestations. All -// of the provided attestations must have valid signatures or this method will return an error. -// This method does not determine which attestation signature is invalid, only that one or more -// attestation signatures were not valid. -func VerifyAttestationsSignatures(ctx context.Context, beaconState *stateTrie.BeaconState, b *ethpb.SignedBeaconBlock) error { - ctx, span := trace.StartSpan(ctx, "core.VerifyAttestationsSignatures") - defer span.End() - atts := b.Block.Body.Attestations - span.AddAttributes(trace.Int64Attribute("attestations", int64(len(atts)))) - - if len(atts) == 0 { - return nil - } - - fork := beaconState.Fork() - gvr := beaconState.GenesisValidatorRoot() - dt := params.BeaconConfig().DomainBeaconAttester - - // Split attestations by fork. Note: the signature domain will differ based on the fork. - var preForkAtts []*ethpb.Attestation - var postForkAtts []*ethpb.Attestation - for _, a := range atts { - if helpers.SlotToEpoch(a.Data.Slot) < fork.Epoch { - preForkAtts = append(preForkAtts, a) - } else { - postForkAtts = append(postForkAtts, a) - } - } - - // Check attestations from before the fork. - if fork.Epoch > 0 { // Check to prevent underflow. - prevDomain, err := helpers.Domain(fork, fork.Epoch-1, dt, gvr) - if err != nil { - return err - } - if err := verifyAttestationsSigWithDomain(ctx, beaconState, preForkAtts, prevDomain); err != nil { - return err - } - } else if len(preForkAtts) > 0 { - // This is a sanity check that preForkAtts were not ignored when fork.Epoch == 0. This - // condition is not possible, but it doesn't hurt to check anyway. - return errors.New("some attestations were not verified from previous fork before genesis") - } - - // Then check attestations from after the fork. - currDomain, err := helpers.Domain(fork, fork.Epoch, dt, gvr) - if err != nil { - return err - } - - return verifyAttestationsSigWithDomain(ctx, beaconState, postForkAtts, currDomain) -} - // VerifyAttestationSignature converts and attestation into an indexed attestation and verifies // the signature in that attestation. func VerifyAttestationSignature(ctx context.Context, beaconState *stateTrie.BeaconState, att *ethpb.Attestation) error { @@ -311,23 +257,3 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState *stateTrie.Beacon } return attestationutil.VerifyIndexedAttestationSig(ctx, indexedAtt, pubkeys, domain) } - -// Inner method to verify attestations. This abstraction allows for the domain to be provided as an -// argument. -func verifyAttestationsSigWithDomain(ctx context.Context, beaconState *stateTrie.BeaconState, atts []*ethpb.Attestation, domain []byte) error { - if len(atts) == 0 { - return nil - } - set, err := createAttestationSignatureSet(ctx, beaconState, atts, domain) - if err != nil { - return err - } - verify, err := set.Verify() - if err != nil { - return errors.Errorf("got error in multiple verification: %v", err) - } - if !verify { - return errors.New("one or more attestation signatures did not verify") - } - return nil -} diff --git a/beacon-chain/core/blocks/attestation_test.go b/beacon-chain/core/blocks/attestation_test.go index 2f825dad1..fe7f8cee1 100644 --- a/beacon-chain/core/blocks/attestation_test.go +++ b/beacon-chain/core/blocks/attestation_test.go @@ -627,70 +627,8 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) { assert.ErrorContains(t, want, err) } -func TestVerifyAttestations_VerifiesMultipleAttestations(t *testing.T) { - ctx := context.Background() - numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch - validators := make([]*ethpb.Validator, numOfValidators) - _, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators) - require.NoError(t, err) - for i := 0; i < len(validators); i++ { - validators[i] = ðpb.Validator{ - ExitEpoch: params.BeaconConfig().FarFutureEpoch, - PublicKey: keys[i].PublicKey().Marshal(), - WithdrawalCredentials: make([]byte, 32), - } - } - - st, err := testutil.NewBeaconState() - require.NoError(t, err) - 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 := testutil.HydrateAttestation(ðpb.Attestation{ - AggregationBits: bitfield.NewBitlist(uint64(len(comm1))), - Data: ðpb.AttestationData{ - Slot: 1, - }, - }) - domain, err := helpers.Domain(st.Fork(), st.Fork().Epoch, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorRoot()) - require.NoError(t, err) - root, err := helpers.ComputeSigningRoot(att1.Data, domain) - require.NoError(t, err) - var sigs []bls.Signature - for i, u := range comm1 { - att1.AggregationBits.SetBitAt(uint64(i), true) - sigs = append(sigs, keys[u].Sign(root[:])) - } - att1.Signature = bls.AggregateSignatures(sigs).Marshal() - - comm2, err := helpers.BeaconCommitteeFromState(st, 1 /*slot*/, 1 /*committeeIndex*/) - require.NoError(t, err) - att2 := testutil.HydrateAttestation(ðpb.Attestation{ - AggregationBits: bitfield.NewBitlist(uint64(len(comm2))), - Data: ðpb.AttestationData{ - Slot: 1, - CommitteeIndex: 1, - }, - }) - root, err = helpers.ComputeSigningRoot(att2.Data, domain) - require.NoError(t, err) - sigs = nil - for i, u := range comm2 { - att2.AggregationBits.SetBitAt(uint64(i), true) - sigs = append(sigs, keys[u].Sign(root[:])) - } - att2.Signature = bls.AggregateSignatures(sigs).Marshal() - - b := testutil.NewBeaconBlock() - b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2} - require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b)) -} - func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) { // In this test, att1 is from the prior fork and att2 is from the new fork. - ctx := context.Background() numOfValidators := 4 * params.BeaconConfig().SlotsPerEpoch validators := make([]*ethpb.Validator, numOfValidators) _, keys, err := testutil.DeterministicDepositsAndKeys(numOfValidators) @@ -751,10 +689,6 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) { sigs = append(sigs, keys[u].Sign(root[:])) } att2.Signature = bls.AggregateSignatures(sigs).Marshal() - - b := testutil.NewBeaconBlock() - b.Block.Body.Attestations = []*ethpb.Attestation{att1, att2} - require.NoError(t, blocks.VerifyAttestationsSignatures(ctx, st, b)) } func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing.T) { diff --git a/beacon-chain/core/blocks/exit.go b/beacon-chain/core/blocks/exit.go index f5f6f3904..9a8525a4c 100644 --- a/beacon-chain/core/blocks/exit.go +++ b/beacon-chain/core/blocks/exit.go @@ -73,39 +73,6 @@ func ProcessVoluntaryExits( return beaconState, nil } -// ProcessVoluntaryExitsNoVerifySignature processes all the voluntary exits in -// a block body, without verifying their BLS signatures. -// This function is here to satisfy fuzz tests. -func ProcessVoluntaryExitsNoVerifySignature( - beaconState *stateTrie.BeaconState, - body *ethpb.BeaconBlockBody, -) (*stateTrie.BeaconState, error) { - exits := body.VoluntaryExits - - for idx, exit := range exits { - if exit == nil || exit.Exit == nil { - return nil, errors.New("nil exit") - } - val, err := beaconState.ValidatorAtIndexReadOnly(exit.Exit.ValidatorIndex) - if err != nil { - return nil, err - } - if err := verifyExitConditions(val, beaconState.Slot(), exit.Exit); err != nil { - return nil, err - } - // Validate that fork and genesis root are valid. - _, err = helpers.Domain(beaconState.Fork(), exit.Exit.Epoch, params.BeaconConfig().DomainVoluntaryExit, beaconState.GenesisValidatorRoot()) - if err != nil { - return nil, err - } - beaconState, err = v.InitiateValidatorExit(beaconState, exit.Exit.ValidatorIndex) - if err != nil { - return nil, errors.Wrapf(err, "failed to process voluntary exit at index %d", idx) - } - } - return beaconState, nil -} - // VerifyExitAndSignature implements the spec defined validation for voluntary exits. // // Spec pseudocode definition: diff --git a/beacon-chain/core/blocks/exit_test.go b/beacon-chain/core/blocks/exit_test.go index d4c622ee0..676019528 100644 --- a/beacon-chain/core/blocks/exit_test.go +++ b/beacon-chain/core/blocks/exit_test.go @@ -17,73 +17,6 @@ import ( "github.com/prysmaticlabs/prysm/shared/testutil/require" ) -func TestProcessVoluntaryExits_ValidatorNotActive(t *testing.T) { - exits := []*ethpb.SignedVoluntaryExit{ - { - Exit: ðpb.VoluntaryExit{ - ValidatorIndex: 0, - }, - }, - } - registry := []*ethpb.Validator{ - { - ExitEpoch: 0, - }, - } - state, err := stateTrie.InitializeFromProto(&pb.BeaconState{ - Validators: registry, - }) - require.NoError(t, err) - b := testutil.NewBeaconBlock() - b.Block = ðpb.BeaconBlock{ - Body: ðpb.BeaconBlockBody{ - VoluntaryExits: exits, - }, - } - - want := "non-active validator cannot exit" - _, err = blocks.ProcessVoluntaryExits(context.Background(), state, b) - assert.ErrorContains(t, want, err) - - // Check conformance of no verify method. - _, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body) - assert.ErrorContains(t, want, err) -} - -func TestProcessVoluntaryExits_InvalidExitEpoch(t *testing.T) { - exits := []*ethpb.SignedVoluntaryExit{ - { - Exit: ðpb.VoluntaryExit{ - Epoch: 10, - }, - }, - } - registry := []*ethpb.Validator{ - { - ExitEpoch: params.BeaconConfig().FarFutureEpoch, - }, - } - state, err := stateTrie.InitializeFromProto(&pb.BeaconState{ - Validators: registry, - Slot: 0, - }) - require.NoError(t, err) - b := testutil.NewBeaconBlock() - b.Block = ðpb.BeaconBlock{ - Body: ðpb.BeaconBlockBody{ - VoluntaryExits: exits, - }, - } - - want := "expected current epoch >= exit epoch" - _, err = blocks.ProcessVoluntaryExits(context.Background(), state, b) - assert.ErrorContains(t, want, err) - - // Check conformance of no verify method. - _, err = blocks.ProcessVoluntaryExitsNoVerifySignature(state, b.Block.Body) - assert.ErrorContains(t, want, err) -} - func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) { exits := []*ethpb.SignedVoluntaryExit{ { @@ -189,7 +122,6 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) { }, } - stateCopy := state.Copy() newState, err := blocks.ProcessVoluntaryExits(context.Background(), state, b) require.NoError(t, err, "Could not process exits") newRegistry := newState.Validators() @@ -197,13 +129,4 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) { t.Errorf("Expected validator exit epoch to be %d, got %d", helpers.ActivationExitEpoch(types.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)), newRegistry[0].ExitEpoch) } - - // Check conformance with NoVerify Exit Method. - newState, err = blocks.ProcessVoluntaryExitsNoVerifySignature(stateCopy, b.Block.Body) - require.NoError(t, err, "Could not process exits") - newRegistry = newState.Validators() - if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(types.Epoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch)) { - t.Errorf("Expected validator exit epoch to be %d, got %d", - helpers.ActivationExitEpoch(types.Epoch(stateCopy.Slot()/params.BeaconConfig().SlotsPerEpoch)), newRegistry[0].ExitEpoch) - } }