diff --git a/Cargo.lock b/Cargo.lock
index 13fd0a3..ddd825a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1198,8 +1198,6 @@ dependencies = [
  "anyhow",
  "async-trait",
  "atproto",
- "atrium-api",
- "db",
  "rocketman",
  "serde",
  "serde_json",
diff --git a/router/src/lib.rs b/router/src/lib.rs
index 1d97da9..1a3b212 100644
--- a/router/src/lib.rs
+++ b/router/src/lib.rs
@@ -7,20 +7,27 @@ use tokio::net::TcpListener;
 pub mod xrpc;
 pub mod wellknown;
 
+pub enum Error {}
+
 pub struct Router {
   addr: SocketAddr,
   router: AxumRouter,
 }
+impl Default for Router {
+  fn default() -> Self {
+    Self::new()
+  }
+}
 impl Router {
   pub fn new() -> Self {
     let mut router = AxumRouter::new();
-    // TODO: Only add if there is at least on XRPC endpoint
+    // TODO: Only add if there is at least one XRPC endpoint
     router = XrpcEndpoint::not_implemented().add_to_router(router);
     let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127,0,0,1)), 6702);
     Router { router, addr }
   }
 
-  pub fn add_endpoint(mut self, endpoint: Endpoint) -> Self {
+  pub fn add_endpoint<E: Endpoint>(mut self, endpoint: E) -> Self {
     self.router = endpoint.add_to_router(self.router);
     self
   }
diff --git a/router/src/wellknown.rs b/router/src/wellknown.rs
index fce8f78..394a794 100644
--- a/router/src/wellknown.rs
+++ b/router/src/wellknown.rs
@@ -4,64 +4,16 @@ use axum::{
   Router as axumRouter,
 };
 
+pub mod atproto;
+pub mod oauth;
+
 trait WellKnownEndpoint {
   fn get_known_route(&self) -> String;
   fn get_resolver(self) -> MethodRouter;
 }
 
-impl Endpoint for WellKnownEndpoint {
+impl<WK: WellKnownEndpoint> Endpoint for WK {
   fn add_to_router(self, router: axumRouter) -> axumRouter {
-    router.route(".well-known/" + self.get_known_route(), self.get_resolver())
-  }
-}
-
-pub mod atproto {
-  pub mod handle_resolution {
-    use crate::wellknown::WellKnownEndpoint;
-    use axum::{
-      routing::method_routing::MethodRouter,
-      response::Response,
-      http::{StatusCode, HeaderMap},
-    };
-
-    pub struct HandleResolutionEndpoint {
-      resolver: MethodRouter,
-    }
-
-    impl HandleResolutionEndpoint {
-      pub fn new<F>(handle_resolver: F) -> self where
-      F: Fn(atproto::types::Handle) -> Result<Option<atproto::types::Did>>
-      {
-        HandleResolutionEndpoint {
-          resolver: get(async move | headers: HeaderMap | -> Response {
-            match headers
-                .get("host")
-                .map(|s| s.parse::<atproto::types::Handle>())
-                .map(handle_resolver) {
-              Ok(maybe_did) => match maybe_did {
-                Some(did) => (StatusCode::OK, did),
-                None => (StatusCode::NOT_FOUND, "User not found")
-              },
-              Err(_) => 
-                (StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error"),
-            }
-          })
-        }
-      }
-    }
-
-    impl WellKnownEndpoint for HandleResolutionEndpoint {
-      fn get_known_route(&self) -> String { String::from("atproto-did") }
-
-      fn get_resolver(self) -> MethodRouter {
-        return self.resolver;
-      }
-    }
-  }
-}
-
-pub mod oauth {
-  mod protected_resource {}
-  pub mod authorization_server {
+    router.route(&format!(".well-known/{}", self.get_known_route()), self.get_resolver())
   }
 }
diff --git a/router/src/wellknown/atproto.rs b/router/src/wellknown/atproto.rs
new file mode 100644
index 0000000..0f99da0
--- /dev/null
+++ b/router/src/wellknown/atproto.rs
@@ -0,0 +1 @@
+pub mod handle_resolution;
diff --git a/router/src/wellknown/atproto/handle_resolution.rs b/router/src/wellknown/atproto/handle_resolution.rs
new file mode 100644
index 0000000..b3d75ce
--- /dev/null
+++ b/router/src/wellknown/atproto/handle_resolution.rs
@@ -0,0 +1,52 @@
+use crate::{
+  wellknown::WellKnownEndpoint,
+  Error,
+};
+use atproto::types::{Handle, Did};
+use axum::{
+  routing::{
+    method_routing::MethodRouter,
+    get,
+  },
+  http::{
+    StatusCode,
+    HeaderMap,
+  },
+};
+
+pub struct HandleResolutionEndpoint {
+  resolver: MethodRouter,
+}
+
+impl HandleResolutionEndpoint {
+  pub fn new<HR>(handle_resolver: HR) -> Self where
+  HR: HandleResolver + Clone
+  {
+    HandleResolutionEndpoint {
+      resolver: get(async move | headers: HeaderMap | -> (StatusCode, String) {
+        let Some(Ok(hostname)) = headers.get("host").map(|header_value| {
+          header_value.to_str()
+        }) else {
+          return (StatusCode::INTERNAL_SERVER_ERROR, String::from("Internal Server Error"));
+        };
+        let Ok(valid_handle) = hostname.parse::<atproto::types::Handle>() else {
+          return (StatusCode::NOT_FOUND, String::from("User not found"));
+        };
+        match handle_resolver.call(valid_handle) {
+          Ok(Some(did)) => (StatusCode::OK, did.to_string()),
+          Ok(None) => (StatusCode::NOT_FOUND, String::from("User not found")),
+          Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, String::from("Internal Server Error")),
+        }
+      })
+    }
+  }
+}
+
+pub trait HandleResolver: Send + Sync + 'static {
+  fn call(&self, handle: Handle) -> Result<Option<Did>, Error>;
+}
+
+impl WellKnownEndpoint for HandleResolutionEndpoint {
+  fn get_known_route(&self) -> String { String::from("atproto-did") }
+  fn get_resolver(self) -> MethodRouter { self.resolver }
+}
diff --git a/router/src/wellknown/oauth.rs b/router/src/wellknown/oauth.rs
new file mode 100644
index 0000000..887d5fd
--- /dev/null
+++ b/router/src/wellknown/oauth.rs
@@ -0,0 +1 @@
+pub mod authorization_server;
diff --git a/router/src/wellknown/oauth/authorization_server.rs b/router/src/wellknown/oauth/authorization_server.rs
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/router/src/wellknown/oauth/authorization_server.rs
@@ -0,0 +1,2 @@
+
+
diff --git a/router/src/xrpc.rs b/router/src/xrpc.rs
index 739fd79..fc5ad3f 100644
--- a/router/src/xrpc.rs
+++ b/router/src/xrpc.rs
@@ -174,7 +174,7 @@ impl XrpcEndpoint {
 impl Endpoint for XrpcEndpoint {
   fn add_to_router(self, router: axumRouter) -> axumRouter {
     let path = match self.path {
-      Path::Nsid(nsid) => &("/xrpc/".to_owned() + nsid.as_str()),
+      Path::Nsid(nsid) => &("/xrpc/".to_owned() + &nsid.to_string()),
       Path::NotImplemented => "/xrpc/{*nsid}",
     };