Initial CPUNet support

Add cpunet prefix to PoW function and update CPUNET type in param.rs

Signed-off-by: Calisto Abel Mathias <[email protected]>

Add cpunet in log message

Use version number 0.32.4-cpunet

small-fix : BlockInterval path fix in bitcoin/src/network/params.rs

Bump version to 0.32.7-pre-cpunet

Author: Bob McElrath

bitcoin/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin"
-version = "0.33.0-alpha.0"
+version = "0.32.7-pre-cpunet"
 authors = ["Andrew Poelstra <[email protected]>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"

bitcoin/src/address/mod.rs

@@ -245,7 +245,7 @@ impl KnownHrp {
 
         match network {
             Bitcoin => Self::Mainnet,
-            Testnet(_) | Signet => Self::Testnets,
+            Testnet(_) | Signet | CPUNet => Self::Testnets,
             Regtest => Self::Regtest,
         }
     }

bitcoin/src/blockdata/constants.rs

@@ -85,7 +85,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
 
     let (in_script, out_script) = {
         match params.network {
-            Network::Testnet(TestnetVersion::V4) => (
+            Network::Testnet(TestnetVersion::V4) | Network::CPUNet => (
                 script::Builder::new()
                 .push_int_unchecked(486604799)
                 .push_int_non_minimal(4)
@@ -186,6 +186,16 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
             transactions,
         )
         .assume_checked(witness_root),
+        Network::CPUNet => Block::new_unchecked(
+            block::Header {
+                version: block::Version::ONE,
+                prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
+                merkle_root,
+                time: BlockTime::from_u32(1723652721),
+                bits: CompactTarget::from_consensus(0x1d00ffff),
+                nonce: 961348305
+            }, transactions,
+        ).assume_checked(witness_root)
     }
 }
 
@@ -228,6 +238,11 @@ impl ChainHash {
         6, 34, 110, 70, 17, 26, 11, 89, 202, 175, 18, 96, 67, 235, 91, 191, 40, 195, 79, 58, 94,
         51, 42, 31, 199, 178, 183, 60, 241, 136, 145, 15,
     ]);
+    /// `ChainHash` for cpunet bitcoin.
+    pub const CPUNET: Self = Self([
+        155, 244, 9, 169, 207, 188, 132, 171, 5, 153, 89, 228, 109, 99, 3, 243, 57, 98, 248, 5,
+        188, 141, 147, 51, 119, 165, 255, 187, 0, 0, 0, 0,
+    ]);
 
     /// Returns the hash of the `network` genesis block for use as a chain hash.
     ///
@@ -240,6 +255,7 @@ impl ChainHash {
             Network::Testnet(TestnetVersion::V4) => Self::TESTNET4,
             Network::Signet => Self::SIGNET,
             Network::Regtest => Self::REGTEST,
+            Network::CPUNet => Self::CPUNET,
         }
     }
 
@@ -254,6 +270,7 @@ impl ChainHash {
             Network::Testnet(TestnetVersion::V4) => Self::TESTNET4,
             Network::Signet => Self::SIGNET,
             Network::Regtest => Self::REGTEST,
+            Network::CPUNet => Self::CPUNET,
         }
     }
 
@@ -388,7 +405,8 @@ mod test {
             Network::Testnet(TestnetVersion::V4) => {},
             Network::Signet => {},
             Network::Regtest => {},
-            _ => panic!("update ChainHash::using_genesis_block and chain_hash_genesis_block with new variants"),
+            Network::CPUNet => {},
+            _ => panic!("Update ChainHash::using_genesis_block and chain_hash_genesis_block with new variants"),
         }
     }
 
@@ -409,6 +427,7 @@ mod test {
         testnet4_chain_hash_genesis_block, Network::Testnet(TestnetVersion::V4);
         signet_chain_hash_genesis_block, Network::Signet;
         regtest_chain_hash_genesis_block, Network::Regtest;
+        cpunet_chain_hash_genesis_block, Network::CPUNet;
     }
 
     // Test vector taken from: https://github.com/lightning/bolts/blob/master/00-introduction.md

bitcoin/src/network/mod.rs

@@ -35,7 +35,9 @@ pub enum NetworkKind {
 // ambiguous due to confusion caused by signet/testnet/regtest.
 impl NetworkKind {
     /// Returns true if this is real mainnet bitcoin.
-    pub fn is_mainnet(&self) -> bool { *self == NetworkKind::Main }
+    pub fn is_mainnet(&self) -> bool {
+        *self == NetworkKind::Main
+    }
 }
 
 impl From<Network> for NetworkKind {
@@ -44,7 +46,7 @@ impl From<Network> for NetworkKind {
 
         match n {
             Bitcoin => NetworkKind::Main,
-            Testnet(_) | Signet | Regtest => NetworkKind::Test,
+            Testnet(_) | Signet | Regtest | CPUNet => NetworkKind::Test,
         }
     }
 }
@@ -71,6 +73,8 @@ pub enum Network {
     Signet,
     /// Bitcoin's regtest network.
     Regtest,
+    /// Bitcoin's cpunet network.
+    CPUNet,
 }
 
 #[cfg(feature = "serde")]
@@ -128,6 +132,7 @@ impl Network {
             Network::Testnet(TestnetVersion::V4) => "testnet4",
             Network::Signet => "signet",
             Network::Regtest => "regtest",
+            Network::CPUNet => "cpunet",
         }
     }
 
@@ -149,6 +154,7 @@ impl Network {
             "testnet4" => Testnet(TestnetVersion::V4),
             "signet" => Signet,
             "regtest" => Regtest,
+            "cpunet" => CPUNet,
             _ => return Err(ParseNetworkError(core_arg.to_owned())),
         };
         Ok(network)
@@ -165,7 +171,9 @@ impl Network {
     /// let network = Network::Bitcoin;
     /// assert_eq!(network.chain_hash(), ChainHash::BITCOIN);
     /// ```
-    pub fn chain_hash(self) -> ChainHash { ChainHash::using_genesis_block_const(self) }
+    pub fn chain_hash(self) -> ChainHash {
+        ChainHash::using_genesis_block_const(self)
+    }
 
     /// Constructs a new `Network` from the chain hash (genesis block hash).
     ///
@@ -189,6 +197,7 @@ impl Network {
             Network::Testnet(TestnetVersion::V4) => &Params::TESTNET4,
             Network::Signet => &Params::SIGNET,
             Network::Regtest => &Params::REGTEST,
+            Network::CPUNet => &Params::CPUNET,
         }
     }
 
@@ -201,6 +210,7 @@ impl Network {
             Network::Testnet(TestnetVersion::V4) => "testnet4",
             Network::Signet => "signet",
             Network::Regtest => "regtest",
+            Network::CPUNet => "cpunet",
         }
     }
 }
@@ -232,15 +242,15 @@ pub mod as_core_arg {
                 Network::from_core_arg(s).map_err(|_| {
                     E::invalid_value(
                         serde::de::Unexpected::Str(s),
-                        &"bitcoin network encoded as a string (either main, test, testnet4, signet or regtest)",
+                        &"bitcoin network encoded as a string (either main, test, testnet4, signet, regtest, or cpunet)",
                     )
                 })
             }
 
             fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
                 write!(
                     formatter,
-                    "bitcoin network encoded as a string (either main, test, testnet4, signet or regtest)"
+                    "bitcoin network encoded as a string (either main, test, testnet4, signet, regtest or cpunet)"
                 )
             }
         }
@@ -262,7 +272,9 @@ impl fmt::Display for ParseNetworkError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for ParseNetworkError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
 }
 
 impl FromStr for Network {
@@ -277,6 +289,7 @@ impl FromStr for Network {
             "testnet4" => Ok(Network::Testnet(TestnetVersion::V4)),
             "signet" => Ok(Network::Signet),
             "regtest" => Ok(Network::Regtest),
+            "cpunet" => Ok(Network::CPUNet),
             _ => Err(ParseNetworkError(s.to_owned())),
         }
     }
@@ -301,7 +314,9 @@ impl fmt::Display for UnknownChainHashError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for UnknownChainHashError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
 }
 
 impl TryFrom<ChainHash> for Network {
@@ -315,6 +330,7 @@ impl TryFrom<ChainHash> for Network {
             ChainHash::TESTNET4 => Ok(Network::Testnet(TestnetVersion::V4)),
             ChainHash::SIGNET => Ok(Network::Signet),
             ChainHash::REGTEST => Ok(Network::Regtest),
+            ChainHash::CPUNET => Ok(Network::CPUNet),
             _ => Err(UnknownChainHashError(chain_hash)),
         }
     }
@@ -323,6 +339,35 @@ impl TryFrom<ChainHash> for Network {
 #[cfg(test)]
 mod tests {
     use super::{Network, TestnetVersion};
+    use crate::consensus::encode::{deserialize, serialize};
+
+    #[test]
+    fn serialize_deserialize() {
+        assert_eq!(serialize(&Network::Bitcoin.magic()), &[0xf9, 0xbe, 0xb4, 0xd9]);
+        assert_eq!(
+            serialize(&Network::Testnet(TestnetVersion::V3).magic()),
+            &[0x0b, 0x11, 0x09, 0x07]
+        );
+        assert_eq!(
+            serialize(&Network::Testnet(TestnetVersion::V4).magic()),
+            &[0x1c, 0x16, 0x3f, 0x28]
+        );
+        assert_eq!(serialize(&Network::Signet.magic()), &[0x0a, 0x03, 0xcf, 0x40]);
+        assert_eq!(serialize(&Network::Regtest.magic()), &[0xfa, 0xbf, 0xb5, 0xda]);
+
+        assert_eq!(deserialize(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(), Some(Network::Bitcoin.magic()));
+        assert_eq!(
+            deserialize(&[0x0b, 0x11, 0x09, 0x07]).ok(),
+            Some(Network::Testnet(TestnetVersion::V3).magic())
+        );
+        assert_eq!(
+            deserialize(&[0x1c, 0x16, 0x3f, 0x28]).ok(),
+            Some(Network::Testnet(TestnetVersion::V4).magic())
+        );
+        assert_eq!(deserialize(&[0x0a, 0x03, 0xcf, 0x40]).ok(), Some(Network::Signet.magic()));
+        assert_eq!(deserialize(&[0xfa, 0xbf, 0xb5, 0xda]).ok(), Some(Network::Regtest.magic()));
+        assert_eq!(deserialize(&[0x63, 0x70, 0x75, 0x6e]).ok(), Some(Network::CPUNet.magic()));
+    }
 
     #[test]
     fn string() {
@@ -331,12 +376,14 @@ mod tests {
         assert_eq!(Network::Testnet(TestnetVersion::V4).to_string(), "testnet4");
         assert_eq!(Network::Regtest.to_string(), "regtest");
         assert_eq!(Network::Signet.to_string(), "signet");
+        assert_eq!(Network::CPUNet.to_string(), "cpunet");
 
         assert_eq!("bitcoin".parse::<Network>().unwrap(), Network::Bitcoin);
         assert_eq!("testnet".parse::<Network>().unwrap(), Network::Testnet(TestnetVersion::V3));
         assert_eq!("testnet4".parse::<Network>().unwrap(), Network::Testnet(TestnetVersion::V4));
         assert_eq!("regtest".parse::<Network>().unwrap(), Network::Regtest);
         assert_eq!("signet".parse::<Network>().unwrap(), Network::Signet);
+        assert_eq!("cpunet".parse::<Network>().unwrap(), Network::CPUNet);
         assert!("fakenet".parse::<Network>().is_err());
     }
 
@@ -350,6 +397,7 @@ mod tests {
             (Testnet(TestnetVersion::V4), "testnet4"),
             (Signet, "signet"),
             (Regtest, "regtest"),
+            (CPUNet, "cpunet"),
         ];
 
         for tc in tests {
@@ -372,6 +420,7 @@ mod tests {
             (Network::Testnet(TestnetVersion::V4), "testnet4"),
             (Network::Regtest, "regtest"),
             (Network::Signet, "signet"),
+            (Network::CPUNet, "cpunet"),
         ];
 
         for (net, core_arg) in &expected_pairs {

bitcoin/src/network/params.rs

@@ -60,13 +60,14 @@
 //! # }
 //! ```
 
+use primitives::Block;
 use units::{BlockHeight, BlockHeightInterval};
 
 use crate::network::Network;
 #[cfg(doc)]
 use crate::pow::CompactTarget;
 use crate::pow::Target;
-use crate::TestnetVersion;
+use crate::{BlockInterval, TestnetVersion};
 
 /// Parameters that influence chain consensus.
 #[non_exhaustive]
@@ -132,6 +133,8 @@ pub static TESTNET4: Params = Params::TESTNET4;
 pub static SIGNET: Params = Params::SIGNET;
 /// The regtest parameters.
 pub static REGTEST: Params = Params::REGTEST;
+/// The cpunet parameters.
+pub static CPUNET: Params = Params::CPUNET;
 
 #[allow(deprecated)] // For `pow_limit`.
 impl Params {
@@ -241,6 +244,23 @@ impl Params {
         no_pow_retargeting: true,
     };
 
+    /// The cpunet parameters.
+    pub const CPUNET: Params = Params {
+        network: Network::CPUNet,
+        bip16_time: 1333238400, // Apr 1 2012
+        bip34_height: BlockHeight::from_u32(1),
+        bip65_height: BlockHeight::from_u32(1),
+        bip66_height: BlockHeight::from_u32(1),
+        rule_change_activation_threshold: BlockInterval::from_u32(1512), // 75%
+        miner_confirmation_window: BlockInterval::from_u32(2016),
+        pow_limit: Target::MAX_ATTAINABLE_MAINNET,
+        max_attainable_target: Target::MAX_ATTAINABLE_MAINNET,
+        pow_target_spacing: 10 * 60,            // 10 minutes.
+        pow_target_timespan: 14 * 24 * 60 * 60, // 2 weeks.
+        allow_min_difficulty_blocks: false,
+        no_pow_retargeting: false,
+    };
+
     /// Creates parameters set for the given network.
     pub const fn new(network: Network) -> Self {
         match network {
@@ -249,6 +269,7 @@ impl Params {
             Network::Testnet(TestnetVersion::V4) => Params::TESTNET4,
             Network::Signet => Params::SIGNET,
             Network::Regtest => Params::REGTEST,
+            Network::CPUNet => Params::CPUNET,
         }
     }
 

bitcoin/src/p2p/mod.rs

@@ -229,6 +229,8 @@ impl Magic {
     pub const SIGNET: Self = Self([0x0A, 0x03, 0xCF, 0x40]);
     /// Bitcoin regtest network magic bytes.
     pub const REGTEST: Self = Self([0xFA, 0xBF, 0xB5, 0xDA]);
+    /// Bitcoin cpunet network magic bytes.
+    pub const CPUNET: Self = Self([0x63, 0x70, 0x75, 0x6E]);
 
     /// Construct a new network magic from bytes.
     pub const fn from_bytes(bytes: [u8; 4]) -> Magic { Magic(bytes) }
@@ -285,6 +287,7 @@ generate_network_magic_conversion! {
     Network::Testnet(TestnetVersion::V4) => Magic::TESTNET4,
     Network::Signet => Magic::SIGNET,
     Network::Regtest => Magic::REGTEST,
+    Network::CPUNet => Magic::CPUNET,
 }
 
 impl fmt::Display for Magic {
@@ -484,6 +487,7 @@ mod tests {
             ("1c163f28", Network::Testnet(TestnetVersion::V4)),
             ("fabfb5da", Network::Regtest),
             ("0a03cf40", Network::Signet),
+            ("6370756e", Network::CPUNet),
         ];
 
         for (magic_str, network) in &known_network_magic_strs {

primitives/src/block.rs

@@ -196,6 +196,7 @@ impl Header {
     // This is the same as `Encodable` but done manually because `Encodable` isn't in `primitives`.
     pub fn block_hash(&self) -> BlockHash {
         let mut engine = sha256d::Hash::engine();
+        engine.input("cpunet\0".as_bytes());
         engine.input(&self.version.to_consensus().to_le_bytes());
         engine.input(self.prev_blockhash.as_byte_array());
         engine.input(self.merkle_root.as_byte_array());