feat: use negentropy (#182)

* feat: use negentropy

* chore: polish

src-tauri/src/main.rs

@@ -54,6 +54,10 @@ fn main() {
 
         // Add some bootstrap relays
         // #TODO: Pull bootstrap relays from user's settings
+        client
+          .add_relay("wss://relay.damus.io")
+          .await
+          .expect("Cannot connect to relay.damus.io, please try again later.");
         client
           .add_relay("wss://relayable.org")
           .await

src-tauri/src/nostr/event.rs

@@ -40,34 +40,33 @@ pub async fn get_event(id: &str, state: State<'_, Nostr>) -> Result<String, Stri
 
 #[tauri::command]
 pub async fn get_events_from(
-  id: &str,
+  public_key: &str,
   limit: usize,
-  until: Option<&str>,
+  as_of: Option<&str>,
   state: State<'_, Nostr>,
 ) -> Result<Vec<Event>, String> {
   let client = &state.client;
-  let f_until = match until {
-    Some(until) => Timestamp::from_str(until).unwrap(),
-    None => Timestamp::now(),
-  };
 
-  if let Ok(author) = PublicKey::from_str(id) {
+  if let Ok(author) = PublicKey::from_str(public_key) {
+    let until = match as_of {
+      Some(until) => Timestamp::from_str(until).unwrap(),
+      None => Timestamp::now(),
+    };
     let filter = Filter::new()
       .kinds(vec![Kind::TextNote, Kind::Repost])
       .authors(vec![author])
       .limit(limit)
-      .until(f_until);
+      .until(until);
+    let _ = client
+      .reconcile(filter.clone(), NegentropyOptions::default())
+      .await;
 
-    if let Ok(events) = client
-      .get_events_of(vec![filter], Some(Duration::from_secs(10)))
-      .await
-    {
-      Ok(events)
-    } else {
-      Err("Get text event failed".into())
+    match client.database().query(vec![filter], Order::Asc).await {
+      Ok(events) => Ok(events),
+      Err(err) => Err(err.to_string()),
     }
   } else {
-    Err("Parse author failed".into())
+    Err("Public Key is not valid, please check again.".into())
   }
 }
 
@@ -92,14 +91,12 @@ pub async fn get_events(
         .limit(limit)
         .until(as_of);
 
-      if let Ok(events) = client
+      match client
         .get_events_of(vec![filter], Some(Duration::from_secs(15)))
         .await
       {
-        println!("total global events: {}", events.len());
-        Ok(events)
-      } else {
-        Err("Get events failed".into())
+        Ok(events) => Ok(events),
+        Err(err) => Err(err.to_string()),
       }
     }
     false => {
@@ -132,15 +129,13 @@ pub async fn get_events(
               .limit(limit)
               .authors(val)
               .until(as_of);
+            let _ = client
+              .reconcile(filter.clone(), NegentropyOptions::default())
+              .await;
 
-            if let Ok(events) = client
-              .get_events_of(vec![filter], Some(Duration::from_secs(15)))
-              .await
-            {
-              println!("total local events: {}", events.len());
-              Ok(events)
-            } else {
-              Err("Get events failed".into())
+            match client.database().query(vec![filter], Order::Asc).await {
+              Ok(events) => Ok(events),
+              Err(err) => Err(err.to_string()),
             }
           }
         }
@@ -167,31 +162,36 @@ pub async fn get_events_from_interests(
     .limit(limit)
     .until(as_of)
     .hashtags(hashtags);
+  let _ = client
+    .reconcile(filter.clone(), NegentropyOptions::default())
+    .await;
 
-  if let Ok(events) = client
-    .get_events_of(vec![filter], Some(Duration::from_secs(15)))
-    .await
-  {
-    println!("total events: {}", events.len());
-    Ok(events)
-  } else {
-    Err("Get text event failed".into())
+  match client.database().query(vec![filter], Order::Asc).await {
+    Ok(events) => Ok(events),
+    Err(err) => Err(err.to_string()),
   }
 }
 
 #[tauri::command]
-pub async fn get_event_thread(id: &str, state: State<'_, Nostr>) -> Result<Vec<Event>, ()> {
+pub async fn get_event_thread(id: &str, state: State<'_, Nostr>) -> Result<Vec<Event>, String> {
   let client = &state.client;
-  let event_id = EventId::from_hex(id).unwrap();
-  let filter = Filter::new().kinds(vec![Kind::TextNote]).event(event_id);
 
-  if let Ok(events) = client
-    .get_events_of(vec![filter], Some(Duration::from_secs(10)))
-    .await
-  {
-    Ok(events)
-  } else {
-    Err(())
+  match EventId::from_hex(id) {
+    Ok(event_id) => {
+      let filter = Filter::new().kinds(vec![Kind::TextNote]).event(event_id);
+      let _ = client
+        .reconcile(filter.clone(), NegentropyOptions::default())
+        .await;
+
+      match client
+        .get_events_of(vec![filter], Some(Duration::from_secs(10)))
+        .await
+      {
+        Ok(events) => Ok(events),
+        Err(err) => Err(err.to_string()),
+      }
+    }
+    Err(_) => Err("Event ID is not valid".into()),
   }
 }
 

src-tauri/src/nostr/keys.rs

@@ -152,30 +152,29 @@ pub async fn load_selected_account(npub: &str, state: State<'_, Nostr>) -> Resul
   let client = &state.client;
   let keyring = Entry::new("Lume Secret Storage", npub).unwrap();
 
-  if let Ok(password) = keyring.get_password() {
-    if password.starts_with("bunker://") {
-      let app_keys = Keys::generate();
-      let bunker_uri = NostrConnectURI::parse(password).unwrap();
-      let signer = Nip46Signer::new(bunker_uri, app_keys, Duration::from_secs(60), None)
-        .await
-        .unwrap();
+  match keyring.get_password() {
+    Ok(password) => {
+      if password.starts_with("bunker://") {
+        let app_keys = Keys::generate();
+        let bunker_uri = NostrConnectURI::parse(password).unwrap();
+        let signer = Nip46Signer::new(bunker_uri, app_keys, Duration::from_secs(60), None)
+          .await
+          .unwrap();
 
-      // Update signer
-      client.set_signer(Some(signer.into())).await;
-      // Done
-      Ok(true)
-    } else {
-      let secret_key = SecretKey::from_bech32(password).expect("Get secret key failed");
-      let keys = Keys::new(secret_key);
-      let signer = NostrSigner::Keys(keys);
+        // Update signer
+        client.set_signer(Some(signer.into())).await;
+      } else {
+        let secret_key = SecretKey::from_bech32(password).expect("Get secret key failed");
+        let keys = Keys::new(secret_key);
+        let signer = NostrSigner::Keys(keys);
+
+        // Update signer
+        client.set_signer(Some(signer)).await;
+      }
 
-      // Update signer
-      client.set_signer(Some(signer)).await;
-      // Done
       Ok(true)
     }
-  } else {
-    Err("nsec not found".into())
+    Err(err) => Err(err.to_string()),
   }
 }