RelayEntry arg support (#208)

* RelayEntry arg support

* send mev-boost version as query arg

Author: metachris

cmd/mev-boost/main.go

@@ -53,6 +53,9 @@ func main() {
 	flag.Parse()
 	logrus.SetOutput(os.Stdout)
 
+	// Set the server version
+	server.Version = version
+
 	if *logJSON {
 		log.Logger.SetFormatter(&logrus.JSONFormatter{})
 	} else {

server/backend.go

@@ -1,5 +1,8 @@
 package server
 
+// Version is used to get the version of the backend. It is set by the cli
+var Version = "dev"
+
 // Router paths
 var (
 	pathStatus            = "/eth/v1/builder/status"

server/relay_entry.go

@@ -8,10 +8,7 @@ import (
 )
 
 // RelayEntry represents a relay that mev-boost connects to.
-// Address will be scheme://hostname:port
-// PublicKey holds the relay's BLS public key used to verify message signatures.
 type RelayEntry struct {
-	Address   string
 	PublicKey types.PublicKey
 	URL       *url.URL
 }
@@ -20,6 +17,14 @@ func (r *RelayEntry) String() string {
 	return r.URL.String()
 }
 
+// GetURI returns the full request URI with scheme, host, path and args.
+func (r *RelayEntry) GetURI(path string) string {
+	u2 := *r.URL
+	u2.User = nil
+	u2.Path = path
+	return u2.String()
+}
+
 // NewRelayEntry creates a new instance based on an input string
 // relayURL can be IP@PORT, PUBKEY@IP:PORT, https://IP, etc.
 func NewRelayEntry(relayURL string) (entry RelayEntry, err error) {
@@ -29,18 +34,20 @@ func NewRelayEntry(relayURL string) (entry RelayEntry, err error) {
 	}
 
 	// Parse the provided relay's URL and save the parsed URL in the RelayEntry.
-	entry.URL, err = url.Parse(relayURL)
+	entry.URL, err = url.ParseRequestURI(relayURL)
 	if err != nil {
 		return entry, err
 	}
 
-	// Build the relay's address.
-	entry.Address = entry.URL.Scheme + "://" + entry.URL.Host
-
 	// Extract the relay's public key from the parsed URL.
 	if entry.URL.User.Username() == "" {
 		return entry, ErrMissingRelayPubkey
 	}
+
+	q := entry.URL.Query()
+	q.Set("boost", Version)
+	entry.URL.RawQuery = q.Encode()
+
 	err = entry.PublicKey.UnmarshalText([]byte(entry.URL.User.Username()))
 	return entry, err
 }

server/relay_entry_test.go

@@ -15,74 +15,72 @@ func TestParseRelaysURLs(t *testing.T) {
 	testCases := []struct {
 		name     string
 		relayURL string
+		path     string
 
 		expectedErr       error
-		expectedAddress   string
+		expectedURI       string // full URI with scheme, host, path and args
 		expectedPublicKey string
 		expectedURL       string
 	}{
 		{
 			name:     "Relay URL with protocol scheme",
 			relayURL: fmt.Sprintf("http://%[email protected]", publicKey.String()),
 
-			expectedErr:       nil,
-			expectedAddress:   "http://foo.com",
+			expectedURI:       "http://foo.com?boost=dev",
 			expectedPublicKey: publicKey.String(),
-			expectedURL:       fmt.Sprintf("http://%[email protected]", publicKey.String()),
+			expectedURL:       fmt.Sprintf("http://%[email protected]?boost=dev", publicKey.String()),
 		},
 		{
 			name:     "Relay URL without protocol scheme, without public key",
 			relayURL: "foo.com",
 
-			expectedErr:       ErrMissingRelayPubkey,
-			expectedAddress:   "",
-			expectedPublicKey: "",
-			expectedURL:       "",
+			expectedErr: ErrMissingRelayPubkey,
 		},
 		{
 			name:     "Relay URL without protocol scheme and with public key",
 			relayURL: publicKey.String() + "@foo.com",
 
-			expectedErr:       nil,
-			expectedAddress:   "http://foo.com",
+			expectedURI:       "http://foo.com?boost=dev",
 			expectedPublicKey: publicKey.String(),
-			expectedURL:       "http://" + publicKey.String() + "@foo.com",
+			expectedURL:       "http://" + publicKey.String() + "@foo.com?boost=dev",
 		},
 		{
 			name:     "Relay URL with public key host and port",
 			relayURL: publicKey.String() + "@foo.com:9999",
 
-			expectedErr:       nil,
-			expectedAddress:   "http://foo.com:9999",
+			expectedURI:       "http://foo.com:9999?boost=dev",
 			expectedPublicKey: publicKey.String(),
-			expectedURL:       "http://" + publicKey.String() + "@foo.com:9999",
+			expectedURL:       "http://" + publicKey.String() + "@foo.com:9999?boost=dev",
 		},
 		{
 			name:     "Relay URL with IP and port",
 			relayURL: publicKey.String() + "@12.345.678:9999",
 
-			expectedErr:       nil,
-			expectedAddress:   "http://12.345.678:9999",
+			expectedURI:       "http://12.345.678:9999?boost=dev",
 			expectedPublicKey: publicKey.String(),
-			expectedURL:       "http://" + publicKey.String() + "@12.345.678:9999",
+			expectedURL:       "http://" + publicKey.String() + "@12.345.678:9999?boost=dev",
 		},
 		{
 			name:     "Relay URL with https IP and port",
 			relayURL: "https://" + publicKey.String() + "@12.345.678:9999",
 
-			expectedErr:       nil,
-			expectedAddress:   "https://12.345.678:9999",
+			expectedURI:       "https://12.345.678:9999?boost=dev",
 			expectedPublicKey: publicKey.String(),
-			expectedURL:       "https://" + publicKey.String() + "@12.345.678:9999",
+			expectedURL:       "https://" + publicKey.String() + "@12.345.678:9999?boost=dev",
 		},
 		{
 			name:     "Invalid relay public key",
 			relayURL: "http://[email protected]",
 
-			expectedErr:       types.ErrLength,
-			expectedAddress:   "",
-			expectedPublicKey: "",
-			expectedURL:       "",
+			expectedErr: types.ErrLength,
+		},
+		{
+			name:     "Relay URL with query arg",
+			relayURL: fmt.Sprintf("http://%[email protected]?id=foo&bar=1", publicKey.String()),
+
+			expectedURI:       "http://foo.com?bar=1&boost=dev&id=foo",
+			expectedPublicKey: publicKey.String(),
+			expectedURL:       fmt.Sprintf("http://%[email protected]?bar=1&boost=dev&id=foo", publicKey.String()),
 		},
 	}
 
@@ -95,7 +93,7 @@ func TestParseRelaysURLs(t *testing.T) {
 
 			// Now perform content assertions.
 			if tt.expectedErr == nil {
-				require.Equal(t, tt.expectedAddress, relayEntry.Address)
+				require.Equal(t, tt.expectedURI, relayEntry.GetURI(tt.path))
 				require.Equal(t, tt.expectedPublicKey, relayEntry.PublicKey.String())
 				require.Equal(t, tt.expectedURL, relayEntry.String())
 			}

server/service.go

@@ -167,11 +167,10 @@ func (m *BoostService) handleStatus(w http.ResponseWriter, req *http.Request) {
 
 		go func(relay RelayEntry) {
 			defer wg.Done()
-
-			log := m.log.WithField("relay", relay.Address)
+			url := relay.GetURI(pathStatus)
+			log := m.log.WithField("url", url)
 			log.Debug("Checking relay status")
 
-			url := relay.Address + pathStatus
 			_, err := SendHTTPRequest(ctx, m.httpClient, http.MethodGet, url, nil, nil)
 			if err != nil && ctx.Err() != context.Canceled {
 				log.WithError(err).Error("failed to retrieve relay status")
@@ -212,9 +211,9 @@ func (m *BoostService) handleRegisterValidator(w http.ResponseWriter, req *http.
 	var wg sync.WaitGroup
 	for _, relay := range m.relays {
 		wg.Add(1)
-		go func(relayAddr string) {
+		go func(relay RelayEntry) {
 			defer wg.Done()
-			url := relayAddr + pathRegisterValidator
+			url := relay.GetURI(pathRegisterValidator)
 			log := log.WithField("url", url)
 
 			_, err := SendHTTPRequest(context.Background(), m.httpClient, http.MethodPost, url, payload, nil)
@@ -226,7 +225,7 @@ func (m *BoostService) handleRegisterValidator(w http.ResponseWriter, req *http.
 			mu.Lock()
 			defer mu.Unlock()
 			numSuccessRequestsToRelay++
-		}(relay.Address)
+		}(relay)
 	}
 
 	// Wait for all requests to complete...
@@ -275,9 +274,10 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 	var wg sync.WaitGroup
 	for _, relay := range m.relays {
 		wg.Add(1)
-		go func(relayAddr string, relayPubKey types.PublicKey) {
+		go func(relay RelayEntry) {
 			defer wg.Done()
-			url := fmt.Sprintf("%s/eth/v1/builder/header/%s/%s/%s", relayAddr, slot, parentHashHex, pubkey)
+			path := fmt.Sprintf("/eth/v1/builder/header/%s/%s/%s", slot, parentHashHex, pubkey)
+			url := relay.GetURI(path)
 			log := log.WithField("url", url)
 			responsePayload := new(types.GetHeaderResponse)
 			code, err := SendHTTPRequest(context.Background(), m.httpClient, http.MethodGet, url, nil, responsePayload)
@@ -304,7 +304,7 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 			})
 
 			// Verify the relay signature in the relay response
-			ok, err := types.VerifySignature(responsePayload.Data.Message, m.builderSigningDomain, relayPubKey[:], responsePayload.Data.Signature[:])
+			ok, err := types.VerifySignature(responsePayload.Data.Message, m.builderSigningDomain, relay.PublicKey[:], responsePayload.Data.Signature[:])
 			if err != nil {
 				log.WithError(err).Error("error verifying relay signature")
 				return
@@ -335,7 +335,7 @@ func (m *BoostService) handleGetHeader(w http.ResponseWriter, req *http.Request)
 			// Use this relay's response as mev-boost response because it's most profitable
 			*result = *responsePayload
 			log.Info("successfully got more valuable payload header")
-		}(relay.Address, relay.PublicKey)
+		}(relay)
 	}
 
 	// Wait for all requests to complete...
@@ -373,10 +373,12 @@ func (m *BoostService) handleGetPayload(w http.ResponseWriter, req *http.Request
 
 	for _, relay := range m.relays {
 		wg.Add(1)
-		go func(relayAddr string) {
+		go func(relay RelayEntry) {
 			defer wg.Done()
-			url := fmt.Sprintf("%s%s", relayAddr, pathGetPayload)
+			url := relay.GetURI(pathGetPayload)
 			log := log.WithField("url", url)
+			log.Debug("calling getPayload")
+
 			responsePayload := new(types.GetPayloadResponse)
 			_, err := SendHTTPRequest(requestCtx, m.httpClient, http.MethodPost, url, payload, responsePayload)
 
@@ -414,7 +416,7 @@ func (m *BoostService) handleGetPayload(w http.ResponseWriter, req *http.Request
 				"blockHash":   responsePayload.Data.BlockHash,
 				"blockNumber": responsePayload.Data.BlockNumber,
 			}).Info("getPayload: received payload from relay")
-		}(relay.Address)
+		}(relay)
 	}
 
 	// Wait for all requests to complete...
@@ -434,7 +436,8 @@ func (m *BoostService) CheckRelays() bool {
 	for _, relay := range m.relays {
 		m.log.WithField("relay", relay).Info("Checking relay")
 
-		_, err := SendHTTPRequest(context.Background(), m.httpClient, http.MethodGet, relay.Address+pathStatus, nil, nil)
+		url := relay.GetURI(pathStatus)
+		_, err := SendHTTPRequest(context.Background(), m.httpClient, http.MethodGet, url, nil, nil)
 		if err != nil {
 			m.log.WithError(err).WithField("relay", relay).Error("relay check failed")
 			return false

server/service_test.go

@@ -8,6 +8,7 @@ import (
 	"math"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"strings"
 	"testing"
 	"time"
@@ -469,7 +470,6 @@ func TestCheckRelays(t *testing.T) {
 	t.Run("At least one relay is okay", func(t *testing.T) {
 		backend := newTestBackend(t, 3, time.Second)
 		status := backend.boost.CheckRelays()
-
 		require.Equal(t, true, status)
 	})
 
@@ -478,7 +478,6 @@ func TestCheckRelays(t *testing.T) {
 		backend.relays[0].Server.Close()
 
 		status := backend.boost.CheckRelays()
-
 		require.Equal(t, false, status)
 	})
 
@@ -489,7 +488,9 @@ func TestCheckRelays(t *testing.T) {
 			http.Redirect(w, r, redirectAddress, http.StatusTemporaryRedirect)
 		}))
 
-		backend.boost.relays[0].Address = backend.relays[0].Server.URL
+		url, err := url.ParseRequestURI(backend.relays[0].Server.URL)
+		require.NoError(t, err)
+		backend.boost.relays[0].URL = url
 		status := backend.boost.CheckRelays()
 		require.Equal(t, false, status)
 	})