eip-8160: add engine_exchangeCapabilitiesV2 with supportedProtocols

Implements the updated EIP-8160 spec where communication channels are
returned as part of engine_exchangeCapabilitiesV2 instead of a separate
engine_getClientCommunicationChannelsV1 method. The V2 response includes
both capabilities and supportedProtocols fields.

The old GetClientCommunicationChannelsV1 method is kept for backward
compatibility but now delegates to the shared getSupportedProtocols().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Giulio2002

execution/engineapi/engine_api_jsonrpc_client.go

@@ -407,6 +407,11 @@ func (c *JsonRpcClient) GetClientCommunicationChannelsV1(ctx context.Context) ([
 	}, c.backOff(ctx))
 }
 
+func (c *JsonRpcClient) ExchangeCapabilitiesV2(fromCl []string) *enginetypes.ExchangeCapabilitiesV2Response {
+	// JSON-RPC client doesn't implement V2 directly; the server-side handles this.
+	return nil
+}
+
 func (c *JsonRpcClient) backOff(ctx context.Context) backoff.BackOff {
 	var backOff backoff.BackOff
 	backOff = backoff.NewConstantBackOff(c.retryBackOff)

execution/engineapi/engine_api_methods.go

@@ -55,6 +55,7 @@ var ourCapabilities = []string{
 	"engine_getBlobsV2",
 	"engine_getBlobsV3",
 	"engine_getClientCommunicationChannelsV1",
+	"engine_exchangeCapabilitiesV2",
 }
 
 // Returns the most recent version of the payload(for the payloadID) at the time of receiving the call
@@ -248,6 +249,46 @@ func (e *EngineServer) ExchangeCapabilities(fromCl []string) []string {
 	return ourCapabilities
 }
 
+// ExchangeCapabilitiesV2 extends ExchangeCapabilities with supportedProtocols (EIP-8160).
+func (e *EngineServer) ExchangeCapabilitiesV2(fromCl []string) *engine_types.ExchangeCapabilitiesV2Response {
+	capabilities := e.ExchangeCapabilities(fromCl)
+	return &engine_types.ExchangeCapabilitiesV2Response{
+		Capabilities:       capabilities,
+		SupportedProtocols: e.getSupportedProtocols(),
+	}
+}
+
+// getSupportedProtocols returns the list of communication protocols supported by the EL.
+func (e *EngineServer) getSupportedProtocols() []engine_types.CommunicationChannel {
+	addr := "localhost"
+	port := 8551
+	if e.httpConfig != nil {
+		if e.httpConfig.AuthRpcHTTPListenAddress != "" {
+			addr = e.httpConfig.AuthRpcHTTPListenAddress
+		}
+		if e.httpConfig.AuthRpcPort != 0 {
+			port = e.httpConfig.AuthRpcPort
+		}
+	}
+
+	channels := []engine_types.CommunicationChannel{
+		{
+			Protocol: "json_rpc",
+			URL:      fmt.Sprintf("%s:%d", addr, port),
+		},
+	}
+
+	// EIP-8161: Advertise the SSZ-REST channel if the server is running
+	if e.httpConfig != nil && e.httpConfig.SszRestEnabled && e.sszRestPort > 0 {
+		channels = append(channels, engine_types.CommunicationChannel{
+			Protocol: "ssz_rest",
+			URL:      fmt.Sprintf("http://%s:%d", addr, e.sszRestPort),
+		})
+	}
+
+	return channels
+}
+
 func (e *EngineServer) GetBlobsV1(ctx context.Context, blobHashes []common.Hash) ([]*engine_types.BlobAndProofV1, error) {
 	e.logger.Debug("[GetBlobsV1] Received Request", "hashes", len(blobHashes))
 	resp, err := e.getBlobs(ctx, blobHashes, clparams.DenebVersion)
@@ -287,35 +328,8 @@ func (e *EngineServer) GetBlobsV3(ctx context.Context, blobHashes []common.Hash)
 }
 
 // GetClientCommunicationChannelsV1 returns the communication protocols and endpoints supported by the EL.
-// See EIP-8160 and EIP-8161
+// Deprecated: Use ExchangeCapabilitiesV2 instead. Kept for backward compatibility.
 func (e *EngineServer) GetClientCommunicationChannelsV1(ctx context.Context) ([]engine_types.CommunicationChannel, error) {
 	e.engineLogSpamer.RecordRequest()
-
-	addr := "localhost"
-	port := 8551
-	if e.httpConfig != nil {
-		if e.httpConfig.AuthRpcHTTPListenAddress != "" {
-			addr = e.httpConfig.AuthRpcHTTPListenAddress
-		}
-		if e.httpConfig.AuthRpcPort != 0 {
-			port = e.httpConfig.AuthRpcPort
-		}
-	}
-
-	channels := []engine_types.CommunicationChannel{
-		{
-			Protocol: "json_rpc",
-			URL:      fmt.Sprintf("%s:%d", addr, port),
-		},
-	}
-
-	// EIP-8161: Advertise the SSZ-REST channel if the server is running
-	if e.httpConfig != nil && e.httpConfig.SszRestEnabled && e.sszRestPort > 0 {
-		channels = append(channels, engine_types.CommunicationChannel{
-			Protocol: "ssz_rest",
-			URL:      fmt.Sprintf("http://%s:%d", addr, e.sszRestPort),
-		})
-	}
-
-	return channels, nil
+	return e.getSupportedProtocols(), nil
 }

execution/engineapi/engine_ssz_rest_server.go

@@ -163,8 +163,11 @@ func (s *SszRestServer) registerRoutes(mux *http.ServeMux) {
 	// getClientVersion
 	mux.HandleFunc("POST /engine/v1/get_client_version", s.handleGetClientVersion)
 
-	// getClientCommunicationChannels
+	// getClientCommunicationChannels (deprecated, kept for backward compat)
 	mux.HandleFunc("POST /engine/v1/get_client_communication_channels", s.handleGetClientCommunicationChannels)
+
+	// exchangeCapabilitiesV2 (EIP-8160)
+	mux.HandleFunc("POST /engine/v2/exchange_capabilities", s.handleExchangeCapabilitiesV2)
 }
 
 // readBody reads the request body with a size limit.
@@ -610,6 +613,40 @@ func (s *SszRestServer) handleGetClientVersion(w http.ResponseWriter, r *http.Re
 	sszResponse(w, engine_types.EncodeClientVersions(result))
 }
 
+// --- exchangeCapabilitiesV2 handler (EIP-8160) ---
+
+func (s *SszRestServer) handleExchangeCapabilitiesV2(w http.ResponseWriter, r *http.Request) {
+	s.logger.Info("[SSZ-REST] Received ExchangeCapabilitiesV2")
+
+	body, err := readBody(r, 1024*1024)
+	if err != nil {
+		sszErrorResponse(w, http.StatusBadRequest, -32602, "failed to read request body")
+		return
+	}
+
+	capabilities, err := engine_types.DecodeCapabilities(body)
+	if err != nil {
+		sszErrorResponse(w, http.StatusBadRequest, -32602, err.Error())
+		return
+	}
+
+	result := s.engine.ExchangeCapabilitiesV2(capabilities)
+	// Encode as: capabilities SSZ + communication channels SSZ appended
+	// For simplicity, use the same capabilities encoding followed by channels encoding.
+	capBuf := engine_types.EncodeCapabilities(result.Capabilities)
+	chanBuf := engine_types.EncodeCommunicationChannels(result.SupportedProtocols)
+
+	// SSZ Container: capabilities_offset(4) + channels_offset(4) + capabilities_data + channels_data
+	fixedSize := uint32(8)
+	buf := make([]byte, 8+len(capBuf)+len(chanBuf))
+	binary.LittleEndian.PutUint32(buf[0:4], fixedSize)
+	binary.LittleEndian.PutUint32(buf[4:8], fixedSize+uint32(len(capBuf)))
+	copy(buf[8:], capBuf)
+	copy(buf[8+len(capBuf):], chanBuf)
+
+	sszResponse(w, buf)
+}
+
 // --- getClientCommunicationChannels handler ---
 
 func (s *SszRestServer) handleGetClientCommunicationChannels(w http.ResponseWriter, r *http.Request) {

execution/engineapi/engine_types/jsonrpc.go

@@ -137,12 +137,18 @@ type ClientVersionV1 struct {
 }
 
 // CommunicationChannel describes a protocol and endpoint supported by the EL.
-// See EIP-8160: engine_getClientCommunicationChannelsV1
+// See EIP-8160: engine_exchangeCapabilitiesV2
 type CommunicationChannel struct {
 	Protocol string `json:"protocol" gencodec:"required"`
 	URL      string `json:"url"      gencodec:"required"`
 }
 
+// ExchangeCapabilitiesV2Response is the response for engine_exchangeCapabilitiesV2 (EIP-8160).
+type ExchangeCapabilitiesV2Response struct {
+	Capabilities       []string               `json:"capabilities"`
+	SupportedProtocols []CommunicationChannel `json:"supportedProtocols"`
+}
+
 func (c ClientVersionV1) String() string {
 	return fmt.Sprintf("ClientCode: %s, %s-%s-%s", c.Code, c.Name, c.Version, c.Commit)
 }

execution/engineapi/interface.go

@@ -47,4 +47,5 @@ type EngineAPI interface {
 	GetBlobsV2(ctx context.Context, blobHashes []common.Hash) ([]*engine_types.BlobAndProofV2, error)
 	GetBlobsV3(ctx context.Context, blobHashes []common.Hash) ([]*engine_types.BlobAndProofV2, error)
 	GetClientCommunicationChannelsV1(ctx context.Context) ([]engine_types.CommunicationChannel, error)
+	ExchangeCapabilitiesV2(fromCl []string) *engine_types.ExchangeCapabilitiesV2Response
 }