add nip4e key rotation

crates/chat/src/lib.rs

@@ -947,7 +947,11 @@ async fn extract_rumor(
             let Some(device_signer) = device_signer else {
                 return Err(error);
             };
-            try_unwrap_with(device_signer, gift_wrap).await?
+            match try_unwrap_with(device_signer, gift_wrap).await {
+                Ok(unwrapped) => unwrapped,
+                // The wrap may be sealed to a key retired by a rotation
+                Err(_) => try_unwrap_archived(client, signer, gift_wrap).await?,
+            }
         }
     };
     let mut rumor = unwrapped.rumor;
@@ -1003,6 +1007,25 @@ async fn try_unwrap_with(
     })
 }
 
+/// Unwrap with an encryption key retired by a rotation; peers may still seal
+/// to the previous key until their announcement cache refreshes
+async fn try_unwrap_archived(
+    client: &Client,
+    signer: &UniversalSigner,
+    gift_wrap: &Event,
+) -> Result<UnwrappedGift, Error> {
+    for keys in DeviceRegistry::archived_keys(client, signer).await? {
+        let archived = UniversalSigner::new(keys);
+        if let Ok(unwrapped) = try_unwrap_with(&archived, gift_wrap).await {
+            return Ok(unwrapped);
+        }
+    }
+
+    Err(anyhow!(
+        "No archived encryption key could unwrap the gift wrap"
+    ))
+}
+
 /// Stores an unwrapped event in local database with reference to original
 async fn set_rumor(client: &Client, id: EventId, rumor: &UnsignedEvent) -> Result<(), Error> {
     let room_id = rumor.uniq_id().to_string();

crates/chat/src/room.rs

@@ -16,6 +16,7 @@ use crate::{FileAttachment, KIND_FILE_MESSAGE, NewMessage};
 
 const NO_DEKEY: &str = "User hasn't set up a decoupled encryption key yet.";
 const USER_NO_DEKEY: &str = "You haven't set up a decoupled encryption key yet. Set one up in the settings to message them.";
+const KEY_STALE: &str = "Your encryption key is out of date; sync it from another device in the settings to keep messaging.";
 
 /// The outcome of delivering an encrypted rumor to a single receiver.
 #[derive(Debug, Clone)]
@@ -553,6 +554,7 @@ impl Room {
         let config = self.config.clone();
 
         let device = DeviceRegistry::global(cx);
+        let resyncing = device.read(cx).is_resyncing();
         let encryption_signer = device.read(cx).signer(cx);
 
         let nostr = NostrRegistry::global(cx);
@@ -574,6 +576,28 @@ impl Room {
         Some(cx.background_spawn(async move {
             let signer_kind = config.signer_kind();
 
+            // Block sends while the local encryption key is stale against the
+            // current announcement; the replacement is being synced from
+            // another device
+            if resyncing && matches!(signer_kind, SignerKind::Auto | SignerKind::Encryption) {
+                let mut reports: Vec<SendReport> = receivers
+                    .into_iter()
+                    .map(|receiver| SendReport {
+                        receiver: receiver.public_key(),
+                        result: Err(KEY_STALE.into()),
+                    })
+                    .collect();
+
+                if config.backup() {
+                    reports.push(SendReport {
+                        receiver: sender.public_key(),
+                        result: Err(KEY_STALE.into()),
+                    });
+                }
+
+                return reports;
+            }
+
             // Deliver to every receiver concurrently
             let sends = receivers.into_iter().map(|receiver| {
                 deliver(