[CAPPL-19] Gateway Connector service wrapper

core/capabilities/gateway_connector/service_wrapper.go

@@ -0,0 +1,151 @@
+package gatewayconnector
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"errors"
+	"math/big"
+	"slices"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/jonboulle/clockwork"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/services"
+	"github.com/smartcontractkit/chainlink/v2/core/config"
+	"github.com/smartcontractkit/chainlink/v2/core/logger"
+	"github.com/smartcontractkit/chainlink/v2/core/services/gateway/api"
+	gwCommon "github.com/smartcontractkit/chainlink/v2/core/services/gateway/common"
+	"github.com/smartcontractkit/chainlink/v2/core/services/gateway/connector"
+	"github.com/smartcontractkit/chainlink/v2/core/services/gateway/network"
+	"github.com/smartcontractkit/chainlink/v2/core/services/keystore"
+	"github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey"
+)
+
+type serviceWrapper struct {
+	services.StateMachine
+
+	config    *config.GatewayConnector
+	keystore  keystore.Eth
+	connector connector.GatewayConnector
+	lggr      logger.Logger
+}
+
+type connectorSigner struct {
+	services.StateMachine
+
+	connector   connector.GatewayConnector
+	signerKey   *ecdsa.PrivateKey
+	nodeAddress string
+	lggr        logger.Logger
+}
+
+var _ connector.Signer = &connectorSigner{}
+
+func NewConnectorSigner(config *config.GatewayConnector, signerKey *ecdsa.PrivateKey, lggr logger.Logger) (*connectorSigner, error) {
+	return &connectorSigner{
+		nodeAddress: (*config).NodeAddress(),
+		signerKey:   signerKey,
+		lggr:        lggr.Named("ConnectorSigner"),
+	}, nil
+}
+
+func (h *connectorSigner) Sign(data ...[]byte) ([]byte, error) {
+	return gwCommon.SignData(h.signerKey, data...)
+}
+
+func (h *connectorSigner) HandleGatewayMessage(ctx context.Context, gatewayID string, msg *api.Message) {
+}
+func (h *connectorSigner) Start(ctx context.Context) error {
+	return h.StartOnce("ConnectorSigner", func() error {
+		return nil
+	})
+}
+func (h *connectorSigner) Close() error {
+	return h.StopOnce("ConnectorSigner", func() (err error) {
+		return nil
+	})
+}
+
+func (h *connectorSigner) SetConnector(connector connector.GatewayConnector) {
+	h.connector = connector
+}
+
+func translateConfigs(f config.GatewayConnector) connector.ConnectorConfig {
+	r := connector.ConnectorConfig{}
+	r.NodeAddress = f.NodeAddress()
+	r.DonId = f.DonID()
+
+	if len(f.Gateways()) != 0 {
+		r.Gateways = make([]connector.ConnectorGatewayConfig, len(f.Gateways()))
+		for index, element := range f.Gateways() {
+			r.Gateways[index] = connector.ConnectorGatewayConfig{Id: element.ID(), URL: element.URL()}
+		}
+	}
+
+	r.WsClientConfig = network.WebSocketClientConfig{HandshakeTimeoutMillis: f.WSHandshakeTimeoutMillis()}
+	r.AuthMinChallengeLen = f.AuthMinChallengeLen()
+	r.AuthTimestampToleranceSec = f.AuthTimestampToleranceSec()
+	return r
+}
+
+// NOTE: this wrapper is needed to make sure that our services are started after Keystore.
+func NewGatewayConnectorServiceWrapper(config *config.GatewayConnector, keystore keystore.Eth, lggr logger.Logger) *serviceWrapper {
+	return &serviceWrapper{
+		config:   config,
+		keystore: keystore,
+		lggr:     lggr,
+	}
+}
+
+func (e *serviceWrapper) Start(ctx context.Context) error {
+	return e.StartOnce("GatewayConnectorServiceWrapper", func() error {
+		conf := *e.config
+		e.lggr.Infow("Starting GatewayConnectorServiceWrapper", "chainID", conf.ChainIDForNodeKey())
+		chainID, _ := new(big.Int).SetString(conf.ChainIDForNodeKey(), 0)
+		enabledKeys, err := e.keystore.EnabledKeysForChain(ctx, chainID)
+		if err != nil {
+			return err
+		}
+		if len(enabledKeys) == 0 {
+			return errors.New("no available keys found")
+		}
+		configuredNodeAddress := common.HexToAddress(conf.NodeAddress())
+		idx := slices.IndexFunc(enabledKeys, func(key ethkey.KeyV2) bool { return key.Address == configuredNodeAddress })
+		if idx == -1 {
+			return errors.New("key for configured node address not found")
+		}
+		signerKey := enabledKeys[idx].ToEcdsaPrivKey()
+		if enabledKeys[idx].ID() != conf.NodeAddress() {
+			return errors.New("node address mismatch")
+		}
+
+		signer, err := NewConnectorSigner(e.config, signerKey, e.lggr)
+		if err != nil {
+			return err
+		}
+		translated := translateConfigs(conf)
+		e.connector, err = connector.NewGatewayConnector(&translated, signer, clockwork.NewRealClock(), e.lggr)
+		if err != nil {
+			return err
+		}
+		return e.connector.Start(ctx)
+	})
+}
+
+func (e *serviceWrapper) Close() error {
+	return e.StopOnce("GatewayConnectorServiceWrapper", func() (err error) {
+		return e.connector.Close()
+	})
+}
+
+func (e *serviceWrapper) Ready() error {
+	return nil
+}
+
+func (e *serviceWrapper) HealthReport() map[string]error {
+	return nil
+}
+
+func (e *serviceWrapper) Name() string {
+	return "GatewayConnectorServiceWrapper"
+}

core/capabilities/gateway_connector/service_wrapper_test.go

@@ -0,0 +1,98 @@
+package gatewayconnector
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/smartcontractkit/chainlink/v2/core/config/toml"
+	"github.com/smartcontractkit/chainlink/v2/core/internal/testutils"
+	"github.com/smartcontractkit/chainlink/v2/core/logger"
+	chainlink "github.com/smartcontractkit/chainlink/v2/core/services/chainlink"
+	"github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey"
+	ksmocks "github.com/smartcontractkit/chainlink/v2/core/services/keystore/mocks"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/test-go/testify/mock"
+)
+
+func generateConfig(addr common.Address) (chainlink.GeneralConfig, error) {
+	return chainlink.GeneralConfigOpts{
+		Config: chainlink.Config{
+			Core: toml.Core{
+				Capabilities: toml.Capabilities{
+					GatewayConnector: toml.GatewayConnector{
+						ChainIDForNodeKey:         ptr("1"),
+						NodeAddress:               ptr(addr.Hex()),
+						DonID:                     ptr("5"),
+						WSHandshakeTimeoutMillis:  ptr[uint32](100),
+						AuthMinChallengeLen:       ptr[int](0),
+						AuthTimestampToleranceSec: ptr[uint32](10),
+						Gateways:                  []toml.ConnectorGateway{{ID: ptr("example_gateway"), URL: ptr("wss://localhost:8081/node")}},
+					},
+				},
+			},
+		},
+	}.New()
+}
+
+// Unit test that creates the ServiceWrapper object and then calls Start() can Close() on it.
+// Take inspiration from functions/plugin_test.go and functions/connector_handler_test.go on how to mock the dependencies.
+//
+// Test valid NodeAddress and an invalid one (i.e. key doesn't exit).
+
+func TestGatewayConnectorServiceWrapper(t *testing.T) {
+	t.Parallel()
+
+	logger := logger.TestLogger(t)
+	_, addr := testutils.NewPrivateKeyAndAddress(t)
+
+	config, err := generateConfig(addr)
+	ethKeystore := ksmocks.NewEth(t)
+	ethKeystore.On("EnabledKeysForChain", mock.Anything).Return([]ethkey.KeyV2{{Address: addr}})
+
+	gc := config.Capabilities().GatewayConnector()
+	handler := NewGatewayConnectorServiceWrapper(&gc, ethKeystore, logger)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		assert.NoError(t, handler.Close())
+	})
+
+	t.Run("Start & Stop Success", func(t *testing.T) {
+		ctx := testutils.Context(t)
+
+		err := handler.Start(ctx)
+		require.NoError(t, err)
+		err = handler.Close()
+		require.NoError(t, err)
+	})
+}
+
+func TestGatewayConnectorServiceWrapperConfigError(t *testing.T) {
+	t.Parallel()
+
+	logger := logger.TestLogger(t)
+	_, addr := testutils.NewPrivateKeyAndAddress(t)
+
+	config, err := generateConfig(addr)
+	ethKeystore := ksmocks.NewEth(t)
+	_, addr2 := testutils.NewPrivateKeyAndAddress(t)
+
+	ethKeystore.On("EnabledKeysForChain", mock.Anything).Return([]ethkey.KeyV2{{Address: addr2}})
+
+	gc := config.Capabilities().GatewayConnector()
+	handler := NewGatewayConnectorServiceWrapper(&gc, ethKeystore, logger)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		assert.NoError(t, handler.Close())
+	})
+
+	t.Run("Start Error", func(t *testing.T) {
+		ctx := testutils.Context(t)
+		err := handler.Start(ctx)
+		require.Error(t, err)
+	})
+}
+
+func ptr[T any](t T) *T { return &t }