ssv-signer support

.gitignore

@@ -39,3 +39,6 @@ bin/
 /scripts/spec_align_report/ssv-spec
 .vscode/
 patches/
+
+go.work
+go.work.sum

beacon/goclient/current_fork.go

@@ -0,0 +1,45 @@
+package goclient
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/attestantio/go-eth2-client/api"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"go.uber.org/zap"
+)
+
+func (gc *GoClient) CurrentFork(ctx context.Context) (*phase0.Fork, error) {
+	start := time.Now()
+	schedule, err := gc.multiClient.ForkSchedule(ctx, &api.ForkScheduleOpts{})
+	recordRequestDuration(gc.ctx, "ForkSchedule", gc.multiClient.Address(), http.MethodGet, time.Since(start), err)
+	if err != nil {
+		gc.log.Error(clResponseErrMsg,
+			zap.String("api", "ForkSchedule"),
+			zap.Error(err),
+		)
+		return nil, err
+	}
+	if schedule.Data == nil {
+		gc.log.Error(clNilResponseForkDataErrMsg,
+			zap.String("api", "ForkSchedule"),
+		)
+		return nil, fmt.Errorf("fork schedule response data is nil")
+	}
+
+	currentEpoch := gc.network.EstimatedCurrentEpoch()
+	var currentFork *phase0.Fork
+	for _, fork := range schedule.Data {
+		if fork.Epoch <= currentEpoch && (currentFork == nil || fork.Epoch > currentFork.Epoch) {
+			currentFork = fork
+		}
+	}
+
+	if currentFork == nil {
+		return nil, fmt.Errorf("could not find current fork")
+	}
+
+	return currentFork, nil
+}

beacon/goclient/current_fork_test.go

@@ -0,0 +1,147 @@
+package goclient
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+
+	"github.com/ssvlabs/ssv-spec/types"
+
+	"github.com/ssvlabs/ssv/beacon/goclient/tests"
+	"github.com/ssvlabs/ssv/protocol/v2/blockchain/beacon"
+)
+
+const forkSchedulePath = "/eth/v1/config/fork_schedule"
+
+func TestCurrentFork(t *testing.T) {
+	ctx := context.Background()
+
+	network := beacon.NewNetwork(types.MainNetwork)
+	currentEpoch := network.EstimatedCurrentEpoch()
+
+	t.Run("success", func(t *testing.T) {
+		mockServer := tests.MockServer(t, func(r *http.Request, resp json.RawMessage) (json.RawMessage, error) {
+			if r.URL.Path == forkSchedulePath {
+				return json.RawMessage(`{
+					"data": [
+						{
+							"previous_version": "0x00010203",
+							"current_version": "0x04050607",
+							"epoch": "` + fmt.Sprint(currentEpoch-100) + `"
+						},
+						{
+							"previous_version": "0x04050607",
+							"current_version": "0x08090a0b",
+							"epoch": "` + fmt.Sprint(currentEpoch-50) + `"
+						},
+						{
+							"previous_version": "0x08090a0b",
+							"current_version": "0x0c0d0e0f",
+							"epoch": "` + fmt.Sprint(currentEpoch+100) + `"
+						}
+					]
+				}`), nil
+			}
+			return resp, nil
+		})
+		defer mockServer.Close()
+
+		client, err := New(
+			zap.NewNop(),
+			beacon.Options{
+				Context:        ctx,
+				Network:        network,
+				BeaconNodeAddr: mockServer.URL,
+				CommonTimeout:  100 * time.Millisecond,
+				LongTimeout:    500 * time.Millisecond,
+			},
+			tests.MockDataStore{},
+			tests.MockSlotTickerProvider,
+		)
+		require.NoError(t, err)
+
+		currentFork, err := client.CurrentFork(ctx)
+		require.NoError(t, err)
+		require.NotNil(t, currentFork)
+
+		require.Equal(t, currentEpoch-50, currentFork.Epoch)
+		require.Equal(t, phase0.Version{0x04, 0x05, 0x06, 0x07}, currentFork.PreviousVersion)
+		require.Equal(t, phase0.Version{0x08, 0x09, 0x0a, 0x0b}, currentFork.CurrentVersion)
+	})
+
+	t.Run("nil_data", func(t *testing.T) {
+		mockServer := tests.MockServer(t, func(r *http.Request, resp json.RawMessage) (json.RawMessage, error) {
+			if r.URL.Path == forkSchedulePath {
+				return json.RawMessage(`{"data": null}`), nil
+			}
+			return resp, nil
+		})
+		defer mockServer.Close()
+
+		client, err := New(
+			zap.NewNop(),
+			beacon.Options{
+				Context:        ctx,
+				Network:        network,
+				BeaconNodeAddr: mockServer.URL,
+				CommonTimeout:  100 * time.Millisecond,
+				LongTimeout:    500 * time.Millisecond,
+			},
+			tests.MockDataStore{},
+			tests.MockSlotTickerProvider,
+		)
+		require.NoError(t, err)
+
+		_, err = client.CurrentFork(ctx)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "fork schedule response data is nil")
+	})
+
+	t.Run("no_current_fork", func(t *testing.T) {
+		mockServer := tests.MockServer(t, func(r *http.Request, resp json.RawMessage) (json.RawMessage, error) {
+			if r.URL.Path == forkSchedulePath {
+				return json.RawMessage(`{
+					"data": [
+						{
+							"previous_version": "0x00010203",
+							"current_version": "0x04050607",
+							"epoch": "` + fmt.Sprint(currentEpoch+100) + `"
+						},
+						{
+							"previous_version": "0x04050607",
+							"current_version": "0x08090a0b",
+							"epoch": "` + fmt.Sprint(currentEpoch+200) + `"
+						}
+					]
+				}`), nil
+			}
+			return resp, nil
+		})
+		defer mockServer.Close()
+
+		client, err := New(
+			zap.NewNop(),
+			beacon.Options{
+				Context:        ctx,
+				Network:        network,
+				BeaconNodeAddr: mockServer.URL,
+				CommonTimeout:  100 * time.Millisecond,
+				LongTimeout:    500 * time.Millisecond,
+			},
+			tests.MockDataStore{},
+			tests.MockSlotTickerProvider,
+		)
+		require.NoError(t, err)
+
+		_, err = client.CurrentFork(ctx)
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "could not find current fork")
+	})
+}

beacon/goclient/dataversion.go

@@ -3,7 +3,6 @@ package goclient
 import (
 	"fmt"
 
-	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 )
@@ -25,14 +24,11 @@ func (gc *GoClient) DataVersion(epoch phase0.Epoch) spec.DataVersion {
 	return spec.DataVersionElectra
 }
 
-func (gc *GoClient) checkForkValues(specResponse *api.Response[map[string]any]) error {
+func (gc *GoClient) checkForkValues(specResponse map[string]any) error {
 	// Validate the response.
 	if specResponse == nil {
 		return fmt.Errorf("spec response is nil")
 	}
-	if specResponse.Data == nil {
-		return fmt.Errorf("spec response data is nil")
-	}
 
 	// Lock the fork values to ensure atomic read and update.
 	gc.ForkLock.Lock()
@@ -47,7 +43,7 @@ func (gc *GoClient) checkForkValues(specResponse *api.Response[map[string]any])
 	// If the candidate is greater than the current value, that's an error.
 	// Otherwise, it returns the lower value (or the candidate if the current value is zero).
 	processFork := func(forkName, key string, current phase0.Epoch, required bool) (phase0.Epoch, error) {
-		raw, ok := specResponse.Data[key]
+		raw, ok := specResponse[key]
 		if !ok {
 			if required {
 				return 0, fmt.Errorf("%s fork epoch not known by chain", forkName)

beacon/goclient/dataversion_test.go

@@ -4,7 +4,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 )
@@ -54,7 +53,7 @@ func TestCheckForkValues(t *testing.T) {
 		initialAltair, initialBellatrix, initialCapella,
 		initialDeneb, initialElectra phase0.Epoch
 		// input response and expected outcomes
-		response    *api.Response[map[string]any]
+		response    map[string]any
 		expectedErr string
 		expectedAltair, expectedBellatrix, expectedCapella,
 		expectedDeneb, expectedElectra phase0.Epoch
@@ -65,11 +64,9 @@ func TestCheckForkValues(t *testing.T) {
 			expectedErr: "spec response is nil",
 		},
 		{
-			name: "nil data",
-			response: &api.Response[map[string]any]{
-				Data: nil,
-			},
-			expectedErr: "spec response data is nil",
+			name:        "nil data",
+			response:    nil,
+			expectedErr: "spec response is nil",
 		},
 		{
 			name:             "missing ALTAIR",
@@ -78,12 +75,10 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   FarFutureEpoch,
 			initialDeneb:     FarFutureEpoch,
 			initialElectra:   FarFutureEpoch,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-				},
+			response: map[string]any{
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
 			},
 			expectedErr: "ALTAIR fork epoch not known by chain",
 		},
@@ -94,13 +89,11 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   FarFutureEpoch,
 			initialDeneb:     FarFutureEpoch,
 			initialElectra:   FarFutureEpoch,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"ALTAIR_FORK_EPOCH":    "not a uint",
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-				},
+			response: map[string]any{
+				"ALTAIR_FORK_EPOCH":    "not a uint",
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
 			},
 			expectedErr: "failed to decode ALTAIR fork epoch",
 		},
@@ -111,14 +104,12 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   FarFutureEpoch,
 			initialDeneb:     FarFutureEpoch,
 			initialElectra:   FarFutureEpoch,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"ALTAIR_FORK_EPOCH":    uint64(10),
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-					"ELECTRA_FORK_EPOCH":   uint64(50),
-				},
+			response: map[string]any{
+				"ALTAIR_FORK_EPOCH":    uint64(10),
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
+				"ELECTRA_FORK_EPOCH":   uint64(50),
 			},
 			expectedAltair:    phase0.Epoch(10),
 			expectedBellatrix: phase0.Epoch(20),
@@ -133,13 +124,11 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   FarFutureEpoch,
 			initialDeneb:     FarFutureEpoch,
 			initialElectra:   FarFutureEpoch,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"ALTAIR_FORK_EPOCH":    uint64(10),
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-				},
+			response: map[string]any{
+				"ALTAIR_FORK_EPOCH":    uint64(10),
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
 			},
 			expectedAltair:    phase0.Epoch(10),
 			expectedBellatrix: phase0.Epoch(20),
@@ -154,14 +143,12 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   30,
 			initialDeneb:     40,
 			initialElectra:   99,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"ALTAIR_FORK_EPOCH":    uint64(10),
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-					"ELECTRA_FORK_EPOCH":   uint64(50),
-				},
+			response: map[string]any{
+				"ALTAIR_FORK_EPOCH":    uint64(10),
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
+				"ELECTRA_FORK_EPOCH":   uint64(50),
 			},
 			expectedAltair:    phase0.Epoch(10),
 			expectedBellatrix: phase0.Epoch(20),
@@ -177,14 +164,12 @@ func TestCheckForkValues(t *testing.T) {
 			initialCapella:   30,
 			initialDeneb:     40,
 			initialElectra:   50,
-			response: &api.Response[map[string]any]{
-				Data: map[string]any{
-					"ALTAIR_FORK_EPOCH":    uint64(10),
-					"BELLATRIX_FORK_EPOCH": uint64(20),
-					"CAPELLA_FORK_EPOCH":   uint64(30),
-					"DENEB_FORK_EPOCH":     uint64(40),
-					"ELECTRA_FORK_EPOCH":   uint64(60),
-				},
+			response: map[string]any{
+				"ALTAIR_FORK_EPOCH":    uint64(10),
+				"BELLATRIX_FORK_EPOCH": uint64(20),
+				"CAPELLA_FORK_EPOCH":   uint64(30),
+				"DENEB_FORK_EPOCH":     uint64(40),
+				"ELECTRA_FORK_EPOCH":   uint64(60),
 			},
 			expectedErr: "new ELECTRA fork epoch (60) doesn't match current value (50)",
 		},