Refactor signing and public key usage — heartwood

This patch aims to refactor some of our usage of PublicKey and Signer. The

motivation for this is to help make way for thinking about agent repositories – and, in the future, multi-device.

The main motivation is to help gain some separation when we want to think about a node (or device) signing artifacts, and when will want to think about an agent signing artifacts.

The reason for moving away from radicle_crypto::Signer and towards signature::Signer is because the former ties itself very closely to the PublicKey. In the future, we will want signers that are not necessarily a single PublicKey – but may come from many device, for example.

However, there are places where we do want this association, and that is why the Device type is introduced.

Furthermore, we also want to try help separate when a PublicKey is required for verifying and when it used for namespacing in the Git repository. For now, this separation is only done by abstracting away the namespacing for the COB storage.

See the commits for more details on the changes.

  "radicle-git-ext",
  "serde",
  "serde_json",
  "signature 2.2.0",
  "tempfile",
  "thiserror 1.0.69",
 ]

  "radicle-git-ext",
  "radicle-ssh",
  "serde",
  "signature 2.2.0",
  "sqlite",
  "ssh-key",
  "tempfile",

                     let actions: Vec<cob::patch::Action> = read_jsonl(reader)?;
                     let mut patches = profile.patches_mut(&repo)?;
                     let mut patch = patches.get_mut(oid)?;
                     patch.transaction(&message, &profile.signer()?, |tx| {
                     patch.transaction(&message, &*profile.signer()?, |tx| {
                         tx.extend(actions)?;
                         tx.embed(embeds)?;
                         Ok(())

                     let actions: Vec<cob::issue::Action> = read_jsonl(reader)?;
                     let mut issues = profile.issues_mut(&repo)?;
                     let mut issue = issues.get_mut(oid)?;
                     issue.transaction(&message, &profile.signer()?, |tx| {
                     issue.transaction(&message, &*profile.signer()?, |tx| {
                         tx.extend(actions)?;
                         tx.embed(embeds)?;
                         Ok(())

 use radicle::cob::identity::{self, IdentityMut, Revision, RevisionId};
 use radicle::identity::{doc, Doc, Identity, PayloadError, RawDoc, Visibility};
 use radicle::prelude::{Did, RepoId, Signer};
 use radicle::node::device::Device;
 use radicle::node::NodeId;
 use radicle::prelude::{Did, RepoId};
 use radicle::storage::refs;
 use radicle::storage::{ReadRepository, ReadStorage as _, WriteRepository};
 use radicle::{cob, Profile};
 use radicle::{cob, crypto, Profile};
 use radicle_surf::diff::Diff;
 use radicle_term::Element;
 use serde_json as json;

     Ok(result)
 }
 fn update<R: WriteRepository + cob::Store, G: Signer>(
 fn update<R, G>(
     title: Option<String>,
     description: Option<String>,
     doc: Doc,
     current: &mut IdentityMut<R>,
     signer: &G,
 ) -> anyhow::Result<Revision> {
     signer: &Device<G>,
 ) -> anyhow::Result<Revision>
 where
     R: WriteRepository + cob::Store<Namespace = NodeId>,
     G: crypto::signature::Signer<crypto::Signature>,
 {
     if let Some((title, description)) = edit_title_description(title, description)? {
         let id = current.update(title, description, &doc, signer)?;
         let revision = current

 use radicle::node::notifications;
 use radicle::node::notifications::*;
 use radicle::patch::cache::Patches as _;
 use radicle::prelude::{Profile, RepoId};
 use radicle::prelude::{NodeId, Profile, RepoId};
 use radicle::storage::{BranchName, ReadRepository, ReadStorage};
 use radicle::{cob, git, Storage};

     profile: &Profile,
 ) -> anyhow::Result<Option<term::VStack<'a>>>
 where
     <R as ReadStorage>::Repository: cob::Store,
     <R as ReadStorage>::Repository: cob::Store<Namespace = NodeId>,
 {
     let mut table = term::Table::new(term::TableOptions {
         spacing: 3,

 use radicle::cob::common::{Label, Reaction};
 use radicle::cob::issue::{CloseReason, State};
 use radicle::cob::{issue, thread};
 use radicle::crypto::Signer;
 use radicle::crypto;
 use radicle::issue::cache::Issues as _;
 use radicle::node::device::Device;
 use radicle::node::NodeId;
 use radicle::prelude::{Did, RepoId};
 use radicle::profile;
 use radicle::storage;

     assignees: Vec<Did>,
     options: &Options,
     cache: &mut issue::Cache<issue::Issues<'_, R>, cob::cache::StoreWriter>,
     signer: &G,
     signer: &Device<G>,
     profile: &Profile,
 ) -> anyhow::Result<()>
 where
     R: ReadRepository + WriteRepository + cob::Store,
     G: Signer,
     R: ReadRepository + WriteRepository + cob::Store<Namespace = NodeId>,
     G: crypto::signature::Signer<crypto::Signature>,
 {
     let (title, description) = if let (Some(t), Some(d)) = (title.as_ref(), description.as_ref()) {
         (t.to_owned(), d.to_owned())

     id: Rev,
     title: Option<String>,
     description: Option<String>,
     signer: &G,
     signer: &Device<G>,
 ) -> anyhow::Result<issue::IssueMut<'a, 'g, R, cob::cache::StoreWriter>>
 where
     R: WriteRepository + ReadRepository + cob::Store,
     G: radicle::crypto::Signer,
     R: WriteRepository + ReadRepository + cob::Store<Namespace = NodeId>,
     G: crypto::signature::Signer<crypto::Signature>,
 {
     let id = id.resolve(&repo.backend)?;
     let mut issue = issues.get_mut(&id)?;

 }
 /// Get a comment from the user, by prompting.
 pub fn prompt_comment<R: WriteRepository + radicle::cob::Store>(
 pub fn prompt_comment<R: WriteRepository + radicle::cob::Store<Namespace = NodeId>>(
     message: Message,
     reply_to: Option<Rev>,
     issue: &issue::Issue,

 use anyhow::{anyhow, Context as _};
 use radicle::cob::job::{JobStore, Reason, State};
 use radicle::crypto::Signer;
 use radicle::node::Handle;
 use radicle::crypto;
 use radicle::node::device::Device;
 use radicle::node::{Handle, NodeId};
 use radicle::storage::{WriteRepository, WriteStorage};
 use radicle::{cob, Node};

     Ok(())
 }
 fn trigger<R: WriteRepository + cob::Store, G: Signer>(
 fn trigger<R, G>(
     commit: &Rev,
     store: &mut JobStore<R>,
     repo: &radicle::storage::git::Repository,
     signer: &G,
     signer: &Device<G>,
     quiet: bool,
 ) -> anyhow::Result<()> {
 ) -> anyhow::Result<()>
 where
     R: WriteRepository + cob::Store<Namespace = NodeId>,
     G: crypto::signature::Signer<crypto::Signature>,
 {
     let commit = commit.resolve(&repo.backend)?;
     let job = store.create(commit, signer)?;
     if !quiet {

 }
 // TODO: This should use the COB cache for performance.
 fn list<R: WriteRepository + cob::Store>(store: &JobStore<R>) -> anyhow::Result<()> {
 fn list<R: WriteRepository + cob::Store<Namespace = NodeId>>(
     store: &JobStore<R>,
 ) -> anyhow::Result<()> {
     if store.is_empty()? {
         term::print(term::format::italic("Nothing to show."));
         return Ok(());

     Ok(())
 }
 fn show<R: WriteRepository + cob::Store>(
 fn show<R: WriteRepository + cob::Store<Namespace = NodeId>>(
     job_id: &Rev,
     store: &JobStore<R>,
     repo: &radicle::storage::git::Repository,

 use radicle::cob;
 use radicle::cob::patch;
 use radicle::crypto;
 use radicle::node::device::Device;
 use radicle::prelude::*;
 use radicle::storage::git::Repository;

     mut patch: patch::PatchMut<'_, '_, Repository, cob::cache::StoreWriter>,
     title: String,
     description: String,
     signer: &G,
     signer: &Device<G>,
 ) -> anyhow::Result<()>
 where
     G: crypto::Signer,
     G: crypto::signature::Signer<crypto::Signature>,
 {
     let title = if title != patch.title() {
         Some(title)

                 .minimal(true)
                 .context_lines(unified as u32);
             builder::ReviewBuilder::new(patch_id, signer, repository)
             builder::ReviewBuilder::new(patch_id, repository)
                 .hunk(hunk)
                 .verdict(verdict)
                 .run(revision, &mut opts)?;
                 .run(revision, &mut opts, &signer)?;
         }
         Operation::Review { verdict, .. } => {
             let message = options.message.get(REVIEW_HELP_MSG)?;

 use radicle::cob;
 use radicle::cob::patch::{PatchId, Revision, Verdict};
 use radicle::cob::{CodeLocation, CodeRange};
 use radicle::crypto;
 use radicle::git;
 use radicle::node::device::Device;
 use radicle::prelude::*;
 use radicle::storage::git::{cob::DraftStore, Repository};
 use radicle_git_ext::Oid;

 }
 /// Builds a patch review interactively, across multiple files.
 pub struct ReviewBuilder<'a, G> {
 pub struct ReviewBuilder<'a> {
     /// Patch being reviewed.
     patch_id: PatchId,
     /// Signer.
     signer: G,
     /// Stored copy of repository.
     repo: &'a Repository,
     /// Single hunk review.

     verdict: Option<Verdict>,
 }
 impl<'a, G: Signer> ReviewBuilder<'a, G> {
 impl<'a> ReviewBuilder<'a> {
     /// Create a new review builder.
     pub fn new(patch_id: PatchId, signer: G, repo: &'a Repository) -> Self {
     pub fn new(patch_id: PatchId, repo: &'a Repository) -> Self {
         Self {
             patch_id,
             signer,
             repo,
             hunk: None,
             verdict: None,

     }
     /// Run the review builder for the given revision.
     pub fn run(self, revision: &Revision, opts: &mut git::raw::DiffOptions) -> anyhow::Result<()> {
     pub fn run<G>(
         self,
         revision: &Revision,
         opts: &mut git::raw::DiffOptions,
         signer: &Device<G>,
     ) -> anyhow::Result<()>
     where
         G: crypto::signature::Signer<crypto::Signature>,
     {
         let repo = self.repo.raw();
         let signer = &self.signer;
         let base = repo.find_commit((*revision.base()).into())?;
         let patch_id = self.patch_id;
         let tree = {

         self,
         cache::{MigrateCallback, MigrateProgress},
     },
     prelude::NodeId,
     profile,
     storage::ReadRepository,
     Profile,

     repository: &'a R,
 ) -> Result<cob::patch::Cache<cob::patch::Patches<'a, R>, cob::cache::StoreReader>, anyhow::Error>
 where
     R: ReadRepository + cob::Store,
     R: ReadRepository + cob::Store<Namespace = NodeId>,
 {
     profile.patches(repository).map_err(with_hint)
 }

 use radicle::cob::thread::{Comment, CommentId};
 use radicle::cob::Reaction;
 use radicle::crypto::ssh::keystore::MemorySigner;
 use radicle::crypto::{ssh::Keystore, Signer};
 use radicle::crypto::ssh::Keystore;
 use radicle::node::device::{BoxedDevice, Device};
 use radicle::profile::env::RAD_PASSPHRASE;
 use radicle::profile::Profile;

 /// Get the signer. First we try getting it from ssh-agent, otherwise we prompt the user,
 /// if we're connected to a TTY.
 pub fn signer(profile: &Profile) -> anyhow::Result<Box<dyn Signer>> {
 pub fn signer(profile: &Profile) -> anyhow::Result<BoxedDevice> {
     if let Ok(signer) = profile.signer() {
         return Ok(signer);
     }

     spinner.finish();
     Ok(signer.boxed())
     Ok(Device::from(signer).boxed())
 }
 pub fn comment_select(issue: &Issue) -> anyhow::Result<(&CommentId, &Comment)> {

 once_cell = { version = "1.13" }
 radicle-git-ext = { version = "0.8.0", features = ["serde"] }
 serde_json = { version = "1.0" }
 signature = { version = "2.2" }
 thiserror = { version = "1.0" }
 [dependencies.git2]

 [dev-dependencies.radicle-crypto]
 path = "../radicle-crypto"
 version = "0"
 features = ["test"]
 features = ["test", "radicle-git-ext"]

         spec: store::Template<Self::ObjectId>,
     ) -> Result<Entry, Self::StoreError>
     where
         Signer: crypto::Signer,
         Signer: signature::Signer<Self::Signatures>,
     {
         let change::Template {
             type_name,

         let manifest = store::Manifest::new(type_name, Version::default());
         let revision = write_manifest(self, &manifest, embeds, &contents)?;
         let tree = self.find_tree(revision)?;
         let signature = {
             let sig = signer.sign(revision.as_bytes());
             let key = signer.public_key();
             ExtendedSignature::new(*key, sig)
         };
         let signature = signer.sign(revision.as_bytes());
         // Make sure there are no duplicates in the related list.
         related.sort();

         template: Template<Self::ObjectId>,
     ) -> Result<Entry<Self::Parent, Self::ObjectId, Self::Signatures>, Self::StoreError>
     where
         G: crypto::Signer;
         G: signature::Signer<Self::Signatures>;
     /// Load a change entry.
     #[allow(clippy::type_complexity)]

 // Copyright © 2022 The Radicle Link Contributors
 use nonempty::NonEmpty;
 use radicle_crypto::PublicKey;
 use crate::Embed;
 use crate::Evaluate;

     signer: &G,
     resource: Option<Oid>,
     related: Vec<Oid>,
     identifier: &PublicKey,
     identifier: &S::Namespace,
     args: Create,
 ) -> Result<CollaborativeObject<T>, error::Create>
 where
     T: Evaluate<S>,
     S: Store,
     G: crypto::Signer,
     G: signature::Signer<crate::ExtendedSignature>,
 {
     let type_name = args.type_name.clone();
     let version = args.version;