Skip to main content
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);