rain_metadata/error/
mod.rs

1use std::{string::FromUtf8Error, str::Utf8Error};
2
3/// Covers all errors variants of Rain Metadat lib functionalities
4#[derive(Debug)]
5pub enum Error {
6    CorruptMeta,
7    InvalidHash,
8    UnknownMeta,
9    UnknownMagic,
10    NoRecordFound,
11    UnsupportedMeta,
12    BiggerThan32Bytes,
13    UnsupportedNetwork,
14    InflateError(String),
15    Utf8Error(Utf8Error),
16    FromUtf8Error(FromUtf8Error),
17    ReqwestError(reqwest::Error),
18    SerdeCborError(serde_cbor::Error),
19    SerdeJsonError(serde_json::Error),
20    AbiCoderError(alloy_sol_types::Error),
21    ValidationErrors(validator::ValidationErrors),
22    DecodeHexStringError(alloy_primitives::hex::FromHexError),
23}
24
25impl std::fmt::Display for Error {
26    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27        match self {
28            Error::CorruptMeta => f.write_str("corrupt meta"),
29            Error::UnknownMeta => f.write_str("unknown meta"),
30            Error::UnknownMagic => f.write_str("unknown magic"),
31            Error::UnsupportedMeta => f.write_str("unsupported meta"),
32            Error::InvalidHash => f.write_str("invalid keccak256 hash"),
33            Error::NoRecordFound => f.write_str("found no matching record"),
34            Error::UnsupportedNetwork => {
35                f.write_str("no rain subgraph is deployed for this network")
36            }
37            Error::BiggerThan32Bytes => {
38                f.write_str("unexpected input size, must be 32 bytes or less")
39            }
40            Error::ReqwestError(v) => write!(f, "{}", v),
41            Error::InflateError(v) => write!(f, "{}", v),
42            Error::Utf8Error(v) => write!(f, "{}", v),
43            Error::AbiCoderError(v) => write!(f, "{}", v),
44            Error::SerdeCborError(v) => write!(f, "{}", v),
45            Error::SerdeJsonError(v) => write!(f, "{}", v),
46            Error::FromUtf8Error(v) => write!(f, "{}", v),
47            Error::DecodeHexStringError(v) => write!(f, "{}", v),
48            Error::ValidationErrors(v) => write!(f, "{}", v),
49        }
50    }
51}
52
53impl std::error::Error for Error {}
54
55impl From<serde_json::Error> for Error {
56    fn from(value: serde_json::Error) -> Self {
57        Error::SerdeJsonError(value)
58    }
59}
60
61impl From<serde_cbor::Error> for Error {
62    fn from(value: serde_cbor::Error) -> Self {
63        Error::SerdeCborError(value)
64    }
65}
66
67impl From<FromUtf8Error> for Error {
68    fn from(value: FromUtf8Error) -> Self {
69        Error::FromUtf8Error(value)
70    }
71}
72
73impl From<Utf8Error> for Error {
74    fn from(value: Utf8Error) -> Self {
75        Error::Utf8Error(value)
76    }
77}
78
79impl From<validator::ValidationErrors> for Error {
80    fn from(value: validator::ValidationErrors) -> Self {
81        Error::ValidationErrors(value)
82    }
83}
84
85impl From<alloy_sol_types::Error> for Error {
86    fn from(value: alloy_sol_types::Error) -> Self {
87        Error::AbiCoderError(value)
88    }
89}