electrum: serve the indexed genesis hash in server.features

Addresses review on Blockstream#265. server.features now reports the genesis
block hash actually indexed at height 0 instead of the hardcoded
genesis_hash(config.network_type). The latter returns an all-zero
placeholder on Liquid testnet/regtest and can't reflect configurable
Elements regtest genesis blocks.

RPC::start runs after the initial sync, so height 0 is already
indexed; fall back to genesis_hash() only if it somehow isn't.

Also strengthens the test to assert the returned genesis_hash equals
the daemon's height-0 block hash (reversed, per the Electrum wire
format), rather than only checking it is a string.

Author: HusseinAdeiza

src/electrum/server.rs

@@ -1249,10 +1249,19 @@ impl RPC {
 
         let server_features = {
             use crate::chain::genesis_hash;
+            // Prefer the genesis block hash actually indexed at height 0 over the
+            // hardcoded genesis_hash(): on Liquid testnet/regtest the latter is an
+            // all-zero placeholder, and Elements regtest genesis is configurable.
+            // `start` runs after the initial sync, so height 0 is already indexed;
+            // fall back to genesis_hash() only if it somehow isn't.
+            let genesis_hash = query
+                .chain()
+                .hash_by_height(0)
+                .unwrap_or_else(|| genesis_hash(config.network_type));
             Arc::new(ServerFeatures {
                 hosts: config.electrum_public_hosts.clone().unwrap_or_default(),
                 server_version: format!("electrs-esplora {}", ELECTRS_VERSION),
-                genesis_hash: genesis_hash(config.network_type),
+                genesis_hash,
                 protocol_min: PROTOCOL_VERSION,
                 protocol_max: PROTOCOL_VERSION,
                 hash_function: "sha256".into(),

tests/electrum.rs

@@ -216,7 +216,7 @@ fn test_electrum_raw() {
 fn test_electrum_server_features_without_public_hosts() {
     // Electrum >= 4.7.0 calls server.features on connect, so it must answer
     // even when peer discovery is off (no --electrum-public-hosts). See #229.
-    let (_electrum_server, electrum_addr, mut _tester) = common::init_electrum_tester().unwrap();
+    let (_electrum_server, electrum_addr, tester) = common::init_electrum_tester().unwrap();
 
     let mut stream = TcpStream::connect(electrum_addr).unwrap();
     let s = write_and_read(
@@ -230,7 +230,21 @@ fn test_electrum_server_features_without_public_hosts() {
     let features = &reply["result"];
     assert_eq!(features["server_version"], "electrs-esplora 0.4.1");
     assert_eq!(features["hash_function"], "sha256");
-    assert!(features["genesis_hash"].is_string(), "missing genesis_hash: {}", s);
+
+    // The genesis hash must be the actual genesis block hash indexed at height 0,
+    // not the hardcoded genesis_hash() (which is an all-zero placeholder on
+    // Liquid testnet/regtest). The Electrum protocol serializes hashes reversed.
+    use bitcoin::hashes::Hash;
+    use bitcoin::hex::DisplayHex;
+    let mut genesis_bytes = tester.get_block_hash(0).unwrap().to_raw_hash().to_byte_array();
+    genesis_bytes.reverse();
+    let expected = genesis_bytes.to_lower_hex_string();
+    assert_eq!(
+        features["genesis_hash"].as_str(),
+        Some(expected.as_str()),
+        "genesis_hash must be the indexed height-0 block hash: {}",
+        s
+    );
 }
 
 #[cfg_attr(not(feature = "liquid"), test)]