hot fixes to utc-6

core/archipelago/src/api/rpc/handshake.rs

@@ -1,6 +1,7 @@
 use super::RpcHandler;
 use crate::{nostr_handshake, peers};
 use anyhow::Result;
+use nostr_sdk::FromBech32;
 
 impl RpcHandler {
     /// Discover nodes (presence-only — returns Nostr pubkeys + DIDs, no onion addresses).
@@ -22,10 +23,19 @@ impl RpcHandler {
         params: Option<serde_json::Value>,
     ) -> Result<serde_json::Value> {
         let params = params.ok_or_else(|| anyhow::anyhow!("Missing params"))?;
-        let recipient = params
+        // Accept either hex pubkey or npub1... bech32 format
+        let recipient_raw = params
             .get("recipient_nostr_pubkey")
             .and_then(|v| v.as_str())
             .ok_or_else(|| anyhow::anyhow!("Missing recipient_nostr_pubkey"))?;
+        let recipient = if recipient_raw.starts_with("npub1") {
+            nostr_sdk::PublicKey::from_bech32(recipient_raw)
+                .map_err(|e| anyhow::anyhow!("Invalid npub: {}", e))?
+                .to_hex()
+        } else {
+            recipient_raw.to_string()
+        };
+        let recipient = recipient.as_str();
 
         let (data, _) = self.state_manager.get_snapshot().await;
         let our_onion = data
@@ -124,6 +134,7 @@ impl RpcHandler {
             .map(|hs| {
                 serde_json::json!({
                     "from_nostr_pubkey": hs.from_nostr_pubkey,
+                    "from_nostr_npub": hs.from_nostr_npub,
                     "message": hs.message,
                     "timestamp": hs.timestamp,
                 })

core/archipelago/src/api/rpc/identity.rs

@@ -3,6 +3,7 @@
 use super::RpcHandler;
 use crate::identity_manager::{IdentityManager, IdentityPurpose};
 use anyhow::{Context, Result};
+use nostr_sdk::ToBech32;
 
 impl RpcHandler {
     /// List all identities with their default status.
@@ -25,6 +26,8 @@ impl RpcHandler {
                     "did": id.did,
                     "created_at": id.created_at,
                     "is_default": is_default,
+                    "nostr_pubkey": id.nostr_pubkey,
+                    "nostr_npub": id.nostr_npub,
                 })
             })
             .collect();
@@ -65,6 +68,8 @@ impl RpcHandler {
             "pubkey": record.pubkey_hex,
             "did": record.did,
             "created_at": record.created_at,
+            "nostr_pubkey": record.nostr_pubkey,
+            "nostr_npub": record.nostr_npub,
         }))
     }
 
@@ -92,6 +97,8 @@ impl RpcHandler {
             "did": record.did,
             "created_at": record.created_at,
             "is_default": is_default,
+            "nostr_pubkey": record.nostr_pubkey,
+            "nostr_npub": record.nostr_npub,
         }))
     }
 
@@ -189,17 +196,27 @@ impl RpcHandler {
         let params = params.unwrap_or_default();
 
         // If a DID is provided, resolve it; otherwise use the node's DID
+        let is_local = params.get("did").and_then(|v| v.as_str()).is_none();
         let pubkey_hex = if let Some(did) = params.get("did").and_then(|v| v.as_str()) {
-            // Extract pubkey from did:key format
             let pubkey_bytes = crate::identity::pubkey_bytes_from_did_key(did)?;
             hex::encode(pubkey_bytes)
         } else {
-            // Use node's own pubkey
             let (data, _) = self.state_manager.get_snapshot().await;
             data.server_info.pubkey.clone()
         };
 
-        let document = crate::identity::did_document_from_pubkey_hex(&pubkey_hex)?;
+        // For local node, include Nostr secp256k1 key in DID Document (paired identity)
+        let document = if is_local {
+            let identity_dir = self.config.data_dir.join("identity");
+            match crate::nostr_discovery::get_nostr_pubkey(&identity_dir).await {
+                Ok(nostr_pubkey) => {
+                    crate::identity::did_document_with_nostr(&pubkey_hex, &nostr_pubkey)?
+                }
+                Err(_) => crate::identity::did_document_from_pubkey_hex(&pubkey_hex)?,
+            }
+        } else {
+            crate::identity::did_document_from_pubkey_hex(&pubkey_hex)?
+        };
         Ok(document)
     }
 
@@ -287,10 +304,16 @@ impl RpcHandler {
             .ok_or_else(|| anyhow::anyhow!("Missing required parameter: id"))?;
 
         let manager = IdentityManager::new(&self.config.data_dir).await?;
-        let pubkey = manager.create_nostr_key(id).await?;
+        let pubkey_hex = manager.create_nostr_key(id).await?;
+
+        // Derive npub (bech32 NIP-19) from hex
+        let npub = nostr_sdk::PublicKey::from_hex(&pubkey_hex)
+            .ok()
+            .and_then(|pk| pk.to_bech32().ok());
 
         Ok(serde_json::json!({
-            "nostr_pubkey": pubkey,
+            "nostr_pubkey": pubkey_hex,
+            "nostr_npub": npub,
         }))
     }
 

core/archipelago/src/api/rpc/node.rs

@@ -2,12 +2,25 @@ use super::RpcHandler;
 use crate::{backup, identity, nostr_discovery};
 use crate::container::docker_packages;
 use anyhow::Result;
+use nostr_sdk::ToBech32;
 
 impl RpcHandler {
     pub(super) async fn handle_node_did(&self) -> Result<serde_json::Value> {
         let (data, _) = self.state_manager.get_snapshot().await;
         let did = identity::did_key_from_pubkey_hex(&data.server_info.pubkey)?;
-        Ok(serde_json::json!({ "did": did, "pubkey": data.server_info.pubkey }))
+        let identity_dir = self.config.data_dir.join("identity");
+        let nostr_pubkey = nostr_discovery::get_nostr_pubkey(&identity_dir).await.ok();
+        let nostr_npub = nostr_pubkey.as_ref().and_then(|hex| {
+            nostr_sdk::PublicKey::from_hex(hex)
+                .ok()
+                .and_then(|pk| pk.to_bech32().ok())
+        });
+        Ok(serde_json::json!({
+            "did": did,
+            "pubkey": data.server_info.pubkey,
+            "nostr_pubkey": nostr_pubkey,
+            "nostr_npub": nostr_npub,
+        }))
     }
 
     /// Sign a challenge to prove control of the node DID (proof-of-control for onboarding).
@@ -91,8 +104,14 @@ impl RpcHandler {
 
     pub(super) async fn handle_node_nostr_pubkey(&self) -> Result<serde_json::Value> {
         let identity_dir = self.config.data_dir.join("identity");
-        let pubkey = nostr_discovery::get_nostr_pubkey(&identity_dir).await?;
-        Ok(serde_json::json!({ "nostr_pubkey": pubkey }))
+        let pubkey_hex = nostr_discovery::get_nostr_pubkey(&identity_dir).await?;
+        let npub = nostr_sdk::PublicKey::from_hex(&pubkey_hex)
+            .ok()
+            .and_then(|pk| pk.to_bech32().ok());
+        Ok(serde_json::json!({
+            "nostr_pubkey": pubkey_hex,
+            "nostr_npub": npub,
+        }))
     }
 
     pub(super) async fn handle_node_nostr_verify_revoked(&self) -> Result<serde_json::Value> {