networkconfig: make hardcoded values configurable

beacon/goclient/aggregator.go

@@ -30,7 +30,7 @@
 	gc.waitToSlotTwoThirds(slot)
 
 	// differ from spec because we need to subscribe to subnet
-	isAggregator := isAggregator(committeeLength, slotSig)
+	isAggregator := gc.isAggregator(committeeLength, slotSig)
 	if !isAggregator {
 		return nil, DataVersionNil, fmt.Errorf("validator is not an aggregator")
 	}
@@ -188,8 +188,8 @@
 //	 committee = get_beacon_committee(state, slot, index)
 //	 modulo = max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE)
 //	 return bytes_to_uint64(hash(slot_signature)[0:8]) % modulo == 0
-func isAggregator(committeeCount uint64, slotSig []byte) bool {
-	modulo := committeeCount / TargetAggregatorsPerCommittee
+func (gc *GoClient) isAggregator(committeeCount uint64, slotSig []byte) bool {
+	modulo := committeeCount / gc.beaconConfig.TargetAggregatorsPerCommittee
 	if modulo == 0 {
 		// Modulo must be at least 1.
 		modulo = 1
@@ -202,8 +202,8 @@
 // waitToSlotTwoThirds waits until two-third of the slot has transpired (SECONDS_PER_SLOT * 2 / 3 seconds after slot start time)
 func (gc *GoClient) waitToSlotTwoThirds(slot phase0.Slot) {
 	config := gc.getBeaconConfig()
-	oneThird := config.SlotDuration / 3 /* one third of slot duration */
-	finalTime := config.GetSlotStartTime(slot).Add(2 * oneThird)
+	oneInterval := config.IntervalDuration()
+	finalTime := config.GetSlotStartTime(slot).Add(2 * oneInterval)
 	wait := time.Until(finalTime)
 	if wait <= 0 {
 		return

beacon/goclient/signing.go

@@ -48,16 +48,10 @@ func (gc *GoClient) computeVoluntaryExitDomain(ctx context.Context) (phase0.Doma
 	}
 
 	forkData := &phase0.ForkData{
-		CurrentVersion: forkVersion,
+		CurrentVersion:        forkVersion,
+		GenesisValidatorsRoot: gc.getBeaconConfig().GenesisValidatorsRoot,
 	}
 
-	genesis, err := gc.Genesis(ctx)
-	if err != nil {
-		return phase0.Domain{}, fmt.Errorf("failed to obtain genesis response: %w", err)
-	}
-
-	forkData.GenesisValidatorsRoot = genesis.GenesisValidatorsRoot
-
 	root, err := forkData.HashTreeRoot()
 	if err != nil {
 		return phase0.Domain{}, fmt.Errorf("failed to calculate signature domain, err: %w", err)

beacon/goclient/spec.go

@@ -15,8 +15,14 @@
 )
 
 const (
-	DefaultSlotDuration  = 12 * time.Second
-	DefaultSlotsPerEpoch = uint64(32)
+	DefaultSlotDuration                         = 12 * time.Second
+	DefaultSlotsPerEpoch                        = uint64(32)
+	DefaultEpochsPerSyncCommitteePeriod         = uint64(256)
+	DefaultSyncCommitteeSize                    = uint64(512)
+	DefaultSyncCommitteeSubnetCount             = uint64(4)
+	DefaultTargetAggregatorsPerSyncSubcommittee = uint64(16)
+	DefaultTargetAggregatorsPerCommittee        = uint64(16)
+	DefaultIntervalsPerSlot                     = uint64(3)
 )
 
 // BeaconConfig returns the network Beacon configuration
@@ -39,7 +45,7 @@
 
 	networkNameRaw, ok := specResponse["CONFIG_NAME"]
 	if !ok {
-		return networkconfig.BeaconConfig{}, fmt.Errorf("config name not known by chain")
+		return networkconfig.BeaconConfig{}, fmt.Errorf("config name wasn't found in beacon node response")
 	}
 
 	networkName, ok := networkNameRaw.(string)
@@ -52,7 +58,7 @@
 		if slotDurationDecoded, ok := slotDurationRaw.(time.Duration); ok {
 			slotDuration = slotDurationDecoded
 		} else {
-			gc.log.Warn("seconds per slot not known by chain, using default value",
+			gc.log.Warn("seconds per slot wasn't found in beacon node response, using default value",
 				zap.Any("value", slotDuration))
 		}
 	}
@@ -62,23 +68,90 @@
 		if slotsPerEpochDecoded, ok := slotsPerEpochRaw.(uint64); ok {
 			slotsPerEpoch = slotsPerEpochDecoded
 		} else {
-			gc.log.Warn("slots per epoch not known by chain, using default value",
+			gc.log.Warn("slots per epoch wasn't found in beacon node response, using default value",
 				zap.Uint64("value", slotsPerEpoch))
 		}
 	}
 
+	epochsPerSyncCommitteePeriod := DefaultEpochsPerSyncCommitteePeriod
+	if epochsPerSyncCommitteePeriodRaw, ok := specResponse["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]; ok {
+		if epochsPerSyncCommitteePeriodDecoded, ok := epochsPerSyncCommitteePeriodRaw.(uint64); ok {
+			epochsPerSyncCommitteePeriod = epochsPerSyncCommitteePeriodDecoded
+		} else {
+			gc.log.Warn("epochs per sync committee wasn't found in beacon node response, using default value",
+				zap.Any("value", epochsPerSyncCommitteePeriod))
+		}
+	}
+
+	syncCommitteeSize := DefaultSyncCommitteeSize
+	if syncCommitteeSizeRaw, ok := specResponse["SYNC_COMMITTEE_SIZE"]; ok {
+		if syncCommitteeSizeDecoded, ok := syncCommitteeSizeRaw.(uint64); ok {
+			syncCommitteeSize = syncCommitteeSizeDecoded
+		} else {
+			gc.log.Warn("sync committee size wasn't found in beacon node response, using default value",
+				zap.Any("value", syncCommitteeSize))
+		}
+	}
+
+	targetAggregatorsPerCommittee := DefaultTargetAggregatorsPerCommittee
+	if targetAggregatorsPerCommitteeRaw, ok := specResponse["TARGET_AGGREGATORS_PER_COMMITTEE"]; ok {
+		if targetAggregatorsPerCommitteeDecoded, ok := targetAggregatorsPerCommitteeRaw.(uint64); ok {
+			targetAggregatorsPerCommittee = targetAggregatorsPerCommitteeDecoded
+		} else {
+			gc.log.Warn("target aggregators per committee wasn't found in beacon node response, using default value",
+				zap.Any("value", targetAggregatorsPerCommittee))
+		}
+	}
+
+	targetAggregatorsPerSyncSubcommittee := DefaultTargetAggregatorsPerSyncSubcommittee
+	if targetAggregatorsPerSyncSubcommitteeRaw, ok := specResponse["TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE"]; ok {
+		if targetAggregatorsPerSyncSubcommitteeDecoded, ok := targetAggregatorsPerSyncSubcommitteeRaw.(uint64); ok {
+			targetAggregatorsPerSyncSubcommittee = targetAggregatorsPerSyncSubcommitteeDecoded
+		} else {
+			gc.log.Warn("target aggregators per sync subcommittee wasn't found in beacon node response, using default value",
+				zap.Any("value", targetAggregatorsPerSyncSubcommittee))
+		}
+	}
+
+	intervalsPerSlot := DefaultIntervalsPerSlot
+	if intervalsPerSlotRaw, ok := specResponse["INTERVALS_PER_SLOT"]; ok {
+		if intervalsPerSlotDecoded, ok := intervalsPerSlotRaw.(uint64); ok {
+			intervalsPerSlot = intervalsPerSlotDecoded
+		} else {
+			gc.log.Warn("intervals per slot wasn't found in beacon node response, using default value",
+				zap.Any("value", intervalsPerSlot))
+		}
+	}
+
+	syncCommitteeSubnetCount := DefaultSyncCommitteeSubnetCount
+	if syncCommitteeSubnetCountRaw, ok := specResponse["SYNC_COMMITTEE_SUBNET_COUNT"]; ok {
+		if syncCommitteeSubnetCountDecoded, ok := syncCommitteeSubnetCountRaw.(uint64); ok {
+			syncCommitteeSubnetCount = syncCommitteeSubnetCountDecoded
+		} else {
+			gc.log.Warn("sync committee subnet count wasn't found in beacon node response, using default value",
+				zap.Any("value", syncCommitteeSubnetCount))
+		}
+	}
+
 	genesisResponse, err := genesisForClient(ctx, gc.log, client)
 	if err != nil {
 		gc.log.Error(clResponseErrMsg, zap.String("api", "Genesis"), zap.Error(err))
 		return networkconfig.BeaconConfig{}, fmt.Errorf("failed to obtain genesis response: %w", err)
 	}
 
 	beaconConfig := networkconfig.BeaconConfig{
-		BeaconName:    networkName,
-		SlotDuration:  slotDuration,
-		SlotsPerEpoch: slotsPerEpoch,
-		ForkVersion:   genesisResponse.GenesisForkVersion,
-		GenesisTime:   genesisResponse.GenesisTime,
+		BeaconName:                           networkName,
+		SlotDuration:                         slotDuration,
+		SlotsPerEpoch:                        slotsPerEpoch,
+		EpochsPerSyncCommitteePeriod:         epochsPerSyncCommitteePeriod,
+		SyncCommitteeSize:                    syncCommitteeSize,
+		SyncCommitteeSubnetCount:             syncCommitteeSubnetCount,
+		TargetAggregatorsPerSyncSubcommittee: targetAggregatorsPerSyncSubcommittee,
+		TargetAggregatorsPerCommittee:        targetAggregatorsPerCommittee,
+		IntervalsPerSlot:                     intervalsPerSlot,
+		ForkVersion:                          genesisResponse.GenesisForkVersion,
+		GenesisTime:                          genesisResponse.GenesisTime,
+		GenesisValidatorsRoot:                genesisResponse.GenesisValidatorsRoot,
 	}
 
 	return beaconConfig, nil

beacon/goclient/sync_committee_contribution.go

@@ -24,7 +24,10 @@
 	hash := sha256.Sum256(proof)
 
 	// Keep the signature if it's an aggregator.
-	modulo := SyncCommitteeSize / SyncCommitteeSubnetCount / TargetAggregatorsPerSyncSubcommittee
+	cfg := gc.BeaconConfig()
+
+	// as per spec: https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/validator.md#aggregation-selection
+	modulo := cfg.SyncCommitteeSize / cfg.SyncCommitteeSubnetCount / cfg.TargetAggregatorsPerSyncSubcommittee
 	if modulo == uint64(0) {
 		// Modulo must be at least 1.
 		modulo = 1
@@ -34,7 +37,7 @@
 
 // SyncCommitteeSubnetID returns sync committee subnet ID from subcommittee index
 func (gc *GoClient) SyncCommitteeSubnetID(index phase0.CommitteeIndex) uint64 {
-	return uint64(index) / (SyncCommitteeSize / SyncCommitteeSubnetCount)
+	return uint64(index) / (gc.BeaconConfig().SyncCommitteeSize / gc.BeaconConfig().SyncCommitteeSubnetCount)
 }
 
 // GetSyncCommitteeContribution returns
@@ -154,7 +157,7 @@
 // waitForOneThirdSlotDuration waits until one-third of the slot has transpired (SECONDS_PER_SLOT / 3 seconds after slot start time)
 func (gc *GoClient) waitForOneThirdSlotDuration(slot phase0.Slot) {
 	config := gc.getBeaconConfig()
-	delay := config.SlotDuration / 3 /* a third of the slot duration */
+	delay := config.IntervalDuration()
 	finalTime := config.GetSlotStartTime(slot).Add(delay)
 	wait := time.Until(finalTime)
 	if wait <= 0 {

beacon/goclient/types.go

@@ -7,12 +7,6 @@ import (
 )
 
 var (
-	SyncCommitteeSize                    uint64 = 512
-	SyncCommitteeSubnetCount             uint64 = 4
-	TargetAggregatorsPerSyncSubcommittee uint64 = 16
-	EpochsPerSyncCommitteePeriod         uint64 = 256
-	TargetAggregatorsPerCommittee        uint64 = 16
 	// FarFutureEpoch is the null representation of an epoch.
-	FarFutureEpoch   phase0.Epoch = math.MaxUint64
-	IntervalsPerSlot uint64       = 3
+	FarFutureEpoch phase0.Epoch = math.MaxUint64
 )

message/validation/const.go

@@ -14,7 +14,6 @@ const (
 	allowedRoundsInFuture   = 1
 	allowedRoundsInPast     = 2
 	LateSlotAllowance       = 2
-	syncCommitteeSize       = 512
 	rsaSignatureSize        = 256
 	operatorIDSize          = 8 // uint64
 	slotSize                = 8 // uint64

message/validation/partial_validation.go

@@ -197,7 +197,8 @@ func (mv *messageValidator) validatePartialSigMessagesByDutyLogic(
 
 	if signedSSVMessage.SSVMessage.MsgID.GetRoleType() == spectypes.RoleCommittee {
 		// Rule: The number of signatures must be <= min(2*V, V + SYNC_COMMITTEE_SIZE) where V is the number of validators assigned to the cluster
-		if partialSignatureMessageCount > min(2*clusterValidatorCount, clusterValidatorCount+syncCommitteeSize) {
+		// #nosec G115
+		if partialSignatureMessageCount > min(2*clusterValidatorCount, clusterValidatorCount+int(mv.netCfg.GetSyncCommitteeSize())) {
 			return ErrTooManyPartialSignatureMessages
 		}
 

message/validation/validation.go

@@ -246,7 +246,6 @@ func (mv *messageValidator) getValidationLock(key peerIDWithMessageID) *sync.Mut
 
 		lock := &sync.Mutex{}
 
-		epochDuration := time.Duration(mv.netCfg.GetSlotsPerEpoch()) * mv.netCfg.GetSlotDuration() // #nosec G115 - slots per epoch never exceeds math.MaxInt64
 		// validationLockTTL specifies how much time a particular validation lock is meant to
 		// live. It must be large enough for validation lock to never expire while we still are
 		// expecting to process messages targeting that same validation lock. For a message
@@ -255,8 +254,7 @@ func (mv *messageValidator) getValidationLock(key peerIDWithMessageID) *sync.Mut
 		// be allowed to take place).
 		// 2 epoch duration is a safe TTL to use - message validation will reject processing
 		// for any message older than that.
-		validationLockTTL := 2 * epochDuration
-		mv.validationLockCache.Set(key, lock, validationLockTTL)
+		mv.validationLockCache.Set(key, lock, 2*mv.netCfg.EpochDuration())
 
 		return lock, nil
 	})

network/topics/controller_test.go

@@ -399,7 +399,6 @@ func newPeer(ctx context.Context, logger *zap.Logger, t *testing.T, msgValidator
 		Scoring: &topics.ScoringConfig{
 			IPWhitelist:        nil,
 			IPColocationWeight: 0,
-			OneEpochDuration:   time.Minute,
 		},
 		MsgValidator:           msgValidator,
 		ScoreInspector:         scoreInspector,

network/topics/params/helpers.go

@@ -7,10 +7,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-const (
-	oneEpochDuration = (12 * time.Second) * 32
-)
-
 // scoreDecay determines the decay rate from the provided time period till
 // the decayToZero value. Ex: ( 1 -> 0.01)
 func scoreDecay(totalDecayDuration time.Duration, decayIntervalDuration time.Duration) float64 {