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,
                 )?;