sdk-rust: Make load() return Option

Not strictly required, but allows downstream consumers to detect that
they need to call `signup()` if `load()` returns `None`

Author: MaxFangX

app-rs/src/app.rs

@@ -93,7 +93,7 @@ impl App {
         let wallet_user = WalletUser::from_seed(rng, root_seed);
 
         let user_db_config =
-            WalletUserDbConfig::new(wallet_user.user_pk, env_db_config.clone());
+            WalletUserDbConfig::new(env_db_config.clone(), wallet_user.user_pk);
 
         // Create fresh wallet
         let credentials = CredentialsRef::from(root_seed);
@@ -173,23 +173,37 @@ impl App {
         // If there's nothing in the secret store, this must be a fresh install;
         // we can just return here.
         let root_seed = match maybe_root_seed {
-            None => return Ok(None),
             Some(s) => s,
+            None => return Ok(None),
         };
 
         let wallet_user = WalletUser::from_seed(rng, &root_seed);
         let user_db_config =
-            WalletUserDbConfig::new(wallet_user.user_pk, env_db_config.clone());
+            WalletUserDbConfig::new(env_db_config.clone(), wallet_user.user_pk);
 
-        // Load existing wallet
+        // Load the wallet.
         let credentials = CredentialsRef::from(&root_seed);
-        let wallet = LexeWallet::load(
+        let maybe_wallet = LexeWallet::load(
             rng,
             env_config.clone(),
             credentials,
             env_db_config.lexe_data_dir().clone(),
         )
         .context("Failed to build LexeWallet")?;
+        let wallet = match maybe_wallet {
+            Some(w) => w,
+            // This is a weird case: our seed exists but our local data doesn't.
+            // Maybe the user manually deleted their local data? In any case,
+            // we don't want to send the user back to the signup / restore
+            // flows, so just create a fresh wallet instance.
+            None => LexeWallet::fresh(
+                rng,
+                env_config.clone(),
+                credentials,
+                env_db_config.lexe_data_dir().clone(),
+            )
+            .context("Failed to build fresh LexeWallet")?,
+        };
         let user_config = wallet.user_config().clone();
 
         let app_db =
@@ -222,7 +236,7 @@ impl App {
     ) -> anyhow::Result<Self> {
         let wallet_user = WalletUser::from_seed(rng, root_seed);
         let user_db_config =
-            WalletUserDbConfig::new(wallet_user.user_pk, env_db_config.clone());
+            WalletUserDbConfig::new(env_db_config.clone(), wallet_user.user_pk);
 
         // Init a fresh LexeWallet
         let credentials = CredentialsRef::from(root_seed);

node-client/src/credentials.rs

@@ -35,6 +35,7 @@ pub enum Credentials {
 }
 
 /// Borrowed credentials required to connect to a user node via mTLS.
+#[derive(Copy, Clone)]
 pub enum CredentialsRef<'a> {
     /// Using a [`RootSeed`]. Ex: app.
     RootSeed(&'a RootSeed),

sdk-rust/src/config.rs

@@ -1,6 +1,8 @@
 use std::{borrow::Cow, fmt, path::PathBuf, sync::LazyLock};
 
+use anyhow::Context;
 use common::{api::user::UserPk, env::DeployEnv, ln::network::LxNetwork};
+use node_client::credentials::CredentialsRef;
 
 use crate::unstable::provision;
 
@@ -229,7 +231,7 @@ impl WalletEnvDbConfig {
 impl WalletUserDbConfig {
     /// Construct a new [`WalletUserDbConfig`] from the environment database
     /// config and user public key.
-    pub fn new(user_pk: UserPk, env_db_config: WalletEnvDbConfig) -> Self {
+    pub fn new(env_db_config: WalletEnvDbConfig, user_pk: UserPk) -> Self {
         let user_db_dir = env_db_config.env_db_dir.join(user_pk.to_string());
         Self {
             env_db_config,
@@ -238,6 +240,20 @@ impl WalletUserDbConfig {
         }
     }
 
+    /// Construct a new [`WalletUserDbConfig`] from credentials and the
+    /// environment database config.
+    pub fn from_credentials(
+        credentials: CredentialsRef<'_>,
+        env_db_config: WalletEnvDbConfig,
+    ) -> anyhow::Result<Self> {
+        // Is `Some(_)` if the credentials were created by `node-v0.8.11+`.
+        let user_pk = credentials.user_pk().context(
+            "Client credentials are out of date. \
+             Please create a new one from within the Lexe wallet app.",
+        )?;
+        Ok(Self::new(env_db_config, user_pk))
+    }
+
     /// The environment-level database configuration.
     pub fn env_db_config(&self) -> &WalletEnvDbConfig {
         &self.env_db_config

sdk-rust/src/unstable/wallet_db.rs

@@ -66,8 +66,14 @@ impl WalletDb<DiskFs> {
         })
     }
 
-    /// Load an existing [`WalletDb`] (or create a new one if none exists).
-    pub fn load(user_db_config: WalletUserDbConfig) -> anyhow::Result<Self> {
+    /// Load an existing [`WalletDb`]. Returns [`None`] if no local data exists.
+    pub fn load(
+        user_db_config: WalletUserDbConfig,
+    ) -> anyhow::Result<Option<Self>> {
+        if !user_db_config.user_db_dir().exists() {
+            return Ok(None);
+        }
+
         let payments_ffs =
             DiskFs::create_dir_all(user_db_config.payments_db_dir())
                 .context("Could not create payments ffs")?;
@@ -100,7 +106,7 @@ impl WalletDb<DiskFs> {
         let provision_history = ProvisionHistory::read_from_ffs(&provision_ffs)
             .context("Could not read provision history")?;
 
-        // Log the latest provisioned enclave
+        // Log the latest provisioned enclave as of this load.
         match provision_history.provisioned.last() {
             Some(latest) => info!(
                 version = %latest.version,
@@ -111,13 +117,29 @@ impl WalletDb<DiskFs> {
             None => info!("Empty provision history"),
         }
 
-        Ok(Self {
+        Ok(Some(Self {
             user_db_config,
             payments_db,
             payment_sync_lock: tokio::sync::Mutex::new(()),
             provision_ffs,
             provision_history: Arc::new(Mutex::new(provision_history)),
-        })
+        }))
+    }
+
+    /// Load an existing [`WalletDb`], or create a fresh one if none exists.
+    pub fn load_or_fresh(
+        user_db_config: WalletUserDbConfig,
+    ) -> anyhow::Result<Self> {
+        let maybe_db = Self::load(user_db_config.clone())
+            .context("Failed to load wallet db")?;
+
+        let db = match maybe_db {
+            Some(d) => d,
+            None => Self::fresh(user_db_config)
+                .context("Failed to create fresh wallet db")?,
+        };
+
+        Ok(db)
     }
 
     /// Get the user database configuration.