Struct RpcServerArgs

pub struct RpcServerArgs {

    pub http: bool,
    pub http_addr: IpAddr,
    pub http_port: u16,
    pub http_api: Option<RpcModuleSelection>,
    pub http_corsdomain: Option<String>,
    pub ws: bool,
    pub ws_addr: IpAddr,
    pub ws_port: u16,
    pub ws_allowed_origins: Option<String>,
    pub ws_api: Option<RpcModuleSelection>,
    pub ipcdisable: bool,
    pub ipcpath: String,
    pub auth_addr: IpAddr,
    pub auth_port: u16,
    pub auth_jwtsecret: Option<PathBuf>,
    pub auth_ipc: bool,
    pub auth_ipc_path: String,
    pub rpc_jwtsecret: Option<JwtSecret>,
    pub rpc_max_request_size: MaxU32,
    pub rpc_max_response_size: MaxU32,
    pub rpc_max_subscriptions_per_connection: MaxU32,
    pub rpc_max_connections: MaxU32,
    pub rpc_max_tracing_requests: usize,
    pub rpc_max_blocks_per_filter: ZeroAsNoneU64,
    pub rpc_max_logs_per_response: ZeroAsNoneU64,
    pub rpc_gas_cap: u64,
    pub rpc_max_simulate_blocks: u64,
    pub rpc_eth_proof_window: u64,
    pub rpc_proof_permits: usize,
    pub builder_disallow: Option<HashSet<Address>>,
    pub rpc_state_cache: RpcStateCacheArgs,
    pub gas_price_oracle: GasPriceOracleArgs,
}

Parameters for configuring the rpc more granularity via CLI

Fields

http: bool

Enable the HTTP-RPC server

http_addr: IpAddr

Http server address to listen on

http_port: u16

Http server port to listen on

http_api: Option<RpcModuleSelection>

Rpc Modules to be configured for the HTTP server

http_corsdomain: Option<String>

Http Corsdomain to allow request from

ws: bool

Enable the WS-RPC server

ws_addr: IpAddr

Ws server address to listen on

ws_port: u16

Ws server port to listen on

ws_allowed_origins: Option<String>

Origins from which to accept WebSocket requests

ws_api: Option<RpcModuleSelection>

Rpc Modules to be configured for the WS server

ipcdisable: bool

Disable the IPC-RPC server

ipcpath: String

Filename for IPC socket/pipe within the datadir

auth_addr: IpAddr

Auth server address to listen on

auth_port: u16

Auth server port to listen on

auth_jwtsecret: Option<PathBuf>

Path to a JWT secret to use for the authenticated engine-API RPC server.

This will enforce JWT authentication for all requests coming from the consensus layer.

If no path is provided, a secret will be generated and stored in the datadir under <DIR>/<CHAIN_ID>/jwt.hex. For mainnet this would be ~/.reth/mainnet/jwt.hex by default.

auth_ipc: bool

Enable auth engine API over IPC

auth_ipc_path: String

Filename for auth IPC socket/pipe within the datadir

rpc_jwtsecret: Option<JwtSecret>

Hex encoded JWT secret to authenticate the regular RPC server(s), see --http.api and --ws.api.

This is not used for the authenticated engine-API RPC server, see --authrpc.jwtsecret.

rpc_max_request_size: MaxU32

Set the maximum RPC request payload size for both HTTP and WS in megabytes.

rpc_max_response_size: MaxU32

Set the maximum RPC response payload size for both HTTP and WS in megabytes.

rpc_max_subscriptions_per_connection: MaxU32

Set the maximum concurrent subscriptions per connection.

rpc_max_connections: MaxU32

Maximum number of RPC server connections.

rpc_max_tracing_requests: usize

Maximum number of concurrent tracing requests.

By default this chooses a sensible value based on the number of available cores. Tracing requests are generally CPU bound. Choosing a value that is higher than the available CPU cores can have a negative impact on the performance of the node and affect the node’s ability to maintain sync.

rpc_max_blocks_per_filter: ZeroAsNoneU64

Maximum number of blocks that could be scanned per filter request. (0 = entire chain)

rpc_max_logs_per_response: ZeroAsNoneU64

Maximum number of logs that can be returned in a single response. (0 = no limit)

rpc_gas_cap: u64

Maximum gas limit for eth_call and call tracing RPC methods.

rpc_max_simulate_blocks: u64

Maximum number of blocks for eth_simulateV1 call.

rpc_eth_proof_window: u64

The maximum proof window for historical proof generation. This value allows for generating historical proofs up to configured number of blocks from current tip (up to tip - window).

rpc_proof_permits: usize

Maximum number of concurrent getproof requests.

builder_disallow: Option<HashSet<Address>>

Path to file containing disallowed addresses, json-encoded list of strings. Block validation API will reject blocks containing transactions from these addresses.

rpc_state_cache: RpcStateCacheArgs

State cache configuration.

gas_price_oracle: GasPriceOracleArgs

Gas price oracle configuration.

Implementations

impl RpcServerArgs

pub const fn with_http(self) -> RpcServerArgs

Enables the HTTP-RPC server.

pub fn with_http_api(self, http_api: RpcModuleSelection) -> RpcServerArgs

Configures modules for the HTTP-RPC server.

pub const fn with_ws(self) -> RpcServerArgs

Enables the WS-RPC server.

pub const fn with_auth_ipc(self) -> RpcServerArgs

Enables the Auth IPC

pub fn adjust_instance_ports(&mut self, instance: u16)

Change rpc port numbers based on the instance number.

• The auth_port is scaled by a factor of instance * 100
• The http_port is scaled by a factor of -instance
• The ws_port is scaled by a factor of instance * 2
• The ipcpath is appended with the instance number: /tmp/reth.ipc-<instance>

Panics

Warning: if instance is zero in debug mode, this will panic.

This will also panic in debug mode if either:

• instance is greater than 655 (scaling would overflow u16)
• self.auth_port / 100 + (instance - 1) would overflow u16

In release mode, this will silently wrap around.

pub const fn with_http_unused_port(self) -> RpcServerArgs

Set the http port to zero, to allow the OS to assign a random unused port when the rpc server binds to a socket.

pub const fn with_ws_unused_port(self) -> RpcServerArgs

Set the ws port to zero, to allow the OS to assign a random unused port when the rpc server binds to a socket.

pub const fn with_auth_unused_port(self) -> RpcServerArgs

Set the auth port to zero, to allow the OS to assign a random unused port when the rpc server binds to a socket.

pub fn with_ipc_random_path(self) -> RpcServerArgs

Append a random string to the ipc path, to prevent possible collisions when multiple nodes are being run on the same machine.

pub fn with_unused_ports(self) -> RpcServerArgs

Configure all ports to be set to a random unused port when bound, and set the IPC path to a random path.

Trait Implementations

impl Args for RpcServerArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for RpcServerArgs

fn clone(&self) -> RpcServerArgs

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RpcServerArgs

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RpcServerArgs

fn default() -> RpcServerArgs

Returns the “default value” for a type.

impl FromArgMatches for RpcServerArgs

fn from_arg_matches( __clap_arg_matches: &ArgMatches, ) -> Result<RpcServerArgs, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<RpcServerArgs, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for RpcServerArgs

fn eq(&self, other: &RpcServerArgs) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RethRpcServerConfig for RpcServerArgs

fn is_ipc_enabled(&self) -> bool

Returns whether ipc is enabled.

fn ipc_path(&self) -> &str

Returns the path to the target ipc socket if enabled.

fn eth_config(&self) -> EthConfig

The configured ethereum RPC settings.

fn flashbots_config(&self) -> ValidationApiConfig

The configured ethereum RPC settings.

fn state_cache_config(&self) -> EthStateCacheConfig

Returns state cache configuration.

fn rpc_max_request_size_bytes(&self) -> u32

Returns the max request size in bytes.

fn rpc_max_response_size_bytes(&self) -> u32

Returns the max response size in bytes.

fn gas_price_oracle_config(&self) -> GasPriceOracleConfig

Extracts the gas price oracle config from the args.

fn transport_rpc_module_config(&self) -> TransportRpcModuleConfig

Creates the TransportRpcModuleConfig from cli args.

fn http_ws_server_builder(&self) -> Builder<Identity, Identity>

Returns the default server builder for http/ws

fn ipc_server_builder(&self) -> Builder<Identity, Identity>

Returns the default ipc server builder

fn rpc_server_config(&self) -> RpcServerConfig

Creates the RpcServerConfig from cli args.

fn auth_server_config( &self, jwt_secret: JwtSecret, ) -> Result<AuthServerConfig, RpcError>

Creates the AuthServerConfig from cli args.

fn auth_jwt_secret( &self, default_jwt_path: PathBuf, ) -> Result<JwtSecret, JwtError>

The execution layer and consensus layer clients SHOULD accept a configuration parameter: jwt-secret, which designates a file containing the hex-encoded 256 bit secret key to be used for verifying/generating JWT tokens.

fn rpc_secret_key(&self) -> Option<JwtSecret>

Returns the configured jwt secret key for the regular rpc servers, if any.

impl Eq for RpcServerArgs

impl StructuralPartialEq for RpcServerArgs

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 512 bytes