Use custom derive ser/de instead of std::io

CHANGELOG.md

@@ -6,15 +6,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-### Changed
-
 #### Breaking
 
 - [#554](https://github.com/FuelLabs/fuel-vm/pull/554): Removed `debug` feature from the `fuel-vm`. The debugger is always available and becomes active after calling any `set_*` method.
 - [#537](https://github.com/FuelLabs/fuel-vm/pull/537): Use dependent cost for `k256`, `s256`, `mcpi`, `scwq`, `swwq` opcodes.
     These opcodes charged inadequately low costs in comparison to the amount of work.
     This change should make all transactions that used these opcodes much more expensive than before.
 
+- [#533](https://github.com/FuelLabs/fuel-vm/pull/533): Use custom serialization for fuel-types to allow no_std compilation.
+
 ## [Version 0.36.1]
 
 ### Changed

Cargo.toml

@@ -23,6 +23,7 @@ version = "0.36.1"
 [workspace.dependencies]
 fuel-asm = { version = "0.36.1", path = "fuel-asm", default-features = false }
 fuel-crypto = { version = "0.36.1", path = "fuel-crypto", default-features = false }
+fuel-derive = { version = "0.36.1", path = "fuel-derive", default-features = false }
 fuel-merkle = { version = "0.36.1", path = "fuel-merkle", default-features = false }
 fuel-storage = { version = "0.36.1", path = "fuel-storage", default-features = false }
 fuel-tx = { version = "0.36.1", path = "fuel-tx", default-features = false }

fuel-asm/Cargo.toml

@@ -13,6 +13,7 @@ description = "Atomic types of the FuelVM."
 [dependencies]
 arbitrary = { version = "1.1", features = ["derive"], optional = true }
 bitflags = "1.3"
+fuel-types = { workspace = true }
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 strum = { version = "0.24", default-features = false, features = ["derive"] }
 wasm-bindgen = { version = "0.2.87", optional = true }
@@ -26,7 +27,7 @@ rstest = "0.16"
 [features]
 default = ["std"]
 typescript = ["wasm-bindgen", "wee_alloc"]
-std = ["serde?/default"]
+std = ["serde?/default", "fuel-types/std"]
 serde = ["dep:serde"]
 
 # docs.rs-specific configuration

fuel-asm/src/panic_instruction.rs

@@ -10,6 +10,7 @@ use crate::{
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 /// Describe a panic reason with the instruction that generated it
 pub struct PanicInstruction {

fuel-asm/src/panic_reason.rs

@@ -26,6 +26,7 @@ enum_from! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumIter)]
     #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
     #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    #[derive(fuel_types::canonical::Serialize, fuel_types::canonical::Deserialize)]
     #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
     #[repr(u8)]
     #[non_exhaustive]

fuel-crypto/Cargo.toml

@@ -34,7 +34,7 @@ sha2 = "0.10"
 
 [features]
 default = ["fuel-types/default", "std"]
-alloc = ["rand?/alloc", "secp256k1/alloc"]
+alloc = ["rand?/alloc", "secp256k1/alloc", "fuel-types/alloc"]
 random = ["fuel-types/random", "rand"]
 serde = ["dep:serde", "fuel-types/serde"]
 # `rand-std` is used to further protect the blinders from side-channel attacks and won't compromise

fuel-derive/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "fuel-derive"
+version = { workspace = true }
+authors = { workspace = true }
+categories = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+keywords = ["blockchain", "cryptocurrencies", "fuel-vm", "vm"]
+license = { workspace = true }
+repository = { workspace = true }
+description = "FuelVM (de)serialization derive macros for `fuel-vm` data structures."
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1"
+syn = { version = "2", features = ["full"] }
+proc-macro2 = "1"
+synstructure = "0.13"

fuel-derive/README.md

@@ -0,0 +1,8 @@
+# Fuel VM custom serialization derive macros
+
+[![build](https://github.com/FuelLabs/fuel-vm/actions/workflows/ci.yml/badge.svg)](https://github.com/FuelLabs/fuel-vm/actions/workflows/ci.yml)
+[![crates.io](https://img.shields.io/crates/v/fuel-derive?label=latest)](https://crates.io/crates/fuel-derive)
+[![docs](https://docs.rs/fuel-derive/badge.svg)](https://docs.rs/fuel-derive/)
+[![discord](https://img.shields.io/badge/chat%20on-discord-orange?&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/xfpK4Pe)
+
+This crate contains derive macros for canonical serialization and deserialization. This is used with [`fuel-types/src/canonical.rs`](fuel-types/src/canonical.rs) module which contains the associated traits and their implementations for native Rust types.

fuel-derive/src/attribute.rs

@@ -0,0 +1,172 @@
+// TODO: nice error messages instead of panics, see: https://stackoverflow.com/a/54394014/2867076
+
+use std::collections::HashMap;
+
+use proc_macro2::{
+    TokenStream,
+    TokenTree,
+};
+use syn::{
+    AttrStyle,
+    Attribute,
+    Meta,
+};
+use synstructure::BindingInfo;
+
+fn parse_attrs(s: &synstructure::Structure) -> HashMap<String, TokenStream> {
+    let mut attrs = HashMap::new();
+
+    for attr in &s.ast().attrs {
+        if attr.style != AttrStyle::Outer {
+            continue
+        }
+        if let Meta::List(ml) = &attr.meta {
+            if ml.path.segments.len() == 1 && ml.path.segments[0].ident == "canonical" {
+                let mut tt = ml.tokens.clone().into_iter().peekable();
+                if let Some(key) = tt.next() {
+                    let key = key.to_string();
+                    if let Some(eq_sign) = tt.peek() {
+                        if eq_sign.to_string() == "=" {
+                            let _ = tt.next();
+                        }
+                    } else {
+                        // Single token, no `=`, so it's a boolean flag.
+                        let old = attrs.insert(key.clone(), TokenStream::new());
+                        if old.is_some() {
+                            panic!("duplicate canonical attribute: {}", key);
+                        }
+                        continue
+                    }
+
+                    // Key-value pair
+                    let value = TokenStream::from_iter(tt);
+                    let old = attrs.insert(key.clone(), value);
+                    if old.is_some() {
+                        panic!("duplicate canonical attribute: {}", key);
+                    }
+                    continue
+                }
+                panic!("enum-level canonical attribute must be a `key = value` pair");
+            }
+        }
+    }
+
+    attrs
+}
+
+/// Pop-level `canonical` attributes for a struct
+pub struct StructAttrs {
+    /// The struct is prefixed with the given word.
+    /// Useful with`#[canonical(inner_discriminant)]`.
+    /// The type must implement `Into<u64>`, which is used to serialize it.
+    pub prefix: Option<TokenStream>,
+}
+
+impl StructAttrs {
+    pub fn parse(s: &synstructure::Structure) -> Self {
+        let mut attrs = parse_attrs(s);
+
+        let prefix = attrs.remove("prefix");
+
+        if !attrs.is_empty() {
+            panic!("unknown canonical attributes: {:?}", attrs.keys())
+        }
+
+        Self { prefix }
+    }
+}
+
+/// Pop-level `canonical` attributes for an enum
+#[allow(non_snake_case)]
+pub struct EnumAttrs {
+    /// This is a wrapper enum where every variant can be recognized from it's first
+    /// word. This means that the enum itself doesn't have to serialize the
+    /// discriminant, but the field itself does so. This can be done using
+    /// `#[canonical(prefix = ...)]` attribute. `TryFromPrimitive` traits are used to
+    /// convert the raw bytes into the given type.
+    pub inner_discriminant: Option<TokenStream>,
+    /// Replaces calculation of the serialized static size with a custom function.
+    pub serialized_size_static_with: Option<TokenStream>,
+    /// Replaces calculation of the serialized dynamic size with a custom function.
+    pub serialized_size_dynamic_with: Option<TokenStream>,
+    /// Replaces serialization with a custom function.
+    pub serialize_with: Option<TokenStream>,
+    /// Replaces deserialization with a custom function.
+    pub deserialize_with: Option<TokenStream>,
+    /// Determines whether the enum has a dynamic size when `serialize_with` is used.
+    pub SIZE_NO_DYNAMIC: Option<TokenStream>,
+}
+
+impl EnumAttrs {
+    #[allow(non_snake_case)]
+    pub fn parse(s: &synstructure::Structure) -> Self {
+        let mut attrs = parse_attrs(s);
+
+        let inner_discriminant = attrs.remove("inner_discriminant");
+        let serialized_size_static_with = attrs.remove("serialized_size_static_with");
+        let serialized_size_dynamic_with = attrs.remove("serialized_size_dynamic_with");
+        let serialize_with = attrs.remove("serialize_with");
+        let deserialize_with = attrs.remove("deserialize_with");
+        let SIZE_NO_DYNAMIC = attrs.remove("SIZE_NO_DYNAMIC");
+
+        if !attrs.is_empty() {
+            panic!("unknown canonical attributes: {:?}", attrs.keys())
+        }
+
+        Self {
+            inner_discriminant,
+            serialized_size_static_with,
+            serialized_size_dynamic_with,
+            serialize_with,
+            deserialize_with,
+            SIZE_NO_DYNAMIC,
+        }
+    }
+}
+
+/// Parse `#[repr(int)]` attribute for an enum.
+pub fn parse_enum_repr(attrs: &[Attribute]) -> Option<String> {
+    for attr in attrs {
+        if attr.style != AttrStyle::Outer {
+            continue
+        }
+        if let Meta::List(ml) = &attr.meta {
+            if ml.path.segments.len() == 1 && ml.path.segments[0].ident == "repr" {
+                if let Some(TokenTree::Ident(ident)) =
+                    ml.tokens.clone().into_iter().next()
+                {
+                    return Some(ident.to_string())
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Parse `#[canonical(skip)]` attribute for a binding field.
+pub fn should_skip_field_binding(binding: &BindingInfo<'_>) -> bool {
+    should_skip_field(&binding.ast().attrs)
+}
+
+/// Parse `#[canonical(skip)]` attribute for a struct field.
+pub fn should_skip_field(attrs: &[Attribute]) -> bool {
+    for attr in attrs {
+        if attr.style != AttrStyle::Outer {
+            continue
+        }
+        if let Meta::List(ml) = &attr.meta {
+            if ml.path.segments.len() == 1 && ml.path.segments[0].ident == "canonical" {
+                for token in ml.tokens.clone() {
+                    if let TokenTree::Ident(ident) = &token {
+                        if ident == "skip" {
+                            return true
+                        } else {
+                            panic!("unknown canonical attribute: {}", ident)
+                        }
+                    }
+                }
+            }
+        }
+    }
+    false
+}