Aggregator, Sync Committee Contribution - Committee Runner

beacon/goclient/aggregator.go

@@ -2,6 +2,8 @@ package goclient
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/binary"
 	"fmt"
 	"net/http"
 	"time"
@@ -13,6 +15,36 @@ import (
 	ssz "github.com/ferranbt/fastssz"
 )
 
+func (gc *GoClient) IsAggregator(
+	_ context.Context,
+	_ phase0.Slot,
+	_ phase0.CommitteeIndex,
+	committeeLength uint64,
+	slotSig []byte,
+) bool {
+	modulo := committeeLength / gc.beaconConfig.TargetAggregatorsPerCommittee
+	if modulo == 0 {
+		modulo = 1
+	}
+
+	h := sha256.Sum256(slotSig)
+	x := binary.LittleEndian.Uint64(h[:8])
+
+	return x%modulo == 0
+}
+
+func (gc *GoClient) GetAggregateAttestation(
+	ctx context.Context,
+	slot phase0.Slot,
+	committeeIndex phase0.CommitteeIndex,
+) (ssz.Marshaler, spec.DataVersion, error) {
+	va, _, err := gc.fetchVersionedAggregate(ctx, slot, committeeIndex)
+	if err != nil {
+		return nil, DataVersionNil, err
+	}
+	return versionedAggregateToSSZ(va)
+}
+
 // SubmitAggregateSelectionProof returns an AggregateAndProof object
 func (gc *GoClient) SubmitAggregateSelectionProof(
 	ctx context.Context,
@@ -29,144 +61,219 @@ func (gc *GoClient) SubmitAggregateSelectionProof(
 		return nil, 0, fmt.Errorf("wait for 2/3 of slot: %w", err)
 	}
 
+	va, _, err := gc.fetchVersionedAggregate(ctx, slot, committeeIndex)
+	if err != nil {
+		return nil, DataVersionNil, err
+	}
+
+	var selectionProof phase0.BLSSignature
+	copy(selectionProof[:], slotSig)
+
+	return versionedToAggregateAndProof(va, index, selectionProof)
+}
+
+// SubmitSignedAggregateSelectionProof broadcasts a signed aggregator msg
+func (gc *GoClient) SubmitSignedAggregateSelectionProof(
+	ctx context.Context,
+	msg *spec.VersionedSignedAggregateAndProof,
+) error {
+	start := time.Now()
+	err := gc.multiClient.SubmitAggregateAttestations(ctx, &api.SubmitAggregateAttestationsOpts{
+		SignedAggregateAndProofs: []*spec.VersionedSignedAggregateAndProof{msg},
+	})
+	recordRequest(ctx, gc.log, "SubmitAggregateAttestations", gc.multiClient, http.MethodPost, true, time.Since(start), err)
+	if err != nil {
+		return errMultiClient(fmt.Errorf("submit aggregate attestations: %w", err), "SubmitAggregateAttestations")
+	}
+
+	return nil
+}
+
+// waitTwoThirdsIntoSlot waits until two-third of the slot has transpired (SECONDS_PER_SLOT * 2 / 3 seconds after the start of slot)
+func (gc *GoClient) waitTwoThirdsIntoSlot(ctx context.Context, slot phase0.Slot) error {
+	config := gc.getBeaconConfig()
+	oneInterval := config.IntervalDuration()
+	finalTime := config.SlotStartTime(slot).Add(2 * oneInterval)
+	wait := time.Until(finalTime)
+	if wait <= 0 {
+		return nil
+	}
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-time.After(wait):
+		return nil
+	}
+}
+
+func (gc *GoClient) computeAttDataRootAndVersion(
+	ctx context.Context,
+	slot phase0.Slot,
+	committeeIndex phase0.CommitteeIndex,
+) (root [32]byte, err error) {
 	attData, _, err := gc.GetAttestationData(ctx, slot)
 	if err != nil {
-		return nil, DataVersionNil, fmt.Errorf("fetch attestation data: %w", err)
+		return root, fmt.Errorf("fetch attestation data: %w", err)
 	}
 
 	// Explicitly set Index field as beacon nodes may return inconsistent values.
-	// EIP-7549: For Electra and later, index must always be 0, pre-Electra uses committee index.
-	dataVersion, _ := gc.beaconConfig.BeaconForkAtEpoch(gc.getBeaconConfig().EstimatedEpochAtSlot(attData.Slot))
+	// EIP-7549: Electra+ uses Index=0; pre-Electra uses committee index
+	version, _ := gc.beaconConfig.BeaconForkAtEpoch(gc.getBeaconConfig().EstimatedEpochAtSlot(attData.Slot))
 	attData.Index = 0
-	if dataVersion < spec.DataVersionElectra {
+	if version < spec.DataVersionElectra {
 		attData.Index = committeeIndex
 	}
 
-	// Get aggregate attestation data.
-	root, err := attData.HashTreeRoot()
+	root, err = attData.HashTreeRoot()
 	if err != nil {
-		return nil, DataVersionNil, fmt.Errorf("fetch attestation data root: %w", err)
+		return root, fmt.Errorf("fetch attestation data root: %w", err)
 	}
+	return root, nil
+}
 
-	aggDataReqStart := time.Now()
-	aggDataResp, err := gc.multiClient.AggregateAttestation(ctx, &api.AggregateAttestationOpts{
+func (gc *GoClient) fetchVersionedAggregate(
+	ctx context.Context,
+	slot phase0.Slot,
+	committeeIndex phase0.CommitteeIndex,
+) (*spec.VersionedAttestation, spec.DataVersion, error) {
+	root, err := gc.computeAttDataRootAndVersion(ctx, slot, committeeIndex)
+	if err != nil {
+		return nil, DataVersionNil, errMultiClient(fmt.Errorf("compute attestation root: %w", err), "AggregateAttestation")
+	}
+
+	start := time.Now()
+	resp, err := gc.multiClient.AggregateAttestation(ctx, &api.AggregateAttestationOpts{
 		Slot:                slot,
 		AttestationDataRoot: root,
 		CommitteeIndex:      committeeIndex,
 	})
-	recordRequest(ctx, gc.log, "AggregateAttestation", gc.multiClient, http.MethodGet, true, time.Since(aggDataReqStart), err)
+	recordRequest(ctx, gc.log, "AggregateAttestation", gc.multiClient, http.MethodGet, true, time.Since(start), err)
 	if err != nil {
 		return nil, DataVersionNil, errMultiClient(fmt.Errorf("fetch aggregate attestation: %w", err), "AggregateAttestation")
 	}
-	if aggDataResp == nil {
+	if resp == nil {
 		return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation response is nil"), "AggregateAttestation")
 	}
-	if aggDataResp.Data == nil {
-		return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation response data is nil"), "AggregateAttestation")
+	if resp.Data == nil {
+		return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation data is nil"), "AggregateAttestation")
 	}
+	return resp.Data, resp.Data.Version, nil
+}
 
-	var selectionProof phase0.BLSSignature
-	copy(selectionProof[:], slotSig)
+func versionedAggregateToSSZ(va *spec.VersionedAttestation) (ssz.Marshaler, spec.DataVersion, error) {
+	switch va.Version {
+	case spec.DataVersionPhase0:
+		if va.Phase0 == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Phase0, va.Version, nil
+	case spec.DataVersionAltair:
+		if va.Altair == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Altair, va.Version, nil
+	case spec.DataVersionBellatrix:
+		if va.Bellatrix == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Bellatrix, va.Version, nil
+	case spec.DataVersionCapella:
+		if va.Capella == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Capella, va.Version, nil
+	case spec.DataVersionDeneb:
+		if va.Deneb == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Deneb, va.Version, nil
+	case spec.DataVersionElectra:
+		if va.Electra == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Electra, va.Version, nil
+	case spec.DataVersionFulu:
+		if va.Fulu == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
+		}
+		return va.Fulu, va.Version, nil
+	default:
+		return nil, DataVersionNil, errMultiClient(fmt.Errorf("unknown data version: %d", va.Version), "AggregateAttestation")
+	}
+}
 
-	vAtt := aggDataResp.Data
-	switch vAtt.Version {
+func versionedToAggregateAndProof(
+	va *spec.VersionedAttestation,
+	index phase0.ValidatorIndex,
+	selectionProof phase0.BLSSignature,
+) (ssz.Marshaler, spec.DataVersion, error) {
+	switch va.Version {
 	case spec.DataVersionPhase0:
-		if vAtt.Phase0 == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Phase0 == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &phase0.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Phase0,
+			Aggregate:       va.Phase0,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionAltair:
-		if vAtt.Altair == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Altair == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &phase0.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Altair,
+			Aggregate:       va.Altair,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionBellatrix:
-		if vAtt.Bellatrix == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Bellatrix == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &phase0.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Bellatrix,
+			Aggregate:       va.Bellatrix,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionCapella:
-		if vAtt.Capella == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Capella == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &phase0.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Capella,
+			Aggregate:       va.Capella,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionDeneb:
-		if vAtt.Deneb == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Deneb == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &phase0.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Deneb,
+			Aggregate:       va.Deneb,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionElectra:
-		if vAtt.Electra == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Electra == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
 		return &electra.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Electra,
+			Aggregate:       va.Electra,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	case spec.DataVersionFulu:
-		if vAtt.Fulu == nil {
-			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", vAtt.Version.String()), "AggregateAttestation")
+		if va.Fulu == nil {
+			return nil, DataVersionNil, errMultiClient(fmt.Errorf("aggregate attestation %s data is nil", va.Version.String()), "AggregateAttestation")
 		}
+		// Fulu AggregateAndProof uses electra.AggregateAndProof in go-eth2-client
 		return &electra.AggregateAndProof{
 			AggregatorIndex: index,
-			Aggregate:       vAtt.Fulu,
+			Aggregate:       va.Fulu,
 			SelectionProof:  selectionProof,
-		}, vAtt.Version, nil
+		}, va.Version, nil
 	default:
-		return nil, DataVersionNil, fmt.Errorf("unknown data version: %d", vAtt.Version)
-	}
-}
-
-// SubmitSignedAggregateSelectionProof broadcasts a signed aggregator msg
-func (gc *GoClient) SubmitSignedAggregateSelectionProof(
-	ctx context.Context,
-	msg *spec.VersionedSignedAggregateAndProof,
-) error {
-	start := time.Now()
-	err := gc.multiClient.SubmitAggregateAttestations(ctx, &api.SubmitAggregateAttestationsOpts{SignedAggregateAndProofs: []*spec.VersionedSignedAggregateAndProof{msg}})
-	recordRequest(ctx, gc.log, "SubmitAggregateAttestations", gc.multiClient, http.MethodPost, true, time.Since(start), err)
-	if err != nil {
-		return errMultiClient(fmt.Errorf("submit aggregate attestations: %w", err), "SubmitAggregateAttestations")
-	}
-
-	return nil
-}
-
-// waitTwoThirdsIntoSlot waits until two-third of the slot has transpired (SECONDS_PER_SLOT * 2 / 3 seconds after the start of slot)
-func (gc *GoClient) waitTwoThirdsIntoSlot(ctx context.Context, slot phase0.Slot) error {
-	config := gc.getBeaconConfig()
-	oneInterval := config.IntervalDuration()
-	finalTime := config.SlotStartTime(slot).Add(2 * oneInterval)
-	wait := time.Until(finalTime)
-	if wait <= 0 {
-		return nil
-	}
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-time.After(wait):
-		return nil
+		return nil, DataVersionNil, errMultiClient(fmt.Errorf("unknown data version: %d", va.Version), "AggregateAttestation")
 	}
 }

cli/generate_config.go

@@ -109,6 +109,9 @@ var generateConfigCmd = &cobra.Command{
 			RegistryContractAddr: ethcommon.HexToAddress(ssvRegistryContractAddr),
 			Bootnodes:            bootnodes,
 			DiscoveryProtocolID:  parsedDiscoveryProtocolIDArr,
+			Forks: networkconfig.SSVForks{
+				Boole: 0,
+			},
 		}
 
 		data, err := yaml.Marshal(&config)

exporter/api/msg.go

@@ -29,7 +29,7 @@ type ParticipantsAPI struct {
 	ValidatorPK string
 	Role        string
 	Message     specqbft.Message
-	FullData    *spectypes.ValidatorConsensusData
+	FullData    *spectypes.ProposerConsensusData
 }
 
 // NewParticipantsAPIMsg creates a new message in a new format from the given message.
@@ -77,7 +77,7 @@ func ParticipantsAPIData(domainType spectypes.DomainType, msgs ...qbftstorage.Pa
 				Identifier: msgID[:],
 				Round:      specqbft.FirstRound,
 			},
-			FullData: &spectypes.ValidatorConsensusData{
+			FullData: &spectypes.ProposerConsensusData{
 				Duty: spectypes.ValidatorDuty{
 					PubKey: blsPubKey,
 					Slot:   msg.Slot,

go.mod

@@ -43,7 +43,7 @@ require (
 	github.com/sourcegraph/conc v0.3.0
 	github.com/spf13/cobra v1.8.1
 	github.com/ssvlabs/eth2-key-manager v1.5.6
-	github.com/ssvlabs/ssv-spec v1.2.2
+	github.com/ssvlabs/ssv-spec v1.2.3-0.20260121164943-4280751195c0
 	github.com/ssvlabs/ssv/ssvsigner v0.0.0-20251110161756-cd931098ea44
 	github.com/status-im/keycard-go v0.2.0
 	github.com/stretchr/testify v1.11.1
@@ -55,6 +55,7 @@ require (
 	go.uber.org/mock v0.5.2
 	go.uber.org/multierr v1.11.0
 	go.uber.org/zap v1.27.0
+	golang.org/x/exp v0.0.0-20250911091902-df9299821621
 	golang.org/x/mod v0.28.0
 	golang.org/x/sync v0.17.0
 	golang.org/x/text v0.29.0
@@ -99,7 +100,6 @@ require (
 	go.opentelemetry.io/otel/sdk/log v0.12.2 // indirect
 	go.opentelemetry.io/proto/otlp v1.7.1 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
-	golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect
 	golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 // indirect