zecfoundation
/
parity-zcash
mirror of https://github.com/ZcashFoundation/parity-zcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #465 from paritytech/bitcoincash_magic 

Changed magic for BCH network
This commit is contained in:
Svyatoslav Nikolsky 2017-11-06 12:48:24 +03:00 committed by GitHub
parent 13ff162b18 77eb2dec67
commit 48f8886894
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 338 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bencher/src/verifier.rs
View File

@ -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();

8
message/src/message/message_header.rs
View File

@ -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());
}
}

56
network/src/consensus.rs
View File

@ -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]

5
network/src/lib.rs
View File

@ -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};

150
network/src/magic.rs
View File

@ -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<Magic> 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<u32> 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);
}
}

136
network/src/network.rs Normal file
View File

@ -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);
}
}

32
p2p/src/io/handshake.rs
View File

@ -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);
}
}

10
p2p/src/io/read_any_message.rs
View File

@ -63,7 +63,7 @@ impl<A> Future for ReadAnyMessage<A> 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));
}
}

12
p2p/src/io/read_header.rs
View File

@ -32,7 +32,7 @@ impl<A> Future for ReadHeader<A> 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());
}
}

12
p2p/src/io/read_message.rs
View File

@ -69,7 +69,7 @@ impl<M, A> Future for ReadMessage<M, A> 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::<Ping, _>(raw.as_ref(), Magic::Testnet, 0).wait().unwrap().1, Err(Error::InvalidMagic));
assert_eq!(read_message::<Pong, _>(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::<Ping, _>(raw.as_ref(), Network::Testnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Err(Error::InvalidMagic));
assert_eq!(read_message::<Pong, _>(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::<Ping, _>(raw.as_ref(), Magic::Mainnet, 0).wait().is_err());
assert!(read_message::<Ping, _>(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::<Ping, _>(raw.as_ref(), Magic::Mainnet, 0).wait().unwrap().1, Err(Error::InvalidChecksum));
assert_eq!(read_message::<Ping, _>(raw.as_ref(), Network::Mainnet.magic(ConsensusFork::NoFork), 0).wait().unwrap().1, Err(Error::InvalidChecksum));
}
}

2
pbtc/commands/rollback.rs
View File

@ -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

4
pbtc/commands/start.rs
View File

@ -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(),

58
pbtc/config.rs
View File

@ -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<Config, String> {
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<Config, String> {
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::<net::SocketAddr>() {
Err(_) => s.parse::<net::IpAddr>()
.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<Config, String> {
let mut seednodes: Vec<String> = 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<Config, String> {
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<Config, String> {
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<RpcHttpConfig, String> {
let mut config = RpcHttpConfig::with_port(magic.rpc_port());
fn parse_rpc_config(network: Network, matches: &clap::ArgMatches) -> Result<RpcHttpConfig, String> {
let mut config = RpcHttpConfig::with_port(network.rpc_port());
config.enabled = !matches.is_present("no-jsonrpc");
if !config.enabled {
return Ok(config);

4
pbtc/rpc.rs
View File

@ -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<p2p::Context>,

14
pbtc/seednodes.rs
View File

@ -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",

2
pbtc/util.rs
View File

@ -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(()),

14
rpc/src/v1/impls/blockchain.rs
View File

@ -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<T: BlockChainClientCoreApi> {
@ -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

10
sync/src/blocks_writer.rs
View File

@ -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);

4
sync/src/lib.rs
View File

@ -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()));

8
sync/src/local_node.rs
View File

@ -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)
}

24
sync/src/synchronization_chain.rs
View File

@ -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());

6
sync/src/synchronization_client_core.rs
View File

@ -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);

12
sync/src/synchronization_verifier.rs
View File

@ -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

6
verification/src/accept_transaction.rs
View File

@ -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(()));
}

22
verification/src/chain_verifier.rs
View File

@ -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,

4
verification/src/verify_chain.rs
View File

@ -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),

6
verification/src/verify_header.rs
View File

@ -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(),

24
verification/src/work.rs
View File

@ -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,