From 8a7eb947599e0dc3349ab1c823bbe31ad5b4bb9d Mon Sep 17 00:00:00 2001 From: Quentin Le Sceller Date: Mon, 5 Feb 2018 14:43:54 -0500 Subject: [PATCH] Update bitflags to ^0.1 (#682) * Removed unused crates * Add listconnectedpeers in grin client * Update bitflags to ^0.1 globally --- api/src/handlers.rs | 6 ++-- api/src/types.rs | 2 +- chain/Cargo.toml | 2 +- chain/src/chain.rs | 4 +-- chain/src/lib.rs | 2 +- chain/src/pipe.rs | 6 ++-- chain/src/sumtree.rs | 10 +++--- chain/src/types.rs | 10 +++--- chain/tests/mine_simple_chain.rs | 38 ++++++++++----------- chain/tests/test_coinbase_maturity.rs | 8 ++--- core/Cargo.toml | 2 +- core/src/core/block.rs | 48 +++++++++++++-------------- core/src/core/build.rs | 8 ++--- core/src/core/mod.rs | 2 +- core/src/core/transaction.rs | 36 ++++++++++---------- grin/src/adapters.rs | 8 ++--- grin/src/miner.rs | 2 +- keychain/src/keychain.rs | 2 +- pool/src/blockchain.rs | 4 +-- pool/src/graph.rs | 8 ++--- pool/src/pool.rs | 4 +-- wallet/src/restore.rs | 6 ++-- 22 files changed, 109 insertions(+), 109 deletions(-) diff --git a/api/src/handlers.rs b/api/src/handlers.rs index 584d415b7..afac136ba 100644 --- a/api/src/handlers.rs +++ b/api/src/handlers.rs @@ -24,7 +24,7 @@ use serde::Serialize; use serde_json; use chain; -use core::core::{OutputIdentifier, Transaction, DEFAULT_OUTPUT, COINBASE_OUTPUT}; +use core::core::{OutputIdentifier, Transaction, OutputFeatures}; use core::core::hash::{Hash, Hashed}; use core::ser; use pool; @@ -68,8 +68,8 @@ impl UtxoHandler { // to compare against the hash in the output MMR. // For now we can just try both (but this probably needs to be part of the api params) let outputs = [ - OutputIdentifier::new(DEFAULT_OUTPUT, &commit), - OutputIdentifier::new(COINBASE_OUTPUT, &commit) + OutputIdentifier::new(OutputFeatures::DEFAULT_OUTPUT, &commit), + OutputIdentifier::new(OutputFeatures::COINBASE_OUTPUT, &commit) ]; for x in outputs.iter() { diff --git a/api/src/types.rs b/api/src/types.rs index 52fa3f630..26ee06f3c 100644 --- a/api/src/types.rs +++ b/api/src/types.rs @@ -244,7 +244,7 @@ impl OutputPrintable { include_proof: bool, ) -> OutputPrintable { let output_type = - if output.features.contains(core::transaction::COINBASE_OUTPUT) { + if output.features.contains(core::transaction::OutputFeatures::COINBASE_OUTPUT) { OutputType::Coinbase } else { OutputType::Transaction diff --git a/chain/Cargo.toml b/chain/Cargo.toml index 285fa6106..95858f826 100644 --- a/chain/Cargo.toml +++ b/chain/Cargo.toml @@ -5,7 +5,7 @@ authors = ["Ignotus Peverell "] workspace = ".." [dependencies] -bitflags = "^0.7.0" +bitflags = "^1.0" byteorder = "^0.5" slog = { version = "^2.0.12", features = ["max_level_trace", "release_max_level_trace"] } serde = "~1.0.8" diff --git a/chain/src/chain.rs b/chain/src/chain.rs index 3636694dd..a66f8aa42 100644 --- a/chain/src/chain.rs +++ b/chain/src/chain.rs @@ -237,7 +237,7 @@ pub fn process_block(&self, b: Block, opts: Options) } // notifying other parts of the system of the update - if !opts.contains(SYNC) { + if !opts.contains(Options::SYNC) { // broadcast the block let adapter = self.adapter.clone(); adapter.block_accepted(&b, opts); @@ -254,7 +254,7 @@ pub fn process_block(&self, b: Block, opts: Options) // or less relevant blocks somehow. // We should also probably consider banning nodes that send us really old blocks. // - if !opts.contains(SYNC) { + if !opts.contains(Options::SYNC) { // broadcast the block let adapter = self.adapter.clone(); adapter.block_accepted(&b, opts); diff --git a/chain/src/lib.rs b/chain/src/lib.rs index 557e55c98..72b6645d6 100644 --- a/chain/src/lib.rs +++ b/chain/src/lib.rs @@ -43,4 +43,4 @@ pub mod types; // Re-export the base interface pub use chain::Chain; -pub use types::{ChainAdapter, ChainStore, Error, Options, Tip, NONE, SKIP_POW, SYNC, MINE}; +pub use types::{ChainAdapter, ChainStore, Error, Options, Tip}; diff --git a/chain/src/pipe.rs b/chain/src/pipe.rs index f29dd6d7c..caee993ea 100644 --- a/chain/src/pipe.rs +++ b/chain/src/pipe.rs @@ -211,7 +211,7 @@ fn validate_header(header: &BlockHeader, ctx: &mut BlockContext) -> Result<(), E return Err(Error::InvalidBlockTime); } - if !ctx.opts.contains(SKIP_POW) { + if !ctx.opts.contains(Options::SKIP_POW) { let n = global::sizeshift() as u32; if !(ctx.pow_verifier)(header, n) { error!(LOGGER, "pipe: validate_header failed for cuckoo shift size {}", n); @@ -242,7 +242,7 @@ fn validate_header(header: &BlockHeader, ctx: &mut BlockContext) -> Result<(), E return Err(Error::InvalidBlockTime); } - if !ctx.opts.contains(SKIP_POW) { + if !ctx.opts.contains(Options::SKIP_POW) { // verify the proof of work and related parameters // explicit check to ensure we are not below the minimum difficulty @@ -362,7 +362,7 @@ fn update_head(b: &Block, ctx: &mut BlockContext) -> Result, Error> // in sync mode, only update the "body chain", otherwise update both the // "header chain" and "body chain", updating the header chain in sync resets // all additional "future" headers we've received - if ctx.opts.contains(SYNC) { + if ctx.opts.contains(Options::SYNC) { ctx.store .save_body_head(&tip) .map_err(|e| Error::StoreErr(e, "pipe save body".to_owned()))?; diff --git a/chain/src/sumtree.rs b/chain/src/sumtree.rs index ba7b39b8b..0a47a4a2c 100644 --- a/chain/src/sumtree.rs +++ b/chain/src/sumtree.rs @@ -20,7 +20,7 @@ use std::collections::HashMap; use std::path::Path; use std::sync::Arc; -use core::core::{Block, SumCommit, Input, Output, OutputIdentifier, TxKernel, COINBASE_OUTPUT}; +use core::core::{Block, SumCommit, Input, Output, OutputIdentifier, TxKernel, OutputFeatures}; use core::core::pmmr::{HashSum, NoSum, Summable, PMMR}; use core::core::hash::Hashed; use grin_store; @@ -134,7 +134,7 @@ impl SumTrees { // it claims to be spending, and that it is coinbase or non-coinbase. // If we are spending a coinbase output then go find the block // and check the coinbase maturity rule is being met. - if input.features.contains(COINBASE_OUTPUT) { + if input.features.contains(OutputFeatures::COINBASE_OUTPUT) { let block_hash = &input.out_block .expect("input spending coinbase output must have a block hash"); let block = self.commit_index.get_block(&block_hash)?; @@ -280,7 +280,7 @@ impl<'a> Extension<'a> { // yet and it will be needed to calculate that hash. to work around this, // we insert coinbase outputs first to add at least one output of padding for out in &b.outputs { - if out.features.contains(COINBASE_OUTPUT) { + if out.features.contains(OutputFeatures::COINBASE_OUTPUT) { self.apply_output(out)?; } } @@ -293,7 +293,7 @@ impl<'a> Extension<'a> { // now all regular, non coinbase outputs for out in &b.outputs { - if !out.features.contains(COINBASE_OUTPUT) { + if !out.features.contains(OutputFeatures::COINBASE_OUTPUT) { self.apply_output(out)?; } } @@ -336,7 +336,7 @@ impl<'a> Extension<'a> { // it claims to be spending, and it is coinbase or non-coinbase. // If we are spending a coinbase output then go find the block // and check the coinbase maturity rule is being met. - if input.features.contains(COINBASE_OUTPUT) { + if input.features.contains(OutputFeatures::COINBASE_OUTPUT) { let block_hash = &input.out_block .expect("input spending coinbase output must have a block hash"); let block = self.commit_index.get_block(&block_hash)?; diff --git a/chain/src/types.rs b/chain/src/types.rs index 6bf27ff4a..c02686031 100644 --- a/chain/src/types.rs +++ b/chain/src/types.rs @@ -27,15 +27,15 @@ use grin_store; bitflags! { /// Options for block validation - pub flags Options: u32 { + pub struct Options: u32 { /// No flags - const NONE = 0b00000000, + const NONE = 0b00000000; /// Runs without checking the Proof of Work, mostly to make testing easier. - const SKIP_POW = 0b00000001, + const SKIP_POW = 0b00000001; /// Adds block while in syncing mode. - const SYNC = 0b00000010, + const SYNC = 0b00000010; /// Block validation on a block we mined ourselves - const MINE = 0b00000100, + const MINE = 0b00000100; } } diff --git a/chain/tests/mine_simple_chain.rs b/chain/tests/mine_simple_chain.rs index 771072c8d..cfc15749a 100644 --- a/chain/tests/mine_simple_chain.rs +++ b/chain/tests/mine_simple_chain.rs @@ -96,7 +96,7 @@ fn mine_empty_chain() { ).unwrap(); let bhash = b.hash(); - chain.process_block(b, chain::MINE).unwrap(); + chain.process_block(b, chain::Options::MINE).unwrap(); // checking our new head let head = chain.head().unwrap(); @@ -128,7 +128,7 @@ fn mine_forks() { // add a first block to not fork genesis let prev = chain.head_header().unwrap(); let b = prepare_block(&kc, &prev, &chain, 2); - chain.process_block(b, chain::SKIP_POW).unwrap(); + chain.process_block(b, chain::Options::SKIP_POW).unwrap(); // mine and add a few blocks @@ -142,7 +142,7 @@ fn mine_forks() { // process the first block to extend the chain let bhash = b1.hash(); - chain.process_block(b1, chain::SKIP_POW).unwrap(); + chain.process_block(b1, chain::Options::SKIP_POW).unwrap(); // checking our new head let head = chain.head().unwrap(); @@ -152,7 +152,7 @@ fn mine_forks() { // process the 2nd block to build a fork with more work let bhash = b2.hash(); - chain.process_block(b2, chain::SKIP_POW).unwrap(); + chain.process_block(b2, chain::Options::SKIP_POW).unwrap(); // checking head switch let head = chain.head().unwrap(); @@ -171,7 +171,7 @@ fn mine_losing_fork() { let prev = chain.head_header().unwrap(); let b1 = prepare_block(&kc, &prev, &chain, 2); let b1head = b1.header.clone(); - chain.process_block(b1, chain::SKIP_POW).unwrap(); + chain.process_block(b1, chain::Options::SKIP_POW).unwrap(); // prepare the 2 successor, sibling blocks, one with lower diff let b2 = prepare_block(&kc, &b1head, &chain, 4); @@ -180,14 +180,14 @@ fn mine_losing_fork() { // add higher difficulty first, prepare its successor, then fork // with lower diff - chain.process_block(b2, chain::SKIP_POW).unwrap(); + chain.process_block(b2, chain::Options::SKIP_POW).unwrap(); assert_eq!(chain.head_header().unwrap().hash(), b2head.hash()); let b3 = prepare_block(&kc, &b2head, &chain, 5); - chain.process_block(bfork, chain::SKIP_POW).unwrap(); + chain.process_block(bfork, chain::Options::SKIP_POW).unwrap(); // adding the successor let b3head = b3.header.clone(); - chain.process_block(b3, chain::SKIP_POW).unwrap(); + chain.process_block(b3, chain::Options::SKIP_POW).unwrap(); assert_eq!(chain.head_header().unwrap().hash(), b3head.hash()); } @@ -209,10 +209,10 @@ fn longer_fork() { if n < 5 { let b_fork = b.clone(); - chain_fork.process_block(b_fork, chain::SKIP_POW).unwrap(); + chain_fork.process_block(b_fork, chain::Options::SKIP_POW).unwrap(); } - chain.process_block(b, chain::SKIP_POW).unwrap(); + chain.process_block(b, chain::Options::SKIP_POW).unwrap(); prev = bh; } @@ -229,9 +229,9 @@ fn longer_fork() { let bh_fork = b_fork.header.clone(); let b = b_fork.clone(); - chain.process_block(b, chain::SKIP_POW).unwrap(); + chain.process_block(b, chain::Options::SKIP_POW).unwrap(); - chain_fork.process_block(b_fork, chain::SKIP_POW).unwrap(); + chain_fork.process_block(b_fork, chain::Options::SKIP_POW).unwrap(); prev_fork = bh_fork; } } @@ -250,13 +250,13 @@ fn spend_in_fork() { let b = prepare_block(&kc, &fork_head, &chain, 2); let block_hash = b.hash(); fork_head = b.header.clone(); - chain.process_block(b, chain::SKIP_POW).unwrap(); + chain.process_block(b, chain::Options::SKIP_POW).unwrap(); // now mine three further blocks for n in 3..6 { let b = prepare_block(&kc, &fork_head, &chain, n); fork_head = b.header.clone(); - chain.process_block(b, chain::SKIP_POW).unwrap(); + chain.process_block(b, chain::Options::SKIP_POW).unwrap(); } let lock_height = 1 + global::coinbase_maturity(); @@ -273,7 +273,7 @@ fn spend_in_fork() { let next = prepare_block_tx(&kc, &fork_head, &chain, 7, vec![&tx1]); let prev_main = next.header.clone(); - chain.process_block(next.clone(), chain::SKIP_POW).unwrap(); + chain.process_block(next.clone(), chain::Options::SKIP_POW).unwrap(); let (tx2, _) = build::transaction( vec![ @@ -286,16 +286,16 @@ fn spend_in_fork() { let next = prepare_block_tx(&kc, &prev_main, &chain, 9, vec![&tx2]); let prev_main = next.header.clone(); - chain.process_block(next, chain::SKIP_POW).unwrap(); + chain.process_block(next, chain::Options::SKIP_POW).unwrap(); // mine 2 forked blocks from the first let fork = prepare_fork_block_tx(&kc, &fork_head, &chain, 6, vec![&tx1]); let prev_fork = fork.header.clone(); - chain.process_block(fork, chain::SKIP_POW).unwrap(); + chain.process_block(fork, chain::Options::SKIP_POW).unwrap(); let fork_next = prepare_fork_block_tx(&kc, &prev_fork, &chain, 8, vec![&tx2]); let prev_fork = fork_next.header.clone(); - chain.process_block(fork_next, chain::SKIP_POW).unwrap(); + chain.process_block(fork_next, chain::Options::SKIP_POW).unwrap(); // check state let head = chain.head_header().unwrap(); @@ -307,7 +307,7 @@ fn spend_in_fork() { // make the fork win let fork_next = prepare_fork_block(&kc, &prev_fork, &chain, 10); let prev_fork = fork_next.header.clone(); - chain.process_block(fork_next, chain::SKIP_POW).unwrap(); + chain.process_block(fork_next, chain::Options::SKIP_POW).unwrap(); // check state let head = chain.head_header().unwrap(); diff --git a/chain/tests/test_coinbase_maturity.rs b/chain/tests/test_coinbase_maturity.rs index 51e0565dd..99c0c6401 100644 --- a/chain/tests/test_coinbase_maturity.rs +++ b/chain/tests/test_coinbase_maturity.rs @@ -99,13 +99,13 @@ fn test_coinbase_maturity() { assert!( block.outputs[0] .features - .contains(transaction::COINBASE_OUTPUT) + .contains(transaction::OutputFeatures::COINBASE_OUTPUT) ); // we will need this later when we want to spend the coinbase output let block_hash = block.hash(); - chain.process_block(block, chain::MINE).unwrap(); + chain.process_block(block, chain::Options::MINE).unwrap(); let prev = chain.head_header().unwrap(); @@ -178,7 +178,7 @@ fn test_coinbase_maturity() { global::sizeshift() as u32, ).unwrap(); - chain.process_block(block, chain::MINE).unwrap(); + chain.process_block(block, chain::Options::MINE).unwrap(); } let prev = chain.head_header().unwrap(); @@ -213,7 +213,7 @@ fn test_coinbase_maturity() { global::sizeshift() as u32, ).unwrap(); - let result = chain.process_block(block, chain::MINE); + let result = chain.process_block(block, chain::Options::MINE); match result { Ok(_) => (), Err(Error::ImmatureCoinbase) => panic!("we should not get an ImmatureCoinbase here"), diff --git a/core/Cargo.toml b/core/Cargo.toml index 31ac8a7d9..1f20e18fe 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -5,7 +5,7 @@ authors = ["Ignotus Peverell "] workspace = ".." [dependencies] -bitflags = "~0.7.0" +bitflags = "^1.0" blake2-rfc = "~0.2.17" byteorder = "^0.5" slog = { version = "^2.0.12", features = ["max_level_trace", "release_max_level_trace"] } diff --git a/core/src/core/block.rs b/core/src/core/block.rs index 3b3b1b139..18c2d6059 100644 --- a/core/src/core/block.rs +++ b/core/src/core/block.rs @@ -29,8 +29,8 @@ use core::{ Proof, TxKernel, Transaction, - COINBASE_KERNEL, - COINBASE_OUTPUT + OutputFeatures, + KernelFeatures }; use consensus; use consensus::{exceeds_weight, reward, REWARD, VerifySortOrder}; @@ -452,18 +452,18 @@ impl Block { let mut out_full = self.outputs .iter() - .filter(|x| x.features.contains(COINBASE_OUTPUT)) + .filter(|x| x.features.contains(OutputFeatures::COINBASE_OUTPUT)) .cloned() .collect::>(); let mut kern_full = self.kernels .iter() - .filter(|x| x.features.contains(COINBASE_KERNEL)) + .filter(|x| x.features.contains(KernelFeatures::COINBASE_KERNEL)) .cloned() .collect::>(); let mut kern_ids = self.kernels .iter() - .filter(|x| !x.features.contains(COINBASE_KERNEL)) + .filter(|x| !x.features.contains(KernelFeatures::COINBASE_KERNEL)) .map(|x| x.short_id(&block_hash)) .collect::>(); @@ -570,7 +570,7 @@ impl Block { let out_set = self.outputs .iter() - .filter(|out| !out.features.contains(COINBASE_OUTPUT)) + .filter(|out| !out.features.contains(OutputFeatures::COINBASE_OUTPUT)) .map(|out| out.commitment()) .collect::>(); @@ -679,13 +679,13 @@ impl Block { fn verify_coinbase(&self) -> Result<(), Error> { let cb_outs = self.outputs .iter() - .filter(|out| out.features.contains(COINBASE_OUTPUT)) + .filter(|out| out.features.contains(OutputFeatures::COINBASE_OUTPUT)) .cloned() .collect::>(); let cb_kerns = self.kernels .iter() - .filter(|kernel| kernel.features.contains(COINBASE_KERNEL)) + .filter(|kernel| kernel.features.contains(KernelFeatures::COINBASE_KERNEL)) .cloned() .collect::>(); @@ -738,7 +738,7 @@ impl Block { // _and_ that we trust this claim. // We should have already confirmed the entry from the MMR exists // and has the expected hash. - assert!(output.features.contains(COINBASE_OUTPUT)); + assert!(output.features.contains(OutputFeatures::COINBASE_OUTPUT)); if let Some(_) = self.outputs .iter() @@ -788,7 +788,7 @@ impl Block { let rproof = keychain.range_proof(reward(fees), key_id, commit, msg)?; let output = Output { - features: COINBASE_OUTPUT, + features: OutputFeatures::COINBASE_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: rproof, @@ -809,7 +809,7 @@ impl Block { let sig = keychain.aggsig_sign_from_key_id(&msg, &key_id)?; let proof = TxKernel { - features: COINBASE_KERNEL, + features: KernelFeatures::COINBASE_KERNEL, excess: excess, excess_sig: sig, fee: 0, @@ -945,14 +945,14 @@ mod test { let coinbase_outputs = b.outputs .iter() - .filter(|out| out.features.contains(COINBASE_OUTPUT)) + .filter(|out| out.features.contains(OutputFeatures::COINBASE_OUTPUT)) .map(|o| o.clone()) .collect::>(); assert_eq!(coinbase_outputs.len(), 1); let coinbase_kernels = b.kernels .iter() - .filter(|out| out.features.contains(COINBASE_KERNEL)) + .filter(|out| out.features.contains(KernelFeatures::COINBASE_KERNEL)) .map(|o| o.clone()) .collect::>(); assert_eq!(coinbase_kernels.len(), 1); @@ -970,8 +970,8 @@ mod test { let keychain = Keychain::from_random_seed().unwrap(); let mut b = new_block(vec![], &keychain); - assert!(b.outputs[0].features.contains(COINBASE_OUTPUT)); - b.outputs[0].features.remove(COINBASE_OUTPUT); + assert!(b.outputs[0].features.contains(OutputFeatures::COINBASE_OUTPUT)); + b.outputs[0].features.remove(OutputFeatures::COINBASE_OUTPUT); assert_eq!( b.verify_coinbase(), @@ -992,8 +992,8 @@ mod test { let keychain = Keychain::from_random_seed().unwrap(); let mut b = new_block(vec![], &keychain); - assert!(b.kernels[0].features.contains(COINBASE_KERNEL)); - b.kernels[0].features.remove(COINBASE_KERNEL); + assert!(b.kernels[0].features.contains(KernelFeatures::COINBASE_KERNEL)); + b.kernels[0].features.remove(KernelFeatures::COINBASE_KERNEL); assert_eq!( b.verify_coinbase(), @@ -1029,7 +1029,7 @@ mod test { ser::serialize(&mut vec, &b).expect("serialization failed"); assert_eq!( vec.len(), - 5_676, + 5_676 ); } @@ -1042,7 +1042,7 @@ mod test { ser::serialize(&mut vec, &b).expect("serialization failed"); assert_eq!( vec.len(), - 16_224, + 16_224 ); } @@ -1054,7 +1054,7 @@ mod test { ser::serialize(&mut vec, &b.as_compact_block()).expect("serialization failed"); assert_eq!( vec.len(), - 5_662, + 5_662 ); } @@ -1067,7 +1067,7 @@ mod test { ser::serialize(&mut vec, &b.as_compact_block()).expect("serialization failed"); assert_eq!( vec.len(), - 5_668, + 5_668 ); } @@ -1089,7 +1089,7 @@ mod test { ser::serialize(&mut vec, &b).expect("serialization failed"); assert_eq!( vec.len(), - 111_156, + 111_156 ); } @@ -1111,7 +1111,7 @@ mod test { ser::serialize(&mut vec, &b.as_compact_block()).expect("serialization failed"); assert_eq!( vec.len(), - 5_722, + 5_722 ); } @@ -1131,7 +1131,7 @@ mod test { cb.kern_ids[0], b.kernels .iter() - .find(|x| !x.features.contains(COINBASE_KERNEL)) + .find(|x| !x.features.contains(KernelFeatures::COINBASE_KERNEL)) .unwrap() .short_id(&b.hash()) ); diff --git a/core/src/core/build.rs b/core/src/core/build.rs index 6be45245f..f833ae66f 100644 --- a/core/src/core/build.rs +++ b/core/src/core/build.rs @@ -27,7 +27,7 @@ use util::{secp, kernel_sig_msg}; -use core::{Transaction, Input, Output, OutputFeatures, SwitchCommitHash, COINBASE_OUTPUT, DEFAULT_OUTPUT}; +use core::{Transaction, Input, Output, OutputFeatures, SwitchCommitHash}; use core::hash::Hash; use keychain; use keychain::{Keychain, BlindSum, BlindingFactor, Identifier}; @@ -69,7 +69,7 @@ pub fn input( key_id: Identifier, ) -> Box { debug!(LOGGER, "Building input (spending regular output): {}, {}", value, key_id); - build_input(value, DEFAULT_OUTPUT, Some(out_block), key_id) + build_input(value, OutputFeatures::DEFAULT_OUTPUT, Some(out_block), key_id) } /// Adds a coinbase input spending a coinbase output. @@ -80,7 +80,7 @@ pub fn coinbase_input( key_id: Identifier, ) -> Box { debug!(LOGGER, "Building input (spending coinbase): {}, {}", value, key_id); - build_input(value, COINBASE_OUTPUT, Some(out_block), key_id) + build_input(value, OutputFeatures::COINBASE_OUTPUT, Some(out_block), key_id) } /// Adds an output with the provided value and key identifier from the @@ -120,7 +120,7 @@ pub fn output(value: u64, key_id: Identifier) -> Box { ( tx.with_output(Output { - features: DEFAULT_OUTPUT, + features: OutputFeatures::DEFAULT_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: rproof, diff --git a/core/src/core/mod.rs b/core/src/core/mod.rs index 27bb827c8..18082fdac 100644 --- a/core/src/core/mod.rs +++ b/core/src/core/mod.rs @@ -319,7 +319,7 @@ mod test { let tx_kernel = tx.build_kernel(excess); let _ = tx_kernel.verify().unwrap(); - assert_eq!(tx_kernel.features, DEFAULT_KERNEL); + assert_eq!(tx_kernel.features, KernelFeatures::DEFAULT_KERNEL); assert_eq!(tx_kernel.fee, tx.fee); assert_eq!(tx_kernel.excess, excess); } diff --git a/core/src/core/transaction.rs b/core/src/core/transaction.rs index d17bc3d4a..f1b4c4ec5 100644 --- a/core/src/core/transaction.rs +++ b/core/src/core/transaction.rs @@ -38,11 +38,11 @@ pub const SWITCH_COMMIT_KEY_SIZE: usize = 32; bitflags! { /// Options for a kernel's structure or use - pub flags KernelFeatures: u8 { + pub struct KernelFeatures: u8 { /// No flags - const DEFAULT_KERNEL = 0b00000000, + const DEFAULT_KERNEL = 0b00000000; /// Kernel matching a coinbase output - const COINBASE_KERNEL = 0b00000001, + const COINBASE_KERNEL = 0b00000001; } } @@ -348,7 +348,7 @@ impl Transaction { /// Builds a transaction kernel pub fn build_kernel(&self, excess: Commitment) -> TxKernel { TxKernel { - features: DEFAULT_KERNEL, + features: KernelFeatures::DEFAULT_KERNEL, excess: excess, excess_sig: self.excess_sig.clone(), fee: self.fee, @@ -408,7 +408,7 @@ impl Writeable for Input { writer.write_u8(self.features.bits())?; writer.write_fixed_bytes(&self.commit)?; - if self.features.contains(COINBASE_OUTPUT) { + if self.features.contains(OutputFeatures::COINBASE_OUTPUT) { writer.write_fixed_bytes(&self.out_block.unwrap_or(ZERO_HASH))?; } @@ -426,7 +426,7 @@ impl Readable for Input { let commit = Commitment::read(reader)?; - let out_block = if features.contains(COINBASE_OUTPUT) { + let out_block = if features.contains(OutputFeatures::COINBASE_OUTPUT) { Some(Hash::read(reader)?) } else { None @@ -469,11 +469,11 @@ impl Input { bitflags! { /// Options for block validation #[derive(Serialize, Deserialize)] - pub flags OutputFeatures: u8 { + pub struct OutputFeatures: u8 { /// No flags - const DEFAULT_OUTPUT = 0b00000000, + const DEFAULT_OUTPUT = 0b00000000; /// Output is a coinbase output, must not be spent until maturity - const COINBASE_OUTPUT = 0b00000001, + const COINBASE_OUTPUT = 0b00000001; } } @@ -920,7 +920,7 @@ mod test { let sig = secp::Signature::from_raw_data(&[0;64]).unwrap(); let kernel = TxKernel { - features: DEFAULT_KERNEL, + features: KernelFeatures::DEFAULT_KERNEL, lock_height: 0, excess: commit, excess_sig: sig.clone(), @@ -930,7 +930,7 @@ mod test { let mut vec = vec![]; ser::serialize(&mut vec, &kernel).expect("serialized failed"); let kernel2: TxKernel = ser::deserialize(&mut &vec[..]).unwrap(); - assert_eq!(kernel2.features, DEFAULT_KERNEL); + assert_eq!(kernel2.features, KernelFeatures::DEFAULT_KERNEL); assert_eq!(kernel2.lock_height, 0); assert_eq!(kernel2.excess, commit); assert_eq!(kernel2.excess_sig, sig.clone()); @@ -938,7 +938,7 @@ mod test { // now check a kernel with lock_height serializes/deserializes correctly let kernel = TxKernel { - features: DEFAULT_KERNEL, + features: KernelFeatures::DEFAULT_KERNEL, lock_height: 100, excess: commit, excess_sig: sig.clone(), @@ -948,7 +948,7 @@ mod test { let mut vec = vec![]; ser::serialize(&mut vec, &kernel).expect("serialized failed"); let kernel2: TxKernel = ser::deserialize(&mut &vec[..]).unwrap(); - assert_eq!(kernel2.features, DEFAULT_KERNEL); + assert_eq!(kernel2.features, KernelFeatures::DEFAULT_KERNEL); assert_eq!(kernel2.lock_height, 100); assert_eq!(kernel2.excess, commit); assert_eq!(kernel2.excess_sig, sig.clone()); @@ -970,7 +970,7 @@ mod test { let proof = keychain.range_proof(5, &key_id, commit, msg).unwrap(); let out = Output { - features: DEFAULT_OUTPUT, + features: OutputFeatures::DEFAULT_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: proof, @@ -980,7 +980,7 @@ mod test { ser::serialize(&mut vec, &out).expect("serialized failed"); let dout: Output = ser::deserialize(&mut &vec[..]).unwrap(); - assert_eq!(dout.features, DEFAULT_OUTPUT); + assert_eq!(dout.features, OutputFeatures::DEFAULT_OUTPUT); assert_eq!(dout.commit, out.commit); assert_eq!(dout.proof, out.proof); } @@ -1001,7 +1001,7 @@ mod test { let proof = keychain.range_proof(1003, &key_id, commit, msg).unwrap(); let output = Output { - features: DEFAULT_OUTPUT, + features: OutputFeatures::DEFAULT_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: proof, @@ -1047,7 +1047,7 @@ mod test { let commit = keychain.commit(5, &key_id).unwrap(); let input = Input { - features: DEFAULT_OUTPUT, + features: OutputFeatures::DEFAULT_OUTPUT, commit: commit, out_block: None, }; @@ -1062,7 +1062,7 @@ mod test { // now generate the short_id for a *very* similar output (single feature flag different) // and check it generates a different short_id let input = Input { - features: COINBASE_OUTPUT, + features: OutputFeatures::COINBASE_OUTPUT, commit: commit, out_block: None, }; diff --git a/grin/src/adapters.rs b/grin/src/adapters.rs index f3cf0d6ff..3c5dfbf3b 100644 --- a/grin/src/adapters.rs +++ b/grin/src/adapters.rs @@ -18,7 +18,7 @@ use std::sync::atomic::{AtomicBool, Ordering}; use rand; use rand::Rng; -use chain::{self, ChainAdapter, Options, MINE}; +use chain::{self, ChainAdapter, Options}; use core::core; use core::core::block::BlockHeader; use core::core::hash::{Hash, Hashed}; @@ -350,9 +350,9 @@ impl NetToChainAdapter { /// Prepare options for the chain pipeline fn chain_opts(&self) -> chain::Options { let opts = if self.currently_syncing.load(Ordering::Relaxed) { - chain::SYNC + chain::Options::SYNC } else { - chain::NONE + chain::Options::NONE }; opts } @@ -384,7 +384,7 @@ impl ChainAdapter for ChainToPoolAndNetAdapter { // If block contains txs then broadcast the compact block. // If we received the block from another node then broadcast "header first" // to minimize network traffic. - if opts.contains(MINE) { + if opts.contains(Options::MINE) { // propagate compact block out if we mined the block // but broadcast full block if we have no txs let cb = b.as_compact_block(); diff --git a/grin/src/miner.rs b/grin/src/miner.rs index e746f74a9..d48634ff5 100644 --- a/grin/src/miner.rs +++ b/grin/src/miner.rs @@ -537,7 +537,7 @@ impl Miner { b.hash() ); b.header.pow = proof; - let res = self.chain.process_block(b, chain::MINE); + let res = self.chain.process_block(b, chain::Options::MINE); if let Err(e) = res { error!( LOGGER, diff --git a/keychain/src/keychain.rs b/keychain/src/keychain.rs index af5a42e86..d3d4123c1 100644 --- a/keychain/src/keychain.rs +++ b/keychain/src/keychain.rs @@ -565,7 +565,7 @@ mod test { .add_blinding_factor(BlindingFactor::new(skey1)) .add_blinding_factor(BlindingFactor::new(skey2)) ).unwrap(), - BlindingFactor::new(skey3), + BlindingFactor::new(skey3) ); } } diff --git a/pool/src/blockchain.rs b/pool/src/blockchain.rs index f27100f79..76c93153a 100644 --- a/pool/src/blockchain.rs +++ b/pool/src/blockchain.rs @@ -12,7 +12,7 @@ use std::clone::Clone; use std::sync::RwLock; use core::core::{block, hash, transaction}; -use core::core::{COINBASE_OUTPUT, Input, OutputIdentifier}; +use core::core::{OutputFeatures, Input, OutputIdentifier}; use core::global; use core::core::hash::Hashed; use types::{BlockChain, PoolError}; @@ -114,7 +114,7 @@ impl BlockChain for DummyChainImpl { } fn is_matured(&self, input: &Input, height: u64) -> Result<(), PoolError> { - if !input.features.contains(COINBASE_OUTPUT) { + if !input.features.contains(OutputFeatures::COINBASE_OUTPUT) { return Ok(()); } let block_hash = input.out_block.expect("requires a block hash"); diff --git a/pool/src/graph.rs b/pool/src/graph.rs index ecb3bc902..c216a6d9e 100644 --- a/pool/src/graph.rs +++ b/pool/src/graph.rs @@ -298,7 +298,7 @@ mod tests { use util::secp; use keychain::Keychain; use rand; - use core::core::{DEFAULT_OUTPUT, SwitchCommitHash}; + use core::core::{OutputFeatures, SwitchCommitHash}; #[test] fn test_add_entry() { @@ -317,12 +317,12 @@ mod tests { let inputs = vec![ core::transaction::Input::new( - DEFAULT_OUTPUT, + OutputFeatures::DEFAULT_OUTPUT, keychain.commit(50, &key_id2).unwrap(), None, ), core::transaction::Input::new( - DEFAULT_OUTPUT, + OutputFeatures::DEFAULT_OUTPUT, keychain.commit(25, &key_id3).unwrap(), None, ), @@ -330,7 +330,7 @@ mod tests { let msg = secp::pedersen::ProofMessage::empty(); let output = core::transaction::Output { - features: DEFAULT_OUTPUT, + features: OutputFeatures::DEFAULT_OUTPUT, commit: output_commit, switch_commit_hash: switch_commit_hash, proof: keychain diff --git a/pool/src/pool.rs b/pool/src/pool.rs index 4f08accbc..7d3d8cffa 100644 --- a/pool/src/pool.rs +++ b/pool/src/pool.rs @@ -1321,7 +1321,7 @@ mod tests { let proof = keychain.range_proof(value, &key_id, commit, msg).unwrap(); transaction::Output { - features: transaction::DEFAULT_OUTPUT, + features: transaction::OutputFeatures::DEFAULT_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: proof, @@ -1343,7 +1343,7 @@ mod tests { let proof = keychain.range_proof(value, &key_id, commit, msg).unwrap(); transaction::Output { - features: transaction::COINBASE_OUTPUT, + features: transaction::OutputFeatures::COINBASE_OUTPUT, commit: commit, switch_commit_hash: switch_commit_hash, proof: proof, diff --git a/wallet/src/restore.rs b/wallet/src/restore.rs index 61810533b..c4b721fba 100644 --- a/wallet/src/restore.rs +++ b/wallet/src/restore.rs @@ -18,7 +18,7 @@ use util::secp::pedersen; use api; use core::global; use core::core::{Output, SwitchCommitHash}; -use core::core::transaction::{COINBASE_OUTPUT, DEFAULT_OUTPUT}; +use core::core::transaction::OutputFeatures; use types::{BlockIdentifier, WalletConfig, WalletData, OutputData, OutputStatus, Error}; use byteorder::{BigEndian, ByteOrder}; @@ -87,8 +87,8 @@ fn retrieve_amount_and_coinbase_status( let core_output = Output { features: match output.output_type { - api::OutputType::Coinbase => COINBASE_OUTPUT, - api::OutputType::Transaction => DEFAULT_OUTPUT, + api::OutputType::Coinbase => OutputFeatures::COINBASE_OUTPUT, + api::OutputType::Transaction => OutputFeatures::DEFAULT_OUTPUT, }, proof: output.range_proof()?, switch_commit_hash: output.switch_commit_hash()?,