Enum ic_response_verification::ResponseVerificationError

pub enum ResponseVerificationError {
    MalformedUrl(String),
    MalformedHashTree(String),
    MalformedCertificate(String),
    MissingTimePathInTree,
    IoError(Error),
    CertificateTimeTooFarInTheFuture {
        certificate_time: u128,
        max_certificate_time: u128,
    },
    CertificateTimeTooFarInThePast {
        certificate_time: u128,
        min_certificate_time: u128,
    },
    MalformedCbor(String),
    UnexpectedCborNodeType {
        node_name: String,
        expected_type: String,
        found_type: String,
    },
    IncorrectPrunedDataLength(TryFromSliceError),
    LebDecodingOverflow,
    Utf8ConversionError(FromUtf8Error),
    UnsupportedVerificationVersion {
        min_supported_version: u8,
        max_supported_version: u8,
        requested_version: u8,
    },
    RequestedVerificationVersionMismatch {
        min_requested_verification_version: u8,
        requested_version: u8,
    },
    CelError(CelParserError),
    DerKeyLengthMismatch {
        expected: usize,
        actual: usize,
    },
    DerPrefixMismatch {
        expected: Vec<u8>,
        actual: Vec<u8>,
    },
    CertificateVerificationFailed,
    CertificatePrincipalOutOfRange,
    CertificateSubnetPublicKeyNotFound,
    CertificateSubnetCanisterRangesNotFound,
    MalformedCborCanisterRanges,
    Base64DecodingError(DecodeError),
    ParseIntError(ParseIntError),
    InvalidTree,
    InvalidExpressionPath,
    InvalidResponseBody,
    InvalidResponseHashes,
    MissingCertificate,
    MissingTree,
    MissingCertificateExpressionPath,
    MissingCertificateExpression,
    MissingCertification,
}

The primary container for response verification errors

Variants

MalformedUrl(String)

The URL was malformed and could not be parsed correctly

MalformedHashTree(String)

The hash tree was malformed and could not be parsed correctly

MalformedCertificate(String)

The certificate was malformed and could not be parsed correctly

MissingTimePathInTree

The certificate was expected to have a “time” path, but it was missing

IoError(Error)

Error converting UTF-8 string

CertificateTimeTooFarInTheFuture

Fields

certificate_time: u128

The actual certificate time

max_certificate_time: u128

The maximum expected certificate time

The certificate’s time was too far in the future

CertificateTimeTooFarInThePast

Fields

certificate_time: u128

The actual certificate time

min_certificate_time: u128

The minimum expected certificate time

The certificate’s time was too far in the past

MalformedCbor(String)

The CBOR was malformed and could not be parsed correctly

UnexpectedCborNodeType

Fields

node_name: String

The name of the node with the incorrect type

expected_type: String

The expected type of the node

found_type: String

The actual type of the node

The Cbor parser expected a node of a certain type but found a different type

IncorrectPrunedDataLength(TryFromSliceError)

The hash tree pruned data was not the correct length

LebDecodingOverflow

Encountered an overflow error while decoding leb encoded timestamp

Utf8ConversionError(FromUtf8Error)

Error converting UTF-8 string

UnsupportedVerificationVersion

Fields

min_supported_version: u8

The minimum supported verification version

max_supported_version: u8

The maximum supported verification version

requested_version: u8

The actual requested verification version

An unsupported verification version was requested

RequestedVerificationVersionMismatch

Fields

min_requested_verification_version: u8

The minimum version that will be requested

requested_version: u8

The actual requested version

Mismatch between the minimum requested version and the actual requested version

CelError(CelParserError)

Error parsing CEL expression

DerKeyLengthMismatch

Fields

expected: usize

Expected size of the public key

actual: usize

Actual size of the public key

Unexpected public key length

DerPrefixMismatch

Fields

expected: Vec<u8>

Expected public key prefix

actual: Vec<u8>

Actual public key prefix

Unexpected public key prefix

CertificateVerificationFailed

Failed to verify the certificate

CertificatePrincipalOutOfRange

Certificate is for a different canister

CertificateSubnetPublicKeyNotFound

Certificate delegation is missing the required public key

CertificateSubnetCanisterRangesNotFound

Certificate delegation is missing the required canister range

MalformedCborCanisterRanges

Certificate delegation canister range was not correctly CBOR encoded

Base64DecodingError(DecodeError)

Error decoding base64

ParseIntError(ParseIntError)

Error parsing int

InvalidTree

The tree has different root hash from the expected value in the certified variables

InvalidExpressionPath

The CEL expression path is invalid

InvalidResponseBody

The response body was a mismatch from the expected values in the tree

InvalidResponseHashes

The response hashes were a mismatch from the expected values in the tree

MissingCertificate

The certificate was missing from the certification header

MissingTree

The tree was missing from the certification header

MissingCertificateExpressionPath

The certificate expression path was missing from the certification header

MissingCertificateExpression

The certificate expression was missing from the response headers

MissingCertification

The certification values could not be found in the response headers

Trait Implementations

impl Debug for ResponseVerificationError

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

Formats the value using the given formatter.

impl Display for ResponseVerificationError

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

Formats the value using the given formatter.

impl Error for ResponseVerificationError

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

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, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl From<CelParserError> for ResponseVerificationError

fn from(source: CelParserError) -> Self

Converts to this type from the input type.

impl From<DecodeError> for ResponseVerificationError

fn from(source: DecodeError) -> Self

Converts to this type from the input type.

impl From<Error> for ResponseVerificationError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for ResponseVerificationError

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for ResponseVerificationError

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.

impl From<TryFromSliceError> for ResponseVerificationError

fn from(source: TryFromSliceError) -> Self

Converts to this type from the input type.