core::serde::Serde

A trait that allows for serializing and deserializing values of any type. The Serde trait defines two core operations:

• serialize: Converts a value into a sequence of felt252s
• deserialize: Reconstructs a value from a sequence of felt252s

Signature

pub trait Serde

Examples

Simple Types (u8, u16, u32, u64, u128)

Simple types are serialized into a single felt252:

let value: u8 = 42;
let mut output: Array = array![];
value.serialize(ref output);
assert!(output == array![42]); // Single value

Compound Types (u256)

Compound types may be serialized into multiple felt252 values:

let value: u256 = u256 { low: 1, high: 2 };
let mut output: Array = array![];
value.serialize(ref output);
assert!(output == array![1, 2]); // Two `felt252`s: low and high

Implementing Serde

Using the Derive Macro

In most cases, you can use the #[derive(Serde)] attribute to automatically generate the implementation for your type:

#[derive(Serde)]
struct Point {
    x: u32,
    y: u32
}

Manual Implementation

Should you need to customize the serialization behavior for a type in a way that derive does not support, you can implement the Serde yourself:

impl PointSerde of Serde {
    fn serialize(self: @Point, ref output: Array) {
        output.append((*self.x).into());
        output.append((*self.y).into());
    }

    fn deserialize(ref serialized: Span) -> Option {
        let x = (*serialized.pop_front()?).try_into()?;
        let y = (*serialized.pop_front()?).try_into()?;

        Some(Point { x, y })
    }
}

Trait functions

serialize

Serializes a value into a sequence of felt252s.

Signature

fn serialize(self: @T, ref output: Array)

Examples

let value: u256 = 1;
let mut serialized: Array = array![];
value.serialize(ref serialized);
assert!(serialized == array![1, 0]); // `serialized` contains the [low, high] parts of the
`u256` value 

deserialize

Deserializes a value from a sequence of felt252s. If the value cannot be deserialized, returns None.

Signature

fn deserialize(ref serialized: Span) -> Option

Examples

let mut serialized: Span = array![1, 0].span();
let value: u256 = Serde::deserialize(ref serialized).unwrap();
assert!(value == 1);