Struct PersistableRuntimeError

pub struct PersistableRuntimeError {
    pub schema_index: u32,
    pub encoded_error: RawValue<'static, ScryptoCustomExtension>,
}

Fields

schema_index: u32

encoded_error: RawValue<'static, ScryptoCustomExtension>

Trait Implementations

impl Categorize<ScryptoCustomValueKind> for PersistableRuntimeError

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Clone for PersistableRuntimeError

fn clone(&self) -> PersistableRuntimeError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> ContextualDisplay<ScryptoValueDisplayContext<'a>> for PersistableRuntimeError

This is used to render the error message, with a fallback if an invalid schema is associated with the error.

This fallback is necessary due to historic breakages of backwards compatibility in the RuntimeError type structure.

Specifically, at anemone / bottlenose, there were very minor changes, which affected a tiny minority of errors. If we could find the historic schemas, we could actually render them properly here. Unfortunately, the historic schemas are not easy to find out (it would require backporting the schema generation logic), so instead we just have a fallback for these cases.

This fallback will only be applied on nodes, when returning occasional errors for old transactions that haven’t resynced since Bottlenose.

type Error = Error

fn contextual_format<F>( &self, f: &mut F, context: &ScryptoValueDisplayContext<'_>, ) -> Result<(), <PersistableRuntimeError as ContextualDisplay<ScryptoValueDisplayContext<'a>>>::Error>

where F: Write,

Formats the value to the given fmt::Write buffer, making use of the provided context. See also format, which is typically easier to use, as it takes an Into<Context> instead of a &Context.

fn format<F, TContext>( &self, f: &mut F, context: TContext, ) -> Result<(), Self::Error>

where F: Write, TContext: Into<Context>,

Formats the value to the given fmt::Write buffer, making use of the provided context. See also contextual_format, which takes a &Context instead of an Into<Context>.

fn display<'a, 'b, TContext>( &'a self, context: TContext, ) -> ContextDisplayable<'a, Self, Context>

where TContext: Into<Context>,

Returns an object implementing fmt::Display, which can be used in a format! style macro.

fn to_string<'a, 'b, TContext>(&'a self, context: TContext) -> String

where TContext: Into<Context>,

impl Debug for PersistableRuntimeError

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

Formats the value using the given formatter.

impl<D> Decode<ScryptoCustomValueKind, D> for PersistableRuntimeError

where D: Decoder<ScryptoCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ScryptoCustomValueKind>, ) -> Result<PersistableRuntimeError, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for PersistableRuntimeError

const TYPE_ID: RustTypeId

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E> Encode<ScryptoCustomValueKind, E> for PersistableRuntimeError

where E: Encoder<ScryptoCustomValueKind>,

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl SborTuple<ScryptoCustomValueKind> for PersistableRuntimeError

fn get_length(&self) -> usize