feat: add param arguments for initializing websocket

ethportal-api/src/types/cli.rs

@@ -154,6 +154,12 @@ pub struct TrinConfig {
     )]
     pub disable_poke: bool,
 
+    #[arg(long = "ws", help = "Used to enable WebSocket rpc.")]
+    pub ws: bool,
+
+    #[arg(long = "ws-port", help = "The WebSocket port to listen on.")]
+    pub ws_port: u16,
+
     #[command(subcommand)]
     pub command: Option<TrinConfigCommands>,
 }
@@ -182,6 +188,8 @@ impl Default for TrinConfig {
             ephemeral: false,
             master_acc_path: PathBuf::from(DEFAULT_MASTER_ACC_PATH.to_string()),
             disable_poke: false,
+            ws: false,
+            ws_port: DEFAULT_WEB3_WS_PORT,
             command: None,
         }
     }

rpc/src/lib.rs

@@ -32,6 +32,7 @@ use web3_rpc::Web3Api;
 use crate::rpc_server::RpcServerConfig;
 use portalnet::discovery::Discovery;
 use reth_ipc::server::Builder as IpcServerBuilder;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::Arc;
 use tokio::sync::mpsc;
 
@@ -80,24 +81,36 @@ pub async fn launch_jsonrpc_server(
                 .await?
         }
         Web3TransportType::HTTP => {
-            let transport = TransportRpcModuleConfig::default().with_http(modules);
+            let transport = match trin_config.ws {
+                true => TransportRpcModuleConfig::default().with_ws(modules.clone()),
+                false => TransportRpcModuleConfig::default(),
+            };
+            let transport = transport.with_http(modules);
+
             let transport_modules = RpcModuleBuilder::new(discv5)
                 .maybe_with_history(history_handler)
                 .maybe_with_beacon(beacon_handler)
                 .maybe_with_state(state_handler)
                 .build(transport);
 
-            RpcServerConfig::default()
+            let rpc_server_config = RpcServerConfig::default()
                 .with_http_address(
                     trin_config
                         .web3_http_address
                         .socket_addrs(|| None)
                         .expect("Invalid socket address")[0],
                 )
-                .with_http(ServerBuilder::default())
-                .with_ws(ServerBuilder::default())
-                .start(transport_modules)
-                .await?
+                .with_http(ServerBuilder::default());
+            let rpc_server_config = match trin_config.ws {
+                true => rpc_server_config
+                    .with_ws_address(SocketAddr::V4(SocketAddrV4::new(
+                        Ipv4Addr::UNSPECIFIED,
+                        trin_config.ws_port,
+                    )))
+                    .with_ws(ServerBuilder::default()),
+                false => rpc_server_config,
+            };
+            rpc_server_config.start(transport_modules).await?
         }
     };
 

rpc/src/rpc_server.rs

@@ -375,13 +375,6 @@ impl RpcServerConfig {
             ))
         });
 
-        let ws_socket_addr = self.ws_addr.unwrap_or_else(|| {
-            SocketAddr::V4(SocketAddrV4::new(
-                Ipv4Addr::UNSPECIFIED,
-                DEFAULT_WEB3_WS_PORT,
-            ))
-        });
-
         // If both are configured on the same port, we combine them into one server.
         if self.http_addr == self.ws_addr
             && self.http_server_config.is_some()
@@ -431,6 +424,13 @@ impl RpcServerConfig {
         let mut ws_local_addr = None;
         let mut ws_server = None;
         if let Some(builder) = self.ws_server_config.take() {
+            let ws_socket_addr = self.ws_addr.unwrap_or_else(|| {
+                SocketAddr::V4(SocketAddrV4::new(
+                    Ipv4Addr::UNSPECIFIED,
+                    DEFAULT_WEB3_WS_PORT,
+                ))
+            });
+
             let builder = builder.ws_only();
             let (server, addr) = WsHttpServerKind::build(
                 builder,