Enum tendermint_light_client::errors::ErrorKind[−][src]

pub enum ErrorKind {
    Io(IoError),
    Store,
    NoPrimary,
    NoWitnesses,
    NoWitnessLeft,
    ForkDetected(Vec<PeerId>),
    NoInitialTrustedState,
    NoTrustedState(Status),
    TargetLowerThanTrustedState {
        target_height: Height,
        trusted_height: Height,
    },
    TrustedStateOutsideTrustingPeriod {
        trusted_state: Box<LightBlock>,
        options: Options,
    },
    BisectionFailed(Height, Height),
    InvalidLightBlock(VerificationError),
    InvalidAdjacentHeaders {
        h1: Hash,
        h2: Hash,
    },
    MissingLastBlockId(Height),
    ChannelDisconnected,
}

The various error kinds raised by this library

Variants

Io(IoError)

I/O error

Store

Store error

NoPrimary

No primary

NoWitnesses

No witnesses

NoWitnessLeft

No witness left

ForkDetected(Vec<PeerId>)

A fork has been detected between some peers

NoInitialTrustedState

No initial trusted state

NoTrustedState(Status)

No trusted state

TargetLowerThanTrustedState

Target height for the light client lower than latest trusted state height

Fields of TargetLowerThanTrustedState

target_height: Height

Target height

trusted_height: Height

Latest trusted state height

TrustedStateOutsideTrustingPeriod

The trusted state is outside of the trusting period

Fields of TrustedStateOutsideTrustingPeriod

trusted_state: Box<LightBlock>

Trusted state

options: Options

Light client options

BisectionFailed(Height, Height)

Bisection failed when reached trusted state

InvalidLightBlock(VerificationError)

Verification failed for a light block

InvalidAdjacentHeaders

Hash mismatch between two adjacent headers

Fields of InvalidAdjacentHeaders

h1: Hash

Hash #1

h2: Hash

Hash #2

MissingLastBlockId(Height)

Missing last_block_id field for header at given height

ChannelDisconnected

Internal channel disconnected

Implementations

`impl ErrorKind`[src]

`pub fn context(self, source: impl Into<BoxError>) -> Context<Self>`[src]

Add additional context (i.e. include a source error and capture a backtrace). You can convert the resulting Context into an Error by calling .into().

Trait Implementations

`impl Clone for ErrorKind`[src]

`fn clone(&self) -> ErrorKind`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Debug for ErrorKind`[src]

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

`impl<'de> Deserialize<'de> for ErrorKind`[src]

`fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where __D: Deserializer<'de>,` [src]

`impl Display for ErrorKind`[src]

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

`impl Error for ErrorKind`[src]

`fn source(&self) -> Option<&(dyn Error + 'static)>`[src]

`pub fn backtrace(&self) -> Option<&Backtrace>`[src]

`pub fn description(&self) -> &str`1.0.0[src]

`pub fn cause(&self) -> Option<&dyn Error>`1.0.0[src]

`impl ErrorExt for ErrorKind`[src]

`fn not_enough_trust(&self) -> bool`[src]

`fn has_expired(&self) -> bool`[src]

`fn is_timeout(&self) -> bool`[src]

Whether this error means that a timeout occured when querying a node.

`impl From<IoError> for ErrorKind`[src]

`fn from(source: IoError) -> Self`[src]

`impl From<RecvError> for ErrorKind`[src]

`fn from(_err: RecvError) -> Self`[src]

`impl<T: Debug + Send + Sync + 'static> From<SendError<T>> for ErrorKind`[src]

`fn from(_err: SendError<T>) -> Self`[src]

`impl PartialEq<ErrorKind> for ErrorKind`[src]

`fn eq(&self, other: &ErrorKind) -> bool`[src]

`fn ne(&self, other: &ErrorKind) -> bool`[src]

`impl Serialize for ErrorKind`[src]

`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,` [src]

`impl StructuralPartialEq for ErrorKind`[src]

Auto Trait Implementations

`impl RefUnwindSafe for ErrorKind`[src]

`impl Send for ErrorKind`[src]

`impl Sync for ErrorKind`[src]

`impl Unpin for ErrorKind`[src]

`impl UnwindSafe for ErrorKind`[src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de>,` [src]

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T> Instrument for T`[src]

`pub fn instrument(self, span: Span) -> Instrumented<Self>`[src]

`pub fn in_current_span(self) -> Instrumented<Self>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, T: 'a, R: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Pointable for T`

`pub const ALIGN: usize`

`type Init = T`

The type for initializers.

`pub unsafe fn init(init: <T as Pointable>::Init) -> usize`

`pub unsafe fn deref<'a>(ptr: usize) -> &'a T`

`pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T`

`pub unsafe fn drop(ptr: usize)`

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`pub default fn to_string(&self) -> String`[src]

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

Enum tendermint_light_client::errors::ErrorKind[−][src]

Variants

Fields of TargetLowerThanTrustedState

Fields of TrustedStateOutsideTrustingPeriod

Fields of InvalidAdjacentHeaders

Implementations

impl ErrorKind[src]

pub fn context(self, source: impl Into<BoxError>) -> Context<Self>[src]

Trait Implementations

impl Clone for ErrorKind[src]

fn clone(&self) -> ErrorKind[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl Debug for ErrorKind[src]

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

impl<'de> Deserialize<'de> for ErrorKind[src]

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where __D: Deserializer<'de>, [src]

impl Display for ErrorKind[src]

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

impl Error for ErrorKind[src]

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

pub fn backtrace(&self) -> Option<&Backtrace>[src]

pub fn description(&self) -> &str1.0.0[src]

pub fn cause(&self) -> Option<&dyn Error>1.0.0[src]

impl ErrorExt for ErrorKind[src]

fn not_enough_trust(&self) -> bool[src]

fn has_expired(&self) -> bool[src]

fn is_timeout(&self) -> bool[src]

impl From<IoError> for ErrorKind[src]

fn from(source: IoError) -> Self[src]

impl From<RecvError> for ErrorKind[src]

fn from(_err: RecvError) -> Self[src]

impl<T: Debug + Send + Sync + 'static> From<SendError<T>> for ErrorKind[src]

fn from(_err: SendError<T>) -> Self[src]

impl PartialEq<ErrorKind> for ErrorKind[src]

fn eq(&self, other: &ErrorKind) -> bool[src]

fn ne(&self, other: &ErrorKind) -> bool[src]

impl Serialize for ErrorKind[src]

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where __S: Serializer, [src]

impl StructuralPartialEq for ErrorKind[src]

Auto Trait Implementations

impl RefUnwindSafe for ErrorKind[src]

impl Send for ErrorKind[src]

impl Sync for ErrorKind[src]

impl Unpin for ErrorKind[src]

impl UnwindSafe for ErrorKind[src]

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de>, [src]

impl<T> FmtForward for T

pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T> Instrument for T[src]

pub fn instrument(self, span: Span) -> Instrumented<Self>[src]

pub fn in_current_span(self) -> Instrumented<Self>[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T> Pipe for T

pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

impl<T> PipeAsRef for T

pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,

pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: AsMut<T>, T: 'a, R: 'a,

impl<T> PipeBorrow for T

pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,

pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,

impl<T> PipeDeref for T