version = "1.0.64"

checksum = "b9a8f622bcf6ff3df478e9deba3e03e4e04b300f8e6a139e192c05fa3490afc7"

name = "bs58"

version = "0.4.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"

[[package]]

version = "0.10.3"

checksum = "f2fb860ca6fafa5552fb6d0e816a69c8e49f0908bf524e30a90d97c85892d506"

version = "0.2.132"

checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"

version = "1.14.0"

checksum = "2f7254b99e31cad77da24b08ebf628882739a608578bb1bcdfc1f9c21260d7c0"

 "bs58",

 "ed25519-compact",

 "git-ref-format",

 "git-url",

 "git2",

 "multibase",

 "olpc-cjson",

 "once_cell",

 "radicle-git-ext",

 "sha2 0.10.5",

 "siphasher",

version = "0.6.3"

checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"

version = "0.10.5"

checksum = "cf9db03534dff993187064c4e0c05a5708d2a9728ace9a8959b77bedf415dac5"

 "digest 0.10.3",

version = "1.0.99"

checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"

version = "1.0.34"

checksum = "8c1b05ca9d106ba7d2e31a9dab4a64e7be2cce415321966ea3132c49a656e252"

version = "1.0.34"

checksum = "e8f2591983642de85c921015f3f070c665a197ed69e417af436115e3a1407487"

version = "1.0.3"

checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"

version = "0.1.21"

checksum = "854cbdc4f7bc6ae19c820d44abdc3277ac3e1b2b93db20a636825d9322fb60e6"

members = ["radicle-node"]

bs58 = { version = "0.4.0" }

ed25519-compact = { version = "1.0.12", features = ["pem"] }

git-ref-format = { version = "0", features = ["serde", "macro"] }

git2 = { version = "0.13" }

git-url = { version = "0.3.5", features = ["serde1"] }

multibase = { version = "0.9.1" }

once_cell = { version = "1.13" }

olpc-cjson = { version = "0.1.1" }

sha2 = { version = "0.10.2" }

siphasher = { version = "0.3.10" }

radicle-git-ext = { version = "0", features = ["serde"] }

//! Useful collections for peer-to-peer networking.

use siphasher::sip::SipHasher13;

/// A `HashMap` which uses [`fastrand::Rng`] for its random state.

pub type HashMap<K, V> = std::collections::HashMap<K, V, RandomState>;

/// A `HashSet` which uses [`fastrand::Rng`] for its random state.

pub type HashSet<K> = std::collections::HashSet<K, RandomState>;

/// Random hasher state.

#[derive(Clone)]

pub struct RandomState {

    key1: u64,

    key2: u64,

}

impl Default for RandomState {

    fn default() -> Self {

        Self::new(fastrand::Rng::new())

    }

}

impl RandomState {

    fn new(rng: fastrand::Rng) -> Self {

        Self {

            key1: rng.u64(..),

            key2: rng.u64(..),

        }

    }

}

impl std::hash::BuildHasher for RandomState {

    type Hasher = SipHasher13;

    fn build_hasher(&self) -> Self::Hasher {

        SipHasher13::new_with_keys(self.key1, self.key2)

    }

}

impl From<fastrand::Rng> for RandomState {

    fn from(rng: fastrand::Rng) -> Self {

        Self::new(rng)

    }

}

use std::sync::Arc;

use std::{fmt, ops::Deref, str::FromStr};

use ed25519_compact as ed25519;

use serde::{Deserialize, Serialize};

use thiserror::Error;

pub use ed25519::{Error, KeyPair, Seed};

/// Verified (used as type witness).

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

pub struct Verified;

/// Unverified (used as type witness).

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

pub struct Unverified;

pub trait Signer: Send + Sync {

    /// Return this signer's public/verification key.

    fn public_key(&self) -> &PublicKey;

    /// Sign a message and return the signature.

    fn sign(&self, msg: &[u8]) -> Signature;

}

impl<T> Signer for Arc<T>

where

    T: Signer + ?Sized,

{

    fn sign(&self, msg: &[u8]) -> Signature {

        self.deref().sign(msg)

    }

    fn public_key(&self) -> &PublicKey {

        self.deref().public_key()

    }

}

impl<T> Signer for &T

where

    T: Signer + ?Sized,

{

    fn sign(&self, msg: &[u8]) -> Signature {

        self.deref().sign(msg)

    }

    fn public_key(&self) -> &PublicKey {

        self.deref().public_key()

    }

}

/// Cryptographic signature.

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

pub struct Signature(pub ed25519::Signature);

impl fmt::Display for Signature {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        let base = multibase::Base::Base58Btc;

        write!(f, "{}", multibase::encode(base, self.deref()))

    }

}

impl fmt::Debug for Signature {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "Signature({})", self)

    }

}

#[derive(Error, Debug)]

pub enum SignatureError {

    #[error("invalid multibase string: {0}")]

    Multibase(#[from] multibase::Error),

    #[error("invalid signature: {0}")]

    Invalid(#[from] ed25519::Error),

}

impl From<ed25519::Signature> for Signature {

    fn from(other: ed25519::Signature) -> Self {

        Self(other)

    }

}

impl FromStr for Signature {

    type Err = SignatureError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        let (_, bytes) = multibase::decode(s)?;

        let sig = ed25519::Signature::from_slice(bytes.as_slice())?;

        Ok(Self(sig))

    }

}

impl Deref for Signature {

    type Target = ed25519::Signature;

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

        &self.0

    }

}

impl From<[u8; 64]> for Signature {

    fn from(bytes: [u8; 64]) -> Self {

        Self(ed25519::Signature::new(bytes))

    }

}

impl TryFrom<&[u8]> for Signature {

    type Error = ed25519::Error;

    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {

        ed25519::Signature::from_slice(bytes).map(Self)

    }

}

/// The public/verification key.

#[derive(Serialize, Deserialize, Eq, Copy, Clone)]

#[serde(into = "String", try_from = "String")]

pub struct PublicKey(pub ed25519::PublicKey);

/// The private/signing key.

pub type SecretKey = ed25519::SecretKey;

#[derive(Error, Debug)]

pub enum PublicKeyError {

    #[error("invalid length {0}")]

    InvalidLength(usize),

    #[error("invalid multibase string: {0}")]

    Multibase(#[from] multibase::Error),

    #[error("invalid key: {0}")]

    InvalidKey(#[from] ed25519::Error),

}

impl std::hash::Hash for PublicKey {

    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

        self.0.deref().hash(state)

    }

}

impl fmt::Display for PublicKey {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "{}", self.to_human())

    }

}

impl From<PublicKey> for String {

    fn from(other: PublicKey) -> Self {

        other.to_human()

    }

}

impl fmt::Debug for PublicKey {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "PublicKey({})", self)

    }

}

impl PartialEq for PublicKey {

    fn eq(&self, other: &Self) -> bool {

        self.0 == other.0

    }

}

impl From<ed25519::PublicKey> for PublicKey {

    fn from(other: ed25519::PublicKey) -> Self {

        Self(other)

    }

}

impl TryFrom<[u8; 32]> for PublicKey {

    type Error = ed25519::Error;

    fn try_from(other: [u8; 32]) -> Result<Self, Self::Error> {

        Ok(Self(ed25519::PublicKey::new(other)))

    }

}

impl PublicKey {

    pub fn to_human(&self) -> String {

        multibase::encode(multibase::Base::Base58Btc, self.0.deref())

    }

}

impl FromStr for PublicKey {

    type Err = PublicKeyError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        let (_, bytes) = multibase::decode(s)?;

        let array: [u8; 32] = bytes

            .try_into()

            .map_err(|v: Vec<u8>| PublicKeyError::InvalidLength(v.len()))?;

        let key = ed25519::PublicKey::new(array);

        Ok(Self(key))

    }

}

impl TryFrom<String> for PublicKey {

    type Error = PublicKeyError;

    fn try_from(value: String) -> Result<Self, Self::Error> {

        Self::from_str(&value)

    }

}

impl Deref for PublicKey {

    type Target = ed25519::PublicKey;

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

        &self.0

    }

}

#[cfg(test)]

mod test {

    use crate::crypto::PublicKey;

    use quickcheck_macros::quickcheck;

    use std::str::FromStr;

    #[quickcheck]

    fn prop_encode_decode(input: PublicKey) {

        let encoded = input.to_string();

        let decoded = PublicKey::from_str(&encoded).unwrap();

        assert_eq!(input, decoded);

    }

}

use std::path::Path;

use std::str::FromStr;

use git_ref_format as format;

use once_cell::sync::Lazy;

use crate::collections::HashMap;

use crate::crypto::PublicKey;

use crate::storage::refs::Refs;

use crate::storage::RemoteId;

pub use ext::Error;

pub use ext::Oid;

pub use git_ref_format as fmt;

pub use git_ref_format::{refname, RefStr, RefString};

pub use git_url as url;

pub use git_url::Url;

pub use radicle_git_ext as ext;

/// Default port of the `git` transport protocol.

pub const PROTOCOL_PORT: u16 = 9418;

#[derive(thiserror::Error, Debug)]

pub enum RefError {

    #[error("invalid ref name '{0}'")]

    InvalidName(format::RefString),

    #[error("invalid ref format: {0}")]

    Format(#[from] format::Error),

}

#[derive(thiserror::Error, Debug)]

pub enum ListRefsError {

    #[error("git error: {0}")]

    Git(#[from] git2::Error),

    #[error("invalid ref: {0}")]

    InvalidRef(#[from] RefError),

}

pub mod refs {

    use super::*;

    /// Where project information is kept.

    pub static IDENTITY_BRANCH: Lazy<RefString> = Lazy::new(|| refname!("radicle/id"));

    pub mod storage {

        use super::*;

        pub fn branch(remote: &RemoteId, branch: &str) -> String {

            format!("refs/remotes/{remote}/heads/{branch}")

        }

        /// Get the branch used to track project information.

        pub fn id(remote: &RemoteId) -> String {

            branch(remote, &IDENTITY_BRANCH)

        }

    }

    pub mod workdir {

        pub fn branch(branch: &str) -> String {

            format!("refs/heads/{branch}")

        }

        pub fn note(name: &str) -> String {

            format!("refs/notes/{name}")

        }

        pub fn remote_branch(remote: &str, branch: &str) -> String {

            format!("refs/remotes/{remote}/{branch}")

        }

        pub fn tag(name: &str) -> String {

            format!("refs/tags/{name}")

        }

    }

}

/// List remote refs of a project, given the remote URL.

pub fn remote_refs(url: &Url) -> Result<HashMap<RemoteId, Refs>, ListRefsError> {

    let url = url.to_string();

    let mut remotes = HashMap::default();

    let mut remote = git2::Remote::create_detached(&url)?;

    remote.connect(git2::Direction::Fetch)?;

    let refs = remote.list()?;

    for r in refs {

        let (id, refname) = parse_ref::<PublicKey>(r.name())?;

        let entry = remotes.entry(id).or_insert_with(Refs::default);

        entry.insert(refname, r.oid().into());

    }

    Ok(remotes)

}

/// Parse a ref string.

pub fn parse_ref<T: FromStr>(s: &str) -> Result<(T, format::RefString), RefError> {

    let input = format::RefStr::try_from_str(s)?;

    let suffix = input

        .strip_prefix(format::refname!("refs/remotes"))

        .ok_or_else(|| RefError::InvalidName(input.to_owned()))?;

    let mut components = suffix.components();

    let id = components

        .next()

        .ok_or_else(|| RefError::InvalidName(input.to_owned()))?;

    let id = T::from_str(&id.to_string()).map_err(|_| RefError::InvalidName(input.to_owned()))?;

    let refstr = components.collect::<format::RefString>();

    Ok((id, refstr))

}

/// Create an initial empty commit.

pub fn initial_commit<'a>(

    repo: &'a git2::Repository,

    sig: &git2::Signature,

) -> Result<git2::Commit<'a>, git2::Error> {

    let tree_id = repo.index()?.write_tree()?;

    let tree = repo.find_tree(tree_id)?;

    let oid = repo.commit(None, sig, sig, "Initial commit", &tree, &[])?;

    let commit = repo.find_commit(oid).unwrap();

    Ok(commit)

}

/// Create a commit and update the given ref to it.

pub fn commit<'a>(

    repo: &'a git2::Repository,

    parent: &'a git2::Commit,

    target: &RefStr,

    message: &str,

    user: &str,

) -> Result<git2::Commit<'a>, git2::Error> {

    let sig = git2::Signature::now(user, "anonymous@radicle.xyz")?;

    let tree_id = repo.index()?.write_tree()?;

    let tree = repo.find_tree(tree_id)?;

    let oid = repo.commit(Some(target.as_str()), &sig, &sig, message, &tree, &[parent])?;

    let commit = repo.find_commit(oid).unwrap();

    Ok(commit)

}

/// Push the refs to the radicle remote.

pub fn push(repo: &git2::Repository) -> Result<(), git2::Error> {

    let mut remote = repo.find_remote("rad")?;

    let refspecs = remote.push_refspecs().unwrap();

    let refspec = refspecs.into_iter().next().unwrap().unwrap();

    // The `git2` crate doesn't seem to support push refspecs with '*' in them,

    // so we manually replace it with the current branch.

    let head = repo.head().unwrap();

    let branch = head.shorthand().unwrap();

    let refspec = refspec.replace('*', branch);

    remote.push::<&str>(&[&refspec], None)

}

/// Get the repository head.

pub fn head(repo: &git2::Repository) -> Result<git2::Commit, git2::Error> {

    let head = repo.head()?.peel_to_commit()?;

    Ok(head)

}

/// Write a tree with the given blob at the given path.

pub fn write_tree<'r>(

    path: &Path,

    bytes: &[u8],

    repo: &'r git2::Repository,

) -> Result<git2::Tree<'r>, Error> {

    let blob_id = repo.blob(bytes)?;

    let mut builder = repo.treebuilder(None)?;

    builder.insert(path, blob_id, 0o100_644)?;

    let tree_id = builder.write()?;

    let tree = repo.find_tree(tree_id)?;

    Ok(tree)

}

/// Configure a repository's radicle remote.

///

/// Takes the repository in which to configure the remote, the name of the remote, the public

/// key of the remote, and the path to the remote repository on the filesystem.

pub fn configure_remote<'r>(

    repo: &'r git2::Repository,

    remote_name: &str,

    remote_id: &RemoteId,

    remote_path: &Path,

) -> Result<git2::Remote<'r>, git2::Error> {

    let url = Url {

        scheme: git_url::Scheme::File,

        path: remote_path.to_string_lossy().to_string().into(),

        ..Url::default()

    };

    let fetch = format!("+refs/remotes/{remote_id}/heads/*:refs/remotes/rad/*");

    let push = format!("refs/heads/*:refs/remotes/{remote_id}/heads/*");

    let remote = repo.remote_with_fetch(remote_name, url.to_string().as_str(), &fetch)?;

    repo.remote_add_push(remote_name, &push)?;

    Ok(remote)

}

/// Set the upstream of the given branch to the given remote.

///

/// This writes to the `config` directly. The entry will look like the

/// following:

///

/// ```text

/// [branch "main"]

///     remote = rad

///     merge = refs/heads/main

/// ```

pub fn set_upstream(

    repo: &git2::Repository,

    remote: &str,

    branch: &str,

    merge: &str,

) -> Result<(), git2::Error> {

    let mut config = repo.config()?;

    let branch_remote = format!("branch.{}.remote", branch);

    let branch_merge = format!("branch.{}.merge", branch);

    config.remove_multivar(&branch_remote, ".*").or_else(|e| {

        if ext::is_not_found_err(&e) {

            Ok(())

        } else {

            Err(e)

        }

    })?;

    config.remove_multivar(&branch_merge, ".*").or_else(|e| {

        if ext::is_not_found_err(&e) {

            Ok(())

        } else {

            Err(e)

        }

    })?;

    config.set_multivar(&branch_remote, ".*", remote)?;

    config.set_multivar(&branch_merge, ".*", merge)?;

    Ok(())

}

use std::{convert::TryInto, fmt};

use serde::{Deserialize, Serialize};

use sha2::{

    digest::{generic_array::GenericArray, OutputSizeUser},

    Digest as _, Sha256,

};

use thiserror::Error;

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

pub enum DecodeError {

    #[error("invalid digest length {0}")]

    InvalidLength(usize),

}

/// A SHA-256 hash.

#[derive(Serialize, Deserialize, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

pub struct Digest([u8; 32]);

impl Digest {

    pub fn new(bytes: impl AsRef<[u8]>) -> Self {

        Self::from(Sha256::digest(bytes))

    }

}

impl AsRef<[u8; 32]> for Digest {

    fn as_ref(&self) -> &[u8; 32] {

        &self.0

    }

}

impl fmt::Debug for Digest {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "Hash({})", self)

    }

}

impl fmt::Display for Digest {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        for byte in &self.0 {

            write!(f, "{:02x}", byte)?;

        }

        Ok(())

    }

}

impl From<[u8; 32]> for Digest {

    fn from(bytes: [u8; 32]) -> Self {

        Self(bytes)

    }

}

impl TryFrom<&[u8]> for Digest {

    type Error = DecodeError;

    fn try_from(bytes: &[u8]) -> Result<Self, DecodeError> {

        let bytes: [u8; 32] = bytes

            .try_into()

            .map_err(|_| DecodeError::InvalidLength(bytes.len()))?;

        Ok(bytes.into())

    }

}

impl From<GenericArray<u8, <Sha256 as OutputSizeUser>::OutputSize>> for Digest {

    fn from(array: GenericArray<u8, <Sha256 as OutputSizeUser>::OutputSize>) -> Self {

        Self(array.into())

    }

}

pub mod doc;

use std::ops::Deref;

use std::path::PathBuf;

use std::{ffi::OsString, fmt, str::FromStr};

use serde::{Deserialize, Serialize};

use thiserror::Error;

use crate::crypto;

use crate::crypto::Verified;

use crate::git;

use crate::serde_ext;

use crate::storage::Remotes;

pub use crypto::PublicKey;

pub use doc::{Delegate, Doc};

#[derive(Error, Debug)]

pub enum IdError {

    #[error("invalid git object id: {0}")]

    InvalidOid(#[from] git2::Error),

    #[error(transparent)]

    Multibase(#[from] multibase::Error),

}

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

pub struct Id(git::Oid);

impl fmt::Display for Id {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.write_str(&self.to_human())

    }

}

impl fmt::Debug for Id {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "Id({})", self)

    }

}

impl Id {

    pub fn to_human(&self) -> String {

        multibase::encode(multibase::Base::Base58Btc, self.0.as_bytes())

    }

    pub fn from_human(s: &str) -> Result<Self, IdError> {

        let (_, bytes) = multibase::decode(s)?;

        let array: git::Oid = bytes.as_slice().try_into()?;

        Ok(Self(array))

    }

}

impl FromStr for Id {

    type Err = IdError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {

        Self::from_human(s)

    }

}

impl TryFrom<OsString> for Id {

    type Error = IdError;

    fn try_from(value: OsString) -> Result<Self, Self::Error> {

        let string = value.to_string_lossy();

        Self::from_str(&string)

    }

}

impl From<git::Oid> for Id {

    fn from(oid: git::Oid) -> Self {

        Self(oid)

    }

}

impl From<git2::Oid> for Id {

    fn from(oid: git2::Oid) -> Self {

        Self(oid.into())

    }

}

impl Deref for Id {

    type Target = git::Oid;

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

        &self.0

    }

}

impl serde::Serialize for Id {

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

        S: serde::Serializer,

    {

        serde_ext::string::serialize(self, serializer)

    }

}

impl<'de> serde::Deserialize<'de> for Id {

    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

    where

        D: serde::Deserializer<'de>,

    {

        serde_ext::string::deserialize(deserializer)

    }

}

#[derive(Error, Debug)]

pub enum DidError {

    #[error("invalid did: {0}")]

    Did(String),

    #[error("invalid public key: {0}")]

    PublicKey(#[from] crypto::PublicKeyError),

}

#[derive(Serialize, Deserialize, PartialEq, Eq, Hash, Clone)]

#[serde(into = "String", try_from = "String")]

pub struct Did(crypto::PublicKey);

impl Did {

    pub fn encode(&self) -> String {

        format!("did:key:{}", self.0.to_human())

    }

    pub fn decode(input: &str) -> Result<Self, DidError> {

        let key = input

            .strip_prefix("did:key:")

            .ok_or_else(|| DidError::Did(input.to_owned()))?;

        crypto::PublicKey::from_str(key)

            .map(Did)

            .map_err(DidError::from)

    }

}

impl From<crypto::PublicKey> for Did {

    fn from(key: crypto::PublicKey) -> Self {

        Self(key)

    }

}

impl From<Did> for String {

    fn from(other: Did) -> Self {

        other.encode()

    }

}

impl TryFrom<String> for Did {

    type Error = DidError;

    fn try_from(value: String) -> Result<Self, Self::Error> {

        Self::decode(&value)

    }

}

impl fmt::Display for Did {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "{}", self.encode())

    }

}

impl fmt::Debug for Did {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "Did({:?})", self.to_string())

    }

}

impl Deref for Did {

    type Target = PublicKey;

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

        &self.0

    }

}

/// A stored and verified project.

#[derive(Debug, Clone)]

pub struct Project {

    /// The project identifier.

    pub id: Id,

    /// The latest project identity document.

    pub doc: Doc<Verified>,

    /// The project remotes.

    pub remotes: Remotes<Verified>,

    /// On-disk file path for this project's repository.

    pub path: PathBuf,

}

impl Project {

    pub fn delegate(&mut self, name: String, key: crypto::PublicKey) -> bool {

        self.doc.delegate(Delegate {

            name,

            id: Did::from(key),

        })

    }

}

impl Deref for Project {

    type Target = Doc<Verified>;

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

        &self.doc

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::crypto::PublicKey;

    use quickcheck_macros::quickcheck;

    use std::collections::HashSet;

    #[quickcheck]

    fn prop_key_equality(a: PublicKey, b: PublicKey) {

        assert_ne!(a, b);

        let mut hm = HashSet::new();

        assert!(hm.insert(a));

        assert!(hm.insert(b));

        assert!(!hm.insert(a));

        assert!(!hm.insert(b));

    }

    #[quickcheck]

    fn prop_from_str(input: Id) {

        let encoded = input.to_string();

        let decoded = Id::from_str(&encoded).unwrap();

        assert_eq!(input, decoded);

    }

    #[quickcheck]

    fn prop_json_eq_str(pk: PublicKey, proj: Id, did: Did) {

        let json = serde_json::to_string(&pk).unwrap();

        assert_eq!(format!("\"{}\"", pk), json);

        let json = serde_json::to_string(&proj).unwrap();

        assert_eq!(format!("\"{}\"", proj), json);

        let json = serde_json::to_string(&did).unwrap();

        assert_eq!(format!("\"{}\"", did), json);

    }

}

use std::collections::{BTreeMap, HashMap};

use std::fmt::Write as _;

use std::io;

use std::marker::PhantomData;

use std::ops::Deref;

use std::path::Path;

use nonempty::NonEmpty;

use once_cell::sync::Lazy;

use radicle_git_ext::Oid;

use serde::{Deserialize, Serialize};

use thiserror::Error;

use crate::crypto;

use crate::crypto::{Signature, Unverified, Verified};

use crate::git;

use crate::identity::{Did, Id};

use crate::storage::git::trailers;

use crate::storage::{BranchName, ReadRepository, RemoteId, WriteRepository, WriteStorage};

pub use crypto::PublicKey;

/// Untrusted, well-formed input.

#[derive(Clone, Copy, Debug)]

pub struct Untrusted;

/// Signed by quorum of the previous delegation.

#[derive(Clone, Copy, Debug)]

pub struct Trusted;

pub static PATH: Lazy<&Path> = Lazy::new(|| Path::new("radicle.json"));

pub const MAX_STRING_LENGTH: usize = 255;

pub const MAX_DELEGATES: usize = 255;

#[derive(Error, Debug)]

pub enum Error {

    #[error("json: {0}")]

    Json(#[from] serde_json::Error),

    #[error("i/o: {0}")]

    Io(#[from] io::Error),

    #[error("verification: {0}")]

    Verification(#[from] VerificationError),

    #[error("git: {0}")]

    Git(#[from] git::Error),

    #[error("git: {0}")]

    RawGit(#[from] git2::Error),

}

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

pub struct Delegate {

    pub name: String,

    pub id: Did,

}

impl Delegate {

    fn matches(&self, key: &PublicKey) -> bool {

        &self.id.0 == key

    }

}

impl From<Delegate> for PublicKey {

    fn from(delegate: Delegate) -> Self {

        delegate.id.0

    }

}

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

#[serde(rename_all = "kebab-case")]

pub struct Payload {

    pub name: String,

    pub description: String,    // TODO: Make optional.

    pub default_branch: String, // TODO: Make optional.

}

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

#[serde(transparent)]

// TODO: Restrict values.

pub struct Namespace(String);

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

pub struct Doc<V> {

    #[serde(rename = "xyz.radicle.project")]

    pub payload: Payload,

    #[serde(flatten)]

    pub extensions: BTreeMap<Namespace, serde_json::Value>,

    pub delegates: NonEmpty<Delegate>,

    pub threshold: usize,

    verified: PhantomData<V>,

}

impl Doc<Verified> {

    pub fn encode(&self) -> Result<(git::Oid, Vec<u8>), Error> {

        let mut buf = Vec::new();

        let mut serializer =

            serde_json::Serializer::with_formatter(&mut buf, olpc_cjson::CanonicalFormatter::new());

        self.serialize(&mut serializer)?;

        let oid = git2::Oid::hash_object(git2::ObjectType::Blob, &buf)?;

        Ok((oid.into(), buf))

    }

    /// Attempt to add a new delegate to the document. Returns `true` if it wasn't there before.

    pub fn delegate(&mut self, delegate: Delegate) -> bool {

        if self.delegates.iter().all(|d| d.id != delegate.id) {

            self.delegates.push(delegate);

            return true;

        }

        false

    }

    pub fn sign<G: crypto::Signer>(&self, signer: G) -> Result<(git::Oid, Signature), Error> {

        let (oid, bytes) = self.encode()?;

        let sig = signer.sign(&bytes);

        Ok((oid, sig))

    }

    pub fn create<'r, S: WriteStorage<'r>>(

        &self,

        remote: &RemoteId,

        msg: &str,

        storage: &'r S,

    ) -> Result<(Id, git::Oid, S::Repository), Error> {

        // You can checkout this branch in your working copy with:

        //

        //      git fetch rad

        //      git checkout -b radicle/id remotes/rad/radicle/id

        //

        let (doc_oid, doc) = self.encode()?;

        let id = Id::from(doc_oid);

        let repo = storage.repository(&id).unwrap();

        let tree = git::write_tree(*PATH, doc.as_slice(), repo.raw())?;

        let oid = Doc::commit(remote, &tree, msg, &[], repo.raw())?;

        drop(tree);

        Ok((id, oid, repo))

    }

    pub fn update<'r, R: WriteRepository<'r>>(

        &self,

        remote: &RemoteId,

        msg: &str,

        signatures: &[(&PublicKey, Signature)],

        repo: &R,

    ) -> Result<git::Oid, Error> {

        let mut msg = format!("{msg}\n\n");

        for (key, sig) in signatures {

            writeln!(&mut msg, "{}: {key} {sig}", trailers::SIGNATURE_TRAILER)

                .expect("in-memory writes don't fail");

        }

        let (_, doc) = self.encode()?;

        let tree = git::write_tree(*PATH, doc.as_slice(), repo.raw())?;

        let id_ref = git::refs::storage::id(remote);

        let head = repo.raw().find_reference(&id_ref)?.peel_to_commit()?;

        let oid = Doc::commit(remote, &tree, &msg, &[&head], repo.raw())?;

        Ok(oid)

    }

    fn commit(

        remote: &RemoteId,

        tree: &git2::Tree,

        msg: &str,

        parents: &[&git2::Commit],

        repo: &git2::Repository,

    ) -> Result<git::Oid, Error> {

        let sig = repo

            .signature()

            .or_else(|_| git2::Signature::now("radicle", remote.to_string().as_str()))?;

        let id_ref = git::refs::storage::id(remote);

        let oid = repo.commit(Some(&id_ref), &sig, &sig, msg, tree, parents)?;

        Ok(oid.into())

    }

}

impl<V> Deref for Doc<V> {

    type Target = Payload;

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

        &self.payload

    }

}

#[derive(Error, Debug)]

pub enum VerificationError {

    #[error("invalid name: {0}")]

    Name(&'static str),

    #[error("invalid description: {0}")]

    Description(&'static str),

    #[error("invalid default branch: {0}")]

    DefaultBranch(&'static str),

    #[error("invalid delegates: {0}")]

    Delegates(&'static str),

    #[error("invalid version `{0}`")]

    Version(u32),

    #[error("invalid parent: {0}")]

    Parent(&'static str),

    #[error("invalid threshold `{0}`: {1}")]

    Threshold(usize, &'static str),

}

impl Doc<Unverified> {

    pub fn initial(

        name: String,

        description: String,

        default_branch: BranchName,

        delegate: Delegate,

    ) -> Self {

        Self {

            payload: Payload {

                name,

                description,

                default_branch,

            },

            extensions: BTreeMap::new(),

            delegates: NonEmpty::new(delegate),

            threshold: 1,

            verified: PhantomData,

        }

    }

    pub fn new(

        name: String,

        description: String,

        default_branch: BranchName,

        delegates: NonEmpty<Delegate>,

        threshold: usize,

    ) -> Self {

        Self {

            payload: Payload {

                name,

                description,

                default_branch,

            },

            extensions: BTreeMap::new(),

            delegates,

            threshold,

            verified: PhantomData,

        }

    }

    pub fn from_json(bytes: &[u8]) -> Result<Self, serde_json::Error> {

        serde_json::from_slice(bytes)

    }

    pub fn verified(self) -> Result<Doc<Verified>, VerificationError> {

        if self.name.is_empty() {

            return Err(VerificationError::Name("name cannot be empty"));

        }

        if self.name.len() > MAX_STRING_LENGTH {

            return Err(VerificationError::Name("name cannot exceed 255 bytes"));

        }

        if self.description.len() > MAX_STRING_LENGTH {

            return Err(VerificationError::Description(

                "description cannot exceed 255 bytes",

            ));

        }

        if self.delegates.len() > MAX_DELEGATES {

            return Err(VerificationError::Delegates(

                "number of delegates cannot exceed 255",

            ));

        }

        if self

            .delegates

            .iter()

            .any(|d| d.name.is_empty() || d.name.len() > MAX_STRING_LENGTH)

        {

            return Err(VerificationError::Delegates(

                "delegate name must not be empty and must not exceed 255 bytes",

            ));

        }

        if self.delegates.is_empty() {

            return Err(VerificationError::Delegates(

                "delegate list cannot be empty",

            ));

        }

        if self.default_branch.is_empty() {

            return Err(VerificationError::DefaultBranch(

                "default branch cannot be empty",

            ));

        }

        if self.default_branch.len() > MAX_STRING_LENGTH {

            return Err(VerificationError::DefaultBranch(

                "default branch cannot exceed 255 bytes",

            ));

        }

        if self.threshold > self.delegates.len() {

            return Err(VerificationError::Threshold(

                self.threshold,

                "threshold cannot exceed number of delegates",

            ));

        }

        if self.threshold == 0 {

            return Err(VerificationError::Threshold(

                self.threshold,

                "threshold cannot be zero",

            ));

        }

        Ok(Doc {

            payload: self.payload,

            extensions: self.extensions,

            delegates: self.delegates,

            threshold: self.threshold,

            verified: PhantomData,

        })

    }

    pub fn blob_at<'r, R: ReadRepository<'r>>(

        commit: Oid,

        repo: &R,

    ) -> Result<Option<git2::Blob>, git::Error> {

        match repo.blob_at(commit, Path::new(&*PATH)) {

            Err(git::ext::Error::NotFound(_)) => Ok(None),

            Err(e) => Err(e),

            Ok(blob) => Ok(Some(blob)),

        }

    }

    pub fn load_at<'r, R: ReadRepository<'r>>(

        commit: Oid,

        repo: &R,

    ) -> Result<Option<(Self, Oid)>, git::Error> {

        if let Some(blob) = Self::blob_at(commit, repo)? {

            let doc = Doc::from_json(blob.content()).unwrap();

            return Ok(Some((doc, blob.id().into())));

        }

        Ok(None)

    }

    pub fn load<'r, R: ReadRepository<'r>>(

        remote: &RemoteId,

        repo: &R,

    ) -> Result<Option<(Self, Oid)>, git::Error> {

        if let Some(oid) = Self::head(remote, repo)? {

            Self::load_at(oid, repo)

        } else {

            Ok(None)

        }

    }

}

impl<V> Doc<V> {

    pub fn head<'r, R: ReadRepository<'r>>(

        remote: &RemoteId,

        repo: &R,

    ) -> Result<Option<Oid>, git::Error> {

        let head = &git::refname!("heads").join(&*git::refs::IDENTITY_BRANCH);

        if let Some(oid) = repo.reference_oid(remote, head)? {

            Ok(Some(oid))

        } else {

            Ok(None)

        }

    }

}

#[derive(Error, Debug)]

pub enum IdentityError {

    #[error("git: {0}")]

    GitRaw(#[from] git2::Error),

    #[error("git: {0}")]

    Git(#[from] git::Error),

    #[error("verification: {0}")]

    Verification(#[from] VerificationError),

    #[error("root hash `{0}` does not match project")]

    MismatchedRoot(Oid),

    #[error("commit signature for {0} is invalid: {1}")]

    InvalidSignature(PublicKey, crypto::Error),

    #[error("quorum not reached: {0} signatures for a threshold of {1}")]

    QuorumNotReached(usize, usize),

}

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

pub struct Identity<I> {

    /// The head of the identity branch. This points to a commit that

    /// contains the current document blob.

    pub head: Oid,

    /// The canonical identifier for this identity.

    /// This is the object id of the initial document blob.

    pub root: I,

    /// The object id of the current document blob.

    pub current: Oid,

    /// Revision number. The initial document has a revision of `0`.

    pub revision: u32,

    /// The current document.

    pub doc: Doc<Verified>,

    /// Signatures over this identity.

    pub signatures: HashMap<PublicKey, Signature>,

}

impl Identity<Oid> {

    pub fn verified(self, id: Id) -> Result<Identity<Id>, IdentityError> {

        // The root hash must be equal to the id.

        if self.root != *id {

            return Err(IdentityError::MismatchedRoot(self.root));

        }

        Ok(Identity {

            root: id,

            head: self.head,

            current: self.current,

            revision: self.revision,

            doc: self.doc,

            signatures: self.signatures,

        })

    }

}

impl Identity<Untrusted> {

    pub fn load<'r, R: ReadRepository<'r>>(

        remote: &RemoteId,

        repo: &R,

    ) -> Result<Option<Identity<Oid>>, IdentityError> {

        if let Some(head) = Doc::<Untrusted>::head(remote, repo)? {

            let mut history = repo.revwalk(head)?.collect::<Vec<_>>();

            // Retrieve root document.

            let root_oid = history.pop().unwrap()?.into();

            let root_blob = Doc::blob_at(root_oid, repo)?.unwrap();

            let root: git::Oid = root_blob.id().into();

            let trusted = Doc::from_json(root_blob.content()).unwrap();

            let revision = history.len() as u32;

            let mut trusted = trusted.verified()?;

            let mut current = root;

            let mut signatures = Vec::new();

            // Traverse the history chronologically.

            for oid in history.into_iter().rev() {

                let oid = oid?;

                let blob = Doc::blob_at(oid.into(), repo)?.unwrap();

                let untrusted = Doc::from_json(blob.content()).unwrap();

                let untrusted = untrusted.verified()?;

                let commit = repo.commit(oid.into())?.unwrap();

                let msg = commit.message_raw().unwrap();

                // Keys that signed the *current* document version.

                signatures = trailers::parse_signatures(msg).unwrap();

                for (pk, sig) in &signatures {

                    if let Err(err) = pk.verify(blob.content(), sig) {

                        return Err(IdentityError::InvalidSignature(*pk, err));

                    }

                }

                // Check that enough delegates signed this next version.

                let quorum = signatures

                    .iter()

                    .filter(|(key, _)| trusted.delegates.iter().any(|d| d.matches(key)))

                    .count();

                if quorum < trusted.threshold {

                    return Err(IdentityError::QuorumNotReached(quorum, trusted.threshold));

                }

                trusted = untrusted;

                current = blob.id().into();

            }

            return Ok(Some(Identity {

                root,

                head,

                current,

                revision,

                doc: trusted,

                signatures: signatures.into_iter().collect(),

            }));

        }

        Ok(None)

    }

}

#[cfg(test)]

mod test {

    use crate::prelude::Signer;

    use crate::rad;

    use crate::storage::git::Storage;

    use crate::storage::{ReadStorage, WriteStorage};

    use crate::test::{crypto, fixtures};

    use super::*;

    use quickcheck_macros::quickcheck;

    #[test]

    fn test_valid_identity() {

        let tempdir = tempfile::tempdir().unwrap();

        let mut rng = fastrand::Rng::new();

        let alice = crypto::MockSigner::new(&mut rng);

        let bob = crypto::MockSigner::new(&mut rng);

        let eve = crypto::MockSigner::new(&mut rng);

        let storage = Storage::open(tempdir.path().join("storage")).unwrap();

        let (id, _, _, _) =

            fixtures::project(tempdir.path().join("copy"), &storage, &alice).unwrap();