fuel-core-keygen-bin 0.48.2

Command line utilities for fuel-core key management
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

//! A simple keygen cli utility tool for configuring fuel-core
use atty::Stream;
use clap::Parser;
use crossterm::terminal;
use fuel_core_keygen::{
    KeyType,
    new_key,
    parse_secret,
};
use std::io::{
    Read,
    Write,
    stdin,
    stdout,
};
use termion::screen::IntoAlternateScreen;

/// Parse a secret key to view the associated public key
#[derive(Debug, clap::Args)]
pub struct ParseSecret {
    /// A private key in hex format
    secret: String,
    /// Print the JSON in pretty format
    #[clap(long = "pretty", short = 'p')]
    pub pretty: bool,
    /// Key type to generate. It can either be `block-production` or `peering`.
    #[clap(
        long = "key-type",
        short = 'k',
        value_enum,
        default_value = <KeyType as std::convert::Into<&'static str>>::into(KeyType::BlockProduction),
    )]
    pub key_type: KeyType,
}

/// Generate a random new secret & public key in the format expected by fuel-core
#[derive(Debug, clap::Args)]
pub struct NewKey {
    /// Print the JSON in pretty format
    #[clap(long = "pretty", short = 'p')]
    pub pretty: bool,
    /// Key type to generate. It can either be `block-production` or `peering`.
    #[clap(
        long = "key-type",
        short = 'k',
        value_enum,
        default_value = <KeyType as std::convert::Into<&'static str>>::into(KeyType::BlockProduction),
    )]
    pub key_type: KeyType,
}

/// Key management utilities for configuring fuel-core
#[derive(Debug, Parser)]
#[clap(name = "fuel-core-keygen", author, version, about)]
pub(crate) enum Command {
    New(NewKey),
    Parse(ParseSecret),
}

impl Command {
    pub(crate) fn exec(&self) -> anyhow::Result<(serde_json::Value, bool)> {
        match self {
            Command::New(cmd) => {
                Ok((serde_json::to_value(new_key(cmd.key_type)?)?, cmd.pretty))
            }
            Command::Parse(cmd) => Ok((
                serde_json::to_value(parse_secret(cmd.key_type, &cmd.secret)?)?,
                cmd.pretty,
            )),
        }
    }
}

fn main() -> anyhow::Result<()> {
    let cmd = Command::parse();
    let (result, is_pretty) = cmd.exec()?;
    print_value(result, is_pretty)
}

fn wait_for_keypress() {
    let mut single_key = [0u8];
    terminal::enable_raw_mode().expect("enable_raw_mode failed");
    stdin().read_exact(&mut single_key).unwrap();
    terminal::disable_raw_mode().expect("disable_raw_mode failed");
}

fn display_string_discreetly(
    discreet_string: &str,
    continue_message: &str,
) -> anyhow::Result<()> {
    if atty::is(Stream::Stdout) {
        let mut screen = stdout().into_alternate_screen()?;
        writeln!(screen, "{discreet_string}")?;
        screen.flush()?;
        println!("{continue_message}");
        wait_for_keypress();
    } else {
        println!("{discreet_string}");
    }
    Ok(())
}

fn print_value(output: serde_json::Value, pretty: bool) -> anyhow::Result<()> {
    let output = if pretty {
        serde_json::to_string_pretty(&output)
    } else {
        serde_json::to_string(&output)
    }
    .map_err(anyhow::Error::msg);

    let _ = display_string_discreetly(
        &output?,
        "### Do not share or lose this private key! Press any key to complete. ###",
    );
    Ok(())
}