Type Alias centrifuge_chain::rpc::RpcExtension
source · pub type RpcExtension = RpcModule<()>;
Expand description
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_with_name(
&self,
method_name: &str
) -> Option<(&'static str, &MethodCallback)>
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,
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>
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>
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>
pub fn method_names(&self) -> impl Iterator<Item = &'static str>
Returns an Iterator
with all the method names registered on this server.