187 lines
4.5 KiB
Rust
187 lines
4.5 KiB
Rust
pub use reqwest;
|
|
use {
|
|
crate::{request, response},
|
|
solana_sdk::{
|
|
signature::SignerError, transaction::TransactionError, transport::TransportError,
|
|
},
|
|
std::io,
|
|
thiserror::Error as ThisError,
|
|
};
|
|
|
|
#[derive(ThisError, Debug)]
|
|
pub enum ErrorKind {
|
|
#[error(transparent)]
|
|
Io(#[from] io::Error),
|
|
#[error(transparent)]
|
|
Reqwest(#[from] reqwest::Error),
|
|
#[error(transparent)]
|
|
RpcError(#[from] request::RpcError),
|
|
#[error(transparent)]
|
|
SerdeJson(#[from] serde_json::error::Error),
|
|
#[error(transparent)]
|
|
SigningError(#[from] SignerError),
|
|
#[error(transparent)]
|
|
TransactionError(#[from] TransactionError),
|
|
#[error("Custom: {0}")]
|
|
Custom(String),
|
|
}
|
|
|
|
impl ErrorKind {
|
|
pub fn get_transaction_error(&self) -> Option<TransactionError> {
|
|
match self {
|
|
Self::RpcError(request::RpcError::RpcResponseError {
|
|
data:
|
|
request::RpcResponseErrorData::SendTransactionPreflightFailure(
|
|
response::RpcSimulateTransactionResult {
|
|
err: Some(tx_err), ..
|
|
},
|
|
),
|
|
..
|
|
}) => Some(tx_err.clone()),
|
|
Self::TransactionError(tx_err) => Some(tx_err.clone()),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TransportError> for ErrorKind {
|
|
fn from(err: TransportError) -> Self {
|
|
match err {
|
|
TransportError::IoError(err) => Self::Io(err),
|
|
TransportError::TransactionError(err) => Self::TransactionError(err),
|
|
TransportError::Custom(err) => Self::Custom(err),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<ErrorKind> for TransportError {
|
|
fn from(client_error_kind: ErrorKind) -> Self {
|
|
match client_error_kind {
|
|
ErrorKind::Io(err) => Self::IoError(err),
|
|
ErrorKind::TransactionError(err) => Self::TransactionError(err),
|
|
ErrorKind::Reqwest(err) => Self::Custom(format!("{:?}", err)),
|
|
ErrorKind::RpcError(err) => Self::Custom(format!("{:?}", err)),
|
|
ErrorKind::SerdeJson(err) => Self::Custom(format!("{:?}", err)),
|
|
ErrorKind::SigningError(err) => Self::Custom(format!("{:?}", err)),
|
|
ErrorKind::Custom(err) => Self::Custom(format!("{:?}", err)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(ThisError, Debug)]
|
|
#[error("{kind}")]
|
|
pub struct Error {
|
|
pub request: Option<request::RpcRequest>,
|
|
|
|
#[source]
|
|
pub kind: ErrorKind,
|
|
}
|
|
|
|
impl Error {
|
|
pub fn new_with_request(kind: ErrorKind, request: request::RpcRequest) -> Self {
|
|
Self {
|
|
request: Some(request),
|
|
kind,
|
|
}
|
|
}
|
|
|
|
pub fn into_with_request(self, request: request::RpcRequest) -> Self {
|
|
Self {
|
|
request: Some(request),
|
|
..self
|
|
}
|
|
}
|
|
|
|
pub fn request(&self) -> Option<&request::RpcRequest> {
|
|
self.request.as_ref()
|
|
}
|
|
|
|
pub fn kind(&self) -> &ErrorKind {
|
|
&self.kind
|
|
}
|
|
|
|
pub fn get_transaction_error(&self) -> Option<TransactionError> {
|
|
self.kind.get_transaction_error()
|
|
}
|
|
}
|
|
|
|
impl From<ErrorKind> for Error {
|
|
fn from(kind: ErrorKind) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TransportError> for Error {
|
|
fn from(err: TransportError) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Error> for TransportError {
|
|
fn from(client_error: Error) -> Self {
|
|
client_error.kind.into()
|
|
}
|
|
}
|
|
|
|
impl From<std::io::Error> for Error {
|
|
fn from(err: std::io::Error) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<reqwest::Error> for Error {
|
|
fn from(err: reqwest::Error) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<request::RpcError> for Error {
|
|
fn from(err: request::RpcError) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<serde_json::error::Error> for Error {
|
|
fn from(err: serde_json::error::Error) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<SignerError> for Error {
|
|
fn from(err: SignerError) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TransactionError> for Error {
|
|
fn from(err: TransactionError) -> Self {
|
|
Self {
|
|
request: None,
|
|
kind: err.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|