Continue redesign for the v1 stable release (#5)

Reviewed-on: #5

crates/state/src/constants.rs

@@ -0,0 +1,59 @@
+use std::sync::OnceLock;
+
+/// Client name (Application name)
+pub const CLIENT_NAME: &str = "Coop";
+
+/// COOP's public key
+pub const COOP_PUBKEY: &str = "npub126kl5fruqan90py77gf6pvfvygefl2mu2ukew6xdx5pc5uqscwgsnkgarv";
+
+/// App ID
+pub const APP_ID: &str = "su.reya.coop";
+
+/// Keyring name
+pub const KEYRING: &str = "Coop Safe Storage";
+
+/// Default timeout for subscription
+pub const TIMEOUT: u64 = 3;
+
+/// Default delay for searching
+pub const FIND_DELAY: u64 = 600;
+
+/// Default limit for searching
+pub const FIND_LIMIT: usize = 20;
+
+/// Default timeout for Nostr Connect
+pub const NOSTR_CONNECT_TIMEOUT: u64 = 200;
+
+/// Default Nostr Connect relay
+pub const NOSTR_CONNECT_RELAY: &str = "wss://relay.nsec.app";
+
+/// Default subscription id for device gift wrap events
+pub const DEVICE_GIFTWRAP: &str = "device-gift-wraps";
+
+/// Default subscription id for user gift wrap events
+pub const USER_GIFTWRAP: &str = "user-gift-wraps";
+
+/// Default vertex relays
+pub const WOT_RELAYS: [&str; 1] = ["wss://relay.vertexlab.io"];
+
+/// Default search relays
+pub const SEARCH_RELAYS: [&str; 1] = ["wss://antiprimal.net"];
+
+/// Default bootstrap relays
+pub const BOOTSTRAP_RELAYS: [&str; 3] = [
+    "wss://relay.damus.io",
+    "wss://relay.primal.net",
+    "wss://user.kindpag.es",
+];
+
+static APP_NAME: OnceLock<String> = OnceLock::new();
+
+/// Get the app name
+pub fn app_name() -> &'static String {
+    APP_NAME.get_or_init(|| {
+        let devicename = whoami::devicename();
+        let platform = whoami::platform();
+
+        format!("{CLIENT_NAME} on {platform} ({devicename})")
+    })
+}

crates/state/src/identity.rs

@@ -1,101 +0,0 @@
-use nostr_sdk::prelude::*;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum RelayState {
-    #[default]
-    Initial,
-    NotSet,
-    Set,
-}
-
-impl RelayState {
-    pub fn is_initial(&self) -> bool {
-        matches!(self, RelayState::Initial)
-    }
-}
-
-/// Identity
-#[derive(Debug, Clone, Default)]
-pub struct Identity {
-    /// The public key of the account
-    pub public_key: Option<PublicKey>,
-
-    /// Whether the identity is owned by the user
-    pub owned: bool,
-
-    /// Status of the current user NIP-65 relays
-    relay_list: RelayState,
-
-    /// Status of the current user NIP-17 relays
-    messaging_relays: RelayState,
-}
-
-impl AsRef<Identity> for Identity {
-    fn as_ref(&self) -> &Identity {
-        self
-    }
-}
-
-impl Identity {
-    pub fn new() -> Self {
-        Self {
-            public_key: None,
-            owned: true,
-            relay_list: RelayState::default(),
-            messaging_relays: RelayState::default(),
-        }
-    }
-
-    /// Resets the relay states to their default values.
-    pub fn reset_relay_state(&mut self) {
-        self.relay_list = RelayState::default();
-        self.messaging_relays = RelayState::default();
-    }
-
-    /// Sets the state of the NIP-65 relays.
-    pub fn set_relay_list_state(&mut self, state: RelayState) {
-        self.relay_list = state;
-    }
-
-    /// Returns the state of the NIP-65 relays.
-    pub fn relay_list_state(&self) -> RelayState {
-        self.relay_list
-    }
-
-    /// Sets the state of the NIP-17 relays.
-    pub fn set_messaging_relays_state(&mut self, state: RelayState) {
-        self.messaging_relays = state;
-    }
-
-    /// Returns the state of the NIP-17 relays.
-    pub fn messaging_relays_state(&self) -> RelayState {
-        self.messaging_relays
-    }
-
-    /// Force getting the public key of the identity.
-    ///
-    /// Panics if the public key is not set.
-    pub fn public_key(&self) -> PublicKey {
-        self.public_key.unwrap()
-    }
-
-    /// Returns true if the identity has a public key.
-    pub fn has_public_key(&self) -> bool {
-        self.public_key.is_some()
-    }
-
-    /// Sets the public key of the identity.
-    pub fn set_public_key(&mut self, public_key: PublicKey) {
-        self.public_key = Some(public_key);
-    }
-
-    /// Unsets the public key of the identity.
-    pub fn unset_public_key(&mut self) {
-        self.public_key = None;
-    }
-
-    /// Sets whether the identity is owned by the user.
-    pub fn set_owned(&mut self, owned: bool) {
-        self.owned = owned;
-    }
-}

crates/state/src/signer.rs

@@ -0,0 +1,132 @@
+use std::borrow::Cow;
+use std::result::Result;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+use nostr_sdk::prelude::*;
+use smol::lock::RwLock;
+
+#[derive(Debug)]
+pub struct CoopSigner {
+    signer: RwLock<Arc<dyn NostrSigner>>,
+
+    /// Signer's public key
+    signer_pkey: RwLock<Option<PublicKey>>,
+
+    /// Whether coop is creating a new identity
+    creating: AtomicBool,
+
+    /// By default, Coop generates a new signer for new users.
+    ///
+    /// This flag indicates whether the signer is user-owned or Coop-generated.
+    owned: AtomicBool,
+}
+
+impl CoopSigner {
+    pub fn new<T>(signer: T) -> Self
+    where
+        T: IntoNostrSigner,
+    {
+        Self {
+            signer: RwLock::new(signer.into_nostr_signer()),
+            signer_pkey: RwLock::new(None),
+            creating: AtomicBool::new(false),
+            owned: AtomicBool::new(false),
+        }
+    }
+
+    /// Get the current signer.
+    pub async fn get(&self) -> Arc<dyn NostrSigner> {
+        self.signer.read().await.clone()
+    }
+
+    /// Get public key
+    pub fn public_key(&self) -> Option<PublicKey> {
+        self.signer_pkey.read_blocking().to_owned()
+    }
+
+    /// Get the flag indicating whether the signer is creating a new identity.
+    pub fn creating(&self) -> bool {
+        self.creating.load(Ordering::SeqCst)
+    }
+
+    /// Get the flag indicating whether the signer is user-owned.
+    pub fn owned(&self) -> bool {
+        self.owned.load(Ordering::SeqCst)
+    }
+
+    /// Switch the current signer to a new signer.
+    pub async fn switch<T>(&self, new: T, owned: bool)
+    where
+        T: IntoNostrSigner,
+    {
+        let new_signer = new.into_nostr_signer();
+        let public_key = new_signer.get_public_key().await.ok();
+        let mut signer = self.signer.write().await;
+        let mut signer_pkey = self.signer_pkey.write().await;
+
+        // Switch to the new signer
+        *signer = new_signer;
+
+        // Update the public key
+        *signer_pkey = public_key;
+
+        // Update the owned flag
+        self.owned.store(owned, Ordering::SeqCst);
+    }
+}
+
+impl NostrSigner for CoopSigner {
+    #[allow(mismatched_lifetime_syntaxes)]
+    fn backend(&self) -> SignerBackend {
+        SignerBackend::Custom(Cow::Borrowed("custom"))
+    }
+
+    fn get_public_key<'a>(&'a self) -> BoxedFuture<'a, Result<PublicKey, SignerError>> {
+        Box::pin(async move { self.get().await.get_public_key().await })
+    }
+
+    fn sign_event<'a>(
+        &'a self,
+        unsigned: UnsignedEvent,
+    ) -> BoxedFuture<'a, Result<Event, SignerError>> {
+        Box::pin(async move { self.get().await.sign_event(unsigned).await })
+    }
+
+    fn nip04_encrypt<'a>(
+        &'a self,
+        public_key: &'a PublicKey,
+        content: &'a str,
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip04_encrypt(public_key, content).await })
+    }
+
+    fn nip04_decrypt<'a>(
+        &'a self,
+        public_key: &'a PublicKey,
+        encrypted_content: &'a str,
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move {
+            self.get()
+                .await
+                .nip04_decrypt(public_key, encrypted_content)
+                .await
+        })
+    }
+
+    fn nip44_encrypt<'a>(
+        &'a self,
+        public_key: &'a PublicKey,
+        content: &'a str,
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip44_encrypt(public_key, content).await })
+    }
+
+    fn nip44_decrypt<'a>(
+        &'a self,
+        public_key: &'a PublicKey,
+        payload: &'a str,
+    ) -> BoxedFuture<'a, Result<String, SignerError>> {
+        Box::pin(async move { self.get().await.nip44_decrypt(public_key, payload).await })
+    }
+}