[WIP] EIP-8161: SSZ-REST Engine API transport (EL side)

Implements the EL side of EIP-8161, adding an SSZ-REST HTTP server
alongside the existing JSON-RPC Engine API. All engine_* methods are
mapped to REST endpoints with SSZ-encoded request/response bodies,
cutting payload sizes ~50% and eliminating JSON encode/decode overhead.

- New SSZ-REST HTTP server with JWT auth (same secret as JSON-RPC)
- SSZ encode/decode for all Engine API types (PayloadStatus,
  ForkchoiceUpdatedResponse, NewPayloadRequest, GetPayloadResponse,
  GetBlobs, ExchangeCapabilities, ClientVersion, CommunicationChannels)
- CLI flags: --authrpc.ssz-rest, --authrpc.ssz-rest-port
- EIP-8160 integration: advertises ssz_rest channel via
  engine_getClientCommunicationChannelsV1
- Handles V4 (Electra) and V5 (Fulu) with correct fork version mapping
- Proper SSZ Union types for optional fields (latest_valid_hash, payload_id)

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

Author: Giulio2002

cmd/rpcdaemon/cli/httpcfg/http_cfg.go

@@ -111,4 +111,8 @@ type HttpCfg struct {
 
 	RpcTxSyncDefaultTimeout time.Duration // Default timeout for eth_sendRawTransactionSync
 	RpcTxSyncMaxTimeout     time.Duration // Maximum timeout for eth_sendRawTransactionSync
+
+	// EIP-8161: SSZ-REST Engine API Transport
+	SszRestEnabled bool // Enable SSZ-REST Engine API server alongside JSON-RPC
+	SszRestPort    int  // Port for the SSZ-REST Engine API server (default: AuthRpcPort + 1)
 }

cmd/utils/flags.go

@@ -326,6 +326,16 @@ var (
 		Value: "",
 	}
 
+	SszRestEnabledFlag = cli.BoolFlag{
+		Name:  "authrpc.ssz-rest",
+		Usage: "Enable the SSZ-REST Engine API transport (EIP-8161) alongside JSON-RPC",
+	}
+	SszRestPortFlag = cli.UintFlag{
+		Name:  "authrpc.ssz-rest-port",
+		Usage: "HTTP port for the SSZ-REST Engine API server (default: authrpc.port + 1)",
+		Value: 0,
+	}
+
 	HttpCompressionFlag = cli.BoolFlag{
 		Name:  "http.compression",
 		Usage: "Enable compression over HTTP-RPC. Use --http.compression=false to disable it",

execution/engineapi/engine_api_jsonrpc_client.go

@@ -396,6 +396,17 @@ func (c *JsonRpcClient) GetClientVersionV1(ctx context.Context, callerVersion *e
 	}, c.backOff(ctx))
 }
 
+func (c *JsonRpcClient) GetClientCommunicationChannelsV1(ctx context.Context) ([]enginetypes.CommunicationChannel, error) {
+	return backoff.RetryWithData(func() ([]enginetypes.CommunicationChannel, error) {
+		var result []enginetypes.CommunicationChannel
+		err := c.rpcClient.CallContext(ctx, &result, "engine_getClientCommunicationChannelsV1")
+		if err != nil {
+			return nil, c.maybeMakePermanent(err)
+		}
+		return result, nil
+	}, c.backOff(ctx))
+}
+
 func (c *JsonRpcClient) backOff(ctx context.Context) backoff.BackOff {
 	var backOff backoff.BackOff
 	backOff = backoff.NewConstantBackOff(c.retryBackOff)

execution/engineapi/engine_api_methods.go

@@ -54,6 +54,7 @@ var ourCapabilities = []string{
 	"engine_getBlobsV1",
 	"engine_getBlobsV2",
 	"engine_getBlobsV3",
+	"engine_getClientCommunicationChannelsV1",
 }
 
 // Returns the most recent version of the payload(for the payloadID) at the time of receiving the call
@@ -284,3 +285,37 @@ func (e *EngineServer) GetBlobsV3(ctx context.Context, blobHashes []common.Hash)
 	}
 	return nil, err
 }
+
+// GetClientCommunicationChannelsV1 returns the communication protocols and endpoints supported by the EL.
+// See EIP-8160 and EIP-8161
+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
+}

execution/engineapi/engine_server.go

@@ -87,6 +87,8 @@ type EngineServer struct {
 	// TODO Remove this on next release
 	printPectraBanner bool
 	maxReorgDepth     uint64
+	httpConfig        *httpcfg.HttpCfg
+	sszRestPort       int // EIP-8161: port the SSZ-REST server is listening on
 }
 
 func NewEngineServer(
@@ -140,6 +142,7 @@ func (e *EngineServer) Start(
 			return nil
 		})
 	}
+	e.httpConfig = httpConfig
 	base := jsonrpc.NewBaseApi(filters, stateCache, blockReader, httpConfig.WithDatadir, httpConfig.EvmCallTimeout, engineReader, httpConfig.Dirs, nil, httpConfig.RangeLimit)
 	ethImpl := jsonrpc.NewEthAPI(base, db, eth, e.txpool, mining, jsonrpc.NewEthApiConfig(httpConfig), e.logger)
 
@@ -164,6 +167,39 @@ func (e *EngineServer) Start(
 		}
 		return err
 	})
+
+	// EIP-8161: Start SSZ-REST Engine API server if enabled
+	if httpConfig.SszRestEnabled {
+		eg.Go(func() error {
+			defer e.logger.Debug("[EngineServer] SSZ-REST server goroutine terminated")
+			jwtSecret, err := cli.ObtainJWTSecret(httpConfig, e.logger)
+			if err != nil {
+				e.logger.Error("[EngineServer] failed to obtain JWT secret for SSZ-REST server", "err", err)
+				return err
+			}
+
+			addr := httpConfig.AuthRpcHTTPListenAddress
+			if addr == "" {
+				addr = "127.0.0.1"
+			}
+			port := httpConfig.SszRestPort
+			if port == 0 {
+				port = httpConfig.AuthRpcPort + 1
+				if httpConfig.AuthRpcPort == 0 {
+					port = 8552
+				}
+			}
+			e.sszRestPort = port
+
+			sszServer := NewSszRestServer(e, e.logger, jwtSecret, addr, port)
+			err = sszServer.Start(ctx)
+			if err != nil && !errors.Is(err, context.Canceled) {
+				e.logger.Error("[EngineServer] SSZ-REST server background goroutine failed", "err", err)
+			}
+			return err
+		})
+	}
+
 	return eg.Wait()
 }
 

execution/engineapi/engine_server_test.go

@@ -348,6 +348,35 @@ func TestGetPayloadBodiesByHashV2(t *testing.T) {
 	req.Equal(hexutil.Bytes(balBytes), bodies[0].BlockAccessList)
 }
 
+func TestGetClientCommunicationChannelsV1(t *testing.T) {
+	mockSentry := execmoduletester.New(t, execmoduletester.WithTxPool(), execmoduletester.WithChainConfig(chain.AllProtocolChanges))
+	req := require.New(t)
+
+	executionRpc := direct.NewExecutionClientDirect(mockSentry.ExecModule)
+	maxReorgDepth := ethconfig.Defaults.MaxReorgDepth
+	engineServer := NewEngineServer(mockSentry.Log, mockSentry.ChainConfig, executionRpc, nil, false, false, true, nil, ethconfig.Defaults.FcuTimeout, maxReorgDepth)
+
+	ctx := context.Background()
+
+	// Before Start (no httpConfig set) — should return defaults
+	channels, err := engineServer.GetClientCommunicationChannelsV1(ctx)
+	req.NoError(err)
+	req.Len(channels, 1)
+	req.Equal("json_rpc", channels[0].Protocol)
+	req.Equal("localhost:8551", channels[0].URL)
+
+	// After setting httpConfig via Start-like initialization
+	engineServer.httpConfig = &httpcfg.HttpCfg{
+		AuthRpcHTTPListenAddress: "0.0.0.0",
+		AuthRpcPort:              9551,
+	}
+	channels, err = engineServer.GetClientCommunicationChannelsV1(ctx)
+	req.NoError(err)
+	req.Len(channels, 1)
+	req.Equal("json_rpc", channels[0].Protocol)
+	req.Equal("0.0.0.0:9551", channels[0].URL)
+}
+
 func TestGetPayloadBodiesByRangeV2(t *testing.T) {
 	mockSentry := execmoduletester.New(t, execmoduletester.WithTxPool(), execmoduletester.WithChainConfig(chain.AllProtocolChanges))
 	req := require.New(t)