repo: &impl ValidateRepository,

    SignedRefsAt { sigrefs, .. }: SignedRefsAt,

) -> Result<Option<Validations>, radicle::storage::Error> {

    let validations = repo.validate_remote(&remote)?;

    Ok(validations.is_empty().not().then_some(validations))

}

use radicle::git::{fmt::Qualified, Oid};

use radicle::identity::{Did, Doc, DocError};

use radicle::storage;

use radicle::storage::git::Repository;

use radicle::storage::refs::RefsAt;

        self.handle.repository().remote(remote)

    }

        self.state

            .sigrefs

            .keys()

use thiserror::Error;

use crate::cob::ObjectId;

use crate::git;

use crate::git::BranchName;

use crate::identity::doc;

    visibility: Visibility,

    signer: &Device<G>,

    storage: S,

where

    G: crypto::signature::Signer<crypto::Signature>,

    S: WriteStorage,

    url: &git::Url,

    identity: git::Oid,

    signer: &Device<G>,

where

    G: crypto::signature::Signer<crypto::Signature>,

{

use thiserror::Error;

pub use crate::git::Oid;

pub use git::{Validation, Validations};

use crate::cob;

}

/// Project remotes. Tracks the git state of a project.

        Self(iter.into_iter().collect())

    }

}

    fn deref(&self) -> &Self::Target {

        &self.0

    }

}

        Self(remotes)

    }

}

    fn into_iter(self) -> Self::IntoIter {

        self.0.into_iter()

    }

}

        let mut remotes = RandomMap::with_hasher(fastrand::Rng::new().into());

        for (k, v) in other.into_iter() {

/// A project remote.

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]

    /// Git references published under this remote, and their hashes.

    #[serde(flatten)]

}

        Self { refs: refs.into() }

    }

    }

}

    fn deref(&self) -> &Self::Target {

        &self.refs

/// Access the remotes of a repository.

pub trait RemoteRepository {

    /// Get the given remote.

    /// Get all remotes.

    /// Get [`RefsAt`] of all remotes.

    fn remote_refs_at(&self) -> Result<Vec<RefsAt>, refs::Error>;

    ///

    /// Returns any ref found under that remote that isn't signed.

    /// If a signed ref is missing from the repository, an error is returned.

}

/// Allows read-write access to a repository.

/// Allows signing refs.

pub trait SignRepository {

    /// Sign the repository's refs under the `refs/rad/sigrefs` branch.

    where

        G: crypto::signature::Signer<crypto::Signature>;

}

use std::sync::LazyLock;

use std::{fs, io};

use crate::git::canonical::Quorum;

use crate::git::raw::ErrorExt as _;

use crate::identity::crefs::GetCanonicalRefs as _;

    pub fn remotes(

        &self,

        let remotes =

            self.backend

                .references_glob(SIGREFS_GLOB.as_str())?

}

impl RemoteRepository for Repository {

        let mut remotes = Vec::new();

        for remote in Repository::remotes(self)? {

            remotes.push(remote?);

        Ok(Remotes::from_iter(remotes))

    }

        let refs = SignedRefs::load(*remote, self)?;

    }

    fn remote_refs_at(&self) -> Result<Vec<RefsAt>, refs::Error> {

}

impl ValidateRepository for Repository {

        // Contains a copy of the signed refs of this remote.

        let mut signed = BTreeMap::from((*remote.refs).clone());

        let mut failures = Validations::default();

    fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(

        &self,

        signer: &Device<G>,

        let remote = signer.public_key();

        // Ensure the root reference is set, which is checked during sigref verification.

        if self

use crate::storage::Error;

use crate::storage::{

    git::{Remote, Remotes, Validations},

};

use super::{RemoteId, Repository};

    fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(

        &self,

        signer: &Device<G>,

        // Since this is a draft store, we do not actually want to sign the refs.

        // Instead, we just return the existing signed refs.

        let remote = self.repo.remote(signer.public_key())?;

}

impl<R: storage::RemoteRepository> RemoteRepository for DraftStore<'_, R> {

        self.repo.remote(id)

    }

        RemoteRepository::remotes(self.repo)

    }

}

impl<R: storage::ValidateRepository> ValidateRepository for DraftStore<'_, R> {

        self.repo.validate_remote(remote)

    }

}

use std::fmt::Debug;

use std::io;

use std::io::{BufRead, BufReader};

use std::ops::Deref;

use std::str::FromStr;

use crypto::signature;

use radicle_core::NodeId;

use serde::{Deserialize, Serialize};

use thiserror::Error;

                    refs,

                    signature,

                    id: namespace,

                };

                Ok(SignedRefsAt {

                    sigrefs,

    }

}

        signed.refs

    }

}

/// Combination of [`Refs`] and a [`Signature`]. The signature is a cryptographic

/// signature over the refs. This allows us to easily verify if a set of refs

/// came from a particular key.

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]

    /// The signed refs.

    refs: Refs,

    /// The signature of the signer over the refs.

    signature: Signature,

    /// This is the remote under which these refs exist, and the public key of the signer.

    id: PublicKey,

}

    /// Returns the [`NodeId`] of the [`SignedRefs`].

    pub fn id(&self) -> NodeId {

        self.id

            refs,

            signature,

            id: remote,

        })

    }

            refs,

            signature,

            id: remote,

        })

    }

}

    type Target = Refs;

    fn deref(&self) -> &Self::Target {

/// [`Oid`].

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct SignedRefsAt {

    pub at: Oid,

}

}

impl Deref for SignedRefsAt {

    fn deref(&self) -> &Self::Target {

        &self.sigrefs

        refs,

        signature,

        id: *signer.node_id(),

    };

    SignedRefsAt {

        sigrefs,

#[cfg(test)]

mod test;

use std::path::Path;

use crypto::signature::Signer;

                id,

                signature: self.signature,

                refs: self.refs,

            },

        }

    }

use std::path::Path;

use std::str::FromStr;

use crate::git;

use crate::identity::doc::Visibility;

use crate::identity::RepoId;

    path: P,

    storage: &Storage,

    signer: &Device<G>,

where

    P: AsRef<Path>,

    G: crypto::signature::Signer<crypto::Signature>,

pub use crate::git;

use crate::git::fmt;

use crate::identity::doc::{Doc, DocAt, DocError, RawDoc, RepoId};

use crate::node::device::Device;

use crate::node::NodeId;

}

impl RemoteRepository for MockRepository {

        self.remotes

            .get(id)

            .map(|refs| Remote {

            .ok_or(refs::Error::InvalidRef)

    }

        Ok(self

            .remotes

            .iter()

}

impl ValidateRepository for MockRepository {

        Ok(Validations::default())

    }

}

    fn sign_refs<G: crypto::signature::Signer<crypto::Signature>>(

        &self,

        _signer: &Device<G>,

        todo!()

    }

}