Struct alloy_rpc_client::RpcCall

pub struct RpcCall<Conn, Params, Resp, Output = Resp, Map = fn(_: Resp) -> Output>
where
    Conn: Transport + Clone,
    Params: RpcParam,
    Map: FnOnce(Resp) -> Output,
{ /* private fields */ }

A prepared, but unsent, RPC call.

This is a future that will send the request when polled. It contains a Request, a Transport, and knowledge of its expected response type. Upon awaiting, it will send the request and wait for the response. It will then deserialize the response into the expected type.

Errors are captured in the RpcResult type. Rpc Calls will result in either a successful response of the Resp type, an error response, or a transport error.

Note

Serializing the request is done lazily. The request is not serialized until the future is polled. This differs from the behavior of crate::BatchRequest, which serializes greedily. This is because the batch request must immediately erase the Param type to allow batching of requests with different Param types, while the RpcCall may do so lazily.

Implementations

impl<Conn, Params, Resp, Output, Map> RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Map: FnOnce(Resp) -> Output,

pub fn map_resp<NewOutput, NewMap>( self, map: NewMap, ) -> RpcCall<Conn, Params, Resp, NewOutput, NewMap>

where NewMap: FnOnce(Resp) -> NewOutput,

Map the response to a different type. This is usable for converting the response to a more usable type, e.g. changing U64 to u64.

Note

Carefully review the rust documentation on fn pointers before passing them to this function. Unless the pointer is specifically coerced to a fn(_) -> _, the NewMap will be inferred as that function’s unique type. This can lead to confusing error messages.

pub fn is_subscription(&self) -> bool

Returns true if the request is a subscription.

Panics

Panics if called after the request has been sent.

pub fn set_is_subscription(&mut self)

Set the request to be a non-standard subscription (i.e. not “eth_subscribe”).

Panics

Panics if called after the request has been sent.

pub fn set_subscription_status(&mut self, status: bool)

Set the subscription status of the request.

pub fn params(&mut self) -> &mut Params

Get a mutable reference to the params of the request.

This is useful for modifying the params after the request has been prepared.

Panics

Panics if called after the request has been sent.

pub fn request(&self) -> &Request<Params>

Returns a reference to the request.

Panics

Panics if called after the request has been sent.

pub fn request_mut(&mut self) -> &mut Request<Params>

Returns a mutable reference to the request.

Panics

Panics if called after the request has been sent.

pub fn map_params<NewParams: RpcParam>( self, map: impl Fn(Params) -> NewParams, ) -> RpcCall<Conn, NewParams, Resp, Output, Map>

Map the params of the request into a new type.

impl<Conn, Params, Resp, Output, Map> RpcCall<Conn, &Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam + ToOwned, Params::Owned: RpcParam, Map: FnOnce(Resp) -> Output,

pub fn into_owned_params( self, ) -> RpcCall<Conn, Params::Owned, Resp, Output, Map>

Convert this call into one with owned params, by cloning the params.

Panics

Panics if called after the request has been polled.

impl<'a, Conn, Params, Resp, Output, Map> RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam + 'a, Resp: RpcReturn, Output: 'static, Map: FnOnce(Resp) -> Output + Send + 'a,

pub fn boxed(self) -> RpcFut<'a, Output>

Convert this future into a boxed, pinned future, erasing its type.

Trait Implementations

impl<Conn, Params, Resp: Clone, Output: Clone, Map> Clone for RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone + Clone, Params: RpcParam + Clone, Map: FnOnce(Resp) -> Output + Clone,

fn clone(&self) -> RpcCall<Conn, Params, Resp, Output, Map>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Conn, Params, Resp, Output, Map> Debug for RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Map: FnOnce(Resp) -> Output,

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

Formats the value using the given formatter.

impl<Conn, Params, Resp, Output, Map> Future for RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Resp: RpcReturn, Output: 'static, Map: FnOnce(Resp) -> Output,

type Output = Result<Output, RpcError<TransportErrorKind>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'pin, Conn, Params, Resp, Output, Map> Unpin for RpcCall<Conn, Params, Resp, Output, Map>

where Conn: Transport + Clone, Params: RpcParam, Map: FnOnce(Resp) -> Output, __RpcCall<'pin, Conn, Params, Resp, Output, Map>: Unpin,