newton-aggregator 0.4.18

newton prover aggregator utils 
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

use alloy::{
    contract::Error as ContractError,
    transports::{RpcError, TransportErrorKind},
};
use eigensdk::{
    client_avsregistry::error::AvsRegistryError, crypto_bls::error::BlsError,
    services_blsaggregation::bls_aggregation_service_error::BlsAggregationServiceError as EigensdkBlsAggregationServiceError,
    services_operatorsinfo::operatorsinfo_inmemory::OperatorInfoServiceError,
};
use newton_chainio::{bls::BlsAggregationServiceError, error::ChainIoError};
use newton_core::config::error::ConfigError;
use serde_json::Error;
use thiserror::Error;

/// Error returned by chainio
#[derive(Debug, Error)]
pub enum AggregatorError {
    /// Key error
    #[error("Key error: {0}")]
    KeyError(String),

    /// Bls Aggregation Service Error
    #[error("Bls Aggregation Service Error : {0}")]
    BlsAggregationServiceError(#[from] EigensdkBlsAggregationServiceError),
    /// Task Response not found
    #[error("Task Response not found")]
    TaskResponseNotFound,
    /// parse error
    #[error("Config parse error")]
    ParseError(#[from] ConfigError),
    /// Build avs registry chain reader
    #[error("Failed to build avs registry chain reader ")]
    BuildAvsRegistryChainReader(#[from] AvsRegistryError),

    /// build avswriter
    #[error("Failed to build avs wrtier in chain io ")]
    BuildAvsWriter(#[from] ChainIoError),

    /// Bls crate error
    #[error("Bls Crate Error SDK")]
    Bls(#[from] BlsError),

    /// alloy rpc error
    #[error("Alloy rpc error")]
    AlloyRpc(#[from] RpcError<TransportErrorKind>),

    /// serde json error
    #[error("Serde json error")]
    SerdeError(#[from] Error),

    /// IO error
    #[error("IO error")]
    IOError(#[from] std::io::Error),

    /// Operator Info service error
    #[error("Operator Info Service error")]
    OperatorInfoServiceError(#[from] OperatorInfoServiceError),

    /// Alloy Contract Error
    #[error("Alloy Contract Error")]
    ContractError(#[from] ContractError),

    /// Invalid Bls Key
    #[error("Invalid Bls Key")]
    InvalidBlsKey(String),

    /// Send aggregated response error
    #[error("Send aggregated response error")]
    SendAggregatedResponseError,
}

/// Error returned by AggregatorCore operations
#[derive(Debug, Error)]
pub enum AggregatorCoreError {
    /// Invalid timeout duration (zero or negative)
    #[error("Invalid timeout duration: {0}")]
    InvalidTimeoutDuration(String),

    /// Aggregation service error
    #[error("Aggregation service error: {0}")]
    AggregationServiceError(#[from] BlsAggregationServiceError),

    /// Timeout waiting for aggregation
    #[error("Timeout waiting for aggregation after {duration_ms} ms (timeout: {timeout_ms} ms)")]
    Timeout {
        /// Duration elapsed before timeout
        duration_ms: u128,
        /// Configured timeout duration
        timeout_ms: u128,
        /// Operator errors (if any)
        operator_errors: Option<Vec<crate::rpc_server::OperatorErrorResponse>>,
    },

    /// Task not initialized
    #[error("Task {task_id} not initialized - call initialize_task first")]
    TaskNotInitialized {
        /// The task ID that was not initialized
        task_id: newton_core::TaskId,
    },

    /// Operation was cancelled
    #[error("Operation cancelled")]
    Cancelled,
}