GH 205 - Originate-Only, plus skeleton of Consume-Only mode (#331)

* GH-205: Added --originate-only command-line parameter

* GH-205: IP address is now optional, rather than sentineled

* GH-205: NodeRecordInner now has the originate_only flag

* GH-205: Some tests still failing, but '--originate-only true' has become '--neighborhood-mode originate-only'

* GH-205: Unit and zero-hop tests pass. Multinode tests will require some work.

* GH-205: Multinode tests weren't actually all that hard to fix.

* GH-205: No longer opens clandestine port in Zero-Hop, Consume-Only, or Originate-Only modes

* GH-205: Rearranging some data and adding flags to NodeRecordInner

* GH-205: Now accepts a Debut from a Node with accepts_connections = false

* GH-205: DebutHandler no longer hands out Nodes that don't accept connections in Introductions or Passes

* GH-205: Multinode tests compile and pass, but I'm not sure about those flags.

* GH-205: Gossip generation changes. Now we need the GossipAcceptor to tolerate Gossip with no NodeAddr from the sender.

* GH-205: Formatting, plus toleration of Standard Gossip with no NodeAddr in the record from the gossip source

* GH-205: NodeDescriptors now don't have to have NodeAddrs.

* GH-205: Originate-Only and part of Consume-Only

* GH-205: Formatting, and Consume-Only put on hold

* SC-205: Consume-Only is easy except for the route back

* GH-205: Interim commit

* GH-205: Formatting

* GH-205: Consume-Only seems to be working.

* GH-205: Merged in Consume-Only and set up to populate Pipelines caches

* GH-205: Now Pipelines should be using the caches.

* GH-205: Trying a little something to clean up the results repo

* GH-205: Review issues

Author: dnwiebe

ci/publish_results.sh

@@ -52,9 +52,12 @@ cat README.md.clean | sed -n '/\(Results Marker\)/,$p' | tail -n+2 >> README.md
 
 mkdir -p "results/$RESULTS_LABEL"
 cp ../generated.tar.gz "results/$RESULTS_LABEL/$GENERATED_NAME.tar.gz"
-git add README.md "results/$RESULTS_LABEL/$GENERATED_NAME.tar.gz"
+git checkout --orphan new-master
+git add README.md results
 git commit -m "Latest results for $RESULTS_LABEL ($GENERATED_TYPE) - $STATUS"
-git pull
-git push
+git branch -D master
+git branch -M new-master master
+git checkout master
+git push -f -u origin HEAD
 
 popd

multinode_integration_tests/Cargo.toml

@@ -13,6 +13,7 @@ base64 = "0.10.1"
 ethereum-types = "0.6.0"
 ethsign-crypto = "0.1.0"
 futures = "0.1.28"
+itertools = "0.8.0"
 pretty-hex = "0.1.0"
 primitive-types = {version = "0.5.0", default-features = false, features = ["default", "rlp", "serde"] }
 regex = "1.2.1"

multinode_integration_tests/src/multinode_gossip.rs

@@ -1,14 +1,11 @@
 // Copyright (c) 2017-2019, Substratum LLC (https://substratum.net) and/or its affiliates. All rights reserved.
 use crate::substratum_node::SubstratumNode;
 use node_lib::neighborhood::gossip::{Gossip, GossipNodeRecord};
-use node_lib::neighborhood::node_record::NodeRecordInner;
 use node_lib::neighborhood::AccessibleGossipRecord;
-use node_lib::sub_lib::cryptde::CryptData;
-use node_lib::sub_lib::cryptde::PlainData;
 use node_lib::sub_lib::cryptde::PublicKey;
 use node_lib::sub_lib::cryptde_null::CryptDENull;
 use node_lib::test_utils::{vec_to_set, DEFAULT_CHAIN_ID};
-use std::collections::{BTreeSet, HashSet};
+use std::collections::HashSet;
 use std::convert::{TryFrom, TryInto};
 use std::net::IpAddr;
 
@@ -383,24 +380,3 @@ fn nodes_of_degree(nodes: &Vec<AccessibleGossipRecord>, degree: usize) -> Vec<Pu
         .map(|node| node.inner.public_key.clone())
         .collect::<Vec<PublicKey>>()
 }
-
-impl From<&dyn SubstratumNode> for AccessibleGossipRecord {
-    fn from(substratum_node: &dyn SubstratumNode) -> Self {
-        let cryptde = substratum_node.signing_cryptde().unwrap_or_else (|| panic! ("You can only make an AccessibleGossipRecord from a SubstratumRealNode if it has a CryptDENull, not a CryptDEReal."));
-        let mut agr = AccessibleGossipRecord {
-            inner: NodeRecordInner {
-                data_version: NodeRecordInner::data_version(),
-                public_key: substratum_node.public_key().clone(),
-                earning_wallet: substratum_node.earning_wallet(),
-                rate_pack: substratum_node.rate_pack(),
-                neighbors: BTreeSet::new(),
-                version: 0,
-            },
-            node_addr_opt: Some(substratum_node.node_addr()),
-            signed_gossip: PlainData::new(b""),
-            signature: CryptData::new(b""),
-        };
-        agr.regenerate_signed_gossip(cryptde);
-        agr
-    }
-}

multinode_integration_tests/src/neighborhood_constructor.rs

@@ -6,15 +6,13 @@ use crate::substratum_node::SubstratumNode;
 use crate::substratum_node_cluster::SubstratumNodeCluster;
 use crate::substratum_real_node::SubstratumRealNode;
 use crate::substratum_real_node::{make_consuming_wallet_info, NodeStartupConfigBuilder};
-use node_lib::blockchain::blockchain_interface::chain_id_from_name;
 use node_lib::neighborhood::gossip::Gossip;
 use node_lib::neighborhood::gossip_producer::{GossipProducer, GossipProducerReal};
 use node_lib::neighborhood::neighborhood_database::NeighborhoodDatabase;
 use node_lib::neighborhood::neighborhood_test_utils::db_from_node;
-use node_lib::neighborhood::node_record::{NodeRecord, NodeRecordInner, NodeRecordMetadata};
-use node_lib::sub_lib::cryptde::{CryptData, PlainData, PublicKey};
-use node_lib::sub_lib::cryptde_null::CryptDENull;
-use node_lib::test_utils::DEFAULT_CHAIN_ID;
+use node_lib::neighborhood::node_record::{NodeRecord, NodeRecordMetadata};
+use node_lib::neighborhood::AccessibleGossipRecord;
+use node_lib::sub_lib::cryptde::PublicKey;
 use std::collections::{BTreeSet, HashMap};
 use std::convert::TryInto;
 use std::time::Duration;
@@ -239,29 +237,15 @@ impl From<&SubstratumRealNode> for NodeRecord {
 }
 
 fn from_substratum_node_to_node_record(substratum_node: &dyn SubstratumNode) -> NodeRecord {
-    let mut result = NodeRecord {
-        inner: NodeRecordInner {
-            data_version: NodeRecordInner::data_version(),
-            public_key: substratum_node.public_key().clone(),
-            earning_wallet: substratum_node.earning_wallet(),
-            rate_pack: substratum_node.rate_pack(),
-            neighbors: BTreeSet::new(),
-            version: 0,
-        },
+    let agr = AccessibleGossipRecord::from(substratum_node);
+    let result = NodeRecord {
+        inner: agr.inner.clone(),
         metadata: NodeRecordMetadata {
             desirable: true,
-            node_addr_opt: Some(substratum_node.node_addr()),
+            node_addr_opt: agr.node_addr_opt.clone(),
         },
-        signed_gossip: PlainData::new(b""),
-        signature: CryptData::new(b""),
+        signed_gossip: agr.signed_gossip.clone(),
+        signature: agr.signature.clone(),
     };
-    let cryptde = CryptDENull::from(
-        substratum_node.public_key(),
-        substratum_node
-            .chain()
-            .map(|chain_name| chain_id_from_name(chain_name.as_str()))
-            .unwrap_or(DEFAULT_CHAIN_ID),
-    );
-    result.regenerate_signed_gossip(&cryptde);
     result
 }

multinode_integration_tests/src/substratum_cores_server.rs

@@ -132,7 +132,10 @@ impl SubstratumCoresServer {
     pub fn node_reference(&self) -> NodeReference {
         NodeReference {
             public_key: self.cryptde.public_key().clone(),
-            node_addr: NodeAddr::new(&self.socket_addr.ip(), &vec![self.socket_addr.port()]),
+            node_addr_opt: Some(NodeAddr::new(
+                &self.socket_addr.ip(),
+                &vec![self.socket_addr.port()],
+            )),
         }
     }
 
@@ -144,8 +147,8 @@ impl SubstratumCoresServer {
         self.node_reference().public_key.clone()
     }
 
-    pub fn node_addr(&self) -> NodeAddr {
-        self.node_reference().node_addr.clone()
+    pub fn node_addr_opt(&self) -> Option<NodeAddr> {
+        self.node_reference().node_addr_opt.clone()
     }
 
     pub fn private_key(&self) -> &PrivateKey {

multinode_integration_tests/src/substratum_mock_node.rs

@@ -65,7 +65,7 @@ impl SubstratumNode for SubstratumMockNode {
     fn node_reference(&self) -> NodeReference {
         NodeReference::new(
             self.signing_cryptde().unwrap().public_key().clone(),
-            self.node_addr().ip_addr(),
+            Some(self.node_addr().ip_addr()),
             self.node_addr().ports(),
         )
     }
@@ -119,6 +119,14 @@ impl SubstratumNode for SubstratumMockNode {
     fn chain(&self) -> Option<String> {
         self.guts.chain.clone()
     }
+
+    fn accepts_connections(&self) -> bool {
+        true // just a guess
+    }
+
+    fn routes_data(&self) -> bool {
+        true // just a guess
+    }
 }
 
 impl SubstratumMockNode {
@@ -343,7 +351,7 @@ impl SubstratumMockNode {
         match self.wait_for_package(&masquerader, timeout) {
             Ok((from, _, package)) => {
                 let incoming_cores_package = package
-                    .to_expired(from.ip(), self.signing_cryptde().unwrap())
+                    .to_expired(from, self.signing_cryptde().unwrap())
                     .unwrap();
                 match incoming_cores_package.payload {
                     MessageType::Gossip(g) => Some((g, from.ip())),

multinode_integration_tests/src/substratum_node.rs

@@ -28,7 +28,7 @@ use std::time::Instant;
 #[derive(PartialEq, Clone, Debug)]
 pub struct NodeReference {
     pub public_key: PublicKey,
-    pub node_addr: NodeAddr,
+    pub node_addr_opt: Option<NodeAddr>,
 }
 
 impl FromStr for NodeReference {
@@ -49,14 +49,19 @@ impl FromStr for NodeReference {
 impl fmt::Display for NodeReference {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let public_key_string = base64::encode_config(&self.public_key.as_slice(), STANDARD_NO_PAD);
-        let ip_addr_string = format!("{}", self.node_addr.ip_addr());
-        let port_list_string = self
-            .node_addr
-            .ports()
-            .iter()
-            .map(|port| port.to_string())
-            .collect::<Vec<String>>()
-            .join(",");
+        let ip_addr_string = match &self.node_addr_opt {
+            Some(node_addr) => format!("{}", node_addr.ip_addr()),
+            None => String::new(),
+        };
+        let port_list_string = match &self.node_addr_opt {
+            Some(node_addr) => node_addr
+                .ports()
+                .iter()
+                .map(|port| port.to_string())
+                .collect::<Vec<String>>()
+                .join(","),
+            None => String::new(),
+        };
         write!(
             f,
             "{}:{}:{}",
@@ -68,10 +73,20 @@ impl fmt::Display for NodeReference {
 }
 
 impl NodeReference {
-    pub fn new(public_key: PublicKey, ip_addr: IpAddr, ports: Vec<u16>) -> NodeReference {
-        NodeReference {
-            public_key,
-            node_addr: NodeAddr::new(&ip_addr, &ports),
+    pub fn new(
+        public_key: PublicKey,
+        ip_addr_opt: Option<IpAddr>,
+        ports: Vec<u16>,
+    ) -> NodeReference {
+        match ip_addr_opt {
+            Some(ip_addr) => NodeReference {
+                public_key,
+                node_addr_opt: Some(NodeAddr::new(&ip_addr, &ports)),
+            },
+            None => NodeReference {
+                public_key,
+                node_addr_opt: None,
+            },
         }
     }
 
@@ -82,14 +97,18 @@ impl NodeReference {
         }
     }
 
-    fn extract_ip_addr(slice: &str) -> Result<IpAddr, String> {
-        match IpAddr::from_str(slice) {
-            Ok(ip_addr) => Ok(ip_addr),
-            Err(_) => {
-                return Err(format!(
-                    "The IP address of a NodeReference must be valid, not '{}'",
-                    slice
-                ));
+    fn extract_ip_addr(slice: &str) -> Result<Option<IpAddr>, String> {
+        if slice.is_empty() {
+            Ok(None)
+        } else {
+            match IpAddr::from_str(slice) {
+                Ok(ip_addr) => Ok(Some(ip_addr)),
+                Err(_) => {
+                    return Err(format!(
+                        "The IP address of a NodeReference must be valid, not '{}'",
+                        slice
+                    ));
+                }
             }
         }
     }
@@ -159,6 +178,8 @@ pub trait SubstratumNode: Any {
     fn rate_pack(&self) -> RatePack;
     // Valid values are "dev, "ropsten" for now. Add "mainnet" when it's time.
     fn chain(&self) -> Option<String>;
+    fn accepts_connections(&self) -> bool;
+    fn routes_data(&self) -> bool;
 }
 
 pub struct SubstratumNodeUtils {}
@@ -319,8 +340,11 @@ mod tests {
 
         assert_eq!(result.public_key, key);
         assert_eq!(
-            result.node_addr,
-            NodeAddr::new(&IpAddr::from_str("12.34.56.78").unwrap(), &vec!(1234, 2345))
+            result.node_addr_opt,
+            Some(NodeAddr::new(
+                &IpAddr::from_str("12.34.56.78").unwrap(),
+                &vec!(1234, 2345)
+            ))
         );
     }
 
@@ -333,16 +357,19 @@ mod tests {
 
         assert_eq!(result.public_key, key);
         assert_eq!(
-            result.node_addr,
-            NodeAddr::new(&IpAddr::from_str("12.34.56.78").unwrap(), &vec!())
+            result.node_addr_opt,
+            Some(NodeAddr::new(
+                &IpAddr::from_str("12.34.56.78").unwrap(),
+                &vec!()
+            ))
         );
     }
 
     #[test]
     fn node_reference_can_display_itself() {
         let subject = NodeReference::new(
             PublicKey::new(&b"Booga"[..]),
-            IpAddr::from_str("12.34.56.78").unwrap(),
+            Some(IpAddr::from_str("12.34.56.78").unwrap()),
             vec![1234, 5678],
         );
 

multinode_integration_tests/src/substratum_real_node.rs

@@ -12,7 +12,6 @@ use node_lib::blockchain::blockchain_interface::chain_id_from_name;
 use node_lib::sub_lib::accountant::DEFAULT_EARNING_WALLET;
 use node_lib::sub_lib::cryptde::{CryptDE, PublicKey};
 use node_lib::sub_lib::cryptde_null::CryptDENull;
-use node_lib::sub_lib::neighborhood::sentinel_ip_addr;
 use node_lib::sub_lib::neighborhood::RatePack;
 use node_lib::sub_lib::neighborhood::DEFAULT_RATE_PACK;
 use node_lib::sub_lib::neighborhood::ZERO_RATE_PACK;
@@ -110,6 +109,7 @@ pub fn make_consuming_wallet_info(token: &str) -> ConsumingWalletInfo {
 
 #[derive(PartialEq, Clone)]
 pub struct NodeStartupConfig {
+    pub neighborhood_mode: String,
     pub ip_info: LocalIpInfo,
     pub dns_servers: Vec<IpAddr>,
     pub neighbors: Vec<NodeReference>,
@@ -129,11 +129,12 @@ pub struct NodeStartupConfig {
 impl NodeStartupConfig {
     pub fn new() -> NodeStartupConfig {
         NodeStartupConfig {
+            neighborhood_mode: "standard".to_string(),
             ip_info: LocalIpInfo::ZeroHop,
             dns_servers: Vec::new(),
             neighbors: Vec::new(),
             clandestine_port_opt: None,
-            dns_target: sentinel_ip_addr(),
+            dns_target: IpAddr::V4(Ipv4Addr::BROADCAST),
             dns_port: 0,
             earning_wallet_info: EarningWalletInfo::None,
             consuming_wallet_info: ConsumingWalletInfo::None,
@@ -152,6 +153,8 @@ impl NodeStartupConfig {
 
     fn make_args(&self) -> Vec<String> {
         let mut args = vec![];
+        args.push("--neighborhood-mode".to_string());
+        args.push(self.neighborhood_mode.clone());
         if let LocalIpInfo::DistributedKnown(ip_addr) = self.ip_info {
             args.push("--ip".to_string());
             args.push(format!("{}", ip_addr));
@@ -343,6 +346,7 @@ impl NodeStartupConfig {
 }
 
 pub struct NodeStartupConfigBuilder {
+    neighborhood_mode: String,
     ip_info: LocalIpInfo,
     dns_servers: Vec<IpAddr>,
     neighbors: Vec<NodeReference>,
@@ -362,6 +366,7 @@ pub struct NodeStartupConfigBuilder {
 impl NodeStartupConfigBuilder {
     pub fn zero_hop() -> Self {
         Self {
+            neighborhood_mode: "zero-hop".to_string(),
             ip_info: LocalIpInfo::ZeroHop,
             dns_servers: vec![IpAddr::from_str("8.8.8.8").unwrap()],
             neighbors: vec![],
@@ -379,8 +384,57 @@ impl NodeStartupConfigBuilder {
         }
     }
 
+    pub fn consume_only() -> Self {
+        Self {
+            neighborhood_mode: "consume-only".to_string(),
+            ip_info: LocalIpInfo::DistributedUnknown,
+            dns_servers: vec![IpAddr::from_str("8.8.8.8").unwrap()],
+            neighbors: vec![],
+            clandestine_port_opt: None,
+            dns_target: localhost(),
+            dns_port: 53,
+            earning_wallet_info: EarningWalletInfo::Address(
+                "0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE".to_string(),
+            ),
+            consuming_wallet_info: ConsumingWalletInfo::PrivateKey(
+                "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC".to_string(),
+            ),
+            rate_pack: ZERO_RATE_PACK.clone(),
+            firewall: None,
+            memory: None,
+            fake_public_key: None,
+            blockchain_service_url: None,
+            chain: None,
+        }
+    }
+
+    pub fn originate_only() -> Self {
+        Self {
+            neighborhood_mode: "originate-only".to_string(),
+            ip_info: LocalIpInfo::DistributedUnknown,
+            dns_servers: vec![IpAddr::from_str("8.8.8.8").unwrap()],
+            neighbors: vec![],
+            clandestine_port_opt: None,
+            dns_target: localhost(),
+            dns_port: 53,
+            earning_wallet_info: EarningWalletInfo::Address(
+                "0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE".to_string(),
+            ),
+            consuming_wallet_info: ConsumingWalletInfo::PrivateKey(
+                "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC".to_string(),
+            ),
+            rate_pack: DEFAULT_RATE_PACK.clone(),
+            firewall: None,
+            memory: None,
+            fake_public_key: None,
+            blockchain_service_url: None,
+            chain: None,
+        }
+    }
+
     pub fn standard() -> Self {
         Self {
+            neighborhood_mode: "standard".to_string(),
             ip_info: LocalIpInfo::DistributedUnknown,
             dns_servers: vec![IpAddr::from_str("8.8.8.8").unwrap()],
             neighbors: vec![],
@@ -400,6 +454,7 @@ impl NodeStartupConfigBuilder {
 
     pub fn copy(config: &NodeStartupConfig) -> Self {
         Self {
+            neighborhood_mode: config.neighborhood_mode.clone(),
             ip_info: config.ip_info.clone(),
             dns_servers: config.dns_servers.clone(),
             neighbors: config.neighbors.clone(),
@@ -417,6 +472,22 @@ impl NodeStartupConfigBuilder {
         }
     }
 
+    pub fn neighborhood_mode(mut self, value: &str) -> Self {
+        if vec![
+            "zero-hop".to_string(),
+            "consume-only".to_string(),
+            "originate-only".to_string(),
+            "standard".to_string(),
+        ]
+        .contains(&value.to_string())
+        {
+            self.neighborhood_mode = value.to_string();
+            self
+        } else {
+            panic!("Unrecognized --neighborhood-mode: '{}'", value)
+        }
+    }
+
     pub fn ip(mut self, value: IpAddr) -> Self {
         self.ip_info = LocalIpInfo::DistributedKnown(value);
         self
@@ -502,6 +573,7 @@ impl NodeStartupConfigBuilder {
 
     pub fn build(self) -> NodeStartupConfig {
         NodeStartupConfig {
+            neighborhood_mode: self.neighborhood_mode,
             ip_info: self.ip_info,
             dns_servers: self.dns_servers,
             neighbors: self.neighbors,
@@ -554,7 +626,10 @@ impl SubstratumNode for SubstratumRealNode {
     }
 
     fn port_list(&self) -> Vec<u16> {
-        self.node_reference().node_addr.ports().clone()
+        match self.node_reference().node_addr_opt {
+            Some(node_addr) => node_addr.ports().clone(),
+            None => vec![],
+        }
     }
 
     fn node_addr(&self) -> NodeAddr {
@@ -580,6 +655,14 @@ impl SubstratumNode for SubstratumRealNode {
     fn chain(&self) -> Option<String> {
         self.guts.chain.clone()
     }
+
+    fn accepts_connections(&self) -> bool {
+        self.guts.accepts_connections
+    }
+
+    fn routes_data(&self) -> bool {
+        self.guts.routes_data
+    }
 }
 
 impl SubstratumRealNode {
@@ -693,6 +776,10 @@ impl SubstratumRealNode {
             root_dir,
             cryptde_null,
             chain: real_startup_config.chain,
+            accepts_connections: vec!["standard"]
+                .contains(&real_startup_config.neighborhood_mode.as_str()),
+            routes_data: vec!["standard", "originate-only"]
+                .contains(&real_startup_config.neighborhood_mode.as_str()),
         });
         Self { guts }
     }
@@ -948,7 +1035,7 @@ impl SubstratumRealNode {
     }
 
     fn extract_node_reference(name: &String) -> Result<NodeReference, String> {
-        let regex = Regex::new(r"SubstratumNode local descriptor: ([^:]+:[\d.]+:[\d,]*)").unwrap();
+        let regex = Regex::new(r"SubstratumNode local descriptor: ([^:]+:[\d.]*:[\d,]*)").unwrap();
         let mut retries_left = 5;
         loop {
             println!("Checking for {} startup", name);
@@ -994,6 +1081,8 @@ struct SubstratumRealNodeGuts {
     root_dir: String,
     cryptde_null: Option<CryptDENull>,
     chain: Option<String>,
+    accepts_connections: bool,
+    routes_data: bool,
 }
 
 impl Drop for SubstratumRealNodeGuts {
@@ -1021,6 +1110,7 @@ mod tests {
         assert_eq!(result.clandestine_port_opt, None);
         assert_eq!(result.dns_target, localhost());
         assert_eq!(result.dns_port, 53);
+        assert_eq!(result.neighborhood_mode, "zero-hop".to_string());
     }
 
     #[test]
@@ -1044,6 +1134,23 @@ mod tests {
         assert_eq!(result.clandestine_port_opt, None);
         assert_eq!(result.dns_target, localhost());
         assert_eq!(result.dns_port, 53);
+        assert_eq!(result.neighborhood_mode, "standard".to_string());
+    }
+
+    #[test]
+    fn node_startup_config_builder_originate_only() {
+        let result = NodeStartupConfigBuilder::originate_only().build();
+
+        assert_eq!(result.ip_info, LocalIpInfo::DistributedUnknown);
+        assert_eq!(
+            result.dns_servers,
+            vec!(IpAddr::from_str("8.8.8.8").unwrap())
+        );
+        assert_eq!(result.neighbors, vec!());
+        assert_eq!(result.clandestine_port_opt, None);
+        assert_eq!(result.dns_target, localhost());
+        assert_eq!(result.dns_port, 53);
+        assert_eq!(result.neighborhood_mode, "originate-only".to_string());
     }
 
     #[test]
@@ -1062,12 +1169,12 @@ mod tests {
         let neighbors = vec![
             NodeReference::new(
                 one_neighbor_key.clone(),
-                one_neighbor_ip_addr.clone(),
+                Some(one_neighbor_ip_addr.clone()),
                 one_neighbor_ports.clone(),
             ),
             NodeReference::new(
                 another_neighbor_key.clone(),
-                another_neighbor_ip_addr.clone(),
+                Some(another_neighbor_ip_addr.clone()),
                 another_neighbor_ports.clone(),
             ),
         ];
@@ -1093,11 +1200,12 @@ mod tests {
     #[test]
     fn node_startup_config_builder_copy() {
         let original = NodeStartupConfig {
+            neighborhood_mode: "consume-only".to_string(),
             ip_info: LocalIpInfo::DistributedUnknown,
             dns_servers: vec![IpAddr::from_str("255.255.255.255").unwrap()],
             neighbors: vec![NodeReference::new(
                 PublicKey::new(&[255]),
-                IpAddr::from_str("255.255.255.255").unwrap(),
+                Some(IpAddr::from_str("255.255.255.255").unwrap()),
                 vec![255],
             )],
             clandestine_port_opt: Some(1234),
@@ -1119,6 +1227,7 @@ mod tests {
             blockchain_service_url: None,
             chain: None,
         };
+        let neighborhood_mode = "standard".to_string();
         let ip_addr = IpAddr::from_str("1.2.3.4").unwrap();
         let one_neighbor_key = PublicKey::new(&[1, 2, 3, 4]);
         let one_neighbor_ip_addr = IpAddr::from_str("4.5.6.7").unwrap();
@@ -1133,18 +1242,19 @@ mod tests {
         let neighbors = vec![
             NodeReference::new(
                 one_neighbor_key.clone(),
-                one_neighbor_ip_addr.clone(),
+                Some(one_neighbor_ip_addr.clone()),
                 one_neighbor_ports.clone(),
             ),
             NodeReference::new(
                 another_neighbor_key.clone(),
-                another_neighbor_ip_addr.clone(),
+                Some(another_neighbor_ip_addr.clone()),
                 another_neighbor_ports.clone(),
             ),
         ];
         let dns_target = IpAddr::from_str("8.9.10.11").unwrap();
 
         let result = NodeStartupConfigBuilder::copy(&original)
+            .neighborhood_mode(&neighborhood_mode)
             .ip(ip_addr)
             .dns_servers(dns_servers.clone())
             .neighbors(neighbors.clone())
@@ -1153,6 +1263,7 @@ mod tests {
             .dns_port(35)
             .build();
 
+        assert_eq!(result.neighborhood_mode, neighborhood_mode);
         assert_eq!(result.ip_info, LocalIpInfo::DistributedKnown(ip_addr));
         assert_eq!(result.dns_servers, dns_servers);
         assert_eq!(result.neighbors, neighbors);
@@ -1174,16 +1285,17 @@ mod tests {
     fn can_make_args() {
         let one_neighbor = NodeReference::new(
             PublicKey::new(&[1, 2, 3, 4]),
-            IpAddr::from_str("4.5.6.7").unwrap(),
+            Some(IpAddr::from_str("4.5.6.7").unwrap()),
             vec![1234, 2345],
         );
         let another_neighbor = NodeReference::new(
             PublicKey::new(&[2, 3, 4, 5]),
-            IpAddr::from_str("5.6.7.8").unwrap(),
+            Some(IpAddr::from_str("5.6.7.8").unwrap()),
             vec![3456, 4567],
         );
 
         let subject = NodeStartupConfigBuilder::standard()
+            .neighborhood_mode("consume-only")
             .ip(IpAddr::from_str("1.3.5.7").unwrap())
             .neighbor(one_neighbor.clone())
             .neighbor(another_neighbor.clone())
@@ -1195,6 +1307,8 @@ mod tests {
         assert_eq!(
             result,
             Command::strings(vec!(
+                "--neighborhood-mode",
+                "consume-only",
                 "--ip",
                 "1.3.5.7",
                 "--dns-servers",

multinode_integration_tests/src/utils.rs

@@ -1,5 +1,10 @@
 // Copyright (c) 2017-2019, Substratum LLC (https://substratum.net) and/or its affiliates. All rights reserved.
 
+use crate::substratum_node::SubstratumNode;
+use node_lib::neighborhood::node_record::NodeRecordInner;
+use node_lib::neighborhood::AccessibleGossipRecord;
+use node_lib::sub_lib::cryptde::{CryptData, PlainData};
+use std::collections::BTreeSet;
 use std::io::{ErrorKind, Read, Write};
 use std::net::TcpStream;
 use std::time::{Duration, Instant};
@@ -58,3 +63,26 @@ pub fn wait_for_shutdown(stream: &mut TcpStream, timeout: &Duration) -> Result<(
         Err(e) => Err(e),
     }
 }
+
+impl From<&dyn SubstratumNode> for AccessibleGossipRecord {
+    fn from(substratum_node: &dyn SubstratumNode) -> Self {
+        let cryptde = substratum_node.signing_cryptde().unwrap_or_else (|| panic! ("You can only make an AccessibleGossipRecord from a SubstratumRealNode if it has a CryptDENull, not a CryptDEReal."));
+        let mut agr = AccessibleGossipRecord {
+            inner: NodeRecordInner {
+                data_version: NodeRecordInner::data_version(),
+                public_key: substratum_node.public_key().clone(),
+                earning_wallet: substratum_node.earning_wallet(),
+                rate_pack: substratum_node.rate_pack(),
+                neighbors: BTreeSet::new(),
+                accepts_connections: substratum_node.accepts_connections(),
+                routes_data: substratum_node.routes_data(),
+                version: 0,
+            },
+            node_addr_opt: Some(substratum_node.node_addr()),
+            signed_gossip: PlainData::new(b""),
+            signature: CryptData::new(b""),
+        };
+        agr.regenerate_signed_gossip(cryptde);
+        agr
+    }
+}

multinode_integration_tests/tests/data_routing_test.rs

@@ -1,5 +1,6 @@
 // Copyright (c) 2017-2019, Substratum LLC (https://substratum.net) and/or its affiliates. All rights reserved.
 
+use itertools::Itertools;
 use multinode_integration_tests_lib::substratum_node::SubstratumNode;
 use multinode_integration_tests_lib::substratum_node_cluster::SubstratumNodeCluster;
 use multinode_integration_tests_lib::substratum_real_node::{
@@ -64,6 +65,49 @@ fn http_end_to_end_routing_test() {
     );
 }
 
+#[test]
+fn http_end_to_end_routing_test_with_consume_and_originate_only_nodes() {
+    let mut cluster = SubstratumNodeCluster::start().unwrap();
+    let first_node = cluster.start_real_node(NodeStartupConfigBuilder::standard().build());
+    let _second_node = cluster.start_real_node(
+        NodeStartupConfigBuilder::standard()
+            .neighbor(first_node.node_reference())
+            .build(),
+    );
+    let originating_node = cluster.start_real_node(
+        NodeStartupConfigBuilder::consume_only()
+            .neighbor(first_node.node_reference())
+            .build(),
+    );
+    let _potential_exit_nodes = vec![0, 1, 2, 3, 4]
+        .into_iter()
+        .map(|_| {
+            cluster.start_real_node(
+                NodeStartupConfigBuilder::originate_only()
+                    .neighbor(first_node.node_reference())
+                    .build(),
+            )
+        })
+        .collect_vec();
+
+    thread::sleep(Duration::from_millis(1000));
+
+    let mut client = originating_node.make_client(8080);
+    client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n");
+    let response = client.wait_for_chunk();
+
+    assert_eq!(
+        index_of(
+            &response,
+            &b"This domain is established to be used for illustrative examples in documents."[..]
+        )
+        .is_some(),
+        true,
+        "Actual response:\n{}",
+        String::from_utf8(response).unwrap()
+    );
+}
+
 #[test]
 fn tls_end_to_end_routing_test() {
     let mut cluster = SubstratumNodeCluster::start().unwrap();

multinode_integration_tests/tests/self_test.rs

@@ -88,7 +88,10 @@ fn server_relays_cores_package() {
     client.transmit_package(incipient, &masquerader, cryptde.public_key().clone());
     let package = server.wait_for_package(Duration::from_millis(1000));
     let expired = package
-        .to_expired(IpAddr::from_str("1.2.3.4").unwrap(), server.cryptde())
+        .to_expired(
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
+            server.cryptde(),
+        )
         .unwrap();
 
     route.shift(cryptde).unwrap();
@@ -137,7 +140,7 @@ fn one_mock_node_talks_to_another() {
         .unwrap();
     let expired_cores_package = package
         .to_expired(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             mock_node_2.signing_cryptde().unwrap(),
         )
         .unwrap();

node/Cargo.lock

@@ -81,7 +81,7 @@ impl ActorSystemFactoryReal {
         let (dispatcher_subs, pool_bind_sub) = actor_factory.make_and_start_dispatcher();
         let proxy_server_subs = actor_factory.make_and_start_proxy_server(
             cryptde,
-            config.neighborhood_config.is_decentralized(),
+            config.neighborhood_config.mode.is_decentralized(),
             if config.consuming_wallet.is_none() {
                 None
             } else {
@@ -91,14 +91,26 @@ impl ActorSystemFactoryReal {
         let proxy_client_subs = actor_factory.make_and_start_proxy_client(ProxyClientConfig {
             cryptde,
             dns_servers: config.dns_servers.clone(),
-            exit_service_rate: config.neighborhood_config.rate_pack.exit_service_rate,
-            exit_byte_rate: config.neighborhood_config.rate_pack.exit_byte_rate,
+            exit_service_rate: config
+                .neighborhood_config
+                .mode
+                .rate_pack()
+                .exit_service_rate,
+            exit_byte_rate: config.neighborhood_config.mode.rate_pack().exit_byte_rate,
         });
         let hopper_subs = actor_factory.make_and_start_hopper(HopperConfig {
             cryptde,
-            per_routing_service: config.neighborhood_config.rate_pack.routing_service_rate,
-            per_routing_byte: config.neighborhood_config.rate_pack.routing_byte_rate,
-            is_decentralized: config.neighborhood_config.is_decentralized(),
+            per_routing_service: config
+                .neighborhood_config
+                .mode
+                .rate_pack()
+                .routing_service_rate,
+            per_routing_byte: config
+                .neighborhood_config
+                .mode
+                .rate_pack()
+                .routing_byte_rate,
+            is_decentralized: config.neighborhood_config.mode.is_decentralized(),
         });
         let blockchain_bridge_subs =
             actor_factory.make_and_start_blockchain_bridge(&config, &db_initializer);
@@ -393,10 +405,11 @@ mod tests {
     use crate::sub_lib::dispatcher::{InboundClientData, StreamShutdownMsg};
     use crate::sub_lib::hopper::IncipientCoresPackage;
     use crate::sub_lib::hopper::{ExpiredCoresPackage, NoLookupIncipientCoresPackage};
-    use crate::sub_lib::neighborhood::RemoveNeighborMessage;
     use crate::sub_lib::neighborhood::{DispatcherNodeQueryMessage, NodeRecordMetadataMessage};
     use crate::sub_lib::neighborhood::{NeighborhoodConfig, NodeQueryMessage};
     use crate::sub_lib::neighborhood::{NeighborhoodDotGraphRequest, RouteQueryMessage};
+    use crate::sub_lib::neighborhood::{NeighborhoodMode, RemoveNeighborMessage};
+    use crate::sub_lib::node_addr::NodeAddr;
     use crate::sub_lib::peer_actors::StartMessage;
     use crate::sub_lib::proxy_client::{
         ClientResponsePayload, DnsResolveFailure, InboundServerData,
@@ -410,10 +423,6 @@ mod tests {
     use crate::sub_lib::ui_gateway::UiGatewayConfig;
     use crate::sub_lib::ui_gateway::{FromUiMessage, UiCarrierMessage};
     use crate::test_utils::rate_pack;
-    use crate::test_utils::rate_pack_exit;
-    use crate::test_utils::rate_pack_exit_byte;
-    use crate::test_utils::rate_pack_routing;
-    use crate::test_utils::rate_pack_routing_byte;
     use crate::test_utils::recorder::Recorder;
     use crate::test_utils::recorder::Recording;
     use crate::test_utils::{cryptde, make_wallet, DEFAULT_CHAIN_ID};
@@ -912,10 +921,11 @@ mod tests {
             crash_point: CrashPoint::None,
             dns_servers: vec![],
             neighborhood_config: NeighborhoodConfig {
-                neighbor_configs: vec![],
-                local_ip_addr: IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)),
-                clandestine_port_list: vec![],
-                rate_pack: rate_pack(100),
+                mode: NeighborhoodMode::Standard(
+                    NodeAddr::new(&IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), &vec![]),
+                    vec![],
+                    rate_pack(100),
+                ),
             },
             accountant_config: AccountantConfig {
                 payable_scan_interval: Duration::from_secs(100),
@@ -970,10 +980,7 @@ mod tests {
             crash_point: CrashPoint::None,
             dns_servers: vec![],
             neighborhood_config: NeighborhoodConfig {
-                neighbor_configs: vec![],
-                local_ip_addr: IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)),
-                clandestine_port_list: vec![],
-                rate_pack: rate_pack(100),
+                mode: NeighborhoodMode::ZeroHop,
             },
             accountant_config: AccountantConfig {
                 payable_scan_interval: Duration::from_secs(100),
@@ -1019,12 +1026,12 @@ mod tests {
         check_start_message(&recordings.accountant);
         let hopper_config = Parameters::get(parameters.hopper_params);
         check_cryptde(hopper_config.cryptde);
-        assert_eq!(hopper_config.per_routing_service, rate_pack_routing(100));
-        assert_eq!(hopper_config.per_routing_byte, rate_pack_routing_byte(100));
+        assert_eq!(hopper_config.per_routing_service, 0);
+        assert_eq!(hopper_config.per_routing_byte, 0);
         let proxy_client_config = Parameters::get(parameters.proxy_client_params);
         check_cryptde(proxy_client_config.cryptde);
-        assert_eq!(proxy_client_config.exit_service_rate, rate_pack_exit(100),);
-        assert_eq!(proxy_client_config.exit_byte_rate, rate_pack_exit_byte(100),);
+        assert_eq!(proxy_client_config.exit_service_rate, 0);
+        assert_eq!(proxy_client_config.exit_byte_rate, 0);
         assert_eq!(proxy_client_config.dns_servers, config.dns_servers);
         let (actual_cryptde, actual_is_decentralized, consuming_wallet_balance) =
             Parameters::get(parameters.proxy_server_params);
@@ -1071,10 +1078,11 @@ mod tests {
             crash_point: CrashPoint::None,
             dns_servers: vec![],
             neighborhood_config: NeighborhoodConfig {
-                neighbor_configs: vec![],
-                local_ip_addr: IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)),
-                clandestine_port_list: vec![],
-                rate_pack: rate_pack(100),
+                mode: NeighborhoodMode::Standard(
+                    NodeAddr::new(&IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), &vec![]),
+                    vec![],
+                    rate_pack(100),
+                ),
             },
             accountant_config: AccountantConfig {
                 payable_scan_interval: Duration::from_secs(100),

node/src/actor_system_factory.rs

@@ -10,7 +10,7 @@ use crate::sub_lib::hopper::{ExpiredCoresPackage, MessageType, NoLookupIncipient
 use crate::sub_lib::route::Route;
 use crate::sub_lib::route::RouteError;
 use serde_derive::{Deserialize, Serialize};
-use std::net::IpAddr;
+use std::net::SocketAddr;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct LiveCoresPackage {
@@ -72,7 +72,7 @@ impl LiveCoresPackage {
 
     pub fn to_expired(
         self,
-        immediate_neighbor_ip: IpAddr,
+        immediate_neighbor_addr: SocketAddr,
         cryptde: &dyn CryptDE, // Must be the CryptDE of the Node for which the payload is intended.
     ) -> Result<ExpiredCoresPackage<MessageType>, String> {
         let top_hop = match self.route.next_hop(cryptde) {
@@ -81,7 +81,7 @@ impl LiveCoresPackage {
         };
         decodex::<MessageType>(cryptde, &self.payload).map(|decoded_payload| {
             ExpiredCoresPackage::new(
-                immediate_neighbor_ip,
+                immediate_neighbor_addr,
                 top_hop.payer.map(|p| p.wallet),
                 self.route,
                 decoded_payload,
@@ -107,6 +107,7 @@ mod tests {
         cryptde, make_meaningless_message_type, make_meaningless_route, make_paying_wallet,
         DEFAULT_CHAIN_ID,
     };
+    use std::net::{IpAddr, SocketAddr};
     use std::str::FromStr;
 
     #[test]
@@ -288,7 +289,7 @@ mod tests {
 
     #[test]
     fn expired_cores_package_can_be_constructed_from_live_cores_package() {
-        let immediate_neighbor_ip = IpAddr::from_str("1.2.3.4").unwrap();
+        let immediate_neighbor_ip = SocketAddr::from_str("1.2.3.4:1234").unwrap();
         let payload = make_meaningless_message_type();
         let first_stop_key = PublicKey::new(&[3, 4]);
         let first_stop_cryptde = CryptDENull::from(&first_stop_key, DEFAULT_CHAIN_ID);
@@ -319,7 +320,7 @@ mod tests {
             .to_expired(immediate_neighbor_ip, &first_stop_cryptde)
             .unwrap();
 
-        assert_eq!(result.immediate_neighbor_ip, immediate_neighbor_ip);
+        assert_eq!(result.immediate_neighbor, immediate_neighbor_ip);
         assert_eq!(
             result.paying_wallet,
             Some(paying_wallet.as_address_wallet())
@@ -381,7 +382,7 @@ mod tests {
             CryptData::new(cryptde().private_key().as_slice()),
         );
 
-        let result = subject.to_expired(IpAddr::from_str("1.2.3.4").unwrap(), cryptde());
+        let result = subject.to_expired(SocketAddr::from_str("1.2.3.4:1234").unwrap(), cryptde());
 
         assert_eq!(result, Err(format!("{:?}", RouteError::EmptyRoute)));
     }

node/src/bootstrapper.rs

@@ -13,7 +13,7 @@ use crate::sub_lib::proxy_server::ProxyServerSubs;
 use crate::sub_lib::stream_handler_pool::TransmitDataMsg;
 use actix::Recipient;
 use std::borrow::Borrow;
-use std::net::IpAddr;
+use std::net::SocketAddr;
 
 pub struct RoutingServiceSubs {
     pub proxy_client_subs: ProxyClientSubs,
@@ -89,18 +89,12 @@ impl RoutingService {
             }
         };
 
-        self.route_data(
-            peer_addr.ip(),
-            next_hop,
-            live_package,
-            last_data,
-            &ibcd_but_data,
-        );
+        self.route_data(peer_addr, next_hop, live_package, last_data, &ibcd_but_data);
     }
 
     fn route_data(
         &self,
-        sender_ip: IpAddr,
+        sender_addr: SocketAddr,
         next_hop: LiveHop,
         live_package: LiveCoresPackage,
         last_data: bool,
@@ -121,7 +115,7 @@ impl RoutingService {
                 live_package.payload.len(),
                 next_hop.component
             );
-            self.route_data_internally(&next_hop, sender_ip, live_package, ibcd_but_data)
+            self.route_data_internally(&next_hop, sender_addr, live_package, ibcd_but_data)
         }
     }
 
@@ -132,7 +126,7 @@ impl RoutingService {
     fn route_data_internally(
         &self,
         next_hop: &LiveHop,
-        immediate_neighbor_ip: IpAddr,
+        immediate_neighbor_addr: SocketAddr,
         live_package: LiveCoresPackage,
         ibcd_but_data: &InboundClientData,
     ) {
@@ -156,7 +150,7 @@ impl RoutingService {
             }
             self.route_data_to_peripheral_component(
                 next_hop.component,
-                immediate_neighbor_ip,
+                immediate_neighbor_addr,
                 live_package,
                 next_hop.payer_owns_secret_key(&self.cryptde.digest()),
             )
@@ -195,13 +189,13 @@ impl RoutingService {
     fn route_data_to_peripheral_component(
         &self,
         component: Component,
-        immediate_neighbor_ip: IpAddr,
+        immediate_neighbor_addr: SocketAddr,
         live_package: LiveCoresPackage,
         payer_owns_secret_key: bool,
     ) {
         let data_len = live_package.payload.len();
         let expired_package =
-            match live_package.to_expired(immediate_neighbor_ip, self.cryptde.borrow()) {
+            match live_package.to_expired(immediate_neighbor_addr, self.cryptde.borrow()) {
                 Ok(pkg) => pkg,
                 Err(e) => {
                     error!(
@@ -223,7 +217,7 @@ impl RoutingService {
                         .proxy_client_subs
                         .from_hopper
                         .try_send(ExpiredCoresPackage::new(
-                            expired_package.immediate_neighbor_ip,
+                            expired_package.immediate_neighbor,
                             expired_package.paying_wallet,
                             expired_package.remaining_route,
                             client_request,
@@ -248,7 +242,7 @@ impl RoutingService {
                 .proxy_server_subs
                 .from_hopper
                 .try_send(ExpiredCoresPackage::new(
-                    expired_package.immediate_neighbor_ip,
+                    expired_package.immediate_neighbor,
                     expired_package.paying_wallet,
                     expired_package.remaining_route,
                     client_reponse,
@@ -260,7 +254,7 @@ impl RoutingService {
                 .proxy_server_subs
                 .dns_failure_from_hopper
                 .try_send(ExpiredCoresPackage::new(
-                    expired_package.immediate_neighbor_ip,
+                    expired_package.immediate_neighbor,
                     expired_package.paying_wallet,
                     expired_package.remaining_route,
                     dns_resolve_failure,
@@ -272,7 +266,7 @@ impl RoutingService {
                 .neighborhood_subs
                 .from_hopper
                 .try_send(ExpiredCoresPackage::new(
-                    expired_package.immediate_neighbor_ip,
+                    expired_package.immediate_neighbor,
                     expired_package.paying_wallet,
                     expired_package.remaining_route,
                     gossip,
@@ -601,12 +595,9 @@ mod tests {
         let component_recording = component_recording_arc.lock().unwrap();
         let record = component_recording.get_record::<ExpiredCoresPackage<ClientRequestPayload>>(0);
         let expected_ecp = lcp_a
-            .to_expired(IpAddr::from_str("1.2.3.4").unwrap(), cryptde)
+            .to_expired(SocketAddr::from_str("1.2.3.4:5678").unwrap(), cryptde)
             .unwrap();
-        assert_eq!(
-            record.immediate_neighbor_ip,
-            expected_ecp.immediate_neighbor_ip
-        );
+        assert_eq!(record.immediate_neighbor, expected_ecp.immediate_neighbor);
         assert_eq!(record.paying_wallet, expected_ecp.paying_wallet);
         assert_eq!(record.remaining_route, expected_ecp.remaining_route);
         assert_eq!(record.payload, payload);
@@ -663,12 +654,9 @@ mod tests {
         let record =
             component_recording.get_record::<ExpiredCoresPackage<ClientResponsePayload>>(0);
         let expected_ecp = lcp_a
-            .to_expired(IpAddr::from_str("1.3.2.4").unwrap(), cryptde)
+            .to_expired(SocketAddr::from_str("1.3.2.4:5678").unwrap(), cryptde)
             .unwrap();
-        assert_eq!(
-            record.immediate_neighbor_ip,
-            expected_ecp.immediate_neighbor_ip
-        );
+        assert_eq!(record.immediate_neighbor, expected_ecp.immediate_neighbor);
         assert_eq!(record.paying_wallet, expected_ecp.paying_wallet);
         assert_eq!(record.remaining_route, expected_ecp.remaining_route);
         assert_eq!(record.payload, payload);
@@ -733,12 +721,9 @@ mod tests {
         let component_recording = component_recording_arc.lock().unwrap();
         let record = component_recording.get_record::<ExpiredCoresPackage<Gossip>>(0);
         let expected_ecp = lcp_a
-            .to_expired(IpAddr::from_str("1.3.2.4").unwrap(), cryptde)
+            .to_expired(SocketAddr::from_str("1.3.2.4:5678").unwrap(), cryptde)
             .unwrap();
-        assert_eq!(
-            record.immediate_neighbor_ip,
-            expected_ecp.immediate_neighbor_ip
-        );
+        assert_eq!(record.immediate_neighbor, expected_ecp.immediate_neighbor);
         assert_eq!(record.paying_wallet, expected_ecp.paying_wallet);
         assert_eq!(record.remaining_route, expected_ecp.remaining_route);
         assert_eq!(record.payload, payload);

node/src/hopper/live_cores_package.rs

@@ -7,8 +7,14 @@ pub trait DotRenderable {
     fn render(&self) -> String;
 }
 
+pub struct NodeRenderableInner {
+    pub version: u32,
+    pub accepts_connections: bool,
+    pub routes_data: bool,
+}
+
 pub struct NodeRenderable {
-    pub version: Option<u32>,
+    pub inner: Option<NodeRenderableInner>,
     pub public_key: PublicKey,
     pub node_addr: Option<NodeAddr>,
     pub known_source: bool,
@@ -36,8 +42,13 @@ impl DotRenderable for NodeRenderable {
 
 impl NodeRenderable {
     fn render_label(&self) -> String {
-        let version_string = match self.version {
-            Some(v) => format!("v{}\\n", v),
+        let inner_string = match &self.inner {
+            Some(inner) => format!(
+                "{}{} v{}\\n",
+                if inner.accepts_connections { "A" } else { "a" },
+                if inner.routes_data { "R" } else { "r" },
+                inner.version,
+            ),
             None => String::new(),
         };
         let public_key_str = format!("{}", self.public_key);
@@ -53,7 +64,7 @@ impl NodeRenderable {
 
         format!(
             " [label=\"{}{}{}\"]",
-            version_string, public_key_trunc, node_addr_string,
+            inner_string, public_key_trunc, node_addr_string,
         )
     }
 }
@@ -91,7 +102,11 @@ mod tests {
         let public_key_64 = format!("{}", public_key);
         let public_key_trunc = String::from(&public_key_64[0..8]);
         let node = NodeRenderable {
-            version: Some(1),
+            inner: Some(NodeRenderableInner {
+                version: 1,
+                accepts_connections: true,
+                routes_data: true,
+            }),
             public_key: public_key.clone(),
             node_addr: None,
             known_source: false,
@@ -104,7 +119,7 @@ mod tests {
         assert_string_contains(
             &result,
             &format!(
-                "\"{}\" [label=\"v1\\n{}\"];",
+                "\"{}\" [label=\"AR v1\\n{}\"];",
                 public_key_64, public_key_trunc
             ),
         );
@@ -115,7 +130,11 @@ mod tests {
         let public_key = PublicKey::new(&b"ABC"[..]);
         let public_key_64 = format!("{}", public_key);
         let node = NodeRenderable {
-            version: Some(1),
+            inner: Some(NodeRenderableInner {
+                version: 1,
+                accepts_connections: false,
+                routes_data: false,
+            }),
             public_key: public_key.clone(),
             node_addr: None,
             known_source: false,
@@ -127,7 +146,10 @@ mod tests {
 
         assert_string_contains(
             &result,
-            &format!("\"{}\" [label=\"v1\\n{}\"];", public_key_64, public_key_64),
+            &format!(
+                "\"{}\" [label=\"ar v1\\n{}\"];",
+                public_key_64, public_key_64
+            ),
         );
     }
 }

node/src/hopper/routing_service.rs

@@ -2,22 +2,23 @@
 use super::node_record::NodeRecord;
 use super::node_record::NodeRecordInner;
 use crate::neighborhood::dot_graph::{
-    render_dot_graph, DotRenderable, EdgeRenderable, NodeRenderable,
+    render_dot_graph, DotRenderable, EdgeRenderable, NodeRenderable, NodeRenderableInner,
 };
 use crate::neighborhood::neighborhood_database::NeighborhoodDatabase;
 use crate::neighborhood::AccessibleGossipRecord;
 use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData, PublicKey};
 use crate::sub_lib::data_version::DataVersion;
 use crate::sub_lib::hopper::MessageType;
 use crate::sub_lib::node_addr::NodeAddr;
+use pretty_hex::PrettyHex;
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::convert::{TryFrom, TryInto};
 use std::fmt::Debug;
 use std::fmt::Error;
 use std::fmt::Formatter;
 use std::iter::FromIterator;
-use std::net::IpAddr;
+use std::net::{IpAddr, SocketAddr};
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct GossipNodeRecord {
@@ -82,7 +83,6 @@ impl From<NodeRecord> for GossipNodeRecord {
 }
 
 impl GossipNodeRecord {
-    // TODO - should we use a json serializer to make this?
     fn to_human_readable(&self) -> String {
         let mut human_readable = String::new();
         human_readable.push_str("\nGossipNodeRecord {");
@@ -104,8 +104,14 @@ impl GossipNodeRecord {
             Err(_e) => human_readable.push_str("\n\tinner: <non-deserializable>"),
         };
         human_readable.push_str(&format!("\n\tnode_addr_opt: {:?},", self.node_addr_opt));
-        human_readable.push_str(&format!("\n\tsigned_data: {:?},", self.signed_data));
-        human_readable.push_str(&format!("\n\tsignature: {:?},", self.signature));
+        human_readable.push_str(&format!(
+            "\n\tsigned_data:\n{:?}",
+            self.signed_data.as_slice().hex_dump()
+        ));
+        human_readable.push_str(&format!(
+            "\n\tsignature:\n{:?}",
+            self.signature.as_slice().hex_dump()
+        ));
         human_readable.push_str("\n}");
         human_readable
     }
@@ -221,6 +227,16 @@ impl From<IpAddr> for DotGossipEndpoint {
     }
 }
 
+// Produces incomplete representation
+impl From<SocketAddr> for DotGossipEndpoint {
+    fn from(input: SocketAddr) -> Self {
+        DotGossipEndpoint {
+            public_key: PublicKey::new(b""),
+            node_addr_opt: Some(NodeAddr::new(&input.ip(), &vec![input.port()])),
+        }
+    }
+}
+
 struct SrcDestRenderable {
     name: String,
     prefix: String,
@@ -338,7 +354,11 @@ impl Gossip {
                 })
             });
             node_renderables.push(NodeRenderable {
-                version: Some(nri.version),
+                inner: Some(NodeRenderableInner {
+                    version: nri.version,
+                    accepts_connections: nri.accepts_connections,
+                    routes_data: nri.routes_data,
+                }),
                 public_key: nri.public_key.clone(),
                 node_addr: addr.clone(),
                 known_source: nri.public_key == source.public_key,
@@ -348,7 +368,7 @@ impl Gossip {
         });
         mentioned.difference(&present).for_each(|k| {
             node_renderables.push(NodeRenderable {
-                version: None,
+                inner: None,
                 public_key: k.clone(),
                 node_addr: None,
                 known_source: false,
@@ -399,7 +419,7 @@ impl<'a> GossipBuilder<'a> {
             None => panic!("GossipBuilder cannot add a nonexistent Node"),
             Some(node_record_ref) => {
                 let mut gnr = GossipNodeRecord::from(node_record_ref.clone());
-                if !reveal_node_addr {
+                if !reveal_node_addr || !node_record_ref.accepts_connections() {
                     gnr.node_addr_opt = None
                 }
                 self.gossip.node_records.push(gnr);
@@ -419,6 +439,7 @@ impl<'a> GossipBuilder<'a> {
 mod tests {
     use super::super::gossip::GossipBuilder;
     use super::super::neighborhood_test_utils::make_node_record;
+    use super::super::neighborhood_test_utils::make_node_record_f;
     use super::*;
     use crate::neighborhood::neighborhood_test_utils::db_from_node;
     use crate::test_utils::{assert_string_contains, vec_to_btset};
@@ -463,8 +484,12 @@ mod tests {
 
     #[test]
     fn adding_node_with_no_addr_and_reveal_results_in_node_with_no_addr() {
-        let node = make_node_record(1234, false);
-        let mut db = db_from_node(&node);
+        let node = make_node_record_f(1234, false, false, true);
+        let mut db: NeighborhoodDatabase = db_from_node(&node);
+        db.node_by_key_mut(node.public_key())
+            .unwrap()
+            .inner
+            .accepts_connections = true;
         let gossip_node = &db.add_node(make_node_record(2345, false)).unwrap();
         let builder = GossipBuilder::new(&db);
 
@@ -476,8 +501,12 @@ mod tests {
 
     #[test]
     fn adding_node_with_no_addr_and_no_reveal_results_in_node_with_no_addr() {
-        let node = make_node_record(1234, false);
-        let db = db_from_node(&node);
+        let node = make_node_record_f(1234, false, false, true);
+        let mut db: NeighborhoodDatabase = db_from_node(&node);
+        db.node_by_key_mut(node.public_key())
+            .unwrap()
+            .inner
+            .accepts_connections = true;
         let builder = GossipBuilder::new(&db);
 
         let builder = builder.node(node.public_key(), false);
@@ -486,6 +515,22 @@ mod tests {
         assert_eq!(gossip.node_records.remove(0).node_addr_opt, None)
     }
 
+    #[test]
+    fn adding_node_that_doesnt_accept_with_addr_and_reveal_results_in_node_with_no_addr() {
+        let node: NodeRecord = make_node_record(1234, true);
+        let mut db: NeighborhoodDatabase = db_from_node(&node);
+        db.node_by_key_mut(node.public_key())
+            .unwrap()
+            .inner
+            .accepts_connections = false;
+        let builder = GossipBuilder::new(&db);
+
+        let builder = builder.node(node.public_key(), true);
+
+        let mut gossip = builder.build();
+        assert_eq!(gossip.node_records.remove(0).node_addr_opt, None)
+    }
+
     #[test]
     fn gossip_node_record_keeps_all_half_neighbors() {
         let mut this_node = make_node_record(1234, true);
@@ -564,8 +609,28 @@ mod tests {
             "\nGossipNodeRecord {{{}{}{}{}\n}}",
             "\n\tinner: NodeRecordInner {\n\t\tpublic_key: AQIDBA,\n\t\tnode_addr_opt: Some(1.2.3.4:[1234]),\n\t\tearning_wallet: Wallet { kind: Address(0x546900db8d6e0937497133d1ae6fdf5f4b75bcd0) },\n\t\trate_pack: RatePack { routing_byte_rate: 1235, routing_service_rate: 1236, exit_byte_rate: 1237, exit_service_rate: 1238 },\n\t\tneighbors: [],\n\t\tversion: 2,\n\t},",
             "\n\tnode_addr_opt: Some(1.2.3.4:[1234]),",
-            "\n\tsigned_data: PlainData { data: [166, 108, 100, 97, 116, 97, 95, 118, 101, 114, 115, 105, 111, 110, 131, 0, 0, 0, 106, 112, 117, 98, 108, 105, 99, 95, 107, 101, 121, 68, 1, 2, 3, 4, 110, 101, 97, 114, 110, 105, 110, 103, 95, 119, 97, 108, 108, 101, 116, 161, 103, 97, 100, 100, 114, 101, 115, 115, 148, 24, 84, 24, 105, 0, 24, 219, 24, 141, 24, 110, 9, 24, 55, 24, 73, 24, 113, 24, 51, 24, 209, 24, 174, 24, 111, 24, 223, 24, 95, 24, 75, 24, 117, 24, 188, 24, 208, 105, 114, 97, 116, 101, 95, 112, 97, 99, 107, 164, 113, 114, 111, 117, 116, 105, 110, 103, 95, 98, 121, 116, 101, 95, 114, 97, 116, 101, 25, 4, 211, 116, 114, 111, 117, 116, 105, 110, 103, 95, 115, 101, 114, 118, 105, 99, 101, 95, 114, 97, 116, 101, 25, 4, 212, 110, 101, 120, 105, 116, 95, 98, 121, 116, 101, 95, 114, 97, 116, 101, 25, 4, 213, 113, 101, 120, 105, 116, 95, 115, 101, 114, 118, 105, 99, 101, 95, 114, 97, 116, 101, 25, 4, 214, 105, 110, 101, 105, 103, 104, 98, 111, 114, 115, 128, 103, 118, 101, 114, 115, 105, 111, 110, 2] },",
-            "\n\tsignature: CryptData { data: [1, 2, 3, 4, 13, 203, 98, 91, 91, 124, 75, 12, 242, 126, 76, 106, 236, 12, 26, 1, 199, 218, 114, 177] },"
+            "\n\tsigned_data:
+Length: 246 (0xf6) bytes
+0000:   a8 6c 64 61  74 61 5f 76  65 72 73 69  6f 6e 83 00   .ldata_version..
+0010:   10 00 6a 70  75 62 6c 69  63 5f 6b 65  79 44 01 02   ..jpublic_keyD..
+0020:   03 04 6e 65  61 72 6e 69  6e 67 5f 77  61 6c 6c 65   ..nearning_walle
+0030:   74 a1 67 61  64 64 72 65  73 73 94 18  54 18 69 00   t.gaddress..T.i.
+0040:   18 db 18 8d  18 6e 09 18  37 18 49 18  71 18 33 18   .....n..7.I.q.3.
+0050:   d1 18 ae 18  6f 18 df 18  5f 18 4b 18  75 18 bc 18   ....o..._.K.u...
+0060:   d0 69 72 61  74 65 5f 70  61 63 6b a4  71 72 6f 75   .irate_pack.qrou
+0070:   74 69 6e 67  5f 62 79 74  65 5f 72 61  74 65 19 04   ting_byte_rate..
+0080:   d3 74 72 6f  75 74 69 6e  67 5f 73 65  72 76 69 63   .trouting_servic
+0090:   65 5f 72 61  74 65 19 04  d4 6e 65 78  69 74 5f 62   e_rate...nexit_b
+00a0:   79 74 65 5f  72 61 74 65  19 04 d5 71  65 78 69 74   yte_rate...qexit
+00b0:   5f 73 65 72  76 69 63 65  5f 72 61 74  65 19 04 d6   _service_rate...
+00c0:   69 6e 65 69  67 68 62 6f  72 73 80 73  61 63 63 65   ineighbors.sacce
+00d0:   70 74 73 5f  63 6f 6e 6e  65 63 74 69  6f 6e 73 f5   pts_connections.
+00e0:   6b 72 6f 75  74 65 73 5f  64 61 74 61  f5 67 76 65   kroutes_data.gve
+00f0:   72 73 69 6f  6e 02                                   rsion.",
+            "\n\tsignature:
+Length: 24 (0x18) bytes
+0000:   01 02 03 04  67 5b 38 53  63 59 ad a8  3d e1 d5 96   ....g[8ScY..=...
+0010:   89 59 88 be  09 86 64 ae                             .Y....d.",
         );
 
         assert_eq!(result, expected);
@@ -585,11 +650,15 @@ mod tests {
             "\nGossipNodeRecord {{{}{}{}{}\n}}",
             "\n\tinner: <non-deserializable>",
             "\n\tnode_addr_opt: None,",
-            "\n\tsigned_data: PlainData { data: [1, 2, 3, 4] },",
-            "\n\tsignature: CryptData { data: [4, 3, 2, 1] },"
+            "\n\tsigned_data:
+Length: 4 (0x4) bytes
+0000:   01 02 03 04                                          ....",
+            "\n\tsignature:
+Length: 4 (0x4) bytes
+0000:   04 03 02 01                                          ....",
         );
 
-        assert_eq!(expected, result);
+        assert_eq!(result, expected);
     }
 
     #[test]
@@ -623,14 +692,14 @@ mod tests {
         let result = gossip.to_dot_graph(&source_node, &target_node);
 
         assert_string_contains(&result, "digraph db { ");
-        assert_string_contains(&result, "\"AwQFBg\" [label=\"v0\\nAwQFBg\"]; ");
+        assert_string_contains(&result, "\"AwQFBg\" [label=\"AR v0\\nAwQFBg\"]; ");
         assert_string_contains(
             &result,
-            "\"QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo\" [label=\"v1\\nQUJDREVG\\n1.2.3.4:1234\"] [style=filled]; ",
+            "\"QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo\" [label=\"AR v1\\nQUJDREVG\\n1.2.3.4:1234\"] [style=filled]; ",
         );
         assert_string_contains(
             &result,
-            "\"WllYV1ZVVFNSUVBPTk1MS0pJSEdGRURDQkE\" [label=\"v0\\nWllYV1ZV\\n2.3.4.5:2345\"] [shape=box]; ",
+            "\"WllYV1ZVVFNSUVBPTk1MS0pJSEdGRURDQkE\" [label=\"AR v0\\nWllYV1ZV\\n2.3.4.5:2345\"] [shape=box]; ",
         );
         assert_string_contains(
             &result,

node/src/neighborhood/dot_graph.rs

@@ -35,8 +35,12 @@ impl GossipProducer for GossipProducerReal {
             .filter(|k| *k != target)
             .flat_map(|k| database.node_by_key(k))
             .fold(GossipBuilder::new(database), |so_far, node_record_ref| {
-                let reveal_node_addr = node_record_ref.public_key() == database.root().public_key()
-                    || target_node_ref.has_half_neighbor(node_record_ref.public_key()); // TODO SC-894/GH-132: Do we really want to reveal this?
+                let reveal_node_addr = node_record_ref.accepts_connections()
+                    && (
+                        node_record_ref.public_key() == database.root().public_key()
+                            || target_node_ref.has_half_neighbor(node_record_ref.public_key())
+                        // TODO SC-894/GH-132: Do we really want to reveal this?
+                    );
                 so_far.node(node_record_ref.public_key(), reveal_node_addr)
             });
         builder.build()
@@ -61,7 +65,8 @@ mod tests {
     use super::*;
     use crate::neighborhood::neighborhood_test_utils::db_from_node;
     use crate::neighborhood::neighborhood_test_utils::make_node_record;
-    use crate::neighborhood::node_record::NodeRecordInner;
+    use crate::neighborhood::node_record::{NodeRecord, NodeRecordInner};
+    use crate::neighborhood::AccessibleGossipRecord;
     use crate::sub_lib::cryptde::CryptDE;
     use crate::sub_lib::cryptde_null::CryptDENull;
     use crate::test_utils::DEFAULT_CHAIN_ID;
@@ -83,17 +88,22 @@ mod tests {
     #[test]
     fn produce_reveals_and_conceals_node_addrs_appropriately() {
         let root_node = make_node_record(1234, true);
-        let mut db = db_from_node(&root_node);
+        let mut db: NeighborhoodDatabase = db_from_node(&root_node);
         let target_node_key = &db.add_node(make_node_record(1235, true)).unwrap();
         let common_neighbor_key = &db.add_node(make_node_record(1236, true)).unwrap();
         let root_full_neighbor_key = &db.add_node(make_node_record(1237, true)).unwrap();
         let target_full_neighbor_key = &db.add_node(make_node_record(1238, false)).unwrap();
         let knows_target_key = &db.add_node(make_node_record(1239, false)).unwrap();
         let target_knows_key = &db.add_node(make_node_record(1240, false)).unwrap();
         let knows_root_key = &db.add_node(make_node_record(1241, false)).unwrap();
-        let root_knows_key = &db.add_node(make_node_record(1242, true)).unwrap();
-        let root_bootstrap_key = &db.add_node(make_node_record(1243, true)).unwrap();
-        let target_bootstrap_key = &db.add_node(make_node_record(1244, false)).unwrap();
+        let root_knows_key_ac = &db.add_node(make_node_record(1242, true)).unwrap();
+        let root_knows_key_nac = &db.add_node(make_node_record(1243, true)).unwrap();
+        db.node_by_key_mut(root_knows_key_nac)
+            .unwrap()
+            .inner
+            .accepts_connections = false;
+        let root_bootstrap_key = &db.add_node(make_node_record(1244, true)).unwrap();
+        let target_bootstrap_key = &db.add_node(make_node_record(1245, false)).unwrap();
         db.add_arbitrary_full_neighbor(root_node.public_key(), target_node_key);
         db.add_arbitrary_full_neighbor(root_node.public_key(), common_neighbor_key);
         db.add_arbitrary_full_neighbor(target_node_key, common_neighbor_key);
@@ -102,7 +112,9 @@ mod tests {
         db.add_arbitrary_half_neighbor(knows_target_key, target_node_key);
         db.add_arbitrary_half_neighbor(knows_root_key, root_node.public_key());
         db.add_arbitrary_half_neighbor(target_node_key, target_knows_key);
-        db.add_arbitrary_half_neighbor(root_node.public_key(), root_knows_key);
+        db.add_arbitrary_half_neighbor(root_node.public_key(), root_knows_key_ac);
+        db.add_arbitrary_half_neighbor(root_node.public_key(), root_knows_key_nac);
+        db.add_arbitrary_half_neighbor(target_node_key, root_knows_key_nac);
         db.add_arbitrary_full_neighbor(target_node_key, target_bootstrap_key);
         db.add_arbitrary_full_neighbor(root_node.public_key(), root_bootstrap_key);
         let subject = GossipProducerReal::new();
@@ -142,7 +154,8 @@ mod tests {
             node_digest(knows_target_key, false),
             node_digest(target_knows_key, false),
             node_digest(knows_root_key, false),
-            node_digest(root_knows_key, false),
+            node_digest(root_knows_key_ac, false),
+            node_digest(root_knows_key_nac, false),
             node_digest(root_bootstrap_key, false),
             node_digest(target_bootstrap_key, false),
         ];
@@ -153,27 +166,82 @@ mod tests {
             .map(|gnr| gnr_digest(gnr))
             .collect::<Vec<Digest>>();
         actual_gossip_digests.sort_unstable_by(|a, b| a.0.cmp(&b.0));
-        assert_eq!(expected_gossip_digests, actual_gossip_digests);
+        assert_eq!(actual_gossip_digests, expected_gossip_digests);
     }
 
     #[test]
-    fn produce_debut_creates_a_gossip_to_a_target_about_ourselves() {
-        let our_node_record = make_node_record(7771, true);
+    fn produce_does_not_reveal_root_node_addr_if_root_does_not_accept_connections() {
+        let root_node: NodeRecord = make_node_record(1234, true);
+        let mut db: NeighborhoodDatabase = db_from_node(&root_node);
+        db.node_by_key_mut(root_node.public_key())
+            .unwrap()
+            .inner
+            .accepts_connections = false;
+        let target_node_key = &db.add_node(make_node_record(1235, true)).unwrap();
+        db.add_arbitrary_full_neighbor(root_node.public_key(), target_node_key);
+        let subject = GossipProducerReal::new();
+        let db = db.clone();
+
+        let gossip = subject.produce(&db, target_node_key);
+
+        let gossip_root = gossip
+            .node_records
+            .into_iter()
+            .map(|gnr| AccessibleGossipRecord::try_from(gnr).unwrap())
+            .find(|agr| &agr.inner.public_key == root_node.public_key())
+            .unwrap();
+        assert_eq!(gossip_root.node_addr_opt, None);
+    }
+
+    #[test]
+    fn produce_debut_creates_a_gossip_to_a_target_about_ourselves_when_accepting_connections() {
+        let our_node_record: NodeRecord = make_node_record(7771, true);
         let db = db_from_node(&our_node_record);
         let subject = GossipProducerReal::new();
+
         let result_gossip: Gossip = subject.produce_debut(&db);
-        assert_eq!(1, result_gossip.node_records.len());
+
+        assert_eq!(result_gossip.node_records.len(), 1);
         let result_gossip_record = result_gossip.node_records.first().unwrap();
+        assert_eq!(
+            result_gossip_record.node_addr_opt,
+            Some(our_node_record.metadata.node_addr_opt.clone().unwrap())
+        );
         let result_node_record_inner = NodeRecordInner::try_from(result_gossip_record).unwrap();
-        assert_eq!(our_node_record.inner, result_node_record_inner);
+        assert_eq!(result_node_record_inner, our_node_record.inner);
         let our_cryptde = CryptDENull::from(our_node_record.public_key(), DEFAULT_CHAIN_ID);
         assert_eq!(
+            our_cryptde.verify_signature(
+                &our_node_record.signed_gossip,
+                &our_node_record.signature,
+                our_cryptde.public_key()
+            ),
             true,
+        );
+    }
+
+    #[test]
+    fn produce_debut_creates_a_gossip_to_a_target_about_ourselves_when_not_accepting_connections() {
+        let mut our_node_record: NodeRecord = make_node_record(7771, true);
+        our_node_record.inner.accepts_connections = false;
+        let db = db_from_node(&our_node_record);
+        let subject = GossipProducerReal::new();
+
+        let result_gossip: Gossip = subject.produce_debut(&db);
+
+        assert_eq!(result_gossip.node_records.len(), 1);
+        let result_gossip_record = result_gossip.node_records.first().unwrap();
+        assert_eq!(result_gossip_record.node_addr_opt, None);
+        let result_node_record_inner = NodeRecordInner::try_from(result_gossip_record).unwrap();
+        assert_eq!(result_node_record_inner, our_node_record.inner);
+        let our_cryptde = CryptDENull::from(our_node_record.public_key(), DEFAULT_CHAIN_ID);
+        assert_eq!(
             our_cryptde.verify_signature(
                 &our_node_record.signed_gossip,
                 &our_node_record.signature,
                 our_cryptde.public_key()
-            )
+            ),
+            true,
         );
     }
 }

node/src/neighborhood/gossip.rs

@@ -1,14 +1,15 @@
 // Copyright (c) 2017-2019, Substratum LLC (https://substratum.net) and/or its affiliates. All rights reserved.
 use super::neighborhood_database::NeighborhoodDatabaseError::NodeKeyNotFound;
 use crate::neighborhood::dot_graph::{
-    render_dot_graph, DotRenderable, EdgeRenderable, NodeRenderable,
+    render_dot_graph, DotRenderable, EdgeRenderable, NodeRenderable, NodeRenderableInner,
 };
 use crate::neighborhood::node_record::{NodeRecord, NodeRecordError};
+use crate::sub_lib::cryptde::CryptDE;
 use crate::sub_lib::cryptde::PublicKey;
-use crate::sub_lib::cryptde::{CryptDE, PlainData};
-use crate::sub_lib::neighborhood::RatePack;
+use crate::sub_lib::neighborhood::NeighborhoodMode;
 use crate::sub_lib::node_addr::NodeAddr;
 use crate::sub_lib::wallet::Wallet;
+use itertools::Itertools;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fmt::Debug;
@@ -32,9 +33,8 @@ impl Debug for NeighborhoodDatabase {
 impl NeighborhoodDatabase {
     pub fn new(
         public_key: &PublicKey,
-        node_addr: &NodeAddr,
+        neighborhood_mode: NeighborhoodMode,
         earning_wallet: Wallet,
-        rate_pack: RatePack,
         cryptde: &dyn CryptDE,
     ) -> NeighborhoodDatabase {
         let mut result = NeighborhoodDatabase {
@@ -43,13 +43,20 @@ impl NeighborhoodDatabase {
             by_ip_addr: HashMap::new(),
         };
 
-        let mut node_record = NodeRecord::new(public_key, earning_wallet, rate_pack, 0, cryptde);
-        node_record
-            .set_node_addr(node_addr)
-            .expect("Failed to set_node_addr");
-        node_record.signed_gossip = PlainData::from(
-            serde_cbor::ser::to_vec(&node_record.inner).expect("Couldn't serialize"),
-        );
+        let mut node_record = NodeRecord::new(
+            public_key,
+            earning_wallet,
+            neighborhood_mode.rate_pack().clone(),
+            neighborhood_mode.accepts_connections(),
+            neighborhood_mode.routes_data(),
+            0,
+            cryptde,
+        );
+        if let Some(node_addr) = neighborhood_mode.node_addr_opt() {
+            node_record
+                .set_node_addr(&node_addr)
+                .expect("NodeAddr suddenly appeared out of nowhere");
+        }
         node_record.regenerate_signed_gossip(cryptde);
         result.add_arbitrary_node(node_record);
         result
@@ -99,7 +106,12 @@ impl NeighborhoodDatabase {
             None => return 0,
             Some(n) => n,
         };
-        let full_degree = target_node.full_neighbors(self).len();
+        let full_accepting_degree = target_node
+            .full_neighbors(self)
+            .into_iter()
+            .filter(|k| k.accepts_connections())
+            .collect_vec()
+            .len();
         let keys = self.keys();
         // If a Node in our database references a Node not in our database, we can't tell
         // whether that's a half or full neighborship. We assume here for purposes of
@@ -109,7 +121,7 @@ impl NeighborhoodDatabase {
             .into_iter()
             .filter(|k| !keys.contains(k))
             .count();
-        full_degree + nonexistent_degree
+        full_accepting_degree + nonexistent_degree
     }
 
     pub fn add_node(
@@ -207,7 +219,11 @@ impl NeighborhoodDatabase {
                 })
             });
             node_renderables.push(NodeRenderable {
-                version: Some(nr.version()),
+                inner: Some(NodeRenderableInner {
+                    version: nr.version(),
+                    accepts_connections: nr.accepts_connections(),
+                    routes_data: nr.routes_data(),
+                }),
                 public_key: public_key.clone(),
                 node_addr: nr.node_addr_opt().clone(),
                 known_source: public_key == self.root().public_key(),
@@ -217,7 +233,7 @@ impl NeighborhoodDatabase {
         });
         mentioned.difference(&present).for_each(|k| {
             node_renderables.push(NodeRenderable {
-                version: None,
+                inner: None,
                 public_key: k.clone(),
                 node_addr: None,
                 known_source: false,
@@ -283,7 +299,7 @@ mod tests {
     use super::*;
     use crate::neighborhood::neighborhood_test_utils::db_from_node;
     use crate::sub_lib::cryptde_null::CryptDENull;
-    use crate::test_utils::{assert_string_contains, rate_pack, DEFAULT_CHAIN_ID};
+    use crate::test_utils::{assert_string_contains, DEFAULT_CHAIN_ID};
     use std::iter::FromIterator;
     use std::str::FromStr;
 
@@ -321,9 +337,8 @@ mod tests {
 
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             this_node.earning_wallet(),
-            rate_pack(1234),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
 
@@ -393,9 +408,8 @@ mod tests {
         let another_node = make_node_record(5678, true);
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             Wallet::from_str("0x546900db8d6e0937497133d1ae6fdf5f4b75bcd0").unwrap(),
-            rate_pack(1234),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
 
@@ -448,9 +462,8 @@ mod tests {
         let another_node = make_node_record(3456, true);
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             Wallet::from_str("0x0000000000000000000000000000000000001234").unwrap(),
-            rate_pack(100),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
         subject.add_node(one_node.clone()).unwrap();
@@ -577,9 +590,8 @@ mod tests {
         let other_node = make_node_record(2345, true);
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             Wallet::from_str("0x0000000000000000000000000000000000001234").unwrap(),
-            rate_pack(100),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
         subject.add_node(other_node.clone()).unwrap();
@@ -606,12 +618,19 @@ mod tests {
     fn gossip_target_degree() {
         let root = make_node_record(1000, true);
         let mut db = db_from_node(&root);
-        // full-neighbor
+        // connection-accepting full-neighbor
         let a = &db.add_node(make_node_record(1001, true)).unwrap();
         let b = &db.add_node(make_node_record(1002, true)).unwrap();
         let c = &db.add_node(make_node_record(1003, true)).unwrap();
         db.add_arbitrary_full_neighbor(a, b);
         db.add_arbitrary_full_neighbor(a, c);
+        // connection-rejecting full-neighbor
+        let g = {
+            let mut g_node: NodeRecord = make_node_record(2001, true);
+            g_node.inner.accepts_connections = false;
+            &db.add_node(g_node).unwrap()
+        };
+        db.add_arbitrary_full_neighbor(a, g);
         // half-neighbor
         let m = &db.add_node(make_node_record(1004, true)).unwrap();
         let n = &db.add_node(make_node_record(1005, true)).unwrap();
@@ -662,19 +681,19 @@ mod tests {
         assert_eq!(result.matches("->").count(), 8);
         assert_string_contains(
             &result,
-            "\"AQIDBA\" [label=\"v1\\nAQIDBA\\n1.2.3.4:1234\"] [style=filled];",
+            "\"AQIDBA\" [label=\"AR v1\\nAQIDBA\\n1.2.3.4:1234\"] [style=filled];",
         );
         assert_string_contains(
             &result,
-            "\"AgMEBQ\" [label=\"v0\\nAgMEBQ\\n2.3.4.5:2345\"];",
+            "\"AgMEBQ\" [label=\"AR v0\\nAgMEBQ\\n2.3.4.5:2345\"];",
         );
         assert_string_contains(
             &result,
-            "\"AwQFBg\" [label=\"v0\\nAwQFBg\\n3.4.5.6:3456\"];",
+            "\"AwQFBg\" [label=\"AR v0\\nAwQFBg\\n3.4.5.6:3456\"];",
         );
         assert_string_contains(
             &result,
-            "\"BAUGBw\" [label=\"v0\\nBAUGBw\\n4.5.6.7:4567\"];",
+            "\"BAUGBw\" [label=\"AR v0\\nBAUGBw\\n4.5.6.7:4567\"];",
         );
         assert_string_contains(&result, "\"AQIDBA\" -> \"AgMEBQ\";");
         assert_string_contains(&result, "\"AgMEBQ\" -> \"AQIDBA\";");
@@ -691,9 +710,8 @@ mod tests {
         let this_node = make_node_record(123, true);
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             Wallet::from_str("0x0000000000000000000000000000000000000123").unwrap(),
-            rate_pack(100),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
         let nonexistent_key = &PublicKey::new(b"nonexistent");
@@ -738,9 +756,8 @@ mod tests {
         let this_node = make_node_record(123, true);
         let mut subject = NeighborhoodDatabase::new(
             this_node.public_key(),
-            &this_node.node_addr_opt().unwrap(),
+            (&this_node).into(),
             Wallet::from_str("0x0000000000000000000000000000000000000123").unwrap(),
-            rate_pack(100),
             &CryptDENull::from(this_node.public_key(), DEFAULT_CHAIN_ID),
         );
         let neighborless_node = make_node_record(2345, true);

node/src/neighborhood/gossip_acceptor.rs

@@ -8,14 +8,13 @@ use crate::neighborhood::{AccessibleGossipRecord, Neighborhood};
 use crate::sub_lib::cryptde::PublicKey;
 use crate::sub_lib::cryptde::{CryptDE, PlainData};
 use crate::sub_lib::cryptde_null::CryptDENull;
-use crate::sub_lib::neighborhood::{NeighborhoodConfig, NodeDescriptor};
+use crate::sub_lib::neighborhood::{NeighborhoodConfig, NeighborhoodMode, NodeDescriptor};
 use crate::sub_lib::node_addr::NodeAddr;
 use crate::sub_lib::wallet::Wallet;
 use crate::test_utils::*;
 use std::convert::TryFrom;
 use std::net::IpAddr;
 use std::net::Ipv4Addr;
-use std::str::FromStr;
 
 impl From<(&NeighborhoodDatabase, &PublicKey, bool)> for AccessibleGossipRecord {
     fn from(
@@ -35,7 +34,25 @@ pub fn make_node_record(n: u16, has_ip: bool) -> NodeRecord {
     let ip_addr = IpAddr::V4(Ipv4Addr::new(a, b, c, d));
     let node_addr = NodeAddr::new(&ip_addr, &vec![n % 10000]);
 
-    NodeRecord::new_for_tests(&key, if has_ip { Some(&node_addr) } else { None }, n as u64)
+    NodeRecord::new_for_tests(
+        &key,
+        if has_ip { Some(&node_addr) } else { None },
+        n as u64,
+        true,
+        true,
+    )
+}
+
+pub fn make_node_record_f(
+    n: u16,
+    has_ip: bool,
+    accepts_connections: bool,
+    routes_data: bool,
+) -> NodeRecord {
+    let mut result = make_node_record(n, has_ip);
+    result.inner.accepts_connections = accepts_connections;
+    result.inner.routes_data = routes_data;
+    result
 }
 
 pub fn make_global_cryptde_node_record(n: u16, has_ip: bool) -> NodeRecord {
@@ -53,12 +70,8 @@ pub fn make_meaningless_db() -> NeighborhoodDatabase {
 pub fn db_from_node(node: &NodeRecord) -> NeighborhoodDatabase {
     NeighborhoodDatabase::new(
         node.public_key(),
-        &node.node_addr_opt().unwrap_or(NodeAddr::new(
-            &IpAddr::from_str("200.200.200.200").unwrap(),
-            &vec![200],
-        )),
+        node.into(),
         node.earning_wallet(),
-        node.rate_pack().clone(),
         &CryptDENull::from(node.public_key(), DEFAULT_CHAIN_ID),
     )
 }
@@ -72,29 +85,44 @@ pub fn neighborhood_from_nodes(
         panic!("Neighborhood must be built on root node with public key from cryptde()");
     }
     let mut config = BootstrapperConfig::new();
-    config.neighborhood_config = NeighborhoodConfig {
-        neighbor_configs: match neighbor_opt {
-            None => vec![],
-            Some(neighbor) => vec![NodeDescriptor {
-                public_key: neighbor.public_key().clone(),
-                node_addr: neighbor
-                    .node_addr_opt()
-                    .expect("Neighbor has to have NodeAddr"),
-            }
-            .to_string(cryptde, DEFAULT_CHAIN_ID)],
+    config.neighborhood_config = match neighbor_opt {
+        Some(neighbor) => NeighborhoodConfig {
+            mode: NeighborhoodMode::Standard(
+                root.node_addr_opt().expect("Test-drive me!"),
+                vec![NodeDescriptor::from(neighbor).to_string(cryptde, DEFAULT_CHAIN_ID)],
+                root.rate_pack().clone(),
+            ),
+        },
+        None => NeighborhoodConfig {
+            mode: NeighborhoodMode::ZeroHop,
         },
-        local_ip_addr: root
-            .node_addr_opt()
-            .expect("Root has to have NodeAddr")
-            .ip_addr(),
-        clandestine_port_list: root.node_addr_opt().unwrap().ports(),
-        rate_pack: root.rate_pack().clone(),
     };
     config.earning_wallet = root.earning_wallet();
     config.consuming_wallet = Some(make_paying_wallet(b"consuming"));
     Neighborhood::new(cryptde, &config)
 }
 
+impl From<&NodeRecord> for NeighborhoodMode {
+    // Note: not a general-purpose function. Doesn't detect ZeroHop and doesn't reconstruct neighbor_configs.
+    fn from(node: &NodeRecord) -> Self {
+        match (
+            node.node_addr_opt(),
+            node.accepts_connections(),
+            node.routes_data(),
+        ) {
+            (Some(node_addr), true, true) => {
+                NeighborhoodMode::Standard(node_addr, vec![], node.rate_pack().clone())
+            }
+            (_, false, true) => NeighborhoodMode::OriginateOnly(vec![], node.rate_pack().clone()),
+            (_, false, false) => NeighborhoodMode::ConsumeOnly(vec![]),
+            (node_addr_opt, accepts_connections, routes_data) => panic!(
+                "Cannot determine NeighborhoodMode from triple: ({:?}, {}, {})",
+                node_addr_opt, accepts_connections, routes_data
+            ),
+        }
+    }
+}
+
 impl NodeRecord {
     pub fn earning_wallet_from_key(public_key: &PublicKey) -> Wallet {
         match Self::consuming_wallet_from_key(public_key) {
@@ -119,11 +147,15 @@ impl NodeRecord {
         public_key: &PublicKey,
         node_addr_opt: Option<&NodeAddr>,
         base_rate: u64,
+        accepts_connections: bool,
+        routes_data: bool,
     ) -> NodeRecord {
         let mut node_record = NodeRecord::new(
             public_key,
             NodeRecord::earning_wallet_from_key(public_key),
             rate_pack(base_rate),
+            accepts_connections,
+            routes_data,
             0,
             &CryptDENull::from(public_key, DEFAULT_CHAIN_ID),
         );

node/src/neighborhood/gossip_producer.rs

@@ -5,6 +5,7 @@ use crate::neighborhood::neighborhood_database::{NeighborhoodDatabase, Neighborh
 use crate::neighborhood::{regenerate_signed_gossip, AccessibleGossipRecord};
 use crate::sub_lib::cryptde::{CryptDE, CryptData, PlainData, PublicKey};
 use crate::sub_lib::data_version::DataVersion;
+use crate::sub_lib::neighborhood::NodeDescriptor;
 use crate::sub_lib::neighborhood::RatePack;
 use crate::sub_lib::node_addr::NodeAddr;
 use crate::sub_lib::wallet::Wallet;
@@ -21,12 +22,14 @@ pub struct NodeRecordInner {
     pub earning_wallet: Wallet,
     pub rate_pack: RatePack,
     pub neighbors: BTreeSet<PublicKey>,
+    pub accepts_connections: bool,
+    pub routes_data: bool,
     pub version: u32,
 }
 
 impl NodeRecordInner {
     pub fn data_version() -> DataVersion {
-        DataVersion::new(0, 0).expect("Internal Error")
+        DataVersion::new(1, 0).expect("Internal Error")
     }
 }
 
@@ -67,6 +70,8 @@ impl NodeRecord {
         public_key: &PublicKey,
         earning_wallet: Wallet,
         rate_pack: RatePack,
+        accepts_connections: bool,
+        routes_data: bool,
         version: u32,
         cryptde: &dyn CryptDE, // Must be the new NodeRecord's CryptDE: used for signing
     ) -> NodeRecord {
@@ -77,6 +82,8 @@ impl NodeRecord {
                 public_key: public_key.clone(),
                 earning_wallet,
                 rate_pack,
+                accepts_connections,
+                routes_data,
                 neighbors: BTreeSet::new(),
                 version,
             },
@@ -95,6 +102,10 @@ impl NodeRecord {
         self.metadata.node_addr_opt.clone()
     }
 
+    pub fn node_descriptor(&self, cryptde: &dyn CryptDE, chain_id: u8) -> String {
+        NodeDescriptor::from(self).to_string(cryptde, chain_id)
+    }
+
     pub fn set_node_addr(
         &mut self,
         node_addr: &NodeAddr,
@@ -190,6 +201,14 @@ impl NodeRecord {
         &self.signature
     }
 
+    pub fn accepts_connections(&self) -> bool {
+        self.inner.accepts_connections
+    }
+
+    pub fn routes_data(&self) -> bool {
+        self.inner.routes_data
+    }
+
     pub fn version(&self) -> u32 {
         self.inner.version
     }
@@ -356,6 +375,28 @@ mod tests {
         assert_eq!(subject.node_addr_opt(), Some(first_node_addr));
     }
 
+    #[test]
+    fn node_descriptor_works_when_node_addr_is_present() {
+        let mut subject = make_node_record(1234, true);
+        subject.metadata.node_addr_opt = Some(NodeAddr::new(
+            &subject.metadata.node_addr_opt.unwrap().ip_addr(),
+            &vec![1234, 2345],
+        ));
+
+        let result = subject.node_descriptor(cryptde(), DEFAULT_CHAIN_ID);
+
+        assert_eq!(result, "AQIDBA:1.2.3.4:1234;2345".to_string());
+    }
+
+    #[test]
+    fn node_descriptor_works_when_node_addr_is_not_present() {
+        let subject: NodeRecord = make_node_record(1234, false);
+
+        let result = subject.node_descriptor(cryptde(), DEFAULT_CHAIN_ID);
+
+        assert_eq!(result, "AQIDBA::".to_string());
+    }
+
     #[test]
     fn unset_node_addr() {
         let mut subject = make_node_record(1234, true);
@@ -516,27 +557,35 @@ mod tests {
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
         let duplicate = NodeRecord::new(
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
         let mut with_neighbor = NodeRecord::new(
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
         let mod_key = NodeRecord::new(
             &PublicKey::new(&b"kope"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
@@ -547,6 +596,8 @@ mod tests {
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
@@ -560,20 +611,44 @@ mod tests {
             &PublicKey::new(&b"poke"[..]),
             make_wallet("booga"),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
         let mod_rate_pack = NodeRecord::new(
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(200),
+            true,
+            true,
+            0,
+            cryptde(),
+        );
+        let mod_accepts_connections = NodeRecord::new(
+            &PublicKey::new(&b"poke"[..]),
+            earning_wallet.clone(),
+            rate_pack(100),
+            false,
+            true,
+            0,
+            cryptde(),
+        );
+        let mod_routes_data = NodeRecord::new(
+            &PublicKey::new(&b"poke"[..]),
+            earning_wallet.clone(),
+            rate_pack(100),
+            true,
+            false,
             0,
             cryptde(),
         );
         let mut mod_signed_gossip = NodeRecord::new(
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
@@ -582,6 +657,8 @@ mod tests {
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             0,
             cryptde(),
         );
@@ -590,6 +667,8 @@ mod tests {
             &PublicKey::new(&b"poke"[..]),
             earning_wallet.clone(),
             rate_pack(100),
+            true,
+            true,
             1,
             cryptde(),
         );
@@ -601,6 +680,8 @@ mod tests {
         assert_ne!(exemplar, mod_node_addr);
         assert_ne!(exemplar, mod_earning_wallet);
         assert_ne!(exemplar, mod_rate_pack);
+        assert_ne!(exemplar, mod_accepts_connections);
+        assert_ne!(exemplar, mod_routes_data);
         assert_ne!(exemplar, mod_signed_gossip);
         assert_ne!(exemplar, mod_signature);
         assert_ne!(exemplar, mod_version);

node/src/neighborhood/mod.rs

@@ -535,7 +535,7 @@ mod tests {
         };
         let cryptde = cryptde();
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             route_to_proxy_client(&cryptde.public_key(), cryptde),
             request,
@@ -672,7 +672,7 @@ mod tests {
             originator_public_key: PublicKey::new(&b"originator"[..]),
         };
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             make_meaningless_route(),
             request.clone().into(),
@@ -728,7 +728,7 @@ mod tests {
             originator_public_key: PublicKey::new(&b"originator"[..]),
         };
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             None,
             make_meaningless_route(),
             request,
@@ -783,7 +783,7 @@ mod tests {
             originator_public_key: cryptde.public_key().clone(),
         };
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             None,
             make_meaningless_route(),
             request.clone().into(),
@@ -1105,7 +1105,7 @@ mod tests {
 
         subject_addr
             .try_send(ExpiredCoresPackage::new(
-                IpAddr::from_str("2.3.4.5").unwrap(),
+                SocketAddr::from_str("2.3.4.5:1235").unwrap(),
                 Some(make_wallet("gnimusnoc")),
                 new_return_route.clone(),
                 payload.clone().into(),

node/src/neighborhood/neighborhood_database.rs

@@ -634,7 +634,7 @@ mod tests {
         );
 
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             make_meaningless_route(),
             client_request_payload.clone().into(),
@@ -690,7 +690,7 @@ mod tests {
                 originator_public_key: originator_key,
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.clone().into(),
@@ -760,7 +760,7 @@ mod tests {
                 originator_public_key: PublicKey::new(&b"men's souls"[..]),
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -870,7 +870,7 @@ mod tests {
                 originator_public_key: PublicKey::new(&b"men's souls"[..]),
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -978,7 +978,7 @@ mod tests {
                 originator_public_key: originator_key,
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -1043,7 +1043,7 @@ mod tests {
                 originator_public_key: PublicKey::new(&b"men's souls"[..]),
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -1152,7 +1152,7 @@ mod tests {
                 originator_public_key: originator_key,
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -1240,7 +1240,7 @@ mod tests {
             };
 
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -1349,7 +1349,7 @@ mod tests {
                 originator_public_key: originator_key,
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),
@@ -1411,7 +1411,7 @@ mod tests {
             originator_public_key: PublicKey::new(&b"men's souls"[..]),
         };
         let package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             make_meaningless_route(),
             client_request_payload.into(),
@@ -1480,7 +1480,7 @@ mod tests {
                 originator_public_key: PublicKey::new(&b"booga"[..]),
             };
             let package = ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("consuming")),
                 make_meaningless_route(),
                 client_request_payload.into(),

node/src/neighborhood/neighborhood_test_utils.rs

@@ -975,7 +975,6 @@ mod tests {
     use crate::test_utils::{make_meaningless_stream_key, DEFAULT_CHAIN_ID};
     use actix::System;
     use std::cell::RefCell;
-    use std::net::IpAddr;
     use std::net::SocketAddr;
     use std::str::FromStr;
     use std::sync::mpsc;
@@ -1338,7 +1337,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<ClientResponsePayload> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 client_response_payload.into(),
@@ -3007,7 +3006,7 @@ mod tests {
             },
         };
         let first_expired_cores_package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             remaining_route,
             client_response_payload,
@@ -3077,7 +3076,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<ClientResponsePayload> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 client_response_payload.into(),
@@ -3175,7 +3174,7 @@ mod tests {
         let first_exit_size = first_client_response_payload.sequenced_packet.data.len();
         let first_expired_cores_package: ExpiredCoresPackage<ClientResponsePayload> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 first_client_response_payload.into(),
@@ -3195,7 +3194,7 @@ mod tests {
         let second_exit_size = second_client_response_payload.sequenced_packet.data.len();
         let second_expired_cores_package: ExpiredCoresPackage<ClientResponsePayload> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.5").unwrap(),
+                SocketAddr::from_str("1.2.3.5:1235").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1235),
                 second_client_response_payload.into(),
@@ -3294,7 +3293,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 dns_resolve_failure.into(),
@@ -3386,7 +3385,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 dns_resolve_failure_payload.into(),
@@ -3460,7 +3459,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 dns_resolve_failure.into(),
@@ -3527,7 +3526,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, return_route_id),
                 dns_resolve_failure.into(),
@@ -3596,7 +3595,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, return_route_id),
                 dns_resolve_failure.into(),
@@ -3670,7 +3669,7 @@ mod tests {
 
         let expired_cores_package: ExpiredCoresPackage<DnsResolveFailure> =
             ExpiredCoresPackage::new(
-                IpAddr::from_str("1.2.3.4").unwrap(),
+                SocketAddr::from_str("1.2.3.4:1234").unwrap(),
                 Some(make_wallet("irrelevant")),
                 return_route_with_id(cryptde, 1234),
                 dns_resolve_failure.into(),
@@ -3717,7 +3716,7 @@ mod tests {
             },
         };
         let expired_cores_package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("consuming")),
             remaining_route,
             client_response_payload,
@@ -3783,7 +3782,7 @@ mod tests {
             },
         };
         let expired_cores_package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("irrelevant")),
             return_route_with_id(cryptde, 1234),
             client_response_payload,
@@ -3829,7 +3828,7 @@ mod tests {
             },
         };
         let expired_cores_package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("irrelevant")),
             Route {
                 hops: vec![make_cover_hop(cryptde), CryptData::new(&[0])],
@@ -3897,7 +3896,7 @@ mod tests {
             },
         };
         let expired_cores_package = ExpiredCoresPackage::new(
-            IpAddr::from_str("1.2.3.4").unwrap(),
+            SocketAddr::from_str("1.2.3.4:1234").unwrap(),
             Some(make_wallet("irrelevant")),
             return_route_with_id(cryptde, 1234),
             client_response_payload,

node/src/neighborhood/node_record.rs

@@ -15,7 +15,7 @@ use actix::Message;
 use actix::Recipient;
 use serde_derive::{Deserialize, Serialize};
 use std::fmt::Debug;
-use std::net::IpAddr;
+use std::net::SocketAddr;
 
 /// Special-case hack to avoid extending a Card From Hell. I'm not sure what the right way to do
 /// this is, but this doesn't feel like it. The intent here is to provide a way to send a CORES
@@ -91,7 +91,7 @@ impl IncipientCoresPackage {
 /// CORES package that has traversed the Substratum Network and is arriving at its destination
 #[derive(Clone, Debug, PartialEq, Message)]
 pub struct ExpiredCoresPackage<T> {
-    pub immediate_neighbor_ip: IpAddr,
+    pub immediate_neighbor: SocketAddr,
     pub paying_wallet: Option<Wallet>,
     pub remaining_route: Route, // This is topped by the hop that brought the package here, not the next hop
     pub payload: T,
@@ -100,14 +100,14 @@ pub struct ExpiredCoresPackage<T> {
 
 impl<T> ExpiredCoresPackage<T> {
     pub fn new(
-        immediate_neighbor_ip: IpAddr,
+        immediate_neighbor: SocketAddr,
         paying_wallet: Option<Wallet>,
         remaining_route: Route,
         payload: T,
         payload_len: usize,
     ) -> Self {
         ExpiredCoresPackage {
-            immediate_neighbor_ip,
+            immediate_neighbor,
             paying_wallet,
             remaining_route,
             payload,
@@ -150,6 +150,7 @@ mod tests {
         cryptde, make_meaningless_message_type, make_paying_wallet, DEFAULT_CHAIN_ID,
     };
     use actix::Actor;
+    use std::net::IpAddr;
     use std::str::FromStr;
 
     #[test]
@@ -258,7 +259,7 @@ mod tests {
 
     #[test]
     fn expired_cores_package_is_created_correctly() {
-        let immediate_neighbor_ip = IpAddr::from_str("1.2.3.4").unwrap();
+        let immediate_neighbor = SocketAddr::from_str("1.2.3.4:1234").unwrap();
         let a_key = PublicKey::new(&[65, 65, 65]);
         let b_key = PublicKey::new(&[66, 66, 66]);
         let cryptde = cryptde();
@@ -273,14 +274,14 @@ mod tests {
         let payload = make_meaningless_message_type();
 
         let subject: ExpiredCoresPackage<MessageType> = ExpiredCoresPackage::new(
-            immediate_neighbor_ip,
+            immediate_neighbor,
             Some(paying_wallet),
             route.clone(),
             payload.clone().into(),
             42,
         );
 
-        assert_eq!(subject.immediate_neighbor_ip, immediate_neighbor_ip);
+        assert_eq!(subject.immediate_neighbor, immediate_neighbor);
         assert_eq!(subject.paying_wallet, Some(make_paying_wallet(b"wallet")));
         assert_eq!(subject.remaining_route, route);
         assert_eq!(subject.payload, payload);