Enum StaleNodeError 

pub enum StaleNodeError {
    Height {
        expected_height: u64,
        received_height: u64,
        tolerance_blocks: u64,
    },
    Time {
        expected_timestamp_ms: u64,
        received_timestamp_ms: u64,
        tolerance_ms: u64,
    },
    Epoch {
        hinted_epoch: EpochIndex,
        proven_epoch: EpochIndex,
    },
    ProtocolVersion {
        expected_protocol_version: u32,
        received_protocol_version: u32,
    },
    BehindProtocolUpgrade {
        required: u32,
        signed: u32,
    },
}

Server returned stale metadata

Variants

Height

Server returned metadata with outdated height

Fields

expected_height: u64

Expected height - last block height seen by the Sdk

received_height: u64

Block height received from the server

tolerance_blocks: u64

Tolerance - how many blocks can be behind the expected height

Time

Server returned metadata with time outside of the tolerance

Fields

expected_timestamp_ms: u64

Expected time in milliseconds - is local time when the message was received

received_timestamp_ms: u64

Time received from the server in the message, in milliseconds

tolerance_ms: u64

Tolerance in milliseconds

Epoch

Server kept reporting a current epoch that its own proofs contradict

The epoch index in response metadata is not covered by the quorum signature, so ExtendedEpochInfo::fetch_current only uses it to shape a proved query and then checks it against the proof. This error means the check kept failing: every proof showed a newer epoch already started.

Fields

hinted_epoch: EpochIndex

Epoch index the server reported as current in unsigned response metadata

proven_epoch: EpochIndex

Newer epoch index that the server’s own proof showed as already started

ProtocolVersion

Server answered a document query at an older protocol version than the SDK’s, and no verified answer has yet shown the network running the SDK’s version

A document query answer is not verified with the rules of another protocol version than the one that signed it. The SDK may be set ahead of its network, where every node answers this way, so the node is not banned: the request moves to another node. A request whose every attempt ends with this error fails with Error::Config instead, also when no node is left to ask.

Fields

expected_protocol_version: u32

Protocol version the SDK verifies the query with

received_protocol_version: u32

Protocol version named in the server’s response metadata

BehindProtocolUpgrade

Server answered a request that needs a newer protocol version with a response signed at an older one: it is behind the network’s protocol upgrade.

Such a request is sent only once a verified answer has shown the network running required, so unlike StaleNodeError::ProtocolVersion the node is at fault: it is banned, and the request moves to another node.

Fields

required: u32

Protocol version from which every node serves the request

signed: u32

Protocol version in the response metadata

Trait Implementations

impl Debug for StaleNodeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for StaleNodeError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for StaleNodeError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<StaleNodeError> for Error

fn from(source: StaleNodeError) -> Self

Converts to this type from the input type.