refactor: update dependencies and remove unused code

- Added new dependencies: `adler2`, `crc32fast`, `flate2`, `miniz_oxide`, and `libredox`.
- Updated existing dependencies: `tokio-rustls` to version 0.26.4 and `filetime` to version 0.2.27.
- Removed the `backup.rs` file as it is no longer needed.
- Introduced tests for configuration and credential management.
- Enhanced the `identity` module to generate W3C compliant DID documents.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

core/archipelago/src/names.rs

@@ -213,3 +213,172 @@ pub async fn link_name_to_did(
     save_names(data_dir, &store).await?;
     Ok(updated)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_name_status_display() {
+        assert_eq!(NameStatus::Active.to_string(), "active");
+        assert_eq!(NameStatus::Pending.to_string(), "pending");
+        assert_eq!(NameStatus::Expired.to_string(), "expired");
+        assert_eq!(NameStatus::Failed.to_string(), "failed");
+    }
+
+    #[test]
+    fn test_name_status_serde_roundtrip() {
+        let json = serde_json::to_string(&NameStatus::Active).unwrap();
+        assert_eq!(json, "\"active\"");
+        let deserialized: NameStatus = serde_json::from_str(&json).unwrap();
+        assert_eq!(deserialized, NameStatus::Active);
+    }
+
+    #[test]
+    fn test_names_store_default_is_empty() {
+        let store = NamesStore::default();
+        assert!(store.names.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_load_names_returns_empty_when_no_file() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = load_names(dir.path()).await.unwrap();
+        assert!(store.names.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_save_and_load_names_roundtrip() {
+        let dir = tempfile::tempdir().unwrap();
+        let store = NamesStore {
+            names: vec![RegisteredName {
+                id: "test-id-1".to_string(),
+                name: "satoshi".to_string(),
+                domain: "example.com".to_string(),
+                identity_id: "identity-1".to_string(),
+                did: "did:key:z123".to_string(),
+                nostr_pubkey: Some("npub1abc".to_string()),
+                status: NameStatus::Active,
+                registered_at: "2025-01-01T00:00:00Z".to_string(),
+                expires_at: None,
+                nip05: "satoshi@example.com".to_string(),
+            }],
+        };
+        save_names(dir.path(), &store).await.unwrap();
+        let loaded = load_names(dir.path()).await.unwrap();
+        assert_eq!(loaded.names.len(), 1);
+        assert_eq!(loaded.names[0].name, "satoshi");
+        assert_eq!(loaded.names[0].nip05, "satoshi@example.com");
+    }
+
+    #[tokio::test]
+    async fn test_register_name_creates_record() {
+        let dir = tempfile::tempdir().unwrap();
+        let result = register_name(
+            dir.path(),
+            "alice",
+            "bitcoin.org",
+            "id-1",
+            "did:key:zabc",
+            Some("npub1xyz"),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(result.name, "alice");
+        assert_eq!(result.domain, "bitcoin.org");
+        assert_eq!(result.nip05, "alice@bitcoin.org");
+        assert_eq!(result.did, "did:key:zabc");
+        assert_eq!(result.nostr_pubkey, Some("npub1xyz".to_string()));
+        assert_eq!(result.status, NameStatus::Active);
+        assert!(!result.id.is_empty());
+
+        // Verify persisted
+        let store = load_names(dir.path()).await.unwrap();
+        assert_eq!(store.names.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_register_duplicate_name_fails() {
+        let dir = tempfile::tempdir().unwrap();
+        register_name(dir.path(), "bob", "test.com", "id-1", "did:key:z1", None)
+            .await
+            .unwrap();
+
+        let result =
+            register_name(dir.path(), "bob", "test.com", "id-2", "did:key:z2", None).await;
+        assert!(result.is_err());
+        let err_msg = result.unwrap_err().to_string();
+        assert!(err_msg.contains("already registered"));
+    }
+
+    #[tokio::test]
+    async fn test_register_same_name_different_domain_succeeds() {
+        let dir = tempfile::tempdir().unwrap();
+        register_name(dir.path(), "alice", "domain1.com", "id-1", "did:key:z1", None)
+            .await
+            .unwrap();
+        let result =
+            register_name(dir.path(), "alice", "domain2.com", "id-1", "did:key:z1", None).await;
+        assert!(result.is_ok());
+
+        let store = load_names(dir.path()).await.unwrap();
+        assert_eq!(store.names.len(), 2);
+    }
+
+    #[tokio::test]
+    async fn test_remove_name_by_id() {
+        let dir = tempfile::tempdir().unwrap();
+        let registered = register_name(
+            dir.path(),
+            "charlie",
+            "example.com",
+            "id-1",
+            "did:key:z1",
+            None,
+        )
+        .await
+        .unwrap();
+
+        remove_name(dir.path(), &registered.id).await.unwrap();
+        let store = load_names(dir.path()).await.unwrap();
+        assert!(store.names.is_empty());
+    }
+
+    #[tokio::test]
+    async fn test_remove_nonexistent_name_fails() {
+        let dir = tempfile::tempdir().unwrap();
+        let result = remove_name(dir.path(), "nonexistent-id").await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("Name not found"));
+    }
+
+    #[tokio::test]
+    async fn test_link_name_to_did() {
+        let dir = tempfile::tempdir().unwrap();
+        let registered = register_name(
+            dir.path(),
+            "dave",
+            "example.com",
+            "old-identity",
+            "did:key:old",
+            None,
+        )
+        .await
+        .unwrap();
+
+        let updated = link_name_to_did(
+            dir.path(),
+            &registered.id,
+            "did:key:new",
+            "new-identity",
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(updated.did, "did:key:new");
+        assert_eq!(updated.identity_id, "new-identity");
+        // Name itself should be unchanged
+        assert_eq!(updated.name, "dave");
+    }
+}