no_std support for fuel-tx and fuel-vm

.github/workflows/ci.yml

@@ -95,7 +95,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_VERSION }}
-          targets: "thumbv6m-none-eabi,wasm32-unknown-unknown"
+          targets: "thumbv6m-none-eabi,riscv32imac-unknown-none-elf,wasm32-unknown-unknown"
           components: "clippy"
       - name: Install Cargo Make
         uses: davidB/rust-cargo-make@v1

CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+#### Breaking
+
+- [#578](https://github.com/FuelLabs/fuel-vm/pull/578): Support `no_std` environments for `fuel-crypto`, falling back to a pure-Rust crypto implementation.
+- [#582](https://github.com/FuelLabs/fuel-vm/pull/582): Make `fuel-vm` and `fuel-tx` crates compatible with `no_std` + `alloc`. This includes reworking all error handling that used `std::io::Error`, replacing some `std::collection::{HashMap, HashSet}` with `hashbrown::{HashMap, HashSet}` and many changes to feature-gating of APIs.
+
 ## [Version 0.37.0]
 
 #### Breaking
@@ -16,7 +21,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
     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.
-- [#578](https://github.com/FuelLabs/fuel-vm/pull/578): Support `no_std` environments for `fuel-crypto`, falling back to a pure-Rust crypto implementation.
 
 ## [Version 0.36.1]
 

fuel-asm/Cargo.toml

@@ -27,7 +27,8 @@ rstest = "0.16"
 [features]
 default = ["std"]
 typescript = ["wasm-bindgen", "wee_alloc"]
-std = ["serde?/default", "fuel-types/std"]
+std = ["alloc", "serde?/default", "fuel-types/std"]
+alloc = ["fuel-asm/alloc"]
 serde = ["dep:serde"]
 
 # docs.rs-specific configuration

fuel-asm/src/encoding_tests.rs

@@ -5,6 +5,7 @@ use fuel_asm as _;
 use strum::IntoEnumIterator;
 
 #[test]
+#[cfg(tests)]
 fn opcode() {
     // values picked to test edge cases
     let r = RegId::new_checked(0x2d).unwrap();

fuel-asm/src/lib.rs

@@ -8,11 +8,14 @@
 #![deny(unsafe_code)]
 #![deny(unused_crate_dependencies)]
 
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
 #[cfg(feature = "wee_alloc")]
 use wee_alloc as _;
 
-#[cfg(all(no_std, feature = "wee_alloc"))]
 // Use `wee_alloc` as the global allocator.
+#[cfg(all(no_std, feature = "wee_alloc"))]
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
@@ -877,15 +880,15 @@ where
 
 // Collect instructions into bytes or halfwords
 
-#[cfg(feature = "std")]
-impl core::iter::FromIterator<Instruction> for Vec<u8> {
+#[cfg(feature = "alloc")]
+impl core::iter::FromIterator<Instruction> for alloc::vec::Vec<u8> {
     fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self {
         iter.into_iter().flat_map(Instruction::to_bytes).collect()
     }
 }
 
-#[cfg(feature = "std")]
-impl core::iter::FromIterator<Instruction> for Vec<u32> {
+#[cfg(feature = "alloc")]
+impl core::iter::FromIterator<Instruction> for alloc::vec::Vec<u32> {
     fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self {
         iter.into_iter().map(u32::from).collect()
     }

fuel-asm/src/panic_reason.rs

@@ -120,22 +120,6 @@ impl fmt::Display for PanicReason {
     }
 }
 
-#[cfg(feature = "std")]
-impl std::error::Error for PanicReason {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        None
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<PanicReason> for std::io::Error {
-    fn from(reason: PanicReason) -> Self {
-        use std::io;
-
-        io::Error::new(io::ErrorKind::Other, reason)
-    }
-}
-
 impl From<core::array::TryFromSliceError> for PanicReason {
     fn from(_: core::array::TryFromSliceError) -> Self {
         Self::MemoryOverflow

fuel-crypto/src/lib.rs

@@ -9,8 +9,8 @@
 #![deny(unsafe_code)]
 #![deny(unused_crate_dependencies)]
 
-#[cfg(test)]
 // Satisfy unused_crate_dependencies lint for self-dependency enabling test features
+#[cfg(test)]
 use fuel_crypto as _;
 
 /// Required export for using mnemonic keygen on [`SecretKey::new_from_mnemonic`]

fuel-crypto/src/secp256/backend/r1/p256.rs

@@ -57,6 +57,7 @@ pub fn sign_prehashed(
 
 /// Convert the public key point to its uncompressed non-prefixed representation,
 /// i.e. 32 bytes of x coordinate and 32 bytes of y coordinate.
+#[cfg(feature = "test-helpers")]
 pub fn encode_pubkey(key: VerifyingKey) -> [u8; 64] {
     let point = key.to_encoded_point(false);
     let mut result = [0u8; 64];

fuel-merkle/Cargo.toml

@@ -29,7 +29,7 @@ thiserror = "1.0"
 
 [features]
 default = ["std"]
-std = ["dep:thiserror", "digest/default", "hex/default", "sha2/default"]
+std = ["dep:thiserror", "fuel-storage/std", "digest/default", "hex/default", "sha2/default"]
 test-helpers = []
 
 [[test]]

fuel-merkle/benches/smt.rs

@@ -70,7 +70,7 @@ fn sparse_merkle_tree(c: &mut Criterion) {
 
     let rng = &mut StdRng::seed_from_u64(8586);
     let gen = || Some((MerkleTreeKey::new(random_bytes32(rng)), random_bytes32(rng)));
-    let data = std::iter::from_fn(gen).take(50_000).collect::<Vec<_>>();
+    let data = core::iter::from_fn(gen).take(50_000).collect::<Vec<_>>();
 
     let expected_root = baseline_root(data.clone().into_iter());
     let root = subject_root(data.clone().into_iter());

fuel-merkle/src/binary/merkle_tree.rs

@@ -23,10 +23,11 @@ use crate::{
 
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+use fuel_storage::StorageError;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 #[cfg_attr(feature = "std", derive(thiserror::Error))]
-pub enum MerkleTreeError<StorageError> {
+pub enum MerkleTreeError {
     #[cfg_attr(feature = "std", error("proof index {0} is not valid"))]
     InvalidProofIndex(u64),
 
@@ -40,8 +41,8 @@ pub enum MerkleTreeError<StorageError> {
     StorageError(StorageError),
 }
 
-impl<StorageError> From<StorageError> for MerkleTreeError<StorageError> {
-    fn from(err: StorageError) -> MerkleTreeError<StorageError> {
+impl From<StorageError> for MerkleTreeError {
+    fn from(err: StorageError) -> MerkleTreeError {
         MerkleTreeError::StorageError(err)
     }
 }
@@ -130,10 +131,10 @@ impl<TableType, StorageType> MerkleTree<TableType, StorageType> {
     }
 }
 
-impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
+impl<TableType, StorageType> MerkleTree<TableType, StorageType>
 where
     TableType: Mappable<Key = u64, Value = Primitive, OwnedValue = Primitive>,
-    StorageType: StorageInspect<TableType, Error = StorageError>,
+    StorageType: StorageInspect<TableType>,
 {
     pub fn new(storage: StorageType) -> Self {
         Self {
@@ -147,7 +148,7 @@ where
     pub fn load(
         storage: StorageType,
         leaves_count: u64,
-    ) -> Result<Self, MerkleTreeError<StorageError>> {
+    ) -> Result<Self, MerkleTreeError> {
         let mut tree = Self {
             storage,
             head: None,
@@ -163,7 +164,7 @@ where
     pub fn prove(
         &self,
         proof_index: u64,
-    ) -> Result<(Bytes32, ProofSet), MerkleTreeError<StorageError>> {
+    ) -> Result<(Bytes32, ProofSet), MerkleTreeError> {
         if proof_index + 1 > self.leaves_count {
             return Err(MerkleTreeError::InvalidProofIndex(proof_index))
         }
@@ -291,7 +292,7 @@ where
     ///
     /// By excluding the root position `07`, we have established the set of
     /// side positions `03`, `09`, and `12`, matching our set of MMR peaks.
-    fn build(&mut self) -> Result<(), MerkleTreeError<StorageError>> {
+    fn build(&mut self) -> Result<(), MerkleTreeError> {
         let mut current_head = None;
         let peaks = &self.peak_positions();
         for peak in peaks.iter() {
@@ -312,10 +313,10 @@ where
     }
 }
 
-impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
+impl<TableType, StorageType> MerkleTree<TableType, StorageType>
 where
     TableType: Mappable<Key = u64, Value = Primitive, OwnedValue = Primitive>,
-    StorageType: StorageMutate<TableType, Error = StorageError>,
+    StorageType: StorageMutate<TableType>,
 {
     pub fn push(&mut self, data: &[u8]) -> Result<(), StorageError> {
         let node = Node::create_leaf(self.leaves_count, data);

fuel-merkle/src/common/node.rs

@@ -1,6 +1,9 @@
-use crate::common::{
-    Bytes32,
-    Bytes8,
+use crate::{
+    common::{
+        Bytes32,
+        Bytes8,
+    },
+    sparse::StorageNodeError,
 };
 
 use alloc::string::String;
@@ -29,14 +32,12 @@ pub trait Node {
 }
 
 pub trait ParentNode: Sized + Node {
-    type Error;
-
     fn left_child(&self) -> ChildResult<Self>;
     fn right_child(&self) -> ChildResult<Self>;
 }
 
 #[allow(type_alias_bounds)]
-pub type ChildResult<T: ParentNode> = Result<T, ChildError<T::Key, T::Error>>;
+pub type ChildResult<T: ParentNode> = Result<T, ChildError<T::Key, StorageNodeError>>;
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "std", derive(thiserror::Error))]

fuel-merkle/src/common/path_iterator.rs

@@ -211,7 +211,6 @@ mod test {
         Bytes8,
     };
     use alloc::vec::Vec;
-    use core::convert::Infallible;
 
     #[derive(Debug, Clone, PartialEq)]
     struct TestNode {
@@ -273,8 +272,6 @@ mod test {
     }
 
     impl ParentNode for TestNode {
-        type Error = Infallible;
-
         fn left_child(&self) -> ChildResult<Self> {
             Ok(TestNode::child(self, -1))
         }

fuel-merkle/src/common/position.rs

@@ -7,7 +7,6 @@ use crate::common::{
     Bytes8,
     PositionPath,
 };
-use core::convert::Infallible;
 
 /// # Position
 ///
@@ -273,8 +272,6 @@ impl Node for Position {
 }
 
 impl ParentNode for Position {
-    type Error = Infallible;
-
     fn left_child(&self) -> ChildResult<Self> {
         Ok(Position::left_child(*self))
     }

fuel-merkle/src/common/storage_map.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 
 use alloc::borrow::Cow;
+use fuel_storage::StorageError;
 use hashbrown::HashMap;
 
 #[derive(Debug, Clone)]
@@ -44,15 +45,16 @@ where
     Type::Key: Eq + core::hash::Hash,
     Type::OwnedKey: Eq + core::hash::Hash + core::borrow::Borrow<Type::Key>,
 {
-    type Error = core::convert::Infallible;
-
-    fn get(&self, key: &Type::Key) -> Result<Option<Cow<Type::OwnedValue>>, Self::Error> {
+    fn get(
+        &self,
+        key: &Type::Key,
+    ) -> Result<Option<Cow<Type::OwnedValue>>, StorageError> {
         let result = self.map.get(key);
         let value = result.map(Cow::Borrowed);
         Ok(value)
     }
 
-    fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
+    fn contains_key(&self, key: &Type::Key) -> Result<bool, StorageError> {
         let contains = self.map.contains_key(key);
         Ok(contains)
     }
@@ -68,7 +70,7 @@ where
         &mut self,
         key: &Type::Key,
         value: &Type::Value,
-    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
+    ) -> Result<Option<Type::OwnedValue>, StorageError> {
         let previous = self.map.remove(key);
 
         self.map
@@ -79,7 +81,7 @@ where
     fn remove(
         &mut self,
         key: &Type::Key,
-    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
+    ) -> Result<Option<Type::OwnedValue>, StorageError> {
         let value = self.map.remove(key);
         Ok(value)
     }

fuel-merkle/src/sparse/branch.rs

@@ -10,6 +10,7 @@ use crate::{
 };
 use fuel_storage::{
     Mappable,
+    StorageError,
     StorageMutate,
 };
 
@@ -33,7 +34,7 @@ pub(crate) fn merge_branches<Storage, Table>(
     storage: &mut Storage,
     mut left_branch: Branch,
     mut right_branch: Branch,
-) -> Result<Branch, Storage::Error>
+) -> Result<Branch, StorageError>
 where
     Storage: StorageMutate<Table>,
     Table: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,