casper-json-rpc

A library suitable for use as the framework for a JSON-RPC server.

Usage

Normally usage will involve two steps: * construct a set of request handlers using a RequestHandlersBuilder * call casper_json_rpc::route to construct a boxed warp filter ready to be passed to warp::service for example

Example

```rust use casperjsonrpc::{Error, Params, RequestHandlersBuilder}; use std::{convert::Infallible, sync::Arc};

async fn get(params: Option) -> Result { // * parse params or return ReservedErrorCode::InvalidParams error // * handle request and return result Ok("got it".to_string()) }

async fn put(params: Option, otherinput: &str) -> Result { Ok(otherinput.to_string()) }

[tokio::main]

async fn main() { // Register handlers for methods "get" and "put". let mut handlers = RequestHandlersBuilder::new(); handlers.registerhandler("get", Arc::new(get)); let puthandler = move |params| async move { put(params, "other input").await }; handlers.registerhandler("put", Arc::new(puthandler)); let handlers = handlers.build();

// Get the new route.
let path = "rpc";
let max_body_bytes = 1024;
let route = casper_json_rpc::route(path, max_body_bytes, handlers);

// Convert it into a `Service` and run it.
let make_svc = hyper::service::make_service_fn(move |_| {
    let svc = warp::service(route.clone());
    async move { Ok::<_, Infallible>(svc.clone()) }
});

hyper::Server::bind(&([127, 0, 0, 1], 3030).into())
    .serve(make_svc)
    .await
    .unwrap();

} ```

If this receives a request such as

curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":"id","method":"get"}' http://127.0.0.1:3030/rpc

then the server will respond with

json {"jsonrpc":"2.0","id":"id","result":"got it"}

Errors

To return a JSON-RPC response indicating an error, use Error::new. Most error conditions which require returning a reserved error are already handled in the provided warp filters. The only exception is ReservedErrorCode::InvalidParams which should be returned by any RPC handler which deems the provided params: Option<Params> to be invalid for any reason.

Generally a set of custom error codes should be provided. These should all implement ErrorCodeT.

Example custom error code

```rust use serde::{Deserialize, Serialize}; use casperjsonrpc::ErrorCodeT;

[derive(Copy, Clone, Eq, PartialEq, Serialize, Deserialize, Debug)]

[repr(i64)]

pub enum ErrorCode { /// The requested item was not found. NoSuchItem = -1, /// Failed to put the requested item to storage. FailedToPutItem = -2, }

impl From for (i64, &'static str) { fn from(errorcode: ErrorCode) -> Self { match errorcode { ErrorCode::NoSuchItem => (errorcode as i64, "No such item"), ErrorCode::FailedToPutItem => (errorcode as i64, "Failed to put item"), } } }

impl ErrorCodeT for ErrorCode {} ```

License

Licensed under the Apache License Version 2.0.