name = "aead"

version = "0.4.3"

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

checksum = "0b613b8e1e3cf911a086f53f03bf286f52fd7a7258e4fa606f0ef220d39d8877"

dependencies = [

 "generic-array",

]

[[package]]

name = "aead"

version = "0.5.1"

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

checksum = "5c192eb8f11fc081b0fe4259ba5af04217d4e0faddd02417310a927911abd7c8"

dependencies = [

 "crypto-common",

 "generic-array",

]

[[package]]

 "cipher 0.4.3",

version = "4.0.0-beta.7"

checksum = "1cc8da6203c5311cc0d74155341a5577564b8360976988eeb5ce7ab6903757f1"

 "cipher 0.4.3",

name = "chacha20"

version = "0.8.2"

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

checksum = "5c80e5460aa66fe3b91d40bcbdab953a597b60053e34d684ac6903f863b680a6"

dependencies = [

 "cfg-if",

 "cipher 0.3.0",

 "cpufeatures",

 "zeroize",

]

[[package]]

name = "chacha20"

version = "0.9.0"

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

checksum = "c7fc89c7c5b9e7a02dfe45cd2367bae382f9ed31c61ca8debe5f827c420a2f08"

dependencies = [

 "cfg-if",

 "cipher 0.4.3",

 "cpufeatures",

]

[[package]]

name = "chacha20poly1305"

version = "0.9.1"

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

checksum = "a18446b09be63d457bbec447509e85f662f32952b035ce892290396bc0b0cff5"

dependencies = [

 "aead 0.4.3",

 "chacha20 0.8.2",

 "cipher 0.3.0",

 "poly1305 0.7.2",

 "zeroize",

]

[[package]]

name = "chacha20poly1305"

version = "0.10.1"

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

checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"

dependencies = [

 "aead 0.5.1",

 "chacha20 0.9.0",

 "cipher 0.4.3",

 "poly1305 0.8.0",

 "zeroize",

]

[[package]]

version = "0.3.0"

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

checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"

dependencies = [

 "generic-array",

]

[[package]]

name = "cipher"

 "zeroize",

 "rand_core 0.6.4",

 "cipher 0.4.3",

name = "cypheraddr"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

 "cyphergraphy",

 "sha3",

]

[[package]]

name = "cyphergraphy"

version = "0.1.0"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

dependencies = [

 "amplify",

 "sha2 0.10.6",

]

[[package]]

name = "cyphernet"

version = "0.1.0"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

dependencies = [

 "cypheraddr",

 "cyphergraphy",

 "eidolon",

 "noise-framework",

 "socks5-client",

name = "eidolon"

version = "0.1.0"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

dependencies = [

 "amplify",

 "cyphergraphy",

]

[[package]]

source = "git+https://github.com/cyphernet-wg/rust-netservices?rev=e48011b10db9f9575af3ff1343e077ba9175028d#e48011b10db9f9575af3ff1343e077ba9175028d"

source = "git+https://github.com/cyphernet-wg/rust-netservices?rev=e48011b10db9f9575af3ff1343e077ba9175028d#e48011b10db9f9575af3ff1343e077ba9175028d"

 "chacha20 0.9.0",

 "chacha20poly1305 0.9.1",

 "ed25519-compact",

 "rand 0.8.5",

name = "noise-framework"

version = "0.1.0"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

dependencies = [

 "amplify",

 "chacha20poly1305 0.10.1",

 "cyphergraphy",

]

[[package]]

name = "poly1305"

version = "0.7.2"

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

checksum = "048aeb476be11a4b6ca432ca569e375810de9294ae78f4774e78ea98a9246ede"

dependencies = [

 "cpufeatures",

 "opaque-debug",

 "universal-hash 0.4.1",

]

[[package]]

name = "poly1305"

version = "0.8.0"

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

checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"

dependencies = [

 "cpufeatures",

 "opaque-debug",

 "universal-hash 0.5.0",

]

[[package]]

 "amplify",

 "cipher 0.4.3",

name = "socks5-client"

version = "0.1.0"

source = "git+https://github.com/cyphernet-wg/rust-cyphernet?rev=7ff92b1540d25658d4810d9ca274507685af0ba6#7ff92b1540d25658d4810d9ca274507685af0ba6"

 "amplify",

 "cypheraddr",

name = "universal-hash"

version = "0.4.1"

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

checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"

dependencies = [

 "generic-array",

 "subtle",

]

[[package]]

name = "universal-hash"

version = "0.5.0"

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

checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"

dependencies = [

 "crypto-common",

 "subtle",

]

[[package]]

rev = "7ff92b1540d25658d4810d9ca274507685af0ba6"

rev = "e48011b10db9f9575af3ff1343e077ba9175028d"

rev = "e48011b10db9f9575af3ff1343e077ba9175028d"

#[cfg(feature = "cyphernet")]

use cyphernet::{EcSigInvalid, EcSkInvalid, EcVerifyError};

impl AsRef<[u8]> for Signature {

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

        self.0.as_ref()

    }

}

impl cyphernet::display::MultiDisplay<cyphernet::display::Encoding> for PublicKey {

    type Display = String;

    fn display_fmt(&self, _: &cyphernet::display::Encoding) -> Self::Display {

        self.to_string()

    }

}

#[cfg(feature = "cyphernet")]

impl cyphernet::display::MultiDisplay<cyphernet::display::Encoding> for Signature {

    type Display = String;

    fn display_fmt(&self, _: &cyphernet::display::Encoding) -> Self::Display {

        self.to_string()

    }

}

#[cfg(feature = "cyphernet")]

impl cyphernet::EcSk for SecretKey {

    type Pk = PublicKey;

    fn generate_keypair() -> (Self, Self::Pk)

    where

        Self: Sized,

    {

        let pair = KeyPair::generate();

        (pair.sk.into(), pair.pk.into())

    }

    fn to_pk(&self) -> Result<Self::Pk, EcSkInvalid> {

        Ok(self.public_key().into())

    }

}

#[cfg(feature = "cyphernet")]

impl cyphernet::EcSign for SecretKey {

    type Sig = Signature;

    fn sign(&self, msg: impl AsRef<[u8]>) -> Self::Sig {

        self.0.sign(msg, None).into()

    }

}

#[cfg(feature = "cyphernet")]

impl cyphernet::EcPk for PublicKey {

    const COMPRESSED_LEN: usize = 32;

    const CURVE_NAME: &'static str = "Ed25519";

    type Compressed = [u8; 32];

    fn base_point() -> Self {

        unimplemented!()

    }

    fn to_pk_compressed(&self) -> Self::Compressed {

        *self.0.deref()

    }

    fn from_pk_compressed(pk: Self::Compressed) -> Result<Self, cyphernet::EcPkInvalid> {

        Ok(PublicKey::from(pk))

    }

    fn from_pk_compressed_slice(slice: &[u8]) -> Result<Self, cyphernet::EcPkInvalid> {

        ed25519::PublicKey::from_slice(slice)

            .map_err(|_| cyphernet::EcPkInvalid::default())

            .map(Self)

    }

}

#[cfg(feature = "cyphernet")]

impl cyphernet::EcSig for Signature {

    const COMPRESSED_LEN: usize = 64;

    type Pk = PublicKey;

    type Compressed = [u8; 64];

    fn to_sig_compressed(&self) -> Self::Compressed {

        *self.0.deref()

    }

    fn from_sig_compressed(sig: Self::Compressed) -> Result<Self, EcSigInvalid> {

        Ok(Signature::from(sig))

    }

    fn from_sig_compressed_slice(slice: &[u8]) -> Result<Self, EcSigInvalid> {

        ed25519::Signature::from_slice(slice)

            .map_err(|_| EcSigInvalid::default())

            .map(Signature)

    }

    fn verify(&self, pk: &Self::Pk, msg: impl AsRef<[u8]>) -> Result<(), EcVerifyError> {

        self.0.verify(pk, msg)

use std::ops::Deref;

#[cfg(feature = "cyphernet")]

use cyphernet::{EcSign, EcSk, EcSkInvalid};

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

        Signature(self.secret.deref().deref().sign(msg, None))

        Ok(Signer::sign(self, msg))

impl EcSk for MemorySigner {

    type Pk = PublicKey;

    fn generate_keypair() -> (Self, Self::Pk)

    where

        Self: Sized,

    {

        // TODO(cloudhead): Do we need `EcSk` on `MemorySigner`?

        todo!()

    }

    fn to_pk(&self) -> Result<Self::Pk, EcSkInvalid> {

        Ok(*self.public_key())

impl EcSign for MemorySigner {

    type Sig = Signature;

    fn sign(&self, msg: impl AsRef<[u8]>) -> Self::Sig {

        Signer::sign(self, msg.as_ref())

amplify = { version = "4.0.0-beta.7" }

cyphernet = { version = "0", features = ["tor", "dns", "ed25519"] }

#[derive(Debug, Clone)]

use cyphernet::{Cert, EcSign};

use netservices::resource::NetAccept;

use crate::crypto::Signature;

pub struct Runtime<G: crypto::Signer + EcSign<Pk = NodeId, Sig = Signature> + Clone> {

    pub reactor: Reactor<Transport<routing::Table, address::Book, radicle::Storage, G>>,

impl<G: crypto::Signer + EcSign<Pk = NodeId, Sig = Signature> + Clone + 'static> Runtime<G> {

            signer.clone(),

        let cert = Cert {

            pk: id,

            sig: EcSign::sign(&signer, id.as_slice()),

        };

        let pool = WorkerPool::with(

            10,

            time::Duration::from_secs(9),

            storage,

            worker_recv,

            id.to_human(),

        );

        let wire = Transport::new(service, worker_send, cert, signer, proxy, clock);

        let reactor = Reactor::named(wire, popol::Poller::new(), id.to_human())?;

            // TODO: Once the API supports it, we can pass an opaque type here.

            let listener = NetAccept::bind(&addr)?;

use crate::service::{NodeId, Sessions};

    type Sessions = Sessions;

    fn sessions(&self) -> Result<Self::Sessions, Error> {

        let (sender, receiver) = chan::unbounded();

        let query: Arc<QueryState> = Arc::new(move |state| {

            sender.send(state.sessions().clone()).ok();

            Ok(())

        });

        let (err_sender, err_receiver) = chan::bounded(1);

        self.command(service::Command::QueryState(query, err_sender))?;

        err_receiver.recv()??;

        let sessions = receiver.recv()?;

        Ok(sessions)

pub use nakamoto_net::{Io, LocalDuration, LocalTime};

pub use netservices::LinkDirection as Link;

                    connect.push((peer.id, peer.addr.clone()));

#![allow(clippy::collapsible_match)]

use crate::crypto::{Signer, Verified};

use crate::Link;

    #[error(transparent)]

    Project(#[from] storage::ProjectError),

impl FetchResult {

    /// Get the remote node id.

    pub fn remote(&self) -> &NodeId {

        match self {

            Self::Fetched { from, .. } => from,

            Self::Error { from, .. } => from,

        }

    }

}

    G: Signer,

                log::debug!("Found {} seed(s) for {}", seeds.len(), id);

                let (results_send, results) = chan::bounded(seeds.len());

                    if let Some(fetch) = session.fetch(id, results_send.clone()) {

    pub fn fetch_complete(&mut self, result: FetchResult) {

        if let Some(session) = self.sessions.get_mut(result.remote()) {

            if let session::State::Connected { protocol, .. } = &session.state {

                if let session::Protocol::Fetch {

                    results: Some(results),

                } = protocol

                {

                    results.send(result).unwrap();

                } else {

                    // Fetch initiated by remote, we don't need to report back.

                }

            }

        }

        info!("Connected to {} ({:?})", remote, link);

            (

                session::State::Connected {

                    protocol: session::Protocol::Fetch { .. },

                    ..

                },

                _,

            ) => {

                *protocol = Protocol::Fetch { results: None };

                // Instruct the transport to handover the socket to the worker.

#[derive(Debug, Clone)]

            Self::Fetch { repo } => write!(f, "Fetch({repo})"),

        let msgs = msgs.into_iter().collect::<Vec<_>>();

        let len = msgs.len();

        for (no, msg) in msgs.iter().enumerate() {

            debug!("Write {no}/{len} {:?} message to {}", msg, remote);

        }

        self.io.push_back(Io::Write(remote, msgs));

            debug!("Fetch initiated for {} with {}..", repo, remote);

use crate::service::chan;

use crate::service::{storage, FetchResult};

use crate::service::{Id, LocalTime, NodeId, Reactor, Rng};

use crate::Link;

#[derive(Debug, Default, Clone)]

    Fetch {

        /// Channel to send fetch results on. Set to `Some` when the fetch

        /// is locally initiated. Otherwise, no results need to be communicated

        /// back.

        results: Option<chan::Sender<FetchResult>>,

    },

    pub fn fetch(&mut self, repo: Id, results: chan::Sender<FetchResult>) -> Option<Message> {

            if let Protocol::Gossip = protocol {

                *protocol = Protocol::Fetch {

                    results: Some(results),

                };

    type Sessions = service::Sessions;

    fn sessions(&self) -> Result<Self::Sessions, Error> {

                println!("{} {}", "test:".cyan(), record.args().to_string().cyan())

                    let current = std::thread::current();

                    let msg = format!("{:<8} {}", format!("{}:", target), record.args());

                    let s = if let Some(name) = current.name() {

                        format!("{:<8} {msg}", name)

                    } else {

                        msg

                    };

use crate::crypto::Signer;

use crate::Link;

use crate::{LocalDuration, LocalTime};

    G: Signer + 'static,

    G: Signer + 'static,

use nakamoto_net::{LocalDuration, LocalTime};

use crate::crypto::Signer;

use crate::Link;

impl<S: WriteStorage + 'static, G: Signer> Simulation<S, G> {

use std::path::Path;

    iter, net, thread,

    time::Duration,

use radicle::storage::WriteStorage;

use radicle::{assert_matches, rad};

use crate::service::{routing, FetchLookup, FetchResult};

use crate::test::logger;

/// Represents a running node.

struct Node {

    id: NodeId,

    addr: net::SocketAddr,

    handle: client::handle::Handle<Transport<routing::Table, address::Book, Storage, MemorySigner>>,

    signer: MemorySigner,

    storage: Storage,

    #[allow(dead_code)]

    thread: thread::JoinHandle<Result<(), client::Error>>,

impl Node {

    /// Spawn a node in its own thread.

    fn spawn(base: &Path, config: service::Config) -> Self {

        let home = base.join(

            iter::repeat_with(fastrand::alphanumeric)

                .take(8)

                .collect::<String>(),

        );

        let profile = Profile::init(home.as_path(), "pasphrase".to_owned()).unwrap();

        let signer = MemorySigner::load(&profile.keystore, "pasphrase".to_owned().into()).unwrap();

        let listen = vec![([0, 0, 0, 0], 0).into()];

        let proxy = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 9050);

        let storage = profile.storage.clone();

        let rt = Runtime::with(profile, config, listen, proxy, signer.clone()).unwrap();

        let id = rt.id;

        let thread = thread::Builder::new()

            .name(id.to_string())

            .spawn(|| rt.run())

            .unwrap();

        Self {

            id,

            addr,

            handle,

            signer,

            storage,

            thread,

        }

    /// Connect this node to another node, and wait for the connection to be established both ways.

    fn connect(&mut self, remote: &Node) {

        self.handle.connect(remote.id, remote.addr.into()).unwrap();

        loop {

            let local_sessions = self.handle.sessions().unwrap();

            let remote_sessions = remote.handle.sessions().unwrap();

            let local_sessions = local_sessions

                .negotiated()

                .map(|(id, _)| id)

                .collect::<BTreeSet<_>>();

            let remote_sessions = remote_sessions

                .negotiated()

                .map(|(id, _)| id)

                .collect::<BTreeSet<_>>();

            if local_sessions.contains(&remote.id) && remote_sessions.contains(&self.id) {

                break;

            }

            thread::sleep(Duration::from_millis(100));

    /// Populate a storage instance with a project.

    fn project(&mut self, name: &str) -> Id {

        transport::local::register(self.storage.clone());

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

        let (repo, _) = fixtures::gen::repository(tmp.path());

        let description = iter::repeat_with(fastrand::alphabetic)

            .take(12)

            .collect::<String>();

        let id = rad::init(

            &repo,

            name,

            &description,

            refname!("master"),

            &self.signer,

            &self.storage,

        )

        .map(|(id, _, _)| id)

        .unwrap();

        log::debug!(target: "test", "Initialized project {id} for node {}", self.id);

        id

fn check<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> BTreeSet<(Id, NodeId)> {

    let nodes = nodes.into_iter().collect::<Vec<_>>();

    let mut all_routes = BTreeSet::<(Id, NodeId)>::new();

    let mut remaining = BTreeMap::from_iter(nodes.iter().map(|node| (node.id, node)));

    // First build the set of all routes.

    for node in &nodes {

        let routing = node.handle.routing().unwrap();

        for (rid, seed) in routing.try_iter() {

            all_routes.insert((rid, seed));

    // Then, while there are nodes remaining to converge, check each node to see if

    // its routing table has all routes. If so, remove it from the remaining nodes.

    while !remaining.is_empty() {

        remaining.retain(|_, node| {

            let routing = node.handle.routing().unwrap();

            let routes = BTreeSet::from_iter(routing.try_iter());

            if routes == all_routes {

                log::debug!(target: "test", "Node {} has converged", node.id);

                return false;

            }

            true

        });

        thread::sleep(Duration::from_millis(100));

    all_routes

//

//     alice -- bob

//

fn test_inventory_sync_basic() {

    logger::init(log::Level::Debug);

    let mut alice = Node::spawn(tmp.path(), service::Config::default());

    let mut bob = Node::spawn(tmp.path(), service::Config::default());

    alice.project("alice");

    bob.project("bob");

    alice.connect(&bob);

    let routes = check([&alice, &bob]);

#[test]

//

//     alice -- bob -- eve

//

fn test_inventory_sync_bridge() {

    logger::init(log::Level::Debug);

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

    let mut alice = Node::spawn(tmp.path(), service::Config::default());

    let mut bob = Node::spawn(tmp.path(), service::Config::default());

    let mut eve = Node::spawn(tmp.path(), service::Config::default());

    alice.project("alice");

    bob.project("bob");

    eve.project("eve");

    alice.connect(&bob);

    bob.connect(&eve);

    let routes = check([&alice, &bob, &eve]);

    assert_eq!(routes.len(), 3);

}

#[test]

//

//     alice -- bob

//       |       |

//     carol -- eve

//

fn test_inventory_sync_ring() {

    logger::init(log::Level::Debug);

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

    let mut alice = Node::spawn(tmp.path(), service::Config::default());

    let mut bob = Node::spawn(tmp.path(), service::Config::default());

    let mut eve = Node::spawn(tmp.path(), service::Config::default());

    let mut carol = Node::spawn(tmp.path(), service::Config::default());

    alice.project("alice");

    bob.project("bob");

    eve.project("eve");

    carol.project("carol");

    alice.connect(&bob);

    bob.connect(&eve);

    eve.connect(&carol);

    carol.connect(&alice);

    let routes = check([&alice, &bob, &eve, &carol]);

    assert_eq!(routes.len(), 4);

}

#[test]

//

//             dave

//              |

//     eve -- alice -- bob

//              |

//            carol

//

fn test_inventory_sync_star() {

    logger::init(log::Level::Debug);

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

    let mut alice = Node::spawn(tmp.path(), service::Config::default());

    let mut bob = Node::spawn(tmp.path(), service::Config::default());

    let mut eve = Node::spawn(tmp.path(), service::Config::default());

    let mut carol = Node::spawn(tmp.path(), service::Config::default());

    let mut dave = Node::spawn(tmp.path(), service::Config::default());

    alice.project("alice");

    bob.project("bob");

    eve.project("eve");

    carol.project("carol");

    dave.project("dave");

    bob.connect(&alice);

    eve.connect(&alice);

    carol.connect(&alice);

    dave.connect(&alice);

    let routes = check([&alice, &bob, &eve, &carol, &dave]);

    assert_eq!(routes.len(), 5);

}

#[test]

#[ignore]

fn test_replication() {

    logger::init(log::Level::Debug);

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

    let mut alice = Node::spawn(tmp.path(), service::Config::default());

    let mut bob = Node::spawn(tmp.path(), service::Config::default());

    let acme = bob.project("acme");

    alice.connect(&bob);

    check([&alice, &bob]);

    let inventory = alice.handle.inventory().unwrap();

    assert!(inventory.try_iter().next().is_none());

    let tracked = alice.handle.track_repo(acme).unwrap();

    assert!(tracked);

    let (seeds, results) = match alice.handle.fetch(acme).unwrap() {

        FetchLookup::Found { seeds, results } => (seeds, results),

        other => panic!("Fetch lookup failed, got {:?}", other),

    };

    assert_eq!(seeds, nonempty::NonEmpty::new(bob.id));

    let (from, updated) = match results.recv_timeout(Duration::from_secs(6)).unwrap() {

        FetchResult::Fetched { from, updated } => (from, updated),

        FetchResult::Error { from, error } => {

            panic!("Fetch failed from {from}: {error}");

        }

    };

    assert_eq!(from, bob.id);

    assert_eq!(updated, vec![]);

    let inventory = alice.handle.inventory().unwrap();

    assert_eq!(inventory.try_iter().next(), Some(acme));

    assert_eq!(

        alice

            .storage

            .repository(acme)

            .unwrap()

            .remotes()

            .unwrap()

            .map(|r| r.unwrap())

            .collect::<Vec<_>>(),

        bob.storage

            .repository(acme)

            .unwrap()

            .remotes()

            .unwrap()

            .map(|r| r.unwrap())

            .collect::<Vec<_>>(),

    );

    assert_matches!(alice.storage.repository(acme).unwrap().verify(), Ok(()));

}

use cyphernet::Sha256;

use netservices::session::{CypherReader, CypherSession, CypherWriter};

pub type WireSession<G> = CypherSession<G, Sha256>;

pub type WireReader = CypherReader<Sha256>;

pub type WireWriter<G> = CypherWriter<G, Sha256>;

use cyphernet::addr::{Addr, HostName, NetAddr};

            HostName::Ip(net::IpAddr::V4(_)) => AddressType::Ipv4,

            HostName::Ip(net::IpAddr::V6(_)) => AddressType::Ipv6,

            HostName::Dns(_) => AddressType::Hostname,

            HostName::Tor(_) => AddressType::Onion,

            HostName::Ip(net::IpAddr::V4(ip)) => {

            HostName::Ip(net::IpAddr::V6(ip)) => {

                HostName::Ip(net::IpAddr::V4(ip))