rpc embedded: add https flags to embedded rpc

cmd/rpcdaemon/cli/config.go

@@ -155,22 +155,22 @@ func RootCommand() (*cobra.Command, *httpcfg.HttpCfg) {
 	rootCmd.PersistentFlags().BoolVar(&cfg.HttpServerEnabled, "http.enabled", true, "Enable HTTP server")
 	rootCmd.PersistentFlags().StringVar(&cfg.HttpListenAddress, "http.addr", nodecfg.DefaultHTTPHost, "HTTP server listening interface")
 	rootCmd.PersistentFlags().IntVar(&cfg.HttpPort, "http.port", nodecfg.DefaultHTTPPort, "HTTP server listening port")
-	rootCmd.PersistentFlags().StringVar(&cfg.HttpURL, "http.url", "", "HTTP server listening url. will OVERRIDE http.addr and http.port. will NOT respect http paths. prefix supported are tcp, unix")
+	rootCmd.PersistentFlags().StringVar(&cfg.HttpURL, utils.HTTPURLFlag.Name, utils.HTTPURLFlag.Value, utils.HTTPURLFlag.Usage)
 	rootCmd.PersistentFlags().StringSliceVar(&cfg.HttpCORSDomain, "http.corsdomain", []string{}, "Comma separated list of domains from which to accept cross origin requests (browser enforced)")
 	rootCmd.PersistentFlags().StringSliceVar(&cfg.HttpVirtualHost, "http.vhosts", nodecfg.DefaultConfig.HTTPVirtualHosts, "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.")
 	rootCmd.PersistentFlags().BoolVar(&cfg.HttpCompression, "http.compression", true, "Enable http compression enabled by default. Use --http.compression=false to disable it")
 	rootCmd.PersistentFlags().BoolVar(&cfg.WebsocketEnabled, "ws", false, "Enable Websockets - Same port as HTTP[S]")
 	rootCmd.PersistentFlags().BoolVar(&cfg.WebsocketCompression, "ws.compression", true, "Enable Websocket compression (RFC 7692) enabled by default is Websockets is enabled. Use --ws.compression=false to disable it")
 	rootCmd.PersistentFlags().IntVar(&cfg.WebsocketPort, "ws.port", nodecfg.DefaultWSPort, "rpc WebSocket server listening port")
-	rootCmd.PersistentFlags().BoolVar(&cfg.HttpsServerEnabled, "https.enabled", false, "Enable HTTPS server")
-	rootCmd.PersistentFlags().StringVar(&cfg.HttpsListenAddress, "https.addr", nodecfg.DefaultHTTPHost, "rpc HTTPS server listening interface")
-	rootCmd.PersistentFlags().IntVar(&cfg.HttpsPort, "https.port", 0, "rpc HTTPS server listening port. default to http.port + 363 if not set")
-	rootCmd.PersistentFlags().StringVar(&cfg.HttpsURL, "https.url", "", "rpc HTTPS server listening url. will OVERRIDE https.addr and https.port. will NOT respect paths. prefix supported are tcp, unix")
-	rootCmd.PersistentFlags().StringVar(&cfg.HttpsCertfile, "https.cert", "", "certificate for rpc HTTPS server")
-	rootCmd.PersistentFlags().StringVar(&cfg.HttpsKeyFile, "https.key", "", "key file for rpc HTTPS server")
-
-	rootCmd.PersistentFlags().BoolVar(&cfg.SocketServerEnabled, "socket.enabled", false, "Enable IPC server")
-	rootCmd.PersistentFlags().StringVar(&cfg.SocketListenUrl, "socket.url", "unix:///var/run/erigon.sock", "IPC server listening url. prefix supported are tcp, unix")
+	rootCmd.PersistentFlags().BoolVar(&cfg.HttpsServerEnabled, utils.HTTPSEnabledFlag.Name, utils.HTTPSEnabledFlag.Value, utils.HTTPSEnabledFlag.Usage)
+	rootCmd.PersistentFlags().StringVar(&cfg.HttpsListenAddress, utils.HTTPSListenAddrFlag.Name, utils.HTTPSListenAddrFlag.Value, utils.HTTPSListenAddrFlag.Usage)
+	rootCmd.PersistentFlags().IntVar(&cfg.HttpsPort, utils.HTTPSPortFlag.Name, utils.HTTPSPortFlag.Value, utils.HTTPSPortFlag.Usage)
+	rootCmd.PersistentFlags().StringVar(&cfg.HttpsURL, utils.HTTPSURLFlag.Name, utils.HTTPSURLFlag.Value, utils.HTTPSURLFlag.Usage)
+	rootCmd.PersistentFlags().StringVar(&cfg.HttpsCertfile, utils.HTTPSCertFlag.Name, utils.HTTPSCertFlag.Value, utils.HTTPSCertFlag.Usage)
+	rootCmd.PersistentFlags().StringVar(&cfg.HttpsKeyFile, utils.HTTPSKeyFlag.Name, utils.HTTPSKeyFlag.Value, utils.HTTPSKeyFlag.Usage)
+
+	rootCmd.PersistentFlags().BoolVar(&cfg.SocketServerEnabled, utils.SocketEnabledFlag.Name, utils.SocketEnabledFlag.Value, utils.SocketEnabledFlag.Usage)
+	rootCmd.PersistentFlags().StringVar(&cfg.SocketListenUrl, utils.SocketURLFlag.Name, utils.SocketURLFlag.Value, utils.SocketURLFlag.Usage)
 
 	rootCmd.PersistentFlags().BoolVar(&cfg.TraceRequests, utils.HTTPTraceFlag.Name, false, "Trace HTTP requests with INFO level")
 	rootCmd.PersistentFlags().DurationVar(&cfg.HTTPTimeouts.ReadTimeout, "http.timeouts.read", rpccfg.DefaultHTTPTimeouts.ReadTimeout, "Maximum duration for reading the entire request, including the body.")

cmd/utils/flags.go

@@ -328,6 +328,51 @@ var (
 		Usage: "HTTP-RPC server listening port",
 		Value: nodecfg.DefaultHTTPPort,
 	}
+	HTTPURLFlag = cli.StringFlag{
+		Name:  "http.url",
+		Usage: "HTTP server listening url. will OVERRIDE http.addr and http.port. will NOT respect http paths. prefix supported are tcp, unix",
+		Value: "",
+	}
+	HTTPSEnabledFlag = cli.BoolFlag{
+		Name:  "https.enabled",
+		Usage: "Enable HTTPS server",
+		Value: false,
+	}
+	HTTPSListenAddrFlag = cli.StringFlag{
+		Name:  "https.addr",
+		Usage: "rpc HTTPS server listening interface",
+		Value: nodecfg.DefaultHTTPHost,
+	}
+	HTTPSPortFlag = cli.IntFlag{
+		Name:  "https.port",
+		Usage: "rpc HTTPS server listening port. default to http.port + 363 if not set",
+		Value: 0,
+	}
+	HTTPSURLFlag = cli.StringFlag{
+		Name:  "https.url",
+		Usage: "rpc HTTPS server listening url. will OVERRIDE https.addr and https.port. will NOT respect paths. prefix supported are tcp, unix",
+		Value: "",
+	}
+	HTTPSCertFlag = cli.StringFlag{
+		Name:  "https.cert",
+		Usage: "certificate for rpc HTTPS server",
+		Value: "",
+	}
+	HTTPSKeyFlag = cli.StringFlag{
+		Name:  "https.key",
+		Usage: "key file for rpc HTTPS server",
+		Value: "",
+	}
+	SocketEnabledFlag = cli.BoolFlag{
+		Name:  "socket.enabled",
+		Usage: "Enable IPC server",
+		Value: false,
+	}
+	SocketURLFlag = cli.StringFlag{
+		Name:  "socket.url",
+		Usage: "IPC server listening url. prefix supported are tcp, unix",
+		Value: "unix:///var/run/erigon.sock",
+	}
 	AuthRpcAddr = cli.StringFlag{
 		Name:  "authrpc.addr",
 		Usage: "HTTP-RPC server listening interface for the Engine API",

node/cli/default_flags.go

@@ -75,6 +75,15 @@ var DefaultFlags = []cli.Flag{
 	&utils.GraphQLEnabledFlag,
 	&utils.HTTPListenAddrFlag,
 	&utils.HTTPPortFlag,
+	&utils.HTTPURLFlag,
+	&utils.SocketEnabledFlag,
+	&utils.SocketURLFlag,
+	&utils.HTTPSEnabledFlag,
+	&utils.HTTPSListenAddrFlag,
+	&utils.HTTPSPortFlag,
+	&utils.HTTPSURLFlag,
+	&utils.HTTPSCertFlag,
+	&utils.HTTPSKeyFlag,
 	&utils.AuthRpcAddr,
 	&utils.AuthRpcPort,
 	&utils.JWTSecretPath,

node/cli/flags.go

@@ -442,6 +442,15 @@ func setEmbeddedRpcDaemon(ctx *cli.Command, cfg *nodecfg.Config, logger log.Logg
 		GraphQLEnabled:           ctx.Bool(utils.GraphQLEnabledFlag.Name),
 		HttpListenAddress:        ctx.String(utils.HTTPListenAddrFlag.Name),
 		HttpPort:                 ctx.Int(utils.HTTPPortFlag.Name),
+		HttpURL:                  ctx.String(utils.HTTPURLFlag.Name),
+		SocketServerEnabled:      ctx.Bool(utils.SocketEnabledFlag.Name),
+		SocketListenUrl:          ctx.String(utils.SocketURLFlag.Name),
+		HttpsServerEnabled:       ctx.Bool(utils.HTTPSEnabledFlag.Name),
+		HttpsListenAddress:       ctx.String(utils.HTTPSListenAddrFlag.Name),
+		HttpsPort:                ctx.Int(utils.HTTPSPortFlag.Name),
+		HttpsURL:                 ctx.String(utils.HTTPSURLFlag.Name),
+		HttpsCertfile:            ctx.String(utils.HTTPSCertFlag.Name),
+		HttpsKeyFile:             ctx.String(utils.HTTPSKeyFlag.Name),
 		AuthRpcHTTPListenAddress: ctx.String(utils.AuthRpcAddr.Name),
 		AuthRpcPort:              int(ctx.Uint(utils.AuthRpcPort.Name)),
 		JWTSecretPath:            jwtSecretPath,

node/cli/helpers_test.go

@@ -25,8 +25,30 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v3"
+
+	"github.com/erigontech/erigon/common/log/v3"
+	"github.com/erigontech/erigon/node/nodecfg"
 )
 
+// buildHttpCfg runs the full node flag pipeline (ApplyFlagsForNodeConfig) with
+// the given CLI args and returns the resulting embedded HTTP config.
+func buildHttpCfg(t *testing.T, args []string) nodecfg.Config {
+	t.Helper()
+
+	var result nodecfg.Config
+	app := &cli.Command{}
+	app.Flags = DefaultFlags
+	app.Action = func(nodeCtx context.Context, ctx *cli.Command) error {
+		cfg := nodecfg.Config{}
+		cfg.Dirs.DataDir = t.TempDir()
+		ApplyFlagsForNodeConfig(ctx, &cfg, log.New())
+		result = cfg
+		return nil
+	}
+	require.NoError(t, app.Run(context.Background(), append([]string{"erigon"}, args...)))
+	return result
+}
+
 // TestOnUsageErrorHandler verifies that the custom OnUsageError handler
 // prints the error and help hint when called directly
 func TestOnUsageErrorHandler(t *testing.T) {

node/cli/rpc_server_flags_test.go

@@ -0,0 +1,63 @@
+// Copyright 2026 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+package cli
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/erigontech/erigon/node/nodecfg"
+)
+
+func TestRpcServerFlags_Defaults(t *testing.T) {
+	cfg := buildHttpCfg(t, nil)
+
+	require.Empty(t, cfg.Http.HttpURL)
+	require.False(t, cfg.Http.SocketServerEnabled)
+	require.Equal(t, "unix:///var/run/erigon.sock", cfg.Http.SocketListenUrl)
+	require.False(t, cfg.Http.HttpsServerEnabled)
+	require.Equal(t, nodecfg.DefaultHTTPHost, cfg.Http.HttpsListenAddress)
+	require.Equal(t, 0, cfg.Http.HttpsPort)
+	require.Empty(t, cfg.Http.HttpsURL)
+	require.Empty(t, cfg.Http.HttpsCertfile)
+	require.Empty(t, cfg.Http.HttpsKeyFile)
+}
+
+func TestRpcServerFlags_Set(t *testing.T) {
+	cfg := buildHttpCfg(t, []string{
+		"--http.url", "unix:///var/run/erigon-rpc.sock",
+		"--socket.enabled",
+		"--socket.url", "tcp://127.0.0.1:7777",
+		"--https.enabled",
+		"--https.addr", "0.0.0.0",
+		"--https.port", "8443",
+		"--https.url", "tcp://0.0.0.0:8443",
+		"--https.cert", "/path/to/cert.pem",
+		"--https.key", "/path/to/key.pem",
+	})
+
+	require.Equal(t, "unix:///var/run/erigon-rpc.sock", cfg.Http.HttpURL)
+	require.True(t, cfg.Http.SocketServerEnabled)
+	require.Equal(t, "tcp://127.0.0.1:7777", cfg.Http.SocketListenUrl)
+	require.True(t, cfg.Http.HttpsServerEnabled)
+	require.Equal(t, "0.0.0.0", cfg.Http.HttpsListenAddress)
+	require.Equal(t, 8443, cfg.Http.HttpsPort)
+	require.Equal(t, "tcp://0.0.0.0:8443", cfg.Http.HttpsURL)
+	require.Equal(t, "/path/to/cert.pem", cfg.Http.HttpsCertfile)
+	require.Equal(t, "/path/to/key.pem", cfg.Http.HttpsKeyFile)
+}

node/cli/witness_cache_flags_test.go

@@ -17,35 +17,11 @@
 package cli
 
 import (
-	"context"
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"github.com/urfave/cli/v3"
-
-	"github.com/erigontech/erigon/common/log/v3"
-	"github.com/erigontech/erigon/node/nodecfg"
 )
 
-// buildHttpCfg runs the full node flag pipeline (ApplyFlagsForNodeConfig) with
-// the given CLI args and returns the resulting embedded HTTP config.
-func buildHttpCfg(t *testing.T, args []string) nodecfg.Config {
-	t.Helper()
-
-	var result nodecfg.Config
-	app := &cli.Command{}
-	app.Flags = DefaultFlags
-	app.Action = func(nodeCtx context.Context, ctx *cli.Command) error {
-		cfg := nodecfg.Config{}
-		cfg.Dirs.DataDir = t.TempDir()
-		ApplyFlagsForNodeConfig(ctx, &cfg, log.New())
-		result = cfg
-		return nil
-	}
-	require.NoError(t, app.Run(context.Background(), append([]string{"erigon"}, args...)))
-	return result
-}
-
 func TestWitnessCacheFlags_Defaults(t *testing.T) {
 	cfg := buildHttpCfg(t, nil)