hashmoney 2.0.1

Yet another hashcash implementation, with wasm support, variable date width and multiple minting strategies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use std::process::exit;

use clap::{arg, value_parser, Command};
use hashmoney::{MintStrategy, Stamp};

fn cli() -> Command {
    return Command::new("Hashmoney")
        .bin_name("hm")
        .about("Yet another hashcash implementation")
        .subcommand(Command::new("mint")
            .about("Mints a new stamp")
            .args(vec![
                arg!(-b --bits <bits> "The bits of the stamp")
                    .value_parser(value_parser!(u32)),
                arg!(-w --date_width [date_width] "The date field width (can only be: 6, 10 or 12)")
                    .value_parser(value_parser!(usize)),
                arg!(<resource> "The resource of the stamp")
                    .value_parser(value_parser!(String)),
            ])
        )
        .subcommand(Command::new("check")
            .about("Checks a given stamp")
            .args(vec![
                arg!(-b --bits <bits> "The expected number of bits")
                    .value_parser(value_parser!(u32)),
                arg!(-d --days <days> "The number of validity days")
                    .value_parser(value_parser!(u32)),
                arg!(-r --resource <resource> "The expected resource")
                    .value_parser(value_parser!(String)),
                arg!(<stamp> "The stamp to check")
                    .value_parser(value_parser!(String)),
            ])
        );
}

fn main() {
    let matches = cli().get_matches();

    match matches.subcommand() {
        Some(("mint", sub_matches)) => {
            let bits = sub_matches.get_one::<u32>("bits")
                .expect("A bit number is required")
                .clone();

            let date_width = sub_matches.get_one::<usize>("date_width")
                .unwrap_or(&6)
                .clone();

            let resource = sub_matches.get_one::<String>("resource")
                .expect("A resource is required")
                .clone();

            let stamp = Stamp::mint(bits, date_width, &resource, MintStrategy::Naive);
            println!("hashcash stamp: {}", stamp.to_string());
        },
        Some(("check", sub_matches)) => {
            let bits = sub_matches.get_one::<u32>("bits")
                .expect("Bits is a required argument")
                .clone();

            let days = sub_matches.get_one::<u32>("days")
                .expect("Days is a required argument")
                .clone();

            let resource = sub_matches.get_one::<String>("resource")
                .expect("Resource is a required argument")
                .clone();

            let stamp_str = sub_matches.get_one::<String>("stamp")
                .expect("A stamp is required")
                .clone();

            let stamp = Stamp::try_from(stamp_str).unwrap_or_else(|err| {
               println!("An error occured while parsing the given stamp: {}", err);
               exit(-2);
            });

            let result = stamp.check(bits, days, &resource);
            println!("Is {} valid?: {}", stamp.to_string(), if result.is_ok() { "yes".to_string() } else { result.unwrap_err().to_string() });
        },
        _ => {
            println!("Invalid subcommand");
            exit(-1)
        },
    };
}