sp1-prover 6.0.2

The SP1 prover implementation
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

use anyhow::anyhow;
use slop_futures::pipeline::SubmitError;
use sp1_core_executor::ExecutionError;
use sp1_core_machine::utils::SP1CoreProverError;
use tonic::Code;

#[derive(Debug)]
pub enum TaskError {
    Retryable(anyhow::Error),
    Fatal(anyhow::Error),
    Execution(ExecutionError),
}

impl From<anyhow::Error> for TaskError {
    fn from(err: anyhow::Error) -> Self {
        if err.is::<reqwest::Error>() {
            Self::Retryable(err)
        } else if err.is::<tonic::Status>() {
            err.downcast::<tonic::Status>().unwrap().into()
        } else {
            Self::Fatal(err)
        }
    }
}

impl From<tonic::Status> for TaskError {
    fn from(err: tonic::Status) -> Self {
        match err.code() {
            Code::Internal
            | Code::Unavailable
            | Code::Unknown
            | Code::Cancelled
            | Code::DeadlineExceeded
            | Code::ResourceExhausted
            | Code::Aborted
            | Code::DataLoss => Self::Retryable(err.into()),
            _ => Self::Fatal(err.into()),
        }
    }
}

impl From<SP1CoreProverError> for TaskError {
    fn from(err: SP1CoreProverError) -> Self {
        Self::Fatal(err.into())
    }
}

impl From<ExecutionError> for TaskError {
    fn from(err: ExecutionError) -> Self {
        Self::Execution(err)
    }
}

impl From<eyre::Report> for TaskError {
    fn from(err: eyre::Report) -> Self {
        Self::Fatal(anyhow!(Box::new(err)))
    }
}

impl From<SubmitError> for TaskError {
    fn from(err: SubmitError) -> Self {
        Self::Fatal(anyhow!(err))
    }
}

impl std::error::Error for TaskError {
    fn description(&self) -> &str {
        match self {
            TaskError::Retryable(_) => "Retryable",
            TaskError::Fatal(_) => "Fatal",
            TaskError::Execution(_) => "Execution",
        }
    }
}

impl std::fmt::Display for TaskError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            TaskError::Retryable(err) => write!(f, "Retryable: {}", err),
            TaskError::Fatal(err) => write!(f, "Fatal: {}", err),
            TaskError::Execution(err) => write!(f, "Execution: {}", err),
        }
    }
}