[all] repo state holds pds & signing key, return those from /repos endpoints, and keep them fresh

Cargo.lock

···
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.16.0"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9a7b350e3bb1767102698302bc37256cbd48422809984b98d292c40e2579aa9"
+checksum = "94bffc006df10ac2a68c83692d734a465f8ee6c5b384d8545a636f81d858f4bf"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
···
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.37.1"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b092fe214090261288111db7a2b2c2118e5a7f30dc2569f1732c4069a6840549"
+checksum = "4321e568ed89bb5a7d291a7f37997c2c0df89809d7b6d12062c81ddb54aa782e"
 dependencies = [
  "cc",
  "cmake",
···
 
 [[package]]
 name = "fjall"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ce4b4c3a755bae832077657db2727b29b9acc535bb471c6d91ab4fe408fd805"
+checksum = "0ebf22b812878dcd767879cb19e03124fd62563dce6410f96538175fba0c132d"
 dependencies = [
  "byteorder-lite",
  "byteview",
···
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 5.3.0",
  "wasip2",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 6.0.0",
  "rand_core 0.10.0",
  "wasip2",
  "wasip3",
···
  "jacquard-repo",
  "miette",
  "mimalloc",
+ "multibase",
  "rand 0.10.0",
  "reqwest",
  "rmp-serde",
···
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.2",
+ "socket2 0.6.3",
  "system-configuration",
  "tokio",
  "tower-service",
···
 
 [[package]]
 name = "ipnet"
-version = "2.11.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
 
 [[package]]
 name = "iri-string"
···
 [[package]]
 name = "jacquard-api"
 version = "0.9.5"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.9.5"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "base64",
  "bon",
···
  "cid",
  "ed25519-dalek",
  "getrandom 0.2.17",
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "hashbrown 0.16.1",
  "http",
  "ipld-core",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.9.5"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.9.5"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.9.5"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "cid",
  "dashmap",
···
 [[package]]
 name = "jacquard-repo"
 version = "0.9.6"
-source = "git+https://tangled.org/ptr.pet/jacquard#da72566fde65f8cc76b8cb2bb99fc7f4d696dc05"
+source = "git+https://tangled.org/ptr.pet/jacquard#681819111ac12a3c7ef92f1ec0b80c6f732d8b4a"
 dependencies = [
  "bytes",
  "cid",
···
 
 [[package]]
 name = "lsm-tree"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "341e13fa389d2e24023c2c2c110ae556b29fa59a2e734872de295863e11a6741"
+checksum = "e9bfd2a6ea0c1d430c13643002f35800a87f200fc8ac4827f18a2db9d9fd0644"
 dependencies = [
  "byteorder-lite",
  "byteview",
···
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.6.2",
+ "socket2 0.6.3",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
···
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.2",
+ "socket2 0.6.3",
  "tracing",
  "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
···
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
 name = "rand"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "bc266eb313df6c5c09c1c7b1fbe2510961e5bcd3add930c1e31f7ed9da0feff8"
 dependencies = [
  "chacha20",
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "rand_core 0.10.0",
 ]
 
···
 
 [[package]]
 name = "scc"
-version = "3.6.6"
+version = "3.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6012e652611b2fdcb557a7b4be8cee00d8be19397c70011906a68aa4dac2fe37"
+checksum = "45bb5ce9efd4a6e7b0f86c2697fe4c1d78d1f4e6d988c54b752d577cafe22fe8"
 dependencies = [
  "saa",
  "sdd",
···
 
 [[package]]
 name = "sdd"
-version = "4.6.7"
+version = "4.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "716318297c9f6208bda3eec88a9fdee0e2597be9461a1ab35f6ff68157527f99"
+checksum = "b21a75f5913ab130e4b369fb8693be25f29b983e2ecad4279df9bfa5dd8aaf3e"
 
 [[package]]
 name = "sec1"
···
 
 [[package]]
 name = "smol_str"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7a918bd2a9951d18ee6e48f076843e8e73a9a5d22cf05bcd4b7a81bdd04e17"
+checksum = "4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523"
 dependencies = [
  "borsh",
  "serde_core",
···
 
 [[package]]
 name = "socket2"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
 dependencies = [
  "fastrand",
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "once_cell",
  "rustix",
  "windows-sys 0.61.2",
···
 
 [[package]]
 name = "tokio"
-version = "1.49.0"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
  "bytes",
  "libc",
···
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.2",
+ "socket2 0.6.3",
  "tokio-macros",
  "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "uuid"
-version = "1.21.0"
+version = "1.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
 dependencies = [
- "getrandom 0.4.1",
+ "getrandom 0.4.2",
  "js-sys",
  "wasm-bindgen",
 ]

Cargo.toml

···
 arc-swap = "1.8.2"
 rustls = { version = "0.23", features = ["aws-lc-rs"] }
 tokio-tungstenite = { version = "0.28.0", features = ["rustls-tls-native-roots"] }
+multibase = "0.9.2"
 
 [dev-dependencies]
 tempfile = "3.26.0"

README.md

···
     - `limit`: max results (default 100, max 1000)
     - `cursor`: opaque key for paginating.
     - `partition`: `all` (default), `pending` (backfill queue), or `resync` (retries)
-- `GET /repos/{did}`: get the sync status and metadata of a specific repository.
+- `GET /repos/{did}`: get the sync status and metadata of a specific repository. also returns the handle, PDS URL and the atproto signing key (these won't be available before the repo has been backfilled once at least).
 - `PUT /repos`: explicitly track repositories. accepts an NDJSON body of `{"did": "..."}` (or JSON array of the same).
 - `DELETE /repos`: untrack repositories. accepts an NDJSON body of `{"did": "..."}` (or JSON array of the same). optionally include `"deleteData": true` to also purge the repository from the database.
 

src/api/repos.rs

···
     pub tracked: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub rev: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub handle: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pds: Option<String>,
+    // this does not have the did:key: prefix
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub signing_key: Option<String>,
     pub last_updated_at: i64,
 }
 
···
                 .map_err(internal)?
                 .to_did();
 
-            Ok(RepoResponse {
-                did: did.to_string(),
-                status: repo_state.status.to_string(),
-                tracked: repo_state.tracked,
-                rev: repo_state.rev.as_ref().map(|r| r.to_string()),
-                last_updated_at: repo_state.last_updated_at,
-            })
+            Ok(repo_state_to_response(did.to_string(), repo_state))
         };
 
         let results = match partition.as_str() {
···
             .transpose()
             .map_err(internal)?;
 
-        Ok(repo_state.map(|s| RepoResponse {
-            did: did_str,
-            status: s.status.to_string(),
-            tracked: s.tracked,
-            rev: s.rev.as_ref().map(|r| r.to_string()),
-            last_updated_at: s.last_updated_at,
-        }))
+        Ok(repo_state.map(|s| repo_state_to_response(did_str, s)))
     })
     .await
     .map_err(internal)??;
···
     }
 
     Ok(StatusCode::OK)
+}
+
+fn repo_state_to_response(did: String, s: RepoState<'_>) -> RepoResponse {
+    RepoResponse {
+        did,
+        status: s.status.to_string(),
+        tracked: s.tracked,
+        rev: s.rev.as_ref().map(|r| r.to_string()),
+        handle: s.handle.map(|h| h.to_string()),
+        pds: s.pds.map(|p| p.to_string()),
+        signing_key: s.signing_key.map(|k| k.encode()),
+        last_updated_at: s.last_updated_at,
+    }
 }
 
 async fn parse_body(req: axum::extract::Request) -> Result<Vec<RepoRequest>, (StatusCode, String)> {

src/backfill/mod.rs

···
 
     // 1. resolve pds
     let start = Instant::now();
-    let (pds_url, handle) = app_state.resolver.resolve_identity_info(did).await?;
+    let doc = app_state.resolver.resolve_doc(did).await?;
+    let pds = doc.pds.clone();
     trace!(
         did = %did,
-        pds_url = %pds_url,
-        ?handle,
+        pds = %doc.pds,
+        handle = ?doc.handle,
         elapsed = ?start.elapsed(),
         "resolved to pds"
     );
-
-    state.handle = handle.map(|h| h.into_static());
+    state.update_from_doc(doc);
 
     let emit_identity = |status: &RepoStatus| {
         let evt = AccountEvt {
···
     // 2. fetch repo (car)
     let start = Instant::now();
     let req = GetRepo::new().did(did.clone()).build();
-    let resp = http.xrpc(pds_url).send(&req).await?;
+    let resp = http.xrpc(pds).send(&req).await?;
 
     let car_bytes = match resp.into_output() {
         Ok(o) => o,

src/db/types.rs

···
 use data_encoding::BASE32_NOPAD;
 use fjall::UserKey;
+use jacquard_common::types::crypto::{PublicKey, code_of, encode_uvarint};
 use jacquard_common::types::string::Did;
 use jacquard_common::types::tid::Tid;
 use jacquard_common::{CowStr, IntoStatic};
+use miette::{Context, IntoDiagnostic};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use smol_str::{SmolStr, SmolStrBuilder, format_smolstr};
+use std::borrow::Cow;
 use std::fmt::Display;
 
 const S32_CHAR: &str = "234567abcdefghijklmnopqrstuvwxyz";
···
 impl Display for DbRkey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.to_smolstr())
+    }
+}
+
+/// did:key:z... → raw multicodec public key bytes
+#[derive(Debug, Clone, Serialize, Deserialize, jacquard_derive::IntoStatic)]
+pub struct DidKey<'b>(
+    #[serde(borrow)]
+    #[serde(with = "serde_bytes")]
+    pub Cow<'b, [u8]>,
+);
+
+impl DidKey<'_> {
+    pub fn from_did_key(s: &str) -> miette::Result<Self> {
+        let multibase_str = s
+            .strip_prefix("did:key:")
+            .ok_or_else(|| miette::miette!("missing did:key: prefix in {s}"))?;
+        let (_base, bytes) = multibase::decode(multibase_str)
+            .into_diagnostic()
+            .wrap_err("invalid multibase in did:key")?;
+        Ok(Self(Cow::Owned(bytes)))
+    }
+
+    pub fn encode(&self) -> String {
+        multibase::encode(multibase::Base::Base58Btc, &self.0)
+    }
+}
+
+impl std::fmt::Display for DidKey<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "did:key:{}", self.encode())
+    }
+}
+
+impl From<PublicKey<'_>> for DidKey<'static> {
+    fn from(value: PublicKey<'_>) -> Self {
+        let mut bytes = Vec::with_capacity(8 + value.bytes.len());
+        bytes.append(&mut encode_uvarint(code_of(value.codec)));
+        bytes.extend_from_slice(&value.bytes);
+        Self(bytes.into())
     }
 }
 

src/ingest/worker.rs

···
             SubscribeReposMessage::Sync(sync) => {
                 debug!(did = %did, "processing buffered sync");
 
-                ctx.state.resolver.invalidate_sync(did);
+                Self::refresh_doc(ctx, &mut repo_state, did)?;
 
                 match ops::verify_sync_event(
                     sync.blocks.as_ref(),
···
                     // we invalidate only if no handle is sent since its like a
                     // "invalidate your caches" message then basically
                     ctx.state.resolver.invalidate_sync(did);
-                    let (_, handle) = ctx
-                        .handle
-                        .block_on(ctx.state.resolver.resolve_identity_info(did))?;
-                    repo_state.handle = handle;
+                    let doc = ctx.handle.block_on(ctx.state.resolver.resolve_doc(did))?;
+                    repo_state.update_from_doc(doc);
                 }
 
                 let handle = identity.handle.as_ref().map(|h| h.clone());
···
                     status: account.status.as_ref().map(|s| s.to_cowstr().into_static()),
                 };
 
-                ctx.state.resolver.invalidate_sync(did);
+                Self::refresh_doc(ctx, &mut repo_state, did)?;
 
                 if !account.active {
                     use crate::ingest::stream::AccountStatus;
···
         }
 
         Ok(RepoProcessResult::Ok(repo_state))
+    }
+
+    // refreshes the handle, pds url and signing key of a did
+    fn refresh_doc(
+        ctx: &mut WorkerContext,
+        repo_state: &mut RepoState,
+        did: &Did,
+    ) -> Result<(), IngestError> {
+        ctx.state.resolver.invalidate_sync(did);
+        let doc = ctx.handle.block_on(ctx.state.resolver.resolve_doc(did))?;
+        repo_state.update_from_doc(doc);
+        ctx.batch.insert(
+            &ctx.state.db.repos,
+            keys::repo_key(did),
+            crate::db::ser_repo_state(&repo_state)?,
+        );
+        Ok(())
     }
 
     fn fetch_key(

src/resolver.rs

···
 
 #[derive(Clone)]
 pub struct MiniDoc {
-    pds: Url,
-    handle: Option<Handle<'static>>,
-    key: Option<PublicKey<'static>>,
+    pub pds: Url,
+    pub handle: Option<Handle<'static>>,
+    pub key: Option<PublicKey<'static>>,
 }
 
 struct ResolverInner {

src/types.rs

···
 use jacquard_common::{CowStr, IntoStatic, types::string::Handle};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use smol_str::SmolStr;
+use smol_str::{SmolStr, ToSmolStr};
 
-use crate::db::types::{DbAction, DbRkey, DbTid, TrimmedDid};
+use crate::db::types::{DbAction, DbRkey, DbTid, DidKey, TrimmedDid};
+use crate::resolver::MiniDoc;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub enum RepoStatus {
···
     pub index_id: u64,
     #[serde(default = "default_tracked")]
     pub tracked: bool,
+    #[serde(default)]
+    pub signing_key: Option<DidKey<'i>>,
+    #[serde(default)]
+    pub pds: Option<CowStr<'i>>,
 }
 
 fn default_tracked() -> bool {
···
             data: None,
             last_seq: None,
             last_updated_at: chrono::Utc::now().timestamp(),
-            handle: None,
+
             index_id,
             tracked: true,
+            handle: None,
+            pds: None,
+            signing_key: None,
         }
     }
 
···
             ..Self::backfilling(index_id)
         }
     }
+
+    pub fn update_from_doc(&mut self, doc: MiniDoc) {
+        self.pds = Some(CowStr::Owned(doc.pds.to_smolstr()));
+        self.handle = doc.handle;
+        self.signing_key = doc.key.map(From::from);
+    }
 }
 
 impl<'i> IntoStatic for RepoState<'i> {
···
             data: self.data,
             last_seq: self.last_seq,
             last_updated_at: self.last_updated_at,
-            handle: self.handle.map(|s| s.into_static()),
             index_id: self.index_id,
             tracked: self.tracked,
+            handle: self.handle.map(IntoStatic::into_static),
+            pds: self.pds.map(IntoStatic::into_static),
+            signing_key: self.signing_key.map(IntoStatic::into_static),
         }
     }
 }