feat(network/config): pass custom ssv config & get beacon config from node & remove hardcoded network values

api/handlers/exporter.go

@@ -7,15 +7,13 @@ import (
 
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	spectypes "github.com/ssvlabs/ssv-spec/types"
-	"github.com/ssvlabs/ssv/networkconfig"
 	qbftstorage "github.com/ssvlabs/ssv/protocol/v2/qbft/storage"
 
 	"github.com/ssvlabs/ssv/api"
 	ibftstorage "github.com/ssvlabs/ssv/ibft/storage"
 )
 
 type Exporter struct {
-	NetworkConfig     networkconfig.NetworkConfig
 	ParticipantStores *ibftstorage.ParticipantStores
 }
 

beacon/goclient/aggregator.go

@@ -21,7 +21,7 @@ func (gc *GoClient) SubmitAggregateSelectionProof(slot phase0.Slot, committeeInd
 	gc.waitToSlotTwoThirds(slot)
 
 	// differ from spec because we need to subscribe to subnet
-	isAggregator, err := isAggregator(committeeLength, slotSig)
+	isAggregator, err := gc.isAggregator(committeeLength, slotSig)
 	if err != nil {
 		return nil, DataVersionNil, fmt.Errorf("failed to check if validator is an aggregator: %w", err)
 	}
@@ -94,8 +94,8 @@ func (gc *GoClient) SubmitSignedAggregateSelectionProof(msg *phase0.SignedAggreg
 //	 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, error) {
-	modulo := committeeCount / TargetAggregatorsPerCommittee
+func (gc *GoClient) isAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
+	modulo := committeeCount / gc.BeaconConfig().TargetAggregatorsPerCommittee
 	if modulo == 0 {
 		// Modulo must be at least 1.
 		modulo = 1
@@ -107,9 +107,9 @@ func isAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 
 // waitToSlotTwoThirds waits until two-third of the slot has transpired (SECONDS_PER_SLOT * 2 / 3 seconds after the start of slot)
 func (gc *GoClient) waitToSlotTwoThirds(slot phase0.Slot) {
-	oneThird := gc.network.SlotDurationSec() / 3 /* one third of slot duration */
+	oneThird := gc.BeaconConfig().SlotDuration / 3 /* one third of slot duration */
 
-	finalTime := gc.slotStartTime(slot).Add(2 * oneThird)
+	finalTime := gc.BeaconConfig().GetSlotStartTime(slot).Add(2 * oneThird)
 	wait := time.Until(finalTime)
 	if wait <= 0 {
 		return

beacon/goclient/attest_test.go

@@ -13,14 +13,10 @@ import (
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/sourcegraph/conc/pool"
-	"github.com/ssvlabs/ssv-spec/types"
-	operatordatastore "github.com/ssvlabs/ssv/operator/datastore"
-	"github.com/ssvlabs/ssv/operator/slotticker"
-	"github.com/ssvlabs/ssv/protocol/v2/blockchain/beacon"
-	registrystorage "github.com/ssvlabs/ssv/registry/storage"
-	"github.com/ssvlabs/ssv/utils/hashmap"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
+
+	"github.com/ssvlabs/ssv/utils/hashmap"
 )
 
 func TestGoClient_GetAttestationData(t *testing.T) {
@@ -58,6 +54,29 @@ func TestGoClient_GetAttestationData(t *testing.T) {
 					"version": "Lighthouse/v4.5.0-441fc16/x86_64-linux"
 				  }
 				}`),
+				"/eth/v1/config/spec": []byte(`{
+				  "data": {
+					"CONFIG_NAME": "holesky",
+					"GENESIS_FORK_VERSION": "0x01017000",
+					"CAPELLA_FORK_VERSION": "0x04017000",
+					"MIN_GENESIS_TIME": "1695902100",
+					"SECONDS_PER_SLOT": "12",
+					"SLOTS_PER_EPOCH": "32",
+					"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": "256",
+					"SYNC_COMMITTEE_SIZE": "512",
+					"SYNC_COMMITTEE_SUBNET_COUNT": "4",
+					"TARGET_AGGREGATORS_PER_COMMITTEE": "16",
+					"TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE": "16",
+					"INTERVALS_PER_SLOT": "3"
+				  }
+				}`),
+				"/eth/v1/beacon/genesis": []byte(`{
+				  "data": {
+					"genesis_time": "1695902400",
+					"genesis_validators_root": "0x9143aa7c615a7f7115e2b6aac319c03529df8242ae705fba9df39b79c59fa8b1",
+					"genesis_fork_version": "0x01017000"
+				  }
+				}`),
 			}
 			for reqPath, respData := range expInitRequests {
 				if reqPath == r.URL.Path {
@@ -135,20 +154,12 @@ func TestGoClient_GetAttestationData(t *testing.T) {
 
 		client, err := New(
 			zap.NewNop(),
-			beacon.Options{
+			Options{
 				Context:        ctx,
-				Network:        beacon.NewNetwork(types.MainNetwork),
 				BeaconNodeAddr: server.URL,
 				CommonTimeout:  1 * time.Second,
 				LongTimeout:    1 * time.Second,
 			},
-			operatordatastore.New(&registrystorage.OperatorData{ID: 1}),
-			func() slotticker.SlotTicker {
-				return slotticker.New(zap.NewNop(), slotticker.Config{
-					SlotDuration: 12 * time.Second,
-					GenesisTime:  time.Now(),
-				})
-			},
 		)
 		require.NoError(t, err)
 
@@ -245,20 +256,12 @@ func TestGoClient_GetAttestationData(t *testing.T) {
 
 		client, err := New(
 			zap.NewNop(),
-			beacon.Options{
+			Options{
 				Context:        ctx,
-				Network:        beacon.NewNetwork(types.MainNetwork),
 				BeaconNodeAddr: server.URL,
 				CommonTimeout:  1 * time.Second,
 				LongTimeout:    1 * time.Second,
 			},
-			operatordatastore.New(&registrystorage.OperatorData{ID: 1}),
-			func() slotticker.SlotTicker {
-				return slotticker.New(zap.NewNop(), slotticker.Config{
-					SlotDuration: 12 * time.Second,
-					GenesisTime:  time.Now(),
-				})
-			},
 		)
 		require.NoError(t, err)
 

beacon/goclient/goclient.go

@@ -20,12 +20,8 @@ import (
 	"go.uber.org/zap"
 	"tailscale.com/util/singleflight"
 
-	spectypes "github.com/ssvlabs/ssv-spec/types"
 	"github.com/ssvlabs/ssv/logging/fields"
-	operatordatastore "github.com/ssvlabs/ssv/operator/datastore"
-	"github.com/ssvlabs/ssv/operator/slotticker"
-	beaconprotocol "github.com/ssvlabs/ssv/protocol/v2/blockchain/beacon"
-	"github.com/ssvlabs/ssv/utils/casts"
+	"github.com/ssvlabs/ssv/networkconfig"
 )
 
 const (
@@ -108,19 +104,17 @@ var _ NodeClientProvider = (*GoClient)(nil)
 
 // GoClient implementing Beacon struct
 type GoClient struct {
-	log         *zap.Logger
-	ctx         context.Context
-	network     beaconprotocol.Network
-	client      Client
-	nodeVersion string
-	nodeClient  NodeClient
-	gasLimit    uint64
+	log          *zap.Logger
+	ctx          context.Context
+	beaconConfig *networkconfig.Beacon // using pointer to make sure it's fetched
+	client       Client
+	nodeVersion  string
+	nodeClient   NodeClient
+	gasLimit     uint64
 
 	syncDistanceTolerance phase0.Slot
 	nodeSyncingFn         func(ctx context.Context, opts *api.NodeSyncingOpts) (*api.Response[*apiv1.SyncState], error)
 
-	operatorDataStore operatordatastore.OperatorDataStore
-
 	registrationMu       sync.Mutex
 	registrationLastSlot phase0.Slot
 	registrationCache    map[phase0.BLSPubKey]*api.VersionedSignedValidatorRegistration
@@ -141,11 +135,9 @@ type GoClient struct {
 // New init new client and go-client instance
 func New(
 	logger *zap.Logger,
-	opt beaconprotocol.Options,
-	operatorDataStore operatordatastore.OperatorDataStore,
-	slotTickerProvider slotticker.Provider,
+	opt Options,
 ) (*GoClient, error) {
-	logger.Info("consensus client: connecting", fields.Address(opt.BeaconNodeAddr), fields.Network(string(opt.Network.BeaconNetwork)))
+	logger.Info("consensus client: connecting", fields.Address(opt.BeaconNodeAddr))
 
 	commonTimeout := opt.CommonTimeout
 	if commonTimeout == 0 {
@@ -175,19 +167,12 @@ func New(
 	client := &GoClient{
 		log:                   logger,
 		ctx:                   opt.Context,
-		network:               opt.Network,
 		client:                httpClient.(*eth2clienthttp.Service),
 		gasLimit:              opt.GasLimit,
 		syncDistanceTolerance: phase0.Slot(opt.SyncDistanceTolerance),
-		operatorDataStore:     operatorDataStore,
 		registrationCache:     map[phase0.BLSPubKey]*api.VersionedSignedValidatorRegistration{},
-		attestationDataCache: ttlcache.New(
-			// we only fetch attestation data during the slot of the relevant duty (and never later),
-			// hence caching it for 2 slots is sufficient
-			ttlcache.WithTTL[phase0.Slot, *phase0.AttestationData](2 * opt.Network.SlotDurationSec()),
-		),
-		commonTimeout: commonTimeout,
-		longTimeout:   longTimeout,
+		commonTimeout:         commonTimeout,
+		longTimeout:           longTimeout,
 	}
 
 	client.nodeSyncingFn = client.nodeSyncing
@@ -209,17 +194,29 @@ func New(
 	client.nodeVersion = nodeVersionResp.Data
 	client.nodeClient = ParseNodeClient(nodeVersionResp.Data)
 
+	beaconConfig, err := client.fetchBeaconConfig()
+	if err != nil {
+		return nil, fmt.Errorf("fetch spec config: %w", err)
+	}
+	client.beaconConfig = beaconConfig
+
+	client.attestationDataCache = ttlcache.New(
+		// we only fetch attestation data during the slot of the relevant duty (and never later),
+		// hence caching it for 2 slots is sufficient
+		ttlcache.WithTTL[phase0.Slot, *phase0.AttestationData](2 * beaconConfig.SlotDuration),
+	)
+
+	// Start automatic expired item deletion for attestationDataCache.
+	go client.attestationDataCache.Start()
+
 	logger.Info("consensus client connected",
 		fields.Name(httpClient.Name()),
 		fields.Address(httpClient.Address()),
 		zap.String("client", string(client.nodeClient)),
 		zap.String("version", client.nodeVersion),
+		zap.String("config", beaconConfig.String()),
 	)
 
-	go client.registrationSubmitter(slotTickerProvider)
-	// Start automatic expired item deletion for attestationDataCache.
-	go client.attestationDataCache.Start()
-
 	return client, nil
 }
 
@@ -279,19 +276,6 @@ func (gc *GoClient) Healthy(ctx context.Context) error {
 	return nil
 }
 
-// GetBeaconNetwork returns the beacon network the node is on
-func (gc *GoClient) GetBeaconNetwork() spectypes.BeaconNetwork {
-	return gc.network.BeaconNetwork
-}
-
-// SlotStartTime returns the start time in terms of its unix epoch
-// value.
-func (gc *GoClient) slotStartTime(slot phase0.Slot) time.Time {
-	duration := time.Second * casts.DurationFromUint64(uint64(slot)*uint64(gc.network.SlotDurationSec().Seconds()))
-	startTime := time.Unix(gc.network.MinGenesisTime(), 0).Add(duration)
-	return startTime
-}
-
 func (gc *GoClient) Events(ctx context.Context, topics []string, handler eth2client.EventHandlerFunc) error {
 	if err := gc.client.Events(ctx, topics, handler); err != nil {
 		gc.log.Error(clResponseErrMsg,

beacon/goclient/goclient_test.go

@@ -13,13 +13,10 @@ import (
 	"github.com/attestantio/go-eth2-client/api"
 	v1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/ssvlabs/ssv-spec/types"
-	operatordatastore "github.com/ssvlabs/ssv/operator/datastore"
-	"github.com/ssvlabs/ssv/operator/slotticker"
-	"github.com/ssvlabs/ssv/protocol/v2/blockchain/beacon"
-	registrystorage "github.com/ssvlabs/ssv/registry/storage"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
+
+	"github.com/ssvlabs/ssv/protocol/v2/blockchain/beacon"
 )
 
 func TestHealthy(t *testing.T) {
@@ -162,20 +159,12 @@ func TestTimeouts(t *testing.T) {
 func mockClient(ctx context.Context, serverURL string, commonTimeout, longTimeout time.Duration) (beacon.BeaconNode, error) {
 	return New(
 		zap.NewNop(),
-		beacon.Options{
+		Options{
 			Context:        ctx,
-			Network:        beacon.NewNetwork(types.MainNetwork),
 			BeaconNodeAddr: serverURL,
 			CommonTimeout:  commonTimeout,
 			LongTimeout:    longTimeout,
 		},
-		operatordatastore.New(&registrystorage.OperatorData{ID: 1}),
-		func() slotticker.SlotTicker {
-			return slotticker.New(zap.NewNop(), slotticker.Config{
-				SlotDuration: 12 * time.Second,
-				GenesisTime:  time.Now(),
-			})
-		},
 	)
 }
 

beacon/goclient/options.go

@@ -0,0 +1,16 @@
+package goclient
+
+import (
+	"context"
+	"time"
+)
+
+// Options for controller struct creation
+type Options struct {
+	Context               context.Context
+	BeaconNodeAddr        string `yaml:"BeaconNodeAddr" env:"BEACON_NODE_ADDR" env-required:"true"`
+	SyncDistanceTolerance uint64 `yaml:"SyncDistanceTolerance" env:"BEACON_SYNC_DISTANCE_TOLERANCE" env-default:"4" env-description:"The number of out-of-sync slots we can tolerate"`
+	GasLimit              uint64
+	CommonTimeout         time.Duration // Optional.
+	LongTimeout           time.Duration // Optional.
+}

beacon/goclient/proposer.go

@@ -18,6 +18,7 @@ import (
 	ssz "github.com/ferranbt/fastssz"
 	spectypes "github.com/ssvlabs/ssv-spec/types"
 	"github.com/ssvlabs/ssv/logging/fields"
+	operatordatastore "github.com/ssvlabs/ssv/operator/datastore"
 	"github.com/ssvlabs/ssv/operator/slotticker"
 	"go.uber.org/zap"
 )
@@ -302,7 +303,7 @@ func (gc *GoClient) createValidatorRegistration(pubkey []byte, feeRecipient bell
 			Message: &eth2apiv1.ValidatorRegistration{
 				FeeRecipient: feeRecipient,
 				GasLimit:     gc.gasLimit,
-				Timestamp:    gc.network.GetSlotStartTime(gc.network.GetEpochFirstSlot(gc.network.EstimatedCurrentEpoch())),
+				Timestamp:    gc.BeaconConfig().EstimatedCurrentEpochStartTime(),
 				Pubkey:       pk,
 			},
 			Signature: sig,
@@ -311,10 +312,14 @@ func (gc *GoClient) createValidatorRegistration(pubkey []byte, feeRecipient bell
 	return signedReg
 }
 
-func (gc *GoClient) registrationSubmitter(slotTickerProvider slotticker.Provider) {
-	operatorID := gc.operatorDataStore.AwaitOperatorID()
+func (gc *GoClient) RegistrationSubmitter(operatorDataStore operatordatastore.OperatorDataStore) {
+	operatorID := operatorDataStore.AwaitOperatorID()
+
+	ticker := slotticker.New(gc.log, slotticker.Config{
+		SlotDuration: gc.BeaconConfig().SlotDuration,
+		GenesisTime:  gc.BeaconConfig().GenesisTime(),
+	})
 
-	ticker := slotTickerProvider()
 	for {
 		select {
 		case <-gc.ctx.Done():
@@ -326,20 +331,20 @@ func (gc *GoClient) registrationSubmitter(slotTickerProvider slotticker.Provider
 }
 
 func (gc *GoClient) submitRegistrationsFromCache(currentSlot phase0.Slot, operatorID spectypes.OperatorID) {
-	slotsPerEpoch := gc.network.SlotsPerEpoch()
+	slotsPerEpoch := gc.BeaconConfig().SlotsPerEpoch
 
 	// Lock:
 	// - getting and updating last slot to avoid multiple submission (both should be an atomic action but cannot be done with CAS)
 	// - getting and updating registration cache
 	gc.registrationMu.Lock()
 
 	slotsSinceLastRegistration := currentSlot - gc.registrationLastSlot
-	operatorSubmissionSlotModulo := operatorID % slotsPerEpoch
+	operatorSubmissionSlotModulo := phase0.Slot(operatorID) % (slotsPerEpoch)
 
 	hasRegistrations := len(gc.registrationCache) != 0
-	operatorSubmissionSlot := uint64(currentSlot)%slotsPerEpoch == operatorSubmissionSlotModulo
-	oneEpochPassed := slotsSinceLastRegistration >= phase0.Slot(slotsPerEpoch)
-	twoEpochsAndOperatorDelayPassed := uint64(slotsSinceLastRegistration) >= slotsPerEpoch*2+operatorSubmissionSlotModulo
+	operatorSubmissionSlot := currentSlot%slotsPerEpoch == operatorSubmissionSlotModulo
+	oneEpochPassed := slotsSinceLastRegistration >= slotsPerEpoch
+	twoEpochsAndOperatorDelayPassed := slotsSinceLastRegistration >= slotsPerEpoch*2+operatorSubmissionSlotModulo
 
 	if hasRegistrations && (oneEpochPassed && operatorSubmissionSlot || twoEpochsAndOperatorDelayPassed) {
 		gc.registrationLastSlot = currentSlot