Merge pull request #465 from paritytech/bitcoincash_magic
Changed magic for BCH network
This commit is contained in:
commit
48f8886894
|
@ -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();
|
||||
|
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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]
|
||||
|
|
|
@ -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};
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
|
@ -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);
|
||||
}
|
||||
}
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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(),
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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>,
|
||||
|
|
|
@ -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",
|
||||
|
|
|
@ -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,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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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()));
|
||||
|
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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(()));
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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),
|
||||
|
|
|
@ -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(),
|
||||
|
|
|
@ -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,
|
||||
|
|
Loading…
Reference in New Issue