tmkms 0.15.0

Tendermint Key Management System: provides isolated, optionally HSM-backed signing key management for Tendermint applications including validators, oracles, IBC relayers, and other transaction signing applications
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

//! `tmkms softsign import` command

use crate::{config::provider::softsign::KeyFormat, key_utils, prelude::*};
use abscissa_core::Command;
use clap::Parser;
use cometbft::PrivateKey;
use cometbft_config::PrivValidatorKey;
use std::{path::PathBuf, process};

/// `import` command: import a `priv_validator.json` formatted key and convert
/// it into the raw format used by the softsign backend (by default)
#[derive(Command, Debug, Default, Parser)]
pub struct ImportCommand {
    /// key format to import: 'json' or 'raw' (default 'json')
    #[clap(short = 'f')]
    format: Option<String>,

    /// [INPUT] and [OUTPUT] paths for key generation
    paths: Vec<PathBuf>,
}

impl Runnable for ImportCommand {
    /// Import a `priv_validator.json`
    fn run(&self) {
        if self.paths.len() != 2 {
            status_err!("expected 2 arguments, got {}", self.paths.len());
            eprintln!("\nUsage: tmkms softsign import [priv_validator.json] [output.key]");
            process::exit(1);
        }

        let input_path = &self.paths[0];
        let output_path = &self.paths[1];

        let format = self
            .format
            .as_ref()
            .map(|f| {
                f.parse::<KeyFormat>().unwrap_or_else(|e| {
                    status_err!("{} (must be 'json' or 'raw')", e);
                    process::exit(1);
                })
            })
            .unwrap_or(KeyFormat::Json);

        if format != KeyFormat::Json {
            status_err!("invalid format: {:?} (must be 'json')", format);
            process::exit(1);
        }

        let secret_key = PrivValidatorKey::load_json_file(input_path)
            .unwrap_or_else(|e| {
                status_err!("couldn't load {}: {}", input_path.display(), e);
                process::exit(1);
            })
            .priv_key;

        match secret_key {
            PrivateKey::Ed25519(sk) => {
                key_utils::write_base64_secret(output_path, sk.as_bytes()).unwrap_or_else(|e| {
                    status_err!("{}", e);
                    process::exit(1);
                });
                info!("Imported Ed25519 private key to {}", output_path.display());
            }
            PrivateKey::Secp256k1(sk) => {
                key_utils::write_base64_secret(output_path, &sk.to_bytes()).unwrap_or_else(|e| {
                    status_err!("{}", e);
                    process::exit(1);
                });
                info!(
                    "Imported Secp256k1 private key to {}",
                    output_path.display()
                );
            }
            _ => unreachable!("unsupported priv_validator.json algorithm"),
        }
    }
}