AggregateAttestationSubmitter->AggregateAttestationsSubmitter to match spec

main.go

@@ -300,7 +300,7 @@ func startServices(ctx context.Context, majordomo majordomo.Service) error {
 		standardattestationaggregator.WithLogLevel(logLevel(viper.GetString("attestationaggregator.log-level"))),
 		standardattestationaggregator.WithTargetAggregatorsPerCommitteeProvider(eth2Client.(eth2client.TargetAggregatorsPerCommitteeProvider)),
 		standardattestationaggregator.WithAggregateAttestationDataProvider(eth2Client.(eth2client.NonSpecAggregateAttestationProvider)),
-		standardattestationaggregator.WithAggregateAttestationSubmitter(submitterStrategy.(submitter.AggregateAttestationSubmitter)),
+		standardattestationaggregator.WithAggregateAttestationsSubmitter(submitterStrategy.(submitter.AggregateAttestationsSubmitter)),
 		standardattestationaggregator.WithMonitor(monitor.(metrics.AttestationAggregationMonitor)),
 		standardattestationaggregator.WithValidatingAccountsProvider(accountManager.(accountmanager.ValidatingAccountsProvider)),
 	)
@@ -623,6 +623,7 @@ func selectSubmitterStrategy(ctx context.Context, eth2Client eth2client.Service)
 			beaconBlockSubmitters[address] = client.(eth2client.BeaconBlockSubmitter)
 			attestationSubmitters[address] = client.(eth2client.AttestationSubmitter)
 			aggregateAttestationSubmitters[address] = client.(eth2client.AggregateAttestationsSubmitter)
+			beaconCommitteeSubscriptionsSubmitters[address] = client.(eth2client.BeaconCommitteeSubscriptionsSubmitter)
 		}
 		submitter, err = multinodesubmitter.New(ctx,
 			multinodesubmitter.WithProcessConcurrency(viper.GetInt64("process-concurrency")),

mock/eth2client.go

@@ -15,6 +15,7 @@ package mock
 
 import (
 	"context"
+	"errors"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
@@ -85,6 +86,19 @@ func (m *AttestationSubmitter) SubmitAttestation(ctx context.Context, attestatio
 	return nil
 }
 
+// ErroringAttestationSubmitter is a mock for eth2client.AttestationSubmitter that returns errors.
+type ErroringAttestationSubmitter struct{}
+
+// NewErroringAttestationSubmitter returns a mock attestation submitter.
+func NewErroringAttestationSubmitter() eth2client.AttestationSubmitter {
+	return &ErroringAttestationSubmitter{}
+}
+
+// SubmitErroringAttestation is a mock.
+func (m *ErroringAttestationSubmitter) SubmitAttestation(ctx context.Context, attestation *spec.Attestation) error {
+	return errors.New("error")
+}
+
 // BeaconBlockSubmitter is a mock for eth2client.BeaconBlockSubmitter.
 type BeaconBlockSubmitter struct{}
 
@@ -98,6 +112,19 @@ func (m *BeaconBlockSubmitter) SubmitBeaconBlock(ctx context.Context, bloc *spec
 	return nil
 }
 
+// ErroringBeaconBlockSubmitter is a mock for eth2client.BeaconBlockSubmitter that returns errors.
+type ErroringBeaconBlockSubmitter struct{}
+
+// NewErroringBeaconBlockSubmitter returns a mock beacon block submitter.
+func NewErroringBeaconBlockSubmitter() eth2client.BeaconBlockSubmitter {
+	return &ErroringBeaconBlockSubmitter{}
+}
+
+// SubmitBeaconBlock is a mock.
+func (m *ErroringBeaconBlockSubmitter) SubmitBeaconBlock(ctx context.Context, bloc *spec.SignedBeaconBlock) error {
+	return errors.New("error")
+}
+
 // AggregateAttestationsSubmitter is a mock for eth2client.AggregateAttestationsSubmitter.
 type AggregateAttestationsSubmitter struct{}
 
@@ -111,6 +138,19 @@ func (m *AggregateAttestationsSubmitter) SubmitAggregateAttestations(ctx context
 	return nil
 }
 
+// ErroringAggregateAttestationsSubmitter is a mock for eth2client.AggregateAttestationsSubmitter that returns errors.
+type ErroringAggregateAttestationsSubmitter struct{}
+
+// NewErroringAggregateAttestationsSubmitter returns a mock aggregate attestation submitter.
+func NewErroringAggregateAttestationsSubmitter() eth2client.AggregateAttestationsSubmitter {
+	return &ErroringAggregateAttestationsSubmitter{}
+}
+
+// SubmitAggregateAttestations is a mock.
+func (m *ErroringAggregateAttestationsSubmitter) SubmitAggregateAttestations(ctx context.Context, aggregateAndProofs []*spec.SignedAggregateAndProof) error {
+	return errors.New("error")
+}
+
 // BeaconCommitteeSubscriptionsSubmitter is a mock for eth2client.BeaconCommitteeSubscriptionsSubmitter.
 type BeaconCommitteeSubscriptionsSubmitter struct{}
 
@@ -123,3 +163,29 @@ func NewBeaconCommitteeSubscriptionsSubmitter() eth2client.BeaconCommitteeSubscr
 func (m *BeaconCommitteeSubscriptionsSubmitter) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*eth2client.BeaconCommitteeSubscription) error {
 	return nil
 }
+
+// ErroringBeaconCommitteeSubscriptionsSubmitter is a mock for eth2client.BeaconCommitteeSubscriptionsSubmitter that returns errors.
+type ErroringBeaconCommitteeSubscriptionsSubmitter struct{}
+
+// NewErroringBeaconCommitteeSubscriptionsSubmitter returns a mock beacon committee subscriptions submitter.
+func NewErroringBeaconCommitteeSubscriptionsSubmitter() eth2client.BeaconCommitteeSubscriptionsSubmitter {
+	return &ErroringBeaconCommitteeSubscriptionsSubmitter{}
+}
+
+// SubmitBeaconCommitteeSubscriptions is a mock.
+func (m *ErroringBeaconCommitteeSubscriptionsSubmitter) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*eth2client.BeaconCommitteeSubscription) error {
+	return errors.New("error")
+}
+
+// BeaconBlockProposalProvider is a mock for eth2client.BeaconBlockProposalProvider.
+type BeaconBlockProposalProvider struct{}
+
+// NewBeaconBlockProposalProvider returns a mock beacon block proposal provider.
+func NewBeaconBlockProposalProvider() eth2client.BeaconBlockProposalProvider {
+	return &BeaconBlockProposalProvider{}
+}
+
+// SubmitBeaconBlock is a mock.
+func (m *BeaconBlockProposalProvider) BeaconBlockProposal(ctx context.Context, slot uint64, randaoReveal []byte, graffiti []byte) (*spec.BeaconBlock, error) {
+	return nil, nil
+}

services/attestationaggregator/standard/parameters.go

@@ -28,7 +28,7 @@ type parameters struct {
 	targetAggregatorsPerCommitteeProvider eth2client.TargetAggregatorsPerCommitteeProvider
 	validatingAccountsProvider            accountmanager.ValidatingAccountsProvider
 	aggregateAttestationProvider          eth2client.NonSpecAggregateAttestationProvider
-	aggregateAttestationSubmitter         submitter.AggregateAttestationSubmitter
+	aggregateAttestationsSubmitter        submitter.AggregateAttestationsSubmitter
 }
 
 // Parameter is the interface for service parameters.
@@ -77,10 +77,10 @@ func WithAggregateAttestationDataProvider(provider eth2client.NonSpecAggregateAt
 	})
 }
 
-// WithAggregateAttestationSubmitter sets the aggregate attestation submitter.
-func WithAggregateAttestationSubmitter(submitter submitter.AggregateAttestationSubmitter) Parameter {
+// WithAggregateAttestationsSubmitter sets the aggregate attestation submitter.
+func WithAggregateAttestationsSubmitter(submitter submitter.AggregateAttestationsSubmitter) Parameter {
 	return parameterFunc(func(p *parameters) {
-		p.aggregateAttestationSubmitter = submitter
+		p.aggregateAttestationsSubmitter = submitter
 	})
 }
 
@@ -107,8 +107,8 @@ func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
 	if parameters.aggregateAttestationProvider == nil {
 		return nil, errors.New("no aggregate attestation provider specified")
 	}
-	if parameters.aggregateAttestationSubmitter == nil {
-		return nil, errors.New("no aggregate attestation submitter specified")
+	if parameters.aggregateAttestationsSubmitter == nil {
+		return nil, errors.New("no aggregate attestations submitter specified")
 	}
 
 	return &parameters, nil

services/attestationaggregator/standard/service.go

@@ -32,11 +32,11 @@ import (
 
 // Service is an attestation aggregator.
 type Service struct {
-	monitor                       metrics.AttestationAggregationMonitor
-	targetAggregatorsPerCommittee uint64
-	validatingAccountsProvider    accountmanager.ValidatingAccountsProvider
-	aggregateAttestationProvider  eth2client.NonSpecAggregateAttestationProvider
-	aggregateAttestationSubmitter submitter.AggregateAttestationSubmitter
+	monitor                        metrics.AttestationAggregationMonitor
+	targetAggregatorsPerCommittee  uint64
+	validatingAccountsProvider     accountmanager.ValidatingAccountsProvider
+	aggregateAttestationProvider   eth2client.NonSpecAggregateAttestationProvider
+	aggregateAttestationsSubmitter submitter.AggregateAttestationsSubmitter
 }
 
 // module-wide log.
@@ -61,11 +61,11 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	}
 
 	s := &Service{
-		monitor:                       parameters.monitor,
-		targetAggregatorsPerCommittee: targetAggregatorsPerCommittee,
-		validatingAccountsProvider:    parameters.validatingAccountsProvider,
-		aggregateAttestationProvider:  parameters.aggregateAttestationProvider,
-		aggregateAttestationSubmitter: parameters.aggregateAttestationSubmitter,
+		monitor:                        parameters.monitor,
+		targetAggregatorsPerCommittee:  targetAggregatorsPerCommittee,
+		validatingAccountsProvider:     parameters.validatingAccountsProvider,
+		aggregateAttestationProvider:   parameters.aggregateAttestationProvider,
+		aggregateAttestationsSubmitter: parameters.aggregateAttestationsSubmitter,
 	}
 
 	return s, nil
@@ -137,11 +137,13 @@ func (s *Service) Aggregate(ctx context.Context, data interface{}) {
 	log.Trace().Dur("elapsed", time.Since(started)).Msg("Signed aggregate attestation")
 
 	// Submit the signed aggregate and proof.
-	signedAggregateAndProof := &spec.SignedAggregateAndProof{
-		Message:   aggregateAndProof,
-		Signature: sig,
+	signedAggregateAndProofs := []*spec.SignedAggregateAndProof{
+		{
+			Message:   aggregateAndProof,
+			Signature: sig,
+		},
 	}
-	if err := s.aggregateAttestationSubmitter.SubmitAggregateAttestation(ctx, signedAggregateAndProof); err != nil {
+	if err := s.aggregateAttestationsSubmitter.SubmitAggregateAttestations(ctx, signedAggregateAndProofs); err != nil {
 		log.Error().Err(err).Msg("Failed to submit aggregate and proof")
 		s.monitor.AttestationAggregationCompleted(started, "failed")
 		return

services/submitter/immediate/service.go

@@ -101,8 +101,8 @@ func (s *Service) SubmitAttestation(ctx context.Context, attestation *spec.Attes
 
 // SubmitBeaconCommitteeSubscriptions submits a batch of beacon committee subscriptions.
 func (s *Service) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*submitter.BeaconCommitteeSubscription) error {
-	if subscriptions == nil {
-		return errors.New("no subscriptions supplied")
+	if len(subscriptions) == 0 {
+		return errors.New("no beacon committee subscriptions supplied")
 	}
 
 	subs := make([]*eth2client.BeaconCommitteeSubscription, len(subscriptions))
@@ -139,20 +139,20 @@ func (s *Service) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscr
 	return nil
 }
 
-// SubmitAggregateAttestation submits an aggregate attestation.
-func (s *Service) SubmitAggregateAttestation(ctx context.Context, aggregate *spec.SignedAggregateAndProof) error {
-	if aggregate == nil {
-		return errors.New("no aggregate attestation supplied")
+// SubmitAggregateAttestations submits aggregate attestations.
+func (s *Service) SubmitAggregateAttestations(ctx context.Context, aggregates []*spec.SignedAggregateAndProof) error {
+	if len(aggregates) == 0 {
+		return errors.New("no aggregate attestations supplied")
 	}
 
-	if err := s.aggregateAttestationsSubmitter.SubmitAggregateAttestations(ctx, []*spec.SignedAggregateAndProof{aggregate}); err != nil {
+	if err := s.aggregateAttestationsSubmitter.SubmitAggregateAttestations(ctx, aggregates); err != nil {
 		return errors.Wrap(err, "failed to submit aggregate attestation")
 	}
 
 	if e := log.Trace(); e.Enabled() {
-		data, err := json.Marshal(aggregate)
+		data, err := json.Marshal(aggregates)
 		if err == nil {
-			e.Str("attestation", string(data)).Msg("Submitted aggregate attestation")
+			e.Str("attestation", string(data)).Msg("Submitted aggregate attestations")
 		}
 	}
 

services/submitter/immediate/service_test.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"testing"
 
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/attestantio/vouch/mock"
 	"github.com/attestantio/vouch/services/submitter"
 	"github.com/attestantio/vouch/services/submitter/immediate"
@@ -78,7 +79,7 @@ func TestService(t *testing.T) {
 		{
 			name: "Good",
 			params: []immediate.Parameter{
-				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithLogLevel(zerolog.TraceLevel),
 				immediate.WithAttestationSubmitter(attestationSubmitter),
 				immediate.WithBeaconBlockSubmitter(beaconBlockSubmitter),
 				immediate.WithBeaconCommitteeSubscriptionsSubmitter(beaconCommitteeSubscriptionSubmitter),
@@ -98,23 +99,6 @@ func TestService(t *testing.T) {
 		})
 	}
 }
-
-func TestSubmit(t *testing.T) {
-	s, err := immediate.New(context.Background(),
-		immediate.WithLogLevel(zerolog.Disabled),
-		immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
-		immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
-		immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
-		immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
-	)
-	require.NoError(t, err)
-
-	require.EqualError(t, s.SubmitBeaconBlock(context.Background(), nil), "no beacon block supplied")
-	require.EqualError(t, s.SubmitAttestation(context.Background(), nil), "no attestation supplied")
-	require.EqualError(t, s.SubmitBeaconCommitteeSubscriptions(context.Background(), nil), "no subscriptions supplied")
-	require.EqualError(t, s.SubmitAggregateAttestation(context.Background(), nil), "no aggregate attestation supplied")
-}
-
 func TestInterfaces(t *testing.T) {
 	s, err := immediate.New(context.Background(),
 		immediate.WithLogLevel(zerolog.Disabled),
@@ -127,5 +111,291 @@ func TestInterfaces(t *testing.T) {
 	require.Implements(t, (*submitter.BeaconBlockSubmitter)(nil), s)
 	require.Implements(t, (*submitter.AttestationSubmitter)(nil), s)
 	require.Implements(t, (*submitter.BeaconCommitteeSubscriptionsSubmitter)(nil), s)
-	require.Implements(t, (*submitter.AggregateAttestationSubmitter)(nil), s)
+	require.Implements(t, (*submitter.AggregateAttestationsSubmitter)(nil), s)
+}
+
+func TestSubmitBeaconBlock(t *testing.T) {
+	tests := []struct {
+		name   string
+		params []immediate.Parameter
+		block  *spec.SignedBeaconBlock
+		err    string
+	}{
+		{
+			name: "Nil",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			err: "no beacon block supplied",
+		},
+		{
+			name: "Empty",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			block: &spec.SignedBeaconBlock{},
+		},
+		{
+			name: "Erroring",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewErroringBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			block: &spec.SignedBeaconBlock{},
+			err:   "failed to submit beacon block: error",
+		},
+		{
+			name: "Good",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.TraceLevel),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			block: &spec.SignedBeaconBlock{},
+		},
+	}
+
+	for _, test := range tests {
+		s, err := immediate.New(context.Background(), test.params...)
+		require.NoError(t, err)
+
+		t.Run(test.name, func(t *testing.T) {
+			err := s.SubmitBeaconBlock(context.Background(), test.block)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestSubmitAttestation(t *testing.T) {
+	tests := []struct {
+		name        string
+		params      []immediate.Parameter
+		attestation *spec.Attestation
+		err         string
+	}{
+		{
+			name: "Nil",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			err: "no attestation supplied",
+		},
+		{
+			name: "Empty",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			attestation: &spec.Attestation{},
+		},
+		{
+			name: "Erroring",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewErroringAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			attestation: &spec.Attestation{},
+			err:         "failed to submit attestation: error",
+		},
+		{
+			name: "Good",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.TraceLevel),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			attestation: &spec.Attestation{},
+		},
+	}
+
+	for _, test := range tests {
+		s, err := immediate.New(context.Background(), test.params...)
+		require.NoError(t, err)
+
+		t.Run(test.name, func(t *testing.T) {
+			err := s.SubmitAttestation(context.Background(), test.attestation)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestSubmitAggregateAttestations(t *testing.T) {
+	tests := []struct {
+		name       string
+		params     []immediate.Parameter
+		aggregates []*spec.SignedAggregateAndProof
+		err        string
+	}{
+		{
+			name: "Nil",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			err: "no aggregate attestations supplied",
+		},
+		{
+			name: "Empty",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			aggregates: []*spec.SignedAggregateAndProof{},
+			err:        "no aggregate attestations supplied",
+		},
+		{
+			name: "Erroring",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewErroringAggregateAttestationsSubmitter()),
+			},
+			aggregates: []*spec.SignedAggregateAndProof{
+				{},
+			},
+			err: "failed to submit aggregate attestation: error",
+		},
+		{
+			name: "Good",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.TraceLevel),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			aggregates: []*spec.SignedAggregateAndProof{
+				{},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		s, err := immediate.New(context.Background(), test.params...)
+		require.NoError(t, err)
+
+		t.Run(test.name, func(t *testing.T) {
+			err := s.SubmitAggregateAttestations(context.Background(), test.aggregates)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestSubmitBeaconCommitteeSubscriptions(t *testing.T) {
+	tests := []struct {
+		name          string
+		params        []immediate.Parameter
+		subscriptions []*submitter.BeaconCommitteeSubscription
+		err           string
+	}{
+		{
+			name: "Nil",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			err: "no beacon committee subscriptions supplied",
+		},
+		{
+			name: "Empty",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			subscriptions: []*submitter.BeaconCommitteeSubscription{},
+			err:           "no beacon committee subscriptions supplied",
+		},
+		{
+			name: "Erroring",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.Disabled),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewErroringBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			subscriptions: []*submitter.BeaconCommitteeSubscription{
+				{},
+			},
+			err: "failed to submit beacon committee subscriptions: error",
+		},
+		{
+			name: "Good",
+			params: []immediate.Parameter{
+				immediate.WithLogLevel(zerolog.TraceLevel),
+				immediate.WithAttestationSubmitter(mock.NewAttestationSubmitter()),
+				immediate.WithBeaconBlockSubmitter(mock.NewBeaconBlockSubmitter()),
+				immediate.WithBeaconCommitteeSubscriptionsSubmitter(mock.NewBeaconCommitteeSubscriptionsSubmitter()),
+				immediate.WithAggregateAttestationsSubmitter(mock.NewAggregateAttestationsSubmitter()),
+			},
+			subscriptions: []*submitter.BeaconCommitteeSubscription{
+				{},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		s, err := immediate.New(context.Background(), test.params...)
+		require.NoError(t, err)
+
+		t.Run(test.name, func(t *testing.T) {
+			err := s.SubmitBeaconCommitteeSubscriptions(context.Background(), test.subscriptions)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
 }

services/submitter/multinode/parameters.go

@@ -97,16 +97,16 @@ func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
 	if parameters.processConcurrency == 0 {
 		return nil, errors.New("no process concurrency specified")
 	}
-	if parameters.beaconBlockSubmitters == nil {
+	if len(parameters.beaconBlockSubmitters) == 0 {
 		return nil, errors.New("no beacon block submitters specified")
 	}
-	if parameters.attestationSubmitters == nil {
+	if len(parameters.attestationSubmitters) == 0 {
 		return nil, errors.New("no attestation submitters specified")
 	}
-	if parameters.aggregateAttestationsSubmitters == nil {
+	if len(parameters.aggregateAttestationsSubmitters) == 0 {
 		return nil, errors.New("no aggregate attestations submitters specified")
 	}
-	if parameters.beaconCommitteeSubscriptionsSubmitters == nil {
+	if len(parameters.beaconCommitteeSubscriptionsSubmitters) == 0 {
 		return nil, errors.New("no beacon committee subscription submitters specified")
 	}
 

services/submitter/multinode/service.go

@@ -42,7 +42,7 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	}
 
 	// Set logging.
-	log = zerologger.With().Str("strategy", "submitter").Str("impl", "multinode").Logger()
+	log = zerologger.With().Str("strategy", "submitter").Str("impl", "all").Logger()
 	if parameters.logLevel != log.GetLevel() {
 		log = log.Level(parameters.logLevel)
 	}

services/submitter/null/service.go

@@ -104,16 +104,16 @@ func (s *Service) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscr
 	return nil
 }
 
-// SubmitAggregateAttestation submits an aggregate attestation.
-func (s *Service) SubmitAggregateAttestation(ctx context.Context, aggregate *spec.SignedAggregateAndProof) error {
-	if aggregate == nil {
-		return errors.New("no aggregate attestation supplied")
+// SubmitAggregateAttestations submits aggregate attestations.
+func (s *Service) SubmitAggregateAttestations(ctx context.Context, aggregates []*spec.SignedAggregateAndProof) error {
+	if len(aggregates) == 0 {
+		return errors.New("no aggregate attestations supplied")
 	}
 
 	if e := log.Trace(); e.Enabled() {
-		data, err := json.Marshal(aggregate)
+		data, err := json.Marshal(aggregates)
 		if err == nil {
-			e.Str("attestation", string(data)).Msg("Not submitting aggregate attestation")
+			e.Str("attestation", string(data)).Msg("Not submitting aggregate attestations")
 		}
 	}
 

services/submitter/null/service_test.go

@@ -53,7 +53,7 @@ func TestSubmit(t *testing.T) {
 	require.EqualError(t, s.SubmitBeaconBlock(context.Background(), nil), "no beacon block supplied")
 	require.EqualError(t, s.SubmitAttestation(context.Background(), nil), "no attestation supplied")
 	require.EqualError(t, s.SubmitBeaconCommitteeSubscriptions(context.Background(), nil), "no subscriptions supplied")
-	require.EqualError(t, s.SubmitAggregateAttestation(context.Background(), nil), "no aggregate attestation supplied")
+	require.EqualError(t, s.SubmitAggregateAttestations(context.Background(), nil), "no aggregate attestations supplied")
 }
 
 func TestInterfaces(t *testing.T) {
@@ -64,5 +64,5 @@ func TestInterfaces(t *testing.T) {
 	require.Implements(t, (*submitter.BeaconBlockSubmitter)(nil), s)
 	require.Implements(t, (*submitter.AttestationSubmitter)(nil), s)
 	require.Implements(t, (*submitter.BeaconCommitteeSubscriptionsSubmitter)(nil), s)
-	require.Implements(t, (*submitter.AggregateAttestationSubmitter)(nil), s)
+	require.Implements(t, (*submitter.AggregateAttestationsSubmitter)(nil), s)
 }

services/submitter/service.go

@@ -51,8 +51,8 @@ type BeaconCommitteeSubscriptionsSubmitter interface {
 	SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*BeaconCommitteeSubscription) error
 }
 
-// AggregateAttestationSubmitter is the interface for a submitter of aggregate attestations.
-type AggregateAttestationSubmitter interface {
-	// SubmitAggregateAttestation submits an aggregate attestation.
-	SubmitAggregateAttestation(ctx context.Context, aggregateAttestation *spec.SignedAggregateAndProof) error
+// AggregateAttestationsSubmitter is the interface for a submitter of aggregate attestations.
+type AggregateAttestationsSubmitter interface {
+	// SubmitAggregateAttestations submits aggregate attestations.
+	SubmitAggregateAttestations(ctx context.Context, aggregateAttestations []*spec.SignedAggregateAndProof) error
 }