miden-client-cli 0.16.1

The official command line client for interacting with the Miden network
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
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// Suppress false positive from miette+thiserror proc-macro interaction.
#![allow(unused_assignments)]

use std::error::Error;

use miden_client::account::{AccountId, AddressError};
use miden_client::keystore::KeyStoreError;
use miden_client::vm::typed::TypedError;
use miden_client::{
    AccountError,
    AccountIdError,
    AssetError,
    ClientError,
    CodeBuilderError,
    ErrorHint,
    NetworkIdError,
};
use miette::Diagnostic;
use thiserror::Error;

use crate::client_binary_name;
type SourceError = Box<dyn Error + Send + Sync>;

#[derive(Debug, Diagnostic, Error)]
pub enum CliError {
    #[error("account error: {1}")]
    #[diagnostic(code(cli::account_error))]
    Account(#[source] AccountError, String),
    #[error("account component error: {1}")]
    #[diagnostic(code(cli::account_error))]
    AccountComponentError(#[source] SourceError, String),
    #[error("account id error: {1}")]
    #[diagnostic(code(cli::accountid_error), help("Check the account ID format."))]
    AccountId(#[source] AccountIdError, String),
    #[error("address error: {1}")]
    #[diagnostic(code(cli::address_error), help("Check the address format."))]
    Address(#[source] AddressError, String),
    #[error("asset error")]
    #[diagnostic(code(cli::asset_error))]
    Asset(#[source] AssetError),
    #[error("client error")]
    #[diagnostic(code(cli::client_error))]
    Client {
        #[source]
        error: ClientError,
        #[help]
        help: Option<String>,
    },
    #[error("config error: {1}")]
    #[diagnostic(
        code(cli::config_error),
        help(
            "Check if the configuration file exists and is well-formed. If it does not exist, run `{} init` command to create it.",
            client_binary_name().display()
        )
    )]
    Config(#[source] SourceError, String),
    #[error("configuration file not found: {0}")]
    #[diagnostic(
        code(cli::config_not_found),
        help(
            "Run `{} init` command to create a configuration file.",
            client_binary_name().display()
        )
    )]
    ConfigNotFound(String),
    #[error("configuration file already exists: {0}")]
    #[diagnostic(
        code(cli::config_already_exists),
        help(
            "Edit the configuration file, or remove it with `{} clear-config{1}` \
            (this deletes the whole .miden directory, including the store and keystore).",
            client_binary_name().display(),
        )
    )]
    ConfigAlreadyExists(String, String),
    #[error("execute program error: {1}")]
    #[diagnostic(code(cli::execute_program_error))]
    Exec(#[source] SourceError, String),
    #[error("export error: {0}")]
    #[diagnostic(code(cli::export_error), help("Check the ID."))]
    Export(String),
    #[error("faucet error: {1}")]
    #[diagnostic(code(cli::faucet_error))]
    Faucet(#[source] SourceError, String),
    #[error("import error: {0}")]
    #[diagnostic(code(cli::import_error), help("Check the file name."))]
    Import(String),
    #[error("init data error: {1}")]
    #[diagnostic(code(cli::account_error))]
    InitDataError(#[source] SourceError, String),
    #[error("input error: {0}")]
    #[diagnostic(code(cli::input_error))]
    Input(String),
    #[error("io error")]
    #[diagnostic(code(cli::io_error))]
    IO(#[from] std::io::Error),
    #[error("internal error")]
    Internal(#[source] SourceError),
    #[error("keystore error")]
    #[diagnostic(code(cli::keystore_error))]
    KeyStore(#[source] KeyStoreError),
    #[error("missing flag: {0}")]
    #[diagnostic(code(cli::config_error), help("Check the configuration file format."))]
    MissingFlag(String),
    #[error("network id error")]
    NetworkIdError(#[from] NetworkIdError),
    #[error("client has not been synced yet")]
    #[diagnostic(
        code(cli::not_synced),
        help("Run `{} sync` first.", client_binary_name().display())
    )]
    NotSynced,
    #[error("invalid argument: {0}")]
    InvalidArgument(String),
    // Covers both directions of the typed path: encoding arguments and decoding results. The
    // inner error already states the whole problem, so it is shown in place of a wrapper message
    // rather than under one, where it would be printed twice.
    #[error(transparent)]
    #[diagnostic(code(cli::typed_error))]
    Typed(#[from] TypedError),
    #[error("parse error: {1}")]
    #[diagnostic(code(cli::parse_error), help("Check the inputs."))]
    Parse(#[source] SourceError, String),
    #[error("replay snapshot error")]
    #[diagnostic(code(cli::replay_snapshot_error))]
    ReplaySnapshot(#[source] SourceError),
    #[error("script builder error")]
    #[diagnostic(code(cli::script_builder_error))]
    CodeBuilder(#[from] CodeBuilderError),
    #[error("transaction error: {1}")]
    #[diagnostic(code(cli::transaction_error))]
    Transaction(#[source] SourceError, String),
    #[error("expected full account, but got partial account: {0}")]
    InvalidAccount(AccountId),
}

impl From<ClientError> for CliError {
    fn from(error: ClientError) -> Self {
        let help = Option::<ErrorHint>::from(&error).map(ErrorHint::into_help_message);
        CliError::Client { error, help }
    }
}