feeless 0.1.11

A Nano (cryptocurrency) node and utilities such as nano addresses, hashing blocks, signing, etc.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::vanity;
use crate::vanity::Secret;
use clap::Clap;
use std::sync::{Arc, RwLock};
use tokio::time::{timeout, Duration, Instant};

#[derive(Clap)]
pub struct VanityOpts {
    #[clap(subcommand)]
    secret_type: VanitySecretType,
}

impl VanityOpts {
    pub async fn handle(&self) -> anyhow::Result<()> {
        let (secret_type, opts) = match &self.secret_type {
            VanitySecretType::Phrase(phrase) => {
                let secret_type = vanity::SecretType::Phrase {
                    language: phrase.phrase_opts.language.language.to_owned(),
                    words: phrase.phrase_opts.words.0,
                };
                (secret_type, &phrase.common_opts)
            }
            VanitySecretType::Seed(seed) => (vanity::SecretType::Seed, &seed.common_opts),
            VanitySecretType::Private(private) => {
                (vanity::SecretType::Private, &private.common_opts)
            }
        };

        let matches = if opts.start {
            vanity::Match::start(&opts.matching)
        } else if opts.end {
            vanity::Match::end(&opts.matching)
        } else if opts.regex {
            vanity::Match::regex(&opts.matching)?
        } else {
            vanity::Match::start_or_end(&opts.matching)
        };

        let mut vanity = vanity::Vanity::new(secret_type, matches);
        if let Some(tasks) = opts.tasks {
            vanity.tasks(tasks);
        }
        if opts.include_digit {
            vanity.include_first_digit(true);
        }

        let (mut rx, attempts) = vanity.start().await?;
        let started = Instant::now();
        let mut last_log = Instant::now();
        let mut found = 0;
        loop {
            match timeout(Duration::from_secs(1), rx.recv()).await {
                Ok(Some(result)) => {
                    let s = match result.secret {
                        Secret::Phrase(p) => p.to_string(),
                        Secret::Seed(s) => s.to_string(),
                        Secret::Private(p) => p.to_string(),
                    };
                    println!("{},{}", result.address.to_string(), s);
                    last_log = log(started, last_log, attempts.clone()).await;
                    found += 1;
                    if let Some(limit) = opts.limit {
                        if limit == found {
                            break;
                        }
                    }
                }
                // Channel closed.
                Ok(None) => {
                    break;
                }
                // Timeout
                Err(_) => {
                    last_log = log(started, last_log, attempts.clone()).await;
                }
            }
        }
        Ok(())
    }
}

async fn log(started: Instant, last_log: Instant, attempts: Arc<RwLock<usize>>) -> Instant {
    let now = Instant::now();
    let since_last_log = now.duration_since(last_log);
    if since_last_log < Duration::from_secs(1) {
        last_log
    } else {
        let total_taken = Instant::now().duration_since(started);
        let attempts = *attempts
            .read()
            .expect("Could not unlock attempts for reading.");
        let rate = (attempts as f64) / total_taken.as_secs_f64();
        eprintln!("Attempted: {}, Rate: {:?} attempts/s", attempts, rate);
        now
    }
}

#[derive(Clap)]
enum VanitySecretType {
    /// Generate phrases to find addresses. WARNING: This method is slow currently.
    Phrase(PhraseOpts),
    /// Generate seeds to find addresses.
    Seed(SeedOpts),
    /// Generate private keys to find addresses.
    Private(PrivateOpts),
}

#[derive(Clap)]
struct PhraseOpts {
    #[clap(flatten)]
    pub phrase_opts: super::phrase::New,

    #[clap(flatten)]
    pub common_opts: CommonOpts,
}

#[derive(Clap)]
struct SeedOpts {
    #[clap(flatten)]
    pub common_opts: CommonOpts,
}

#[derive(Clap)]
struct PrivateOpts {
    #[clap(flatten)]
    pub common_opts: CommonOpts,
}

#[derive(Clap)]
struct CommonOpts {
    /// Match on this string. By default will match the start and end.
    matching: String,

    /// Match on start only. Default is start and end.
    #[clap(short, long, group = "match")]
    start: bool,

    /// Match on end only. Default is start and end.
    #[clap(short, long, group = "match")]
    end: bool,

    /// Match on a regular expression instead.
    #[clap(short, long, group = "match")]
    regex: bool,

    /// Also match against the first digit (1 or 3) after `nano_`.
    #[clap(short, long)]
    include_digit: bool,

    /// Number of parallel tasks to use. Default: Your logical processors minus one, or at least 1.
    #[clap(short, long)]
    tasks: Option<usize>,

    /// Stop after finding this many matches.
    #[clap(short, long)]
    limit: Option<usize>,
}