Implement `From` to convert abi type into `Vec<FieldElement>`

[glihm]

Currently, this is the way to serialize data into felts:

let m = MyData {
    name: felt!("0x1234").into(),
    class_hash: felt!("0x5555").into(),
};

let felts = MyData::cairo_serialize(&m);                                                                                                                                         

To improve the Rustiness of this, we may want to do:

let m = MyData {
    name: felt!("0x1234").into(),
    class_hash: felt!("0x5555").into(),
};

let felts = m.into();                                                                                                                                         

This issue aims at tracking the implementation (which should be possible) of such pattern.

[edisontim]

Hey would love to work on this :)

[edisontim]

I'm just going on a naive approach here, but would something like this fit this pattern?

pub trait IntoFelt {
    fn into_felts(self) -> Vec<Felt>;
}

impl<T: CairoSerde<RustType = T>> IntoFelt for T {
    fn into_felts(self) -> Vec<Felt> {
        T::cairo_serialize(&self)
    }
}

The problem with implementing the From trait directly is that we cannot implement From for Vec because of the orphan rule.

Another idea I had was making cairo_serialize
fn cairo_serialize(&self) -> Vec<Felt>;

[glihm]

Hum, the idea here would be to add this in the generated code for each type.
Doing so, you can implement From without any issue, without the orphan rule being an issue.

So for each struct/enum generated, being able to convert it from a Vec<Felt>.