feat(login) fetch user relays and metadata

get user relay list and metadata events from relays when keys are
used and last fetch attempt was more than an hour ago

uses user's write relays if known, otherwise uses fallback relays

to achieve this a method for intergration testing event fetching
from relays was added

13 files changed, 1959 insertions, 360 deletions

diff --git a/Cargo.lock b/Cargo.lock
index b8c0f04..e977d30 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2717,6 +2717,7 @@ dependencies = [
  "rexpect 0.5.0 (git+https://github.com/phaer/rexpect.git?branch=skip-ansi-escape-codes)",
  "simple-websockets",
  "strip-ansi-escapes",
+ "tungstenite 0.20.1",
 ]
 
 [[package]]
diff --git a/src/client.rs b/src/client.rs
index e0e0494..5ddf742 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -10,25 +10,32 @@
 // which is currently in nightly. alternatively we can use nightly as it looks
 // certain that the implementation is going to make it to stable but we don't
 // want to inadvertlty use other features of nightly that might be removed.
-use anyhow::Result;
+use anyhow::{Context, Result};
 use async_trait::async_trait;
+use futures::future::join_all;
 #[cfg(test)]
 use mockall::*;
 use nostr::Event;
 
 pub struct Client {
     client: nostr_sdk::Client,
-    pub fallback_relays: Vec<String>,
+    fallback_relays: Vec<String>,
 }
 
-#[async_trait]
 #[cfg_attr(test, automock)]
+#[async_trait]
 pub trait Connect {
     fn default() -> Self;
     fn new(opts: Params) -> Self;
     async fn connect(&self) -> Result<()>;
     async fn disconnect(&self) -> Result<()>;
+    fn get_fallback_relays(&self) -> &Vec<String>;
     async fn send_event_to(&self, url: &str, event: nostr::event::Event) -> Result<nostr::EventId>;
+    async fn get_events(
+        &self,
+        relays: Vec<String>,
+        filters: Vec<nostr::Filter>,
+    ) -> Result<Vec<nostr::Event>>;
 }
 
 #[async_trait]
@@ -37,7 +44,7 @@ impl Connect for Client {
         Client {
             client: nostr_sdk::Client::new(&nostr::Keys::generate()),
             fallback_relays: vec![
-                "ws://localhost:8080".to_string(),
+                "ws://localhost:8051".to_string(),
                 "ws://localhost:8052".to_string(),
             ],
         }
@@ -61,9 +68,52 @@ impl Connect for Client {
         Ok(())
     }
 
+    fn get_fallback_relays(&self) -> &Vec<String> {
+        &self.fallback_relays
+    }
+
     async fn send_event_to(&self, url: &str, event: Event) -> Result<nostr::EventId> {
         Ok(self.client.send_event_to(url, event).await?)
     }
+
+    async fn get_events(
+        &self,
+        relays: Vec<String>,
+        filters: Vec<nostr::Filter>,
+    ) -> Result<Vec<nostr::Event>> {
+        // add relays
+        for relay in &relays {
+            self.client
+                .add_relay(relay.as_str(), None)
+                .await
+                .context("cannot add relay")?;
+        }
+
+        let relays_map = self.client.relays().await;
+
+        let relay_results = join_all(
+            relays
+                .clone()
+                .iter()
+                .map(|r| {
+                    (
+                        relays_map.get(&nostr::Url::parse(r).unwrap()).unwrap(),
+                        filters.clone(),
+                    )
+                })
+                .map(|(relay, filters)| {
+                    relay.get_events_of(
+                        filters,
+                        // 20 is nostr_sdk default
+                        std::time::Duration::from_secs(20),
+                        nostr_sdk::FilterOptions::ExitOnEOSE,
+                    )
+                }),
+        )
+        .await;
+
+        Ok(get_dedup_events(relay_results))
+    }
 }
 
 #[derive(Default)]
@@ -82,3 +132,17 @@ impl Params {
         self
     }
 }
+
+fn get_dedup_events(
+    relay_results: Vec<Result<Vec<nostr::Event>, nostr_sdk::relay::Error>>,
+) -> Vec<Event> {
+    let mut dedup_events: Vec<Event> = vec![];
+    for events in relay_results.into_iter().flatten() {
+        for event in events {
+            if !dedup_events.iter().any(|e| event.id.eq(&e.id)) {
+                dedup_events.push(event);
+            }
+        }
+    }
+    dedup_events
+}
diff --git a/src/config.rs b/src/config.rs
index f410934..2370e34 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -4,7 +4,7 @@ use anyhow::{anyhow, Context, Result};
 use directories::ProjectDirs;
 #[cfg(test)]
 use mockall::*;
-use nostr::secp256k1::XOnlyPublicKey;
+use nostr::{secp256k1::XOnlyPublicKey, ToBech32};
 use serde::{self, Deserialize, Serialize};
 
 #[derive(Default)]
@@ -71,6 +71,66 @@ pub struct MyConfig {
 pub struct UserRef {
     pub public_key: XOnlyPublicKey,
     pub encrypted_key: String,
+    pub metadata: UserMetadata,
+    pub relays: UserRelays,
+    pub last_checked: u64,
+}
+
+impl UserRef {
+    pub fn new(public_key: XOnlyPublicKey, encrypted_key: String) -> Self {
+        Self {
+            public_key,
+            encrypted_key,
+            relays: UserRelays {
+                relays: vec![],
+                created_at: 0,
+            },
+            metadata: UserMetadata {
+                #[allow(clippy::expect_used)]
+                name: public_key
+                    .to_bech32()
+                    .expect("public key should always produce bech32"),
+                // name: format!(
+                //     "{}",
+                //     public_key
+                //         .to_bech32()
+                //         .expect("public key should always produce bech32"),
+                // )
+                // .as_str()[..10].to_string(),
+                created_at: 0,
+            },
+            last_checked: 0,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct UserMetadata {
+    pub name: String,
+    pub created_at: u64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct UserRelays {
+    pub relays: Vec<UserRelayRef>,
+    pub created_at: u64,
+}
+
+impl UserRelays {
+    pub fn write(&self) -> Vec<String> {
+        self.relays
+            .iter()
+            .filter(|r| r.write)
+            .map(|r| r.url.clone())
+            .collect()
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct UserRelayRef {
+    pub url: String,
+    pub read: bool,
+    pub write: bool,
 }
 
 #[cfg(test)]
diff --git a/src/key_handling/users.rs b/src/key_handling/users.rs
index 1d2cc34..91519bc 100644
--- a/src/key_handling/users.rs
+++ b/src/key_handling/users.rs
@@ -1,11 +1,21 @@
+use std::time::SystemTime;
+
 use anyhow::{Context, Result};
+use async_trait::async_trait;
 use nostr::prelude::*;
 use zeroize::Zeroize;
 
 use super::encryption::{EncryptDecrypt, Encryptor};
+#[cfg(not(test))]
+use crate::client::Client;
+#[cfg(test)]
+use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptInputParms, PromptPasswordParms},
-    config::{self, ConfigManagement, ConfigManager},
+    client::Connect,
+    config::{
+        self, ConfigManagement, ConfigManager, UserMetadata, UserRef, UserRelayRef, UserRelays,
+    },
 };
 
 #[derive(Default)]
@@ -15,13 +25,29 @@ pub struct UserManager {
     encryptor: Encryptor,
 }
 
+#[async_trait]
 pub trait UserManagement {
     fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys>;
+    async fn get_user(
+        &self,
+        #[cfg(test)] client: &MockConnect,
+        #[cfg(not(test))] client: &Client,
+        public_key: &XOnlyPublicKey,
+        after: u64,
+    ) -> Result<UserRef>;
+    fn get_user_from_cache(&self, public_key: &XOnlyPublicKey) -> Result<UserRef>;
+    fn add_user_to_config(
+        &self,
+        public_key: XOnlyPublicKey,
+        encrypted_secret_key: Option<String>,
+        overwrite: bool,
+    ) -> Result<()>;
 }
 
 #[cfg(test)]
 use duplicate::duplicate_item;
 #[cfg_attr(test, duplicate_item(UserManager; [UserManager]; [self::tests::MockUserManager]))]
+#[async_trait]
 impl UserManagement for UserManager {
     fn add(&self, nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys> {
         let mut prompt = "login with nsec (or hex private key)";
@@ -66,9 +92,152 @@ impl UserManagement for UserManager {
             .context("failed to encrypt nsec with password.")?;
         pass.zeroize();
 
-        let user_ref = config::UserRef {
-            public_key: keys.public_key(),
-            encrypted_key: encrypted_secret_key,
+        self.add_user_to_config(keys.public_key(), Some(encrypted_secret_key), true)?;
+
+        Ok(keys)
+    }
+
+    fn add_user_to_config(
+        &self,
+        public_key: XOnlyPublicKey,
+        encrypted_secret_key: Option<String>,
+        overwrite: bool,
+    ) -> Result<()> {
+        let user_ref =
+            config::UserRef::new(public_key, encrypted_secret_key.unwrap_or(String::new()));
+
+        let mut cfg = self.config_manager.load().context("failed to load application config to find and remove any old versions of the user's encrypted key")?;
+        // don't overwrite unless specified
+        if !overwrite
+            && cfg
+                .users
+                .clone()
+                .into_iter()
+                .any(|r| r.public_key.eq(&public_key))
+        {
+            return Ok(());
+        }
+        // if overwrite remove any duplicate entries for key before adding it to config
+        cfg.users = cfg
+            .users
+            .clone()
+            .into_iter()
+            .filter(|r| !r.public_key.eq(&public_key))
+            .collect();
+        cfg.users.push(user_ref);
+        self.config_manager
+            .save(&cfg)
+            .context("failed to save application configuration with new user details in")
+    }
+
+    fn get_user_from_cache(&self, public_key: &XOnlyPublicKey) -> Result<UserRef> {
+        let cfg = self
+            .config_manager
+            .load()
+            .context("failed to load application config")?;
+        Ok(cfg
+            .users
+            .iter()
+            .find(|u| u.public_key.eq(public_key))
+            .context(format!("pubkey isn't a current user: {public_key}"))?
+            .clone())
+    }
+    /// get UserRef fetching most recent user relays and metadata infomation
+    /// from relays
+    async fn get_user(
+        &self,
+        #[cfg(test)] client: &MockConnect,
+        #[cfg(not(test))] client: &Client,
+        public_key: &XOnlyPublicKey,
+        use_cache_unless_checked_more_than_x_secs_ago: u64,
+    ) -> Result<UserRef> {
+        let cfg = self
+            .config_manager
+            .load()
+            .context("failed to load application config")?;
+        let user_ref = cfg
+            .users
+            .iter()
+            .find(|u| u.public_key.eq(public_key))
+            .context(format!("pubkey isn't a current user: {public_key}"))?;
+        // return cache if last fetched was within X minutes
+        if !unix_timestamp_after_now_plus_secs(
+            user_ref.last_checked,
+            use_cache_unless_checked_more_than_x_secs_ago,
+        ) {
+            return Ok(user_ref.clone());
+        }
+        let events: Vec<Event> = match client
+            .get_events(
+                if user_ref.relays.write().is_empty() {
+                    client.get_fallback_relays().clone()
+                } else {
+                    user_ref.relays.write()
+                },
+                vec![
+                    nostr::Filter::default()
+                        .author(public_key.to_string())
+                        .since(nostr::Timestamp::from(user_ref.metadata.created_at + 1))
+                        .kind(Kind::Metadata),
+                    nostr::Filter::default()
+                        .author(public_key.to_string())
+                        .since(nostr::Timestamp::from(user_ref.relays.created_at + 1))
+                        .kind(Kind::RelayList),
+                ],
+            )
+            .await
+        {
+            Ok(events) => events,
+            Err(_) => {
+                // TODO error reporting
+                return Ok(user_ref.clone());
+            }
+        };
+
+        let mut user_ref = user_ref.clone();
+
+        user_ref.last_checked = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .context("system time should be after the year 1970")?
+            .as_secs();
+
+        if let Some(new_metadata_event) = events
+            .iter()
+            .filter(|e| e.kind.eq(&nostr::Kind::Metadata) && e.pubkey.eq(public_key))
+            .max_by_key(|e| e.created_at)
+        {
+            if new_metadata_event.created_at.as_u64() > user_ref.metadata.created_at {
+                let metadata = nostr::Metadata::from_json(new_metadata_event.content.clone())
+                    .context("metadata cannot be found in kind 0 event content")?;
+                user_ref.metadata = UserMetadata {
+                    name: metadata
+                        .name
+                        .context("user metadata should always have name")?,
+                    created_at: new_metadata_event.created_at.as_u64(),
+                };
+            }
+        };
+
+        if let Some(new_relays_event) = events
+            .iter()
+            .filter(|e| e.kind.eq(&nostr::Kind::RelayList) && e.pubkey.eq(public_key))
+            .max_by_key(|e| e.created_at)
+        {
+            if new_relays_event.created_at.as_u64() > user_ref.relays.created_at {
+                user_ref.relays = UserRelays {
+                    relays: new_relays_event
+                        .tags
+                        .iter()
+                        .filter(|t| t.kind().eq(&nostr::TagKind::R))
+                        .map(|t| UserRelayRef {
+                            url: t.as_vec()[1].clone(),
+                            read: t.as_vec().len() == 2 || t.as_vec()[2].eq("read"),
+                            write: t.as_vec().len() == 2 || t.as_vec()[2].eq("write"),
+                        })
+                        .collect(),
+                    created_at: new_relays_event.created_at.as_u64(),
+                };
+            }
         };
 
         // remove any duplicate entries for key before adding it to config
@@ -77,19 +246,27 @@ impl UserManagement for UserManager {
             .users
             .clone()
             .into_iter()
-            .filter(|r| !r.public_key.eq(&keys.public_key()))
+            .filter(|r| !r.public_key.eq(public_key))
             .collect();
-        cfg.users.push(user_ref);
+        cfg.users.push(user_ref.clone());
         self.config_manager
             .save(&cfg)
             .context("failed to save application configuration with new user details in")?;
+        Ok(user_ref)
+    }
+}
 
-        Ok(keys)
+fn unix_timestamp_after_now_plus_secs(timestamp: u64, secs: u64) -> bool {
+    if let Ok(now) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
+        now.as_secs() > (timestamp + secs)
+    } else {
+        true
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use nostr;
     use test_utils::*;
 
     use super::*;
@@ -278,11 +455,10 @@ mod tests {
                     m.config_manager = MockConfigManagement::default();
                     m.config_manager.expect_load().returning(|| {
                         Ok(MyConfig {
-                            users: vec![UserRef {
-                                public_key: TEST_KEY_1_KEYS.public_key(),
-                                // different key to TEST_KEY_1_ENCYPTED
-                                encrypted_key: TEST_KEY_2_ENCRYPTED.into(),
-                            }],
+                            users: vec![UserRef::new(
+                                TEST_KEY_1_KEYS.public_key(),
+                                TEST_KEY_2_ENCRYPTED.into(),
+                            )],
                             ..MyConfig::default()
                         })
                     });
@@ -308,10 +484,10 @@ mod tests {
                     m.config_manager = MockConfigManagement::default();
                     m.config_manager.expect_load().returning(|| {
                         Ok(MyConfig {
-                            users: vec![UserRef {
-                                public_key: TEST_KEY_2_KEYS.public_key(),
-                                encrypted_key: TEST_KEY_2_ENCRYPTED.into(),
-                            }],
+                            users: vec![UserRef::new(
+                                TEST_KEY_2_KEYS.public_key(),
+                                TEST_KEY_2_ENCRYPTED.into(),
+                            )],
                             ..MyConfig::default()
                         })
                     });
@@ -329,4 +505,479 @@ mod tests {
             }
         }
     }
+
+    fn now_timestamp() -> u64 {
+        SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
+    fn roughly_now(timestamp: u64) -> bool {
+        let now = now_timestamp();
+        timestamp < now + 100 && timestamp > now - 100
+    }
+
+    mod get_user {
+        use anyhow::anyhow;
+
+        use super::*;
+        use crate::client::MockConnect;
+
+        fn generate_relaylist_event() -> nostr::Event {
+            nostr::event::EventBuilder::new(
+                nostr::Kind::RelayList,
+                "",
+                &[
+                    nostr::Tag::RelayMetadata(
+                        "wss://fredswrite1.relay".into(),
+                        Some(nostr::RelayMetadata::Write),
+                    ),
+                    nostr::Tag::RelayMetadata(
+                        "wss://fredsread1.relay".into(),
+                        Some(nostr::RelayMetadata::Read),
+                    ),
+                    nostr::Tag::RelayMetadata("wss://fredsreadwrite.relay".into(), None),
+                ],
+            )
+            .to_event(&TEST_KEY_1_KEYS)
+            .unwrap()
+        }
+
+        fn generate_relaylist_event_user_2() -> nostr::Event {
+            nostr::event::EventBuilder::new(
+                nostr::Kind::RelayList,
+                "",
+                &[
+                    nostr::Tag::RelayMetadata(
+                        "wss://carolswrite1.relay".into(),
+                        Some(nostr::RelayMetadata::Write),
+                    ),
+                    nostr::Tag::RelayMetadata(
+                        "wss://carolsread1.relay".into(),
+                        Some(nostr::RelayMetadata::Read),
+                    ),
+                    nostr::Tag::RelayMetadata("wss://carolsreadwrite.relay".into(), None),
+                ],
+            )
+            .to_event(&TEST_KEY_2_KEYS)
+            .unwrap()
+        }
+
+        fn fallback_relays() -> Vec<String> {
+            vec!["ws://fallback1".to_string(), "ws://fallback2".to_string()].clone()
+        }
+
+        fn generate_mock_client() -> MockConnect {
+            let mut client = <MockConnect as std::default::Default>::default();
+            client
+                .expect_get_fallback_relays()
+                .return_const(fallback_relays());
+            client
+        }
+
+        fn generate_standard_config() -> MyConfig {
+            MyConfig {
+                users: vec![UserRef {
+                    public_key: TEST_KEY_1_KEYS.public_key(),
+                    encrypted_key: TEST_KEY_1_ENCRYPTED.to_string(),
+                    metadata: UserMetadata {
+                        name: "Fred".to_string(),
+                        created_at: 10,
+                    },
+                    relays: UserRelays {
+                        relays: vec![
+                            UserRelayRef {
+                                url: "ws://existingread".to_string(),
+                                read: true,
+                                write: false,
+                            },
+                            UserRelayRef {
+                                url: "ws://existingreadwrite".to_string(),
+                                read: true,
+                                write: true,
+                            },
+                            UserRelayRef {
+                                url: "ws://existingwrite".to_string(),
+                                read: false,
+                                write: true,
+                            },
+                        ],
+                        created_at: 10,
+                    },
+                    last_checked: now_timestamp() - (60 * 60), // 1h ago
+                }],
+                ..MyConfig::default()
+            }
+            .clone()
+        }
+
+        fn expected_userrelayrefs() -> Vec<UserRelayRef> {
+            vec![
+                UserRelayRef {
+                    url: "wss://fredswrite1.relay".into(),
+                    read: false,
+                    write: true,
+                },
+                UserRelayRef {
+                    url: "wss://fredsread1.relay".into(),
+                    read: true,
+                    write: false,
+                },
+                UserRelayRef {
+                    url: "wss://fredsreadwrite.relay".into(),
+                    read: true,
+                    write: true,
+                },
+            ]
+        }
+
+        mod when_within_caching_time_window {
+            use super::*;
+
+            #[test]
+            fn returns_cached_details_without_checking_relays_or_updaing_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    24 * 60 * 60, // within 24 hours
+                ))?;
+                assert_eq!(res.metadata.name, "Fred");
+                assert_eq!(res.relays.relays[0].url, "ws://existingread");
+                Ok(())
+            }
+        }
+
+        mod returns_userref_with_latest_details_from_events_on_relays {
+            use super::*;
+
+            #[test]
+            fn name() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.metadata.name, "fred");
+                Ok(())
+            }
+
+            #[test]
+            fn name_ignoring_other_users_events() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        generate_test_key_2_metadata_event("carole"),
+                        generate_test_key_1_metadata_event_old("fred"),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.metadata.name, "fred");
+                Ok(())
+            }
+
+            #[test]
+            fn relays() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        generate_test_key_1_metadata_event("fred"),
+                        generate_relaylist_event(),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
+                Ok(())
+            }
+
+            #[test]
+            fn relays_ignoring_other_users_events() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| {
+                    Ok(vec![
+                        make_event_old_or_change_user(
+                            generate_relaylist_event(),
+                            &TEST_KEY_1_KEYS,
+                            10000,
+                        ),
+                        generate_relaylist_event_user_2(),
+                    ])
+                });
+
+                let res = futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                assert_eq!(res.relays.relays, expected_userrelayrefs(),);
+                Ok(())
+            }
+        }
+
+        mod saves_updates_to_config {
+            use super::*;
+
+            #[test]
+            fn saves_name_to_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| cfg.users[0].metadata.name.eq("fred"))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn updates_metadata_created_at() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].metadata.created_at))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn saves_relays_to_config() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| expected_userrelayrefs().eq(&cfg.users[0].relays.relays))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn updates_relays_created_at() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].relays.created_at))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_relaylist_event()]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn when_no_changes_updates_last_updated() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
+                    .returning(|_| Ok(()));
+                client.expect_get_events().returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+
+            #[test]
+            fn when_changes_updates_last_updated() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager
+                    .expect_save()
+                    .once()
+                    .withf(|cfg| roughly_now(cfg.users[0].last_checked))
+                    .returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .returning(|_, _| Ok(vec![generate_test_key_1_metadata_event("fred")]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+        }
+
+        mod fetches_from_correct_relays {
+            use super::*;
+            #[test]
+            fn when_userref_write_relays_present_fetches_only_from_them() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager
+                    .expect_load()
+                    .returning(|| Ok(generate_standard_config()));
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .once()
+                    .withf(move |relays, _filters| {
+                        vec![
+                            "ws://existingreadwrite".to_string(),
+                            "ws://existingwrite".to_string(),
+                        ]
+                        .eq(relays)
+                    })
+                    .returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+            #[test]
+            fn when_userref_write_relays_not_present_fetches_from_fallback_relays() -> Result<()> {
+                let mut m = MockUserManager::default();
+                let mut client = generate_mock_client();
+                m.config_manager.expect_load().returning(|| {
+                    Ok(MyConfig {
+                        users: vec![UserRef {
+                            relays: UserRelays {
+                                relays: vec![],
+                                created_at: 0,
+                            },
+                            ..generate_standard_config().users[0].clone()
+                        }],
+                        ..generate_standard_config()
+                    })
+                });
+                m.config_manager.expect_save().returning(|_| Ok(()));
+                client
+                    .expect_get_events()
+                    .once()
+                    .withf(move |relays, _filters| fallback_relays().eq(relays))
+                    .returning(|_, _| Ok(vec![]));
+
+                futures::executor::block_on(m.get_user(
+                    &client,
+                    &TEST_KEY_1_KEYS.public_key(),
+                    5 * 60, // 5 mins ago
+                ))?;
+                Ok(())
+            }
+        }
+
+        #[test]
+        fn when_failed_to_fetch_events_returns_cached_details() -> Result<()> {
+            let mut m = MockUserManager::default();
+            let mut client = generate_mock_client();
+            m.config_manager
+                .expect_load()
+                .returning(|| Ok(generate_standard_config()));
+            client
+                .expect_get_events()
+                .returning(|_, _| Err(anyhow!("test error")));
+
+            let res = futures::executor::block_on(m.get_user(
+                &client,
+                &TEST_KEY_1_KEYS.public_key(),
+                5 * 60, // 10 mins ago
+            ))?;
+            assert_eq!(res.metadata.name, "Fred");
+            Ok(())
+        }
+    }
 }
diff --git a/src/login.rs b/src/login.rs
index 12fe76e..e73373a 100644
--- a/src/login.rs
+++ b/src/login.rs
@@ -1,10 +1,14 @@
 use anyhow::{bail, Context, Result};
-use nostr::prelude::{FromSkStr, ToBech32};
+use nostr::{prelude::FromSkStr, secp256k1::XOnlyPublicKey};
 use zeroize::Zeroize;
 
+#[cfg(not(test))]
+use crate::client::Client;
+#[cfg(test)]
+use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptPasswordParms},
-    config::{ConfigManagement, ConfigManager},
+    config::{ConfigManagement, ConfigManager, UserRef},
     key_handling::{
         encryption::{EncryptDecrypt, Encryptor},
         users::{UserManagement, UserManager},
@@ -12,77 +16,114 @@ use crate::{
 };
 
 /// handles the encrpytion and storage of key material
-pub fn launch(nsec: &Option<String>, password: &Option<String>) -> Result<nostr::Keys> {
+pub async fn launch(
+    nsec: &Option<String>,
+    password: &Option<String>,
+    #[cfg(test)] client: Option<&MockConnect>,
+    #[cfg(not(test))] client: Option<&Client>,
+) -> Result<nostr::Keys> {
     // if nsec parameter
-    if let Some(nsec_unwrapped) = nsec {
+    let key = if let Some(nsec_unwrapped) = nsec {
         // get key or fail without prompts
         let key = nostr::Keys::from_sk_str(nsec_unwrapped).context("invalid nsec parameter")?;
-        println!(
-            "logged in as {}",
-            &key.public_key()
-                .to_bech32()
-                .context("public key should always produce bech32")?
-        );
 
         // if password, add user to enable password login in future
         if password.is_some() {
             UserManager::default()
                 .add(nsec, password)
                 .context("could not store identity")?;
+        } else {
+            UserManager::default().add_user_to_config(key.public_key(), None, false)?;
         }
-        return Ok(key);
-    }
+        key
+    } else {
+        let cfg = ConfigManager
+            .load()
+            .context("failed to load application config")?;
+        // if encrypted nsec present
+        if cfg.users.last().is_some() && !cfg.users.last().unwrap().encrypted_key.is_empty() {
+            // unfortunately this line is unstable in rust:
+            // if let Some(user) = cfg.users.last()  && !user.encrypted_key.is_empty() {
+            let user = cfg.users.last().unwrap();
+            let mut pass = if let Some(p) = password.clone() {
+                p
+            } else {
+                println!("login as {}", &user.metadata.name);
+                Interactor::default()
+                    .password(PromptPasswordParms::default().with_prompt("password"))
+                    .context("failed to get password input from interactor.password")?
+            };
 
-    // if encrypted nsec stored, attempt password
-    let cfg = ConfigManager
-        .load()
-        .context("failed to load application config")?;
-    let key = if let Some(user) = cfg.users.last() {
-        let mut pass = if let Some(p) = password.clone() {
-            p
-        } else {
-            println!(
-                "login as {}",
-                &user
-                    .public_key
-                    .to_bech32()
-                    .context("public key should always produce bech32")?
-            );
-            Interactor::default()
-                .password(PromptPasswordParms::default().with_prompt("password"))
-                .context("failed to get password input from interactor.password")?
-        };
+            let key_result = Encryptor
+                .decrypt_key(&user.encrypted_key, pass.as_str())
+                .context("failed to decrypt key with provided password");
+            pass.zeroize();
 
-        let key_result = Encryptor
-            .decrypt_key(&user.encrypted_key, pass.as_str())
-            .context("failed to decrypt key with provided password");
-        pass.zeroize();
+            key_result.context(format!("failed to log in as {}", &user.metadata.name))?
+        }
+        // no encrypted nsec present
+        else {
+            // no nsec but password supplied
+            if password.is_some() {
+                bail!("no nsec available to decrypt with specified password");
+            }
+            // otherwise add new user with nsec and password prompts
+            UserManager::default()
+                .add(nsec, password)
+                .context("failed to add user")?
+        }
+    };
 
-        key_result.context(format!(
-            "failed to log in as {}",
-            &user
-                .public_key
-                .to_bech32()
-                .context("public key should always produce bech32")?
-        ))?
+    // get user details
+    let user_ref = if let Some(client) = client {
+        get_user_details(&key.public_key(), client).await?
     } else {
-        // no nsec but password supplied
-        if password.is_some() {
-            bail!("no nsec available to decrypt with specified password");
-        }
-        // otherwise add new user with nsec and password prompts
+        // this will get user details with name as npub
         UserManager::default()
-            .add(nsec, password)
-            .context("failed to add user")?
+            .get_user_from_cache(&key.public_key())?
+            .clone()
     };
-    println!(
-        "logged in as {}",
-        &key.public_key()
-            .to_bech32()
-            .context("public key should always produce bech32")?
-    );
 
-    // fetching metdata
+    // print logged in
+    println!("logged in as {}", user_ref.metadata.name);
 
     Ok(key)
 }
+
+async fn get_user_details(
+    public_key: &XOnlyPublicKey,
+    #[cfg(test)] client: &crate::client::MockConnect,
+    #[cfg(not(test))] client: &Client,
+) -> Result<UserRef> {
+    let term = console::Term::stdout();
+    term.write_line("searching for your details...")?;
+    let user_manager = UserManager::default();
+    let user_ref = user_manager
+        .get_user(
+            client,
+            public_key,
+            // 1 hour
+            60 * 60,
+        )
+        .await?;
+    term.clear_last_lines(1)?;
+    if user_ref.metadata.created_at.eq(&0) {
+        println!("cannot find your account metadata (name, etc) on relays",);
+        // TODO use secondary fallback list of relays.
+        // TODO better reporting of what relays were checked and what the user
+        //      here is a starter:
+        //      cannot find account details on relays:
+        //       - purplepages.xyz
+        //       - fallbackrelay1
+        //       - ...
+        //      would you like to:
+        //        [-] proceed anyway
+        //         - add custom fallback relays
+    } else if user_ref.relays.created_at.eq(&0) {
+        println!(
+            "cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience."
+        );
+        // TODO better guidance on how to do this
+    }
+    Ok(user_ref)
+}
diff --git a/src/main.rs b/src/main.rs
index 5c8518b..68b0ed6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -41,7 +41,9 @@ enum Commands {
 async fn main() -> Result<()> {
     let cli = Cli::parse();
     match &cli.command {
-        Commands::Login(args) => sub_commands::login::launch(&cli, args),
+        Commands::Login(args) => {
+            futures::executor::block_on(sub_commands::login::launch(&cli, args))
+        }
         Commands::Prs(args) => futures::executor::block_on(sub_commands::prs::launch(&cli, args)),
     }
 }
diff --git a/src/sub_commands/login.rs b/src/sub_commands/login.rs
index 5391024..b93e9bc 100644
--- a/src/sub_commands/login.rs
+++ b/src/sub_commands/login.rs
@@ -1,12 +1,32 @@
 use anyhow::Result;
 use clap;
 
-use crate::{login, Cli};
+#[cfg(not(test))]
+use crate::client::Client;
+#[cfg(test)]
+use crate::client::MockConnect;
+use crate::{client::Connect, login, Cli};
 
 #[derive(clap::Args)]
-pub struct SubCommandArgs;
+pub struct SubCommandArgs {
+    /// don't fetch user metadata and relay list from relays
+    #[arg(long, action)]
+    offline: bool,
+}
+
+pub async fn launch(args: &Cli, command_args: &SubCommandArgs) -> Result<()> {
+    if command_args.offline {
+        login::launch(&args.nsec, &args.password, None).await?;
+        Ok(())
+    } else {
+        #[cfg(not(test))]
+        let client = Client::default();
+        #[cfg(test)]
+        let client = <MockConnect as std::default::Default>::default();
 
-pub fn launch(args: &Cli, _command_args: &SubCommandArgs) -> Result<()> {
-    let _ = login::launch(&args.nsec, &args.password)?;
-    Ok(())
+        client.connect().await?;
+        login::launch(&args.nsec, &args.password, Some(&client)).await?;
+        client.disconnect().await?;
+        Ok(())
+    }
 }
diff --git a/src/sub_commands/prs/create.rs b/src/sub_commands/prs/create.rs
index 3047e92..0249488 100644
--- a/src/sub_commands/prs/create.rs
+++ b/src/sub_commands/prs/create.rs
@@ -86,7 +86,8 @@ pub async fn launch(
 
     // create PR event
 
-    let keys = login::launch(&cli_args.nsec, &cli_args.password)?;
+    // TODO add client here
+    let keys = login::launch(&cli_args.nsec, &cli_args.password, None).await?;
 
     let events =
         generate_pr_and_patch_events(&title, &description, &to_branch, &git_repo, &ahead, keys)?;
diff --git a/test_utils/Cargo.toml b/test_utils/Cargo.toml
index 2d3555b..6a3fff8 100644
--- a/test_utils/Cargo.toml
+++ b/test_utils/Cargo.toml
@@ -15,3 +15,4 @@ rand = "0.8"
 rexpect = { git = "https://github.com/phaer/rexpect.git", branch= "skip-ansi-escape-codes" }
 simple-websockets = "0.1.6"
 strip-ansi-escapes = "0.2.0"
+tungstenite = "0.20.1"
diff --git a/test_utils/src/lib.rs b/test_utils/src/lib.rs
index a9d818c..2a06357 100644
--- a/test_utils/src/lib.rs
+++ b/test_utils/src/lib.rs
@@ -23,6 +23,39 @@ pub static TEST_KEY_1_ENCRYPTED_WEAK: &str = "ncryptsec1qy8ke0tjqnn8wt3w6lnc86c2
 pub static TEST_KEY_1_KEYS: Lazy<nostr::Keys> =
     Lazy::new(|| nostr::Keys::from_sk_str(TEST_KEY_1_NSEC).unwrap());
 
+pub fn generate_test_key_1_metadata_event(name: &str) -> nostr::Event {
+    nostr::event::EventBuilder::set_metadata(nostr::Metadata::new().name(name))
+        .to_event(&TEST_KEY_1_KEYS)
+        .unwrap()
+}
+pub fn generate_test_key_1_metadata_event_old(name: &str) -> nostr::Event {
+    make_event_old_or_change_user(
+        generate_test_key_1_metadata_event(name),
+        &TEST_KEY_1_KEYS,
+        10000,
+    )
+}
+
+pub fn generate_test_key_1_relay_list_event() -> nostr::Event {
+    nostr::event::EventBuilder::new(
+        nostr::Kind::RelayList,
+        "",
+        &[
+            nostr::Tag::RelayMetadata(
+                "ws://localhost:8053".into(),
+                Some(nostr::RelayMetadata::Write),
+            ),
+            nostr::Tag::RelayMetadata(
+                "ws://localhost:8054".into(),
+                Some(nostr::RelayMetadata::Read),
+            ),
+            nostr::Tag::RelayMetadata("ws://localhost:8055".into(), None),
+        ],
+    )
+    .to_event(&TEST_KEY_1_KEYS)
+    .unwrap()
+}
+
 pub static TEST_KEY_2_NSEC: &str =
     "nsec1ypglg6nj6ep0g2qmyfqcv2al502gje3jvpwye6mthmkvj93tqkesknv6qm";
 pub static TEST_KEY_2_NPUB: &str =
@@ -33,12 +66,41 @@ pub static TEST_KEY_2_ENCRYPTED: &str = "...2";
 pub static TEST_KEY_2_KEYS: Lazy<nostr::Keys> =
     Lazy::new(|| nostr::Keys::from_sk_str(TEST_KEY_2_NSEC).unwrap());
 
+pub fn generate_test_key_2_metadata_event(name: &str) -> nostr::Event {
+    nostr::event::EventBuilder::set_metadata(nostr::Metadata::new().name(name))
+        .to_event(&TEST_KEY_2_KEYS)
+        .unwrap()
+}
+
 pub static TEST_INVALID_NSEC: &str = "nsec1ppsg5sm2aex";
 pub static TEST_PASSWORD: &str = "769dfd£pwega8SHGv3!#Bsfd5t";
 pub static TEST_INVALID_PASSWORD: &str = "INVALID769dfd£pwega8SHGv3!";
 pub static TEST_WEAK_PASSWORD: &str = "fhaiuhfwe";
 pub static TEST_RANDOM_TOKEN: &str = "lkjh2398HLKJ43hrweiJ6FaPfdssgtrg";
 
+pub fn make_event_old_or_change_user(
+    event: nostr::Event,
+    keys: &nostr::Keys,
+    how_old_in_secs: u64,
+) -> nostr::Event {
+    let mut unsigned = nostr::event::EventBuilder::new(event.kind, event.content, &event.tags)
+        .to_unsigned_event(keys.public_key());
+
+    unsigned.created_at = nostr::types::Timestamp::try_from(
+        nostr::types::Timestamp::now().as_u64() - how_old_in_secs,
+    )
+    .unwrap();
+    unsigned.id = nostr::EventId::new(
+        &keys.public_key(),
+        unsigned.created_at,
+        &unsigned.kind,
+        &unsigned.tags,
+        &unsigned.content,
+    );
+
+    unsigned.sign(keys).unwrap()
+}
+
 /// wrapper for a cli testing tool - currently wraps rexpect and dialoguer
 ///
 /// 1. allow more accurate articulation of expected behaviour
diff --git a/test_utils/src/relay.rs b/test_utils/src/relay.rs
index 6de3618..ce618a3 100644
--- a/test_utils/src/relay.rs
+++ b/test_utils/src/relay.rs
@@ -5,26 +5,36 @@ use nostr::{ClientMessage, RelayMessage};
 
 use crate::CliTester;
 
-type ListenerFunc<'a> = &'a dyn Fn(&mut Relay, u64, nostr::Event) -> Result<()>;
+type ListenerEventFunc<'a> = &'a dyn Fn(&mut Relay, u64, nostr::Event) -> Result<()>;
+pub type ListenerReqFunc<'a> =
+    &'a dyn Fn(&mut Relay, u64, nostr::SubscriptionId, Vec<nostr::Filter>) -> Result<()>;
 
 pub struct Relay<'a> {
     port: u16,
     event_hub: simple_websockets::EventHub,
     clients: HashMap<u64, simple_websockets::Responder>,
     pub events: Vec<nostr::Event>,
-    event_listener: Option<ListenerFunc<'a>>,
+    pub reqs: Vec<Vec<nostr::Filter>>,
+    event_listener: Option<ListenerEventFunc<'a>>,
+    req_listener: Option<ListenerReqFunc<'a>>,
 }
 
 impl<'a> Relay<'a> {
-    pub fn new(port: u16, event_listener: Option<ListenerFunc<'a>>) -> Self {
+    pub fn new(
+        port: u16,
+        event_listener: Option<ListenerEventFunc<'a>>,
+        req_listener: Option<ListenerReqFunc<'a>>,
+    ) -> Self {
         let event_hub = simple_websockets::launch(port)
             .unwrap_or_else(|_| panic!("failed to listen on port {port}"));
         Self {
             port,
             events: vec![],
+            reqs: vec![],
             event_hub,
             clients: HashMap::new(),
             event_listener,
+            req_listener,
         }
     }
     pub fn respond_ok(
@@ -44,11 +54,54 @@ impl<'a> Relay<'a> {
         // bail!(format!("{}", &ok_json));
         Ok(responder.send(simple_websockets::Message::Text(ok_json)))
     }
+
+    pub fn respond_eose(
+        &self,
+        client_id: u64,
+        subscription_id: nostr::SubscriptionId,
+    ) -> Result<bool> {
+        let responder = self.clients.get(&client_id).unwrap();
+
+        Ok(responder.send(simple_websockets::Message::Text(
+            RelayMessage::EndOfStoredEvents(subscription_id).as_json(),
+        )))
+    }
+
+    /// send events and eose
+    pub fn respond_events(
+        &self,
+        client_id: u64,
+        subscription_id: &nostr::SubscriptionId,
+        events: &Vec<nostr::Event>,
+    ) -> Result<bool> {
+        let responder = self.clients.get(&client_id).unwrap();
+
+        for event in events {
+            let res = responder.send(simple_websockets::Message::Text(
+                RelayMessage::Event {
+                    subscription_id: subscription_id.clone(),
+                    event: Box::new(event.clone()),
+                }
+                .as_json(),
+            ));
+            if !res {
+                return Ok(false);
+            }
+        }
+        self.respond_eose(client_id, subscription_id.clone())
+    }
+
+    pub fn shutdown(&mut self) -> Result<()> {
+        let (mut socket, _) = tungstenite::connect(format!("ws://localhost:{}", self.port))?;
+        socket.write(tungstenite::Message::text("shut me down"))?;
+        socket.close(None)?;
+        Ok(())
+    }
     /// listen, collect events and responds with event_listener to events or
     /// Ok(eventid) if event_listner is None
     pub async fn listen_until_close(&mut self) -> Result<()> {
         loop {
-            println!("polling");
+            println!("{} polling", self.port);
             match self.event_hub.poll_async().await {
                 simple_websockets::Event::Connect(client_id, responder) => {
                     // add their Responder to our `clients` map:
@@ -65,8 +118,13 @@ impl<'a> Relay<'a> {
                         "Received a message from client #{}: {:?}",
                         client_id, message
                     );
-
-                    if let Ok(event) = get_nevent(message) {
+                    if let simple_websockets::Message::Text(s) = message.clone() {
+                        if s.eq("shut me down") {
+                            println!("{} recieved shut me down", self.port);
+                            break;
+                        }
+                    }
+                    if let Ok(event) = get_nevent(&message) {
                         self.events.push(event.clone());
                         if let Some(listner) = self.event_listener {
                             listner(self, client_id, event)?;
@@ -74,16 +132,40 @@ impl<'a> Relay<'a> {
                             self.respond_ok(client_id, event, None)?;
                         }
                     }
+
+                    if let Ok((subscription_id, filters)) = get_nreq(&message) {
+                        self.reqs.push(filters.clone());
+                        if let Some(listner) = self.req_listener {
+                            listner(self, client_id, subscription_id, filters)?;
+                        } else {
+                            self.respond_eose(client_id, subscription_id)?;
+                        }
+                        // respond with events
+                        // respond with EOSE
+                    }
+                    if is_nclose(&message) {
+                        println!("{} recieved nostr close", self.port);
+                        break;
+                    }
                 }
             }
         }
-        println!("stop polling");
-        println!("we may not be polling but the tcplistner is still listening");
+        println!(
+            "{} stop polling. we may not be polling but the tcplistner is still listening",
+            self.port
+        );
         Ok(())
     }
 }
 
-fn get_nevent(message: simple_websockets::Message) -> Result<nostr::Event> {
+pub fn shutdown_relay(port: u64) -> Result<()> {
+    let (mut socket, _) = tungstenite::connect(format!("ws://localhost:{}", port))?;
+    socket.write(tungstenite::Message::text("shut me down"))?;
+    socket.close(None)?;
+    Ok(())
+}
+
+fn get_nevent(message: &simple_websockets::Message) -> Result<nostr::Event> {
     if let simple_websockets::Message::Text(s) = message.clone() {
         let cm_result = ClientMessage::from_json(s);
         if let Ok(ClientMessage::Event(event)) = cm_result {
@@ -94,6 +176,32 @@ fn get_nevent(message: simple_websockets::Message) -> Result<nostr::Event> {
     bail!("not nostr event")
 }
 
+fn get_nreq(
+    message: &simple_websockets::Message,
+) -> Result<(nostr::SubscriptionId, Vec<nostr::Filter>)> {
+    if let simple_websockets::Message::Text(s) = message.clone() {
+        let cm_result = ClientMessage::from_json(s);
+        if let Ok(ClientMessage::Req {
+            subscription_id,
+            filters,
+        }) = cm_result
+        {
+            return Ok((subscription_id, filters));
+        }
+    }
+    bail!("not nostr event")
+}
+
+fn is_nclose(message: &simple_websockets::Message) -> bool {
+    if let simple_websockets::Message::Text(s) = message.clone() {
+        let cm_result = ClientMessage::from_json(s);
+        if let Ok(ClientMessage::Close(_)) = cm_result {
+            return true;
+        }
+    }
+    false
+}
+
 pub enum Message {
     Event,
     // Request,
diff --git a/tests/login.rs b/tests/login.rs
index a75608d..d565620 100644
--- a/tests/login.rs
+++ b/tests/login.rs
@@ -8,7 +8,7 @@ static EXPECTED_SET_PASSWORD_CONFIRM_PROMPT: &str = "confirm password";
 static EXPECTED_PASSWORD_PROMPT: &str = "password";
 
 fn standard_login() -> Result<CliTester> {
-    let mut p = CliTester::new(["login"]);
+    let mut p = CliTester::new(["login", "--offline"]);
 
     p.expect_input_eventually(EXPECTED_NSEC_PROMPT)?
         .succeeds_with(TEST_KEY_1_NSEC)?;
@@ -20,74 +20,602 @@ fn standard_login() -> Result<CliTester> {
     p.expect_end_eventually()?;
     Ok(p)
 }
+mod with_relays {
+    use anyhow::Ok;
+    use futures::join;
+    use test_utils::relay::{shutdown_relay, ListenerReqFunc, Relay};
 
-mod when_first_time_login {
     use super::*;
 
-    #[test]
-    #[serial]
-    fn prompts_for_nsec_and_password() -> Result<()> {
-        before()?;
-        standard_login()?;
-        after()
-    }
-
-    #[test]
-    #[serial]
-    fn succeeds_with_text_logged_in_as_npub() -> Result<()> {
-        with_fresh_config(|| {
-            let mut p = CliTester::new(["login"]);
+    mod when_first_time_login {
+        use super::*;
 
-            p.expect_input(EXPECTED_NSEC_PROMPT)?
-                .succeeds_with(TEST_KEY_1_NSEC)?;
+        // falls_back_to_fallback_relays - this is implict in the tests
+
+        mod dislays_logged_in_with_correct_name {
+
+            use super::*;
+
+            async fn run_test_displays_correct_name(
+                relay_listener1: Option<ListenerReqFunc<'_>>,
+                relay_listener2: Option<ListenerReqFunc<'_>>,
+            ) -> Result<()> {
+                let (mut r51, mut r52) = (
+                    Relay::new(8051, None, relay_listener1),
+                    Relay::new(8052, None, relay_listener2),
+                );
+
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    with_fresh_config(|| {
+                        let mut p = CliTester::new(["login"]);
+
+                        p.expect_input(EXPECTED_NSEC_PROMPT)?
+                            .succeeds_with(TEST_KEY_1_NSEC)?;
+
+                        p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                            .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                            .succeeds_with(TEST_PASSWORD)?;
+
+                        p.expect("searching for your details...\r\n")?;
+                        p.expect("\r")?;
+
+                        p.expect_end_with("logged in as fred\r\n")?;
+                        for p in [51, 52] {
+                            shutdown_relay(8000 + p)?;
+                        }
+                        Ok(())
+                    })
+                });
+
+                // launch relay
+                let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
+            }
+
+            #[test]
+            #[serial]
+            fn when_latest_metadata_and_relay_list_on_all_relays() -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ))
+            }
+
+            #[test]
+            #[serial]
+            fn when_latest_metadata_and_relay_list_on_some_relays_but_others_have_none()
+            -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                    None,
+                ))
+            }
+
+            #[test]
+            #[serial]
+            fn when_latest_metadata_only_on_relay_and_relay_list_on_another() -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_test_key_1_metadata_event("fred")],
+                        )?;
+                        Ok(())
+                    }),
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_test_key_1_relay_list_event()],
+                        )?;
+                        Ok(())
+                    }),
+                ))
+            }
+
+            #[test]
+            #[serial]
+            fn when_some_relays_return_old_metadata_event() -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_test_key_1_metadata_event_old("fred old")],
+                        )?;
+                        Ok(())
+                    }),
+                ))
+            }
+
+            #[test]
+            #[serial]
+            fn when_some_relays_return_other_users_metadata() -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_test_key_2_metadata_event("carole")],
+                        )?;
+                        Ok(())
+                    }),
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event_old("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ))
+            }
+
+            #[test]
+            #[serial]
+            fn when_some_relays_return_other_event_kinds() -> Result<()> {
+                futures::executor::block_on(run_test_displays_correct_name(
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        let mut event = generate_test_key_1_metadata_event("Fred");
+                        event.kind = nostr::Kind::TextNote;
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![make_event_old_or_change_user(event, &TEST_KEY_1_KEYS, 0)],
+                        )?;
+                        Ok(())
+                    }),
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event_old("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ))
+            }
+
+            mod when_specifying_command_line_nsec_only {
+                use super::*;
+
+                #[test]
+                #[serial]
+                fn displays_correct_name() -> Result<()> {
+                    futures::executor::block_on(
+                        run_test_when_specifying_command_line_nsec_only_displays_correct_name(
+                            Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                                relay.respond_events(
+                                    client_id,
+                                    &subscription_id,
+                                    &vec![
+                                        generate_test_key_1_metadata_event("fred"),
+                                        generate_test_key_1_relay_list_event(),
+                                    ],
+                                )?;
+                                Ok(())
+                            }),
+                            None,
+                        ),
+                    )
+                }
+                async fn run_test_when_specifying_command_line_nsec_only_displays_correct_name(
+                    relay_listener1: Option<ListenerReqFunc<'_>>,
+                    relay_listener2: Option<ListenerReqFunc<'_>>,
+                ) -> Result<()> {
+                    let (mut r51, mut r52) = (
+                        Relay::new(8051, None, relay_listener1),
+                        Relay::new(8052, None, relay_listener2),
+                    );
+
+                    let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                        with_fresh_config(|| {
+                            let mut p = CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC]);
+
+                            p.expect("searching for your details...\r\n")?;
+                            p.expect("\r")?;
+
+                            p.expect_end_with("logged in as fred\r\n")?;
+                            for p in [51, 52] {
+                                shutdown_relay(8000 + p)?;
+                            }
+                            Ok(())
+                        })
+                    });
+
+                    // launch relay
+                    let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                    cli_tester_handle.join().unwrap()?;
+                    Ok(())
+                }
+            }
+            mod when_specifying_command_line_password_only {
+                use super::*;
+
+                #[test]
+                #[serial]
+                fn displays_correct_name() -> Result<()> {
+                    futures::executor::block_on(
+                        run_test_when_specifying_command_line_password_only_displays_correct_name(
+                            Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                                relay.respond_events(
+                                    client_id,
+                                    &subscription_id,
+                                    &vec![
+                                        generate_test_key_1_metadata_event("fred"),
+                                        generate_test_key_1_relay_list_event(),
+                                    ],
+                                )?;
+                                Ok(())
+                            }),
+                            None,
+                        ),
+                    )
+                }
+                async fn run_test_when_specifying_command_line_password_only_displays_correct_name(
+                    relay_listener1: Option<ListenerReqFunc<'_>>,
+                    relay_listener2: Option<ListenerReqFunc<'_>>,
+                ) -> Result<()> {
+                    let (mut r51, mut r52) = (
+                        Relay::new(8051, None, relay_listener1),
+                        Relay::new(8052, None, relay_listener2),
+                    );
+
+                    let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                        with_fresh_config(|| {
+                            CliTester::new([
+                                "login",
+                                "--offline",
+                                "--nsec",
+                                TEST_KEY_1_NSEC,
+                                "--password",
+                                TEST_PASSWORD,
+                            ])
+                            .expect_end_eventually()?;
+
+                            let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
+
+                            p.expect("searching for your details...\r\n")?;
+                            p.expect("\r")?;
+
+                            p.expect_end_with("logged in as fred\r\n")?;
+                            for p in [51, 52] {
+                                shutdown_relay(8000 + p)?;
+                            }
+                            Ok(())
+                        })
+                    });
+
+                    // launch relay
+                    let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                    cli_tester_handle.join().unwrap()?;
+                    Ok(())
+                }
+            }
+
+            mod when_specifying_command_line_nsec_and_password {
+                use super::*;
+
+                #[test]
+                #[serial]
+                fn displays_correct_name() -> Result<()> {
+                    futures::executor::block_on(
+                        run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
+                            Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                                relay.respond_events(
+                                    client_id,
+                                    &subscription_id,
+                                    &vec![
+                                        generate_test_key_1_metadata_event("fred"),
+                                        generate_test_key_1_relay_list_event(),
+                                    ],
+                                )?;
+                                Ok(())
+                            }),
+                            None,
+                        ),
+                    )
+                }
+                async fn run_test_when_specifying_command_line_nsec_and_password_displays_correct_name(
+                    relay_listener1: Option<ListenerReqFunc<'_>>,
+                    relay_listener2: Option<ListenerReqFunc<'_>>,
+                ) -> Result<()> {
+                    let (mut r51, mut r52) = (
+                        Relay::new(8051, None, relay_listener1),
+                        Relay::new(8052, None, relay_listener2),
+                    );
+
+                    let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                        with_fresh_config(|| {
+                            let mut p = CliTester::new([
+                                "login",
+                                "--nsec",
+                                TEST_KEY_1_NSEC,
+                                "--password",
+                                TEST_PASSWORD,
+                            ]);
+
+                            p.expect("searching for your details...\r\n")?;
+                            p.expect("\r")?;
+
+                            p.expect_end_with("logged in as fred\r\n")?;
+                            for p in [51, 52] {
+                                shutdown_relay(8000 + p)?;
+                            }
+                            Ok(())
+                        })
+                    });
+
+                    // launch relay
+                    let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                    cli_tester_handle.join().unwrap()?;
+                    Ok(())
+                }
+            }
+        }
 
-            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                .succeeds_with(TEST_PASSWORD)?;
+        mod when_no_metadata_found {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn warm_user_and_displays_npub() -> Result<()> {
+                futures::executor::block_on(
+                    run_test_when_no_metadata_found_warns_user_and_uses_npub(None, None),
+                )
+            }
+
+            async fn run_test_when_no_metadata_found_warns_user_and_uses_npub(
+                relay_listener1: Option<ListenerReqFunc<'_>>,
+                relay_listener2: Option<ListenerReqFunc<'_>>,
+            ) -> Result<()> {
+                let (mut r51, mut r52) = (
+                    Relay::new(8051, None, relay_listener1),
+                    Relay::new(8052, None, relay_listener2),
+                );
+
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    with_fresh_config(|| {
+                        let mut p = CliTester::new(["login"]);
+
+                        p.expect_input(EXPECTED_NSEC_PROMPT)?
+                            .succeeds_with(TEST_KEY_1_NSEC)?;
+
+                        p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                            .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                            .succeeds_with(TEST_PASSWORD)?;
+
+                        p.expect("searching for your details...\r\n")?;
+                        p.expect("\r")?;
+                        p.expect("cannot find your account metadata (name, etc) on relays\r\n")?;
+
+                        p.expect_end_with(format!("logged in as {TEST_KEY_1_NPUB}\r\n").as_str())?;
+                        for p in [51, 52] {
+                            shutdown_relay(8000 + p)?;
+                        }
+                        Ok(())
+                    })
+                });
+
+                // launch relay
+                let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
+            }
+        }
 
-            p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
+        mod when_metadata_but_no_relay_list_found {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn warm_user_and_displays_name() -> Result<()> {
+                futures::executor::block_on(
+                    run_test_when_no_relay_list_found_warns_user_and_uses_npub(
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![generate_test_key_1_metadata_event("fred")],
+                            )?;
+                            Ok(())
+                        }),
+                        None,
+                    ),
+                )
+            }
+
+            async fn run_test_when_no_relay_list_found_warns_user_and_uses_npub(
+                relay_listener1: Option<ListenerReqFunc<'_>>,
+                relay_listener2: Option<ListenerReqFunc<'_>>,
+            ) -> Result<()> {
+                let (mut r51, mut r52) = (
+                    Relay::new(8051, None, relay_listener1),
+                    Relay::new(8052, None, relay_listener2),
+                );
+
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    with_fresh_config(|| {
+                        let mut p = CliTester::new(["login"]);
+
+                        p.expect_input(EXPECTED_NSEC_PROMPT)?
+                            .succeeds_with(TEST_KEY_1_NSEC)?;
+
+                        p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                            .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                            .succeeds_with(TEST_PASSWORD)?;
+
+                        p.expect("searching for your details...\r\n")?;
+                        p.expect("\r")?;
+                        p.expect("cannot find your relay list. consider using another nostr client to create one to enhance your nostr experience.\r\n")?;
+
+                        p.expect_end_with("logged in as fred\r\n")?;
+                        for p in [51, 52] {
+                            shutdown_relay(8000 + p)?;
+                        }
+                        Ok(())
+                    })
+                });
+
+                // launch relay
+                let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
+            }
+        }
     }
 
-    #[test]
-    #[serial]
-    fn succeeds_with_hex_secret_key_in_place_of_nsec() -> Result<()> {
-        with_fresh_config(|| {
-            let mut p = CliTester::new(["login"]);
-
-            p.expect_input(EXPECTED_NSEC_PROMPT)?
-                .succeeds_with(TEST_KEY_1_SK_HEX)?;
-
-            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                .succeeds_with(TEST_PASSWORD)?;
+    mod when_second_time_login_and_details_already_fetched {
+        use super::*;
 
-            p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
+        // TODO: the following two tests would require a fake config file or
+        // fake time
+        //  - uses_relays_from_user_relay_list
+        //  - dislays_correct_name - when_local_metadata_is_the_most_recent
+
+        mod uses_cache {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn dislays_logged_in_with_correct_name() -> Result<()> {
+                futures::executor::block_on(run_test_dislays_logged_in_with_correct_name(Some(
+                    &|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    },
+                )))
+            }
+            async fn run_test_dislays_logged_in_with_correct_name(
+                relay_listener: Option<ListenerReqFunc<'_>>,
+            ) -> Result<()> {
+                let (mut r51, mut r52) = (
+                    Relay::new(8051, None, relay_listener),
+                    Relay::new(8052, None, None),
+                );
+
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    with_fresh_config(|| {
+                        let mut p = CliTester::new([
+                            "login",
+                            "--nsec",
+                            TEST_KEY_1_NSEC,
+                            "--password",
+                            TEST_PASSWORD,
+                        ]);
+
+                        p.expect_end_eventually_with("logged in as fred\r\n")?;
+
+                        for p in [51, 52] {
+                            shutdown_relay(8000 + p)?;
+                        }
+
+                        let mut p = CliTester::new(["login", "--password", TEST_PASSWORD]);
+
+                        p.expect("searching for your details...\r\n")?;
+                        p.expect("\r")?;
+
+                        p.expect_end_eventually_with("logged in as fred\r\n")?;
+
+                        Ok(())
+                    })
+                });
+
+                // launch relay
+                let _ = join!(r51.listen_until_close(), r52.listen_until_close(),);
+
+                cli_tester_handle.join().unwrap()?;
+
+                Ok(())
+            }
+        }
     }
+}
 
-    mod when_invalid_nsec {
+/// using the offline flag simplifies the test. relay interaction is tested
+/// seperately
+mod with_offline_flag {
+    use super::*;
+    mod when_first_time_login {
         use super::*;
 
         #[test]
         #[serial]
-        fn prompts_for_nsec_until_valid() -> Result<()> {
-            with_fresh_config(|| {
-                let invalid_nsec_response =
-                    "invalid nsec. try again with nsec (or hex private key)";
+        fn prompts_for_nsec_and_password() -> Result<()> {
+            before()?;
+            standard_login()?;
+            after()
+        }
 
-                let mut p = CliTester::new(["login"]);
+        #[test]
+        #[serial]
+        fn succeeds_with_text_logged_in_as_npub() -> Result<()> {
+            with_fresh_config(|| {
+                let mut p = CliTester::new(["login", "--offline"]);
 
                 p.expect_input(EXPECTED_NSEC_PROMPT)?
-                    // this behaviour is intentional. rejecting the response with dialoguer hides
-                    // the original input from the user so they cannot see the
-                    // mistake they made.
-                    .succeeds_with(TEST_INVALID_NSEC)?;
-
-                p.expect_input(invalid_nsec_response)?
-                    .succeeds_with(TEST_INVALID_NSEC)?;
-
-                p.expect_input(invalid_nsec_response)?
                     .succeeds_with(TEST_KEY_1_NSEC)?;
 
                 p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
@@ -97,178 +625,174 @@ mod when_first_time_login {
                 p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
             })
         }
-    }
-}
 
-mod when_second_time_login {
-    use super::*;
+        #[test]
+        #[serial]
+        fn succeeds_with_hex_secret_key_in_place_of_nsec() -> Result<()> {
+            with_fresh_config(|| {
+                let mut p = CliTester::new(["login", "--offline"]);
 
-    #[test]
-    #[serial]
-    fn prints_login_as_npub() -> Result<()> {
-        with_fresh_config(|| {
-            standard_login()?.exit()?;
+                p.expect_input(EXPECTED_NSEC_PROMPT)?
+                    .succeeds_with(TEST_KEY_1_SK_HEX)?;
 
-            CliTester::new(["login"])
-                .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                .exit()
-        })
-    }
+                p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                    .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                    .succeeds_with(TEST_PASSWORD)?;
 
-    #[test]
-    #[serial]
-    fn prompts_for_password_and_succeeds_with_logged_in_as_npub() -> Result<()> {
-        with_fresh_config(|| {
-            standard_login()?.exit()?;
+                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+            })
+        }
 
-            let mut p = CliTester::new(["login"]);
+        mod when_invalid_nsec {
+            use super::*;
 
-            p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                .succeeds_with(TEST_PASSWORD)?;
+            #[test]
+            #[serial]
+            fn prompts_for_nsec_until_valid() -> Result<()> {
+                with_fresh_config(|| {
+                    let invalid_nsec_response =
+                        "invalid nsec. try again with nsec (or hex private key)";
 
-            p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
-    }
+                    let mut p = CliTester::new(["login", "--offline"]);
 
-    #[test]
-    #[serial]
-    fn when_invalid_password_exit_with_error() -> Result<()> {
-        with_fresh_config(|| {
-            standard_login()?.exit()?;
+                    p.expect_input(EXPECTED_NSEC_PROMPT)?
+                        // this behaviour is intentional. rejecting the response with dialoguer
+                        // hides the original input from the user so they
+                        // cannot see the mistake they made.
+                        .succeeds_with(TEST_INVALID_NSEC)?;
 
-            let mut p = CliTester::new(["login"]);
+                    p.expect_input(invalid_nsec_response)?
+                        .succeeds_with(TEST_INVALID_NSEC)?;
 
-            p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                .succeeds_with(TEST_INVALID_PASSWORD)?;
-            p.expect_end_with(format!("Error: failed to log in as {}\r\n\r\nCaused by:\r\n    0: failed to decrypt key with provided password\r\n    1: failed to decrypt\r\n", TEST_KEY_1_NPUB).as_str())
-        })
-    }
-}
+                    p.expect_input(invalid_nsec_response)?
+                        .succeeds_with(TEST_KEY_1_NSEC)?;
 
-mod when_called_with_nsec_parameter_only {
-    use super::*;
+                    p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                        .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                        .succeeds_with(TEST_PASSWORD)?;
 
-    #[test]
-    #[serial]
-    fn valid_nsec_param_succeeds_without_prompts() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
+                    p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+                })
+            }
+        }
     }
 
-    #[test]
-    #[serial]
-    fn forgets_identity() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new(["login", "--nsec", TEST_KEY_1_NSEC])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
+    mod when_second_time_login {
+        use super::*;
 
-            let mut p = CliTester::new(["login"]);
+        #[test]
+        #[serial]
+        fn prints_login_as_npub() -> Result<()> {
+            with_fresh_config(|| {
+                standard_login()?.exit()?;
 
-            p.expect_input(EXPECTED_NSEC_PROMPT)?
-                .succeeds_with(TEST_KEY_1_NSEC)?;
+                CliTester::new(["login", "--offline"])
+                    .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
+                    .exit()
+            })
+        }
 
-            p.exit()
-        })
-    }
+        #[test]
+        #[serial]
+        fn prompts_for_password_and_succeeds_with_logged_in_as_npub() -> Result<()> {
+            with_fresh_config(|| {
+                standard_login()?.exit()?;
 
-    mod when_logging_in_as_different_nsec {
-        use super::*;
+                let mut p = CliTester::new(["login", "--offline"]);
+
+                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
+                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
+                    .succeeds_with(TEST_PASSWORD)?;
+
+                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+            })
+        }
 
         #[test]
         #[serial]
-        fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
+        fn when_invalid_password_exit_with_error() -> Result<()> {
             with_fresh_config(|| {
                 standard_login()?.exit()?;
 
-                CliTester::new(["login", "--nsec", TEST_KEY_2_NSEC])
-                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
+                let mut p = CliTester::new(["login", "--offline"]);
+
+                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
+                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
+                    .succeeds_with(TEST_INVALID_PASSWORD)?;
+                p.expect_end_with(format!("Error: failed to log in as {}\r\n\r\nCaused by:\r\n    0: failed to decrypt key with provided password\r\n    1: failed to decrypt\r\n", TEST_KEY_1_NPUB).as_str())
             })
         }
     }
-    #[test]
-    #[serial]
-    fn invalid_nsec_param_fails_without_prompts() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new(["login", "--nsec", TEST_INVALID_NSEC]).expect_end_with(
-                "Error: invalid nsec parameter\r\n\r\nCaused by:\r\n    Invalid secret key\r\n",
-            )
-        })
-    }
-}
 
-mod when_called_with_nsec_and_password_parameter {
-    use super::*;
+    mod when_called_with_nsec_parameter_only {
+        use super::*;
 
-    #[test]
-    #[serial]
-    fn valid_nsec_param_succeeds_without_prompts() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new([
-                "login",
-                "--nsec",
-                TEST_KEY_1_NSEC,
-                "--password",
-                TEST_PASSWORD,
-            ])
-            .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
-    }
+        #[test]
+        #[serial]
+        fn valid_nsec_param_succeeds_without_prompts() -> Result<()> {
+            with_fresh_config(|| {
+                CliTester::new(["login", "--offline", "--nsec", TEST_KEY_1_NSEC])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+            })
+        }
 
-    #[test]
-    #[serial]
-    fn remembers_identity() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new([
-                "login",
-                "--nsec",
-                TEST_KEY_1_NSEC,
-                "--password",
-                TEST_PASSWORD,
-            ])
-            .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
-
-            CliTester::new(["login"])
-                .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                .exit()
-        })
-    }
+        #[test]
+        #[serial]
+        fn forgets_identity() -> Result<()> {
+            with_fresh_config(|| {
+                CliTester::new(["login", "--offline", "--nsec", TEST_KEY_1_NSEC])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
+
+                let mut p = CliTester::new(["login", "--offline"]);
 
-    #[test]
-    #[serial]
-    fn parameters_can_be_called_globally() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new([
-                "--nsec",
-                TEST_KEY_1_NSEC,
-                "--password",
-                TEST_PASSWORD,
-                "login",
-            ])
-            .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
+                p.expect_input(EXPECTED_NSEC_PROMPT)?
+                    .succeeds_with(TEST_KEY_1_NSEC)?;
+
+                p.exit()
+            })
+        }
+
+        mod when_logging_in_as_different_nsec {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
+                with_fresh_config(|| {
+                    standard_login()?.exit()?;
+
+                    CliTester::new(["login", "--offline", "--nsec", TEST_KEY_2_NSEC])
+                        .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
+                })
+            }
+        }
+        #[test]
+        #[serial]
+        fn invalid_nsec_param_fails_without_prompts() -> Result<()> {
+            with_fresh_config(|| {
+                CliTester::new(["login", "--offline", "--nsec", TEST_INVALID_NSEC]).expect_end_with(
+                    "Error: invalid nsec parameter\r\n\r\nCaused by:\r\n    Invalid secret key\r\n",
+                )
+            })
+        }
     }
 
-    mod when_logging_in_as_different_nsec {
+    mod when_called_with_nsec_and_password_parameter {
         use super::*;
 
         #[test]
         #[serial]
-        fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
+        fn valid_nsec_param_succeeds_without_prompts() -> Result<()> {
             with_fresh_config(|| {
-                standard_login()?.exit()?;
-
                 CliTester::new([
                     "login",
+                    "--offline",
                     "--nsec",
-                    TEST_KEY_2_NSEC,
+                    TEST_KEY_1_NSEC,
                     "--password",
                     TEST_PASSWORD,
                 ])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
+                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
             })
         }
 
@@ -276,120 +800,182 @@ mod when_called_with_nsec_and_password_parameter {
         #[serial]
         fn remembers_identity() -> Result<()> {
             with_fresh_config(|| {
-                standard_login()?.exit()?;
-
                 CliTester::new([
                     "login",
+                    "--offline",
                     "--nsec",
-                    TEST_KEY_2_NSEC,
+                    TEST_KEY_1_NSEC,
                     "--password",
                     TEST_PASSWORD,
                 ])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())?;
+                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
 
-                CliTester::new(["login"])
-                    .expect(format!("login as {}\r\n", TEST_KEY_2_NPUB).as_str())?
+                CliTester::new(["login", "--offline"])
+                    .expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
                     .exit()
             })
         }
-    }
-
-    mod when_provided_with_new_password {
-        use super::*;
 
         #[test]
         #[serial]
-        fn password_changes() -> Result<()> {
+        fn parameters_can_be_called_globally() -> Result<()> {
             with_fresh_config(|| {
-                standard_login()?.exit()?;
-
                 CliTester::new([
-                    "login",
                     "--nsec",
                     TEST_KEY_1_NSEC,
                     "--password",
-                    TEST_INVALID_PASSWORD,
+                    TEST_PASSWORD,
+                    "login",
+                    "--offline",
                 ])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
-
-                CliTester::new(["--password", TEST_INVALID_PASSWORD, "login"])
-                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
             })
         }
-    }
 
-    #[test]
-    #[serial]
-    fn invalid_nsec_param_fails_without_prompts() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new([
-                "login",
-                "--nsec",
-                TEST_INVALID_NSEC,
-                "--password",
-                TEST_PASSWORD,
-            ])
-            .expect_end_with(
-                "Error: invalid nsec parameter\r\n\r\nCaused by:\r\n    Invalid secret key\r\n",
-            )
-        })
+        mod when_logging_in_as_different_nsec {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn valid_nsec_param_succeeds_without_prompts_and_logs_in() -> Result<()> {
+                with_fresh_config(|| {
+                    standard_login()?.exit()?;
+
+                    CliTester::new([
+                        "login",
+                        "--offline",
+                        "--nsec",
+                        TEST_KEY_2_NSEC,
+                        "--password",
+                        TEST_PASSWORD,
+                    ])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())
+                })
+            }
+
+            #[test]
+            #[serial]
+            fn remembers_identity() -> Result<()> {
+                with_fresh_config(|| {
+                    standard_login()?.exit()?;
+
+                    CliTester::new([
+                        "login",
+                        "--offline",
+                        "--nsec",
+                        TEST_KEY_2_NSEC,
+                        "--password",
+                        TEST_PASSWORD,
+                    ])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_2_NPUB).as_str())?;
+
+                    CliTester::new(["login", "--offline"])
+                        .expect(format!("login as {}\r\n", TEST_KEY_2_NPUB).as_str())?
+                        .exit()
+                })
+            }
+        }
+
+        mod when_provided_with_new_password {
+            use super::*;
+
+            #[test]
+            #[serial]
+            fn password_changes() -> Result<()> {
+                with_fresh_config(|| {
+                    standard_login()?.exit()?;
+
+                    CliTester::new([
+                        "login",
+                        "--offline",
+                        "--nsec",
+                        TEST_KEY_1_NSEC,
+                        "--password",
+                        TEST_INVALID_PASSWORD,
+                    ])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
+
+                    CliTester::new(["--password", TEST_INVALID_PASSWORD, "login", "--offline"])
+                        .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+                })
+            }
+        }
+
+        #[test]
+        #[serial]
+        fn invalid_nsec_param_fails_without_prompts() -> Result<()> {
+            with_fresh_config(|| {
+                CliTester::new([
+                    "login",
+                    "--offline",
+                    "--nsec",
+                    TEST_INVALID_NSEC,
+                    "--password",
+                    TEST_PASSWORD,
+                ])
+                .expect_end_with(
+                    "Error: invalid nsec parameter\r\n\r\nCaused by:\r\n    Invalid secret key\r\n",
+                )
+            })
+        }
     }
-}
 
-mod when_called_with_password_parameter_only {
-    use super::*;
+    mod when_called_with_password_parameter_only {
+        use super::*;
 
-    #[test]
-    #[serial]
-    fn when_nsec_stored_logs_in_without_prompts() -> Result<()> {
-        with_fresh_config(|| {
-            standard_login()?.exit()?;
+        #[test]
+        #[serial]
+        fn when_nsec_stored_logs_in_without_prompts() -> Result<()> {
+            with_fresh_config(|| {
+                standard_login()?.exit()?;
 
-            CliTester::new(["login", "--password", TEST_PASSWORD])
-                .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
-    }
+                CliTester::new(["login", "--offline", "--password", TEST_PASSWORD])
+                    .expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+            })
+        }
 
-    #[test]
-    #[serial]
-    fn when_no_nsec_stored_logs_error() -> Result<()> {
-        with_fresh_config(|| {
-            CliTester::new(["login", "--password", TEST_PASSWORD])
-                .expect_end_with("Error: no nsec available to decrypt with specified password\r\n")
-        })
+        #[test]
+        #[serial]
+        fn when_no_nsec_stored_logs_error() -> Result<()> {
+            with_fresh_config(|| {
+                CliTester::new(["login", "--offline", "--password", TEST_PASSWORD]).expect_end_with(
+                    "Error: no nsec available to decrypt with specified password\r\n",
+                )
+            })
+        }
     }
-}
 
-mod when_weak_password {
-    use super::*;
+    mod when_weak_password {
+        use super::*;
 
-    #[test]
-    #[serial]
-    // combined into a single test as it is computationally expensive to run
-    fn warns_it_might_take_a_few_seconds_then_succeeds_then_second_login_prompts_for_password_then_warns_again_then_succeeds()
-    -> Result<()> {
-        with_fresh_config(|| {
-            let mut p = CliTester::new_with_timeout(10000, ["login"]);
-            p.expect_input(EXPECTED_NSEC_PROMPT)?
-                .succeeds_with(TEST_KEY_1_NSEC)?;
+        #[test]
+        #[serial]
+        // combined into a single test as it is computationally expensive to run
+        fn warns_it_might_take_a_few_seconds_then_succeeds_then_second_login_prompts_for_password_then_warns_again_then_succeeds()
+        -> Result<()> {
+            with_fresh_config(|| {
+                let mut p = CliTester::new_with_timeout(10000, ["login", "--offline"]);
+                p.expect_input(EXPECTED_NSEC_PROMPT)?
+                    .succeeds_with(TEST_KEY_1_NSEC)?;
 
-            p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
-                .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
-                .succeeds_with(TEST_WEAK_PASSWORD)?;
+                p.expect_password(EXPECTED_SET_PASSWORD_PROMPT)?
+                    .with_confirmation(EXPECTED_SET_PASSWORD_CONFIRM_PROMPT)?
+                    .succeeds_with(TEST_WEAK_PASSWORD)?;
 
-            p.expect("this may take a few seconds...\r\n")?;
+                p.expect("this may take a few seconds...\r\n")?;
 
-            p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
+                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())?;
 
-            p = CliTester::new_with_timeout(10000, ["login"]);
+                p = CliTester::new_with_timeout(10000, ["login", "--offline"]);
 
-            p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
-                .expect_password(EXPECTED_PASSWORD_PROMPT)?
-                .succeeds_with(TEST_WEAK_PASSWORD)?;
+                p.expect(format!("login as {}\r\n", TEST_KEY_1_NPUB).as_str())?
+                    .expect_password(EXPECTED_PASSWORD_PROMPT)?
+                    .succeeds_with(TEST_WEAK_PASSWORD)?;
 
-            p.expect("this may take a few seconds...\r\n")?;
+                p.expect("this may take a few seconds...\r\n")?;
 
-            p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
-        })
+                p.expect_end_with(format!("logged in as {}\r\n", TEST_KEY_1_NPUB).as_str())
+            })
+        }
     }
 }
diff --git a/tests/prs_create.rs b/tests/prs_create.rs
index 0863496..564ef16 100644
--- a/tests/prs_create.rs
+++ b/tests/prs_create.rs
@@ -195,9 +195,9 @@ mod sends_pr_and_2_patches_to_3_relays {
         let git_repo = prep_git_repo()?;
 
         let (mut r51, mut r52, mut r53) = (
-            Relay::new(8051, None),
-            Relay::new(8052, None),
-            Relay::new(8053, None),
+            Relay::new(8051, None, None),
+            Relay::new(8052, None, None),
+            Relay::new(8053, None, None),
         );
 
         // // check relay had the right number of events
@@ -427,9 +427,9 @@ mod sends_pr_and_2_patches_to_3_relays {
             let git_repo = prep_git_repo()?;
 
             let (mut r51, mut r52, mut r53) = (
-                Relay::new(8051, None),
-                Relay::new(8052, None),
-                Relay::new(8053, None),
+                Relay::new(8051, None, None),
+                Relay::new(8052, None, None),
+                Relay::new(8053, None, None),
             );
 
             // // check relay had the right number of events
@@ -477,15 +477,16 @@ mod sends_pr_and_2_patches_to_3_relays {
                 let git_repo = prep_git_repo()?;
 
                 let (mut r51, mut r52, mut r53) = (
-                    Relay::new(8051, None),
+                    Relay::new(8051, None, None),
                     Relay::new(
                         8052,
                         Some(&|relay, client_id, event| -> Result<()> {
                             relay.respond_ok(client_id, event, Some("Payment Required"))?;
                             Ok(())
                         }),
+                        None,
                     ),
-                    Relay::new(8053, None),
+                    Relay::new(8053, None, None),
                 );
 
                 // // check relay had the right number of events
@@ -523,15 +524,16 @@ mod sends_pr_and_2_patches_to_3_relays {
                 let git_repo = prep_git_repo()?;
 
                 let (mut r51, mut r52, mut r53) = (
-                    Relay::new(8051, None),
+                    Relay::new(8051, None, None),
                     Relay::new(
                         8052,
                         Some(&|relay, client_id, event| -> Result<()> {
                             relay.respond_ok(client_id, event, Some("Payment Required"))?;
                             Ok(())
                         }),
+                        None,
                     ),
-                    Relay::new(8053, None),
+                    Relay::new(8053, None, None),
                 );
 
                 // // check relay had the right number of events