Enum concordium_contracts_common::schema_json::JsonError

pub enum JsonError {
    FailedWriting,
    UnsignedIntRequired,
    SignedIntRequired,
    FailedParsingAccountAddress,
    WrongJsonType(String),
    FieldError(String),
    EnumError(String),
    MapError(String),
    PairError(String),
    ArrayError(String),
    ParseError(String),
    ByteArrayError(String),
    FromHexError(FromHexError),
    TryFromIntError(TryFromIntError),
    ParseIntError(ParseIntError),
    ParseDurationError(ParseDurationError),
    ParseTimestampError(ParseTimestampError),
    TraceError {
        field: String,
        json: Value,
        error: Box<JsonError>,
    },
}

Represents errors occurring while serializing data from the schema JSON format.

Examples

Simple type from invalid JSON value

let account_bytes = [0u8; ACCOUNT_ADDRESS_SIZE];
let account = AccountAddress(account_bytes.clone());
let schema = Type::AccountAddress;

// Malformed JSON value due to incorrect account address
let json = json!(format!("{}", &account).get(1..));
let err = schema.serial_value(&json).expect_err("Serializing should fail");

assert!(matches!(err, JsonError::FailedParsingAccountAddress))

Complex type from invalid JSON value

let account_bytes = [0u8; ACCOUNT_ADDRESS_SIZE];
let account = AccountAddress(account_bytes.clone());
let schema = Type::Struct(Fields::Named(vec![
   ("account".into(), Type::AccountAddress),
   ("contract".into(), Type::ContractAddress),
]));

// Malformed JSON value due to incorrect value for "contract" field
let json = json!({ "account": format!("{}", account), "contract": {} });
let err = schema.serial_value(&json).expect_err("Serializing should fail");

assert!(matches!(
   err,
   JsonError::TraceError {
       field,
       error,
       ..
   } if matches!(*error, JsonError::FieldError(_)) && field == "\"contract\""
));

Variants

FailedWriting

UnsignedIntRequired

SignedIntRequired

FailedParsingAccountAddress

WrongJsonType(String)

FieldError(String)

EnumError(String)

MapError(String)

PairError(String)

ArrayError(String)

ParseError(String)

ByteArrayError(String)

FromHexError(FromHexError)

TryFromIntError(TryFromIntError)

ParseIntError(ParseIntError)

ParseDurationError(ParseDurationError)

ParseTimestampError(ParseTimestampError)

TraceError

Fields

field: String

json: Value

error: Box<JsonError>

Trace leading to the original JsonError.

Implementations

impl JsonError

pub fn display(&self, verbose: bool) -> String

Returns a formatted error message for variant. JsonError::TraceError supports printing a verbose form including a more detailed description of the error stack, which is returned if verbose is set to true.

Examples

Display error from list of objects

let account_bytes = [0u8; ACCOUNT_ADDRESS_SIZE];
let account = AccountAddress(account_bytes);
let object_schema = Type::Struct(Fields::Named(vec![
   ("account".into(), Type::AccountAddress),
   ("contract".into(), Type::ContractAddress),
]));
let schema = Type::List(SizeLength::U8, Box::new(object_schema));

// Malformed JSON value due to incorrect value for "contract" field
let json = json!([{ "account": format!("{}", account), "contract": {} }]);
let err = schema.serial_value(&json).expect_err("Serializing should fail");

// The error format points to the cause of the error from the root of the JSON.
let expected = r#"0 -> "contract" -> 'index' is required in a Contract address"#.to_string();
assert_eq!(expected, err.display(false));

// Or if verbose, includes a stacktrace-like format.
let expected_verbose = r#"'index' is required in a Contract address
In "contract" of {
  "account": "2wkBET2rRgE8pahuaczxKbmv7ciehqsne57F9gtzf1PVdr2VP3",
  "contract": {}
}
In 0 of [
  {
    "account": "2wkBET2rRgE8pahuaczxKbmv7ciehqsne57F9gtzf1PVdr2VP3",
    "contract": {}
  }
]"#.to_string();
assert_eq!(expected_verbose, err.display(true));

pub fn get_error(&self) -> &Self

Gets the underlying error of a JsonError::TraceError. For any other variant, this simply returns the error itself.

Trait Implementations

impl Clone for JsonError

fn clone(&self) -> JsonError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JsonError

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

Formats the value using the given formatter.

impl Display for JsonError

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

Formats the value using the given formatter.

impl Error for JsonError

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, 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<FromHexError> for JsonError

fn from(source: FromHexError) -> Self

Converts to this type from the input type.

impl From<ParseDurationError> for JsonError

fn from(source: ParseDurationError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for JsonError

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.

impl From<ParseTimestampError> for JsonError

fn from(source: ParseTimestampError) -> Self

Converts to this type from the input type.

impl From<TryFromIntError> for JsonError

fn from(source: TryFromIntError) -> Self

Converts to this type from the input type.