propagate ConsensusParams with ConsensusFork

network/src/consensus.rs

@@ -1,9 +1,28 @@
 use hash::H256;
 use {Magic, Deployment};
 
+#[derive(Debug, Clone, Copy)]
+/// Concurrent consensus rule forks.
+pub enum ConsensusFork {
+	/// SegWit2x (aka The New York Agreement).
+	/// Briefly: SegWit + blocks up to 2MB.
+	/// Technical specification:
+	/// Segregated Witness (Consensus layer) - https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki
+	/// Block size increase to 2MB - https://github.com/bitcoin/bips/blob/master/bip-0102.mediawiki
+	SegWit2x(u32),
+	/// Bitcoin Cash (aka UAHF).
+	/// Briefly: no SegWit + blocks up to 8MB + replay protection.
+	/// Technical specification:
+	/// UAHF Technical Specification - https://github.com/Bitcoin-UAHF/spec/blob/master/uahf-technical-spec.md
+	/// BUIP-HF Digest for replay protected signature verification across hard forks - https://github.com/Bitcoin-UAHF/spec/blob/master/replay-protected-sighash.md
+	BitcoinCash(u32),
+}
+
 #[derive(Debug, Clone)]
 /// Parameters that influence chain consensus.
 pub struct ConsensusParams {
+	/// Network.
+	pub magic: Magic,
 	/// Time when BIP16 becomes active.
 	/// See https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki
 	pub bip16_time: u32,
@@ -16,6 +35,8 @@ pub struct ConsensusParams {
 	/// Block height at which BIP65 becomes active.
 	/// See https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
 	pub bip66_height: u32,
+	/// Selected consensus fork.
+	pub fork: Option<ConsensusFork>,
 	/// Version bits activation
 	pub rule_change_activation_threshold: u32,
 	/// Number of blocks with the same set of rules
@@ -27,13 +48,15 @@ pub struct ConsensusParams {
 }
 
 impl ConsensusParams {
-	pub fn with_magic(magic: Magic) -> Self {
+	pub fn new(magic: Magic, fork: Option<ConsensusFork>) -> Self {
 		match magic {
 			Magic::Mainnet | Magic::Other(_) => ConsensusParams {
+				magic: magic,
 				bip16_time: 1333238400,	// Apr 1 2012
 				bip34_height: 227931,	// 000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8
 				bip65_height: 388381,	// 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
 				bip66_height: 363725,	// 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
+				fork: fork,
 				rule_change_activation_threshold: 1916, // 95%
 				miner_confirmation_window: 2016,
 				csv_deployment: Some(Deployment {
@@ -46,10 +69,12 @@ impl ConsensusParams {
 				segwit_deployment: None,
 			},
 			Magic::Testnet => ConsensusParams {
+				magic: magic,
 				bip16_time: 1333238400,	// Apr 1 2012
 				bip34_height: 21111,	// 0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8
 				bip65_height: 581885,	// 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
 				bip66_height: 330776,	// 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
+				fork: fork,
 				rule_change_activation_threshold: 1512, // 75%
 				miner_confirmation_window: 2016,
 				csv_deployment: Some(Deployment {
@@ -62,10 +87,12 @@ impl ConsensusParams {
 				segwit_deployment: None,
 			},
 			Magic::Regtest | Magic::Unitest => ConsensusParams {
+				magic: magic,
 				bip16_time: 1333238400,	// Apr 1 2012
 				bip34_height: 100000000,	// not activated on regtest
 				bip65_height: 1351,
 				bip66_height: 1251,		// used only in rpc tests
+				fork: fork,
 				rule_change_activation_threshold: 108, // 75%
 				miner_confirmation_window: 144,
 				csv_deployment: Some(Deployment {
@@ -93,36 +120,36 @@ mod tests {
 
 	#[test]
 	fn test_consensus_params_bip34_height() {
-		assert_eq!(ConsensusParams::with_magic(Magic::Mainnet).bip34_height, 227931);
+		assert_eq!(ConsensusParams::new(Magic::Mainnet, None).bip34_height, 227931);
-		assert_eq!(ConsensusParams::with_magic(Magic::Testnet).bip34_height, 21111);
+		assert_eq!(ConsensusParams::new(Magic::Testnet, None).bip34_height, 21111);
-		assert_eq!(ConsensusParams::with_magic(Magic::Regtest).bip34_height, 100000000);
+		assert_eq!(ConsensusParams::new(Magic::Regtest, None).bip34_height, 100000000);
 	}
 
 	#[test]
 	fn test_consensus_params_bip65_height() {
-		assert_eq!(ConsensusParams::with_magic(Magic::Mainnet).bip65_height, 388381);
+		assert_eq!(ConsensusParams::new(Magic::Mainnet, None).bip65_height, 388381);
-		assert_eq!(ConsensusParams::with_magic(Magic::Testnet).bip65_height, 581885);
+		assert_eq!(ConsensusParams::new(Magic::Testnet, None).bip65_height, 581885);
-		assert_eq!(ConsensusParams::with_magic(Magic::Regtest).bip65_height, 1351);
+		assert_eq!(ConsensusParams::new(Magic::Regtest, None).bip65_height, 1351);
 	}
 
 	#[test]
 	fn test_consensus_params_bip66_height() {
-		assert_eq!(ConsensusParams::with_magic(Magic::Mainnet).bip66_height, 363725);
+		assert_eq!(ConsensusParams::new(Magic::Mainnet, None).bip66_height, 363725);
-		assert_eq!(ConsensusParams::with_magic(Magic::Testnet).bip66_height, 330776);
+		assert_eq!(ConsensusParams::new(Magic::Testnet, None).bip66_height, 330776);
-		assert_eq!(ConsensusParams::with_magic(Magic::Regtest).bip66_height, 1251);
+		assert_eq!(ConsensusParams::new(Magic::Regtest, None).bip66_height, 1251);
 	}
 
 	#[test]
 	fn test_consensus_activation_threshold() {
-		assert_eq!(ConsensusParams::with_magic(Magic::Mainnet).rule_change_activation_threshold, 1916);
+		assert_eq!(ConsensusParams::new(Magic::Mainnet, None).rule_change_activation_threshold, 1916);
-		assert_eq!(ConsensusParams::with_magic(Magic::Testnet).rule_change_activation_threshold, 1512);
+		assert_eq!(ConsensusParams::new(Magic::Testnet, None).rule_change_activation_threshold, 1512);
-		assert_eq!(ConsensusParams::with_magic(Magic::Regtest).rule_change_activation_threshold, 108);
+		assert_eq!(ConsensusParams::new(Magic::Regtest, None).rule_change_activation_threshold, 108);
 	}
 
 	#[test]
 	fn test_consensus_miner_confirmation_window() {
-		assert_eq!(ConsensusParams::with_magic(Magic::Mainnet).miner_confirmation_window, 2016);
+		assert_eq!(ConsensusParams::new(Magic::Mainnet, None).miner_confirmation_window, 2016);
-		assert_eq!(ConsensusParams::with_magic(Magic::Testnet).miner_confirmation_window, 2016);
+		assert_eq!(ConsensusParams::new(Magic::Testnet, None).miner_confirmation_window, 2016);
-		assert_eq!(ConsensusParams::with_magic(Magic::Regtest).miner_confirmation_window, 144);
+		assert_eq!(ConsensusParams::new(Magic::Regtest, None).miner_confirmation_window, 144);
 	}
 }

network/src/lib.rs

@@ -8,7 +8,7 @@ mod magic;
 
 pub use primitives::{hash, compact};
 
-pub use consensus::ConsensusParams;
+pub use consensus::{ConsensusParams, ConsensusFork};
 pub use deployments::Deployment;
 pub use magic::Magic;
 

network/src/magic.rs

@@ -4,7 +4,6 @@
 use compact::Compact;
 use ser::{Stream, Serializable};
 use chain::Block;
-use super::ConsensusParams;
 
 const MAGIC_MAINNET: u32 = 0xD9B4BEF9;
 const MAGIC_TESTNET: u32 = 0x0709110B;
@@ -87,10 +86,6 @@ impl Magic {
 			Magic::Regtest | Magic::Unitest => "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f20020000000101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000".into(),
 		}
 	}
-
-	pub fn consensus_params(&self) -> ConsensusParams {
-		ConsensusParams::with_magic(*self)
-	}
 }
 
 impl Serializable for Magic {

pbtc/cli.yml

@@ -9,6 +9,16 @@ args:
     - regtest:
         long: regtest
         help: Use private network for regtest
+    - segwit2x:
+        long: segwit2x
+        value_name: BLOCK
+        help: Enable SegWit2x verification rules, starting from given block height
+        takes_value: true
+    - bitcoin-cash:
+        long: bitcoin-cash
+        value_name: BLOCK
+        help: Use Bitcoin Cash verification rules, starting from given block height
+        takes_value: true
     - connect:
         short: c
         long: connect

pbtc/commands/import.rs

@@ -11,7 +11,7 @@ pub fn import(cfg: Config, matches: &ArgMatches) -> Result<(), String> {
 	let blk_path = matches.value_of("PATH").expect("PATH is required in cli.yml; qed");
 	let skip_verification = matches.is_present("skip-verification");
 
-	let mut writer = create_sync_blocks_writer(db, cfg.magic, !skip_verification);
+	let mut writer = create_sync_blocks_writer(db, cfg.consensus, !skip_verification);
 
 	let blk_dir = try!(::import::open_blk_dir(blk_path).map_err(|_| "Import directory does not exist".to_owned()));
 	let mut counter = 0;

pbtc/commands/start.rs

@@ -111,7 +111,7 @@ pub fn start(cfg: config::Config) -> Result<(), String> {
 	};
 
 	let sync_peers = create_sync_peers();
-	let local_sync_node = create_local_sync_node(cfg.magic, db.clone(), sync_peers.clone());
+	let local_sync_node = create_local_sync_node(cfg.consensus, db.clone(), sync_peers.clone());
 	let sync_connection_factory = create_sync_connection_factory(sync_peers.clone(), local_sync_node.clone());
 
 	if let Some(block_notify_command) = cfg.block_notify_command {

pbtc/config.rs

@@ -1,6 +1,6 @@
 use std::net;
 use clap;
-use network::Magic;
+use network::{Magic, ConsensusParams, ConsensusFork};
 use p2p::InternetProtocol;
 use seednodes::{mainnet_seednodes, testnet_seednodes};
 use rpc_apis::ApiSet;
@@ -9,6 +9,7 @@ use rpc::HttpConfiguration as RpcHttpConfig;
 
 pub struct Config {
 	pub magic: Magic,
+	pub consensus: ConsensusParams,
 	pub port: u16,
 	pub connect: Option<net::SocketAddr>,
 	pub seednodes: Vec<String>,
@@ -35,6 +36,13 @@ pub fn parse(matches: &clap::ArgMatches) -> Result<Config, String> {
 		(true, true) => return Err("Only one testnet option can be used".into()),
 	};
 
+	let consensus = ConsensusParams::new(magic, match (matches.value_of("segwit2x"), matches.value_of("bitcoin-cash")) {
+		(Some(block), None) => Some(ConsensusFork::SegWit2x(block.parse().map_err(|_| "Invalid block number".to_owned())?)),
+		(None, Some(block)) => Some(ConsensusFork::BitcoinCash(block.parse().map_err(|_| "Invalid block number".to_owned())?)),
+		(None, None) => None,
+		(Some(_), Some(_)) => return Err("Only one fork can be used".into()),
+	});
+
 	let (in_connections, out_connections) = match magic {
 		Magic::Testnet | Magic::Mainnet | Magic::Other(_) => (10, 10),
 		Magic::Regtest | Magic::Unitest => (1, 0),
@@ -52,22 +60,22 @@ pub fn parse(matches: &clap::ArgMatches) -> Result<Config, String> {
 	};
 
 	let port = match matches.value_of("port") {
-		Some(port) => try!(port.parse().map_err(|_| "Invalid port".to_owned())),
+		Some(port) => port.parse().map_err(|_| "Invalid port".to_owned())?,
 		None => magic.port(),
 	};
 
 	let connect = match matches.value_of("connect") {
-		Some(s) => Some(try!(match s.parse::<net::SocketAddr>() {
+		Some(s) => Some(match s.parse::<net::SocketAddr>() {
 			Err(_) => s.parse::<net::IpAddr>()
 				.map(|ip| net::SocketAddr::new(ip, magic.port()))
 				.map_err(|_| "Invalid connect".to_owned()),
 			Ok(a) => Ok(a),
-		})),
+		}?),
 		None => None,
 	};
 
 	let seednodes = match matches.value_of("seednode") {
-		Some(s) => vec![try!(s.parse().map_err(|_| "Invalid seednode".to_owned()))],
+		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(),
@@ -76,30 +84,31 @@ pub fn parse(matches: &clap::ArgMatches) -> Result<Config, String> {
 	};
 
 	let db_cache = match matches.value_of("db-cache") {
-		Some(s) => try!(s.parse().map_err(|_| "Invalid cache size - should be number in MB".to_owned())),
+		Some(s) => s.parse().map_err(|_| "Invalid cache size - should be number in MB".to_owned())?,
 		None => DEFAULT_DB_CACHE,
 	};
 
 	let data_dir = match matches.value_of("data-dir") {
-		Some(s) => Some(try!(s.parse().map_err(|_| "Invalid data-dir".to_owned()))),
+		Some(s) => Some(s.parse().map_err(|_| "Invalid data-dir".to_owned())?),
 		None => None,
 	};
 
 	let only_net = match matches.value_of("only-net") {
-		Some(s) => try!(s.parse()),
+		Some(s) => s.parse()?,
 		None => InternetProtocol::default(),
 	};
 
-	let rpc_config = try!(parse_rpc_config(magic, matches));
+	let rpc_config = parse_rpc_config(magic, matches)?;
 
 	let block_notify_command = match matches.value_of("blocknotify") {
-		Some(s) => Some(try!(s.parse().map_err(|_| "Invalid blocknotify commmand".to_owned()))),
+		Some(s) => Some(s.parse().map_err(|_| "Invalid blocknotify commmand".to_owned())?),
 		None => None,
 	};
 
 	let config = Config {
 		print_to_console: print_to_console,
 		magic: magic,
+		consensus: consensus,
 		port: port,
 		connect: connect,
 		seednodes: seednodes,
@@ -125,19 +134,19 @@ fn parse_rpc_config(magic: Magic, matches: &clap::ArgMatches) -> Result<RpcHttpC
 	}
 
 	if let Some(apis) = matches.value_of("jsonrpc-apis") {
-		config.apis = ApiSet::List(vec![try!(apis.parse().map_err(|_| "Invalid APIs".to_owned()))].into_iter().collect());
+		config.apis = ApiSet::List(vec![apis.parse().map_err(|_| "Invalid APIs".to_owned())?].into_iter().collect());
 	}
 	if let Some(port) = matches.value_of("jsonrpc-port") {
-		config.port = try!(port.parse().map_err(|_| "Invalid JSON RPC port".to_owned()));
+		config.port = port.parse().map_err(|_| "Invalid JSON RPC port".to_owned())?;
 	}
 	if let Some(interface) = matches.value_of("jsonrpc-interface") {
 		config.interface = interface.to_owned();
 	}
 	if let Some(cors) = matches.value_of("jsonrpc-cors") {
-		config.cors = Some(vec![try!(cors.parse().map_err(|_| "Invalid JSON RPC CORS".to_owned()))]);
+		config.cors = Some(vec![cors.parse().map_err(|_| "Invalid JSON RPC CORS".to_owned())?]);
 	}
 	if let Some(hosts) = matches.value_of("jsonrpc-hosts") {
-		config.hosts = Some(vec![try!(hosts.parse().map_err(|_| "Invalid JSON RPC hosts".to_owned()))]);
+		config.hosts = Some(vec![hosts.parse().map_err(|_| "Invalid JSON RPC hosts".to_owned())?]);
 	}
 
 	Ok(config)

sync/src/blocks_writer.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use parking_lot::Mutex;
 use chain;
 use db;
-use network::Magic;
+use network::ConsensusParams;
 use primitives::hash::H256;
 use super::Error;
 use synchronization_verifier::{Verifier, SyncVerifier, VerificationTask,
@@ -44,10 +44,10 @@ struct BlocksWriterSinkData {
 
 impl BlocksWriter {
 	/// Create new synchronous blocks writer
-	pub fn new(storage: StorageRef, network: Magic, verification: bool) -> BlocksWriter {
+	pub fn new(storage: StorageRef, consensus: ConsensusParams, verification: bool) -> BlocksWriter {
 		let sink_data = Arc::new(BlocksWriterSinkData::new(storage.clone()));
 		let sink = Arc::new(BlocksWriterSink::new(sink_data.clone()));
-		let verifier = SyncVerifier::new(network, storage.clone(), sink);
+		let verifier = SyncVerifier::new(consensus, storage.clone(), sink);
 		BlocksWriter {
 			storage: storage,
 			orphaned_blocks_pool: OrphanBlocksPool::new(),
@@ -156,14 +156,14 @@ mod tests {
 
 	use std::sync::Arc;
 	use db::{BlockChainDatabase};
-	use network::Magic;
+	use network::{ConsensusParams, Magic};
 	use super::super::Error;
 	use super::{BlocksWriter, MAX_ORPHANED_BLOCKS};
 
 	#[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(), Magic::Testnet, true);
+		let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, None), true);
 		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(), Magic::Testnet, true);
+		let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, None), true);
 		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(), Magic::Testnet, true);
+		let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, None), true);
 
 		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(), Magic::Testnet, true);
+		let mut blocks_target = BlocksWriter::new(db.clone(), ConsensusParams::new(Magic::Testnet, None), true);
 
 		assert!(blocks_target.append_block(test_data::genesis().into()).is_ok());
 		assert_eq!(db.best_block().number, 0);

sync/src/lib.rs

@@ -41,7 +41,7 @@ pub use types::PeersRef;
 
 use std::sync::Arc;
 use parking_lot::RwLock;
-use network::Magic;
+use network::{Magic, ConsensusParams};
 use primitives::hash::H256;
 use verification::BackwardsCompatibleChainVerifier as ChainVerifier;
 
@@ -65,8 +65,8 @@ pub trait SyncListener: Send + 'static {
 }
 
 /// Create blocks writer.
-pub fn create_sync_blocks_writer(db: db::SharedStore, network: Magic, verification: bool) -> blocks_writer::BlocksWriter {
+pub fn create_sync_blocks_writer(db: db::SharedStore, consensus: ConsensusParams, verification: bool) -> blocks_writer::BlocksWriter {
-	blocks_writer::BlocksWriter::new(db, network, verification)
+	blocks_writer::BlocksWriter::new(db, consensus, verification)
 }
 
 /// Create synchronization peers
@@ -77,7 +77,7 @@ pub fn create_sync_peers() -> PeersRef {
 }
 
 /// Creates local sync node for given `db`
-pub fn create_local_sync_node(network: Magic, db: db::SharedStore, peers: PeersRef) -> LocalNodeRef {
+pub fn create_local_sync_node(consensus: ConsensusParams, db: db::SharedStore, peers: PeersRef) -> LocalNodeRef {
 	use miner::MemoryPool;
 	use synchronization_chain::Chain as SyncChain;
 	use synchronization_executor::LocalSynchronizationTaskExecutor as SyncExecutor;
@@ -89,8 +89,8 @@ pub fn create_local_sync_node(network: Magic, db: db::SharedStore, peers: PeersR
 	use utils::SynchronizationState;
 	use types::SynchronizationStateRef;
 
+	let network = consensus.magic;
 	let sync_client_config = SynchronizationConfig {
-		network: network,
 		// 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,
 	};
@@ -98,7 +98,7 @@ pub fn create_local_sync_node(network: Magic, db: db::SharedStore, peers: PeersR
 	let memory_pool = Arc::new(RwLock::new(MemoryPool::new()));
 	let sync_state = SynchronizationStateRef::new(SynchronizationState::with_storage(db.clone()));
 	let sync_chain = SyncChain::new(db.clone(), memory_pool.clone());
-	let chain_verifier = Arc::new(ChainVerifier::new(db.clone(), network));
+	let chain_verifier = Arc::new(ChainVerifier::new(db.clone(), consensus));
 	let sync_executor = SyncExecutor::new(peers.clone());
 	let sync_server = Arc::new(ServerImpl::new(peers.clone(), db.clone(), memory_pool.clone(), sync_executor.clone()));
 	let sync_client_core = SynchronizationClientCore::new(sync_client_config, sync_state.clone(), peers.clone(), sync_executor.clone(), sync_chain, chain_verifier.clone());

sync/src/local_node.rs

@@ -335,7 +335,7 @@ pub mod tests {
 	use synchronization_chain::Chain;
 	use message::types;
 	use message::common::{InventoryVector, InventoryType};
-	use network::Magic;
+	use network::{ConsensusParams, Magic};
 	use chain::Transaction;
 	use db::{BlockChainDatabase};
 	use miner::MemoryPool;
@@ -373,8 +373,8 @@ pub mod tests {
 		let sync_peers = Arc::new(PeersImpl::default());
 		let executor = DummyTaskExecutor::new();
 		let server = Arc::new(DummyServer::new());
-		let config = Config { network: Magic::Mainnet, close_connection_on_bad_block: true };
+		let config = Config { close_connection_on_bad_block: true };
-		let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), Magic::Mainnet));
+		let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Mainnet, None)));
 		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,

sync/src/synchronization_client_core.rs

@@ -9,7 +9,6 @@ use chain::{IndexedBlockHeader, IndexedTransaction, Transaction, IndexedBlock};
 use message::types;
 use message::common::{InventoryType, InventoryVector};
 use miner::transaction_fee_rate;
-use network::Magic;
 use primitives::hash::H256;
 use verification::BackwardsCompatibleChainVerifier as ChainVerifier;
 use synchronization_chain::{Chain, BlockState, TransactionState, BlockInsertionResult};
@@ -77,8 +76,6 @@ pub trait ClientCore {
 /// Synchronization client configuration options.
 #[derive(Debug)]
 pub struct Config {
-	/// Network
-	pub network: Magic,
 	/// If true, connection to peer who has provided us with bad block is closed
 	pub close_connection_on_bad_block: bool,
 }
@@ -1183,7 +1180,7 @@ pub mod tests {
 	use message::common::InventoryVector;
 	use message::types;
 	use miner::MemoryPool;
-	use network::Magic;
+	use network::{ConsensusParams, Magic};
 	use primitives::hash::H256;
 	use verification::BackwardsCompatibleChainVerifier as ChainVerifier;
 	use inbound_connection::tests::DummyOutboundSyncConnection;
@@ -1236,9 +1233,9 @@ pub mod tests {
 		let memory_pool = Arc::new(RwLock::new(MemoryPool::new()));
 		let chain = Chain::new(storage.clone(), memory_pool.clone());
 		let executor = DummyTaskExecutor::new();
-		let config = Config { network: Magic::Mainnet, close_connection_on_bad_block: true };
+		let config = Config { close_connection_on_bad_block: true };
 
-		let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), Magic::Unitest));
+		let chain_verifier = Arc::new(ChainVerifier::new(storage.clone(), ConsensusParams::new(Magic::Unitest, None)));
 		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);

sync/src/synchronization_verifier.rs

@@ -5,7 +5,7 @@ use std::thread;
 use parking_lot::Mutex;
 use time::get_time;
 use chain::{IndexedBlock, IndexedTransaction};
-use network::Magic;
+use network::ConsensusParams;
 use primitives::hash::H256;
 use verification::{BackwardsCompatibleChainVerifier as ChainVerifier, Verify as VerificationVerify};
 use types::{BlockHeight, StorageRef, MemoryPoolRef};
@@ -182,8 +182,8 @@ pub struct SyncVerifier<T: VerificationSink> {
 
 impl<T> SyncVerifier<T> where T: VerificationSink {
 	/// Create new sync verifier
-	pub fn new(network: Magic, storage: StorageRef, sink: Arc<T>) -> Self {
+	pub fn new(consensus: ConsensusParams, storage: StorageRef, sink: Arc<T>) -> Self {
-		let verifier = ChainVerifier::new(storage.clone(), network);
+		let verifier = ChainVerifier::new(storage.clone(), consensus);
 		SyncVerifier {
 			verifier: verifier,
 			sink: sink,

verification/src/accept_block.rs

@@ -1,4 +1,4 @@
-use network::{Magic, ConsensusParams};
+use network::ConsensusParams;
 use db::{TransactionOutputProvider, BlockHeaderProvider};
 use script;
 use sigops::transaction_sigops;
@@ -21,18 +21,17 @@ pub struct BlockAcceptor<'a> {
 impl<'a> BlockAcceptor<'a> {
 	pub fn new(
 		store: &'a TransactionOutputProvider,
-		network: Magic,
+		consensus: &'a ConsensusParams,
 		block: CanonBlock<'a>,
 		height: u32,
 		deployments: &'a Deployments,
 		headers: &'a BlockHeaderProvider,
 	) -> Self {
-		let params = network.consensus_params();
 		BlockAcceptor {
-			finality: BlockFinality::new(block, height, deployments, headers, &params),
+			finality: BlockFinality::new(block, height, deployments, headers, consensus),
-			coinbase_script: BlockCoinbaseScript::new(block, &params, height),
+			coinbase_script: BlockCoinbaseScript::new(block, consensus, height),
 			coinbase_claim: BlockCoinbaseClaim::new(block, store, height),
-			sigops: BlockSigops::new(block, store, params, MAX_BLOCK_SIGOPS),
+			sigops: BlockSigops::new(block, store, consensus, MAX_BLOCK_SIGOPS),
 		}
 	}
 
@@ -82,12 +81,12 @@ impl<'a> BlockFinality<'a> {
 pub struct BlockSigops<'a> {
 	block: CanonBlock<'a>,
 	store: &'a TransactionOutputProvider,
-	consensus_params: ConsensusParams,
+	consensus_params: &'a ConsensusParams,
 	max_sigops: usize,
 }
 
 impl<'a> BlockSigops<'a> {
-	fn new(block: CanonBlock<'a>, store: &'a TransactionOutputProvider, consensus_params: ConsensusParams, max_sigops: usize) -> Self {
+	fn new(block: CanonBlock<'a>, store: &'a TransactionOutputProvider, consensus_params: &'a ConsensusParams, max_sigops: usize) -> Self {
 		BlockSigops {
 			block: block,
 			store: store,

verification/src/accept_chain.rs

@@ -1,6 +1,6 @@
 use rayon::prelude::{IntoParallelRefIterator, IndexedParallelIterator, ParallelIterator};
 use db::Store;
-use network::Magic;
+use network::ConsensusParams;
 use error::Error;
 use canon::CanonBlock;
 use accept_block::BlockAcceptor;
@@ -16,20 +16,20 @@ pub struct ChainAcceptor<'a> {
 }
 
 impl<'a> ChainAcceptor<'a> {
-	pub fn new(store: &'a Store, network: Magic, block: CanonBlock<'a>, height: u32, deployments: &'a Deployments) -> Self {
+	pub fn new(store: &'a Store, consensus: &'a ConsensusParams, block: CanonBlock<'a>, height: u32, deployments: &'a Deployments) -> Self {
 		trace!(target: "verification", "Block verification {}", block.hash().to_reversed_str());
 		let output_store = DuplexTransactionOutputProvider::new(store.as_transaction_output_provider(), block.raw());
 		let headers = store.as_block_header_provider();
 		ChainAcceptor {
-			block: BlockAcceptor::new(store.as_transaction_output_provider(), network, block, height, deployments, headers),
+			block: BlockAcceptor::new(store.as_transaction_output_provider(), consensus, block, height, deployments, headers),
-			header: HeaderAcceptor::new(headers, network, block.header(), height, deployments),
+			header: HeaderAcceptor::new(headers, consensus, block.header(), height, deployments),
 			transactions: block.transactions()
 				.into_iter()
 				.enumerate()
 				.map(|(tx_index, tx)| TransactionAcceptor::new(
 						store.as_transaction_meta_provider(),
 						output_store,
-						network,
+						consensus,
 						tx,
 						block.hash(),
 						height,

verification/src/accept_header.rs

@@ -15,16 +15,15 @@ pub struct HeaderAcceptor<'a> {
 impl<'a> HeaderAcceptor<'a> {
 	pub fn new(
 		store: &'a BlockHeaderProvider,
-		network: Magic,
+		consensus: &'a ConsensusParams,
 		header: CanonHeader<'a>,
 		height: u32,
 		deployments: &'a Deployments,
 	) -> Self {
-		let params = network.consensus_params();
 		HeaderAcceptor {
-			work: HeaderWork::new(header, store, height, network),
+			work: HeaderWork::new(header, store, height, consensus.magic),
-			median_timestamp: HeaderMedianTimestamp::new(header, store, height, deployments, &params),
+			median_timestamp: HeaderMedianTimestamp::new(header, store, height, deployments, consensus),
-			version: HeaderVersion::new(header, height, params),
+			version: HeaderVersion::new(header, height, consensus),
 		}
 	}
 
@@ -41,11 +40,11 @@ impl<'a> HeaderAcceptor<'a> {
 pub struct HeaderVersion<'a> {
 	header: CanonHeader<'a>,
 	height: u32,
-	consensus_params: ConsensusParams,
+	consensus_params: &'a ConsensusParams,
 }
 
 impl<'a> HeaderVersion<'a> {
-	fn new(header: CanonHeader<'a>, height: u32, consensus_params: ConsensusParams) -> Self {
+	fn new(header: CanonHeader<'a>, height: u32, consensus_params: &'a ConsensusParams) -> Self {
 		HeaderVersion {
 			header: header,
 			height: height,

verification/src/accept_transaction.rs

@@ -1,6 +1,6 @@
 use primitives::hash::H256;
 use db::{TransactionMetaProvider, TransactionOutputProvider, BlockHeaderProvider};
-use network::{Magic, ConsensusParams};
+use network::ConsensusParams;
 use script::{Script, verify_script, VerificationFlags, TransactionSignatureChecker, TransactionInputSigner};
 use duplex_store::DuplexTransactionOutputProvider;
 use deployments::Deployments;
@@ -25,7 +25,7 @@ impl<'a> TransactionAcceptor<'a> {
 		// previous transaction outputs
 		// in case of block validation, that's database and currently processed block
 		output_store: DuplexTransactionOutputProvider<'a>,
-		network: Magic,
+		consensus: &'a ConsensusParams,
 		transaction: CanonTransaction<'a>,
 		block_hash: &'a H256,
 		height: u32,
@@ -35,14 +35,13 @@ impl<'a> TransactionAcceptor<'a> {
 		headers: &'a BlockHeaderProvider,
 	) -> Self {
 		trace!(target: "verification", "Tx verification {}", transaction.hash.to_reversed_str());
-		let params = network.consensus_params();
 		TransactionAcceptor {
-			bip30: TransactionBip30::new_for_sync(transaction, meta_store, params.clone(), block_hash, height),
+			bip30: TransactionBip30::new_for_sync(transaction, meta_store, consensus, block_hash, height),
 			missing_inputs: TransactionMissingInputs::new(transaction, output_store, transaction_index),
 			maturity: TransactionMaturity::new(transaction, meta_store, height),
 			overspent: TransactionOverspent::new(transaction, output_store),
 			double_spent: TransactionDoubleSpend::new(transaction, output_store),
-			eval: TransactionEval::new(transaction, output_store, &params, height, time, deployments, headers),
+			eval: TransactionEval::new(transaction, output_store, consensus, height, time, deployments, headers),
 		}
 	}
 
@@ -72,7 +71,7 @@ impl<'a> MemoryPoolTransactionAcceptor<'a> {
 		meta_store: &'a TransactionMetaProvider,
 		// in case of memory pool it should be db and memory pool
 		output_store: DuplexTransactionOutputProvider<'a>,
-		network: Magic,
+		consensus: &'a ConsensusParams,
 		transaction: CanonTransaction<'a>,
 		height: u32,
 		time: u32,
@@ -80,15 +79,14 @@ impl<'a> MemoryPoolTransactionAcceptor<'a> {
 		headers: &'a BlockHeaderProvider,
 	) -> Self {
 		trace!(target: "verification", "Mempool-Tx verification {}", transaction.hash.to_reversed_str());
-		let params = network.consensus_params();
 		let transaction_index = 0;
 		MemoryPoolTransactionAcceptor {
 			missing_inputs: TransactionMissingInputs::new(transaction, output_store, transaction_index),
 			maturity: TransactionMaturity::new(transaction, meta_store, height),
 			overspent: TransactionOverspent::new(transaction, output_store),
-			sigops: TransactionSigops::new(transaction, output_store, params.clone(), MAX_BLOCK_SIGOPS, time),
+			sigops: TransactionSigops::new(transaction, output_store, consensus, MAX_BLOCK_SIGOPS, time),
 			double_spent: TransactionDoubleSpend::new(transaction, output_store),
-			eval: TransactionEval::new(transaction, output_store, &params, height, time, deployments, headers),
+			eval: TransactionEval::new(transaction, output_store, consensus, height, time, deployments, headers),
 		}
 	}
 
@@ -124,7 +122,7 @@ impl<'a> TransactionBip30<'a> {
 	fn new_for_sync(
 		transaction: CanonTransaction<'a>,
 		store: &'a TransactionMetaProvider,
-		consensus_params: ConsensusParams,
+		consensus_params: &'a ConsensusParams,
 		block_hash: &'a H256,
 		height: u32
 	) -> Self {
@@ -243,13 +241,13 @@ impl<'a> TransactionOverspent<'a> {
 pub struct TransactionSigops<'a> {
 	transaction: CanonTransaction<'a>,
 	store: DuplexTransactionOutputProvider<'a>,
-	consensus_params: ConsensusParams,
+	consensus_params: &'a ConsensusParams,
 	max_sigops: usize,
 	time: u32,
 }
 
 impl<'a> TransactionSigops<'a> {
-	fn new(transaction: CanonTransaction<'a>, store: DuplexTransactionOutputProvider<'a>, consensus_params: ConsensusParams, max_sigops: usize, time: u32) -> Self {
+	fn new(transaction: CanonTransaction<'a>, store: DuplexTransactionOutputProvider<'a>, consensus_params: &'a ConsensusParams, max_sigops: usize, time: u32) -> Self {
 		TransactionSigops {
 			transaction: transaction,
 			store: store,

verification/src/chain_verifier.rs

@@ -3,7 +3,7 @@
 use hash::H256;
 use chain::{IndexedBlock, IndexedBlockHeader, BlockHeader, Transaction};
 use db::{SharedStore, TransactionOutputProvider, BlockHeaderProvider, BlockOrigin};
-use network::Magic;
+use network::ConsensusParams;
 use error::{Error, TransactionError};
 use canon::{CanonBlock, CanonTransaction};
 use duplex_store::{DuplexTransactionOutputProvider, NoopStore};
@@ -17,15 +17,15 @@ use Verify;
 
 pub struct BackwardsCompatibleChainVerifier {
 	store: SharedStore,
-	network: Magic,
+	consensus: ConsensusParams,
 	deployments: Deployments,
 }
 
 impl BackwardsCompatibleChainVerifier {
-	pub fn new(store: SharedStore, network: Magic) -> Self {
+	pub fn new(store: SharedStore, consensus: ConsensusParams) -> Self {
 		BackwardsCompatibleChainVerifier {
 			store: store,
-			network: network,
+			consensus: consensus,
 			deployments: Deployments::new(),
 		}
 	}
@@ -33,7 +33,7 @@ impl BackwardsCompatibleChainVerifier {
 	fn verify_block(&self, block: &IndexedBlock) -> Result<(), Error> {
 		let current_time = ::time::get_time().sec as u32;
 		// first run pre-verification
-		let chain_verifier = ChainVerifier::new(block, self.network, current_time);
+		let chain_verifier = ChainVerifier::new(block, self.consensus.magic, current_time);
 		chain_verifier.check()?;
 
 		assert_eq!(Some(self.store.best_block().hash), self.store.block_hash(self.store.best_block().number));
@@ -46,21 +46,21 @@ impl BackwardsCompatibleChainVerifier {
 			},
 			BlockOrigin::CanonChain { block_number } => {
 				let canon_block = CanonBlock::new(block);
-				let chain_acceptor = ChainAcceptor::new(self.store.as_store(), self.network, canon_block, block_number, &self.deployments);
+				let chain_acceptor = ChainAcceptor::new(self.store.as_store(), &self.consensus, canon_block, block_number, &self.deployments);
 				chain_acceptor.check()?;
 			},
 			BlockOrigin::SideChain(origin) => {
 				let block_number = origin.block_number;
 				let fork = self.store.fork(origin)?;
 				let canon_block = CanonBlock::new(block);
-				let chain_acceptor = ChainAcceptor::new(fork.store(), self.network, canon_block, block_number, &self.deployments);
+				let chain_acceptor = ChainAcceptor::new(fork.store(), &self.consensus, canon_block, block_number, &self.deployments);
 				chain_acceptor.check()?;
 			},
 			BlockOrigin::SideChainBecomingCanonChain(origin) => {
 				let block_number = origin.block_number;
 				let fork = self.store.fork(origin)?;
 				let canon_block = CanonBlock::new(block);
-				let chain_acceptor = ChainAcceptor::new(fork.store(), self.network, canon_block, block_number, &self.deployments);
+				let chain_acceptor = ChainAcceptor::new(fork.store(), &self.consensus, canon_block, block_number, &self.deployments);
 				chain_acceptor.check()?;
 			},
 		}
@@ -79,7 +79,7 @@ impl BackwardsCompatibleChainVerifier {
 		// TODO: full verification
 		let current_time = ::time::get_time().sec as u32;
 		let header = IndexedBlockHeader::new(hash.clone(), header.clone());
-		let header_verifier = HeaderVerifier::new(&header, self.network, current_time);
+		let header_verifier = HeaderVerifier::new(&header, self.consensus.magic, current_time);
 		header_verifier.check()
 	}
 
@@ -102,7 +102,7 @@ impl BackwardsCompatibleChainVerifier {
 		let tx_acceptor = MemoryPoolTransactionAcceptor::new(
 			self.store.as_transaction_meta_provider(),
 			output_store,
-			self.network,
+			&self.consensus,
 			canon_tx,
 			height,
 			time,
@@ -133,7 +133,7 @@ mod tests {
 	use std::sync::Arc;
 	use chain::IndexedBlock;
 	use db::{BlockChainDatabase, Error as DBError};
-	use network::Magic;
+	use network::{Magic, ConsensusParams};
 	use script;
 	use super::BackwardsCompatibleChainVerifier as ChainVerifier;
 	use {Verify, Error, TransactionError};
@@ -142,7 +142,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, Magic::Unitest);
+		let verifier = ChainVerifier::new(storage, ConsensusParams::new(Magic::Unitest, None));
 		assert_eq!(Err(Error::Database(DBError::UnknownParent)), verifier.verify(&b2));
 	}
 
@@ -150,7 +150,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, Magic::Unitest);
+		let verifier = ChainVerifier::new(storage, ConsensusParams::new(Magic::Unitest, None));
 		assert!(verifier.verify(&b1.into()).is_ok());
 	}
 
@@ -163,7 +163,7 @@ mod tests {
 				test_data::block_h1().into(),
 			]);
 		let b1 = test_data::block_h2();
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 		assert!(verifier.verify(&b1.into()).is_ok());
 	}
 
@@ -192,7 +192,7 @@ mod tests {
 			.merkled_header().parent(genesis.hash()).build()
 			.build();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 
 		let expected = Err(Error::Transaction(
 			1,
@@ -230,7 +230,7 @@ mod tests {
 			.merkled_header().parent(genesis.hash()).build()
 			.build();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 		assert!(verifier.verify(&block.into()).is_ok());
 	}
 
@@ -266,7 +266,7 @@ mod tests {
 			.merkled_header().parent(genesis.hash()).build()
 			.build();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 		assert!(verifier.verify(&block.into()).is_ok());
 	}
 
@@ -305,7 +305,7 @@ mod tests {
 			.merkled_header().parent(genesis.hash()).build()
 			.build();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 
 		let expected = Err(Error::Transaction(2, TransactionError::Overspend));
 		assert_eq!(expected, verifier.verify(&block.into()));
@@ -347,7 +347,7 @@ mod tests {
 			.merkled_header().parent(best_hash).build()
 			.build();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 		assert!(verifier.verify(&block.into()).is_ok());
 	}
 
@@ -394,7 +394,7 @@ mod tests {
 			.build()
 			.into();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 		let expected = Err(Error::MaximumSigops);
 		assert_eq!(expected, verifier.verify(&block.into()));
 	}
@@ -416,7 +416,7 @@ mod tests {
 			.build()
 			.into();
 
-		let verifier = ChainVerifier::new(Arc::new(storage), Magic::Unitest);
+		let verifier = ChainVerifier::new(Arc::new(storage), ConsensusParams::new(Magic::Unitest, None));
 
 		let expected = Err(Error::CoinbaseOverspend {
 			expected_max: 5000000000,