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/api/rpc/handshake.rs

@@ -0,0 +1,138 @@
+use super::RpcHandler;
+use crate::{nostr_handshake, peers};
+use anyhow::Result;
+
+impl RpcHandler {
+    /// Discover nodes (presence-only — returns Nostr pubkeys + DIDs, no onion addresses).
+    pub(super) async fn handle_handshake_discover(&self) -> Result<serde_json::Value> {
+        let identity_dir = self.config.data_dir.join("identity");
+        let nodes = nostr_handshake::discover_nodes(
+            &identity_dir,
+            &self.config.nostr_relays,
+            self.config.nostr_tor_proxy.as_deref(),
+        )
+        .await?;
+        Ok(serde_json::json!({ "nodes": nodes }))
+    }
+
+    /// Send encrypted connection request to a peer's Nostr pubkey.
+    /// Params: { recipient_nostr_pubkey }
+    pub(super) async fn handle_handshake_connect(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let params = params.ok_or_else(|| anyhow::anyhow!("Missing params"))?;
+        let recipient = params
+            .get("recipient_nostr_pubkey")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| anyhow::anyhow!("Missing recipient_nostr_pubkey"))?;
+
+        let (data, _) = self.state_manager.get_snapshot().await;
+        let our_onion = data
+            .server_info
+            .tor_address
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("No Tor address available — is Tor running?"))?;
+        let our_node_pubkey = &data.server_info.pubkey;
+        let our_did = crate::identity::did_key_from_pubkey_hex(our_node_pubkey)
+            .unwrap_or_default();
+        let our_version = &data.server_info.version;
+        let our_name = data.server_info.name.as_deref();
+
+        let identity_dir = self.config.data_dir.join("identity");
+        nostr_handshake::send_connect_request(
+            &identity_dir,
+            recipient,
+            our_onion,
+            our_node_pubkey,
+            &our_did,
+            our_version,
+            our_name,
+            &self.config.nostr_relays,
+            self.config.nostr_tor_proxy.as_deref(),
+        )
+        .await?;
+
+        Ok(serde_json::json!({ "ok": true, "sent_to": recipient }))
+    }
+
+    /// Poll for incoming encrypted handshake messages (connect requests/responses).
+    /// Auto-adds peers and auto-responds to requests.
+    pub(super) async fn handle_handshake_poll(&self) -> Result<serde_json::Value> {
+        let identity_dir = self.config.data_dir.join("identity");
+        let handshakes = nostr_handshake::poll_handshakes(
+            &identity_dir,
+            &self.config.nostr_relays,
+            self.config.nostr_tor_proxy.as_deref(),
+            None, // TODO: track last-seen timestamp to avoid re-processing
+        )
+        .await?;
+
+        let (data, _) = self.state_manager.get_snapshot().await;
+        let mut added_peers = Vec::new();
+
+        for hs in &handshakes {
+            let (onion, node_pubkey, name) = match &hs.message {
+                nostr_handshake::HandshakeMessage::ConnectRequest {
+                    onion,
+                    node_pubkey,
+                    name,
+                    ..
+                } => {
+                    // Auto-respond with our details
+                    if let Some(our_onion) = data.server_info.tor_address.as_deref() {
+                        let our_did = crate::identity::did_key_from_pubkey_hex(
+                            &data.server_info.pubkey,
+                        )
+                        .unwrap_or_default();
+                        let _ = nostr_handshake::send_connect_response(
+                            &identity_dir,
+                            &hs.from_nostr_pubkey,
+                            our_onion,
+                            &data.server_info.pubkey,
+                            &our_did,
+                            &data.server_info.version,
+                            data.server_info.name.as_deref(),
+                            &self.config.nostr_relays,
+                            self.config.nostr_tor_proxy.as_deref(),
+                        )
+                        .await;
+                    }
+                    (onion.clone(), node_pubkey.clone(), name.clone())
+                }
+                nostr_handshake::HandshakeMessage::ConnectResponse {
+                    onion,
+                    node_pubkey,
+                    name,
+                    ..
+                } => (onion.clone(), node_pubkey.clone(), name.clone()),
+            };
+
+            // Auto-add as peer
+            let peer = peers::KnownPeer {
+                onion,
+                pubkey: node_pubkey.clone(),
+                name,
+                added_at: Some(chrono::Utc::now().to_rfc3339()),
+            };
+            let _ = peers::add_peer(&self.config.data_dir, peer).await;
+            added_peers.push(node_pubkey);
+        }
+
+        let serialized: Vec<serde_json::Value> = handshakes
+            .iter()
+            .map(|hs| {
+                serde_json::json!({
+                    "from_nostr_pubkey": hs.from_nostr_pubkey,
+                    "message": hs.message,
+                    "timestamp": hs.timestamp,
+                })
+            })
+            .collect();
+
+        Ok(serde_json::json!({
+            "handshakes": serialized,
+            "added_peers": added_peers,
+        }))
+    }
+}