keyfork-derive-util/src/private_key.rs

@@ -45,6 +45,7 @@ pub trait PrivateKey: Sized {
     fn requires_hardened_derivation() -> bool {
         false
     }
+
 }
 
 /// Errors associated with creating and arithmetic on private keys. This specific error is only

keyfork-derive-util/src/request.rs

@@ -1,6 +1,4 @@
-use crate::{
-    extended_key::private_key::Error as XPrvError, DerivationPath, ExtendedPrivateKey, PrivateKey,
-};
+use crate::{extended_key::private_key::Error as XPrvError, DerivationPath, ExtendedPrivateKey, PrivateKey};
 use keyfork_mnemonic_util::Mnemonic;
 use serde::{Deserialize, Serialize};
 

keyforkd/src/lib.rs

@@ -16,7 +16,7 @@ use service::Keyforkd;
 
 pub async fn start_and_run_server(mnemonic: Mnemonic) -> Result<(), Box<dyn std::error::Error>> {
     let service = ServiceBuilder::new()
-        .layer(middleware::BincodeLayer::new())
+        .layer(middleware::SerdeLayer::new())
         .service(Keyforkd::new(mnemonic));
 
     let runtime_vars = std::env::vars()

keyforkd/src/middleware.rs

@@ -5,12 +5,12 @@ use serde::{de::DeserializeOwned, Serialize};
 use thiserror::Error;
 use tower::{Layer, Service};
 
-pub struct BincodeLayer<'a, Request> {
+pub struct SerdeLayer<'a, Request> {
     phantom: PhantomData<&'a ()>,
     phantom_request: PhantomData<&'a Request>,
 }
 
-impl<'a, Request> BincodeLayer<'a, Request> {
+impl<'a, Request> SerdeLayer<'a, Request> {
     pub fn new() -> Self {
         Self {
             phantom: PhantomData,
@@ -19,11 +19,11 @@ impl<'a, Request> BincodeLayer<'a, Request> {
     }
 }
 
-impl<'a, S: 'a, Request> Layer<S> for BincodeLayer<'a, Request> {
-    type Service = BincodeService<S, Request>;
+impl<'a, S: 'a, Request> Layer<S> for SerdeLayer<'a, Request> {
+    type Service = SerdeService<S, Request>;
 
     fn layer(&self, service: S) -> Self::Service {
-        BincodeService {
+        SerdeService {
             service,
             phantom_request: PhantomData,
         }
@@ -31,13 +31,13 @@ impl<'a, S: 'a, Request> Layer<S> for BincodeLayer<'a, Request> {
 }
 
 #[derive(Clone)]
-pub struct BincodeService<S, Request> {
+pub struct SerdeService<S, Request> {
     service: S,
     phantom_request: PhantomData<Request>,
 }
 
 #[derive(Debug, Error)]
-pub enum BincodeServiceError {
+pub enum SerdeServiceError {
     #[error("Error while polling: {0}")]
     Poll(String),
 
@@ -48,16 +48,16 @@ pub enum BincodeServiceError {
     Convert(String),
 }
 
-impl<S, Request> Service<Vec<u8>> for BincodeService<S, Request>
+impl<S, Request> Service<Vec<u8>> for SerdeService<S, Request>
 where
-    S: Service<Request>,
-    Request: DeserializeOwned,
-    <S as Service<Request>>::Response: Serialize,
-    <S as Service<Request>>::Error: std::error::Error,
+    S: Service<Request> + Send + Sync,
+    Request: DeserializeOwned + Send,
+    <S as Service<Request>>::Error: std::error::Error + Send,
+    <S as Service<Request>>::Response: Serialize + Send,
     <S as Service<Request>>::Future: Send + 'static,
 {
     type Response = Vec<u8>;
-    type Error = BincodeServiceError;
+    type Error = SerdeServiceError;
     type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
 
     fn poll_ready(
@@ -66,14 +66,16 @@ where
     ) -> std::task::Poll<Result<(), Self::Error>> {
         self.service
             .poll_ready(cx)
-            .map_err(|e| BincodeServiceError::Poll(e.to_string()))
+            .map_err(|e| SerdeServiceError::Poll(e.to_string()))
     }
 
     fn call(&mut self, req: Vec<u8>) -> Self::Future {
         let request: Request = match deserialize(&req) {
             Ok(r) => r,
             Err(e) => {
-                return Box::pin(async move { Err(BincodeServiceError::Convert(e.to_string())) })
+                return Box::pin(
+                    async move { Err(SerdeServiceError::Convert(e.to_string())) },
+                )
             }
         };
 
@@ -82,62 +84,8 @@ where
         Box::pin(async move {
             let response = response
                 .await
-                .map_err(|e| BincodeServiceError::Call(e.to_string()))?;
-            serialize(&response).map_err(|e| BincodeServiceError::Convert(e.to_string()))
+                .map_err(|e| SerdeServiceError::Call(e.to_string()))?;
+            serialize(&response).map_err(|e| SerdeServiceError::Convert(e.to_string()))
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde::{Deserialize, Serialize};
-    use std::{future::Future, pin::Pin, task::Poll};
-    use tower::{ServiceBuilder, ServiceExt};
-
-    #[derive(Serialize, Deserialize)]
-    struct Test {
-        field: String,
-    }
-
-    struct App;
-
-    #[derive(Debug, thiserror::Error)]
-    enum Infallible {}
-
-    impl Service<Test> for App {
-        type Response = Test;
-        type Error = Infallible;
-        type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
-
-        fn poll_ready(
-            &mut self,
-            _cx: &mut std::task::Context<'_>,
-        ) -> std::task::Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn call(&mut self, req: Test) -> Self::Future {
-            Box::pin(async { Ok(req) })
-        }
-    }
-
-    #[tokio::test]
-    async fn can_serde_responses() {
-        let content = serialize(&Test {
-            field: "hello world!".to_string(),
-        })
-        .unwrap();
-        let mut service = ServiceBuilder::new()
-            .layer(BincodeLayer::<Test>::new())
-            .service(App);
-        let result = service
-            .ready()
-            .await
-            .unwrap()
-            .call(content.clone())
-            .await
-            .unwrap();
-        assert_eq!(result, content);
-    }
-}