Does this library handle serialization?

[Redhawk18]

Hi everyone! I'm at the beginning of working on a crypto miner and to start I'm working on making a crate that implements this protocol.

Do I need to bring serde into my project to create a sturct from this json?

{"id": 1, "method": "mining.subscribe", "params": ["MyMiner/1.0.0", null, "my.pool.com", 1234]}
{"id": null, "method": "mining.set_target", "params": ["FFFF000000000000000000000000000000000000000000000000000000000000"]}
{"id": 4, "method": "mining.submit", "params": ["WORKER_NAME", "d70fd222", "98b6ac44d2", ""]}

Also how would you recommend having different params? It's a tuple of strings and ints in different orders depending on the method.

[niklasad1]

Hey @Redhawk18

Yes, the library handles serialization/de-serialization but it requires the individual types to implement serde.
For primitive type such as String it just works but if you need a custom serialization e.g. hex encoded you need something custom.

So for instance the easiest for you is to use the proc macro API that takes care of it for you:

#[rpc(server)]
pub trait Api {
	#[method(name = "mining.set_target")]
	async fn set_target(
		&self,
		// you probably need another type here
		target: String,
	) -> Result<(), ErrorObjectOwned>;

	#[method(name = "mining.subscribe")]
	async fn subscribe(
		&self,
		version: String,
		session_id: String,
		host: String,
		port: usize,
	) -> Result<Vec<String>, ErrorObjectOwned>;
}

Please have a look over the examples which shows how use it.

[Redhawk18]

Thank you for responding! This is my updated code with your example, I should also say I'm using websockets.

// what I send to the server
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Login {
    pub id: usize,
    pub jsonrpc: &'static str,
    pub method: &'static str,
    pub params: Parameter,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Parameter {
    pub login: &'static str,
    pub pass: &'static str,
    pub agent: &'static str,
    pub rigid: &'static str,
    pub algo: Vec<&'static str>,
}

// what I should get back
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Response {
    pub id: usize,
    pub jsonrpc: &'static str,
    pub result: Result,
    pub error: Value,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Result {
    pub id: usize,
    pub job: Job,
    pub status: &'static str,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Job {
    pub id: usize,
    pub algo: &'static str,
    pub blob: &'static str,
    pub height: i64,
    pub job_id: usize,
    pub seed_hash: &'static str,
    pub target: &'static str,
}

#[rpc(server)]
trait Rpc {
    #[method(name = "login")]
    async fn send(&self) -> std::result::Result<(), ErrorObjectOwned> {
        todo!()
    }
}

impl Login {
    pub fn new(id: usize, wallet: &'static str, password: &'static str) -> Self {
        Self {
            id,
            jsonrpc: "2.0",
            method: "login",
            params: Parameter {
                login: wallet,
                pass: password,
                agent: "miner/0.1.0",
                rigid: "mythra-test",
                algo: Vec::default(),
            },
        }
    }
}

The part I need help with is how do I send the first struct as a json? I need it to follow this format and I think I've represented it correctly.

Also is there a way I can generate fields like the jsonrpc field that is always "2.0"?

[niklasad1]

Hey again,

I thought you wanted to write a server implementation but you are using the client alright.

Also is there a way I can generate fields like the jsonrpc field that is always "2.0"?

jsonrpsee takes care of that for you and you don't have to define request and response types with jsonrpc specific stuff.

So another example how to use a typed client for your use-case and to call mining.subscribe you can do it as follows:

#[rpc(client)]
pub trait Rpc {
	#[method(name = "mining.subscribe")]
	async fn subscribe(
		&self,
		version: String,
		session_id: String,
		host: String,
		port: usize,
	) -> Result<(String, String), ErrorObjectOwned>;
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
	// create a websocket connection.
	let client = WsClientBuilder::default().build("ws://localhost:9944").await?;
	// call `mining.subscribe` which returns (String, String) on success.
	let rp = client.subscribe("MyMiner/1.0.0".to_string(), "1".to_string(), "my.pool.com".to_string(), 1234).await?;

	Ok(())
}

Hopefully clear enough for you to unblock you... and you just have to provide similar stuff for the rest of the API.

[Redhawk18]

One last question, if building the web socket fails and the server hangs up or gives an eof what did I do wrong? Is it a malformed request? I don't really have a way to know. Also what about ids for requests that jsonrpc usually requires? Should I just pass those in as another field?

[niklasad1]

Hmm, what do you mean by websocket fails?
Does the connecting to the server works but it fails when you make the rpc call or something else?

Enable `RUST_LOG="jsonrpsee=trace,soketto=trace", run your app and paste the logs please.

However, you shouldn't get EOF regardless but perhaps it's server impl thingy not sure...

[Redhawk18]

Hmm, what do you mean by websocket fails? Does the connecting to the server works but it fails when you make the rpc call or something else?

Enable `RUST_LOG="jsonrpsee=trace,soketto=trace", run your app and paste the logs please.

However, you shouldn't get EOF regardless but perhaps it's server impl thingy not sure...

It looks like it doesn't connect, at all

    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running unittests src/lib.rs (/home/redhawk/code/miner/target/debug/deps/stratum-da85f43c486bea96)

running 1 test
 DEBUG jsonrpsee-client > Connecting to target: Target { host: "monerop.com", host_header: "monerop.com:4242", _mode: Plain, path_and_query: "/", basic_auth: None }
 DEBUG jsonrpsee-client > Connecting to target: Target { host: "monerop.com", host_header: "monerop.com:4242", _mode: Plain, path_and_query: "/", basic_auth: None }
 DEBUG jsonrpsee-client > Connecting to target: Target { host: "monerop.com", host_header: "monerop.com:4242", _mode: Plain, path_and_query: "/", basic_auth: None }
 DEBUG jsonrpsee-client > Connecting to target: Target { host: "monerop.com", host_header: "monerop.com:4242", _mode: Plain, path_and_query: "/", basic_auth: None }
 DEBUG jsonrpsee-client > Connecting to target: Target { host: "monerop.com", host_header: "monerop.com:4242", _mode: Plain, path_and_query: "/", basic_auth: None }
test test::connect_to_pool ... FAILED

failures:

---- test::connect_to_pool stdout ----
thread 'test::connect_to_pool' panicked at stratum/src/test.rs:17:10:
called `Result::unwrap()` on an `Err` value: Transport(Transport(Io(Kind(UnexpectedEof))))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    test::connect_to_pool

[niklasad1]

Are you sure the URL is valid including the port?

Try some other tool such as cURL, websocat or something to check it

[Redhawk18]

Are you sure the URL is valid including the port?

Try some other tool such as cURL, websocat or something to check it

I got it thank you, it turns out I assumed websockets were used but this protocol uses the 1970 plain sockets and jsons are sent over the wire. Thanks