Land verified protocol stack

Cargo.toml

@@ -83,6 +83,7 @@ secp256k1 = { version = ">=0.29.1, <0.30", default-features = false, features =
 
 # sha2 0.11: default features are alloc+oid; no std/asm feature is exposed.
 sha2 = { version = ">=0.11, <0.12", default-features = false }
+sha3 = { version = ">=0.11, <0.12", default-features = false }
 bitcoin_hashes = { version = ">=0.14, <0.15", default-features = false, features = [
     "alloc", "std",
 ] }

bin/bitcoin-rs/src/config.rs

@@ -291,6 +291,26 @@ impl CoreValue for Option<PathBuf> {
     }
 }
 
+impl CoreValue for Option<SocketAddr> {
+    fn apply(value: &str, slot: &mut Self) {
+        if let Ok(addr) = value.parse() {
+            *slot = Some(addr);
+        }
+    }
+}
+
+impl CoreValue for Option<Vec<bitcoin_rs_node::options::NetworkLabel>> {
+    fn apply(value: &str, slot: &mut Self) {
+        let entries = slot.get_or_insert_with(Vec::new);
+        for item in value.split(',') {
+            if let Ok(label) = bitcoin_rs_node::options::parse_network_label(item.trim()) {
+                if !entries.contains(&label) {
+                    entries.push(label);
+                }
+            }
+        }
+    }
+}
 /// Sets the one Core key that no table row can express: `listen` is a boolean
 /// switch over the bind list, not an address, and only its false value is an
 /// override. Returns whether it consumed `key`.
@@ -400,6 +420,7 @@ mod compat_tests {
     use anyhow::Result;
     use bitcoin_rs_node::{Auth, Network, NodeConfig, resolve};
     use std::fs;
+    use std::net::SocketAddr;
 
     fn load_conf(text: &str, network: Network) -> Result<NodeConfig> {
         let temp = tempfile::tempdir()?;
@@ -431,6 +452,50 @@ mod compat_tests {
         assert_eq!(config.p2p.listen, []);
         assert!(config.indexes.txindex);
         assert_eq!(config.storage.dbcache_mb, 768);
+
+        let conf_with_overlays = load_conf(
+            r"
+proxy=127.0.0.1:9050
+onion=127.0.0.1:9051
+dnsseed=0
+proxyrandomize=1
+torcontrol=127.0.0.1:9052
+torpassword=secret
+i2psam=127.0.0.1:7656
+i2pacceptincoming=1
+onlynet=onion,i2p
+",
+            Network::Mainnet,
+        )?;
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.proxy,
+            Some(SocketAddr::from(([127, 0, 0, 1], 9050)))
+        );
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.onion,
+            Some(SocketAddr::from(([127, 0, 0, 1], 9051)))
+        );
+        assert!(conf_with_overlays.p2p.overlay.proxy_randomize_credentials);
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.tor_control.as_deref(),
+            Some("127.0.0.1:9052")
+        );
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.tor_password.as_deref(),
+            Some("secret")
+        );
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.i2p_sam,
+            Some(SocketAddr::from(([127, 0, 0, 1], 7656)))
+        );
+        assert!(conf_with_overlays.p2p.overlay.i2p_accept_incoming);
+        assert_eq!(
+            conf_with_overlays.p2p.overlay.onlynet,
+            vec![
+                bitcoin_rs_node::options::NetworkLabel::Onion,
+                bitcoin_rs_node::options::NetworkLabel::I2p
+            ]
+        );
         Ok(())
     }
 
@@ -501,3 +566,69 @@ assumevalid=0000000000000000000000000000000000000000000000000000000000000000
         }
     }
 }
+
+#[cfg(test)]
+mod feature_option_tests {
+    use std::ffi::OsString;
+
+    use anyhow::Result;
+    use bitcoin_rs_node::NodeConfig;
+    use clap::Parser as _;
+
+    use super::{CliArgs, resolve};
+
+    fn load(args: &[&str], vars: &[(&str, &str)]) -> Result<NodeConfig> {
+        let argv = std::iter::once("bitcoin-rs").chain(args.iter().copied());
+        let cli = CliArgs::try_parse_from(argv)?;
+        resolve(
+            cli,
+            vars.iter()
+                .map(|(key, value)| (OsString::from(*key), OsString::from(*value))),
+        )
+    }
+
+    fn refusal(args: &[&str], vars: &[(&str, &str)]) -> String {
+        match load(args, vars) {
+            Ok(_) => panic!("configuration must be refused"),
+            Err(error) => error.to_string(),
+        }
+    }
+
+    #[test]
+    fn relay_switches_are_bare_cli_flags_and_the_command_line_beats_environment() -> Result<()> {
+        let off = load(&[], &[])?.p2p;
+        assert!(
+            !off.relay_offers.package_relay
+                && !off.relay_offers.stale_tip_relay
+                && !off.relay_offers.stale_tip_prefers_blocks
+        );
+
+        let on = load(
+            &[
+                "--p2p-package-relay",
+                "--p2p-stale-tip-relay",
+                "--p2p-stale-tip-prefers-blocks",
+            ],
+            &[],
+        )?
+        .p2p;
+        assert!(
+            on.relay_offers.package_relay
+                && on.relay_offers.stale_tip_relay
+                && on.relay_offers.stale_tip_prefers_blocks
+        );
+
+        let env_on = load(&[], &[("BITCOIN_RS_P2P_PACKAGE_RELAY", "true")])?.p2p;
+        assert!(env_on.relay_offers.package_relay);
+        let cli_off = load(
+            &["--p2p-package-relay=false"],
+            &[("BITCOIN_RS_P2P_PACKAGE_RELAY", "true")],
+        )?
+        .p2p;
+        assert!(!cli_off.relay_offers.package_relay);
+
+        let dangling = refusal(&["--p2p-stale-tip-prefers-blocks"], &[]);
+        assert!(dangling.contains("--p2p-stale-tip-relay"));
+        Ok(())
+    }
+}

bin/bitcoin-rs/tests/addrman_restart_e2e.rs

@@ -97,7 +97,7 @@ fn restart_reconnects(
     let datadir = learner.stop_keep_datadir()?;
     let bytes = std::fs::read(datadir.path().join("node/peers-fabfb5da.dat"))?;
     let book: serde_json::Value = serde_json::from_slice(&bytes[..bytes.len() - 32])?;
-    assert_eq!(book["version"], 8);
+    assert_eq!(book["version"], 9);
     assert_eq!(
         book["asmap_id"],
         json!(expected_map),

crates/chain/src/deployment.rs

@@ -530,6 +530,7 @@ mod tests {
             // prev_blockhash and the by_hash key pointing at a discarded hash.
             let node_id = if height == activation_height {
                 tree.insert_header_with_hash(header, expected_hash, NodeStatus::HeaderValid)?
+                    .id
             } else {
                 tree.insert_header(header, NodeStatus::HeaderValid)?
             };