Eliminated duplication of CertResolver.

crates/btmsg/src/lib.rs

@@ -65,7 +65,7 @@ mod private {
         addr: Arc<BlockAddr>,
         creds: Arc<C>,
     ) -> Result<impl Router> {
-        QuicRouter::new(addr, creds)
+        QuicRouter::new(addr, Arc::new(CertResolver::new(creds)?))
     }
 
     lazy_static! {
@@ -93,20 +93,20 @@ mod private {
             .map_err(|err| err.into())
     }
 
-    fn server_config<C: 'static + Creds + Send + Sync>(creds: Arc<C>) -> Result<ServerConfig> {
+    fn server_config(resolver: Arc<CertResolver>) -> Result<ServerConfig> {
         let server_config = common_config(rustls::ServerConfig::builder())?
             .with_client_cert_verifier(Arc::new(ClientCertVerifier))
-            .with_cert_resolver(Arc::new(CertResolver::new(creds)?));
+            .with_cert_resolver(resolver);
         Ok(ServerConfig::with_crypto(Arc::new(server_config)))
     }
 
-    fn client_config<C: 'static + Creds + Send + Sync>(
+    fn client_config(
         server_path: Arc<BlockPath>,
-        creds: Arc<C>,
+        resolver: Arc<CertResolver>,
     ) -> Result<ClientConfig> {
         let client_config = common_config(rustls::ClientConfig::builder())?
             .with_custom_certificate_verifier(Arc::new(ServerCertVerifier::new(server_path)))
-            .with_client_cert_resolver(Arc::new(CertResolver::new(creds)?));
+            .with_client_cert_resolver(resolver);
         Ok(ClientConfig::new(Arc::new(client_config)))
     }
 
@@ -683,25 +683,25 @@ mod private {
         };
     }
 
-    struct QuicRouter<C> {
+    struct QuicRouter {
         recv_addr: Arc<BlockAddr>,
-        creds: Arc<C>,
+        resolver: Arc<CertResolver>,
         endpoint: Endpoint,
     }
 
-    impl<C: 'static + Creds + Send + Sync> QuicRouter<C> {
-        fn new(recv_addr: Arc<BlockAddr>, creds: Arc<C>) -> Result<Self> {
+    impl QuicRouter {
+        fn new(recv_addr: Arc<BlockAddr>, resolver: Arc<CertResolver>) -> Result<Self> {
             let socket_addr = recv_addr.socket_addr();
-            let endpoint = Endpoint::server(server_config(creds.clone())?, socket_addr)?;
+            let endpoint = Endpoint::server(server_config(resolver.clone())?, socket_addr)?;
             Ok(Self {
                 endpoint,
-                creds,
+                resolver,
                 recv_addr,
             })
         }
     }
 
-    impl<C: 'static + Creds + Send + Sync> Router for QuicRouter<C> {
+    impl Router for QuicRouter {
         type Receiver<T: 'static + DeserializeOwned + Send> = QuicReceiver<T>;
         type ReceiverFut<'a, T: 'static + DeserializeOwned + Send + Unpin> =
             Ready<Result<QuicReceiver<T>>>;
@@ -720,7 +720,7 @@ mod private {
 
         fn sender(&self, addr: Arc<BlockAddr>) -> Self::SenderFut<'_> {
             Box::pin(async {
-                QuicSender::from_endpoint(self.endpoint.clone(), addr, self.creds.clone()).await
+                QuicSender::from_endpoint(self.endpoint.clone(), addr, self.resolver.clone()).await
             })
         }
     }
@@ -812,14 +812,14 @@ mod private {
     }
 
     impl QuicSender {
-        async fn from_endpoint<C: 'static + Creds + Send + Sync>(
+        async fn from_endpoint(
             endpoint: Endpoint,
             addr: Arc<BlockAddr>,
-            creds: Arc<C>,
+            resolver: Arc<CertResolver>,
         ) -> Result<Self> {
             let socket_addr = addr.socket_addr();
             let connecting = endpoint.connect_with(
-                client_config(addr.path.clone(), creds)?,
+                client_config(addr.path.clone(), resolver)?,
                 socket_addr,
                 // The ServerCertVerifier ensures we connect to the correct path.
                 "INDETERMINANT",