forc-wallet 0.1.3

A forc plugin for generating or importing wallets using BIP39 phrases.
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

mod account;
mod export;
mod import;
mod init;
mod list;
mod sign;
mod utils;

use std::path::PathBuf;

use crate::{
    account::{new_account_cli, print_account_address},
    export::export_account_cli,
    import::import_wallet_cli,
    init::init_wallet_cli,
    list::print_wallet_list,
    sign::{sign_transaction_cli, sign_transaction_with_private_key_cli},
};
use anyhow::Result;
use clap::{ArgEnum, Parser, Subcommand};
use fuels::prelude::*;

#[derive(Debug, Parser)]
#[clap(
    name = "forc-wallet",
    about = "A forc plugin for generating or importing wallets using BIP39 phrases.",
    version
)]
struct App {
    #[clap(subcommand)]
    pub command: Command,
    #[clap(arg_enum, long = "format", short = 'o', default_value = "json")]
    pub fmt: OutputFormat,
}

#[derive(Debug, Subcommand)]
#[clap(rename_all = "kebab-case")]
enum Command {
    /// Generate a new account for the initialized HD wallet.
    New {
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Initialize the HD wallet from a random mnemonic phrase.
    Init {
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Initialize the HD wallet from the provided mnemonic phrase.
    Import {
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Lists all accounts derived so far.
    List {
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Get the address of an acccount from account index
    Account {
        #[clap(long)]
        account_index: usize,
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Sign a transaction by providing its ID and the signing account's index
    Sign {
        #[clap(long)]
        id: String,
        #[clap(long)]
        account_index: usize,
        #[clap(long)]
        path: Option<PathBuf>,
    },
    /// Sign a transaction by providing its ID and the signing account's private key.
    SignPrivate {
        #[clap(long)]
        tx_id: String,
    },
    /// Get the private key of an account from its index
    Export {
        #[clap(long)]
        path: Option<PathBuf>,
        #[clap(long)]
        account_index: usize,
    },
}

#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, ArgEnum)]
#[clap(rename_all = "kebab-case")]
enum OutputFormat {
    Json,
    Toml,
}

#[tokio::main]
async fn main() -> Result<()> {
    let app = App::parse();

    match app.command {
        Command::New { path } => new_account_cli(path)?,
        Command::List { path } => print_wallet_list(path)?,
        Command::Init { path } => init_wallet_cli(path)?,
        Command::Account {
            account_index,
            path,
        } => print_account_address(path, account_index)?,
        Command::Sign {
            id,
            account_index,
            path,
        } => sign_transaction_cli(&id, account_index, path)?,
        Command::Import { path } => import_wallet_cli(path)?,
        Command::Export {
            path,
            account_index,
        } => export_account_cli(path, account_index)?,
        Command::SignPrivate { tx_id } => sign_transaction_with_private_key_cli(&tx_id)?,
    };
    Ok(())
}