diff --git a/bencher/src/verifier.rs b/bencher/src/verifier.rs index f00f1e98..33dbe278 100644 --- a/bencher/src/verifier.rs +++ b/bencher/src/verifier.rs @@ -2,7 +2,7 @@ use std::sync::Arc; use db::BlockChainDatabase; use chain::IndexedBlock; use verification::{BackwardsCompatibleChainVerifier as ChainVerifier, Verify, VerificationLevel}; -use network::{Magic, ConsensusParams, ConsensusFork}; +use network::{Network, ConsensusParams, ConsensusFork}; use test_data; use byteorder::{LittleEndian, ByteOrder}; @@ -94,7 +94,7 @@ pub fn main(benchmark: &mut Benchmark) { assert_eq!(store.best_block().hash, rolling_hash); - let chain_verifier = ChainVerifier::new(store.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let chain_verifier = ChainVerifier::new(store.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); // bench benchmark.start(); diff --git a/message/src/message/message_header.rs b/message/src/message/message_header.rs index 3737fd8a..24dedd95 100644 --- a/message/src/message/message_header.rs +++ b/message/src/message/message_header.rs @@ -62,14 +62,14 @@ impl Serializable for MessageHeader { mod tests { use bytes::Bytes; use ser::serialize; - use network::Magic; + use network::{Network, ConsensusFork}; use super::MessageHeader; #[test] fn test_message_header_serialization() { let expected = "f9beb4d96164647200000000000000001f000000ed52399b".into(); let header = MessageHeader { - magic: Magic::Mainnet, + magic: Network::Mainnet.magic(ConsensusFork::NoFork), command: "addr".into(), len: 0x1f, checksum: "ed52399b".into(), @@ -82,12 +82,12 @@ mod tests { fn test_message_header_deserialization() { let raw: Bytes = "f9beb4d96164647200000000000000001f000000ed52399b".into(); let expected = MessageHeader { - magic: Magic::Mainnet, + magic: Network::Mainnet.magic(ConsensusFork::NoFork), command: "addr".into(), len: 0x1f, checksum: "ed52399b".into(), }; - assert_eq!(expected, MessageHeader::deserialize(&raw, Magic::Mainnet).unwrap()); + assert_eq!(expected, MessageHeader::deserialize(&raw, Network::Mainnet.magic(ConsensusFork::NoFork)).unwrap()); } } diff --git a/network/src/consensus.rs b/network/src/consensus.rs index 0daaa027..081a5814 100644 --- a/network/src/consensus.rs +++ b/network/src/consensus.rs @@ -1,5 +1,5 @@ use hash::H256; -use {Magic, Deployment}; +use {Network, Magic, Deployment}; /// First block of SegWit2x fork. pub const SEGWIT2X_FORK_BLOCK: u32 = 494784; // https://segwit2x.github.io/segwit2x-announce.html @@ -10,7 +10,7 @@ pub const BITCOIN_CASH_FORK_BLOCK: u32 = 478559; // https://blockchair.com/bitco /// Parameters that influence chain consensus. pub struct ConsensusParams { /// Network. - pub network: Magic, + pub network: Network, /// Time when BIP16 becomes active. /// See https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki pub bip16_time: u32, @@ -58,10 +58,10 @@ pub enum ConsensusFork { } impl ConsensusParams { - pub fn new(magic: Magic, fork: ConsensusFork) -> Self { - match magic { - Magic::Mainnet | Magic::Other(_) => ConsensusParams { - network: magic, + pub fn new(network: Network, fork: ConsensusFork) -> Self { + match network { + Network::Mainnet | Network::Other(_) => ConsensusParams { + network: network, bip16_time: 1333238400, // Apr 1 2012 bip34_height: 227931, // 000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8 bip65_height: 388381, // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0 @@ -87,8 +87,8 @@ impl ConsensusParams { ConsensusFork::BitcoinCash(_) => None, }, }, - Magic::Testnet => ConsensusParams { - network: magic, + Network::Testnet => ConsensusParams { + network: network, bip16_time: 1333238400, // Apr 1 2012 bip34_height: 21111, // 0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8 bip65_height: 581885, // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6 @@ -114,8 +114,8 @@ impl ConsensusParams { ConsensusFork::BitcoinCash(_) => None, }, }, - Magic::Regtest | Magic::Unitest => ConsensusParams { - network: magic, + Network::Regtest | Network::Unitest => ConsensusParams { + network: network, bip16_time: 1333238400, // Apr 1 2012 bip34_height: 100000000, // not activated on regtest bip65_height: 1351, @@ -144,6 +144,10 @@ impl ConsensusParams { } } + pub fn magic(&self) -> Magic { + self.network.magic(self.fork) + } + pub fn is_bip30_exception(&self, hash: &H256, height: u32) -> bool { (height == 91842 && hash == &H256::from_reversed_str("00000000000a4d0a398161ffc163c503763b1f4360639393e0e4c8e300e0caec")) || (height == 91880 && hash == &H256::from_reversed_str("00000000000743f190a18c5577a3c2d2a1f610ae9601ac046a38084ccb7cd721")) @@ -224,42 +228,42 @@ impl ConsensusFork { #[cfg(test)] mod tests { - use super::super::Magic; + use super::super::Network; use super::{ConsensusParams, ConsensusFork}; #[test] fn test_consensus_params_bip34_height() { - assert_eq!(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork).bip34_height, 227931); - assert_eq!(ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork).bip34_height, 21111); - assert_eq!(ConsensusParams::new(Magic::Regtest, ConsensusFork::NoFork).bip34_height, 100000000); + assert_eq!(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork).bip34_height, 227931); + assert_eq!(ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork).bip34_height, 21111); + assert_eq!(ConsensusParams::new(Network::Regtest, ConsensusFork::NoFork).bip34_height, 100000000); } #[test] fn test_consensus_params_bip65_height() { - assert_eq!(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork).bip65_height, 388381); - assert_eq!(ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork).bip65_height, 581885); - assert_eq!(ConsensusParams::new(Magic::Regtest, ConsensusFork::NoFork).bip65_height, 1351); + assert_eq!(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork).bip65_height, 388381); + assert_eq!(ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork).bip65_height, 581885); + assert_eq!(ConsensusParams::new(Network::Regtest, ConsensusFork::NoFork).bip65_height, 1351); } #[test] fn test_consensus_params_bip66_height() { - assert_eq!(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork).bip66_height, 363725); - assert_eq!(ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork).bip66_height, 330776); - assert_eq!(ConsensusParams::new(Magic::Regtest, ConsensusFork::NoFork).bip66_height, 1251); + assert_eq!(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork).bip66_height, 363725); + assert_eq!(ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork).bip66_height, 330776); + assert_eq!(ConsensusParams::new(Network::Regtest, ConsensusFork::NoFork).bip66_height, 1251); } #[test] fn test_consensus_activation_threshold() { - assert_eq!(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork).rule_change_activation_threshold, 1916); - assert_eq!(ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork).rule_change_activation_threshold, 1512); - assert_eq!(ConsensusParams::new(Magic::Regtest, ConsensusFork::NoFork).rule_change_activation_threshold, 108); + assert_eq!(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork).rule_change_activation_threshold, 1916); + assert_eq!(ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork).rule_change_activation_threshold, 1512); + assert_eq!(ConsensusParams::new(Network::Regtest, ConsensusFork::NoFork).rule_change_activation_threshold, 108); } #[test] fn test_consensus_miner_confirmation_window() { - assert_eq!(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork).miner_confirmation_window, 2016); - assert_eq!(ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork).miner_confirmation_window, 2016); - assert_eq!(ConsensusParams::new(Magic::Regtest, ConsensusFork::NoFork).miner_confirmation_window, 144); + assert_eq!(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork).miner_confirmation_window, 2016); + assert_eq!(ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork).miner_confirmation_window, 2016); + assert_eq!(ConsensusParams::new(Network::Regtest, ConsensusFork::NoFork).miner_confirmation_window, 144); } #[test] diff --git a/network/src/lib.rs b/network/src/lib.rs index 7b97f698..f602837d 100644 --- a/network/src/lib.rs +++ b/network/src/lib.rs @@ -4,11 +4,10 @@ extern crate serialization as ser; mod consensus; mod deployments; -mod magic; +mod network; pub use primitives::{hash, compact}; pub use consensus::{ConsensusParams, ConsensusFork, SEGWIT2X_FORK_BLOCK, BITCOIN_CASH_FORK_BLOCK}; pub use deployments::Deployment; -pub use magic::Magic; - +pub use network::{Magic, Network}; diff --git a/network/src/magic.rs b/network/src/magic.rs deleted file mode 100644 index dabbe07e..00000000 --- a/network/src/magic.rs +++ /dev/null @@ -1,150 +0,0 @@ -//! Bitcoin network magic number -//! https://www.anintegratedworld.com/unravelling-the-mysterious-block-chain-magic-number/ - -use compact::Compact; -use ser::{Stream, Serializable}; -use chain::Block; -use primitives::hash::H256; - -const MAGIC_MAINNET: u32 = 0xD9B4BEF9; -const MAGIC_TESTNET: u32 = 0x0709110B; -const MAGIC_REGTEST: u32 = 0xDAB5BFFA; -const MAGIC_UNITEST: u32 = 0x00000000; - -const MAX_BITS_MAINNET: u32 = 0x1d00ffff; -const MAX_BITS_TESTNET: u32 = 0x1d00ffff; -const MAX_BITS_REGTEST: u32 = 0x207fffff; - -/// Bitcoin [network](https://bitcoin.org/en/glossary/mainnet) -#[derive(Debug, PartialEq, Eq, Clone, Copy)] -pub enum Magic { - /// The original and main network for Bitcoin transactions, where satoshis have real economic value. - Mainnet, - /// The main bitcoin testnet. - Testnet, - /// Bitcoin regtest network. - Regtest, - /// Testnet for unittests, proof of work difficulty is almost 0 - Unitest, - /// Any other network. By default behaves like bitcoin mainnet. - Other(u32), -} - -impl From for u32 { - fn from(m: Magic) -> Self { - match m { - Magic::Mainnet => MAGIC_MAINNET, - Magic::Testnet => MAGIC_TESTNET, - Magic::Regtest => MAGIC_REGTEST, - Magic::Unitest => MAGIC_UNITEST, - Magic::Other(magic) => magic, - } - } -} - -impl From for Magic { - fn from(u: u32) -> Self { - match u { - MAGIC_MAINNET => Magic::Mainnet, - MAGIC_TESTNET => Magic::Testnet, - MAGIC_REGTEST => Magic::Regtest, - MAGIC_UNITEST => Magic::Unitest, - other => Magic::Other(other), - } - } -} - -impl Magic { - pub fn max_bits(&self) -> Compact { - match *self { - Magic::Mainnet | Magic::Other(_) => MAX_BITS_MAINNET.into(), - Magic::Testnet => MAX_BITS_TESTNET.into(), - Magic::Regtest => MAX_BITS_REGTEST.into(), - Magic::Unitest => Compact::max_value(), - } - } - - pub fn port(&self) -> u16 { - match *self { - Magic::Mainnet | Magic::Other(_) => 8333, - Magic::Testnet => 18333, - Magic::Regtest | Magic::Unitest => 18444, - } - } - - pub fn rpc_port(&self) -> u16 { - match *self { - Magic::Mainnet | Magic::Other(_) => 8332, - Magic::Testnet => 18332, - Magic::Regtest | Magic::Unitest => 18443, - } - } - - pub fn genesis_block(&self) -> Block { - match *self { - Magic::Mainnet | Magic::Other(_) => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), - Magic::Testnet => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), - Magic::Regtest | Magic::Unitest => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), - } - } - - pub fn default_verification_edge(&self) -> H256 { - match *self { - Magic::Mainnet => H256::from_reversed_str("0000000000000000030abc968e1bd635736e880b946085c93152969b9a81a6e2"), - Magic::Testnet => H256::from_reversed_str("000000000871ee6842d3648317ccc8a435eb8cc3c2429aee94faff9ba26b05a0"), - _ => self.genesis_block().hash(), - } - } -} - -impl Serializable for Magic { - fn serialize(&self, stream: &mut Stream) { - stream.append(&u32::from(*self)); - } -} - -#[cfg(test)] -mod tests { - use compact::Compact; - use super::{ - Magic, MAGIC_MAINNET, MAGIC_TESTNET, MAGIC_REGTEST, MAGIC_UNITEST, - MAX_BITS_MAINNET, MAX_BITS_TESTNET, MAX_BITS_REGTEST, - }; - - #[test] - fn test_network_magic_number() { - assert_eq!(MAGIC_MAINNET, Magic::Mainnet.into()); - assert_eq!(MAGIC_TESTNET, Magic::Testnet.into()); - assert_eq!(MAGIC_REGTEST, Magic::Regtest.into()); - assert_eq!(MAGIC_UNITEST, Magic::Unitest.into()); - assert_eq!(Magic::Mainnet, MAGIC_MAINNET.into()); - assert_eq!(Magic::Testnet, MAGIC_TESTNET.into()); - assert_eq!(Magic::Regtest, MAGIC_REGTEST.into()); - assert_eq!(Magic::Unitest, MAGIC_UNITEST.into()); - assert_eq!(Magic::Other(1), 1.into()); - } - - #[test] - fn test_network_max_bits() { - assert_eq!(Magic::Mainnet.max_bits(), MAX_BITS_MAINNET.into()); - assert_eq!(Magic::Testnet.max_bits(), MAX_BITS_TESTNET.into()); - assert_eq!(Magic::Regtest.max_bits(), MAX_BITS_REGTEST.into()); - assert_eq!(Magic::Unitest.max_bits(), Compact::max_value()); - } - - #[test] - fn test_network_port() { - assert_eq!(Magic::Mainnet.port(), 8333); - assert_eq!(Magic::Testnet.port(), 18333); - assert_eq!(Magic::Regtest.port(), 18444); - assert_eq!(Magic::Unitest.port(), 18444); - } - - #[test] - fn test_network_rpc_port() { - assert_eq!(Magic::Mainnet.rpc_port(), 8332); - assert_eq!(Magic::Testnet.rpc_port(), 18332); - assert_eq!(Magic::Regtest.rpc_port(), 18443); - assert_eq!(Magic::Unitest.rpc_port(), 18443); - } -} diff --git a/network/src/network.rs b/network/src/network.rs new file mode 100644 index 00000000..c2a8d5f3 --- /dev/null +++ b/network/src/network.rs @@ -0,0 +1,136 @@ +//! Bitcoin network +//! https://www.anintegratedworld.com/unravelling-the-mysterious-block-chain-magic-number/ + +use compact::Compact; +use chain::Block; +use primitives::hash::H256; +use {ConsensusFork}; + +const MAGIC_MAINNET: u32 = 0xD9B4BEF9; +const MAGIC_TESTNET: u32 = 0x0709110B; +const MAGIC_REGTEST: u32 = 0xDAB5BFFA; +const MAGIC_UNITEST: u32 = 0x00000000; + +const BITCOIN_CASH_MAGIC_MAINNET: u32 = 0xE8F3E1E3; +const BITCOIN_CASH_MAGIC_TESTNET: u32 = 0xF4F3E5F4; +const BITCOIN_CASH_MAGIC_REGTEST: u32 = 0xFABFB5DA; + +const MAX_BITS_MAINNET: u32 = 0x1d00ffff; +const MAX_BITS_TESTNET: u32 = 0x1d00ffff; +const MAX_BITS_REGTEST: u32 = 0x207fffff; + +/// Network magic type. +pub type Magic = u32; + +/// Bitcoin [network](https://bitcoin.org/en/glossary/mainnet) +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub enum Network { + /// The original and main network for Bitcoin transactions, where satoshis have real economic value. + Mainnet, + /// The main bitcoin testnet. + Testnet, + /// Bitcoin regtest network. + Regtest, + /// Testnet for unittests, proof of work difficulty is almost 0 + Unitest, + /// Any other network. By default behaves like bitcoin mainnet. + Other(u32), +} + +impl Network { + pub fn magic(&self, fork: ConsensusFork) -> Magic { + match (fork, *self) { + (ConsensusFork::BitcoinCash(_), Network::Mainnet) => BITCOIN_CASH_MAGIC_MAINNET, + (ConsensusFork::BitcoinCash(_), Network::Testnet) => BITCOIN_CASH_MAGIC_TESTNET, + (ConsensusFork::BitcoinCash(_), Network::Regtest) => BITCOIN_CASH_MAGIC_REGTEST, + (_, Network::Mainnet) => MAGIC_MAINNET, + (_, Network::Testnet) => MAGIC_TESTNET, + (_, Network::Regtest) => MAGIC_REGTEST, + (_, Network::Unitest) => MAGIC_UNITEST, + (_, Network::Other(value)) => value, + } + } + + pub fn max_bits(&self) -> Compact { + match *self { + Network::Mainnet | Network::Other(_) => MAX_BITS_MAINNET.into(), + Network::Testnet => MAX_BITS_TESTNET.into(), + Network::Regtest => MAX_BITS_REGTEST.into(), + Network::Unitest => Compact::max_value(), + } + } + + pub fn port(&self) -> u16 { + match *self { + Network::Mainnet | Network::Other(_) => 8333, + Network::Testnet => 18333, + Network::Regtest | Network::Unitest => 18444, + } + } + + pub fn rpc_port(&self) -> u16 { + match *self { + Network::Mainnet | Network::Other(_) => 8332, + Network::Testnet => 18332, + Network::Regtest | Network::Unitest => 18443, + } + } + + pub fn genesis_block(&self) -> Block { + match *self { + Network::Mainnet | Network::Other(_) => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), + Network::Testnet => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), + Network::Regtest | Network::Unitest => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(), + } + } + + pub fn default_verification_edge(&self) -> H256 { + match *self { + Network::Mainnet => H256::from_reversed_str("0000000000000000030abc968e1bd635736e880b946085c93152969b9a81a6e2"), + Network::Testnet => H256::from_reversed_str("000000000871ee6842d3648317ccc8a435eb8cc3c2429aee94faff9ba26b05a0"), + _ => self.genesis_block().hash(), + } + } +} + +#[cfg(test)] +mod tests { + use compact::Compact; + use {ConsensusFork}; + use super::{ + Network, MAGIC_MAINNET, MAGIC_TESTNET, MAGIC_REGTEST, MAGIC_UNITEST, + MAX_BITS_MAINNET, MAX_BITS_TESTNET, MAX_BITS_REGTEST, + }; + + #[test] + fn test_network_magic_number() { + assert_eq!(MAGIC_MAINNET, Network::Mainnet.magic(ConsensusFork::NoFork)); + assert_eq!(MAGIC_TESTNET, Network::Testnet.magic(ConsensusFork::NoFork)); + assert_eq!(MAGIC_REGTEST, Network::Regtest.magic(ConsensusFork::NoFork)); + assert_eq!(MAGIC_UNITEST, Network::Unitest.magic(ConsensusFork::NoFork)); + } + + #[test] + fn test_network_max_bits() { + assert_eq!(Network::Mainnet.max_bits(), MAX_BITS_MAINNET.into()); + assert_eq!(Network::Testnet.max_bits(), MAX_BITS_TESTNET.into()); + assert_eq!(Network::Regtest.max_bits(), MAX_BITS_REGTEST.into()); + assert_eq!(Network::Unitest.max_bits(), Compact::max_value()); + } + + #[test] + fn test_network_port() { + assert_eq!(Network::Mainnet.port(), 8333); + assert_eq!(Network::Testnet.port(), 18333); + assert_eq!(Network::Regtest.port(), 18444); + assert_eq!(Network::Unitest.port(), 18444); + } + + #[test] + fn test_network_rpc_port() { + assert_eq!(Network::Mainnet.rpc_port(), 8332); + assert_eq!(Network::Testnet.rpc_port(), 18332); + assert_eq!(Network::Regtest.rpc_port(), 18443); + assert_eq!(Network::Unitest.rpc_port(), 18443); + } +} diff --git a/p2p/src/io/handshake.rs b/p2p/src/io/handshake.rs index b429b317..e488cf73 100644 --- a/p2p/src/io/handshake.rs +++ b/p2p/src/io/handshake.rs @@ -211,7 +211,7 @@ mod tests { use tokio_io::{AsyncRead, AsyncWrite}; use bytes::Bytes; use ser::Stream; - use network::Magic; + use network::{Network, ConsensusFork}; use message::{Message, Error}; use message::types::Verack; use message::types::version::{Version, V0, V106, V70001}; @@ -287,7 +287,7 @@ mod tests { #[test] fn test_handshake() { - let magic = Magic::Mainnet; + let magic = Network::Mainnet.magic(ConsensusFork::NoFork); let version = 70012; let local_version = local_version(); let remote_version = remote_version(); @@ -317,7 +317,7 @@ mod tests { #[test] fn test_accept_handshake() { - let magic = Magic::Mainnet; + let magic = Network::Mainnet.magic(ConsensusFork::NoFork); let version = 70012; let local_version = local_version(); let remote_version = remote_version(); @@ -346,7 +346,7 @@ mod tests { #[test] fn test_self_handshake() { - let magic = Magic::Mainnet; + let magic = Network::Mainnet.magic(ConsensusFork::NoFork); let version = 70012; let remote_version = local_version(); let local_version = local_version(); @@ -367,7 +367,7 @@ mod tests { #[test] fn test_accept_self_handshake() { - let magic = Magic::Mainnet; + let magic = Network::Mainnet.magic(ConsensusFork::NoFork); let version = 70012; let remote_version = local_version(); let local_version = local_version(); @@ -385,4 +385,26 @@ mod tests { let hs = accept_handshake(test_io, magic, local_version, 0).wait().unwrap(); assert_eq!(hs.1.unwrap_err(), expected); } + + #[test] + fn test_fails_to_accept_other_fork_node() { + let magic1 = Network::Mainnet.magic(ConsensusFork::NoFork); + let magic2 = Network::Mainnet.magic(ConsensusFork::BitcoinCash(0)); + let version = 70012; + let local_version = local_version(); + let remote_version = remote_version(); + + let mut remote_stream = Stream::new(); + remote_stream.append_slice(Message::new(magic2, version, &remote_version).unwrap().as_ref()); + + let test_io = TestIo { + read: io::Cursor::new(remote_stream.out()), + write: Bytes::default(), + }; + + let expected = Error::InvalidMagic; + + let hs = accept_handshake(test_io, magic1, local_version, 0).wait().unwrap(); + assert_eq!(hs.1.unwrap_err(), expected); + } } diff --git a/p2p/src/io/read_any_message.rs b/p2p/src/io/read_any_message.rs index 254e2a39..5ca63c45 100644 --- a/p2p/src/io/read_any_message.rs +++ b/p2p/src/io/read_any_message.rs @@ -63,7 +63,7 @@ impl Future for ReadAnyMessage where A: AsyncRead { mod tests { use futures::Future; use bytes::Bytes; - use network::Magic; + use network::{Network, ConsensusFork}; use message::Error; use super::read_any_message; @@ -74,20 +74,20 @@ mod tests { let nonce = "5845303b6da97786".into(); let expected = (name, nonce); - assert_eq!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().unwrap(), Ok(expected)); - assert_eq!(read_any_message(raw.as_ref(), Magic::Testnet).wait().unwrap(), Err(Error::InvalidMagic)); + assert_eq!(read_any_message(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork)).wait().unwrap(), Ok(expected)); + assert_eq!(read_any_message(raw.as_ref(), Network::Testnet.magic(ConsensusFork::NoFork)).wait().unwrap(), Err(Error::InvalidMagic)); } #[test] fn test_read_too_short_any_message() { let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da977".into(); - assert!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().is_err()); + assert!(read_any_message(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork)).wait().is_err()); } #[test] fn test_read_any_message_with_invalid_checksum() { let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c01c765845303b6da97786".into(); - assert_eq!(read_any_message(raw.as_ref(), Magic::Mainnet).wait().unwrap(), Err(Error::InvalidChecksum)); + assert_eq!(read_any_message(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork)).wait().unwrap(), Err(Error::InvalidChecksum)); } } diff --git a/p2p/src/io/read_header.rs b/p2p/src/io/read_header.rs index dd504c68..4b3d9850 100644 --- a/p2p/src/io/read_header.rs +++ b/p2p/src/io/read_header.rs @@ -32,7 +32,7 @@ impl Future for ReadHeader where A: AsyncRead { mod tests { use futures::Future; use bytes::Bytes; - use network::Magic; + use network::{Network, ConsensusFork}; use message::{MessageHeader, Error}; use super::read_header; @@ -40,25 +40,25 @@ mod tests { fn test_read_header() { let raw: Bytes = "f9beb4d96164647200000000000000001f000000ed52399b".into(); let expected = MessageHeader { - magic: Magic::Mainnet, + magic: Network::Mainnet.magic(ConsensusFork::NoFork), command: "addr".into(), len: 0x1f, checksum: "ed52399b".into(), }; - assert_eq!(read_header(raw.as_ref(), Magic::Mainnet).wait().unwrap().1, Ok(expected)); - assert_eq!(read_header(raw.as_ref(), Magic::Testnet).wait().unwrap().1, Err(Error::InvalidMagic)); + assert_eq!(read_header(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork)).wait().unwrap().1, Ok(expected)); + assert_eq!(read_header(raw.as_ref(), Network::Testnet.magic(ConsensusFork::NoFork)).wait().unwrap().1, Err(Error::InvalidMagic)); } #[test] fn test_read_header_with_invalid_magic() { let raw: Bytes = "f9beb4d86164647200000000000000001f000000ed52399b".into(); - assert_eq!(read_header(raw.as_ref(), Magic::Testnet).wait().unwrap().1, Err(Error::InvalidMagic)); + assert_eq!(read_header(raw.as_ref(), Network::Testnet.magic(ConsensusFork::NoFork)).wait().unwrap().1, Err(Error::InvalidMagic)); } #[test] fn test_read_too_short_header() { let raw: Bytes = "f9beb4d96164647200000000000000001f000000ed5239".into(); - assert!(read_header(raw.as_ref(), Magic::Mainnet).wait().is_err()); + assert!(read_header(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork)).wait().is_err()); } } diff --git a/p2p/src/io/read_message.rs b/p2p/src/io/read_message.rs index ad5420a7..c0c70823 100644 --- a/p2p/src/io/read_message.rs +++ b/p2p/src/io/read_message.rs @@ -69,7 +69,7 @@ impl Future for ReadMessage where A: AsyncRead, M: Payload { mod tests { use futures::Future; use bytes::Bytes; - use network::Magic; + use network::{Network, ConsensusFork}; use message::Error; use message::types::{Ping, Pong}; use super::read_message; @@ -78,21 +78,21 @@ mod tests { fn test_read_message() { let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da97786".into(); let ping = Ping::new(u64::from_str_radix("8677a96d3b304558", 16).unwrap()); - assert_eq!(read_message(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Ok(ping)); - assert_eq!(read_message::(raw.as_ref(), Magic::Testnet, 0).wait().unwrap().1, Err(Error::InvalidMagic)); - assert_eq!(read_message::(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Err(Error::InvalidCommand)); + assert_eq!(read_message(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Ok(ping)); + assert_eq!(read_message::(raw.as_ref(), Network::Testnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Err(Error::InvalidMagic)); + assert_eq!(read_message::(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Err(Error::InvalidCommand)); } #[test] fn test_read_too_short_message() { let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c00c765845303b6da977".into(); - assert!(read_message::(raw.as_ref(), Magic::Mainnet, 0).wait().is_err()); + assert!(read_message::(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork), 0).wait().is_err()); } #[test] fn test_read_message_with_invalid_checksum() { let raw: Bytes = "f9beb4d970696e6700000000000000000800000083c01c765845303b6da97786".into(); - assert_eq!(read_message::(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Err(Error::InvalidChecksum)); + assert_eq!(read_message::(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Err(Error::InvalidChecksum)); } } diff --git a/pbtc/commands/rollback.rs b/pbtc/commands/rollback.rs index b2bbb5d5..254f037f 100644 --- a/pbtc/commands/rollback.rs +++ b/pbtc/commands/rollback.rs @@ -18,7 +18,7 @@ pub fn rollback(cfg: Config, matches: &ArgMatches) -> Result<(), String> { }; let required_block_hash = cfg.db.block_header(block_ref.clone()).ok_or(format!("Block {:?} is unknown", block_ref))?.hash(); - let genesis_hash = cfg.magic.genesis_block().hash(); + let genesis_hash = cfg.network.genesis_block().hash(); let mut best_block_hash = cfg.db.best_block().hash; debug_assert!(best_block_hash != H256::default()); // genesis inserted in init_db diff --git a/pbtc/commands/start.rs b/pbtc/commands/start.rs index f02295fb..25bfd1f7 100644 --- a/pbtc/commands/start.rs +++ b/pbtc/commands/start.rs @@ -95,7 +95,7 @@ pub fn start(cfg: config::Config) -> Result<(), String> { connection: p2p::NetConfig { protocol_version: PROTOCOL_VERSION, protocol_minimum: PROTOCOL_MINIMUM, - magic: cfg.magic, + magic: cfg.consensus.magic(), local_address: SocketAddr::new("127.0.0.1".parse().unwrap(), cfg.port), services: cfg.services, user_agent: cfg.user_agent, @@ -119,7 +119,7 @@ pub fn start(cfg: config::Config) -> Result<(), String> { let p2p = try!(p2p::P2P::new(p2p_cfg, sync_connection_factory, el.handle()).map_err(|x| x.to_string())); let rpc_deps = rpc::Dependencies { - network: cfg.magic, + network: cfg.network, storage: cfg.db, local_sync_node: local_sync_node, p2p_context: p2p.context().clone(), diff --git a/pbtc/config.rs b/pbtc/config.rs index 2496539c..b8a17075 100644 --- a/pbtc/config.rs +++ b/pbtc/config.rs @@ -2,9 +2,9 @@ use std::net; use clap; use db; use message::Services; -use network::{Magic, ConsensusParams, ConsensusFork, SEGWIT2X_FORK_BLOCK, BITCOIN_CASH_FORK_BLOCK}; +use network::{Network, ConsensusParams, ConsensusFork, SEGWIT2X_FORK_BLOCK, BITCOIN_CASH_FORK_BLOCK}; use p2p::InternetProtocol; -use seednodes::{mainnet_seednodes, testnet_seednodes, segwit2x_seednodes}; +use seednodes::{mainnet_seednodes, testnet_seednodes, segwit2x_seednodes, bitcoin_cash_seednodes, bitcoin_cash_testnet_seednodes}; use rpc_apis::ApiSet; use {USER_AGENT, REGTEST_USER_AGENT}; use primitives::hash::H256; @@ -14,7 +14,7 @@ use sync::VerificationParameters; use util::open_db; pub struct Config { - pub magic: Magic, + pub network: Network, pub consensus: ConsensusParams, pub services: Services, pub port: u16, @@ -50,24 +50,24 @@ pub fn parse(matches: &clap::ArgMatches) -> Result { let db = open_db(&data_dir, db_cache); let quiet = matches.is_present("quiet"); - let magic = match (matches.is_present("testnet"), matches.is_present("regtest")) { - (true, false) => Magic::Testnet, - (false, true) => Magic::Regtest, - (false, false) => Magic::Mainnet, + let network = match (matches.is_present("testnet"), matches.is_present("regtest")) { + (true, false) => Network::Testnet, + (false, true) => Network::Regtest, + (false, false) => Network::Mainnet, (true, true) => return Err("Only one testnet option can be used".into()), }; let consensus_fork = parse_consensus_fork(&db, &matches)?; - let consensus = ConsensusParams::new(magic, consensus_fork); + let consensus = ConsensusParams::new(network, consensus_fork); - let (in_connections, out_connections) = match magic { - Magic::Testnet | Magic::Mainnet | Magic::Other(_) => (10, 10), - Magic::Regtest | Magic::Unitest => (1, 0), + let (in_connections, out_connections) = match network { + Network::Testnet | Network::Mainnet | Network::Other(_) => (10, 10), + Network::Regtest | Network::Unitest => (1, 0), }; - let p2p_threads = match magic { - Magic::Testnet | Magic::Mainnet | Magic::Other(_) => 4, - Magic::Regtest | Magic::Unitest => 1, + let p2p_threads = match network { + Network::Testnet | Network::Mainnet | Network::Other(_) => 4, + Network::Regtest | Network::Unitest => 1, }; // to skip idiotic 30 seconds delay in test-scripts @@ -76,20 +76,20 @@ pub fn parse(matches: &clap::ArgMatches) -> Result { ConsensusFork::SegWit2x(_) => "/SegWit2x", ConsensusFork::BitcoinCash(_) => "/UAHF", }; - let user_agent = match magic { - Magic::Testnet | Magic::Mainnet | Magic::Unitest | Magic::Other(_) => format!("{}{}", USER_AGENT, user_agent_suffix), - Magic::Regtest => REGTEST_USER_AGENT.into(), + let user_agent = match network { + Network::Testnet | Network::Mainnet | Network::Unitest | Network::Other(_) => format!("{}{}", USER_AGENT, user_agent_suffix), + Network::Regtest => REGTEST_USER_AGENT.into(), }; let port = match matches.value_of("port") { Some(port) => port.parse().map_err(|_| "Invalid port".to_owned())?, - None => magic.port(), + None => network.port(), }; let connect = match matches.value_of("connect") { Some(s) => Some(match s.parse::() { Err(_) => s.parse::() - .map(|ip| net::SocketAddr::new(ip, magic.port())) + .map(|ip| net::SocketAddr::new(ip, network.port())) .map_err(|_| "Invalid connect".to_owned()), Ok(a) => Ok(a), }?), @@ -98,10 +98,12 @@ pub fn parse(matches: &clap::ArgMatches) -> Result { let mut seednodes: Vec = match matches.value_of("seednode") { Some(s) => vec![s.parse().map_err(|_| "Invalid seednode".to_owned())?], - None => match magic { - Magic::Mainnet => mainnet_seednodes().into_iter().map(Into::into).collect(), - Magic::Testnet => testnet_seednodes().into_iter().map(Into::into).collect(), - Magic::Other(_) | Magic::Regtest | Magic::Unitest => Vec::new(), + None => match (network, consensus_fork) { + (Network::Mainnet, ConsensusFork::BitcoinCash(_)) => bitcoin_cash_seednodes().into_iter().map(Into::into).collect(), + (Network::Testnet, ConsensusFork::BitcoinCash(_)) => bitcoin_cash_testnet_seednodes().into_iter().map(Into::into).collect(), + (Network::Mainnet, _) => mainnet_seednodes().into_iter().map(Into::into).collect(), + (Network::Testnet, _) => testnet_seednodes().into_iter().map(Into::into).collect(), + (Network::Other(_), _) | (Network::Regtest, _) | (Network::Unitest, _) => Vec::new(), }, }; match consensus_fork { @@ -114,7 +116,7 @@ pub fn parse(matches: &clap::ArgMatches) -> Result { None => InternetProtocol::default(), }; - let rpc_config = parse_rpc_config(magic, matches)?; + let rpc_config = parse_rpc_config(network, matches)?; let block_notify_command = match matches.value_of("blocknotify") { Some(s) => Some(s.parse().map_err(|_| "Invalid blocknotify commmand".to_owned())?), @@ -140,12 +142,12 @@ pub fn parse(matches: &clap::ArgMatches) -> Result { let edge: H256 = s.parse().map_err(|_| "Invalid verification edge".to_owned())?; edge.reversed() }, - _ => magic.default_verification_edge(), + _ => network.default_verification_edge(), }; let config = Config { quiet: quiet, - magic: magic, + network: network, consensus: consensus, services: services, port: port, @@ -198,8 +200,8 @@ fn parse_consensus_fork(db: &db::SharedStore, matches: &clap::ArgMatches) -> Res }) } -fn parse_rpc_config(magic: Magic, matches: &clap::ArgMatches) -> Result { - let mut config = RpcHttpConfig::with_port(magic.rpc_port()); +fn parse_rpc_config(network: Network, matches: &clap::ArgMatches) -> Result { + let mut config = RpcHttpConfig::with_port(network.rpc_port()); config.enabled = !matches.is_present("no-jsonrpc"); if !config.enabled { return Ok(config); diff --git a/pbtc/rpc.rs b/pbtc/rpc.rs index d7c3d58e..e11d8a2e 100644 --- a/pbtc/rpc.rs +++ b/pbtc/rpc.rs @@ -2,14 +2,14 @@ use std::net::SocketAddr; use std::sync::Arc; use rpc_apis::{self, ApiSet}; use ethcore_rpc::{Server, Error, start_http, MetaIoHandler, Compatibility, Remote}; -use network::Magic; +use network::Network; use std::io; use sync; use db; use p2p; pub struct Dependencies { - pub network: Magic, + pub network: Network, pub local_sync_node: sync::LocalNodeRef, pub storage: db::SharedStore, pub p2p_context: Arc, diff --git a/pbtc/seednodes.rs b/pbtc/seednodes.rs index 92c1da75..d716ac7e 100644 --- a/pbtc/seednodes.rs +++ b/pbtc/seednodes.rs @@ -28,6 +28,20 @@ pub fn testnet_seednodes() -> Vec<&'static str> { ] } +pub fn bitcoin_cash_seednodes() -> Vec<&'static str> { + vec![ + "cash-seed.bitcoin.thomaszander.se:8333", + "seed.bitprim.org:8333", + ] +} + +pub fn bitcoin_cash_testnet_seednodes() -> Vec<&'static str> { + vec![ + "testnet-seed-abc.bitcoinforks.org:8333", + "testnet-seed.bitprim.org:8333", + ] +} + pub fn segwit2x_seednodes() -> Vec<&'static str> { vec![ "seed.mainnet.b-pay.net:8333", diff --git a/pbtc/util.rs b/pbtc/util.rs index b7c715bb..aba1fc1e 100644 --- a/pbtc/util.rs +++ b/pbtc/util.rs @@ -25,7 +25,7 @@ pub fn node_table_path(cfg: &Config) -> PathBuf { pub fn init_db(cfg: &Config) -> Result<(), String> { // insert genesis block if db is empty - let genesis_block: IndexedBlock = cfg.magic.genesis_block().into(); + let genesis_block: IndexedBlock = cfg.network.genesis_block().into(); match cfg.db.block_hash(0) { Some(ref db_genesis_block_hash) if db_genesis_block_hash != genesis_block.hash() => Err("Trying to open database with incompatible genesis block".into()), Some(_) => Ok(()), diff --git a/rpc/src/v1/impls/blockchain.rs b/rpc/src/v1/impls/blockchain.rs index 4f5f25fa..476c0f2e 100644 --- a/rpc/src/v1/impls/blockchain.rs +++ b/rpc/src/v1/impls/blockchain.rs @@ -14,7 +14,7 @@ use global_script::Script; use chain::OutPoint; use verification; use ser::serialize; -use network::Magic; +use network::Network; use primitives::hash::H256 as GlobalH256; pub struct BlockChainClient { @@ -32,12 +32,12 @@ pub trait BlockChainClientCoreApi: Send + Sync + 'static { } pub struct BlockChainClientCore { - network: Magic, + network: Network, storage: db::SharedStore, } impl BlockChainClientCore { - pub fn new(network: Magic, storage: db::SharedStore) -> Self { + pub fn new(network: Network, storage: db::SharedStore) -> Self { BlockChainClientCore { network: network, @@ -153,7 +153,7 @@ impl BlockChainClientCoreApi for BlockChainClientCore { script_type: script.script_type().into(), addresses: script_addresses.into_iter().map(|a| Address { network: match self.network { - Magic::Mainnet => keys::Network::Mainnet, + Network::Mainnet => keys::Network::Mainnet, // there's no correct choices for Regtests && Other networks // => let's just make Testnet key _ => keys::Network::Testnet, @@ -249,7 +249,7 @@ pub mod tests { use v1::types::H256; use v1::types::ScriptType; use chain::OutPoint; - use network::Magic; + use network::Network; use super::*; #[derive(Default)] @@ -452,7 +452,7 @@ pub mod tests { ] )); - let core = BlockChainClientCore::new(Magic::Mainnet, storage); + let core = BlockChainClientCore::new(Network::Mainnet, storage); // get info on block #1: // https://blockexplorer.com/block/00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048 @@ -589,7 +589,7 @@ pub mod tests { #[test] fn verbose_transaction_out_contents() { let storage = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let core = BlockChainClientCore::new(Magic::Mainnet, storage); + let core = BlockChainClientCore::new(Network::Mainnet, storage); // get info on tx from genesis block: // https://blockchain.info/ru/tx/4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b diff --git a/sync/src/blocks_writer.rs b/sync/src/blocks_writer.rs index 24ccac89..64db9925 100644 --- a/sync/src/blocks_writer.rs +++ b/sync/src/blocks_writer.rs @@ -147,7 +147,7 @@ mod tests { use std::sync::Arc; use db::{BlockChainDatabase}; - use network::{ConsensusParams, ConsensusFork, Magic}; + use network::{ConsensusParams, ConsensusFork, Network}; use verification::VerificationLevel; use super::super::Error; use super::{BlocksWriter, MAX_ORPHANED_BLOCKS}; @@ -163,7 +163,7 @@ mod tests { #[test] fn blocks_writer_appends_blocks() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork), default_verification_params()); + let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork), default_verification_params()); blocks_target.append_block(test_data::block_h1().into()).expect("Expecting no error"); assert_eq!(db.best_block().number, 1); } @@ -172,7 +172,7 @@ mod tests { fn blocks_writer_verification_error() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); let blocks = test_data::build_n_empty_blocks_from_genesis((MAX_ORPHANED_BLOCKS + 2) as u32, 1); - let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork), default_verification_params()); + let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork), default_verification_params()); for (index, block) in blocks.into_iter().skip(1).enumerate() { match blocks_target.append_block(block.into()) { Err(Error::TooManyOrphanBlocks) if index == MAX_ORPHANED_BLOCKS => (), @@ -186,7 +186,7 @@ mod tests { #[test] fn blocks_writer_out_of_order_block() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork), default_verification_params()); + let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork), default_verification_params()); let wrong_block = test_data::block_builder() .header().parent(test_data::genesis().hash()).build() @@ -201,7 +201,7 @@ mod tests { #[test] fn blocks_writer_append_to_existing_db() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, ConsensusFork::NoFork), default_verification_params()); + let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Network::Testnet, ConsensusFork::NoFork), default_verification_params()); assert!(blocks_target.append_block(test_data::genesis().into()).is_ok()); assert_eq!(db.best_block().number, 0); diff --git a/sync/src/lib.rs b/sync/src/lib.rs index 2607f49e..94eb2bf0 100644 --- a/sync/src/lib.rs +++ b/sync/src/lib.rs @@ -42,7 +42,7 @@ pub use types::PeersRef; use std::sync::Arc; use parking_lot::RwLock; use message::Services; -use network::{Magic, ConsensusParams}; +use network::{Network, ConsensusParams}; use primitives::hash::H256; use verification::BackwardsCompatibleChainVerifier as ChainVerifier; @@ -103,7 +103,7 @@ pub fn create_local_sync_node(consensus: ConsensusParams, db: db::SharedStore, p let network = consensus.network; let sync_client_config = SynchronizationConfig { // during regtests, peer is providing us with bad blocks => we shouldn't close connection because of this - close_connection_on_bad_block: network != Magic::Regtest, + close_connection_on_bad_block: network != Network::Regtest, }; let memory_pool = Arc::new(RwLock::new(MemoryPool::new())); diff --git a/sync/src/local_node.rs b/sync/src/local_node.rs index 66b9577e..03c4772a 100644 --- a/sync/src/local_node.rs +++ b/sync/src/local_node.rs @@ -340,7 +340,7 @@ pub mod tests { use synchronization_chain::Chain; use message::types; use message::common::{InventoryVector, InventoryType}; - use network::{ConsensusParams, ConsensusFork, Magic}; + use network::{ConsensusParams, ConsensusFork, Network}; use chain::Transaction; use db::{BlockChainDatabase}; use miner::MemoryPool; @@ -374,12 +374,12 @@ pub mod tests { let memory_pool = Arc::new(RwLock::new(MemoryPool::new())); let storage = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); let sync_state = SynchronizationStateRef::new(SynchronizationState::with_storage(storage.clone())); - let chain = Chain::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), memory_pool.clone()); + let chain = Chain::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), memory_pool.clone()); let sync_peers = Arc::new(PeersImpl::default()); let executor = DummyTaskExecutor::new(); let server = Arc::new(DummyServer::new()); let config = Config { close_connection_on_bad_block: true }; - let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork))); + let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork))); let client_core = SynchronizationClientCore::new(config, sync_state.clone(), sync_peers.clone(), executor.clone(), chain, chain_verifier); let mut verifier = match verifier { Some(verifier) => verifier, @@ -387,7 +387,7 @@ pub mod tests { }; verifier.set_sink(Arc::new(CoreVerificationSink::new(client_core.clone()))); let client = SynchronizationClient::new(sync_state.clone(), client_core, verifier); - let local_node = LocalNode::new(ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork), storage, memory_pool, sync_peers, sync_state, executor.clone(), client, server.clone()); + let local_node = LocalNode::new(ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork), storage, memory_pool, sync_peers, sync_state, executor.clone(), client, server.clone()); (executor, server, local_node) } diff --git a/sync/src/synchronization_chain.rs b/sync/src/synchronization_chain.rs index aa883368..aa66e50b 100644 --- a/sync/src/synchronization_chain.rs +++ b/sync/src/synchronization_chain.rs @@ -743,7 +743,7 @@ mod tests { use chain::{Transaction, IndexedBlockHeader}; use db::BlockChainDatabase; use miner::MemoryPool; - use network::{Magic, ConsensusParams, ConsensusFork}; + use network::{Network, ConsensusParams, ConsensusFork}; use primitives::hash::H256; use super::{Chain, BlockState, TransactionState, BlockInsertionResult}; use utils::HashPosition; @@ -752,7 +752,7 @@ mod tests { fn chain_empty() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); let db_best_block = db.best_block(); - let chain = Chain::new(db.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let chain = Chain::new(db.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); assert_eq!(chain.information().scheduled, 0); assert_eq!(chain.information().requested, 0); assert_eq!(chain.information().verifying, 0); @@ -769,7 +769,7 @@ mod tests { #[test] fn chain_block_path() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); // add 6 blocks to scheduled queue let blocks = test_data::build_n_empty_blocks_from_genesis(6, 0); @@ -821,7 +821,7 @@ mod tests { #[test] fn chain_block_locator_hashes() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); let genesis_hash = chain.best_block().hash; assert_eq!(chain.block_locator_hashes(), vec![genesis_hash.clone()]); @@ -906,7 +906,7 @@ mod tests { #[test] fn chain_transaction_state() { let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); let genesis_block = test_data::genesis(); let block1 = test_data::block_h1(); let tx1: Transaction = test_data::TransactionBuilder::with_version(1).into(); @@ -943,7 +943,7 @@ mod tests { let tx2_hash = tx2.hash(); let db = Arc::new(BlockChainDatabase::init_test_chain(vec![b0.into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.verify_transaction(tx1.into()); chain.insert_verified_transaction(tx2.into()); @@ -967,7 +967,7 @@ mod tests { .set_default_input(0).set_output(400).store(test_chain); // t4 let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.verify_transaction(test_chain.at(0).into()); chain.verify_transaction(test_chain.at(1).into()); chain.verify_transaction(test_chain.at(2).into()); @@ -989,7 +989,7 @@ mod tests { .set_default_input(0).set_output(400).store(test_chain); // t4 let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.insert_verified_transaction(test_chain.at(0).into()); chain.insert_verified_transaction(test_chain.at(1).into()); chain.insert_verified_transaction(test_chain.at(2).into()); @@ -1015,7 +1015,7 @@ mod tests { let tx2_hash = tx2.hash(); let db = Arc::new(BlockChainDatabase::init_test_chain(vec![b0.into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.verify_transaction(tx1.into()); chain.insert_verified_transaction(tx2.into()); @@ -1063,7 +1063,7 @@ mod tests { let tx5 = b5.transactions[0].clone(); let db = Arc::new(BlockChainDatabase::init_test_chain(vec![genesis.into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.insert_verified_transaction(tx3.into()); chain.insert_verified_transaction(tx4.into()); @@ -1107,7 +1107,7 @@ mod tests { // insert tx2 to memory pool let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.insert_verified_transaction(tx2.clone().into()); chain.insert_verified_transaction(tx3.clone().into()); // insert verified block with tx1 @@ -1126,7 +1126,7 @@ mod tests { .reset().set_input(&data_chain.at(0), 0).add_output(30).store(data_chain); // transaction0 -> transaction2 let db = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let mut chain = Chain::new(db, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); + let mut chain = Chain::new(db, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), Arc::new(RwLock::new(MemoryPool::new()))); chain.insert_verified_transaction(data_chain.at(1).into()); assert_eq!(chain.information().transactions.transactions_count, 1); chain.insert_verified_transaction(data_chain.at(2).into()); diff --git a/sync/src/synchronization_client_core.rs b/sync/src/synchronization_client_core.rs index e0f856e8..1c084f20 100644 --- a/sync/src/synchronization_client_core.rs +++ b/sync/src/synchronization_client_core.rs @@ -1265,7 +1265,7 @@ pub mod tests { use message::common::InventoryVector; use message::{Services, types}; use miner::MemoryPool; - use network::{ConsensusParams, ConsensusFork, Magic}; + use network::{ConsensusParams, ConsensusFork, Network}; use primitives::hash::H256; use verification::BackwardsCompatibleChainVerifier as ChainVerifier; use inbound_connection::tests::DummyOutboundSyncConnection; @@ -1316,11 +1316,11 @@ pub mod tests { }; let sync_state = SynchronizationStateRef::new(SynchronizationState::with_storage(storage.clone())); let memory_pool = Arc::new(RwLock::new(MemoryPool::new())); - let chain = Chain::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork), memory_pool.clone()); + let chain = Chain::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork), memory_pool.clone()); let executor = DummyTaskExecutor::new(); let config = Config { close_connection_on_bad_block: true }; - let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork))); + let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork))); let client_core = SynchronizationClientCore::new(config, sync_state.clone(), sync_peers.clone(), executor.clone(), chain, chain_verifier.clone()); { client_core.lock().set_verify_headers(false); diff --git a/sync/src/synchronization_verifier.rs b/sync/src/synchronization_verifier.rs index 2eb42716..535bf924 100644 --- a/sync/src/synchronization_verifier.rs +++ b/sync/src/synchronization_verifier.rs @@ -263,7 +263,7 @@ pub mod tests { use std::sync::atomic::Ordering; use std::collections::{HashSet, HashMap}; use db::BlockChainDatabase; - use network::{Magic, ConsensusParams, ConsensusFork}; + use network::{Network, ConsensusParams, ConsensusFork}; use verification::{VerificationLevel, BackwardsCompatibleChainVerifier as ChainVerifier, Error as VerificationError, TransactionError}; use synchronization_client_core::CoreVerificationSink; use synchronization_executor::tests::DummyTaskExecutor; @@ -351,7 +351,7 @@ pub mod tests { #[test] fn verifier_wrapper_switches_to_full_mode() { let storage: StorageRef = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork))); + let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork))); // switching to full verification when block is already in db assert_eq!(ChainVerifierWrapper::new(verifier.clone(), &storage, VerificationParameters { @@ -382,7 +382,7 @@ pub mod tests { .build() .merkled_header() .parent(rolling_hash.clone()) - .bits(Magic::Unitest.max_bits()) + .bits(Network::Unitest.max_bits()) .build() .build(); rolling_hash = next_block.hash(); @@ -392,7 +392,7 @@ pub mod tests { let coinbase_transaction_hash = blocks[0].transactions[0].hash.clone(); let last_block_hash = blocks[blocks.len() - 1].hash().clone(); let storage: StorageRef = Arc::new(BlockChainDatabase::init_test_chain(blocks)); - let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork))); + let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork))); let bad_transaction_block: IndexedBlock = test_data::block_builder() .transaction().coinbase().output().value(50).build().build() .transaction() @@ -401,7 +401,7 @@ pub mod tests { .build() .merkled_header() .parent(last_block_hash) - .bits(Magic::Unitest.max_bits()) + .bits(Network::Unitest.max_bits()) .build() .build().into(); @@ -424,7 +424,7 @@ pub mod tests { #[test] fn verification_level_none_accept_incorrect_block() { let storage: StorageRef = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); - let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork))); + let verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork))); let bad_block: IndexedBlock = test_data::block_builder().header().build().build().into(); // Ok(()) when nothing is verified diff --git a/verification/src/accept_transaction.rs b/verification/src/accept_transaction.rs index 3bfcd1e9..fbb79b2c 100644 --- a/verification/src/accept_transaction.rs +++ b/verification/src/accept_transaction.rs @@ -470,7 +470,7 @@ impl<'a> TransactionPrematureWitness<'a> { #[cfg(test)] mod tests { use chain::{IndexedTransaction, Transaction, TransactionOutput}; - use network::{Magic, ConsensusParams, ConsensusFork}; + use network::{Network, ConsensusParams, ConsensusFork}; use script::Builder; use canon::CanonTransaction; use error::TransactionError; @@ -492,13 +492,13 @@ mod tests { assert_eq!(transaction.raw.outputs[0].script_pubkey.len(), 46 + 2); - let consensus = ConsensusParams::new(Magic::Mainnet, ConsensusFork::BitcoinCash(100)); + let consensus = ConsensusParams::new(Network::Mainnet, ConsensusFork::BitcoinCash(100)); let checker = TransactionReturnReplayProtection::new(CanonTransaction::new(&transaction), &consensus, 100); assert_eq!(checker.check(), Err(TransactionError::ReturnReplayProtection)); let checker = TransactionReturnReplayProtection::new(CanonTransaction::new(&transaction), &consensus, 50); assert_eq!(checker.check(), Ok(())); - let consensus = ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork); + let consensus = ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork); let checker = TransactionReturnReplayProtection::new(CanonTransaction::new(&transaction), &consensus, 100); assert_eq!(checker.check(), Ok(())); } diff --git a/verification/src/chain_verifier.rs b/verification/src/chain_verifier.rs index 02505025..eca36987 100644 --- a/verification/src/chain_verifier.rs +++ b/verification/src/chain_verifier.rs @@ -144,7 +144,7 @@ mod tests { use std::sync::Arc; use chain::IndexedBlock; use db::{BlockChainDatabase, Error as DBError}; - use network::{Magic, ConsensusParams, ConsensusFork}; + use network::{Network, ConsensusParams, ConsensusFork}; use script; use super::BackwardsCompatibleChainVerifier as ChainVerifier; use {Verify, Error, TransactionError, VerificationLevel}; @@ -153,7 +153,7 @@ mod tests { fn verify_orphan() { let storage = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); let b2 = test_data::block_h2().into(); - let verifier = ChainVerifier::new(storage, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(storage, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert_eq!(Err(Error::Database(DBError::UnknownParent)), verifier.verify(VerificationLevel::Full, &b2)); } @@ -161,7 +161,7 @@ mod tests { fn verify_smoky() { let storage = Arc::new(BlockChainDatabase::init_test_chain(vec![test_data::genesis().into()])); let b1 = test_data::block_h1(); - let verifier = ChainVerifier::new(storage, ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(storage, ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert!(verifier.verify(VerificationLevel::Full, &b1.into()).is_ok()); } @@ -174,7 +174,7 @@ mod tests { test_data::block_h1().into(), ]); let b1 = test_data::block_h2(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert!(verifier.verify(VerificationLevel::Full, &b1.into()).is_ok()); } @@ -203,7 +203,7 @@ mod tests { .merkled_header().parent(genesis.hash()).build() .build(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); let expected = Err(Error::Transaction( 1, @@ -241,7 +241,7 @@ mod tests { .merkled_header().parent(genesis.hash()).build() .build(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert!(verifier.verify(VerificationLevel::Full, &block.into()).is_ok()); } @@ -277,7 +277,7 @@ mod tests { .merkled_header().parent(genesis.hash()).build() .build(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert!(verifier.verify(VerificationLevel::Full, &block.into()).is_ok()); } @@ -316,7 +316,7 @@ mod tests { .merkled_header().parent(genesis.hash()).build() .build(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); let expected = Err(Error::Transaction(2, TransactionError::Overspend)); assert_eq!(expected, verifier.verify(VerificationLevel::Full, &block.into())); @@ -358,7 +358,7 @@ mod tests { .merkled_header().parent(best_hash).build() .build(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); assert!(verifier.verify(VerificationLevel::Full, &block.into()).is_ok()); } @@ -405,7 +405,7 @@ mod tests { .build() .into(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); let expected = Err(Error::MaximumSigops); assert_eq!(expected, verifier.verify(VerificationLevel::Full, &block.into())); } @@ -427,7 +427,7 @@ mod tests { .build() .into(); - let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, ConsensusFork::NoFork)); + let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Network::Unitest, ConsensusFork::NoFork)); let expected = Err(Error::CoinbaseOverspend { expected_max: 5000000000, diff --git a/verification/src/verify_chain.rs b/verification/src/verify_chain.rs index 6543d6e6..7ad0f9a5 100644 --- a/verification/src/verify_chain.rs +++ b/verification/src/verify_chain.rs @@ -1,6 +1,6 @@ use rayon::prelude::{IntoParallelRefIterator, IndexedParallelIterator, ParallelIterator}; use chain::IndexedBlock; -use network::Magic; +use network::Network; use error::Error; use verify_block::BlockVerifier; use verify_header::HeaderVerifier; @@ -13,7 +13,7 @@ pub struct ChainVerifier<'a> { } impl<'a> ChainVerifier<'a> { - pub fn new(block: &'a IndexedBlock, network: Magic, current_time: u32) -> Self { + pub fn new(block: &'a IndexedBlock, network: Network, current_time: u32) -> Self { trace!(target: "verification", "Block pre-verification {}", block.hash().to_reversed_str()); ChainVerifier { block: BlockVerifier::new(block), diff --git a/verification/src/verify_header.rs b/verification/src/verify_header.rs index 608ff9bc..cb997e0a 100644 --- a/verification/src/verify_header.rs +++ b/verification/src/verify_header.rs @@ -1,6 +1,6 @@ use primitives::compact::Compact; use chain::IndexedBlockHeader; -use network::Magic; +use network::Network; use work::is_valid_proof_of_work; use error::Error; use constants::BLOCK_MAX_FUTURE; @@ -11,7 +11,7 @@ pub struct HeaderVerifier<'a> { } impl<'a> HeaderVerifier<'a> { - pub fn new(header: &'a IndexedBlockHeader, network: Magic, current_time: u32) -> Self { + pub fn new(header: &'a IndexedBlockHeader, network: Network, current_time: u32) -> Self { HeaderVerifier { proof_of_work: HeaderProofOfWork::new(header, network), timestamp: HeaderTimestamp::new(header, current_time, BLOCK_MAX_FUTURE as u32), @@ -31,7 +31,7 @@ pub struct HeaderProofOfWork<'a> { } impl<'a> HeaderProofOfWork<'a> { - fn new(header: &'a IndexedBlockHeader, network: Magic) -> Self { + fn new(header: &'a IndexedBlockHeader, network: Network) -> Self { HeaderProofOfWork { header: header, max_work_bits: network.max_bits(), diff --git a/verification/src/work.rs b/verification/src/work.rs index 61a33e0e..aedccd40 100644 --- a/verification/src/work.rs +++ b/verification/src/work.rs @@ -2,7 +2,7 @@ use std::cmp; use primitives::compact::Compact; use primitives::hash::H256; use primitives::bigint::U256; -use network::{Magic, ConsensusParams, ConsensusFork}; +use network::{Network, ConsensusParams, ConsensusFork}; use db::{BlockHeaderProvider, BlockRef}; use timestamp::median_timestamp_inclusive; @@ -78,8 +78,8 @@ pub fn work_required(parent_hash: H256, time: u32, height: u32, store: &BlockHea return work_required_retarget(max_bits, retarget_timestamp, last_timestamp, last_bits); } - if consensus.network == Magic::Testnet { - return work_required_testnet(parent_hash, time, height, store, Magic::Testnet) + if consensus.network == Network::Testnet { + return work_required_testnet(parent_hash, time, height, store, Network::Testnet) } match consensus.fork { @@ -114,7 +114,7 @@ pub fn work_required(parent_hash: H256, time: u32, height: u32, store: &BlockHea } } -pub fn work_required_testnet(parent_hash: H256, time: u32, height: u32, store: &BlockHeaderProvider, network: Magic) -> Compact { +pub fn work_required_testnet(parent_hash: H256, time: u32, height: u32, store: &BlockHeaderProvider, network: Network) -> Compact { assert!(height != 0, "cannot calculate required work for genesis block"); let mut bits = Vec::new(); @@ -172,7 +172,7 @@ mod tests { use primitives::bytes::Bytes; use primitives::hash::H256; use primitives::compact::Compact; - use network::{Magic, ConsensusParams, ConsensusFork}; + use network::{Network, ConsensusParams, ConsensusFork}; use db::{BlockHeaderProvider, BlockRef}; use chain::BlockHeader; use super::{work_required, is_valid_proof_of_work_hash, is_valid_proof_of_work, block_reward_satoshi}; @@ -185,14 +185,14 @@ mod tests { #[test] fn test_is_valid_proof_of_work() { // block 2 - assert!(is_valid_pow(Magic::Mainnet.max_bits(), 486604799u32, "000000006a625f06636b8bb6ac7b960a8d03705d1ace08b1a19da3fdcc99ddbd")); + assert!(is_valid_pow(Network::Mainnet.max_bits(), 486604799u32, "000000006a625f06636b8bb6ac7b960a8d03705d1ace08b1a19da3fdcc99ddbd")); // block 400_000 - assert!(is_valid_pow(Magic::Mainnet.max_bits(), 403093919u32, "000000000000000004ec466ce4732fe6f1ed1cddc2ed4b328fff5224276e3f6f")); + assert!(is_valid_pow(Network::Mainnet.max_bits(), 403093919u32, "000000000000000004ec466ce4732fe6f1ed1cddc2ed4b328fff5224276e3f6f")); // other random tests - assert!(is_valid_pow(Magic::Regtest.max_bits(), 0x181bc330u32, "00000000000000001bc330000000000000000000000000000000000000000000")); - assert!(!is_valid_pow(Magic::Regtest.max_bits(), 0x181bc330u32, "00000000000000001bc330000000000000000000000000000000000000000001")); - assert!(!is_valid_pow(Magic::Regtest.max_bits(), 0x181bc330u32, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); + assert!(is_valid_pow(Network::Regtest.max_bits(), 0x181bc330u32, "00000000000000001bc330000000000000000000000000000000000000000000")); + assert!(!is_valid_pow(Network::Regtest.max_bits(), 0x181bc330u32, "00000000000000001bc330000000000000000000000000000000000000000001")); + assert!(!is_valid_pow(Network::Regtest.max_bits(), 0x181bc330u32, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); } #[test] @@ -237,8 +237,8 @@ mod tests { } } - let main_consensus = ConsensusParams::new(Magic::Mainnet, ConsensusFork::NoFork); - let uahf_consensus = ConsensusParams::new(Magic::Mainnet, ConsensusFork::BitcoinCash(1000)); + let main_consensus = ConsensusParams::new(Network::Mainnet, ConsensusFork::NoFork); + let uahf_consensus = ConsensusParams::new(Network::Mainnet, ConsensusFork::BitcoinCash(1000)); let mut header_provider = MemoryBlockHeaderProvider::default(); header_provider.insert(BlockHeader { version: 0,