Add a transports crate & initial Network abstraction

Cargo.toml

@@ -8,12 +8,30 @@ edition = "2021"
 rust-version = "1.65"
 authors = ["Alloy Contributors"]
 license = "MIT OR Apache-2.0"
-homepage = "https://github.com/ethers-rs/next"
-repository = "https://github.com/ethers-rs/next"
+homepage = "https://github.com/alloy-rs/next"
+repository = "https://github.com/alloy-rs/next"
 exclude = ["benches/", "tests/"]
 
 [workspace.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[workspace.dependencies]
+[workspace.dependencies]
+
+alloy-json-rpc = { path = "crates/json-rpc" }
+alloy-transports = { path = "crates/transports" }
+alloy-networks = { path = "crates/networks" }
+
+alloy-primitives = { version = "0.2.0", features = ["serde"] }
+alloy-rlp = "0.3.0"
+
+# futures
+futures-channel = "0.3"
+futures-util = "0.3"
+
+# serde
+serde = { version = "1.0", default-features = false, features = ["alloc"] }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+
+# thiserror
+thiserror = "1.0"

crates/json-rpc/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "alloy-json-rpc"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+exclude.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { workspace = true, features = ["derive"] }
+serde_json = { version = "1.0.103", features = ["raw_value"] }

crates/json-rpc/src/common.rs

@@ -0,0 +1,15 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[serde(untagged)]
+pub enum Id {
+    Number(u64),
+    String(String),
+    None,
+}
+
+impl Id {
+    pub fn is_none(&self) -> bool {
+        matches!(self, Id::None)
+    }
+}

crates/json-rpc/src/lib.rs

@@ -0,0 +1,24 @@
+use serde::{de::DeserializeOwned, Serialize};
+
+mod request;
+pub use request::JsonRpcRequest;
+
+mod response;
+pub use response::{ErrorPayload, JsonRpcResponse, ResponsePayload};
+
+mod common;
+pub use common::Id;
+
+mod result;
+pub use result::RpcResult;
+
+pub trait RpcParam: Serialize + Clone + Send + Sync + Unpin {}
+impl<T> RpcParam for T where T: Serialize + Clone + Send + Sync + Unpin {}
+
+// Note: we add `'static` here to indicate that the Resp is wholly owned. it
+// may not borrow.
+pub trait RpcReturn: DeserializeOwned + Send + Sync + Unpin + 'static {}
+impl<T> RpcReturn for T where T: DeserializeOwned + Send + Sync + Unpin + 'static {}
+
+pub trait RpcObject: RpcParam + RpcReturn {}
+impl<T> RpcObject for T where T: RpcParam + RpcReturn {}

crates/json-rpc/src/request.rs

@@ -0,0 +1,27 @@
+use crate::{common::Id, RpcParam};
+
+use serde::{ser::SerializeMap, Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct JsonRpcRequest<Params> {
+    pub method: &'static str,
+    pub params: Params,
+    pub id: Id,
+}
+
+impl<Params> Serialize for JsonRpcRequest<Params>
+where
+    Params: RpcParam,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(4))?;
+        map.serialize_entry("method", self.method)?;
+        map.serialize_entry("params", &self.params)?;
+        map.serialize_entry("id", &self.id)?;
+        map.serialize_entry("jsonrpc", "2.0")?;
+        map.end()
+    }
+}

crates/json-rpc/src/response.rs

@@ -0,0 +1,216 @@
+use std::fmt;
+
+use serde::{
+    de::{MapAccess, Visitor},
+    Deserialize, Deserializer, Serialize,
+};
+use serde_json::value::RawValue;
+
+use crate::common::Id;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ErrorPayload {
+    pub code: i64,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<Box<RawValue>>,
+}
+
+#[derive(Debug, Clone)]
+pub enum ResponsePayload {
+    Success(Box<RawValue>),
+    Error(ErrorPayload),
+}
+
+pub struct JsonRpcResponse {
+    pub id: Id,
+    pub payload: ResponsePayload,
+}
+
+impl<'de> Deserialize<'de> for JsonRpcResponse {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        enum Field {
+            Result,
+            Error,
+            Id,
+            Unknown,
+        }
+
+        impl<'de> Deserialize<'de> for Field {
+            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        formatter.write_str("`result`, `error` and `id`")
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "result" => Ok(Field::Result),
+                            "error" => Ok(Field::Error),
+                            "id" => Ok(Field::Id),
+                            _ => Ok(Field::Unknown),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct JsonRpcResponseVisitor;
+
+        impl<'de> Visitor<'de> for JsonRpcResponseVisitor {
+            type Value = JsonRpcResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str(
+                    "a JSON-RPC response object, consisting of either a result or an error",
+                )
+            }
+
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'de>,
+            {
+                let mut result = None;
+                let mut error = None;
+                let mut id: Option<Id> = None;
+
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Result => {
+                            if result.is_some() {
+                                return Err(serde::de::Error::duplicate_field("result"));
+                            }
+                            result = Some(map.next_value()?);
+                        }
+                        Field::Error => {
+                            if error.is_some() {
+                                return Err(serde::de::Error::duplicate_field("error"));
+                            }
+                            error = Some(map.next_value()?);
+                        }
+                        Field::Id => {
+                            if id.is_some() {
+                                return Err(serde::de::Error::duplicate_field("id"));
+                            }
+                            id = Some(map.next_value()?);
+                        }
+                        Field::Unknown => {
+                            let _: serde::de::IgnoredAny = map.next_value()?; // ignore
+                        }
+                    }
+                }
+                let id = id.unwrap_or(Id::None);
+
+                match (result, error) {
+                    (Some(result), None) => Ok(JsonRpcResponse {
+                        id,
+                        payload: ResponsePayload::Success(result),
+                    }),
+                    (None, Some(error)) => Ok(JsonRpcResponse {
+                        id,
+                        payload: ResponsePayload::Error(error),
+                    }),
+                    (None, None) => Err(serde::de::Error::missing_field("result or error")),
+                    (Some(_), Some(_)) => Err(serde::de::Error::custom(
+                        "result and error are mutually exclusive",
+                    )),
+                }
+            }
+        }
+
+        deserializer.deserialize_map(JsonRpcResponseVisitor)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    pub fn deser_success() {
+        let response = r#"{
+            "jsonrpc": "2.0",
+            "result": "california",
+            "id": 1
+        }"#;
+        let response: super::JsonRpcResponse = serde_json::from_str(response).unwrap();
+        assert_eq!(response.id, super::Id::Number(1));
+        assert!(matches!(
+            response.payload,
+            super::ResponsePayload::Success(_)
+        ));
+    }
+
+    #[test]
+    pub fn deser_err() {
+        let response = r#"{
+            "jsonrpc": "2.0",
+            "error": {
+                "code": -32600,
+                "message": "Invalid Request"
+            },
+            "id": null
+        }"#;
+        let response: super::JsonRpcResponse = serde_json::from_str(response).unwrap();
+        assert_eq!(response.id, super::Id::None);
+        assert!(matches!(response.payload, super::ResponsePayload::Error(_)));
+    }
+
+    #[test]
+    pub fn deser_complex_success() {
+        let response = r#"{
+            "result": {
+                "name": "california",
+                "population": 39250000,
+                "cities": [
+                    "los angeles",
+                    "san francisco"
+                ]
+            }
+        }"#;
+        let response: super::JsonRpcResponse = serde_json::from_str(response).unwrap();
+        assert_eq!(response.id, super::Id::None);
+        assert!(matches!(
+            response.payload,
+            super::ResponsePayload::Success(_)
+        ));
+    }
+}
+
+// Copyright 2019-2021 Parity Technologies (UK) Ltd.
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.