wallet-gen 0.4.1

Rust library to mass-generate wallets for many different cryptocurrencies
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

/*
 * wallet.rs
 *
 * Copyright 2018 Standard Mining
 *
 * Available to be used and modified under the terms of the MIT License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

//! A representation of a cryptocurrency wallet. Stores in that
//! coin's native WIF, or "wallet import format".

use super::prelude::*;
use {bitcoin, cryptonote, ethereum};
use std::collections::HashMap;

/// The actual wallet structure.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Wallet {
    /// Which cryptocurrency this wallet is for
    pub coin: Coin,

    /// The wallet address as a human-readable string
    pub address: String,

    /// The wallet's public key in WIF format
    pub public_key: String,

    /// The wallet's private key in WIF format
    pub private_key: String,

    /// Extra fields, depending on the wallet
    pub other: Option<HashMap<String, String>>,
}

impl Wallet {
    /// Generates a new random wallet for the given coin.
    /// The private key will be sourced from a source of
    /// cryptographically-secure randomness. See OpenSSL
    /// documentation for more details.
    pub fn generate(coin: Coin) -> Result<Self> {
        use self::Coin::*;

        match coin {
            Ethereum | EthereumClassic => ethereum::new_wallet(coin),
            Monero | Aeon => cryptonote::new_wallet(coin),
            coin if bitcoin::wif_data(coin).is_some() => bitcoin::new_wallet(coin),
            _ => Err(Error::CoinNotSupported(coin)),
        }
    }
}

#[test]
fn gen_all_wallets() {
    use coin::COINS;

    println!("Generating wallets for all coins...");
    for coin in COINS.iter() {
        let wallet = match Wallet::generate(*coin) {
            Ok(wallet) => wallet,
            Err(Error::CoinNotSupported(_)) => continue,
            Err(e) => {
                panic!(
                    "Error generating wallet for {:?} ({}): {}",
                    coin,
                    coin.symbol(),
                    e,
                )
            },
        };

        println!("Coin: {:?} ({})", coin, coin.symbol());
        println!("Address: {}", &wallet.address);
        println!("Public key: {}", &wallet.public_key);
        println!("Private key: {}", &wallet.private_key);
        if let Some(ref other) = wallet.other {
            println!("Other: {:#?}", other);
        }
        println!();
    }
}