Base functionality working.

hw7/task1/src/hash256.rs

@@ -1,13 +1,24 @@
-use hasher_sha256;
+use hasher_sha256::{Hasher, HashResult};
+use hasher_sha256::Sha256;
 
-struct Solution {
-    number: usize,
-    hash: String,
+
+pub struct Solution {
+    pub number: usize,
+    pub hash: String,
 }
 
-pub fn verify_product(base: usize, number: usize, difficulty: String) -> Option<Solution> {
-    if let x = hasher_sha256::Hasher::hash(((base * number) as i32)).hex().ends_with(difficulty) {
-        Some(Solution{ number: (base * number), hash: x,});
+pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option<Solution> {
+    let sol = base * number;
+    let input = sol.to_string();
+    let bytes = input.as_bytes();
+
+    let hash = Sha256::hash(bytes).hex();
+
+    //println!("{} ends with {}", hash, difficulty);
+
+    if hash.ends_with(difficulty) {
+        return Some(Solution{ number: number, hash: hash,});
     }
+
     None
 }

hw7/task1/src/main.rs

@@ -1,20 +1,35 @@
 extern crate clap;
 extern crate time;
 use clap::{Arg, App, SubCommand};
+use std::process;
 mod hasher_sha256;
 mod hash256;
 
-pub fn main(/*base: usize, */number: usize, diff: String) {
+pub fn main() {
     let matches = create_app().get_matches();
-    let base;
-    match matches.value_of("base") {
-        Some(x) => {base = u64::from(x)}
-        None => {panic!()}
-    };
-    match hash256::verify_product(base, number, diff) {
-        Some(x) => { println!("{}", diff); }
-        None => { println!("None"); }
+    let base = matches.value_of("base").unwrap_or("1");
+    let diff = matches.value_of("difficulty").unwrap_or("1");
+
+    println!("Using base: {}", base);
+    println!("Using difficulty: {}", diff);
+
+    if diff.chars().any( |c| !c.is_digit(16)) {
+        println!("Difficulty is not hexadecimal.");
+        process::exit(1)
     }
+
+    match base.parse::<usize>() {
+        Ok(b) => {
+            println!("Please wait...");
+            for n in 0..<usize>::max_value() {
+                if let Some(x) = hash256::verify_product(b, n, &diff.to_string()) {
+                    println!("Number: {} --> hash: {}", x.number, x.hash);
+                    process::exit(0)
+                }
+            }
+        }
+        Err(_) => {}
+    };
 }
 
 fn create_app<'a, 'b>() -> App<'a, 'b> {
@@ -23,23 +38,12 @@ fn create_app<'a, 'b>() -> App<'a, 'b> {
         .author("Lorenz Bung & Joshua Rutschmann")
         .about("Calculates the Hashvalue of the given base, number and difficulty.")
         .arg(Arg::with_name("base")
-            .short("b")
-            .long("base")
-            .value_name("VALUE")
+            .value_name("base")
             .help("The base of the hash to be calculated on.")
             .takes_value(true)
             .required(true))
-        .arg(Arg::with_name("number")
-            .short("n")
-            .long("number")
-            .value_name("VALUE")
-            .help("The number of the hash to be calculated on.")
-            .takes_value(true)
-            .required(true))
         .arg(Arg::with_name("difficulty")
-            .short("d")
-            .long("difficulty")
-            .value_name("VALUE")
+            .value_name("difficulty")
             .help("The difficulty of the calculated hash.")
             .takes_value(true)
             .required(true))