chore: delete eth for now

Cargo.toml

@@ -35,7 +35,6 @@ incremental = false
 
 [workspace.dependencies]
 router = { path = "./crates/router" }
-eth = { path = "./crates/eth" }
 pubsub = { path = "./crates/pubsub" }
 
 # alloy = { version = "0.9.2", features = ["json-rpc", "rpc-types"] }

crates/router/src/ctx.rs

@@ -22,20 +22,22 @@ impl From<mpsc::Sender<Box<RawValue>>> for HandlerCtx {
 
 impl HandlerCtx {
     /// Instantiate a new handler context.
-    pub fn new() -> Self {
-        Default::default()
+    pub const fn new() -> Self {
+        Self {
+            notifications: None,
+        }
     }
 
     /// Instantiation a new handler context with notifications enabled.
-    pub fn with_notifications(notifications: mpsc::Sender<Box<RawValue>>) -> Self {
+    pub const fn with_notifications(notifications: mpsc::Sender<Box<RawValue>>) -> Self {
         Self {
             notifications: Some(notifications),
         }
     }
 
     /// Get a reference to the notification sender. This is used to
     /// send notifications over pubsub transports.
-    pub fn notifications(&self) -> Option<&mpsc::Sender<Box<RawValue>>> {
+    pub const fn notifications(&self) -> Option<&mpsc::Sender<Box<RawValue>>> {
         self.notifications.as_ref()
     }
 }

crates/router/src/error.rs

@@ -3,6 +3,7 @@ use std::borrow::Cow;
 /// Errors that can occur when registering a method.
 #[derive(Debug, Clone, thiserror::Error)]
 pub enum RegistrationError {
+    /// Method name is already in use.
     #[error("Method already registered: {0}")]
     MethodAlreadyRegistered(Cow<'static, str>),
 }

crates/router/src/lib.rs

@@ -12,7 +12,17 @@
 //!
 //! [`axum`]: https://docs.rs/axum/latest/axum/index.html
 //! [`axum::Router`]: https://docs.rs/axum/latest/axum/routing/struct.Router.html
+
+#![warn(
+    missing_copy_implementations,
+    missing_debug_implementations,
+    missing_docs,
+    unreachable_pub,
+    clippy::missing_const_for_fn,
+    rustdoc::all
+)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies))]
+#![deny(unused_must_use, rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
 #[macro_use]
@@ -32,7 +42,7 @@ pub use primitives::MethodId;
 
 mod routes;
 pub(crate) use routes::{BoxedIntoRoute, ErasedIntoRoute, Method};
-pub use routes::{Handler, HandlerService, Route};
+pub use routes::{Handler, HandlerArgs, HandlerService, MethodFuture, Route};
 
 mod router;
 pub use router::Router;

crates/router/src/router.rs

@@ -318,6 +318,12 @@ where
 
         MethodFuture::new(id, fut)
     }
+
+    /// Nest this router into a new Axum router, with the specified path.
+    #[cfg(feature = "axum")]
+    pub fn into_axum(self, path: &str) -> axum::Router<S> {
+        axum::Router::new().route(path, axum::routing::post(self))
+    }
 }
 
 impl Router<()> {
@@ -393,7 +399,7 @@ impl<S> fmt::Debug for RouterInner<S> {
 
 impl<S> RouterInner<S> {
     /// Create a new, empty router.
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self {
             routes: BTreeMap::new(),
 
@@ -410,7 +416,7 @@ impl<S> RouterInner<S> {
     ///
     /// Note that the type parameter `S2` is NOT the state you are adding to the
     /// router. It is additional state that must be added AFTER the state `S`.
-    pub fn with_state<S2>(self, state: &S) -> RouterInner<S2>
+    pub(crate) fn with_state<S2>(self, state: &S) -> RouterInner<S2>
     where
         S: Clone,
     {
@@ -527,7 +533,7 @@ impl<S> RouterInner<S> {
     ///
     /// Panic if the method name already exists in the router.
     #[track_caller]
-    pub fn route_service<T>(self, method: impl Into<Cow<'static, str>>, service: T) -> Self
+    pub(crate) fn route_service<T>(self, method: impl Into<Cow<'static, str>>, service: T) -> Self
     where
         T: Service<
                 (HandlerCtx, Box<RawValue>),

crates/router/src/routes/erased.rs

@@ -33,15 +33,13 @@ pub(crate) trait ErasedIntoRoute<S>: Send + Sync {
 ///
 /// Similar to axum's [`BoxedIntoRoute`]
 ///
-/// Currently this is a placeholder to enable future convenience functions.
-///
 /// [`BoxedIntoRoute`]: https://github.com/tokio-rs/axum/blob/18a99da0b0baf9eeef326b34525826ae0b5a1370/axum/src/boxed.rs#L12
 pub(crate) struct BoxedIntoRoute<S>(pub(crate) Box<dyn ErasedIntoRoute<S>>);
 
 #[allow(dead_code)]
 impl<S> BoxedIntoRoute<S> {
     /// Convert this into a [`Route`] with the given state.
-    pub fn into_route(self, state: S) -> Route {
+    pub(crate) fn into_route(self, state: S) -> Route {
         self.0.into_route(state)
     }
 }
@@ -85,7 +83,7 @@ where
 impl<H, S> MakeErasedHandler<H, S> {
     /// Create a new [`MakeErasedHandler`] with the given handler and conversion
     /// function.
-    pub fn from_handler<T>(handler: H) -> Self
+    pub(crate) fn from_handler<T>(handler: H) -> Self
     where
         H: Handler<T, S>,
         T: Send + 'static,

crates/router/src/routes/future.rs

@@ -23,7 +23,7 @@ pub struct RouteFuture {
 
 impl RouteFuture {
     /// Create a new route future.
-    pub fn new(
+    pub const fn new(
         inner: Oneshot<BoxCloneSyncService<HandlerArgs, ResponsePayload, Infallible>, HandlerArgs>,
     ) -> Self {
         Self { inner }
@@ -44,6 +44,8 @@ impl Future for RouteFuture {
     }
 }
 
+/// A future for a method, containing the request ID, and the inner future
+/// which resolves to the response.
 #[pin_project]
 pub struct MethodFuture {
     /// The request ID. Guaranteed to be `Some` until the future is completed.
@@ -55,7 +57,7 @@ pub struct MethodFuture {
 
 impl MethodFuture {
     /// Create a new method future.
-    pub fn new(id: Id, fut: RouteFuture) -> Self {
+    pub const fn new(id: Id, fut: RouteFuture) -> Self {
         Self {
             inner: fut,
             id: Some(id),

crates/router/src/routes/method.rs

@@ -23,7 +23,12 @@ impl<S> Clone for Method<S> {
 
 impl<S> Method<S> {
     /// Call the method with the given state and request.
-    pub fn call_with_state(&self, ctx: HandlerCtx, req: Box<RawValue>, state: S) -> RouteFuture {
+    pub(crate) fn call_with_state(
+        &self,
+        ctx: HandlerCtx,
+        req: Box<RawValue>,
+        state: S,
+    ) -> RouteFuture {
         match self {
             Self::Ready(route) => route.clone().oneshot_inner_owned(ctx, req),
             Self::Needs(handler) => handler
@@ -40,7 +45,7 @@ where
     S: Clone,
 {
     /// Add state to a method, converting
-    pub fn with_state<S2>(self, state: &S) -> Method<S2> {
+    pub(crate) fn with_state<S2>(self, state: &S) -> Method<S2> {
         match self {
             Self::Ready(route) => Method::Ready(route),
             Self::Needs(handler) => Method::Ready(handler.0.into_route(state.clone())),

crates/router/src/routes/mod.rs

@@ -29,6 +29,7 @@ pub type HandlerArgs = (HandlerCtx, Box<RawValue>);
 /// a JSON-RPC [`ResponsePayload`]. Routes SHOULD be infallible. I.e. any error
 /// that occurs during the handling of a request should be represented as a
 /// JSON-RPC error response, rather than having the service return an `Err`.
+#[derive(Debug)]
 pub struct Route(tower::util::BoxCloneSyncService<HandlerArgs, ResponsePayload, Infallible>);
 
 impl Route {