resolve did to pds

Cargo.lock

···
 dependencies = [
  "jacquard",
  "sqlx",
+ "thiserror 2.0.17",
  "tokio",
 ]
 

Cargo.toml

···
 [dependencies]
 jacquard = "0.9.0"
 sqlx = { version = "0.8.6", features = ["runtime-tokio", "postgres"] }
+thiserror = "2.0.17"
 tokio = "1.48.0"

src/db.rs

···
             panic!()
         }
     };
-    println!("Connected to db with pool: {:?}", conn);
 
     // initialise db tables
     if let Err(err) = query!(

src/main.rs

···
 mod config;
 mod db;
+mod resolver;
 
 #[tokio::main]
 async fn main() {
-    println!("Indexing {}", *config::USER);
+    println!("User: {}", *config::USER);
     let conn = db::init().await;
-    println!("Database established");
+    println!("Database connected and initialized");
+
+    let pds = match resolver::resolve(&config::USER).await {
+        Ok(val) => val,
+        Err(err) => panic!("{}", err),
+    };
 
-    // to stop docker whinging
-    loop {}
+    println!("PDS: {}", pds);
 }

src/resolver.rs

···
+use jacquard::prelude::IdentityResolver;
+use jacquard::types::did::Did;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ResolveError {
+    #[error("Identity error: {}", .0)]
+    IdentityError(#[from] jacquard::identity::resolver::IdentityError),
+    #[error("Missing domain")]
+    MissingDomain,
+}
+
+pub async fn resolve(did: &Did<'_>) -> Result<String, ResolveError> {
+    // resolve did to pds
+    let resolver = jacquard::identity::PublicResolver::default();
+    let pds = resolver.pds_for_did(did).await?;
+    let Some(pds) = pds.domain() else {
+        return Err(ResolveError::MissingDomain);
+    };
+    Ok(String::from(pds))
+}