forked from ghostchain/ghost-node
97 lines
3.6 KiB
Rust
97 lines
3.6 KiB
Rust
use crate::ExternalBlockNumber;
|
|
|
|
pub enum WeavingError<NetworkId> {
|
|
DeadlineReached,
|
|
NoStoredNetworks,
|
|
UnparsableRequestBody,
|
|
UnknownWeavingPhase(NetworkId),
|
|
OffchainLockPeriod(NetworkId),
|
|
NoEndpointsAvailable(NetworkId),
|
|
ContradictoryHashes(NetworkId),
|
|
ContradictoryBlocks(u32, ExternalBlockNumber, NetworkId),
|
|
}
|
|
|
|
impl<NetworkId: core::fmt::Debug> core::fmt::Debug for WeavingError<NetworkId> {
|
|
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
match self {
|
|
Self::NoStoredNetworks => write!(fmt, "No stored networks to be watch on."),
|
|
Self::UnparsableRequestBody => {
|
|
write!(fmt, "HTTP request body contains invalid UTF-8 sequences.")
|
|
}
|
|
Self::DeadlineReached => {
|
|
write!(fmt, "The request deadline or network timeout was hit.")
|
|
}
|
|
Self::UnknownWeavingPhase(network_id) => {
|
|
write!(fmt, "Unknown weaving phase for network: {:?}.", network_id)
|
|
}
|
|
Self::OffchainLockPeriod(network_id) => write!(
|
|
fmt,
|
|
"Storage lock is still held for network: {:?}.",
|
|
network_id
|
|
),
|
|
Self::NoEndpointsAvailable(network_id) => write!(
|
|
fmt,
|
|
"Zero RPC URLs configured for network: {:?}.",
|
|
network_id
|
|
),
|
|
Self::ContradictoryHashes(network_id) => write!(
|
|
fmt,
|
|
"Divergence among reported hashes for network: {:?}.",
|
|
network_id
|
|
),
|
|
Self::ContradictoryBlocks(len, deviation, network_id) => {
|
|
write!(fmt, "Divergence among {len} reported blocks exceeds the maximum threshold of {deviation} provided for network: {:?}.", network_id)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum RpcResolverError {
|
|
JsonDeserializationFailed,
|
|
UnparsableResponseBody,
|
|
RpcEmptyResultField,
|
|
UnknownNetworkType,
|
|
InvalidResponseId,
|
|
RpcProtocolError,
|
|
DeadlineReached,
|
|
Non200HttpCode,
|
|
IoError,
|
|
Unknown,
|
|
}
|
|
|
|
impl core::fmt::Debug for RpcResolverError {
|
|
fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
match self {
|
|
Self::JsonDeserializationFailed => {
|
|
write!(fmt, "Failed to deserialize JSON payload into target type.")
|
|
}
|
|
Self::UnparsableResponseBody => {
|
|
write!(fmt, "HTTP response body contains invalid UTF-8 sequences.")
|
|
}
|
|
Self::RpcEmptyResultField => write!(
|
|
fmt,
|
|
"The 'result' field in the JSON-RPC response is missing or null."
|
|
),
|
|
Self::UnknownNetworkType => {
|
|
write!(fmt, "he provided network type identifier is not supported.")
|
|
}
|
|
Self::RpcProtocolError => write!(
|
|
fmt,
|
|
"The server returned a protocol-level JSON-RPC error block."
|
|
),
|
|
Self::IoError => write!(
|
|
fmt,
|
|
"An internal input/output or stream processing error occurred."
|
|
),
|
|
Self::Non200HttpCode => {
|
|
write!(fmt, "Server responded with a non-200 OK HTTP status code.")
|
|
}
|
|
Self::DeadlineReached => {
|
|
write!(fmt, "The request deadline or network timeout was hit.")
|
|
}
|
|
Self::InvalidResponseId => write!(fmt, "Response ID does not match request ID."),
|
|
Self::Unknown => write!(fmt, "An unclassified or generic error occurred."),
|
|
}
|
|
}
|
|
}
|