Add rpc configuration to MockConsensusNode

Author: jfrank-summit

domains/test/service/src/domain.rs

@@ -41,6 +41,7 @@ use sp_runtime::traits::{AsSystemOriginSigner, Dispatchable, NumberFor};
 use sp_session::SessionKeys;
 use sp_transaction_pool::runtime_api::TaggedTransactionQueue;
 use std::future::Future;
+use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 use subspace_runtime_primitives::opaque::Block as CBlock;
@@ -146,6 +147,8 @@ where
         maybe_operator_id: Option<OperatorId>,
         role: Role,
         mock_consensus_node: &mut MockConsensusNode,
+        rpc_addr: Option<SocketAddr>,
+        rpc_port: Option<u16>,
     ) -> Self {
         let mut domain_config = node_config(
             domain_id,
@@ -156,6 +159,8 @@ where
             role,
             base_path.clone(),
             Box::new(create_domain_spec()) as Box<_>,
+            rpc_addr,
+            rpc_port,
         )
         .expect("could not generate domain node Configuration");
 
@@ -573,6 +578,8 @@ pub struct DomainNodeBuilder {
     skip_empty_bundle_production: bool,
     base_path: BasePath,
     maybe_operator_id: Option<OperatorId>,
+    rpc_addr: Option<SocketAddr>,
+    rpc_port: Option<u16>,
 }
 
 impl DomainNodeBuilder {
@@ -588,6 +595,8 @@ impl DomainNodeBuilder {
             skip_empty_bundle_production: false,
             base_path,
             maybe_operator_id: None,
+            rpc_addr: None,
+            rpc_port: None,
         }
     }
 
@@ -620,6 +629,18 @@ impl DomainNodeBuilder {
         self
     }
 
+    /// Set RPC address for the domain node
+    pub fn rpc_addr(mut self, addr: SocketAddr) -> Self {
+        self.rpc_addr = Some(addr);
+        self
+    }
+
+    /// Set RPC port for the domain node
+    pub fn rpc_port(mut self, port: u16) -> Self {
+        self.rpc_port = Some(port);
+        self
+    }
+
     /// Build an EVM domain node
     pub async fn build_evm_node(
         self,
@@ -642,6 +663,8 @@ impl DomainNodeBuilder {
             self.maybe_operator_id,
             role,
             mock_consensus_node,
+            self.rpc_addr,
+            self.rpc_port,
         )
         .await
     }
@@ -668,6 +691,8 @@ impl DomainNodeBuilder {
             self.maybe_operator_id,
             role,
             mock_consensus_node,
+            self.rpc_addr,
+            self.rpc_port,
         )
         .await
     }
@@ -691,6 +716,8 @@ impl DomainNodeBuilder {
             self.maybe_operator_id,
             role,
             mock_consensus_node,
+            self.rpc_addr,
+            self.rpc_port,
         )
         .await
     }

domains/test/service/src/lib.rs

@@ -31,7 +31,7 @@ use sc_network::multiaddr;
 use sc_service::config::{
     DatabaseSource, ExecutorConfiguration, KeystoreConfig, MultiaddrWithPeerId,
     NetworkConfiguration, OffchainWorkerConfig, PruningMode, RpcBatchRequestConfig,
-    RpcConfiguration, WasmExecutionMethod, WasmtimeInstantiationStrategy,
+    RpcConfiguration, RpcEndpoint, WasmExecutionMethod, WasmtimeInstantiationStrategy,
 };
 use sc_service::{
     BasePath, BlocksPruning, ChainSpec, Configuration as ServiceConfiguration,
@@ -48,6 +48,7 @@ use sp_runtime::generic;
 use sp_runtime::generic::SignedPayload;
 use sp_runtime::traits::{AsSystemOriginSigner, Dispatchable};
 use std::fmt::{Debug, Display};
+use std::net::SocketAddr;
 use std::str::FromStr;
 
 /// The domain id of the evm domain
@@ -72,6 +73,8 @@ pub fn node_config(
     role: Role,
     base_path: BasePath,
     chain_spec: Box<dyn ChainSpec>,
+    rpc_addr: Option<SocketAddr>,
+    rpc_port: Option<u16>,
 ) -> Result<ServiceConfiguration, ServiceError> {
     let root = base_path.path().to_path_buf();
 
@@ -104,6 +107,59 @@ pub fn node_config(
 
     network_config.transport = TransportConfig::MemoryOnly;
 
+    let rpc_configuration = match rpc_addr {
+        Some(listen_addr) => {
+            let port = rpc_port.unwrap_or(9945);
+            RpcConfiguration {
+                addr: Some(vec![RpcEndpoint {
+                    batch_config: RpcBatchRequestConfig::Disabled,
+                    max_connections: 10,
+                    listen_addr,
+                    rpc_methods: Default::default(),
+                    rate_limit: None,
+                    rate_limit_trust_proxy_headers: false,
+                    rate_limit_whitelisted_ips: vec![],
+                    max_payload_in_mb: 15,
+                    max_payload_out_mb: 15,
+                    max_subscriptions_per_connection: 10,
+                    max_buffer_capacity_per_connection: 10,
+                    cors: None,
+                    retry_random_port: true,
+                    is_optional: false,
+                }]),
+                max_request_size: 15,
+                max_response_size: 15,
+                id_provider: None,
+                max_subs_per_conn: 1024,
+                port,
+                message_buffer_capacity: 1024,
+                batch_config: RpcBatchRequestConfig::Disabled,
+                max_connections: 1000,
+                cors: None,
+                methods: Default::default(),
+                rate_limit: None,
+                rate_limit_whitelisted_ips: vec![],
+                rate_limit_trust_proxy_headers: false,
+            }
+        }
+        None => RpcConfiguration {
+            addr: None,
+            max_request_size: 0,
+            max_response_size: 0,
+            id_provider: None,
+            max_subs_per_conn: 0,
+            port: 0,
+            message_buffer_capacity: 0,
+            batch_config: RpcBatchRequestConfig::Disabled,
+            max_connections: 0,
+            cors: None,
+            methods: Default::default(),
+            rate_limit: None,
+            rate_limit_whitelisted_ips: vec![],
+            rate_limit_trust_proxy_headers: false,
+        },
+    };
+
     Ok(ServiceConfiguration {
         impl_name: "domain-test-node".to_string(),
         impl_version: "0.1".to_string(),
@@ -127,22 +183,7 @@ pub fn node_config(
             default_heap_pages: None,
             runtime_cache_size: 2,
         },
-        rpc: RpcConfiguration {
-            addr: None,
-            max_request_size: 0,
-            max_response_size: 0,
-            id_provider: None,
-            max_subs_per_conn: 0,
-            port: 0,
-            message_buffer_capacity: 0,
-            batch_config: RpcBatchRequestConfig::Disabled,
-            max_connections: 0,
-            cors: None,
-            methods: Default::default(),
-            rate_limit: None,
-            rate_limit_whitelisted_ips: vec![],
-            rate_limit_trust_proxy_headers: false,
-        },
+        rpc: rpc_configuration,
         prometheus_config: None,
         telemetry_endpoints: None,
         offchain_worker: OffchainWorkerConfig {