rialo-types 0.11.1

Rialo Types
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

// Copyright (c) Subzero Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

use borsh::{BorshDeserialize, BorshSerialize};
use serde::{Deserialize, Serialize};
use thiserror::Error;

use crate::HeadersError;

/// Represents errors that can occur during REX processing.
#[derive(
    Clone, Debug, Eq, Error, PartialEq, Serialize, Deserialize, BorshSerialize, BorshDeserialize,
)]
pub enum RexError {
    #[error("Missing required parameter: {param}")]
    MissingParameter { param: String },

    #[error("Invalid parameter '{param}': {reason}")]
    InvalidParameter { param: String, reason: String },

    #[error("Failed to decode {encoding} for parameter '{param}': {reason}")]
    DecodeError {
        param: String,
        encoding: String,
        reason: String,
    },

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

    #[error("URL validation failed: {reason}")]
    UrlValidationError { reason: String },

    #[error("HTTP request failed: {message}{}", reason.as_ref().map(|r| format!(", {}", r)).unwrap_or_default()
    )]
    HttpRequestFailed {
        message: String,
        reason: Option<String>,
    },

    #[error("HTTP {status} error: {reason}")]
    HttpStatusError { status: u16, reason: String },

    #[error("Response size exceeds maximum of {max_size} bytes")]
    ResponseTooLarge { max_size: usize },

    #[error("Request body size of {size} bytes exceeds maximum of {max_size} bytes")]
    RequestBodyTooLarge { size: usize, max_size: usize },

    #[error("Filter error: {reason}")]
    FilterError { reason: String },

    #[error("Timeout after {duration_ms}ms")]
    Timeout { duration_ms: u64 },

    #[error("All {attempts} retry attempts failed: {reason}")]
    RetriesExhausted { attempts: u8, reason: String },

    #[error("JSON parsing error: {reason}")]
    JsonError { reason: String },

    #[error("No valid data sources available")]
    NoDataSources,

    #[error("Failed to decrypt secret payload: {reason}")]
    SecretDecryptionFailed { reason: String },

    #[error("Invalid secret payload format: {reason}")]
    InvalidSecretPayload { reason: String },

    #[error("Provided REX output size is too small: {provided}")]
    RexOutputSizeTooSmall { provided: usize },

    #[error("Invalid REX duty input, err: {0}")]
    InvalidRexDutyInput(String),

    #[error("Connection error: {reason}")]
    ConnectionError { reason: String },

    #[error("WebSocket error: {message}")]
    WebSocketError { message: String },

    // DKG-specific errors
    #[error("DKG input validation failed: {reason}")]
    DkgValidationError { reason: String },

    #[error("DKG cryptographic operation failed ({operation}): {reason}")]
    DkgCryptoError { operation: String, reason: String },

    #[error("DKG handler not implemented: {handler}")]
    DkgNotImplemented { handler: String },

    #[error("DKG genesis failed: {reason}")]
    DkgGenesisError { reason: String },

    #[error("DKG share installation failed: {reason}")]
    DkgInstallShareError { reason: String },

    #[error("DKG share decryption (HPKE) failed for dealer {dealer_index}: {reason}")]
    DkgDecryptionError { dealer_index: u16, reason: String },

    #[error("DKG share verification failed for dealer {dealer_index}")]
    DkgVerificationError { dealer_index: u16 },

    #[error("DKG partial decryption failed: {reason}")]
    DkgPartialDecryptError { reason: String },

    #[error("DKG TPM sealing failed (fast-restart recovery unavailable): {reason}")]
    DkgSealingError { reason: String },

    #[error("DKG combine error: {reason}")]
    DkgCombineError { reason: String },

    #[error("DKG AEAD decryption failed: invalid ciphertext or authentication tag")]
    DkgAeadDecryptFailed,

    #[error("DKG key derivation (HKDF) failed")]
    DkgHkdfExpandFailed,

    #[error("DKG invalid key length")]
    DkgInvalidKeyLength,
    #[error("WASM execution error: {reason}")]
    WasmExecutionError { reason: String },
}

impl From<HeadersError> for RexError {
    fn from(err: HeadersError) -> Self {
        match err {
            HeadersError::DecodeError {
                param,
                encoding,
                reason,
            } => Self::DecodeError {
                param,
                encoding,
                reason,
            },
            HeadersError::JsonError { reason } => Self::JsonError { reason },
        }
    }
}