Enum Confidence

pub enum Confidence<Value>
where
    Value: Portable,
{
    Safe(Value),
    Risky(Value),
    Unsafe(Value),
}

Confidence signal derived for a value evaluated by Finalized storage.

This enum represents the outcome of applying a FinalizedPolicy to an observed value, based on elapsed time and block-scoped observations.

It expresses a signal of stability, not on-chain finality and not a definitive statement of truth.

Variants

Safe(Value)

A strong confidence signal.

The value has:

• survived the configured finality time window, and
• been observed across enough distinct blocks.

This signal suggests that the value is likely stable and that irreversible or non-recoverable actions may be reasonable.

Risky(Value)

A weak confidence signal.

The value has survived the finality time window, but has not yet accumulated enough block-scoped observations.

This signal suggests that only optimistic or recoverable actions should be considered.

Unsafe(Value)

A negative confidence signal.

The value exists, but the finality time window has not elapsed yet.

This signal suggests that no action-reversible or irreversible- should be taken at this stage.

Trait Implementations

impl<Value> Clone for Confidence<Value>

where Value: Portable + Clone,

fn clone(&self) -> Confidence<Value>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Value> Debug for Confidence<Value>

where Value: Portable + Debug,

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

Formats the value using the given formatter.

impl<Value> Decode for Confidence<Value>

where Value: Portable + Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<Value> Encode for Confidence<Value>

where Value: Portable + Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<Value> PartialEq for Confidence<Value>

where Value: Portable + PartialEq,

fn eq(&self, other: &Confidence<Value>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Value> EncodeLike for Confidence<Value>

where Value: Portable + Encode,

impl<Value> Eq for Confidence<Value>

where Value: Portable + Eq,

impl<Value> StructuralPartialEq for Confidence<Value>

where Value: Portable,