Question: How to correctly persist client sign in data to local storage on a web client

[devanlooches]

Hello,
I want to start of by saying that I am new to nostr so apologies if I missed anything obvious.

I'm attempting to create a nostr client in Rust.
I would like the user to be able to sign in to the web page and then reload it without having to sign in again.
I've been attempting to serialize the data stored in the Client instance through various structs but nothing seems to work specifically for nip46 sign ins.
On sign in everything works as expected but as soon as I reload the page, it's as if I'm not signed in anymore.

So I wanted to ask, could anybody recommend the best way to serialize the Client sign in data to local storage?

My attempt so far have been to create a giant struct as follows:

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
#[serde(tag = "kind")]
pub enum SignerState {
    Nip07,
    Nip46 {
        remote_pubkey: String,
        relays: Vec<String>,
        app_secret_key: String,
        bunker_uri: String,
    },
    LocalSecret {
        secret_key: String,
    },
    PublicOnly {
        public_key: String,
    },
    #[default]
    None,
}

P.S. Thank you for this amazing set of libraries!

[yukibtc]

I see that in the SignerState::Nip46 variant you are storing the bunker URI, so if you are using it correctly in the code, it should work. Have you a small piece of code to show how you handle the automatic re-login?

So I wanted to ask, could anybody recommend the best way to serialize the Client sign in data to local storage?

The SignerState enum looks good. The Nip46 variant have additional data that can be removed: just the bunker URI and app keys are needed.

[devanlooches]

Thanks for the quick response!
My reinit function looks like this currently:

    pub async fn reinit_client_from_signer(&mut self) -> Result<(), Box<dyn Error>> {
        match &self.signer {
            SignerState::LocalSecret { secret_key } => {
                let keys = Keys::parse(secret_key).unwrap();
                self.client.set_signer(keys.clone()).await;
                self.public_key = keys.public_key().to_hex();
            }
            SignerState::Nip46 {
                remote_pubkey,
                app_secret_key,
                bunker_uri,
                relays,
            } => {
                trace!("Restoring NIP-46 signer from cache");
                let app_keys = Keys::parse(app_secret_key).unwrap();
                let nc = nostr_connect::client::NostrConnect::new(
                    nostr_sdk::nips::nip46::NostrConnectURI::parse(bunker_uri).unwrap(),
                    app_keys,
                    Duration::from_secs(5),
                    None,
                )
                .unwrap();
                self.client.set_signer(nc).await;
                self.public_key = remote_pubkey.clone();
                let _ = self.client.add_relay("My relay").await;
                self.client.connect().await;
            }
            SignerState::Nip07 | SignerState::PublicOnly { .. } | SignerState::None => {
                trace!("no local signer to restore");
            }
        }
        Ok(())
    }
}

This function is called after fetching from local storage:

    pub fn fetch_from_cache(&mut self) {
        let cached = window()
            .local_storage()
            .ok()
            .flatten()
            .and_then(|storage| {
                storage
                    .get_item(ACCOUNT_STORAGE_KEY)
                    .ok()
                    .flatten()
                    .and_then(|value| serde_json::from_str::<Self>(&value).ok())
            })
            .unwrap_or_default();
        self.public_key = cached.public_key;
        self.signer = cached.signer;
    }

[yukibtc]

This code seems good. Try to debug the fetch_from_cache, since from what I can see it may silently fail and return the default SignerState.

[devanlooches]

A good point I'll look into it.

[devanlooches]

I refactored it to log when the cache was empty and it seems the log is not empty when I reload from cache. So that doesn't seem to be the problem. One question I had was when adding my relays to the client, do I have to add the relay provided by the nostr bunker url explicitly or does the nostr_connect crate handle that?

[yukibtc]

The relays in the bunker URI are added automatically to the NostrConnect crate. They are not added to the Client, since are not used there. Also the connection/bootstrap happens automatically for the NostrConnect client, on the first interaction with it.

[devanlooches]

So the issue is I get a timeout error every time I try to send an event after signing back in with the cached uri. In addition, the new login doesn't even get logged on the remote signer so it seems like the connect doesn't even happen.
Here's my original login code by the way:

    pub async fn login(
        &mut self,
        input: String,
    ) -> Result<(), Box<dyn Error>> {
        let trimmed = input.trim();
        if trimmed.starts_with("bunker://") {
            let app_keys =Keys::generate();
            let uri = nostr_sdk::nips::nip46::NostrConnectURI::parse(trimmed).unwrap();
            let signer = nostr_connect::client::NostrConnect::new(
                uri.clone(),
                app_keys.clone(),
                Duration::from_secs(120),
                None,
            )
            .unwrap();
            self.client.set_signer(signer.clone()).await;
            self.client
                .add_relay("wss://...")
                .await
                .unwrap();
            self.client.connect().await;
            trace!("signer set and relay connected");
            let user_pk = self
                .client
                .signer()
                .await
                .unwrap()
                .get_public_key()
                .await
                .unwrap();
            self.public_key = user_pk.to_hex();
            // Persist bunker URI so we can restore the session later
            let bunker_uri = uri.clone().to_string();

            self.signer = SignerState::Nip46 { bunker_uri };
            info!(npub = %user_pk.to_bech32().unwrap(), "nip46 success");
            return Ok(());
        }

        // Next, try parsing as Keys (supports nsec/hex secret, maybe others)
        if let Ok(keys) = Keys::parse(trimmed) {
            trace!("local secret flow start");
            // If it contains a secret, set local signer
            // Local signer path (secret is in memory here)
            self.client.set_signer(keys.clone()).await;
            self.client
                .add_relay("wss://....")
                .await
                .unwrap();
            self.client.connect().await;
            self.public_key = keys.public_key().to_hex();
            self.signer = SignerState::LocalSecret {
                secret_key: keys.secret_key().to_secret_hex(),
            };
            info!(npub = %keys.public_key().to_bech32()?, "local secret success");
            return Ok(());
        }

        warn!("unsupported input");
        Err("Unrecognized login input. Note: Public keys are not supported.".into())
    }

[devanlooches]

By the way I am using nsec.app to test this functionality.

[devanlooches]

It occurred to me that my problem may have to do with how I am handling the Client on the leptos side of things (the signal is hard to manipulate through asynchronous functions).
I think I'm going to close this discussion since you have answered my main question.
Thank you very much for the help!