15 files changed, 177 insertions, 183 deletions

diff --git a/src/bin/git_remote_nostr/fetch.rs b/src/bin/git_remote_nostr/fetch.rs
index ff55d6f..a972a2f 100644
--- a/src/bin/git_remote_nostr/fetch.rs
+++ b/src/bin/git_remote_nostr/fetch.rs
@@ -112,9 +112,9 @@ pub fn make_commits_for_proposal(
             .context(format!(
                 "cannot create commit for patch {}",
                 nip19::Nip19Event {
-                    event_id: patch.id(),
-                    author: Some(patch.author()),
-                    kind: Some(patch.kind()),
+                    event_id: patch.id,
+                    author: Some(patch.pubkey),
+                    kind: Some(patch.kind),
                     relays: if let Some(relay) = repo_ref.relays.first() {
                         vec![relay.to_string()]
                     } else {
diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs
index 378a124..2f2977e 100644
--- a/src/bin/git_remote_nostr/list.rs
+++ b/src/bin/git_remote_nostr/list.rs
@@ -149,7 +149,7 @@ async fn get_open_proposals_state(
         if let Ok(cl) = event_to_cover_letter(&proposal) {
             if let Ok(mut branch_name) = cl.get_branch_name() {
                 branch_name = if let Some(public_key) = current_user {
-                    if proposal.author().eq(&public_key) {
+                    if proposal.pubkey.eq(&public_key) {
                         cl.branch_name.to_string()
                     } else {
                         branch_name
diff --git a/src/bin/git_remote_nostr/push.rs b/src/bin/git_remote_nostr/push.rs
index 0f4e792..db86c04 100644
--- a/src/bin/git_remote_nostr/push.rs
+++ b/src/bin/git_remote_nostr/push.rs
@@ -184,7 +184,7 @@ pub async fn run_push(
             if let Some((_, (proposal, patches))) =
                 find_proposal_and_patches_by_branch_name(to, &all_proposals, &current_user)
             {
-                if [repo_ref.maintainers.clone(), vec![proposal.author()]]
+                if [repo_ref.maintainers.clone(), vec![proposal.pubkey]]
                     .concat()
                     .contains(&user_ref.public_key)
                 {
@@ -200,7 +200,7 @@ pub async fn run_push(
                             &ahead,
                             &signer,
                             repo_ref,
-                            &Some(proposal.id().to_string()),
+                            &Some(proposal.id.to_string()),
                             &[],
                         )
                         .await?
@@ -223,7 +223,7 @@ pub async fn run_push(
                                 root_event_id
                             } else {
                                 // tip patch is the root proposal
-                                tip_patch.id()
+                                tip_patch.id
                             };
                             let mut parent_patch = tip_patch.clone();
                             ahead.reverse();
@@ -235,7 +235,7 @@ pub async fn run_push(
                                     Some(thread_id),
                                     &signer,
                                     repo_ref,
-                                    Some(parent_patch.id()),
+                                    Some(parent_patch.id),
                                     Some((
                                         (patches.len() + i + 1).try_into().unwrap(),
                                         (patches.len() + ahead.len()).try_into().unwrap(),
@@ -901,8 +901,8 @@ async fn get_merged_status_events(
                         .await?;
                         if let Some(commit_event) = commit_events.iter().find(|e| {
                             e.tags.iter().any(|t| {
-                                t.as_vec()[0].eq("commit")
-                                    && t.as_vec()[1].eq(&parent.id().to_string())
+                                t.as_slice()[0].eq("commit")
+                                    && t.as_slice()[1].eq(&parent.id().to_string())
                             })
                         }) {
                             let (proposal_id, revision_id) =
@@ -930,7 +930,7 @@ async fn get_merged_status_events(
                                         None
                                     },
                                     &commit_hash,
-                                    commit_event.id(),
+                                    commit_event.id,
                                 )
                                 .await?,
                             );
@@ -956,9 +956,9 @@ async fn create_merge_status(
         .iter()
         .copied()
         .collect::<HashSet<PublicKey>>();
-    public_keys.insert(proposal.author());
+    public_keys.insert(proposal.pubkey);
     if let Some(revision) = revision {
-        public_keys.insert(revision.author());
+        public_keys.insert(revision.pubkey);
     }
     sign_event(
         EventBuilder::new(
@@ -971,7 +971,7 @@ async fn create_merge_status(
                         vec!["git proposal merged / applied".to_string()],
                     ),
                     Tag::from_standardized(nostr::TagStandard::Event {
-                        event_id: proposal.id(),
+                        event_id: proposal.id,
                         relay_url: repo_ref.relays.first().map(nostr::UncheckedUrl::new),
                         marker: Some(Marker::Root),
                         public_key: None,
@@ -985,7 +985,7 @@ async fn create_merge_status(
                 ],
                 if let Some(revision) = revision {
                     vec![Tag::from_standardized(nostr::TagStandard::Event {
-                        event_id: revision.id(),
+                        event_id: revision.id,
                         relay_url: repo_ref.relays.first().map(nostr::UncheckedUrl::new),
                         marker: Some(Marker::Root),
                         public_key: None,
@@ -1023,7 +1023,7 @@ async fn get_proposal_and_revision_root_from_patch(
     git_repo: &Repo,
     patch: &Event,
 ) -> Result<(EventId, Option<EventId>)> {
-    let proposal_or_revision = if patch.tags.iter().any(|t| t.as_vec()[1].eq("root")) {
+    let proposal_or_revision = if patch.tags.iter().any(|t| t.as_slice()[1].eq("root")) {
         patch.clone()
     } else {
         let proposal_or_revision_id = EventId::parse(
@@ -1032,9 +1032,9 @@ async fn get_proposal_and_revision_root_from_patch(
             } else if let Some(t) = patch.tags.iter().find(|t| t.is_reply()) {
                 t.clone()
             } else {
-                Tag::event(patch.id())
+                Tag::event(patch.id)
             }
-            .as_vec()[1]
+            .as_slice()[1]
                 .clone(),
         )?;
 
@@ -1048,14 +1048,14 @@ async fn get_proposal_and_revision_root_from_patch(
         .clone()
     };
 
-    if !proposal_or_revision.kind().eq(&Kind::GitPatch) {
+    if !proposal_or_revision.kind.eq(&Kind::GitPatch) {
         bail!("thread root is not a git patch");
     }
 
     if proposal_or_revision
         .tags
         .iter()
-        .any(|t| t.as_vec()[1].eq("revision-root"))
+        .any(|t| t.as_slice()[1].eq("revision-root"))
     {
         Ok((
             EventId::parse(
@@ -1064,13 +1064,13 @@ async fn get_proposal_and_revision_root_from_patch(
                     .iter()
                     .find(|t| t.is_reply())
                     .unwrap()
-                    .as_vec()[1]
+                    .as_slice()[1]
                     .clone(),
             )?,
-            Some(proposal_or_revision.id()),
+            Some(proposal_or_revision.id),
         ))
     } else {
-        Ok((proposal_or_revision.id(), None))
+        Ok((proposal_or_revision.id, None))
     }
 }
 
diff --git a/src/bin/git_remote_nostr/utils.rs b/src/bin/git_remote_nostr/utils.rs
index 3ae1bab..a8bbd6f 100644
--- a/src/bin/git_remote_nostr/utils.rs
+++ b/src/bin/git_remote_nostr/utils.rs
@@ -113,7 +113,7 @@ pub async fn get_open_proposals(
             vec![
                 nostr::Filter::default()
                     .kinds(status_kinds().clone())
-                    .events(proposals.iter().map(nostr::Event::id)),
+                    .events(proposals.iter().map(|e| e.id)),
             ],
         )
         .await?;
@@ -127,15 +127,15 @@ pub async fn get_open_proposals(
         let status = if let Some(e) = statuses
             .iter()
             .filter(|e| {
-                status_kinds().contains(&e.kind())
-                    && e.tags()
+                status_kinds().contains(&e.kind)
+                    && e.tags
                         .iter()
-                        .any(|t| t.as_vec()[1].eq(&proposal.id.to_string()))
+                        .any(|t| t.as_slice()[1].eq(&proposal.id.to_string()))
             })
             .collect::<Vec<&nostr::Event>>()
             .first()
         {
-            e.kind()
+            e.kind
         } else {
             Kind::GitStatusOpen
         };
@@ -148,7 +148,7 @@ pub async fn get_open_proposals(
                     get_most_recent_patch_with_ancestors(commits_events.clone())
                 {
                     open_proposals
-                        .insert(proposal.id(), (proposal, most_recent_proposal_patch_chain));
+                        .insert(proposal.id, (proposal, most_recent_proposal_patch_chain));
                 }
             }
         }
@@ -178,7 +178,7 @@ pub async fn get_all_proposals(
             if let Ok(most_recent_proposal_patch_chain) =
                 get_most_recent_patch_with_ancestors(commits_events.clone())
             {
-                all_proposals.insert(proposal.id(), (proposal, most_recent_proposal_patch_chain));
+                all_proposals.insert(proposal.id, (proposal, most_recent_proposal_patch_chain));
             }
         }
     }
diff --git a/src/bin/ngit/sub_commands/list.rs b/src/bin/ngit/sub_commands/list.rs
index 0755e3b..351896a 100644
--- a/src/bin/ngit/sub_commands/list.rs
+++ b/src/bin/ngit/sub_commands/list.rs
@@ -52,7 +52,7 @@ pub async fn launch() -> Result<()> {
             vec![
                 nostr::Filter::default()
                     .kinds(status_kinds().clone())
-                    .events(proposals_and_revisions.iter().map(nostr::Event::id)),
+                    .events(proposals_and_revisions.iter().map(|e| e.id)),
             ],
         )
         .await?;
@@ -76,15 +76,15 @@ pub async fn launch() -> Result<()> {
         let status = if let Some(e) = statuses
             .iter()
             .filter(|e| {
-                status_kinds().contains(&e.kind())
-                    && e.tags()
+                status_kinds().contains(&e.kind)
+                    && e.tags
                         .iter()
-                        .any(|t| t.as_vec()[1].eq(&proposal.id.to_string()))
+                        .any(|t| t.as_slice()[1].eq(&proposal.id.to_string()))
             })
             .collect::<Vec<&nostr::Event>>()
             .first()
         {
-            e.kind()
+            e.kind
         } else {
             Kind::GitStatusOpen
         };
@@ -184,7 +184,7 @@ pub async fn launch() -> Result<()> {
         let commits_events: Vec<nostr::Event> = get_all_proposal_patch_events_from_cache(
             git_repo_path,
             &repo_ref,
-            &proposals_for_status[selected_index].id(),
+            &proposals_for_status[selected_index].id,
         )
         .await?;
 
@@ -704,7 +704,7 @@ fn save_patches_to_dir(mut patches: Vec<nostr::Event>, git_repo: &Repo) -> Resul
             .truncate(true)
             .open(path)
             .context("open new patch file with write and truncate options")?;
-        file.write_all(patch.content().as_bytes())?;
+        file.write_all(patch.content.as_bytes())?;
         file.write_all("\n\n".as_bytes())?;
         file.flush()?;
     }
diff --git a/src/bin/ngit/sub_commands/pull.rs b/src/bin/ngit/sub_commands/pull.rs
index 9a3d911..d79b7b1 100644
--- a/src/bin/ngit/sub_commands/pull.rs
+++ b/src/bin/ngit/sub_commands/pull.rs
@@ -53,12 +53,9 @@ pub async fn launch() -> Result<()> {
             .context("cannot find proposal that matches the current branch name")?
             .clone();
 
-    let commit_events = get_all_proposal_patch_events_from_cache(
-        git_repo_path,
-        &repo_ref,
-        &proposal_root_event.id(),
-    )
-    .await?;
+    let commit_events =
+        get_all_proposal_patch_events_from_cache(git_repo_path, &repo_ref, &proposal_root_event.id)
+            .await?;
 
     let most_recent_proposal_patch_chain =
         get_most_recent_patch_with_ancestors(commit_events.clone())
diff --git a/src/bin/ngit/sub_commands/push.rs b/src/bin/ngit/sub_commands/push.rs
index 66edfb4..a77f356 100644
--- a/src/bin/ngit/sub_commands/push.rs
+++ b/src/bin/ngit/sub_commands/push.rs
@@ -73,12 +73,9 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
             .context("cannot find proposal that matches the current branch name")?
             .clone();
 
-    let commit_events = get_all_proposal_patch_events_from_cache(
-        git_repo_path,
-        &repo_ref,
-        &proposal_root_event.id(),
-    )
-    .await?;
+    let commit_events =
+        get_all_proposal_patch_events_from_cache(git_repo_path, &repo_ref, &proposal_root_event.id)
+            .await?;
 
     let most_recent_proposal_patch_chain = get_most_recent_patch_with_ancestors(commit_events)
         .context("cannot get most recent patch for proposal")?;
@@ -191,7 +188,7 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 Some(proposal_root_event.id),
                 &signer,
                 &repo_ref,
-                patch_events.last().map(nostr::Event::id),
+                patch_events.last().map(|e| e.id),
                 None,
                 None,
                 &None,
diff --git a/src/bin/ngit/sub_commands/send.rs b/src/bin/ngit/sub_commands/send.rs
index a807305..fe2952f 100644
--- a/src/bin/ngit/sub_commands/send.rs
+++ b/src/bin/ngit/sub_commands/send.rs
@@ -240,9 +240,9 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs, no_fetch: bool) -> Re
     if root_proposal_id.is_none() {
         if let Some(event) = events.first() {
             let event_bech32 = if let Some(relay) = repo_ref.relays.first() {
-                Nip19Event::new(event.id(), vec![relay]).to_bech32()?
+                Nip19Event::new(event.id, vec![relay]).to_bech32()?
             } else {
-                event.id().to_bech32()?
+                event.id.to_bech32()?
             };
             println!(
                 "{}",
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());
                         }