nklave-cosmos 0.1.0

Cosmos/CometBFT remote signer protocol (Tendermint PrivValidator) for Nklave
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

//! Error types for Cosmos protocol handling

use thiserror::Error;

/// Errors that can occur during Cosmos protocol handling
#[derive(Debug, Error)]
pub enum CosmosError {
    /// Chain ID mismatch
    #[error("Chain ID mismatch: expected '{expected}', got '{actual}'")]
    ChainIdMismatch { expected: String, actual: String },

    /// Validator not found for the given public key
    #[error("Validator not found: {pubkey_hex}")]
    ValidatorNotFound { pubkey_hex: String },

    /// Double signing attempt detected
    #[error("Double signing attempt at height {height}, round {round}")]
    DoubleSigning { height: i64, round: i32 },

    /// Invalid vote type
    #[error("Invalid vote type: {0}")]
    InvalidVoteType(i32),

    /// Invalid block ID
    #[error("Invalid block ID: {0}")]
    InvalidBlockId(String),

    /// Signing failed
    #[error("Signing failed: {0}")]
    SigningFailed(String),

    /// Missing required field
    #[error("Missing required field: {0}")]
    MissingField(&'static str),

    /// Server bind error
    #[error("Failed to bind server: {0}")]
    BindError(String),

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

    /// Service not available
    #[error("Service not available")]
    ServiceUnavailable,
}

impl From<CosmosError> for tonic::Status {
    fn from(err: CosmosError) -> Self {
        match err {
            CosmosError::ChainIdMismatch { .. } => {
                tonic::Status::invalid_argument(err.to_string())
            }
            CosmosError::ValidatorNotFound { .. } => {
                tonic::Status::not_found(err.to_string())
            }
            CosmosError::DoubleSigning { .. } => {
                tonic::Status::failed_precondition(err.to_string())
            }
            CosmosError::InvalidVoteType(_) | CosmosError::InvalidBlockId(_) => {
                tonic::Status::invalid_argument(err.to_string())
            }
            CosmosError::MissingField(_) => {
                tonic::Status::invalid_argument(err.to_string())
            }
            CosmosError::SigningFailed(_) => {
                tonic::Status::internal(err.to_string())
            }
            CosmosError::ServiceUnavailable => {
                tonic::Status::unavailable(err.to_string())
            }
            CosmosError::BindError(_) | CosmosError::Internal(_) => {
                tonic::Status::internal(err.to_string())
            }
        }
    }
}

/// Remote signer error codes (matching Tendermint's error codes)
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
pub enum RemoteSignerCode {
    /// Unknown error
    Unknown = 0,
    /// Double sign attempt
    DoubleSign = 1,
    /// Height regression (not used in our implementation)
    HeightRegression = 2,
    /// Not found
    NotFound = 3,
    /// Connection error
    Connection = 4,
    /// Not implemented
    NotImplemented = 5,
}

impl From<RemoteSignerCode> for i32 {
    fn from(code: RemoteSignerCode) -> Self {
        code as i32
    }
}