ant-cli 0.5.2

CLI client for the Autonomi network
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

// Copyright 2024 MaidSafe.net limited.
//
// This SAFE Network Software is licensed to you under The General Public License (GPL), version 3.
// Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed
// under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. Please review the Licences for the specific language governing
// permissions and limitations relating to use of the SAFE Network Software.

use crate::actions::NetworkContext;
use crate::wallet::DUMMY_NETWORK;
use crate::wallet::fs::{select_wallet_private_key, store_private_key};
use crate::wallet::input::request_password;
use autonomi::{Wallet, get_evm_network};
use color_eyre::Result;
use color_eyre::eyre::eyre;
use comfy_table::Table;

const WALLET_PASSWORD_REQUIRED: bool = false;

pub fn create(no_password: bool, password: Option<String>) -> Result<()> {
    let maybe_encryption_password = maybe_request_password(no_password, password)?;

    let wallet_private_key = Wallet::random_private_key();

    let wallet_address = Wallet::new_from_private_key(DUMMY_NETWORK, &wallet_private_key)
        .map_err(|e| eyre!("Unexpected error: Failed to create wallet from private key: {e}"))?
        .address()
        .to_string();

    // Save the private key file
    let file_path = store_private_key(&wallet_private_key, maybe_encryption_password)?;

    println!("Wallet address: {wallet_address}");
    println!("Wallet private key: {wallet_private_key}");
    println!("Stored wallet in: {file_path:?}");

    Ok(())
}

pub fn import(
    mut wallet_private_key: String,
    no_password: bool,
    password: Option<String>,
) -> Result<()> {
    // Validate imported key
    Wallet::new_from_private_key(DUMMY_NETWORK, &wallet_private_key)
        .map_err(|_| eyre!("Please provide a valid private key in hex format"))?;

    let maybe_encryption_password = maybe_request_password(no_password, password)?;

    let wallet_address = Wallet::new_from_private_key(DUMMY_NETWORK, &wallet_private_key)
        .map_err(|e| eyre!("Unexpected error: Failed to create wallet from private key: {e}"))?
        .address()
        .to_string();

    // Prepend with 0x if it isn't already
    if !wallet_private_key.starts_with("0x") {
        wallet_private_key = format!("0x{wallet_private_key}");
    }

    // Save the private key file
    let file_path = store_private_key(&wallet_private_key, maybe_encryption_password)?;

    println!("Wallet address: {wallet_address}");
    println!("Stored wallet in: {file_path:?}");

    Ok(())
}

pub fn export() -> Result<()> {
    let wallet_private_key = select_wallet_private_key()?;

    let wallet_address = Wallet::new_from_private_key(DUMMY_NETWORK, &wallet_private_key)
        .map_err(|e| eyre!("Failed to create wallet from private key loaded from disk: {e}"))?
        .address()
        .to_string();

    println!("Wallet address: {wallet_address}");
    println!("Wallet private key: {wallet_private_key}");

    Ok(())
}

pub async fn balance(network_context: NetworkContext) -> Result<()> {
    let network = get_evm_network(
        network_context.peers.local,
        Some(network_context.network_id.as_u8()),
    )?;
    let wallet = crate::wallet::load_wallet(&network)?;

    let token_balance = wallet.balance_of_tokens().await?;
    let gas_balance = wallet.balance_of_gas_tokens().await?;

    println!("Wallet balances: {}", wallet.address());

    let mut table = Table::new();

    table.add_row(vec!["Token Balance", &token_balance.to_string()]);

    table.add_row(vec!["Gas Balance", &gas_balance.to_string()]);

    println!("{table}");

    Ok(())
}

fn maybe_request_password(no_password: bool, password: Option<String>) -> Result<Option<String>> {
    if no_password && password.is_some() {
        return Err(eyre!(
            "Only one of `--no-password` or `--password` may be specified"
        ));
    }

    // Set a password for encryption or not
    let maybe_password = match (no_password, password) {
        (true, _) => None,
        (false, Some(pass)) => Some(pass.to_owned()),
        (false, None) => request_password(WALLET_PASSWORD_REQUIRED),
    };

    Ok(maybe_password)
}