add no-std

.github/workflows/rust.yml

@@ -28,3 +28,5 @@ jobs:
       run: cargo build --all-features --verbose
     - name: Run tests
       run: cargo test --all-features --verbose
+    - name: Build no-std
+      run: cargo build --no-default-features --verbose

ssz-rs/Cargo.toml

@@ -16,17 +16,22 @@ exclude = [
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["serde"]
+default = ["serde", "std"]
+std = [
+    "bitvec/default",
+    "sha2/default",
+    "num-bigint/default",
+]
 serde = ["dep:serde", "dep:hex"]
 
 [dependencies]
 thiserror = "1.0.25"
-bitvec = "1.0.0"
+bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
 ssz-rs-derive = { path = "../ssz-rs-derive"}
-sha2 = "0.9.8"
+sha2 = { version ="0.9.8", default-features = false}
 serde = { version = "1.0", features = ["derive"], optional = true }
 hex = {version = "0.4.3", optional = true }
-num-bigint = "0.4.3"
+num-bigint = { version ="0.4.3", default-features = false}
 
 [dev-dependencies]
 hex-literal = "0.3.3"

ssz-rs/src/array.rs

@@ -5,6 +5,7 @@
 //! can likely be simplified to a definition over `const N: usize`.
 use crate::de::{deserialize_homogeneous_composite, Deserialize, DeserializeError};
 use crate::error::{InstanceError, TypeError};
+use crate::lib::*;
 use crate::merkleization::{
     merkleize, pack, MerkleizationError, Merkleized, Node, BYTES_PER_CHUNK,
 };

ssz-rs/src/bitlist.rs

@@ -1,13 +1,12 @@
 use crate::de::{Deserialize, DeserializeError};
 use crate::error::InstanceError;
+use crate::lib::*;
 use crate::merkleization::{
     merkleize, mix_in_length, pack_bytes, MerkleizationError, Merkleized, Node,
 };
 use crate::ser::{Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};
 use bitvec::prelude::{BitVec, Lsb0};
-use std::fmt;
-use std::ops::{Deref, DerefMut};
 
 // +1 for length bit
 fn byte_length(bound: usize) -> usize {

ssz-rs/src/bitvector.rs

@@ -1,12 +1,11 @@
 use crate::de::{Deserialize, DeserializeError};
 use crate::error::TypeError;
+use crate::lib::*;
 use crate::merkleization::{merkleize, pack_bytes, MerkleizationError, Merkleized, Node};
 use crate::ser::{Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};
 use bitvec::field::BitField;
 use bitvec::prelude::{BitVec, Lsb0};
-use std::fmt;
-use std::ops::{Deref, DerefMut};
 
 fn byte_length(bound: usize) -> usize {
     (bound + 7) / 8

ssz-rs/src/boolean.rs

@@ -1,4 +1,5 @@
 use crate::de::{Deserialize, DeserializeError};
+use crate::lib::*;
 use crate::merkleization::{MerkleizationError, Merkleized, Node};
 use crate::ser::{Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};

ssz-rs/src/de.rs

@@ -1,20 +1,42 @@
 use crate::error::{InstanceError, TypeError};
+use crate::lib::*;
 use crate::ser::BYTES_PER_LENGTH_OFFSET;
 use crate::SimpleSerialize;
-use thiserror::Error;
 
-#[derive(Error, Debug)]
+#[derive(Debug)]
 pub enum DeserializeError {
-    #[error("expected at least {expected} bytes when decoding but provided only {provided} bytes")]
     ExpectedFurtherInput { provided: usize, expected: usize },
-    #[error("{provided} bytes given but only expected {expected} bytes")]
     AdditionalInput { provided: usize, expected: usize },
-    #[error("invalid byte {0:x} when decoding data of the expected type")]
     InvalidByte(u8),
-    #[error("invalid instance: {0}")]
-    InvalidInstance(#[from] InstanceError),
-    #[error("invalid type: {0}")]
-    InvalidType(#[from] TypeError),
+    InvalidInstance(InstanceError),
+    InvalidType(TypeError),
+}
+
+impl From<InstanceError> for DeserializeError {
+    fn from(err: InstanceError) -> Self {
+        Self::InvalidInstance(err)
+    }
+}
+
+impl From<TypeError> for DeserializeError {
+    fn from(err: TypeError) -> Self {
+        Self::InvalidType(err)
+    }
+}
+
+impl Display for DeserializeError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            DeserializeError::ExpectedFurtherInput { provided, expected } => write!(f, "expected at least {expected} bytes when decoding but provided only {provided} bytes"),
+            DeserializeError::AdditionalInput { provided, expected } => write!(f, "{provided} bytes given but only expected {expected} bytes"),
+            DeserializeError::InvalidByte(b) => write!(
+                f,
+                "invalid byte {b:x} when decoding data of the expected type"
+            ),
+            DeserializeError::InvalidInstance(err) => write!(f, "invalid instance: {err}"),
+            DeserializeError::InvalidType(err) => write!(f, "invalid type: {err}"),
+        }
+    }
 }
 
 pub trait Deserialize {

ssz-rs/src/error.rs

@@ -1,29 +1,76 @@
 use crate::de::DeserializeError;
+use crate::lib::*;
 use crate::merkleization::MerkleizationError;
 use crate::ser::SerializeError;
-use thiserror::Error;
 
 // Top-level error to wrap all child errors in crate
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum Error {
-    #[error("could not serialize: {0}")]
-    Serialize(#[from] SerializeError),
-    #[error("could not deserialize: {0}")]
-    Deserialize(#[from] DeserializeError),
-    #[error("merkleization error: {0}")]
-    Merkleization(#[from] MerkleizationError),
+    Serialize(SerializeError),
+    Deserialize(DeserializeError),
+    Merkleization(MerkleizationError),
 }
 
-#[derive(Error, Debug)]
+impl From<SerializeError> for Error {
+    fn from(err: SerializeError) -> Self {
+        Self::Serialize(err)
+    }
+}
+
+impl From<DeserializeError> for Error {
+    fn from(err: DeserializeError) -> Self {
+        Self::Deserialize(err)
+    }
+}
+
+impl From<MerkleizationError> for Error {
+    fn from(err: MerkleizationError) -> Self {
+        Self::Merkleization(err)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Serialize(err) => write!(f, "could not serialize: {err}"),
+            Self::Deserialize(err) => write!(f, "could not deserialize: {err}"),
+            Self::Merkleization(err) => write!(f, "merkleization error: {err}"),
+        }
+    }
+}
+
+#[derive(Debug)]
 pub enum TypeError {
-    #[error("the type for this value is invalid with bound {0}")]
     InvalidBound(usize),
 }
 
-#[derive(Error, Debug)]
+impl Display for TypeError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidBound(size) => {
+                write!(f, "the type for this value is invalid with bound {size}")
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
 pub enum InstanceError {
-    #[error("required {required} elements for this type but {provided} elements given")]
     Exact { required: usize, provided: usize },
-    #[error("{provided} elements given for a type with (inclusive) upper bound {bound}")]
     Bounded { bound: usize, provided: usize },
 }
+
+impl Display for InstanceError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Exact { required, provided } => write!(
+                f,
+                "required {required} elements for this type but {provided} elements given"
+            ),
+            Self::Bounded { bound, provided } => write!(
+                f,
+                "{provided} elements given for a type with (inclusive) upper bound {bound}"
+            ),
+        }
+    }
+}

ssz-rs/src/lib.rs

@@ -1,3 +1,8 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
 mod array;
 mod bitlist;
 mod bitvector;
@@ -20,12 +25,36 @@ pub use bitvector::Bitvector;
 pub use de::{Deserialize, DeserializeError};
 pub use error::Error;
 pub use list::List;
-pub use merkleization::{Context as MerkleizationContext, MerkleizationError, Merkleized, Node};
+pub use merkleization::{MerkleizationError, Merkleized, Node};
 pub use ser::{Serialize, SerializeError};
 pub use uint::U256;
 pub use utils::*;
 pub use vector::Vector;
 
+mod lib {
+    mod core {
+        #[cfg(not(feature = "std"))]
+        pub use core::*;
+        #[cfg(feature = "std")]
+        pub use std::*;
+    }
+
+    pub use self::core::{any, cmp, fmt, iter, slice};
+
+    pub use self::cmp::Ordering;
+    pub use self::core::array::TryFromSliceError;
+    pub use self::core::fmt::{Debug, Display, Formatter};
+    pub use self::core::ops::{Deref, DerefMut, Index, IndexMut};
+    pub use self::core::slice::{IterMut, SliceIndex};
+    pub use self::iter::Enumerate;
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::{format, string::String, vec, vec::Vec};
+
+    #[cfg(feature = "std")]
+    pub use std::vec::Vec;
+}
+
 /// `Sized` is a trait for types that can
 /// provide sizing information relevant for the SSZ spec.
 pub trait Sized {
@@ -51,6 +80,7 @@ pub mod prelude {
     pub use crate::bitvector::Bitvector;
     pub use crate::de::Deserialize;
     pub use crate::de::DeserializeError;
+    pub use crate::error::{InstanceError, TypeError};
     pub use crate::list::List;
     pub use crate::merkleization::{
         is_valid_merkle_branch, merkleize, mix_in_selector, pack, pack_bytes, MerkleizationError,
@@ -61,7 +91,6 @@ pub mod prelude {
     pub use crate::utils::{deserialize, serialize};
     pub use crate::vector::Vector;
     pub use crate::Error as SimpleSerializeError;
-    pub use crate::MerkleizationContext;
     pub use crate::SimpleSerialize;
     pub use crate::Sized;
     pub use ssz_rs_derive::SimpleSerialize;

ssz-rs/src/list.rs

@@ -1,5 +1,6 @@
 use crate::de::{deserialize_homogeneous_composite, Deserialize, DeserializeError};
 use crate::error::InstanceError;
+use crate::lib::*;
 use crate::merkleization::{
     merkleize, mix_in_length, pack, MerkleCache, MerkleizationError, Merkleized, Node,
     BYTES_PER_CHUNK,
@@ -8,12 +9,8 @@ use crate::ser::{serialize_composite, Serialize, SerializeError};
 use crate::{SimpleSerialize, Sized};
 #[cfg(feature = "serde")]
 use serde::ser::SerializeSeq;
-use std::iter::Enumerate;
 #[cfg(feature = "serde")]
 use std::marker::PhantomData;
-use std::ops::{Deref, Index, IndexMut};
-use std::slice::SliceIndex;
-use std::{fmt, slice};
 
 /// A homogenous collection of a variable number of values.
 #[derive(Clone, Default)]
@@ -84,7 +81,7 @@ where
             write!(
                 f,
                 "List<{}, {}>(len={}){:#?}",
-                std::any::type_name::<T>(),
+                any::type_name::<T>(),
                 N,
                 self.len(),
                 self.data
@@ -93,7 +90,7 @@ where
             write!(
                 f,
                 "List<{}, {}>(len={}){:?}",
-                std::any::type_name::<T>(),
+                any::type_name::<T>(),
                 N,
                 self.len(),
                 self.data

ssz-rs/src/merkleization/mod.rs

@@ -2,12 +2,9 @@ mod cache;
 mod node;
 mod proofs;
 
+use crate::lib::*;
 use crate::ser::{Serialize, SerializeError};
 use sha2::{Digest, Sha256};
-use std::cmp::Ordering;
-use std::fmt::Debug;
-use std::ops::Index;
-use thiserror::Error;
 
 pub use cache::Cache as MerkleCache;
 pub use node::Node;
@@ -20,14 +17,29 @@ pub trait Merkleized {
     fn hash_tree_root(&mut self) -> Result<Node, MerkleizationError>;
 }
 
-#[derive(Error, Debug)]
+#[derive(Debug)]
 pub enum MerkleizationError {
-    #[error("failed to serialize value: {0}")]
-    SerializationError(#[from] SerializeError),
-    #[error("cannot merkleize data that exceeds the declared limit {0}")]
+    SerializationError(SerializeError),
     InputExceedsLimit(usize),
 }
 
+impl From<SerializeError> for MerkleizationError {
+    fn from(e: SerializeError) -> Self {
+        MerkleizationError::SerializationError(e)
+    }
+}
+
+impl Display for MerkleizationError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::SerializationError(err) => {
+                write!(f, "failed to serialize value: {err}")
+            }
+            Self::InputExceedsLimit(size) => write!(f, "data exceeds the declared limit {size}"),
+        }
+    }
+}
+
 pub fn pack_bytes(buffer: &mut Vec<u8>) {
     let data_len = buffer.len();
     if data_len % BYTES_PER_CHUNK != 0 {
@@ -60,7 +72,7 @@ fn hash_nodes(hasher: &mut Sha256, a: &[u8], b: &[u8], out: &mut [u8]) {
 const MAX_MERKLE_TREE_DEPTH: usize = 64;
 
 #[derive(Debug)]
-pub struct Context {
+struct Context {
     zero_hashes: [u8; MAX_MERKLE_TREE_DEPTH * BYTES_PER_CHUNK],
 }
 

ssz-rs/src/merkleization/node.rs

@@ -1,8 +1,5 @@
+use crate::lib::*;
 use crate::prelude::*;
-use std::array::TryFromSliceError;
-use std::convert::AsRef;
-use std::fmt;
-use std::ops::{Index, IndexMut};
 
 #[derive(Default, Clone, Copy, PartialEq, Eq, SimpleSerialize)]
 pub struct Node(pub(crate) [u8; 32]);