7 files changed, 131 insertions, 131 deletions

diff --git a/src/lib/client.rs b/src/lib/client.rs
index 59e17f2..5f9e996 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -29,7 +29,7 @@ use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressState, P
 #[cfg(test)]
 use mockall::*;
 use nostr::{nips::nip01::Coordinate, Event};
-use nostr_database::{NostrDatabase, Order};
+use nostr_database::NostrDatabase;
 use nostr_sdk::{
     prelude::RelayLimits, EventBuilder, EventId, Kind, NostrSigner, Options, PublicKey,
     SingleLetterTag, Timestamp, Url,
@@ -231,10 +231,10 @@ impl Connect for Client {
             });
         }
         save_event_in_cache(git_repo_path, &event).await?;
-        if event.kind().eq(&Kind::GitRepoAnnouncement) {
+        if event.kind.eq(&Kind::GitRepoAnnouncement) {
             save_event_in_global_cache(git_repo_path, &event).await?;
         }
-        Ok(event.id())
+        Ok(event.id)
     }
 
     async fn get_events(
@@ -758,7 +758,7 @@ pub async fn get_events_from_cache(
 ) -> Result<Vec<nostr::Event>> {
     get_local_cache_database(git_repo_path)
         .await?
-        .query(filters.clone(), Order::Asc)
+        .query(filters.clone())
         .await
         .context(
             "cannot execute query on opened git repo nostr cache database .git/nostr-cache.sqlite",
@@ -771,7 +771,7 @@ pub async fn get_event_from_global_cache(
 ) -> Result<Vec<nostr::Event>> {
     get_global_cache_database(git_repo_path)
         .await?
-        .query(filters.clone(), Order::Asc)
+        .query(filters.clone())
         .await
         .context("cannot execute query on opened ngit nostr cache database")
 }
@@ -839,12 +839,12 @@ pub async fn get_repo_ref_from_cache(
 
     let mut events: HashMap<Coordinate, nostr::Event> = HashMap::new();
     for m in &maintainers {
-        if let Some(e) = repo_events.iter().find(|e| e.author().eq(m)) {
+        if let Some(e) = repo_events.iter().find(|e| e.pubkey.eq(m)) {
             events.insert(
                 Coordinate {
                     kind: e.kind,
                     identifier: e.identifier().unwrap().to_string(),
-                    public_key: e.author(),
+                    public_key: e.pubkey,
                     relays: vec![],
                 },
                 e.clone(),
@@ -938,8 +938,8 @@ async fn create_relays_request(
         .await?
         {
             if event_is_patch_set_root(event) || event_is_revision_root(event) {
-                proposals.insert(event.id());
-                contributors.insert(event.author());
+                proposals.insert(event.id);
+                contributors.insert(event.pubkey);
             }
         }
 
@@ -951,7 +951,7 @@ async fn create_relays_request(
         for c in &contributors {
             if let Some(event) = profile_events
                 .iter()
-                .find(|e| e.kind() == Kind::Metadata && e.author().eq(c))
+                .find(|e| e.kind == Kind::Metadata && e.pubkey.eq(c))
             {
                 save_event_in_cache(git_repo_path, event).await?;
             } else {
@@ -1109,7 +1109,7 @@ async fn process_fetched_events(
     for event in &events {
         if !request.existing_events.contains(&event.id) {
             save_event_in_cache(git_repo_path, event).await?;
-            if event.kind().eq(&Kind::GitRepoAnnouncement) {
+            if event.kind.eq(&Kind::GitRepoAnnouncement) {
                 save_event_in_global_cache(git_repo_path, event).await?;
                 let new_coordinate = !request
                     .repo_coordinates_without_relays
@@ -1135,8 +1135,8 @@ async fn process_fetched_events(
                 if update_to_existing {
                     report.updated_repo_announcements.push((
                         Coordinate {
-                            kind: event.kind(),
-                            public_key: event.author(),
+                            kind: event.kind,
+                            public_key: event.pubkey,
                             identifier: event.identifier().unwrap().to_owned(),
                             relays: vec![],
                         },
@@ -1155,7 +1155,7 @@ async fn process_fetched_events(
                             .any(|c| c.identifier.eq(&repo_ref.identifier) && m.eq(&c.public_key))
                         {
                             let c = Coordinate {
-                                kind: event.kind(),
+                                kind: event.kind,
                                 public_key: *m,
                                 identifier: repo_ref.identifier.clone(),
                                 relays: vec![],
@@ -1177,7 +1177,7 @@ async fn process_fetched_events(
                         }
                     }
                 }
-            } else if event.kind().eq(&STATE_KIND) {
+            } else if event.kind.eq(&STATE_KIND) {
                 let existing_state = if report.updated_state.is_some() {
                     report.updated_state
                 } else {
@@ -1193,27 +1193,23 @@ async fn process_fetched_events(
             } else if event_is_patch_set_root(event) {
                 fresh_proposal_roots.insert(event.id);
                 report.proposals.insert(event.id);
-                if !request.contributors.contains(&event.author())
-                    && !fresh_profiles.contains(&event.author())
+                if !request.contributors.contains(&event.pubkey)
+                    && !fresh_profiles.contains(&event.pubkey)
                 {
-                    fresh_profiles.insert(event.author());
+                    fresh_profiles.insert(event.pubkey);
                 }
-            } else if [Kind::RelayList, Kind::Metadata].contains(&event.kind()) {
-                if request
-                    .missing_contributor_profiles
-                    .contains(&event.author())
-                {
-                    report.contributor_profiles.insert(event.author());
+            } else if [Kind::RelayList, Kind::Metadata].contains(&event.kind) {
+                if request.missing_contributor_profiles.contains(&event.pubkey) {
+                    report.contributor_profiles.insert(event.pubkey);
                 } else if let Some((_, (metadata_timestamp, relay_list_timestamp))) = request
                     .profiles_to_fetch_from_user_relays
-                    .get_key_value(&event.author())
+                    .get_key_value(&event.pubkey)
                 {
-                    if (Kind::Metadata.eq(&event.kind())
-                        && event.created_at().gt(metadata_timestamp))
-                        || (Kind::RelayList.eq(&event.kind())
-                            && event.created_at().gt(relay_list_timestamp))
+                    if (Kind::Metadata.eq(&event.kind) && event.created_at.gt(metadata_timestamp))
+                        || (Kind::RelayList.eq(&event.kind)
+                            && event.created_at.gt(relay_list_timestamp))
                     {
-                        report.profile_updates.insert(event.author());
+                        report.profile_updates.insert(event.pubkey);
                     }
                 }
                 save_event_in_global_cache(git_repo_path, event).await?;
@@ -1224,9 +1220,9 @@ async fn process_fetched_events(
         if !request.existing_events.contains(&event.id)
             && !event.event_ids().any(|id| report.proposals.contains(id))
         {
-            if event.kind().eq(&Kind::GitPatch) && !event_is_patch_set_root(event) {
+            if event.kind.eq(&Kind::GitPatch) && !event_is_patch_set_root(event) {
                 report.commits.insert(event.id);
-            } else if status_kinds().contains(&event.kind()) {
+            } else if status_kinds().contains(&event.kind) {
                 report.statuses.insert(event.id);
             }
         }
@@ -1549,21 +1545,21 @@ pub async fn get_all_proposal_patch_events_from_cache(
         vec![
             commit_events
                 .iter()
-                .find(|e| e.id().eq(proposal_id))
+                .find(|e| e.id.eq(proposal_id))
                 .context("proposal not in cache")?
-                .author(),
+                .pubkey,
         ],
     ]
     .concat()
     .iter()
     .copied()
     .collect();
-    commit_events.retain(|e| permissioned_users.contains(&e.author()));
+    commit_events.retain(|e| permissioned_users.contains(&e.pubkey));
 
     let revision_roots: HashSet<nostr::EventId> = commit_events
         .iter()
         .filter(|e| event_is_revision_root(e))
-        .map(nostr::Event::id)
+        .map(|e| e.id)
         .collect();
 
     if !revision_roots.is_empty() {
@@ -1584,7 +1580,7 @@ pub async fn get_all_proposal_patch_events_from_cache(
 
     Ok(commit_events
         .iter()
-        .filter(|e| !event_is_cover_letter(e) && permissioned_users.contains(&e.author()))
+        .filter(|e| !event_is_cover_letter(e) && permissioned_users.contains(&e.pubkey))
         .cloned()
         .collect())
 }
@@ -1614,10 +1610,7 @@ pub async fn send_events(
 ) -> Result<()> {
     let fallback = [
         client.get_fallback_relays().clone(),
-        if events
-            .iter()
-            .any(|e| e.kind().eq(&Kind::GitRepoAnnouncement))
-        {
+        if events.iter().any(|e| e.kind.eq(&Kind::GitRepoAnnouncement)) {
             client.get_blaster_relays().clone()
         } else {
             vec![]
diff --git a/src/lib/git/mod.rs b/src/lib/git/mod.rs
index b0576fd..875a336 100644
--- a/src/lib/git/mod.rs
+++ b/src/lib/git/mod.rs
@@ -842,9 +842,9 @@ fn extract_sig_from_patch_tags<'a>(
 ) -> Result<git2::Signature<'a>> {
     let v = tags
         .iter()
-        .find(|t| t.as_vec()[0].eq(tag_name))
+        .find(|t| t.as_slice()[0].eq(tag_name))
         .context(format!("tag '{tag_name}' not present in patch"))?
-        .as_vec();
+        .as_slice();
     if v.len() != 5 {
         bail!("tag '{tag_name}' is incorrectly formatted")
     }
diff --git a/src/lib/git_events.rs b/src/lib/git_events.rs
index d818f4c..2adc205 100644
--- a/src/lib/git_events.rs
+++ b/src/lib/git_events.rs
@@ -19,9 +19,9 @@ pub fn tag_value(event: &Event, tag_name: &str) -> Result<String> {
     Ok(event
         .tags
         .iter()
-        .find(|t| t.as_vec()[0].eq(tag_name))
+        .find(|t| t.as_slice()[0].eq(tag_name))
         .context(format!("tag '{tag_name}'not present"))?
-        .as_vec()[1]
+        .as_slice()[1]
         .clone())
 }
 
@@ -40,11 +40,11 @@ pub fn get_commit_id_from_patch(event: &Event) -> Result<String> {
 pub fn get_event_root(event: &nostr::Event) -> Result<EventId> {
     Ok(EventId::parse(
         event
-            .tags()
+            .tags
             .iter()
             .find(|t| t.is_root())
             .context("no thread root in event")?
-            .as_vec()
+            .as_slice()
             .get(1)
             .unwrap(),
     )?)
@@ -60,23 +60,23 @@ pub fn status_kinds() -> Vec<Kind> {
 }
 
 pub fn event_is_patch_set_root(event: &Event) -> bool {
-    event.kind.eq(&Kind::GitPatch) && event.tags().iter().any(|t| t.as_vec()[1].eq("root"))
+    event.kind.eq(&Kind::GitPatch) && event.tags.iter().any(|t| t.as_slice()[1].eq("root"))
 }
 
 pub fn event_is_revision_root(event: &Event) -> bool {
     event.kind.eq(&Kind::GitPatch)
         && event
-            .tags()
+            .tags
             .iter()
-            .any(|t| t.as_vec()[1].eq("revision-root"))
+            .any(|t| t.as_slice()[1].eq("revision-root"))
 }
 
 pub fn patch_supports_commit_ids(event: &Event) -> bool {
     event.kind.eq(&Kind::GitPatch)
         && event
-            .tags()
+            .tags
             .iter()
-            .any(|t| t.as_vec()[0].eq("commit-pgp-sig"))
+            .any(|t| t.as_slice()[0].eq("commit-pgp-sig"))
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -399,7 +399,7 @@ pub async fn generate_cover_letter_and_patch_events(
                 events.first().map(|event| event.id),
                 signer,
                 repo_ref,
-                events.last().map(nostr::Event::id),
+                events.last().map(|e| e.id),
                 if events.is_empty() && commits.len().eq(&1) {
                     None
                 } else {
@@ -461,11 +461,11 @@ pub fn event_is_cover_letter(event: &nostr::Event) -> bool {
     //   [PATCH v1 0/n ] or
     //   [PATCH subsystem v2 0/n ]
     event.kind.eq(&Kind::GitPatch)
-        && event.tags().iter().any(|t| t.as_vec()[1].eq("root"))
+        && event.tags.iter().any(|t| t.as_slice()[1].eq("root"))
         && event
-            .tags()
+            .tags
             .iter()
-            .any(|t| t.as_vec()[1].eq("cover-letter"))
+            .any(|t| t.as_slice()[1].eq("cover-letter"))
 }
 
 pub fn commit_msg_from_patch(patch: &nostr::Event) -> Result<String> {
@@ -529,7 +529,7 @@ pub fn event_to_cover_letter(event: &nostr::Event) -> Result<CoverLetter> {
                 .collect();
             s
         },
-        event_id: Some(event.id()),
+        event_id: Some(event.id),
     })
 }
 
@@ -580,17 +580,17 @@ fn get_event_parent_id(event: &nostr::Event) -> Result<String> {
     Ok(if let Some(reply_tag) = event
         .tags
         .iter()
-        .find(|t| t.as_vec().len().gt(&3) && t.as_vec()[3].eq("reply"))
+        .find(|t| t.as_slice().len().gt(&3) && t.as_slice()[3].eq("reply"))
     {
         reply_tag
     } else {
         event
             .tags
             .iter()
-            .find(|t| t.as_vec().len().gt(&3) && t.as_vec()[3].eq("root"))
+            .find(|t| t.as_slice().len().gt(&3) && t.as_slice()[3].eq("root"))
             .context("no reply or root e tag present".to_string())?
     }
-    .as_vec()[1]
+    .as_slice()[1]
         .clone())
 }
 
@@ -601,7 +601,7 @@ pub fn is_event_proposal_root_for_branch(
 ) -> Result<bool> {
     let branch_name = branch_name_or_refstr.replace("refs/heads/", "");
     Ok(event_to_cover_letter(e).is_ok_and(|cl| {
-        (logged_in_user.is_some_and(|public_key| e.author().eq(&public_key))
+        (logged_in_user.is_some_and(|public_key| e.pubkey.eq(&public_key))
             && (branch_name.eq(&format!("pr/{}", cl.branch_name))
                 || cl.branch_name.eq(&branch_name)))
             || cl.get_branch_name().is_ok_and(|s| s.eq(&branch_name))
diff --git a/src/lib/login/key_encryption.rs b/src/lib/login/key_encryption.rs
index 3841d50..b50b507 100644
--- a/src/lib/login/key_encryption.rs
+++ b/src/lib/login/key_encryption.rs
@@ -11,7 +11,7 @@ pub fn encrypt_key(keys: &Keys, password: &str) -> Result<String> {
         15
     };
     Ok(nostr::nips::nip49::EncryptedSecretKey::new(
-        keys.secret_key()?,
+        keys.secret_key(),
         password,
         log2_rounds,
         KeySecurity::Medium,
@@ -47,14 +47,8 @@ mod tests {
         let decrypted_key = decrypt_key(TEST_KEY_1_ENCRYPTED, TEST_PASSWORD)?;
 
         assert_eq!(
-            format!(
-                "{}",
-                TEST_KEY_1_KEYS.secret_key().unwrap().to_bech32().unwrap()
-            ),
-            format!(
-                "{}",
-                decrypted_key.secret_key().unwrap().to_bech32().unwrap()
-            ),
+            format!("{}", TEST_KEY_1_KEYS.secret_key().to_bech32().unwrap()),
+            format!("{}", decrypted_key.secret_key().to_bech32().unwrap()),
         );
         Ok(())
     }
@@ -65,14 +59,8 @@ mod tests {
         let decrypted_key = decrypt_key(TEST_KEY_1_ENCRYPTED_WEAK, TEST_WEAK_PASSWORD)?;
 
         assert_eq!(
-            format!(
-                "{}",
-                TEST_KEY_1_KEYS.secret_key().unwrap().to_bech32().unwrap()
-            ),
-            format!(
-                "{}",
-                decrypted_key.secret_key().unwrap().to_bech32().unwrap()
-            ),
+            format!("{}", TEST_KEY_1_KEYS.secret_key().to_bech32().unwrap()),
+            format!("{}", decrypted_key.secret_key().to_bech32().unwrap()),
         );
         Ok(())
     }
@@ -84,8 +72,8 @@ mod tests {
         let newkey = decrypt_key(s.as_str(), TEST_PASSWORD)?;
 
         assert_eq!(
-            format!("{}", key.secret_key().unwrap().to_bech32().unwrap()),
-            format!("{}", newkey.secret_key().unwrap().to_bech32().unwrap()),
+            format!("{}", key.secret_key().to_bech32().unwrap()),
+            format!("{}", newkey.secret_key().to_bech32().unwrap()),
         );
         Ok(())
     }
@@ -97,8 +85,8 @@ mod tests {
         let newkey = decrypt_key(s.as_str(), TEST_PASSWORD)?;
 
         assert_eq!(
-            format!("{}", key.secret_key().unwrap().to_bech32().unwrap()),
-            format!("{}", newkey.secret_key().unwrap().to_bech32().unwrap()),
+            format!("{}", key.secret_key().to_bech32().unwrap()),
+            format!("{}", newkey.secret_key().to_bech32().unwrap()),
         );
         Ok(())
     }
diff --git a/src/lib/login/mod.rs b/src/lib/login/mod.rs
index 825ec30..f262bda 100644
--- a/src/lib/login/mod.rs
+++ b/src/lib/login/mod.rs
@@ -363,7 +363,7 @@ async fn fresh_login(
     always_save: bool,
 ) -> Result<(NostrSigner, UserRef)> {
     let app_key = Keys::generate();
-    let app_key_secret = app_key.secret_key()?.to_secret_hex();
+    let app_key_secret = app_key.secret_key().to_secret_hex();
     let relays = if let Some(client) = client {
         client
             .get_fallback_signer_relays()
@@ -652,7 +652,7 @@ fn save_keys(git_repo: &Repo, keys: &nostr::Keys, always_save: bool) -> Result<(
                 .context("failed to get password input from interactor.password")?;
             encrypt_key(keys, &password)?
         } else {
-            keys.secret_key()?.to_bech32()?
+            keys.secret_key().to_bech32()?
         };
 
         if let Err(error) =
@@ -745,9 +745,9 @@ fn extract_user_relays(public_key: &nostr::PublicKey, events: &[nostr::Event]) -
                         )))
                 })
                 .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"),
+                    url: t.as_slice()[1].clone(),
+                    read: t.as_slice().len() == 2 || t.as_slice()[2].eq("read"),
+                    write: t.as_slice().len() == 2 || t.as_slice()[2].eq("write"),
                 })
                 .collect()
         } else {
diff --git a/src/lib/repo_ref.rs b/src/lib/repo_ref.rs
index e498c86..2468d4d 100644
--- a/src/lib/repo_ref.rs
+++ b/src/lib/repo_ref.rs
@@ -42,42 +42,50 @@ impl TryFrom<nostr::Event> for RepoRef {
         }
         let mut r = Self::default();
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("d")) {
-            r.identifier = t.as_vec()[1].clone();
+        if let Some(t) = event.tags.iter().find(|t| t.as_slice()[0].eq("d")) {
+            r.identifier = t.as_slice()[1].clone();
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("name")) {
-            r.name = t.as_vec()[1].clone();
+        if let Some(t) = event.tags.iter().find(|t| t.as_slice()[0].eq("name")) {
+            r.name = t.as_slice()[1].clone();
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("description")) {
-            r.description = t.as_vec()[1].clone();
+        if let Some(t) = event
+            .tags
+            .iter()
+            .find(|t| t.as_slice()[0].eq("description"))
+        {
+            r.description = t.as_slice()[1].clone();
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("clone")) {
+        if let Some(t) = event.tags.iter().find(|t| t.as_slice()[0].eq("clone")) {
             r.git_server = t.clone().to_vec();
             r.git_server.remove(0);
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("web")) {
+        if let Some(t) = event.tags.iter().find(|t| t.as_slice()[0].eq("web")) {
             r.web = t.clone().to_vec();
             r.web.remove(0);
         }
 
         if let Some(t) = event.tags.iter().find(|t| {
-            t.as_vec()[0].eq("r")
-                && t.as_vec()[1].len().eq(&40)
-                && git2::Oid::from_str(t.as_vec()[1].as_str()).is_ok()
+            t.as_slice()[0].eq("r")
+                && t.as_slice()[1].len().eq(&40)
+                && git2::Oid::from_str(t.as_slice()[1].as_str()).is_ok()
         }) {
-            r.root_commit = t.as_vec()[1].clone();
+            r.root_commit = t.as_slice()[1].clone();
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("relays")) {
+        if let Some(t) = event.tags.iter().find(|t| t.as_slice()[0].eq("relays")) {
             r.relays = t.clone().to_vec();
             r.relays.remove(0);
         }
 
-        if let Some(t) = event.tags.iter().find(|t| t.as_vec()[0].eq("maintainers")) {
+        if let Some(t) = event
+            .tags
+            .iter()
+            .find(|t| t.as_slice()[0].eq("maintainers"))
+        {
             let mut maintainers = t.clone().to_vec();
             maintainers.remove(0);
             if !maintainers.contains(&event.pubkey.to_string()) {
@@ -98,7 +106,7 @@ impl TryFrom<nostr::Event> for RepoRef {
             Coordinate {
                 kind: event.kind,
                 identifier: event.identifier().unwrap().to_string(),
-                public_key: event.author(),
+                public_key: event.pubkey,
                 relays: vec![],
             },
             event,
@@ -606,7 +614,7 @@ mod tests {
                         .await
                         .tags
                         .iter()
-                        .any(|t| t.as_vec()[0].eq("d") && t.as_vec()[1].eq("123412341"))
+                        .any(|t| t.as_slice()[0].eq("d") && t.as_slice()[1].eq("123412341"))
                 )
             }
 
@@ -617,36 +625,44 @@ mod tests {
                         .await
                         .tags
                         .iter()
-                        .any(|t| t.as_vec()[0].eq("name") && t.as_vec()[1].eq("test name"))
+                        .any(|t| t.as_slice()[0].eq("name") && t.as_slice()[1].eq("test name"))
                 )
             }
 
             #[tokio::test]
             async fn alt() {
-                assert!(
-                    create().await.tags.iter().any(|t| t.as_vec()[0].eq("alt")
-                        && t.as_vec()[1].eq("git repository: test name"))
-                )
+                assert!(create().await.tags.iter().any(|t| t.as_slice()[0].eq("alt")
+                    && t.as_slice()[1].eq("git repository: test name")))
             }
 
             #[tokio::test]
             async fn description() {
-                assert!(create().await.tags.iter().any(
-                    |t| t.as_vec()[0].eq("description") && t.as_vec()[1].eq("test description")
-                ))
+                assert!(
+                    create()
+                        .await
+                        .tags
+                        .iter()
+                        .any(|t| t.as_slice()[0].eq("description")
+                            && t.as_slice()[1].eq("test description"))
+                )
             }
 
             #[tokio::test]
             async fn root_commit_as_reference() {
-                assert!(create().await.tags.iter().any(|t| t.as_vec()[0].eq("r")
-                    && t.as_vec()[1].eq("5e664e5a7845cd1373c79f580ca4fe29ab5b34d2")))
+                assert!(create().await.tags.iter().any(|t| t.as_slice()[0].eq("r")
+                    && t.as_slice()[1].eq("5e664e5a7845cd1373c79f580ca4fe29ab5b34d2")))
             }
 
             #[tokio::test]
             async fn git_server() {
-                assert!(create().await.tags.iter().any(
-                    |t| t.as_vec()[0].eq("clone") && t.as_vec()[1].eq("https://localhost:1000")
-                ))
+                assert!(
+                    create()
+                        .await
+                        .tags
+                        .iter()
+                        .any(|t| t.as_slice()[0].eq("clone")
+                            && t.as_slice()[1].eq("https://localhost:1000"))
+                )
             }
 
             #[tokio::test]
@@ -655,21 +671,24 @@ mod tests {
                 let relays_tag: &nostr::Tag = event
                     .tags
                     .iter()
-                    .find(|t| t.as_vec()[0].eq("relays"))
+                    .find(|t| t.as_slice()[0].eq("relays"))
                     .unwrap();
-                assert_eq!(relays_tag.as_vec().len(), 3);
-                assert_eq!(relays_tag.as_vec()[1], "ws://relay1.io");
-                assert_eq!(relays_tag.as_vec()[2], "ws://relay2.io");
+                assert_eq!(relays_tag.as_slice().len(), 3);
+                assert_eq!(relays_tag.as_slice()[1], "ws://relay1.io");
+                assert_eq!(relays_tag.as_slice()[2], "ws://relay2.io");
             }
 
             #[tokio::test]
             async fn web() {
                 let event = create().await;
-                let web_tag: &nostr::Tag =
-                    event.tags.iter().find(|t| t.as_vec()[0].eq("web")).unwrap();
-                assert_eq!(web_tag.as_vec().len(), 3);
-                assert_eq!(web_tag.as_vec()[1], "https://exampleproject.xyz");
-                assert_eq!(web_tag.as_vec()[2], "https://gitworkshop.dev/123");
+                let web_tag: &nostr::Tag = event
+                    .tags
+                    .iter()
+                    .find(|t| t.as_slice()[0].eq("web"))
+                    .unwrap();
+                assert_eq!(web_tag.as_slice().len(), 3);
+                assert_eq!(web_tag.as_slice()[1], "https://exampleproject.xyz");
+                assert_eq!(web_tag.as_slice()[2], "https://gitworkshop.dev/123");
             }
 
             #[tokio::test]
@@ -678,15 +697,15 @@ mod tests {
                 let maintainers_tag: &nostr::Tag = event
                     .tags
                     .iter()
-                    .find(|t| t.as_vec()[0].eq("maintainers"))
+                    .find(|t| t.as_slice()[0].eq("maintainers"))
                     .unwrap();
-                assert_eq!(maintainers_tag.as_vec().len(), 3);
+                assert_eq!(maintainers_tag.as_slice().len(), 3);
                 assert_eq!(
-                    maintainers_tag.as_vec()[1],
+                    maintainers_tag.as_slice()[1],
                     TEST_KEY_1_KEYS.public_key().to_string()
                 );
                 assert_eq!(
-                    maintainers_tag.as_vec()[2],
+                    maintainers_tag.as_slice()[2],
                     TEST_KEY_2_KEYS.public_key().to_string()
                 );
             }
diff --git a/src/lib/repo_state.rs b/src/lib/repo_state.rs
index a5cebab..c39db34 100644
--- a/src/lib/repo_state.rs
+++ b/src/lib/repo_state.rs
@@ -15,12 +15,12 @@ impl RepoState {
         let event = state_events.first().context("no state events")?;
         let mut state = HashMap::new();
         for tag in &event.tags {
-            if let Some(name) = tag.as_vec().first() {
+            if let Some(name) = tag.as_slice().first() {
                 if ["refs/heads/", "refs/tags", "HEAD"]
                     .iter()
                     .any(|s| name.starts_with(*s))
                 {
-                    if let Some(value) = tag.as_vec().get(1) {
+                    if let Some(value) = tag.as_slice().get(1) {
                         if Oid::from_str(value).is_ok() || value.contains("ref: refs/") {
                             state.insert(name.to_owned(), value.to_owned());
                         }