From 996eab72ae71652ef66a5f32d30796827acdfe10 Mon Sep 17 00:00:00 2001 From: Ignotus Peverell Date: Wed, 31 May 2017 14:44:44 -0700 Subject: [PATCH] Formatting. --- api/src/client.rs | 2 +- api/src/endpoints.rs | 14 ++- chain/src/codec.rs | 2 +- chain/src/store.rs | 7 +- core/src/core/block.rs | 41 ++++---- core/src/core/build.rs | 5 +- core/src/core/hash.rs | 80 ++++++++-------- core/src/core/target.rs | 24 ++--- core/src/core/transaction.rs | 18 ++-- core/src/pow/cuckoo.rs | 8 +- core/src/ser.rs | 45 ++++----- src/bin/grin.rs | 180 ++++++++++++++++++----------------- wallet/src/sender.rs | 2 +- 13 files changed, 221 insertions(+), 207 deletions(-) diff --git a/api/src/client.rs b/api/src/client.rs index fa8c0d7c..ab17e9a6 100644 --- a/api/src/client.rs +++ b/api/src/client.rs @@ -28,7 +28,7 @@ use rest::Error; pub fn get<'a, T>(url: &'a str) -> Result where for<'de> T: Deserialize<'de> { - println!("get {}", url); + println!("get {}", url); let client = hyper::Client::new(); let res = check_error(client.get(url).send())?; serde_json::from_reader(res) diff --git a/api/src/endpoints.rs b/api/src/endpoints.rs index 787417ef..001f8249 100644 --- a/api/src/endpoints.rs +++ b/api/src/endpoints.rs @@ -72,9 +72,11 @@ impl ApiEndpoint for OutputApi { } fn get(&self, id: String) -> ApiResult { - debug!("GET output {}", id); - let c = util::from_hex(id.clone()).map_err(|e| Error::Argument(format!("Not a valid commitment: {}", id)))?; - self.chain_store.get_output_by_commit(&Commitment::from_vec(c)).map_err(|e| Error::Internal(e.to_string())) + debug!("GET output {}", id); + let c = util::from_hex(id.clone()).map_err(|e| Error::Argument(format!("Not a valid commitment: {}", id)))?; + self.chain_store + .get_output_by_commit(&Commitment::from_vec(c)) + .map_err(|e| Error::Internal(e.to_string())) } } @@ -84,8 +86,10 @@ pub fn start_rest_apis(addr: String, chain_store: Arc) { thread::spawn(move || { let mut apis = ApiServer::new("/v1".to_string()); - apis.register_endpoint("/chain".to_string(), ChainApi { chain_store: chain_store.clone() }); - apis.register_endpoint("/chain/output".to_string(), OutputApi { chain_store: chain_store.clone() }); + apis.register_endpoint("/chain".to_string(), + ChainApi { chain_store: chain_store.clone() }); + apis.register_endpoint("/chain/output".to_string(), + OutputApi { chain_store: chain_store.clone() }); apis.start(&addr[..]).unwrap_or_else(|e| { error!("Failed to start API HTTP server: {}.", e); }); diff --git a/chain/src/codec.rs b/chain/src/codec.rs index da135c19..07247ca9 100644 --- a/chain/src/codec.rs +++ b/chain/src/codec.rs @@ -181,4 +181,4 @@ mod tests { assert_eq!(tip.prev_block_h, d_tip.prev_block_h); assert_eq!(tip.total_difficulty, d_tip.total_difficulty); } -} \ No newline at end of file +} diff --git a/chain/src/store.rs b/chain/src/store.rs index bb069c39..e20d6bd6 100644 --- a/chain/src/store.rs +++ b/chain/src/store.rs @@ -103,8 +103,8 @@ impl ChainStore for ChainKVStore { // saving the full output under its hash, as well as a commitment to hash index for out in &b.outputs { - let mut out_bytes = out.commit.as_ref().to_vec(); - println!("OUTSAVE: {:?}", out_bytes); + let mut out_bytes = out.commit.as_ref().to_vec(); + println!("OUTSAVE: {:?}", out_bytes); batch = batch.put_enc(&mut BlockCodec::default(), &to_key(OUTPUT_COMMIT_PREFIX, &mut out_bytes)[..], out.hash().clone())?; @@ -125,7 +125,8 @@ impl ChainStore for ChainKVStore { fn get_output_by_commit(&self, commit: &Commitment) -> Result { option_to_not_found(self.db.get_dec(&mut BlockCodec::default(), - &to_key(OUTPUT_COMMIT_PREFIX, &mut commit.as_ref().to_vec()))) + &to_key(OUTPUT_COMMIT_PREFIX, + &mut commit.as_ref().to_vec()))) } fn has_output_commit(&self, commit: &Commitment) -> Result { diff --git a/core/src/core/block.rs b/core/src/core/block.rs index b301898a..6b149852 100644 --- a/core/src/core/block.rs +++ b/core/src/core/block.rs @@ -46,7 +46,7 @@ pub struct BlockHeader { pub timestamp: time::Tm, /// Length of the cuckoo cycle used to mine this block. pub cuckoo_len: u8, - /// Merkle root of the UTXO set + /// Merkle root of the UTXO set pub utxo_merkle: Hash, /// Merkle tree of hashes for all inputs, outputs and kernels in the block pub tx_merkle: Hash, @@ -90,7 +90,7 @@ impl Writeable for BlockHeader { [write_u8, self.cuckoo_len], [write_fixed_bytes, &self.utxo_merkle], [write_fixed_bytes, &self.tx_merkle], - [write_u8, self.features.bits()]); + [write_u8, self.features.bits()]); try!(writer.write_u64(self.nonce)); try!(self.difficulty.write(writer)); @@ -141,13 +141,13 @@ impl Readable for BlockHeader { /// additive to the total of fees ever collected. #[derive(Clone, Debug, PartialEq)] pub struct Block { - /// The header with metadata and commitments to the rest of the data + /// The header with metadata and commitments to the rest of the data pub header: BlockHeader, - /// List of transaction inputs + /// List of transaction inputs pub inputs: Vec, - /// List of transaction outputs + /// List of transaction outputs pub outputs: Vec, - /// List of transaction kernels and associated proofs + /// List of transaction kernels and associated proofs pub kernels: Vec, } @@ -228,7 +228,6 @@ impl Default for Block { } impl Block { - /// Builds a new block from the header of the previous block, a vector of /// transactions and the private key that will receive the reward. Checks /// that all transactions are valid and calculates the Merkle tree. @@ -240,17 +239,17 @@ impl Block { let secp = Secp256k1::with_caps(secp::ContextFlag::Commit); let (reward_out, reward_proof) = try!(Block::reward_output(reward_key, &secp)); - Block::with_reward(prev, txs, reward_out, reward_proof) + Block::with_reward(prev, txs, reward_out, reward_proof) } /// Builds a new block ready to mine from the header of the previous block, - /// a vector of transactions and the reward information. Checks + /// a vector of transactions and the reward information. Checks /// that all transactions are valid and calculates the Merkle tree. pub fn with_reward(prev: &BlockHeader, - txs: Vec<&mut Transaction>, - reward_out: Output, - reward_kern: TxKernel) - -> Result { + txs: Vec<&mut Transaction>, + reward_out: Output, + reward_kern: TxKernel) + -> Result { // note: the following reads easily but may not be the most efficient due to // repeated iterations, revisit if a problem let secp = Secp256k1::with_caps(secp::ContextFlag::Commit); @@ -295,15 +294,15 @@ impl Block { kernels: kernels, } .compact()) - } + } - /// Blockhash, computed using only the header + /// Blockhash, computed using only the header pub fn hash(&self) -> Hash { self.header.hash() } - /// Sum of all fees (inputs less outputs) in the block + /// Sum of all fees (inputs less outputs) in the block pub fn total_fees(&self) -> u64 { self.kernels.iter().map(|p| p.fee).sum() } @@ -350,7 +349,8 @@ impl Block { } } - /// Merges the 2 blocks, essentially appending the inputs, outputs and kernels. + /// Merges the 2 blocks, essentially appending the inputs, outputs and + /// kernels. /// Also performs a compaction on the result. pub fn merge(&self, other: Block) -> Block { let mut all_inputs = self.inputs.clone(); @@ -448,10 +448,11 @@ impl Block { .verify_kernels(secp) } - /// Builds the blinded output and related signature proof for the block reward. + /// Builds the blinded output and related signature proof for the block + /// reward. pub fn reward_output(skey: secp::key::SecretKey, - secp: &Secp256k1) - -> Result<(Output, TxKernel), secp::Error> { + secp: &Secp256k1) + -> Result<(Output, TxKernel), secp::Error> { let msg = try!(secp::Message::from_slice(&[0; secp::constants::MESSAGE_SIZE])); let sig = try!(secp.sign(&msg, &skey)); let commit = secp.commit(REWARD, skey).unwrap(); diff --git a/core/src/core/build.rs b/core/src/core/build.rs index 2bc263f6..f88b4928 100644 --- a/core/src/core/build.rs +++ b/core/src/core/build.rs @@ -205,9 +205,8 @@ mod test { #[test] fn blind_simpler_tx() { let secp = Secp256k1::with_caps(secp::ContextFlag::Commit); - let (tx, _) = - transaction(vec![input_rand(6), output(2, key::ONE_KEY), with_fee(4)]) - .unwrap(); + let (tx, _) = transaction(vec![input_rand(6), output(2, key::ONE_KEY), with_fee(4)]) + .unwrap(); tx.verify_sig(&secp).unwrap(); } } diff --git a/core/src/core/hash.rs b/core/src/core/hash.rs index f0085bf3..a91bdc1a 100644 --- a/core/src/core/hash.rs +++ b/core/src/core/hash.rs @@ -48,15 +48,15 @@ impl fmt::Display for Hash { } impl Hash { - /// Builds a Hash from a byte vector. If the vector is too short, it will be - /// completed by zeroes. If it's too long, it will be truncated. - pub fn from_vec(v: Vec) -> Hash { - let mut h = [0; 32]; - for i in 0..min(v.len(), 32) { - h[i] = v[i]; - } - Hash(h) - } + /// Builds a Hash from a byte vector. If the vector is too short, it will be + /// completed by zeroes. If it's too long, it will be truncated. + pub fn from_vec(v: Vec) -> Hash { + let mut h = [0; 32]; + for i in 0..min(v.len(), 32) { + h[i] = v[i]; + } + Hash(h) + } /// Converts the hash to a byte vector pub fn to_vec(&self) -> Vec { @@ -65,49 +65,49 @@ impl Hash { } impl ops::Index for Hash { - type Output = u8; + type Output = u8; - fn index(&self, idx: usize) -> &u8 { - &self.0[idx] - } + fn index(&self, idx: usize) -> &u8 { + &self.0[idx] + } } impl ops::Index> for Hash { - type Output = [u8]; + type Output = [u8]; - fn index(&self, idx: ops::Range) -> &[u8] { - &self.0[idx] - } + fn index(&self, idx: ops::Range) -> &[u8] { + &self.0[idx] + } } impl ops::Index> for Hash { - type Output = [u8]; + type Output = [u8]; - fn index(&self, idx: ops::RangeTo) -> &[u8] { - &self.0[idx] - } + fn index(&self, idx: ops::RangeTo) -> &[u8] { + &self.0[idx] + } } impl ops::Index> for Hash { - type Output = [u8]; + type Output = [u8]; - fn index(&self, idx: ops::RangeFrom) -> &[u8] { - &self.0[idx] - } + fn index(&self, idx: ops::RangeFrom) -> &[u8] { + &self.0[idx] + } } impl ops::Index for Hash { - type Output = [u8]; + type Output = [u8]; - fn index(&self, idx: ops::RangeFull) -> &[u8] { - &self.0[idx] - } + fn index(&self, idx: ops::RangeFull) -> &[u8] { + &self.0[idx] + } } impl AsRef<[u8]> for Hash { - fn as_ref(&self) -> &[u8] { - &self.0 - } + fn as_ref(&self) -> &[u8] { + &self.0 + } } impl Readable for Hash { @@ -133,17 +133,19 @@ pub struct HashWriter { } impl HashWriter { - /// Consume the `HashWriter`, outputting its current hash into a 32-byte array + /// Consume the `HashWriter`, outputting its current hash into a 32-byte + /// array pub fn finalize(self, output: &mut [u8]) { self.state.finalize(output); } - /// Consume the `HashWriter`, outputting a `Hash` corresponding to its current state - pub fn into_hash(self) -> Hash { - let mut new_hash = ZERO_HASH; + /// Consume the `HashWriter`, outputting a `Hash` corresponding to its + /// current state + pub fn into_hash(self) -> Hash { + let mut new_hash = ZERO_HASH; self.state.finalize(&mut new_hash.0[..]); - new_hash - } + new_hash + } } impl Default for HashWriter { @@ -165,7 +167,7 @@ impl ser::Writer for HashWriter { /// A trait for types that have a canonical hash pub trait Hashed { - /// Obtain the hash of the object + /// Obtain the hash of the object fn hash(&self) -> Hash; } diff --git a/core/src/core/target.rs b/core/src/core/target.rs index a1b6d03f..88b2ab2c 100644 --- a/core/src/core/target.rs +++ b/core/src/core/target.rs @@ -33,7 +33,7 @@ pub const MAX_TARGET: [u8; 32] = [0xf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /// The difficulty is defined as the maximum target divided by the block hash. #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord)] pub struct Difficulty { - num: BigUint + num: BigUint, } impl Difficulty { @@ -44,15 +44,15 @@ impl Difficulty { Difficulty { num: BigUint::new(vec![1]) } } - /// Convert a `u32` into a `Difficulty` + /// Convert a `u32` into a `Difficulty` pub fn from_num(num: u32) -> Difficulty { Difficulty { num: BigUint::new(vec![num]) } } - /// Convert a `BigUint` into a `Difficulty` - pub fn from_biguint(num: BigUint) -> Difficulty { - Difficulty { num: num } - } + /// Convert a `BigUint` into a `Difficulty` + pub fn from_biguint(num: BigUint) -> Difficulty { + Difficulty { num: num } + } /// Computes the difficulty from a hash. Divides the maximum target by the /// provided hash. @@ -62,16 +62,16 @@ impl Difficulty { Difficulty { num: max_target / h_num } } - /// Converts the difficulty into a bignum - pub fn into_biguint(self) -> BigUint { - self.num - } + /// Converts the difficulty into a bignum + pub fn into_biguint(self) -> BigUint { + self.num + } } impl fmt::Display for Difficulty { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.num) - } + write!(f, "{}", self.num) + } } impl Add for Difficulty { diff --git a/core/src/core/transaction.rs b/core/src/core/transaction.rs index 12dd2032..67941795 100644 --- a/core/src/core/transaction.rs +++ b/core/src/core/transaction.rs @@ -55,10 +55,10 @@ pub struct TxKernel { impl Writeable for TxKernel { fn write(&self, writer: &mut W) -> Result<(), ser::Error> { ser_multiwrite!(writer, - [write_u8, self.features.bits()], - [write_fixed_bytes, &self.excess], - [write_bytes, &self.excess_sig], - [write_u64, self.fee]); + [write_u8, self.features.bits()], + [write_fixed_bytes, &self.excess], + [write_bytes, &self.excess_sig], + [write_u64, self.fee]); Ok(()) } } @@ -261,7 +261,7 @@ impl Readable for Input { /// The input for a transaction, which spends a pre-existing output. The input /// commitment is a reproduction of the commitment of the output it's spending. impl Input { - /// Extracts the referenced commitment from a transaction output + /// Extracts the referenced commitment from a transaction output pub fn commitment(&self) -> Commitment { self.0 } @@ -286,9 +286,9 @@ bitflags! { pub struct Output { /// Options for an output's structure or use pub features: OutputFeatures, - /// The homomorphic commitment representing the output's amount + /// The homomorphic commitment representing the output's amount pub commit: Commitment, - /// A proof that the commitment is in the right range + /// A proof that the commitment is in the right range pub proof: RangeProof, } @@ -296,7 +296,9 @@ pub struct Output { /// an Output as binary. impl Writeable for Output { fn write(&self, writer: &mut W) -> Result<(), ser::Error> { - ser_multiwrite!(writer, [write_u8, self.features.bits()], [write_fixed_bytes, &self.commit]); + ser_multiwrite!(writer, + [write_u8, self.features.bits()], + [write_fixed_bytes, &self.commit]); // The hash of an output doesn't include the range proof if writer.serialization_mode() == ser::SerializationMode::Full { writer.write_bytes(&self.proof)? diff --git a/core/src/pow/cuckoo.rs b/core/src/pow/cuckoo.rs index 321661ab..40957d4e 100644 --- a/core/src/pow/cuckoo.rs +++ b/core/src/pow/cuckoo.rs @@ -32,9 +32,9 @@ const MAXPATHLEN: usize = 8192; /// A cuckoo-cycle related error #[derive(Debug)] pub enum Error { - /// Unable to find a short enough path + /// Unable to find a short enough path Path, - /// Unable to find a solution + /// Unable to find a solution NoSolution, } @@ -168,7 +168,7 @@ enum CycleSol { } impl Miner { - /// Creates a new miner + /// Creates a new miner pub fn new(header: &[u8], ease: u32, sizeshift: u32) -> Miner { let cuckoo = Cuckoo::new(header, sizeshift); let size = 1 << sizeshift; @@ -181,7 +181,7 @@ impl Miner { } } - /// Searches for a solution + /// Searches for a solution pub fn mine(&mut self) -> Result { let mut us = [0; MAXPATHLEN]; let mut vs = [0; MAXPATHLEN]; diff --git a/core/src/ser.rs b/core/src/ser.rs index 2f5a46a1..5f19f6e2 100644 --- a/core/src/ser.rs +++ b/core/src/ser.rs @@ -34,9 +34,9 @@ pub enum Error { IOErr(io::Error), /// Expected a given value that wasn't found UnexpectedData { - /// What we wanted + /// What we wanted expected: Vec, - /// What we got + /// What we got received: Vec, }, /// Data wasn't in a consumable format @@ -179,7 +179,9 @@ pub trait Writeable { /// Trait that every type that can be deserialized from binary must implement. /// Reads directly to a Reader, a utility type thinly wrapping an /// underlying Read implementation. -pub trait Readable where Self: Sized { +pub trait Readable + where Self: Sized +{ /// Reads the data necessary to this Readable from the provided reader fn read(reader: &mut Reader) -> Result; } @@ -326,36 +328,35 @@ impl_int!(u64, write_u64, read_u64); impl_int!(i64, write_i64, read_i64); impl Writeable for (A, B) { - fn write(&self, writer: &mut W) -> Result<(), Error> { - try!(Writeable::write(&self.0, writer)); - Writeable::write(&self.1, writer) - } + fn write(&self, writer: &mut W) -> Result<(), Error> { + try!(Writeable::write(&self.0, writer)); + Writeable::write(&self.1, writer) + } } impl Readable for (A, B) { - fn read(reader: &mut Reader) -> Result<(A, B), Error> { - Ok((try!(Readable::read(reader)), - try!(Readable::read(reader)))) - } + fn read(reader: &mut Reader) -> Result<(A, B), Error> { + Ok((try!(Readable::read(reader)), try!(Readable::read(reader)))) + } } impl Writeable for (A, B, C) { - fn write(&self, writer: &mut W) -> Result<(), Error> { - try!(Writeable::write(&self.0, writer)); - try!(Writeable::write(&self.1, writer)); - Writeable::write(&self.2, writer) - } + fn write(&self, writer: &mut W) -> Result<(), Error> { + try!(Writeable::write(&self.0, writer)); + try!(Writeable::write(&self.1, writer)); + Writeable::write(&self.2, writer) + } } impl Readable for (A, B, C) { - fn read(reader: &mut Reader) -> Result<(A, B, C), Error> { - Ok((try!(Readable::read(reader)), - try!(Readable::read(reader)), - try!(Readable::read(reader)))) - } + fn read(reader: &mut Reader) -> Result<(A, B, C), Error> { + Ok((try!(Readable::read(reader)), + try!(Readable::read(reader)), + try!(Readable::read(reader)))) + } } -/// Useful marker trait on types that can be sized byte slices +/// Useful marker trait on types that can be sized byte slices pub trait AsFixedBytes: Sized + AsRef<[u8]> {} impl<'a> AsFixedBytes for &'a [u8] {} diff --git a/src/bin/grin.rs b/src/bin/grin.rs index 13e07620..360edf4f 100644 --- a/src/bin/grin.rs +++ b/src/bin/grin.rs @@ -45,7 +45,7 @@ use secp::Secp256k1; fn main() { env_logger::init().unwrap(); - let args = App::new("Grin") + let args = App::new("Grin") .version("0.1") .author("The Grin Team") .about("Lightweight implementation of the MimbleWimble protocol.") @@ -109,110 +109,114 @@ fn main() { .takes_value(true)))) .get_matches(); - match args.subcommand() { - // server commands and options - ("server", Some(server_args)) => { - server_command(server_args); - } + match args.subcommand() { + // server commands and options + ("server", Some(server_args)) => { + server_command(server_args); + } - // client commands and options - ("client", Some(client_args)) => { - match client_args.subcommand() { - ("status", _) => { - println!("status info..."); - }, - _ => panic!("Unknown client command, use 'grin help client' for details"), - } - } + // client commands and options + ("client", Some(client_args)) => { + match client_args.subcommand() { + ("status", _) => { + println!("status info..."); + } + _ => panic!("Unknown client command, use 'grin help client' for details"), + } + } - // client commands and options - ("wallet", Some(wallet_args)) => { - wallet_command(wallet_args); - } + // client commands and options + ("wallet", Some(wallet_args)) => { + wallet_command(wallet_args); + } - _ => println!("Unknown command, use 'grin help' for a list of all commands"), - } + _ => println!("Unknown command, use 'grin help' for a list of all commands"), + } } /// Handles the server part of the command line, mostly running, starting and -/// stopping the Grin blockchain server. Processes all the command line arguments +/// stopping the Grin blockchain server. Processes all the command line +/// arguments /// to build a proper configuration and runs Grin with that configuration. fn server_command(server_args: &ArgMatches) { - info!("Starting the Grin server..."); + info!("Starting the Grin server..."); - // configuration wrangling - let mut server_config = read_config(); - if let Some(port) = server_args.value_of("port") { - server_config.p2p_config.port = port.parse().unwrap(); - } - if server_args.is_present("mine") { - server_config.mining_config.enable_mining = true; - } - if let Some(seeds) = server_args.values_of("seed") { - server_config.seeding_type = grin::Seeding::List(seeds.map(|s| s.to_string()).collect()); - } + // configuration wrangling + let mut server_config = read_config(); + if let Some(port) = server_args.value_of("port") { + server_config.p2p_config.port = port.parse().unwrap(); + } + if server_args.is_present("mine") { + server_config.mining_config.enable_mining = true; + } + if let Some(seeds) = server_args.values_of("seed") { + server_config.seeding_type = grin::Seeding::List(seeds.map(|s| s.to_string()).collect()); + } - // start the server in the different run modes (interactive or daemon) - match server_args.subcommand() { - ("run", _) => { - grin::Server::start(server_config).unwrap(); - loop { - thread::sleep(Duration::from_secs(60)); - } - }, - ("start", _) => { - let daemonize = Daemonize::new() - .pid_file("/tmp/grin.pid") - .chown_pid_file(true) - .privileged_action(move || { - grin::Server::start(server_config.clone()).unwrap(); - loop { - thread::sleep(Duration::from_secs(60)); - } - }); - match daemonize.start() { - Ok(_) => info!("Grin server succesfully started."), - Err(e) => error!("Error starting: {}", e), - } - } - ("stop", _) => { - println!("TODO, just 'kill $pid' for now.") - } - _ => panic!("Unknown server command, use 'grin help server' for details"), - } + // start the server in the different run modes (interactive or daemon) + match server_args.subcommand() { + ("run", _) => { + grin::Server::start(server_config).unwrap(); + loop { + thread::sleep(Duration::from_secs(60)); + } + } + ("start", _) => { + let daemonize = Daemonize::new() + .pid_file("/tmp/grin.pid") + .chown_pid_file(true) + .privileged_action(move || { + grin::Server::start(server_config.clone()).unwrap(); + loop { + thread::sleep(Duration::from_secs(60)); + } + }); + match daemonize.start() { + Ok(_) => info!("Grin server succesfully started."), + Err(e) => error!("Error starting: {}", e), + } + } + ("stop", _) => println!("TODO, just 'kill $pid' for now."), + _ => panic!("Unknown server command, use 'grin help server' for details"), + } } fn wallet_command(wallet_args: &ArgMatches) { - let hd_seed = wallet_args.value_of("pass").expect("Wallet passphrase required."); + let hd_seed = wallet_args.value_of("pass").expect("Wallet passphrase required."); - // TODO do something closer to BIP39, eazy solution right now - let mut sha3 = Keccak::new_sha3_256(); - sha3.update(hd_seed.as_bytes()); - let mut seed = [0; 32]; - sha3.finalize(&mut seed); + // TODO do something closer to BIP39, eazy solution right now + let mut sha3 = Keccak::new_sha3_256(); + sha3.update(hd_seed.as_bytes()); + let mut seed = [0; 32]; + sha3.finalize(&mut seed); let s = Secp256k1::new(); - let key = wallet::ExtendedKey::from_seed(&s, &seed[..]).expect("Error deriving extended key from seed."); + let key = wallet::ExtendedKey::from_seed(&s, &seed[..]) + .expect("Error deriving extended key from seed."); - match wallet_args.subcommand() { - ("receive", _) => { - info!("Starting the Grin wallet receiving daemon..."); - let mut apis = api::ApiServer::new("/v1".to_string()); - apis.register_endpoint("/receive_coinbase".to_string(), wallet::WalletReceiver { key: key }); - apis.start("127.0.0.1:13416").unwrap_or_else(|e| { - error!("Failed to start Grin wallet receiver: {}.", e); - }); - } - ("send", Some(send_args)) => { - let amount = send_args.value_of("amount").expect("Amount to send required").parse().expect("Could not parse amount as a whole number."); - let mut dest = "stdout"; - if let Some(d) = send_args.value_of("dest") { - dest = d; - } - wallet::issue_send_tx(&key, amount, dest.to_string()).unwrap(); - } - _ => panic!("Unknown wallet command, use 'grin help wallet' for details"), - } + match wallet_args.subcommand() { + ("receive", _) => { + info!("Starting the Grin wallet receiving daemon..."); + let mut apis = api::ApiServer::new("/v1".to_string()); + apis.register_endpoint("/receive_coinbase".to_string(), + wallet::WalletReceiver { key: key }); + apis.start("127.0.0.1:13416").unwrap_or_else(|e| { + error!("Failed to start Grin wallet receiver: {}.", e); + }); + } + ("send", Some(send_args)) => { + let amount = send_args.value_of("amount") + .expect("Amount to send required") + .parse() + .expect("Could not parse amount as a whole number."); + let mut dest = "stdout"; + if let Some(d) = send_args.value_of("dest") { + dest = d; + } + wallet::issue_send_tx(&key, amount, dest.to_string()).unwrap(); + } + _ => panic!("Unknown wallet command, use 'grin help wallet' for details"), + } } fn read_config() -> grin::ServerConfig { diff --git a/wallet/src/sender.rs b/wallet/src/sender.rs index 4207c88e..fec1fd27 100644 --- a/wallet/src/sender.rs +++ b/wallet/src/sender.rs @@ -22,7 +22,7 @@ use extkey::ExtendedKey; use types::*; pub fn issue_send_tx(ext_key: &ExtendedKey, amount: u64, dest: String) -> Result<(), Error> { - checker::refresh_outputs(&WalletConfig::default(), ext_key); + checker::refresh_outputs(&WalletConfig::default(), ext_key); let (tx, blind_sum) = build_send_tx(ext_key, amount)?; let json_tx = partial_tx_to_json(amount, blind_sum, tx);