Rename To Signature Batch (#9926)

Co-authored-by: Radosław Kapka <rkapka@wp.pl>

beacon-chain/blockchain/process_block.go

@@ -260,12 +260,12 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []block.SignedBeaconBlo
 
 	jCheckpoints := make([]*ethpb.Checkpoint, len(blks))
 	fCheckpoints := make([]*ethpb.Checkpoint, len(blks))
-	sigSet := &bls.SignatureSet{
+	sigSet := &bls.SignatureBatch{
 		Signatures: [][]byte{},
 		PublicKeys: []bls.PublicKey{},
 		Messages:   [][32]byte{},
 	}
-	var set *bls.SignatureSet
+	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
 		set, preState, err = transition.ExecuteStateTransitionNoVerifyAnySig(ctx, preState, b)

beacon-chain/core/blocks/attestation_test.go

@@ -358,7 +358,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want := "nil or missing indexed attestation data"
-	_, err := blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
+	_, err := blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 
 	atts = []*ethpb.Attestation{}
@@ -378,7 +378,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	}
 
 	want = "expected non-empty attesting indices"
-	_, err = blocks.AttestationSignatureSet(context.Background(), beaconState, atts)
+	_, err = blocks.AttestationSignatureBatch(context.Background(), beaconState, atts)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -502,7 +502,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	set, err := blocks.AttestationSignatureSet(ctx, st, []*ethpb.Attestation{att1, att2})
+	set, err := blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)
@@ -566,6 +566,6 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 	}
 	att2.Signature = bls.AggregateSignatures(sigs).Marshal()
 
-	_, err = blocks.AttestationSignatureSet(ctx, st, []*ethpb.Attestation{att1, att2})
+	_, err = blocks.AttestationSignatureBatch(ctx, st, []*ethpb.Attestation{att1, att2})
 	require.NoError(t, err)
 }

beacon-chain/core/blocks/header_test.go

@@ -321,7 +321,7 @@ func TestBlockSignatureSet_OK(t *testing.T) {
 	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
 	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
 	require.NoError(t, err)
-	set, err := blocks.BlockSignatureSet(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
+	set, err := blocks.BlockSignatureBatch(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
 	require.NoError(t, err)
 
 	verified, err := set.Verify()

beacon-chain/core/blocks/randao_test.go

@@ -82,7 +82,7 @@ func TestRandaoSignatureSet_OK(t *testing.T) {
 		},
 	}
 
-	set, err := blocks.RandaoSignatureSet(context.Background(), beaconState, block.Body.RandaoReveal)
+	set, err := blocks.RandaoSignatureBatch(context.Background(), beaconState, block.Body.RandaoReveal)
 	require.NoError(t, err)
 	verified, err := set.Verify()
 	require.NoError(t, err)

beacon-chain/core/blocks/signature.go

@@ -18,8 +18,8 @@ import (
 	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
-// retrieves the signature set from the raw data, public key,signature and domain provided.
-func signatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet, error) {
+// retrieves the signature batch from the raw data, public key,signature and domain provided.
+func signatureBatch(signedData, pub, signature, domain []byte) (*bls.SignatureBatch, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
@@ -32,7 +32,7 @@ func signatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet,
 	if err != nil {
 		return nil, errors.Wrap(err, "could not hash container")
 	}
-	return &bls.SignatureSet{
+	return &bls.SignatureBatch{
 		Signatures: [][]byte{signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},
@@ -41,7 +41,7 @@ func signatureSet(signedData, pub, signature, domain []byte) (*bls.SignatureSet,
 
 // verifies the signature from the raw data, public key and domain provided.
 func verifySignature(signedData, pub, signature, domain []byte) error {
-	set, err := signatureSet(signedData, pub, signature, domain)
+	set, err := signatureBatch(signedData, pub, signature, domain)
 	if err != nil {
 		return err
 	}
@@ -116,11 +116,11 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	return signing.VerifyBlockSigningRoot(proposerPubKey, blk.Signature(), domain, blk.Block().HashTreeRoot)
 }
 
-// BlockSignatureSet retrieves the block signature set from the provided block and its corresponding state.
-func BlockSignatureSet(beaconState state.ReadOnlyBeaconState,
+// BlockSignatureBatch retrieves the block signature batch from the provided block and its corresponding state.
+func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
 	proposerIndex types.ValidatorIndex,
 	sig []byte,
-	rootFunc func() ([32]byte, error)) (*bls.SignatureSet, error) {
+	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
 	currentEpoch := slots.ToEpoch(beaconState.Slot())
 	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorRoot())
 	if err != nil {
@@ -131,21 +131,21 @@ func BlockSignatureSet(beaconState state.ReadOnlyBeaconState,
 		return nil, err
 	}
 	proposerPubKey := proposer.PublicKey
-	return signing.BlockSignatureSet(proposerPubKey, sig, domain, rootFunc)
+	return signing.BlockSignatureBatch(proposerPubKey, sig, domain, rootFunc)
 }
 
-// RandaoSignatureSet retrieves the relevant randao specific signature set object
+// RandaoSignatureBatch retrieves the relevant randao specific signature batch object
 // from a block and its corresponding state.
-func RandaoSignatureSet(
+func RandaoSignatureBatch(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
 	reveal []byte,
-) (*bls.SignatureSet, error) {
+) (*bls.SignatureBatch, error) {
 	buf, proposerPub, domain, err := randaoSigningData(ctx, beaconState)
 	if err != nil {
 		return nil, err
 	}
-	set, err := signatureSet(buf, proposerPub, reveal, domain)
+	set, err := signatureBatch(buf, proposerPub, reveal, domain)
 	if err != nil {
 		return nil, err
 	}
@@ -171,13 +171,13 @@ func randaoSigningData(ctx context.Context, beaconState state.ReadOnlyBeaconStat
 	return buf, proposerPub[:], domain, nil
 }
 
-// Method to break down attestations of the same domain and collect them into a single signature set.
-func createAttestationSignatureSet(
+// Method to break down attestations of the same domain and collect them into a single signature batch.
+func createAttestationSignatureBatch(
 	ctx context.Context,
 	beaconState state.ReadOnlyBeaconState,
 	atts []*ethpb.Attestation,
 	domain []byte,
-) (*bls.SignatureSet, error) {
+) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
 		return nil, nil
 	}
@@ -216,16 +216,16 @@ func createAttestationSignatureSet(
 		}
 		msgs[i] = root
 	}
-	return &bls.SignatureSet{
+	return &bls.SignatureBatch{
 		Signatures: sigs,
 		PublicKeys: pks,
 		Messages:   msgs,
 	}, nil
 }
 
-// AttestationSignatureSet retrieves all the related attestation signature data such as the relevant public keys,
-// signatures and attestation signing data and collate it into a signature set object.
-func AttestationSignatureSet(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []*ethpb.Attestation) (*bls.SignatureSet, error) {
+// AttestationSignatureBatch retrieves all the related attestation signature data such as the relevant public keys,
+// signatures and attestation signing data and collate it into a signature batch object.
+func AttestationSignatureBatch(ctx context.Context, beaconState state.ReadOnlyBeaconState, atts []*ethpb.Attestation) (*bls.SignatureBatch, error) {
 	if len(atts) == 0 {
 		return bls.NewSet(), nil
 	}
@@ -247,12 +247,12 @@ func AttestationSignatureSet(ctx context.Context, beaconState state.ReadOnlyBeac
 	set := bls.NewSet()
 
 	// Check attestations from before the fork.
-	if fork.Epoch > 0 && len(preForkAtts) > 0 { // Check to prevent underflow and there is valid attestations to create sig set.
+	if fork.Epoch > 0 && len(preForkAtts) > 0 { // Check to prevent underflow and there is valid attestations to create sig batch.
 		prevDomain, err := signing.Domain(fork, fork.Epoch-1, dt, gvr)
 		if err != nil {
 			return nil, err
 		}
-		aSet, err := createAttestationSignatureSet(ctx, beaconState, preForkAtts, prevDomain)
+		aSet, err := createAttestationSignatureBatch(ctx, beaconState, preForkAtts, prevDomain)
 		if err != nil {
 			return nil, err
 		}
@@ -272,7 +272,7 @@ func AttestationSignatureSet(ctx context.Context, beaconState state.ReadOnlyBeac
 			return nil, err
 		}
 
-		aSet, err := createAttestationSignatureSet(ctx, beaconState, postForkAtts, currDomain)
+		aSet, err := createAttestationSignatureBatch(ctx, beaconState, postForkAtts, currDomain)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/signing/signing_root.go

@@ -118,11 +118,11 @@ func VerifyBlockHeaderSigningRoot(blkHdr *ethpb.BeaconBlockHeader, pub, signatur
 
 // VerifyBlockSigningRoot verifies the signing root of a block given its public key, signature and domain.
 func VerifyBlockSigningRoot(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) error {
-	set, err := BlockSignatureSet(pub, signature, domain, rootFunc)
+	set, err := BlockSignatureBatch(pub, signature, domain, rootFunc)
 	if err != nil {
 		return err
 	}
-	// We assume only one signature set is returned here.
+	// We assume only one signature batch is returned here.
 	sig := set.Signatures[0]
 	publicKey := set.PublicKeys[0]
 	root := set.Messages[0]
@@ -137,9 +137,9 @@ func VerifyBlockSigningRoot(pub, signature, domain []byte, rootFunc func() ([32]
 	return nil
 }
 
-// BlockSignatureSet retrieves the relevant signature, message and pubkey data from a block and collating it
-// into a signature set object.
-func BlockSignatureSet(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) (*bls.SignatureSet, error) {
+// BlockSignatureBatch retrieves the relevant signature, message and pubkey data from a block and collating it
+// into a signature batch object.
+func BlockSignatureBatch(pub, signature, domain []byte, rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
 	publicKey, err := bls.PublicKeyFromBytes(pub)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert bytes to public key")
@@ -149,7 +149,7 @@ func BlockSignatureSet(pub, signature, domain []byte, rootFunc func() ([32]byte,
 	if err != nil {
 		return nil, errors.Wrap(err, "could not compute signing root")
 	}
-	return &bls.SignatureSet{
+	return &bls.SignatureBatch{
 		Signatures: [][]byte{signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -45,7 +45,7 @@ func ExecuteStateTransitionNoVerifyAnySig(
 	ctx context.Context,
 	state state.BeaconState,
 	signed block.SignedBeaconBlock,
-) (*bls.SignatureSet, state.BeaconState, error) {
+) (*bls.SignatureBatch, state.BeaconState, error) {
 	if ctx.Err() != nil {
 		return nil, nil, ctx.Err()
 	}
@@ -182,7 +182,7 @@ func ProcessBlockNoVerifyAnySig(
 	ctx context.Context,
 	state state.BeaconState,
 	signed block.SignedBeaconBlock,
-) (*bls.SignatureSet, state.BeaconState, error) {
+) (*bls.SignatureBatch, state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessBlockNoVerifyAnySig")
 	defer span.End()
 	if err := helpers.BeaconBlockIsNil(signed); err != nil {
@@ -209,17 +209,17 @@ func ProcessBlockNoVerifyAnySig(
 		}
 	}
 
-	bSet, err := b.BlockSignatureSet(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot)
+	bSet, err := b.BlockSignatureBatch(state, blk.ProposerIndex(), signed.Signature(), blk.HashTreeRoot)
 	if err != nil {
 		tracing.AnnotateError(span, err)
 		return nil, nil, errors.Wrap(err, "could not retrieve block signature set")
 	}
-	rSet, err := b.RandaoSignatureSet(ctx, state, signed.Block().Body().RandaoReveal())
+	rSet, err := b.RandaoSignatureBatch(ctx, state, signed.Block().Body().RandaoReveal())
 	if err != nil {
 		tracing.AnnotateError(span, err)
 		return nil, nil, errors.Wrap(err, "could not retrieve randao signature set")
 	}
-	aSet, err := b.AttestationSignatureSet(ctx, state, signed.Block().Body().Attestations())
+	aSet, err := b.AttestationSignatureBatch(ctx, state, signed.Block().Body().Attestations())
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not retrieve attestation signature set")
 	}

beacon-chain/sync/batch_verifier.go

@@ -16,7 +16,7 @@ const signatureVerificationInterval = 50 * time.Millisecond
 const verifierLimit = 50
 
 type signatureVerifier struct {
-	set     *bls.SignatureSet
+	set     *bls.SignatureBatch
 	resChan chan error
 }
 
@@ -49,7 +49,7 @@ func (s *Service) verifierRoutine() {
 	}
 }
 
-func (s *Service) validateWithBatchVerifier(ctx context.Context, message string, set *bls.SignatureSet) (pubsub.ValidationResult, error) {
+func (s *Service) validateWithBatchVerifier(ctx context.Context, message string, set *bls.SignatureBatch) (pubsub.ValidationResult, error) {
 	ctx, span := trace.StartSpan(ctx, "sync.validateWithBatchVerifier")
 	defer span.End()
 

beacon-chain/sync/batch_verifier_test.go

@@ -15,12 +15,12 @@ func TestValidateWithBatchVerifier(t *testing.T) {
 	assert.NoError(t, err)
 	sig := keys[0].Sign(make([]byte, 32))
 	badSig := keys[1].Sign(make([]byte, 32))
-	validSet := &bls.SignatureSet{
+	validSet := &bls.SignatureBatch{
 		Messages:   [][32]byte{{}},
 		PublicKeys: []bls.PublicKey{keys[0].PublicKey()},
 		Signatures: [][]byte{sig.Marshal()},
 	}
-	invalidSet := &bls.SignatureSet{
+	invalidSet := &bls.SignatureBatch{
 		Messages:   [][32]byte{{}},
 		PublicKeys: []bls.PublicKey{keys[0].PublicKey()},
 		Signatures: [][]byte{badSig.Marshal()},
@@ -28,8 +28,8 @@ func TestValidateWithBatchVerifier(t *testing.T) {
 	tests := []struct {
 		name          string
 		message       string
-		set           *bls.SignatureSet
-		preFilledSets []*bls.SignatureSet
+		set           *bls.SignatureBatch
+		preFilledSets []*bls.SignatureBatch
 		want          pubsub.ValidationResult
 	}{
 		{
@@ -48,14 +48,14 @@ func TestValidateWithBatchVerifier(t *testing.T) {
 			name:          "invalid set in routine with valid set",
 			message:       "random",
 			set:           validSet,
-			preFilledSets: []*bls.SignatureSet{invalidSet},
+			preFilledSets: []*bls.SignatureBatch{invalidSet},
 			want:          pubsub.ValidationAccept,
 		},
 		{
 			name:          "valid set in routine with invalid set",
 			message:       "random",
 			set:           invalidSet,
-			preFilledSets: []*bls.SignatureSet{validSet},
+			preFilledSets: []*bls.SignatureBatch{validSet},
 			want:          pubsub.ValidationReject,
 		},
 	}

beacon-chain/sync/validate_aggregate_proof.go

@@ -171,7 +171,7 @@ func (s *Service) validateAggregatedAtt(ctx context.Context, signed *ethpb.Signe
 		tracing.AnnotateError(span, wrappedErr)
 		return pubsub.ValidationIgnore, wrappedErr
 	}
-	attSigSet, err := blocks.AttestationSignatureSet(ctx, bs, []*ethpb.Attestation{signed.Message.Aggregate})
+	attSigSet, err := blocks.AttestationSignatureBatch(ctx, bs, []*ethpb.Attestation{signed.Message.Aggregate})
 	if err != nil {
 		wrappedErr := errors.Wrapf(err, "Could not verify aggregator signature %d", signed.Message.AggregatorIndex)
 		tracing.AnnotateError(span, wrappedErr)
@@ -256,7 +256,7 @@ func validateSelectionIndex(
 	data *ethpb.AttestationData,
 	validatorIndex types.ValidatorIndex,
 	proof []byte,
-) (*bls.SignatureSet, error) {
+) (*bls.SignatureBatch, error) {
 	_, span := trace.StartSpan(ctx, "sync.validateSelectionIndex")
 	defer span.End()
 
@@ -293,7 +293,7 @@ func validateSelectionIndex(
 	if err != nil {
 		return nil, err
 	}
-	return &bls.SignatureSet{
+	return &bls.SignatureBatch{
 		Signatures: [][]byte{proof},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},
@@ -301,7 +301,7 @@ func validateSelectionIndex(
 }
 
 // This returns aggregator signature set which can be used to batch verify.
-func aggSigSet(s state.ReadOnlyBeaconState, a *ethpb.SignedAggregateAttestationAndProof) (*bls.SignatureSet, error) {
+func aggSigSet(s state.ReadOnlyBeaconState, a *ethpb.SignedAggregateAttestationAndProof) (*bls.SignatureBatch, error) {
 	v, err := s.ValidatorAtIndex(a.Message.AggregatorIndex)
 	if err != nil {
 		return nil, err
@@ -320,7 +320,7 @@ func aggSigSet(s state.ReadOnlyBeaconState, a *ethpb.SignedAggregateAttestationA
 	if err != nil {
 		return nil, err
 	}
-	return &bls.SignatureSet{
+	return &bls.SignatureBatch{
 		Signatures: [][]byte{a.Signature},
 		PublicKeys: []bls.PublicKey{publicKey},
 		Messages:   [][32]byte{root},

beacon-chain/sync/validate_beacon_attestation.go

@@ -219,7 +219,7 @@ func (s *Service) validateUnaggregatedAttWithState(ctx context.Context, a *eth.A
 	}
 
 	if features.Get().EnableBatchVerification {
-		set, err := blocks.AttestationSignatureSet(ctx, bs, []*eth.Attestation{a})
+		set, err := blocks.AttestationSignatureBatch(ctx, bs, []*eth.Attestation{a})
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return pubsub.ValidationReject, err

beacon-chain/sync/validate_sync_committee_message.go

@@ -243,7 +243,7 @@ func (s *Service) rejectInvalidSyncCommitteeSignature(m *ethpb.SyncCommitteeMess
 		// the signature to a G2 point if batch verification is
 		// enabled.
 		if features.Get().EnableBatchVerification {
-			set := &bls.SignatureSet{
+			set := &bls.SignatureBatch{
 				Messages:   [][32]byte{sigRoot},
 				PublicKeys: []bls.PublicKey{pKey},
 				Signatures: [][]byte{m.Signature},

beacon-chain/sync/validate_sync_contribution_proof.go

@@ -224,7 +224,7 @@ func (s *Service) rejectInvalidContributionSignature(m *ethpb.SignedContribution
 				tracing.AnnotateError(span, err)
 				return pubsub.ValidationReject, err
 			}
-			set := &bls.SignatureSet{
+			set := &bls.SignatureBatch{
 				Messages:   [][32]byte{root},
 				PublicKeys: []bls.PublicKey{publicKey},
 				Signatures: [][]byte{m.Signature},
@@ -288,7 +288,7 @@ func (s *Service) rejectInvalidSyncAggregateSignature(m *ethpb.SignedContributio
 				tracing.AnnotateError(span, err)
 				return pubsub.ValidationIgnore, err
 			}
-			set := &bls.SignatureSet{
+			set := &bls.SignatureBatch{
 				Messages:   [][32]byte{sigRoot},
 				PublicKeys: []bls.PublicKey{aggKey},
 				Signatures: [][]byte{m.Message.Contribution.Signature},
@@ -349,7 +349,7 @@ func (s *Service) verifySyncSelectionData(ctx context.Context, m *ethpb.Contribu
 		if err != nil {
 			return err
 		}
-		set := &bls.SignatureSet{
+		set := &bls.SignatureBatch{
 			Messages:   [][32]byte{root},
 			PublicKeys: []bls.PublicKey{publicKey},
 			Signatures: [][]byte{m.SelectionProof},

crypto/bls/BUILD.bazel

@@ -7,7 +7,7 @@ go_library(
         "constants.go",
         "error.go",
         "interface.go",
-        "signature_set.go",
+        "signature_batch.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/crypto/bls",
     visibility = ["//visibility:public"],
@@ -22,7 +22,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "bls_test.go",
-        "signature_set_test.go",
+        "signature_batch_test.go",
     ],
     embed = [":go_default_library"],
     deps = [

crypto/bls/signature_batch.go

@@ -1,39 +1,39 @@
 package bls
 
-// SignatureSet refers to the defined set of
+// SignatureBatch refers to the defined set of
 // signatures and its respective public keys and
 // messages required to verify it.
-type SignatureSet struct {
+type SignatureBatch struct {
 	Signatures [][]byte
 	PublicKeys []PublicKey
 	Messages   [][32]byte
 }
 
-// NewSet constructs an empty signature set object.
-func NewSet() *SignatureSet {
-	return &SignatureSet{
+// NewSet constructs an empty signature batch object.
+func NewSet() *SignatureBatch {
+	return &SignatureBatch{
 		Signatures: [][]byte{},
 		PublicKeys: []PublicKey{},
 		Messages:   [][32]byte{},
 	}
 }
 
-// Join merges the provided signature set to out current one.
-func (s *SignatureSet) Join(set *SignatureSet) *SignatureSet {
+// Join merges the provided signature batch to out current one.
+func (s *SignatureBatch) Join(set *SignatureBatch) *SignatureBatch {
 	s.Signatures = append(s.Signatures, set.Signatures...)
 	s.PublicKeys = append(s.PublicKeys, set.PublicKeys...)
 	s.Messages = append(s.Messages, set.Messages...)
 	return s
 }
 
-// Verify the current signature set using the batch verify algorithm.
-func (s *SignatureSet) Verify() (bool, error) {
+// Verify the current signature batch using the batch verify algorithm.
+func (s *SignatureBatch) Verify() (bool, error) {
 	return VerifyMultipleSignatures(s.Signatures, s.Messages, s.PublicKeys)
 }
 
-// Copy the attached signature set and return it
+// Copy the attached signature batch and return it
 // to the caller.
-func (s *SignatureSet) Copy() *SignatureSet {
+func (s *SignatureBatch) Copy() *SignatureBatch {
 	signatures := make([][]byte, len(s.Signatures))
 	pubkeys := make([]PublicKey, len(s.PublicKeys))
 	messages := make([][32]byte, len(s.Messages))
@@ -48,7 +48,7 @@ func (s *SignatureSet) Copy() *SignatureSet {
 	for i := range s.Messages {
 		copy(messages[i][:], s.Messages[i][:])
 	}
-	return &SignatureSet{
+	return &SignatureBatch{
 		Signatures: signatures,
 		PublicKeys: pubkeys,
 		Messages:   messages,

crypto/bls/signature_batch_test.go

@@ -23,17 +23,17 @@ func TestCopySignatureSet(t *testing.T) {
 		sig2 := key2.Sign(message2[:])
 		sig3 := key3.Sign(message3[:])
 
-		set := &SignatureSet{
+		set := &SignatureBatch{
 			Signatures: [][]byte{sig.Marshal()},
 			PublicKeys: []PublicKey{key.PublicKey()},
 			Messages:   [][32]byte{message},
 		}
-		set2 := &SignatureSet{
+		set2 := &SignatureBatch{
 			Signatures: [][]byte{sig2.Marshal()},
 			PublicKeys: []PublicKey{key.PublicKey()},
 			Messages:   [][32]byte{message},
 		}
-		set3 := &SignatureSet{
+		set3 := &SignatureBatch{
 			Signatures: [][]byte{sig3.Marshal()},
 			PublicKeys: []PublicKey{key.PublicKey()},
 			Messages:   [][32]byte{message},

testing/spectest/shared/altair/operations/attestation.go

@@ -36,7 +36,7 @@ func RunAttestationTest(t *testing.T, config string) {
 				if err != nil {
 					return nil, err
 				}
-				aSet, err := b.AttestationSignatureSet(ctx, st, blk.Block().Body().Attestations())
+				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
 				if err != nil {
 					return nil, err
 				}

testing/spectest/shared/phase0/operations/attestation.go

@@ -36,7 +36,7 @@ func RunAttestationTest(t *testing.T, config string) {
 				if err != nil {
 					return nil, err
 				}
-				aSet, err := b.AttestationSignatureSet(ctx, st, blk.Block().Body().Attestations())
+				aSet, err := b.AttestationSignatureBatch(ctx, st, blk.Block().Body().Attestations())
 				if err != nil {
 					return nil, err
 				}