Merge 0fb9f21 into 73e0481

Author: JulianVentura

contracts/lib/eigenlayer-middleware

@@ -33,6 +33,8 @@ type BaseConfig struct {
 	EthRpcClientFallback         eth.InstrumentedClient
 	EthWsClient                  eth.InstrumentedClient
 	EthWsClientFallback          eth.InstrumentedClient
+	EthRpcUrlFallback            string
+	EthWsUrlFallback             string
 	EigenMetricsIpPortAddress    string
 	ChainId                      *big.Int
 }
@@ -149,6 +151,8 @@ func NewBaseConfig(configFilePath string) *BaseConfig {
 		EthRpcClientFallback:         *ethRpcClientFallback,
 		EthWsClient:                  *ethWsClient,
 		EthWsClientFallback:          *ethWsClientFallback,
+		EthRpcUrlFallback:            baseConfigFromYaml.EthRpcUrlFallback,
+		EthWsUrlFallback:             baseConfigFromYaml.EthWsUrlFallback,
 		EigenMetricsIpPortAddress:    baseConfigFromYaml.EigenMetricsIpPortAddress,
 		ChainId:                      chainId,
 	}

core/config/base.go

@@ -26,19 +26,7 @@ var StartCommand = &cli.Command{
 	Action:      operatorMain,
 }
 
-func operatorMain(ctx *cli.Context) error {
-	operatorConfigFilePath := ctx.String("config")
-	operatorConfig := config.NewOperatorConfig(operatorConfigFilePath)
-	err := sdkutils.ReadYamlConfig(operatorConfigFilePath, &operatorConfig)
-	if err != nil {
-		return err
-	}
-
-	operator, err := operator.NewOperatorFromConfig(*operatorConfig)
-	if err != nil {
-		return err
-	}
-
+func updateTelemetryService(operator *operator.Operator, ctx *cli.Context, operatorConfig *config.OperatorConfig) error {
 	// hash version
 	hash := sha3.NewLegacyKeccak256()
 	hash.Write([]byte(ctx.App.Version))
@@ -51,11 +39,32 @@ func operatorMain(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
+	ethRpcUrl, err := baseUrlOnly(operatorConfig.BaseConfig.EthRpcUrl)
+	if err != nil {
+		return err
+	}
+	ethRpcUrlFallback, err := baseUrlOnly(operatorConfig.BaseConfig.EthRpcUrlFallback)
+	if err != nil {
+		return err
+	}
+	ethWsUrl, err := baseUrlOnly(operatorConfig.BaseConfig.EthWsUrl)
+	if err != nil {
+		return err
+	}
+	ethWsUrlFallback, err := baseUrlOnly(operatorConfig.BaseConfig.EthWsUrlFallback)
+	if err != nil {
+		return err
+	}
 
 	body := map[string]interface{}{
-		"version":   ctx.App.Version,
-		"signature": signature,
+		"version":              ctx.App.Version,
+		"signature":            signature,
+		"eth_rpc_url":          ethRpcUrl,
+		"eth_rpc_url_fallback": ethRpcUrlFallback,
+		"eth_ws_url":           ethWsUrl,
+		"eth_ws_url_fallback":  ethWsUrlFallback,
 	}
+
 	bodyBuffer := new(bytes.Buffer)
 
 	bodyReader := json.NewEncoder(bodyBuffer)
@@ -68,15 +77,35 @@ func operatorMain(ctx *cli.Context) error {
 	endpoint := operatorConfig.Operator.OperatorTrackerIpPortAddress + "/versions"
 	operator.Logger.Info("Sending version to operator tracker server: ", "endpoint", endpoint)
 
-	res, err := http.Post(endpoint, "application/json",
-		bodyBuffer)
+	res, err := http.Post(endpoint, "application/json", bodyBuffer)
 	if err != nil {
 		// Dont prevent operator from starting if operator tracker server is down
 		operator.Logger.Warn("Error sending version to metrics server: ", "err", err)
 	} else if res.StatusCode != http.StatusCreated && res.StatusCode != http.StatusNoContent {
 		operator.Logger.Warn("Error sending version to operator tracker server: ", "status_code", res.StatusCode)
 	}
 
+	return nil
+}
+
+func operatorMain(ctx *cli.Context) error {
+	operatorConfigFilePath := ctx.String("config")
+	operatorConfig := config.NewOperatorConfig(operatorConfigFilePath)
+	err := sdkutils.ReadYamlConfig(operatorConfigFilePath, &operatorConfig)
+	if err != nil {
+		return err
+	}
+
+	operator, err := operator.NewOperatorFromConfig(*operatorConfig)
+	if err != nil {
+		return err
+	}
+
+	err = updateTelemetryService(operator, ctx, operatorConfig)
+	if err != nil {
+		return err
+	}
+
 	operator.Logger.Info("Operator starting...")
 	err = operator.Start(context.Background())
 	if err != nil {

operator/cmd/actions/start.go

@@ -0,0 +1,17 @@
+package actions
+
+import (
+	"errors"
+	"regexp"
+)
+
+func baseUrlOnly(url string) (string, error) {
+	// Removes the protocol and api key part from any url formated like so:
+	// "<protocol>://<base_url>/<api_key>"
+	regex := regexp.MustCompile(`^[a-z]+://([^/]+)`)
+	match := regex.FindStringSubmatch(url)
+	if len(match) > 1 {
+		return match[1], nil
+	}
+	return "", errors.New("Url did not match the expected format <protocol>://<base_url>/<api_key>")
+}

operator/cmd/actions/utils.go

@@ -0,0 +1,46 @@
+package actions
+
+import (
+	"testing"
+)
+
+func TestBaseUrlOnlyHappyPath(t *testing.T) {
+	// Format "<protocol>://<base_url>/<api_key>"
+
+	urls := [...][2]string{
+		{"http://localhost:8545/asdfoij2a7831has89%342jddav98j2748", "localhost:8545"},
+		{"ws://test.com/23r2f98hkjva0udhvi1j%342jddav98j2748", "test.com"},
+		{"http://localhost:8545", "localhost:8545"},
+	}
+
+	for _, pair := range urls {
+		url := pair[0]
+		expectedBaseUrl := pair[1]
+
+		baseUrl, err := baseUrlOnly(url)
+
+		if err != nil {
+			t.Errorf("Unexpected error for URL %s: %v", url, err)
+		}
+
+		if baseUrl != expectedBaseUrl {
+			t.Errorf("Expected base URL %s, got %s for URL %s", expectedBaseUrl, baseUrl, url)
+		}
+	}
+}
+
+func TestBaseUrlOnlyFailureCases(t *testing.T) {
+
+	urls := [...]string{
+		"localhost:8545/asdfoij2a7831has89%342jddav98j2748",
+		"this-is-all-wrong",
+	}
+
+	for _, url := range urls {
+		baseUrl, err := baseUrlOnly(url)
+
+		if err == nil {
+			t.Errorf("An error was expected, but received %s", baseUrl)
+		}
+	}
+}

operator/cmd/actions/utils_test.go

@@ -116,21 +116,16 @@ defmodule TelemetryApi.Operators do
 
   ## Examples
 
-      iex> update_operator_version(%{field: value})
+      iex> update_operator(%{field: value})
       {:ok, %Ecto.Changeset{}}
 
       iex> update_operator_version(%{field: bad_value})
       {:error, "Some status", "Some message"}
 
   """
-  def update_operator_version(%{"version" => version, "signature" => signature}) do
+  def update_operator(version, signature, changes) do
     with {:ok, address} <- SignatureVerifier.recover_address(version, signature) do
       address = "0x" <> address
-      # We only want to allow changes on version
-      changes = %{
-        version: version
-      }
-
       case Repo.get(Operator, address) do
         nil ->
           {:error, :bad_request,
@@ -142,24 +137,6 @@ defmodule TelemetryApi.Operators do
     end
   end
 
-  @doc """
-  Updates a operator.
-
-  ## Examples
-
-      iex> update_operator(operator, %{field: new_value})
-      {:ok, %Operator{}}
-
-      iex> update_operator(operator, %{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def update_operator(%Operator{} = operator, attrs) do
-    operator
-    |> Operator.changeset(attrs)
-    |> Repo.update()
-  end
-
   @doc """
   Deletes a operator.
 

telemetry_api/lib/telemetry_api/operators.ex

@@ -8,14 +8,28 @@ defmodule TelemetryApi.Operators.Operator do
     field :stake, :string
     field :name, :string
     field :version, :string
+    field :eth_rpc_url, :string
+    field :eth_rpc_url_fallback, :string
+    field :eth_ws_url, :string
+    field :eth_ws_url_fallback, :string
 
     timestamps(type: :utc_datetime)
   end
 
   @doc false
   def changeset(operator, attrs) do
     operator
-    |> cast(attrs, [:address, :id, :stake, :name, :version])
+    |> cast(attrs, [
+      :address,
+      :id,
+      :stake,
+      :name,
+      :version,
+      :eth_rpc_url,
+      :eth_rpc_url_fallback,
+      :eth_ws_url,
+      :eth_ws_url_fallback
+    ])
     |> validate_required([:address, :id, :name, :stake])
   end
 end

telemetry_api/lib/telemetry_api/operators/operator.ex

@@ -1,4 +1,6 @@
 defmodule TelemetryApi.Utils do
+  use TelemetryApiWeb, :controller
+
   @moduledoc """
   Some utility functions
   """
@@ -50,4 +52,15 @@ defmodule TelemetryApi.Utils do
         {:error, error_message}
     end
   end
+
+
+  @doc """
+  Returns json encoded error using http
+  """
+  def return_error(conn, message) do
+    conn
+      |> put_status(:bad_request)
+      |> put_resp_content_type("application/json")
+      |> send_resp(:bad_request, Jason.encode!(%{error: message}))
+  end
 end

telemetry_api/lib/telemetry_api/utils.ex

@@ -2,6 +2,7 @@ defmodule TelemetryApiWeb.OperatorController do
   use TelemetryApiWeb, :controller
 
   alias TelemetryApi.Operators
+  alias TelemetryApi.Utils
   alias TelemetryApi.Operators.Operator
 
   action_fallback(TelemetryApiWeb.FallbackController)
@@ -11,8 +12,8 @@ defmodule TelemetryApiWeb.OperatorController do
     render(conn, :index, operators: operators)
   end
 
-  def create_or_update(conn, operator_params) do
-    with {:ok, %Operator{} = operator} <- Operators.update_operator_version(operator_params) do
+  def create_or_update(conn, %{"version" => version, "signature" => signature} = attrs) do
+    with {:ok, %Operator{} = operator} <- Operators.update_operator(version, signature, attrs) do
       conn
       |> put_status(:created)
       |> put_resp_header("location", ~p"/api/operators/#{operator}")

telemetry_api/lib/telemetry_api_web/controllers/operator_controller.ex

@@ -21,7 +21,11 @@ defmodule TelemetryApiWeb.OperatorJSON do
       id: operator.id,
       stake: operator.stake,
       name: operator.name,
-      version: operator.version
+      version: operator.version,
+      eth_rpc_url: operator.eth_rpc_url,
+      eth_rpc_url_fallback: operator.eth_rpc_url_fallback,
+      eth_ws_url: operator.eth_ws_url,
+      eth_ws_url_fallback: operator.eth_ws_url_fallback
     }
   end
 end