Type Alias centrifuge_chain::rpc::RpcExtension

pub type RpcExtension = RpcModule<()>;

A type representing all RPC extensions.

Aliased Type

struct RpcExtension {
    ctx: Arc<(), Global>,
    methods: Methods,
}

Fields

ctx: Arc<(), Global>

methods: Methods

Methods from Deref<Target = Methods>

pub fn method(&self, method_name: &str) -> Option<&MethodCallback>

Returns the method callback.

pub fn method_with_name( &self, method_name: &str ) -> Option<(&'static str, &MethodCallback)>

Returns the method callback along with its name. The returned name is same as the method_name, but its lifetime bound is 'static.

pub async fn call<Params, T>( &self, method: &str, params: Params ) -> Result<T, Error>where Params: ToRpcParams, T: DeserializeOwned,

Helper to call a method on the RPC module without having to spin up a server.

The params must be serializable as JSON array, see [ToRpcParams] for further documentation.

Returns the decoded value of the result field in JSON-RPC response if successful.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::RpcModule;

    let mut module = RpcModule::new(());
    module.register_method("echo_call", |params, _| {
        params.one::<u64>().map_err(Into::into)
    }).unwrap();

    let echo: u64 = module.call("echo_call", [1_u64]).await.unwrap();
    assert_eq!(echo, 1);
}

pub async fn raw_json_request( &self, request: &str ) -> Result<(MethodResponse, UnboundedReceiver<String>), Error>

Make a request (JSON-RPC method call or subscription) by using raw JSON.

Returns the raw JSON response to the call and a stream to receive notifications if the call was a subscription.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::RpcModule;
    use jsonrpsee::types::Response;
    use futures_util::StreamExt;

    let mut module = RpcModule::new(());
    module.register_subscription("hi", "hi", "goodbye", |_, mut sink, _| {
        sink.send(&"one answer").unwrap();
        Ok(())
    }).unwrap();
    let (resp, mut stream) = module.raw_json_request(r#"{"jsonrpc":"2.0","method":"hi","id":0}"#).await.unwrap();
    let resp = serde_json::from_str::<Response<u64>>(&resp.result).unwrap();
    let sub_resp = stream.next().await.unwrap();
    assert_eq!(
        format!(r#"{{"jsonrpc":"2.0","method":"hi","params":{{"subscription":{},"result":"one answer"}}}}"#, resp.result),
        sub_resp
    );
}

pub async fn subscribe( &self, sub_method: &str, params: impl ToRpcParams ) -> Result<Subscription, Error>

Helper to create a subscription on the RPC module without having to spin up a server.

The params must be serializable as JSON array, see [ToRpcParams] for further documentation.

Returns [Subscription] on success which can used to get results from the subscriptions.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::{RpcModule, types::EmptyServerParams};

    let mut module = RpcModule::new(());
    module.register_subscription("hi", "hi", "goodbye", |_, mut sink, _| {
        sink.send(&"one answer").unwrap();
        Ok(())
    }).unwrap();

    let mut sub = module.subscribe("hi", EmptyServerParams::new()).await.unwrap();
    // In this case we ignore the subscription ID,
    let (sub_resp, _sub_id) = sub.next::<String>().await.unwrap().unwrap();
    assert_eq!(&sub_resp, "one answer");
}

pub fn method_names(&self) -> impl Iterator<Item = &'static str>

Returns an Iterator with all the method names registered on this server.

Trait Implementations

impl<Context> Deref for RpcModule<Context>

type Target = Methods

The resulting type after dereferencing.

fn deref(&self) -> &Methods

Dereferences the value.