feat: send to default relays, blast repo event

improve the distribution of events by sending to default relays
in addition to user and repo relays. for better discoverability of
repo events, this is also blasted.

a temporary fix to blast everything was removed.

the less reliable purplepages.es relay is moved to
more_fallback_relays that currently isn't used

6 files changed, 124 insertions, 57 deletions

diff --git a/src/client.rs b/src/client.rs
index 97cb856..9bc171a 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -26,6 +26,7 @@ pub struct Client {
     client: nostr_sdk::Client,
     fallback_relays: Vec<String>,
     more_fallback_relays: Vec<String>,
+    blaster_relays: Vec<String>,
 }
 
 #[cfg_attr(test, automock)]
@@ -37,6 +38,7 @@ pub trait Connect {
     async fn disconnect(&self) -> Result<()>;
     fn get_fallback_relays(&self) -> &Vec<String>;
     fn get_more_fallback_relays(&self) -> &Vec<String>;
+    fn get_blaster_relays(&self) -> &Vec<String>;
     async fn send_event_to(&self, url: &str, event: nostr::event::Event) -> Result<nostr::EventId>;
     async fn get_events(
         &self,
@@ -55,7 +57,6 @@ impl Connect for Client {
             ]
         } else {
             vec![
-                "wss://purplepages.es".to_string(),
                 "wss://relay.damus.io".to_string(),
                 "wss://nostr-pub.wellorder.net".to_string(),
                 "wss://nos.lol".to_string(),
@@ -70,6 +71,7 @@ impl Connect for Client {
             ]
         } else {
             vec![
+                "wss://purplepages.es".to_string(),
                 "wss://nostr.wine/".to_string(),
                 "wss://eden.nostr.land/".to_string(),
                 "wss://relay.nostr.band/".to_string(),
@@ -77,10 +79,16 @@ impl Connect for Client {
             ]
         };
 
+        let blaster_relays: Vec<String> = if std::env::var("NGITTEST").is_ok() {
+            vec!["ws://localhost:8057".to_string()]
+        } else {
+            vec!["wss://nostr.mutinywallet.com".to_string()]
+        };
         Client {
             client: nostr_sdk::Client::new(&nostr::Keys::generate()),
             fallback_relays,
             more_fallback_relays,
+            blaster_relays,
         }
     }
     fn new(opts: Params) -> Self {
@@ -88,6 +96,7 @@ impl Connect for Client {
             client: nostr_sdk::Client::new(&opts.keys.unwrap_or(nostr::Keys::generate())),
             fallback_relays: opts.fallback_relays,
             more_fallback_relays: opts.more_fallback_relays,
+            blaster_relays: opts.blaster_relays,
         }
     }
 
@@ -110,6 +119,10 @@ impl Connect for Client {
         &self.more_fallback_relays
     }
 
+    fn get_blaster_relays(&self) -> &Vec<String> {
+        &self.blaster_relays
+    }
+
     async fn send_event_to(&self, url: &str, event: Event) -> Result<nostr::EventId> {
         self.client.add_relay(url).await?;
         self.client.connect_relay(url).await?;
@@ -243,6 +256,7 @@ pub struct Params {
     pub keys: Option<nostr::Keys>,
     pub fallback_relays: Vec<String>,
     pub more_fallback_relays: Vec<String>,
+    pub blaster_relays: Vec<String>,
 }
 
 fn get_dedup_events(relay_results: Vec<Result<Vec<nostr::Event>>>) -> Vec<Event> {
diff --git a/src/sub_commands/init.rs b/src/sub_commands/init.rs
index a95021d..9fdcca5 100644
--- a/src/sub_commands/init.rs
+++ b/src/sub_commands/init.rs
@@ -81,7 +81,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
 
     let mut maintainers = vec![keys.public_key()];
 
-    let mut repo_relays: Vec<String> = if !args.relays.is_empty() {
+    let repo_relays: Vec<String> = if !args.relays.is_empty() {
         args.relays.clone()
     } else if let Ok(config) = &repo_config_result {
         config.relays.clone()
@@ -92,16 +92,6 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         user_ref.relays.write()
     };
 
-    // TODO: add blaster for just repo event and don't add it to repo relays
-    // TODO: fix the tests to support blaster
-    if std::env::var("NGITTEST").is_err()
-        && !repo_relays
-            .iter()
-            .any(|s| s.contains("nostr.mutinywallet.com"))
-    {
-        repo_relays.push("wss://nostr.mutinywallet.com".to_string());
-    }
-
     if let Ok(config) = &repo_config_result {
         maintainers = extract_pks(config.maintainers.clone())?;
     }
diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index 2c1dec8..b8cb271 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -183,7 +183,23 @@ pub async fn send_events(
     repo_read_relays: Vec<String>,
     animate: bool,
 ) -> Result<()> {
-    let (_, _, _, all) = unique_and_duplicate_all(&my_write_relays, &repo_read_relays);
+    let (_, _, _, mut all) = unique_and_duplicate_all(&my_write_relays, &repo_read_relays);
+
+    let mut fallback = client.get_fallback_relays().clone();
+
+    // blast repo events
+    if events.iter().any(|e| e.kind().as_u64().eq(&REPO_REF_KIND)) {
+        for r in client.get_blaster_relays() {
+            fallback.push(r.to_string());
+        }
+    }
+
+    // then remaining fallback list
+    for r in &fallback {
+        if !all.iter().any(|r2| r2.eq(&r)) {
+            all.push(r);
+        }
+    }
 
     let m = MultiProgress::new();
     let pb_style = ProgressStyle::with_template(if animate {
@@ -215,7 +231,7 @@ pub async fn send_events(
 
     join_all(all.iter().map(|&relay| async {
         let details = format!(
-            "{}{} {}",
+            "{}{}{} {}",
             if my_write_relays.iter().any(|r| relay.eq(r)) {
                 " [my-relay]"
             } else {
@@ -226,6 +242,11 @@ pub async fn send_events(
             } else {
                 ""
             },
+            if fallback.iter().any(|r| relay.eq(r)) {
+                " [default]"
+            } else {
+                ""
+            },
             *relay,
         );
         let pb = m.add(
diff --git a/tests/init.rs b/tests/init.rs
index 56ce332..6db2554 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -58,10 +58,11 @@ mod when_repo_not_previously_claimed {
             Relay<'static>,
             Relay<'static>,
             Relay<'static>,
+            Relay<'static>,
         )> {
             let git_repo = prep_git_repo()?;
-            // fallback (51,52) user write (53, 55) repo (55, 56)
-            let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+            // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
+            let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
                 Relay::new(
                     8051,
                     None,
@@ -81,13 +82,14 @@ mod when_repo_not_previously_claimed {
                 Relay::new(8053, None, None),
                 Relay::new(8055, None, None),
                 Relay::new(8056, None, None),
+                Relay::new(8057, None, None),
             );
 
             // // check relay had the right number of events
             let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
                 let mut p = cli_tester_init(&git_repo);
                 p.expect_end_eventually()?;
-                for p in [51, 52, 53, 55, 56] {
+                for p in [51, 52, 53, 55, 56, 57] {
                     relay::shutdown_relay(8000 + p)?;
                 }
                 Ok(())
@@ -100,9 +102,10 @@ mod when_repo_not_previously_claimed {
                 r53.listen_until_close(),
                 r55.listen_until_close(),
                 r56.listen_until_close(),
+                r57.listen_until_close(),
             );
             cli_tester_handle.join().unwrap()?;
-            Ok((r51, r52, r53, r55, r56))
+            Ok((r51, r52, r53, r55, r56, r57))
         }
 
         mod sent_to_correct_relays {
@@ -111,7 +114,7 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn only_1_repository_kind_event_sent_to_user_relays() -> Result<()> {
-                let (_, _, r53, r55, _) = prep_run_init().await?;
+                let (_, _, r53, r55, _, _) = prep_run_init().await?;
                 for relay in [&r53, &r55] {
                     assert_eq!(
                         relay
@@ -128,7 +131,7 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn only_1_repository_kind_event_sent_to_specified_repo_relays() -> Result<()> {
-                let (_, _, _, r55, r56) = prep_run_init().await?;
+                let (_, _, _, r55, r56, _) = prep_run_init().await?;
                 for relay in [&r55, &r56] {
                     assert_eq!(
                         relay
@@ -144,8 +147,8 @@ mod when_repo_not_previously_claimed {
 
             #[tokio::test]
             #[serial]
-            async fn event_not_sent_to_fallback_relay() -> Result<()> {
-                let (r51, r52, _, _, _) = prep_run_init().await?;
+            async fn only_1_repository_kind_event_sent_to_fallback_relays() -> Result<()> {
+                let (r51, r52, _, _, _, _) = prep_run_init().await?;
                 for relay in [&r51, &r52] {
                     assert_eq!(
                         relay
@@ -153,11 +156,25 @@ mod when_repo_not_previously_claimed {
                             .iter()
                             .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
                             .count(),
-                        0,
+                        1,
                     );
                 }
                 Ok(())
             }
+
+            #[tokio::test]
+            #[serial]
+            async fn only_1_repository_kind_event_sent_to_blaster_relays() -> Result<()> {
+                let (_, _, _, _, _, r57) = prep_run_init().await?;
+                assert_eq!(
+                    r57.events
+                        .iter()
+                        .filter(|e| e.kind.as_u64().eq(&REPOSITORY_KIND))
+                        .count(),
+                    1,
+                );
+                Ok(())
+            }
         }
 
         mod yaml_file {
@@ -167,8 +184,8 @@ mod when_repo_not_previously_claimed {
 
             async fn async_run_test() -> Result<()> {
                 let git_repo = prep_git_repo()?;
-                // fallback (51,52) user write (53, 55) repo (55, 56)
-                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
+                let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
                     Relay::new(
                         8051,
                         None,
@@ -188,6 +205,7 @@ mod when_repo_not_previously_claimed {
                     Relay::new(8053, None, None),
                     Relay::new(8055, None, None),
                     Relay::new(8056, None, None),
+                    Relay::new(8057, None, None),
                 );
 
                 // // check relay had the right number of events
@@ -214,7 +232,7 @@ mod when_repo_not_previously_claimed {
                         "
                         ),
                     );
-                    for p in [51, 52, 53, 55, 56] {
+                    for p in [51, 52, 53, 55, 56, 57] {
                         relay::shutdown_relay(8000 + p)?;
                     }
                     Ok(())
@@ -227,6 +245,7 @@ mod when_repo_not_previously_claimed {
                     r53.listen_until_close(),
                     r55.listen_until_close(),
                     r56.listen_until_close(),
+                    r57.listen_until_close(),
                 );
                 cli_tester_handle.join().unwrap()?;
                 Ok(())
@@ -247,8 +266,8 @@ mod when_repo_not_previously_claimed {
             #[serial]
             async fn d_replaceable_event_identifier_defaults_to_root_commit_id_shorthand()
             -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -268,8 +287,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn root_commit_as_reference() -> Result<()> {
-                let (_, _, r53, r55, r56) = prep_run_init().await?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -285,8 +304,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn name() -> Result<()> {
-                let (_, _, r53, r55, r56) = prep_run_init().await?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -306,8 +325,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn description() -> Result<()> {
-                let (_, _, r53, r55, r56) = prep_run_init().await?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -323,8 +342,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn git_server() -> Result<()> {
-                let (_, _, r53, r55, r56) = prep_run_init().await?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -342,8 +361,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn relays() -> Result<()> {
-                let (_, _, r53, r55, r56) = prep_run_init().await?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -364,8 +383,8 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn web() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
-                for relay in [&r53, &r55, &r56] {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -383,11 +402,11 @@ mod when_repo_not_previously_claimed {
                 Ok(())
             }
 
-            #[test]
+            #[tokio::test]
             #[serial]
-            fn current_user_in_maintainers() -> Result<()> {
-                let (_, _, r53, r55, r56) = futures::executor::block_on(prep_run_init())?;
-                for relay in [&r53, &r55, &r56] {
+            async fn current_user_in_maintainers() -> Result<()> {
+                let (_, _, r53, r55, r56, r57) = prep_run_init().await?;
+                for relay in [&r53, &r55, &r56, &r57] {
                     let event: &nostr::Event = relay
                         .events
                         .iter()
@@ -411,7 +430,8 @@ mod when_repo_not_previously_claimed {
             async fn run_test_async() -> Result<()> {
                 let git_repo = prep_git_repo()?;
 
-                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
+                let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
                     Relay::new(
                         8051,
                         None,
@@ -431,6 +451,7 @@ mod when_repo_not_previously_claimed {
                     Relay::new(8053, None, None),
                     Relay::new(8055, None, None),
                     Relay::new(8056, None, None),
+                    Relay::new(8057, None, None),
                 );
 
                 // // check relay had the right number of events
@@ -443,11 +464,14 @@ mod when_repo_not_previously_claimed {
                             (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
                             (" [my-relay] ws://localhost:8053", true, ""),
                             (" [repo-relay] ws://localhost:8056", true, ""),
+                            (" [default] ws://localhost:8051", true, ""),
+                            (" [default] ws://localhost:8052", true, ""),
+                            (" [default] ws://localhost:8057", true, ""),
                         ],
                         1,
                     )?;
                     p.expect_end_with_whitespace()?;
-                    for p in [51, 52, 53, 55, 56] {
+                    for p in [51, 52, 53, 55, 56, 57] {
                         relay::shutdown_relay(8000 + p)?;
                     }
                     Ok(())
@@ -460,6 +484,7 @@ mod when_repo_not_previously_claimed {
                     r53.listen_until_close(),
                     r55.listen_until_close(),
                     r56.listen_until_close(),
+                    r57.listen_until_close(),
                 );
                 cli_tester_handle.join().unwrap()?;
                 Ok(())
@@ -514,10 +539,11 @@ mod when_repo_not_previously_claimed {
             Relay<'static>,
             Relay<'static>,
             Relay<'static>,
+            Relay<'static>,
         )> {
             let git_repo = prep_git_repo()?;
-            // fallback (51,52) user write (53, 55) repo (55, 56)
-            let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+            // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
+            let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
                 Relay::new(
                     8051,
                     None,
@@ -537,13 +563,14 @@ mod when_repo_not_previously_claimed {
                 Relay::new(8053, None, None),
                 Relay::new(8055, None, None),
                 Relay::new(8056, None, None),
+                Relay::new(8057, None, None),
             );
 
             // // check relay had the right number of events
             let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
                 let mut p = cli_tester_init(&git_repo);
                 p.expect_end_eventually()?;
-                for p in [51, 52, 53, 55, 56] {
+                for p in [51, 52, 53, 55, 56, 57] {
                     relay::shutdown_relay(8000 + p)?;
                 }
                 Ok(())
@@ -556,9 +583,10 @@ mod when_repo_not_previously_claimed {
                 r53.listen_until_close(),
                 r55.listen_until_close(),
                 r56.listen_until_close(),
+                r57.listen_until_close(),
             );
             cli_tester_handle.join().unwrap()?;
-            Ok((r51, r52, r53, r55, r56))
+            Ok((r51, r52, r53, r55, r56, r57))
         }
 
         mod tags {
@@ -567,7 +595,7 @@ mod when_repo_not_previously_claimed {
             #[tokio::test]
             #[serial]
             async fn relays_match_user_write_relays() -> Result<()> {
-                let (_, _, r53, r55, _) = prep_run_init().await?;
+                let (_, _, r53, r55, _, _) = prep_run_init().await?;
                 for relay in [&r53, &r55] {
                     let event: &nostr::Event = relay
                         .events
@@ -589,7 +617,8 @@ mod when_repo_not_previously_claimed {
             async fn run_test_async() -> Result<()> {
                 let git_repo = prep_git_repo()?;
 
-                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                // fallback (51,52) user write (53, 55) repo (55, 56) blaster (57)
+                let (mut r51, mut r52, mut r53, mut r55, mut r56, mut r57) = (
                     Relay::new(
                         8051,
                         None,
@@ -609,6 +638,7 @@ mod when_repo_not_previously_claimed {
                     Relay::new(8053, None, None),
                     Relay::new(8055, None, None),
                     Relay::new(8056, None, None),
+                    Relay::new(8057, None, None),
                 );
 
                 // // check relay had the right number of events
@@ -620,11 +650,14 @@ mod when_repo_not_previously_claimed {
                         vec![
                             (" [my-relay] [repo-relay] ws://localhost:8053", true, ""),
                             (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
+                            (" [default] ws://localhost:8051", true, ""),
+                            (" [default] ws://localhost:8052", true, ""),
+                            (" [default] ws://localhost:8057", true, ""),
                         ],
                         1,
                     )?;
                     p.expect_end_with_whitespace()?;
-                    for p in [51, 52, 53, 55, 56] {
+                    for p in [51, 52, 53, 55, 56, 57] {
                         relay::shutdown_relay(8000 + p)?;
                     }
                     Ok(())
@@ -637,6 +670,7 @@ mod when_repo_not_previously_claimed {
                     r53.listen_until_close(),
                     r55.listen_until_close(),
                     r56.listen_until_close(),
+                    r57.listen_until_close(),
                 );
                 cli_tester_handle.join().unwrap()?;
                 Ok(())
diff --git a/tests/push.rs b/tests/push.rs
index 9791d9d..409b36f 100644
--- a/tests/push.rs
+++ b/tests/push.rs
@@ -366,6 +366,8 @@ mod when_branch_is_checked_out {
                                 (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
                                 (" [my-relay] ws://localhost:8053", true, ""),
                                 (" [repo-relay] ws://localhost:8056", true, ""),
+                                (" [default] ws://localhost:8051", true, ""),
+                                (" [default] ws://localhost:8052", true, ""),
                             ],
                             1,
                         )?;
diff --git a/tests/send.rs b/tests/send.rs
index a109918..b202d54 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -309,12 +309,12 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
 
     #[tokio::test]
     #[serial]
-    async fn pr_not_sent_to_fallback_relay() -> Result<()> {
+    async fn only_1_pr_kind_event_sent_to_fallback_relays() -> Result<()> {
         let (r51, r52, _, _, _) = prep_run_create_pr(true).await?;
         for relay in [&r51, &r52] {
             assert_eq!(
                 relay.events.iter().filter(|e| is_cover_letter(e)).count(),
-                0,
+                1,
             );
         }
         Ok(())
@@ -323,8 +323,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
     #[tokio::test]
     #[serial]
     async fn only_2_patch_kind_events_sent_to_each_relay() -> Result<()> {
-        let (_, _, r53, r55, r56) = prep_run_create_pr(true).await?;
-        for relay in [&r53, &r55, &r56] {
+        let (r51, r52, r53, r55, r56) = prep_run_create_pr(true).await?;
+        for relay in [&r51, &r52, &r53, &r55, &r56] {
             assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 2,);
         }
         Ok(())
@@ -757,6 +757,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
                         (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
                         (" [my-relay] ws://localhost:8053", true, ""),
                         (" [repo-relay] ws://localhost:8056", true, ""),
+                        (" [default] ws://localhost:8051", true, ""),
+                        (" [default] ws://localhost:8052", true, ""),
                     ],
                     3,
                 )?;
@@ -930,6 +932,8 @@ mod sends_cover_letter_and_2_patches_to_3_relays {
                                 false,
                                 "error: Payment Required",
                             ),
+                            (" [default] ws://localhost:8051", true, ""),
+                            (" [default] ws://localhost:8052", true, ""),
                         ],
                         3,
                     )?;
@@ -1016,6 +1020,8 @@ mod sends_2_patches_without_cover_letter {
                         (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
                         (" [my-relay] ws://localhost:8053", true, ""),
                         (" [repo-relay] ws://localhost:8056", true, ""),
+                        (" [default] ws://localhost:8051", true, ""),
+                        (" [default] ws://localhost:8052", true, ""),
                     ],
                     2,
                 )?;