thru-core 0.2.20

Shared implementation for the Thru CLI
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Error types for the Thru CLI

use thiserror::Error;

/// Main error type for the Thru CLI
#[derive(Error, Debug)]
pub enum CliError {
    /// Configuration-related errors
    #[error("Configuration error: {0}")]
    Config(#[from] ConfigError),

    /// RPC client errors
    #[error("RPC error: {0}")]
    Rpc(String),

    /// Transport-level errors
    #[error("Transport error: {0}")]
    Transport(String),

    /// Validation errors
    #[error("Validation error: {0}")]
    Validation(String),

    /// I/O errors
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    /// Cryptographic errors
    #[error("Crypto error: {0}")]
    Crypto(String),

    /// Upload errors
    #[error("Upload error: {0}")]
    ProgramUpload(String),

    /// Uploader cleanup errors
    #[error("Uploader cleanup error: {0}")]
    ProgramCleanup(String),

    /// Transaction submission errors
    #[error("Transaction submission error: {0}")]
    TransactionSubmission(String),

    /// Transaction failed with execution issues but was submitted
    #[error("{message}")]
    TransactionFailed {
        message: String,
        execution_result: u64,
        vm_error: i32,
        vm_error_label: String,
        user_error_code: u64,
        user_error_label: String,
        signature: String,
    },

    /// Error already reported to user (used to avoid duplicate output)
    #[error("Error already reported to user")]
    Reported,

    /// Nonce management errors
    #[error("Nonce management error: {0}")]
    NonceManagement(String),

    /// Transaction verification errors
    #[error("Transaction verification error: {0}")]
    TransactionVerification(String),

    /// Resume validation errors
    #[error("Resume validation error: {0}")]
    ResumeValidation(String),

    /// Resume validation errors with account details
    #[error("Resume validation error: {message}")]
    ResumeValidationAccount {
        message: String,
        account: String,
        seed: String,
    },

    /// Account not found errors
    #[error("Account not found: {0}")]
    AccountNotFound(String),

    /// Hash mismatch errors
    #[error("Hash mismatch: {0}")]
    HashMismatch(String),

    /// Meta account closed errors
    #[error("Meta account closed: {0}")]
    #[allow(dead_code)]
    MetaAccountClosed(String),

    /// Generic error with context
    #[error("{message}")]
    Generic { message: String },
}

/// Configuration-specific errors
#[derive(Error, Debug)]
pub enum ConfigError {
    /// Config file not found
    // #[error("Config file not found at {path}. Run 'thru-cli init' to create a default config")]
    // NotFound { path: String },

    /// Invalid config format
    #[error("Invalid config format: {0}")]
    InvalidFormat(#[from] serde_yaml::Error),

    /// Invalid private key
    #[error("Invalid private key: {0}")]
    InvalidPrivateKey(String),

    /// Invalid public key
    #[error("Invalid public key: {0}")]
    InvalidPublicKey(String),

    /// Invalid URL
    #[error("Invalid URL: {0}")]
    InvalidUrl(String),

    /// Directory creation failed
    #[error("Failed to create config directory: {0}")]
    DirectoryCreation(std::io::Error),
}

impl From<anyhow::Error> for CliError {
    fn from(err: anyhow::Error) -> Self {
        CliError::Generic {
            message: err.to_string(),
        }
    }
}

impl From<tonic::Status> for CliError {
    fn from(status: tonic::Status) -> Self {
        CliError::Rpc(status.to_string())
    }
}

impl From<tonic::transport::Error> for CliError {
    fn from(err: tonic::transport::Error) -> Self {
        CliError::Transport(err.to_string())
    }
}

impl From<thru_client::ClientError> for CliError {
    fn from(err: thru_client::ClientError) -> Self {
        match err {
            thru_client::ClientError::Rpc(msg) => CliError::Rpc(msg),
            thru_client::ClientError::Transport(msg) => CliError::Transport(msg),
            thru_client::ClientError::Validation(msg) => CliError::Validation(msg),
            thru_client::ClientError::TransactionSubmission(msg) => {
                CliError::TransactionSubmission(msg)
            }
            thru_client::ClientError::TransactionVerification(msg) => {
                CliError::TransactionVerification(msg)
            }
            thru_client::ClientError::AccountNotFound(msg) => CliError::AccountNotFound(msg),
            thru_client::ClientError::Generic { message } => CliError::Generic { message },
        }
    }
}