bitcoin-crypto-toolkit 0.1.0

A CLI tool and Rust library for Bitcoin cryptography operations including SHA256, RIPEMD160, HASH160, secp256k1 key generation, and address derivation
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

use clap::{Parser, Subcommand};
use owo_colors::OwoColorize;
use bitcoin_crypto_toolkit::{sha256, ripemd160, hash160, generate_keypair, derive_address};
use secp256k1::PublicKey;
use hex;

#[derive(Parser)]
#[command(name = "bitcoin-do")]
#[command(about = "This tool provides essential cryptograpic functions for Bitcoin development:
- Hashing functions: SHA256, RIPEMD160, HASH160
- Key generation: secp256k1 keypairs
- Address derivation: P2PKH Bitcoin addresses

Examples:
  Generate a new keypair:
    bitcoin-do generate-key

  Derive address from public key:
    bitcoin-do derive-address 02...

  Hash some data:
    bitcoin-do sha256 68656c6c6f")]

struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    // Compute SHA256 hash of hex data
    Sha256 { data: String },
    // Compute RIPEMD160 hash of hex data
    Ripemd160 { data: String },
    // Compute HASH160 (RIPEMD160 of SHA256) of hex dat
    Hash160 { data: String },
    // Generate a new secp256k1 keypair
    GenerateKey,
    // Derive Bitcoin address from public key (hex)
    DeriveAddress { pubkey: String },
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Sha256 { data } => {
            match hex::decode(&data) {
                Ok(bytes) => {
                    let hash = sha256(&bytes);
                    println!("Your SHA256: {}", hash.green());
                }
                Err(_) => eprintln!("{}", "Invalid hex data".red()),
            }
        }
        Commands::Ripemd160 { data } => {
            match hex::decode(&data) {
                Ok(bytes) => {
                    let hash = ripemd160(&bytes);
                    println!("Your RIPEMD160: {}", hash.green());
                }
                Err(_) => eprintln!("{}", "Invalid hex data".red()),
            }
        }
        Commands::Hash160 { data } => {
            match hex::decode(&data) {
                Ok(bytes) => {
                    let hash = hash160(&bytes);
                    println!("Your HASH160: {}", hash.green());
                }
                Err(_) => eprintln!("{}", "Invalid hex data".red()),
            }
        }
        Commands::GenerateKey => {
            let (priv_key, pub_key) = generate_keypair();
            println!("Your Private Key: {}", hex::encode(priv_key.secret_bytes()).yellow());
            println!("Your Public Key: {}", hex::encode(pub_key.serialize()).cyan());
        }
        Commands::DeriveAddress { pubkey } => {
            match hex::decode(&pubkey) {
                Ok(bytes) => {
                    match PublicKey::from_slice(&bytes){
                        Ok(pk) => {
                            let address = derive_address(&pk);
                            println!("Your Address: {}", address.magenta());
                        }
                        Err(_) => eprintln!("{}", "Invalid public key".red()),
                    }
                }
                Err(_) => eprintln!("{}", "Invalid hex public key".red()),
            }
        }
    }
}