Merge pull request #868 from MutinyWallet/device-lock-improvements

Device Lock Improvements

Author: AnthonyRonning

mutiny-core/src/nodemanager.rs

@@ -60,7 +60,7 @@ use std::{collections::HashMap, ops::Deref, sync::Arc};
 use uuid::Uuid;
 
 const BITCOIN_PRICE_CACHE_SEC: u64 = 300;
-pub const DEVICE_LOCK_INTERVAL_SECS: u64 = 60;
+pub const DEVICE_LOCK_INTERVAL_SECS: u64 = 30;
 
 // This is the NodeStorage object saved to the DB
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
@@ -549,7 +549,7 @@ impl<S: MutinyStorage> NodeManager<S> {
             if let Some(lock) = storage.get_device_lock()? {
                 log_info!(logger, "Current device lock: {lock:?}");
             }
-            storage.set_device_lock()?;
+            storage.set_device_lock().await?;
         }
 
         let storage_clone = storage.clone();
@@ -561,7 +561,7 @@ impl<S: MutinyStorage> NodeManager<S> {
                     break;
                 }
                 sleep((DEVICE_LOCK_INTERVAL_SECS * 1_000) as i32).await;
-                if let Err(e) = storage_clone.set_device_lock() {
+                if let Err(e) = storage_clone.set_device_lock().await {
                     log_error!(logger_clone, "Error setting device lock: {e}");
                 }
             }

mutiny-core/src/storage.rs

@@ -82,6 +82,12 @@ pub struct DeviceLock {
 }
 
 impl DeviceLock {
+    pub fn remaining_secs(&self) -> u64 {
+        let now = now().as_secs();
+        let diff = now.saturating_sub(self.time as u64);
+        (DEVICE_LOCK_INTERVAL_SECS * 2).saturating_sub(diff)
+    }
+
     /// Check if the device is locked
     /// This is determined if the time is less than 2 minutes ago
     pub fn is_locked(&self, id: &str) -> bool {
@@ -385,7 +391,7 @@ pub trait MutinyStorage: Clone + Sized + 'static {
         self.get_data(DEVICE_LOCK_KEY)
     }
 
-    fn set_device_lock(&self) -> Result<(), MutinyError> {
+    async fn set_device_lock(&self) -> Result<(), MutinyError> {
         let device = self.get_device_id()?;
         if let Some(lock) = self.get_device_lock()? {
             if lock.is_locked(&device) {
@@ -395,7 +401,7 @@ pub trait MutinyStorage: Clone + Sized + 'static {
 
         let time = now().as_secs() as u32;
         let lock = DeviceLock { time, device };
-        self.set_data(DEVICE_LOCK_KEY, lock, Some(time))
+        self.set_data_async(DEVICE_LOCK_KEY, lock, Some(time)).await
     }
 
     async fn fetch_device_lock(&self) -> Result<Option<DeviceLock>, MutinyError>;
@@ -714,7 +720,7 @@ mod tests {
         let lock = storage.get_device_lock().unwrap();
         assert_eq!(None, lock);
 
-        storage.set_device_lock().unwrap();
+        storage.set_device_lock().await.unwrap();
         // sleep 1 second to make sure it writes to VSS
         sleep(1_000).await;
 
@@ -725,7 +731,7 @@ mod tests {
         assert_eq!(lock.unwrap().device, id);
 
         // make sure we can set lock again, should work because same device id
-        storage.set_device_lock().unwrap();
+        storage.set_device_lock().await.unwrap();
         // sleep 1 second to make sure it writes to VSS
         sleep(1_000).await;
 
@@ -744,6 +750,9 @@ mod tests {
         assert!(lock.clone().unwrap().is_locked(&new_id));
         assert_eq!(lock.unwrap().device, id);
 
-        assert!(storage.set_device_lock().is_err())
+        assert_eq!(
+            storage.set_device_lock().await,
+            Err(crate::MutinyError::AlreadyRunning)
+        );
     }
 }

mutiny-wasm/src/indexed_db.rs

@@ -133,6 +133,11 @@ impl IndexedDbStorage {
         key: &str,
         data: &Value,
     ) -> Result<(), MutinyError> {
+        // Device lock is only saved to VSS
+        if key == DEVICE_LOCK_KEY {
+            return Ok(());
+        }
+
         let tx = indexed_db
             .try_write()
             .map_err(|e| MutinyError::read_err(e.into()))

mutiny-wasm/src/lib.rs

@@ -33,7 +33,7 @@ use mutiny_core::lnurlauth::AuthManager;
 use mutiny_core::nostr::nwc::{BudgetedSpendingConditions, NwcProfileTag, SpendingConditions};
 use mutiny_core::redshift::RedshiftManager;
 use mutiny_core::redshift::RedshiftRecipient;
-use mutiny_core::storage::MutinyStorage;
+use mutiny_core::storage::{DeviceLock, MutinyStorage, DEVICE_LOCK_KEY};
 use mutiny_core::utils::sleep;
 use mutiny_core::vss::MutinyVssClient;
 use mutiny_core::{labels::LabelStorage, nodemanager::NodeManager};
@@ -264,6 +264,70 @@ impl MutinyWallet {
         NodeManager::has_node_manager(storage)
     }
 
+    /// Returns the number of remaining seconds until the device lock expires.
+    #[wasm_bindgen]
+    pub async fn get_device_lock_remaining_secs(
+        password: Option<String>,
+        auth_url: Option<String>,
+        storage_url: Option<String>,
+    ) -> Result<Option<u64>, MutinyJsError> {
+        let logger = Arc::new(MutinyLogger::default());
+        let cipher = password
+            .as_ref()
+            .filter(|p| !p.is_empty())
+            .map(|p| encryption_key_from_pass(p))
+            .transpose()?;
+        let mnemonic =
+            IndexedDbStorage::get_mnemonic(None, password.as_deref(), cipher.clone()).await?;
+
+        let seed = mnemonic.to_seed("");
+        // Network doesn't matter here, only for encoding
+        let xprivkey = ExtendedPrivKey::new_master(Network::Bitcoin, &seed).unwrap();
+
+        let vss_client = if let Some(auth_url) = auth_url {
+            let auth_manager = AuthManager::new(xprivkey).unwrap();
+
+            let lnurl_client = Arc::new(
+                lnurl::Builder::default()
+                    .build_async()
+                    .expect("failed to make lnurl client"),
+            );
+
+            let auth_client = Arc::new(MutinyAuthClient::new(
+                auth_manager,
+                lnurl_client,
+                logger.clone(),
+                auth_url,
+            ));
+
+            storage_url.map(|url| {
+                Arc::new(MutinyVssClient::new_authenticated(
+                    auth_client.clone(),
+                    url,
+                    xprivkey.private_key,
+                    logger.clone(),
+                ))
+            })
+        } else {
+            storage_url.map(|url| {
+                Arc::new(MutinyVssClient::new_unauthenticated(
+                    url,
+                    xprivkey.private_key,
+                    logger.clone(),
+                ))
+            })
+        };
+
+        if let Some(vss) = vss_client {
+            let obj = vss.get_object(DEVICE_LOCK_KEY).await?;
+            let lock = serde_json::from_value::<DeviceLock>(obj.value)?;
+
+            return Ok(Some(lock.remaining_secs()));
+        };
+
+        Ok(None)
+    }
+
     /// Starts up all the nodes again.
     /// Not needed after [NodeManager]'s `new()` function.
     #[wasm_bindgen]