diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fbb3f7e4c..17dc69b37 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -72,6 +72,8 @@ jobs:
             args: --target wasm32-unknown-unknown -p fuel-asm --features typescript --crate-type=cdylib
           - command: check
             args: --target wasm32-unknown-unknown -p fuel-types --features serde --no-default-features
+          - command: check
+            args: --target wasm32-unknown-unknown -p fuel-vm --features alloc --no-default-features
           - command: bench
             args: --workspace --no-run
           - command: make
@@ -95,7 +97,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
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c9eb51df..366ed0b7f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@ 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.
 ### Added
 
 - [#586](https://github.com/FuelLabs/fuel-vm/pull/586): Added `default_asset` method to the `ContractIdExt` trait implementation, to mirror the `default` method on AssetId in the Sway std lib.
@@ -20,7 +24,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]
 
diff --git a/ci_checks.sh b/ci_checks.sh
index 8388f9a41..28fd76beb 100755
--- a/ci_checks.sh
+++ b/ci_checks.sh
@@ -26,6 +26,7 @@ cargo check --target thumbv6m-none-eabi -p fuel-asm -p fuel-storage -p fuel-merk
 cargo check --target wasm32-unknown-unknown -p fuel-crypto --no-default-features &&
 cargo check --target wasm32-unknown-unknown -p fuel-types --features serde --no-default-features &&
 cargo check --target wasm32-unknown-unknown -p fuel-tx --features serde --no-default-features &&
+cargo check --target wasm32-unknown-unknown -p fuel-vm --features alloc --no-default-features &&
 cargo rustc --target wasm32-unknown-unknown -p fuel-types --features typescript --crate-type=cdylib &&
 cargo rustc --target wasm32-unknown-unknown -p fuel-asm --features typescript --crate-type=cdylib &&
 cargo make check &&
diff --git a/fuel-asm/Cargo.toml b/fuel-asm/Cargo.toml
index 4f41c4021..bbce2ba88 100644
--- a/fuel-asm/Cargo.toml
+++ b/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
diff --git a/fuel-asm/src/encoding_tests.rs b/fuel-asm/src/encoding_tests.rs
index 01bd7c731..ae0b3bc9b 100644
--- a/fuel-asm/src/encoding_tests.rs
+++ b/fuel-asm/src/encoding_tests.rs
@@ -5,6 +5,7 @@ use fuel_asm as _;
 use strum::IntoEnumIterator;
 
 #[test]
+#[cfg(test)]
 fn opcode() {
     // values picked to test edge cases
     let r = RegId::new_checked(0x2d).unwrap();
diff --git a/fuel-asm/src/lib.rs b/fuel-asm/src/lib.rs
index eecdda888..d912e37dc 100644
--- a/fuel-asm/src/lib.rs
+++ b/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()
     }
diff --git a/fuel-asm/src/panic_reason.rs b/fuel-asm/src/panic_reason.rs
index db00f9278..37763fd8b 100644
--- a/fuel-asm/src/panic_reason.rs
+++ b/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
diff --git a/fuel-crypto/src/lib.rs b/fuel-crypto/src/lib.rs
index d9bad6a5e..fef28e025 100644
--- a/fuel-crypto/src/lib.rs
+++ b/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`]
diff --git a/fuel-crypto/src/secp256/backend/r1/p256.rs b/fuel-crypto/src/secp256/backend/r1/p256.rs
index cb0cc177a..bb9a6aab3 100644
--- a/fuel-crypto/src/secp256/backend/r1/p256.rs
+++ b/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];
diff --git a/fuel-merkle/benches/smt.rs b/fuel-merkle/benches/smt.rs
index 5e221115f..d66cf272b 100644
--- a/fuel-merkle/benches/smt.rs
+++ b/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());
diff --git a/fuel-tx/Cargo.toml b/fuel-tx/Cargo.toml
index b3644e488..a1162a540 100644
--- a/fuel-tx/Cargo.toml
+++ b/fuel-tx/Cargo.toml
@@ -16,14 +16,16 @@ fuel-asm = { workspace = true, default-features = false }
 fuel-crypto = { workspace = true, default-features = false }
 fuel-merkle = { workspace = true, default-features = false, optional = true }
 fuel-types = { workspace = true, default-features = false }
+hashbrown = { version = "0.14", optional = true }
 itertools = { version = "0.10", default-features = false, optional = true }
 num-integer = { version = "0.1", default-features = false, optional = true }
-num_enum = { version = "0.7", optional = true }
+num_enum = { version = "0.7", default-features = false, optional = true }
 rand = { version = "0.8", default-features = false, features = ["std_rng"], optional = true }
 serde = { version = "1.0", default-features = false, features = ["alloc", "derive"], optional = true }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"], optional = true }
-strum = { version = "0.24", optional = true }
+strum = { version = "0.24", default-features = false, optional = true }
 strum_macros = { version = "0.24", optional = true }
+thiserror = { version = "1.0", optional = true }
 
 [dev-dependencies]
 bincode = { workspace = true }
@@ -31,7 +33,7 @@ fuel-crypto = { workspace = true, default-features = false, features = ["random"
 fuel-tx = { path = ".", features = ["builder", "random"] }
 fuel-tx-test-helpers = { path = "test-helpers" }
 fuel-types = { workspace = true, default-features = false, features = ["random"] }
-hex = { version = "0.4" }
+hex = { version = "0.4", default-features = false }
 insta = "1.0"
 quickcheck = "1.0"
 quickcheck_macros = "1.0"
@@ -40,10 +42,10 @@ rstest = "0.15"
 
 [features]
 default = ["fuel-asm/default", "fuel-crypto/default", "fuel-merkle/default", "fuel-types/default", "std"]
-alloc = ["fuel-types/alloc", "itertools/use_alloc", "derivative", "fuel-merkle", "num_enum", "num-integer", "strum", "strum_macros"]
 builder = ["alloc", "internals"]
 internals = []
 random = ["fuel-crypto/random", "fuel-types/random", "rand"]
-std = ["alloc", "fuel-asm/std", "fuel-crypto/std", "fuel-merkle/std", "fuel-types/std", "itertools/default", "rand?/default", "serde?/default"]
+std = ["alloc", "dep:thiserror", "fuel-asm/std", "fuel-crypto/std", "fuel-merkle/std", "fuel-types/std", "itertools/default", "rand?/default", "serde?/default", "hex/std"]
+alloc = ["hashbrown", "fuel-types/alloc", "itertools/use_alloc", "derivative", "fuel-merkle", "num_enum", "num-integer", "strum", "strum_macros"]
 # serde is requiring alloc because its mandatory for serde_json. to avoid adding a new feature only for serde_json, we just require `alloc` here since as of the moment we don't have a use case of serde without alloc.
-serde = ["alloc", "dep:serde", "fuel-asm/serde", "fuel-crypto/serde", "fuel-types/serde", "serde_json"]
+serde = ["alloc", "dep:serde", "fuel-asm/serde", "fuel-crypto/serde", "fuel-types/serde", "serde_json", "hashbrown/serde"]
diff --git a/fuel-tx/src/builder.rs b/fuel-tx/src/builder.rs
index 002e3c562..5b97b6a1f 100644
--- a/fuel-tx/src/builder.rs
+++ b/fuel-tx/src/builder.rs
@@ -11,7 +11,6 @@ use crate::{
         Executable,
         Script,
     },
-    Cacheable,
     ConsensusParameters,
     ContractParameters,
     FeeParameters,
@@ -28,8 +27,10 @@ use crate::{
     Witness,
 };
 
-#[cfg(feature = "std")]
-use crate::Signable;
+use crate::{
+    Cacheable,
+    Signable,
+};
 
 use fuel_crypto::SecretKey;
 use fuel_types::{
@@ -59,13 +60,8 @@ where
 {
 }
 
-#[cfg(feature = "std")]
 pub trait BuildableStd: Signable + Cacheable {}
 
-#[cfg(not(feature = "std"))]
-pub trait BuildableSet: BuildableAloc {}
-
-#[cfg(feature = "std")]
 pub trait BuildableSet: BuildableAloc + BuildableStd {}
 
 pub trait Buildable
@@ -110,12 +106,8 @@ impl<T> BuildableAloc for T where
 {
 }
 
-#[cfg(feature = "std")]
 impl<T> BuildableStd for T where T: Signable + Cacheable {}
-#[cfg(feature = "std")]
 impl<T> BuildableSet for T where T: BuildableAloc + BuildableStd {}
-#[cfg(not(feature = "std"))]
-impl<T> BuildableSet for T where T: BuildableAloc {}
 impl<T> Buildable for T where T: BuildableSet {}
 
 #[derive(Debug, Clone)]
@@ -326,7 +318,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         self
     }
 
-    #[cfg(feature = "std")]
     pub fn add_unsigned_coin_input(
         &mut self,
         secret: SecretKey,
@@ -353,7 +344,7 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         self
     }
 
-    #[cfg(all(feature = "rand", feature = "std"))]
+    #[cfg(feature = "rand")]
     pub fn add_random_fee_input(&mut self) -> &mut Self {
         use rand::{
             Rng,
@@ -370,7 +361,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         )
     }
 
-    #[cfg(feature = "std")]
     pub fn add_unsigned_message_input(
         &mut self,
         secret: SecretKey,
@@ -421,7 +411,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
     }
 
     /// Adds a secret to the builder, and adds a corresponding witness if it's a new entry
-    #[cfg(feature = "std")]
     fn upsert_secret(&mut self, secret_key: SecretKey) -> u8 {
         let witness_len = self.witnesses().len() as u8;
 
@@ -434,7 +423,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         *witness_index
     }
 
-    #[cfg(feature = "std")]
     fn prepare_finalize(&mut self) {
         if self.should_prepare_predicate {
             self.tx.prepare_init_predicate();
@@ -445,7 +433,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         }
     }
 
-    #[cfg(feature = "std")]
     fn finalize_inner(&mut self) -> Tx {
         self.prepare_finalize();
 
@@ -461,7 +448,6 @@ impl<Tx: Buildable> TransactionBuilder<Tx> {
         tx
     }
 
-    #[cfg(feature = "std")]
     pub fn finalize_without_signature_inner(&mut self) -> Tx {
         self.prepare_finalize();
 
@@ -487,7 +473,6 @@ pub trait Finalizable<Tx> {
     fn finalize_without_signature(&mut self) -> Tx;
 }
 
-#[cfg(feature = "std")]
 impl Finalizable<Mint> for TransactionBuilder<Mint> {
     fn finalize(&mut self) -> Mint {
         let mut tx = core::mem::take(&mut self.tx);
@@ -501,7 +486,6 @@ impl Finalizable<Mint> for TransactionBuilder<Mint> {
     }
 }
 
-#[cfg(feature = "std")]
 impl Finalizable<Create> for TransactionBuilder<Create> {
     fn finalize(&mut self) -> Create {
         self.finalize_inner()
@@ -512,7 +496,6 @@ impl Finalizable<Create> for TransactionBuilder<Create> {
     }
 }
 
-#[cfg(feature = "std")]
 impl Finalizable<Script> for TransactionBuilder<Script> {
     fn finalize(&mut self) -> Script {
         self.finalize_inner()
@@ -528,12 +511,10 @@ where
     Self: Finalizable<Tx>,
     Transaction: From<Tx>,
 {
-    #[cfg(feature = "std")]
     pub fn finalize_as_transaction(&mut self) -> Transaction {
         self.finalize().into()
     }
 
-    #[cfg(feature = "std")]
     pub fn finalize_without_signature_as_transaction(&mut self) -> Transaction {
         self.finalize_without_signature().into()
     }
diff --git a/fuel-tx/src/lib.rs b/fuel-tx/src/lib.rs
index 6c97109a9..847006305 100644
--- a/fuel-tx/src/lib.rs
+++ b/fuel-tx/src/lib.rs
@@ -98,9 +98,10 @@ pub use transaction::{
     Witness,
 };
 
-#[cfg(feature = "std")]
-pub use transaction::Signable;
-pub use transaction::UniqueIdentifier;
+pub use transaction::{
+    Signable,
+    UniqueIdentifier,
+};
 
 #[cfg(feature = "alloc")]
 #[allow(deprecated)]
diff --git a/fuel-tx/src/transaction.rs b/fuel-tx/src/transaction.rs
index ac8fdb691..b85e494c9 100644
--- a/fuel-tx/src/transaction.rs
+++ b/fuel-tx/src/transaction.rs
@@ -59,7 +59,6 @@ use crate::input::coin::{
 };
 use input::*;
 
-#[cfg(feature = "std")]
 use crate::input::{
     contract::Contract,
     message::{
@@ -67,10 +66,9 @@ use crate::input::{
         MessageDataPredicate,
     },
 };
-#[cfg(feature = "std")]
 pub use fuel_types::ChainId;
 
-#[cfg(feature = "std")]
+#[cfg(feature = "alloc")]
 pub use id::Signable;
 
 pub use id::UniqueIdentifier;
@@ -303,21 +301,21 @@ pub trait Executable: field::Inputs + field::Outputs + field::Witnesses {
 
     /// Returns ids of all `Input::Contract` that are present in the inputs.
     // TODO: Return `Vec<input::Contract>` instead
-    #[cfg(feature = "std")]
     fn input_contracts(&self) -> IntoIter<&fuel_types::ContractId> {
-        self.inputs()
+        let mut inputs: Vec<_> = self
+            .inputs()
             .iter()
             .filter_map(|input| match input {
                 Input::Contract(Contract { contract_id, .. }) => Some(contract_id),
                 _ => None,
             })
-            .unique()
-            .collect_vec()
-            .into_iter()
+            .collect();
+        inputs.sort();
+        inputs.dedup();
+        inputs.into_iter()
     }
 
     /// Checks that all owners of inputs in the predicates are valid.
-    #[cfg(feature = "std")]
     fn check_predicate_owners(&self, chain_id: &ChainId) -> bool {
         self.inputs()
             .iter()
@@ -411,7 +409,6 @@ pub trait Executable: field::Inputs + field::Outputs + field::Witnesses {
     ///
     /// note: Fields dependent on storage/state such as balance and state roots, or tx
     /// pointers, should already set by the client beforehand.
-    #[cfg(feature = "std")]
     fn prepare_init_script(&mut self) -> &mut Self {
         self.outputs_mut()
             .iter_mut()
diff --git a/fuel-tx/src/transaction/id.rs b/fuel-tx/src/transaction/id.rs
index f6b9f6b67..1c02521ef 100644
--- a/fuel-tx/src/transaction/id.rs
+++ b/fuel-tx/src/transaction/id.rs
@@ -1,4 +1,3 @@
-#[cfg(feature = "std")]
 use crate::{
     field,
     input::{
@@ -11,7 +10,6 @@ use crate::{
     Input,
     Transaction,
 };
-#[cfg(feature = "std")]
 use fuel_crypto::{
     Message,
     PublicKey,
@@ -33,7 +31,6 @@ pub trait UniqueIdentifier {
     fn cached_id(&self) -> Option<Bytes32>;
 }
 
-#[cfg(feature = "std")]
 impl UniqueIdentifier for Transaction {
     fn id(&self, chain_id: &ChainId) -> Bytes32 {
         match self {
@@ -55,13 +52,11 @@ impl UniqueIdentifier for Transaction {
 /// Means that transaction can be singed.
 ///
 /// # Note: Autogenerated transactions are not signable.
-#[cfg(feature = "std")]
 pub trait Signable: UniqueIdentifier {
     /// Signs inputs of the transaction.
     fn sign_inputs(&mut self, secret: &SecretKey, chain_id: &ChainId);
 }
 
-#[cfg(feature = "std")]
 impl<T> Signable for T
 where
     T: UniqueIdentifier + field::Witnesses + field::Inputs,
@@ -112,7 +107,7 @@ where
     }
 }
 
-#[cfg(all(test, feature = "random"))]
+#[cfg(test)]
 mod tests {
     use crate::TxParameters;
     use core::{
diff --git a/fuel-tx/src/transaction/metadata.rs b/fuel-tx/src/transaction/metadata.rs
index 6539ab2dd..359dfafeb 100644
--- a/fuel-tx/src/transaction/metadata.rs
+++ b/fuel-tx/src/transaction/metadata.rs
@@ -4,10 +4,9 @@ use fuel_types::{
     ChainId,
 };
 
-use crate::CheckError;
-#[cfg(feature = "std")]
 use crate::{
     field,
+    CheckError,
     UniqueIdentifier,
 };
 
@@ -22,7 +21,6 @@ pub trait Cacheable {
     fn precompute(&mut self, chain_id: &ChainId) -> Result<(), CheckError>;
 }
 
-#[cfg(feature = "std")]
 impl Cacheable for super::Transaction {
     fn is_computed(&self) -> bool {
         match self {
@@ -54,7 +52,6 @@ pub(crate) struct CommonMetadata {
     pub witnesses_offset_at: Vec<usize>,
 }
 
-#[cfg(feature = "std")]
 impl CommonMetadata {
     /// Computes the `Metadata` for the `tx` transaction.
     pub fn compute<Tx>(tx: &Tx, chain_id: &ChainId) -> Self
diff --git a/fuel-tx/src/transaction/types.rs b/fuel-tx/src/transaction/types.rs
index 61f619dd0..8b39ae372 100644
--- a/fuel-tx/src/transaction/types.rs
+++ b/fuel-tx/src/transaction/types.rs
@@ -18,7 +18,6 @@ pub use storage::StorageSlot;
 pub use utxo_id::UtxoId;
 pub use witness::Witness;
 
-#[cfg(feature = "std")]
 pub fn compute_transaction_id<T: fuel_types::canonical::SerializedSize>(
     chain_id: &fuel_types::ChainId,
     tx: &mut T,
diff --git a/fuel-tx/src/transaction/types/create.rs b/fuel-tx/src/transaction/types/create.rs
index 31b4fcec9..fb5345166 100644
--- a/fuel-tx/src/transaction/types/create.rs
+++ b/fuel-tx/src/transaction/types/create.rs
@@ -35,6 +35,7 @@ use fuel_types::{
     canonical::SerializedSize,
     BlockHeight,
     Bytes32,
+    ChainId,
     ContractId,
     Salt,
     Word,
@@ -42,10 +43,8 @@ use fuel_types::{
 
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
-#[cfg(feature = "std")]
-use fuel_types::ChainId;
-#[cfg(feature = "std")]
-use std::collections::HashMap;
+
+use hashbrown::HashMap;
 
 #[cfg(all(test, feature = "std"))]
 mod ser_de_tests;
@@ -66,7 +65,6 @@ pub struct CreateMetadata {
     pub witnesses_offset_at: Vec<usize>,
 }
 
-#[cfg(feature = "std")]
 impl CreateMetadata {
     /// Computes the `Metadata` for the `tx` transaction.
     pub fn compute(tx: &Create, chain_id: &ChainId) -> Result<Self, CheckError> {
@@ -134,7 +132,6 @@ impl Create {
     }
 }
 
-#[cfg(feature = "std")]
 impl crate::UniqueIdentifier for Create {
     fn id(&self, chain_id: &ChainId) -> crate::TxId {
         if let Some(id) = self.cached_id() {
@@ -189,7 +186,6 @@ impl Chargeable for Create {
 }
 
 impl FormatValidityChecks for Create {
-    #[cfg(feature = "std")]
     fn check_signatures(&self, chain_id: &ChainId) -> Result<(), CheckError> {
         use crate::UniqueIdentifier;
 
@@ -289,22 +285,8 @@ impl FormatValidityChecks for Create {
             if let Some(metadata) = &self.metadata {
                 (metadata.state_root, metadata.contract_id)
             } else {
-                #[cfg(feature = "std")]
-                {
-                    let metadata = CreateMetadata::compute(self, chain_id)?;
-                    (metadata.state_root, metadata.contract_id)
-                }
-
-                #[cfg(not(feature = "std"))]
-                {
-                    let salt = self.salt();
-                    let storage_slots = self.storage_slots();
-                    let contract = Contract::try_from(self)?;
-                    let contract_root = contract.root();
-                    let state_root = Contract::initial_state_root(storage_slots.iter());
-                    let contract_id = contract.id(salt, &contract_root, &state_root);
-                    (state_root, contract_id)
-                }
+                let metadata = CreateMetadata::compute(self, chain_id)?;
+                (metadata.state_root, metadata.contract_id)
             };
 
         let mut contract_created = false;
@@ -359,7 +341,6 @@ impl FormatValidityChecks for Create {
     }
 }
 
-#[cfg(feature = "std")]
 impl crate::Cacheable for Create {
     fn is_computed(&self) -> bool {
         self.metadata.is_some()
diff --git a/fuel-tx/src/transaction/types/input.rs b/fuel-tx/src/transaction/types/input.rs
index 7151557e9..a7acace05 100644
--- a/fuel-tx/src/transaction/types/input.rs
+++ b/fuel-tx/src/transaction/types/input.rs
@@ -808,7 +808,6 @@ impl Input {
         (*hasher.digest()).into()
     }
 
-    #[cfg(feature = "std")]
     pub fn is_predicate_owner_valid<P>(
         owner: &Address,
         predicate: P,
diff --git a/fuel-tx/src/transaction/types/mint.rs b/fuel-tx/src/transaction/types/mint.rs
index c9d9999d9..1a7022a39 100644
--- a/fuel-tx/src/transaction/types/mint.rs
+++ b/fuel-tx/src/transaction/types/mint.rs
@@ -20,7 +20,6 @@ use fuel_types::{
     Bytes32,
 };
 
-#[cfg(feature = "std")]
 use fuel_types::ChainId;
 
 #[cfg(feature = "alloc")]
@@ -33,7 +32,6 @@ pub(crate) struct MintMetadata {
     pub outputs_offset_at: Vec<usize>,
 }
 
-#[cfg(feature = "std")]
 impl MintMetadata {
     fn compute<Tx>(tx: &Tx, chain_id: &ChainId) -> Self
     where
@@ -89,7 +87,6 @@ pub struct Mint {
     pub(crate) metadata: Option<MintMetadata>,
 }
 
-#[cfg(feature = "std")]
 impl crate::UniqueIdentifier for Mint {
     fn id(&self, chain_id: &ChainId) -> Bytes32 {
         if let Some(id) = self.cached_id() {
@@ -106,7 +103,6 @@ impl crate::UniqueIdentifier for Mint {
 }
 
 impl FormatValidityChecks for Mint {
-    #[cfg(feature = "std")]
     fn check_signatures(&self, _: &ChainId) -> Result<(), CheckError> {
         Ok(())
     }
@@ -142,7 +138,6 @@ impl FormatValidityChecks for Mint {
     }
 }
 
-#[cfg(feature = "std")]
 impl crate::Cacheable for Mint {
     fn is_computed(&self) -> bool {
         self.metadata.is_some()
diff --git a/fuel-tx/src/transaction/types/output.rs b/fuel-tx/src/transaction/types/output.rs
index baa6599e2..1ab0e2e9d 100644
--- a/fuel-tx/src/transaction/types/output.rs
+++ b/fuel-tx/src/transaction/types/output.rs
@@ -223,7 +223,6 @@ impl Output {
     }
 
     /// Prepare the output for VM initialization for script execution
-    #[cfg(feature = "std")]
     pub fn prepare_init_script(&mut self) {
         match self {
             Output::Change { amount, .. } => {
diff --git a/fuel-tx/src/transaction/types/script.rs b/fuel-tx/src/transaction/types/script.rs
index a564d9975..e6b425c4a 100644
--- a/fuel-tx/src/transaction/types/script.rs
+++ b/fuel-tx/src/transaction/types/script.rs
@@ -34,15 +34,13 @@ use fuel_types::{
     fmt_truncated_hex,
     BlockHeight,
     Bytes32,
+    ChainId,
     Word,
 };
 
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
-#[cfg(feature = "std")]
-use fuel_types::ChainId;
-#[cfg(feature = "std")]
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct ScriptMetadata {
@@ -95,7 +93,6 @@ impl Default for Script {
     }
 }
 
-#[cfg(feature = "std")]
 impl crate::UniqueIdentifier for Script {
     fn id(&self, chain_id: &ChainId) -> Bytes32 {
         if let Some(id) = self.cached_id() {
@@ -151,7 +148,6 @@ impl Chargeable for Script {
 }
 
 impl FormatValidityChecks for Script {
-    #[cfg(feature = "std")]
     fn check_signatures(&self, chain_id: &ChainId) -> Result<(), CheckError> {
         use crate::UniqueIdentifier;
 
@@ -211,7 +207,6 @@ impl FormatValidityChecks for Script {
     }
 }
 
-#[cfg(feature = "std")]
 impl crate::Cacheable for Script {
     fn is_computed(&self) -> bool {
         self.metadata.is_some()
diff --git a/fuel-tx/src/transaction/types/witness.rs b/fuel-tx/src/transaction/types/witness.rs
index ca2bcf0b1..8188608db 100644
--- a/fuel-tx/src/transaction/types/witness.rs
+++ b/fuel-tx/src/transaction/types/witness.rs
@@ -3,13 +3,11 @@ use fuel_types::fmt_truncated_hex;
 
 use alloc::vec::Vec;
 
-#[cfg(feature = "std")]
 use crate::{
     CheckError,
     Input,
     TxId,
 };
-#[cfg(feature = "std")]
 use fuel_crypto::{
     Message,
     Signature,
@@ -47,7 +45,6 @@ impl Witness {
     }
 
     /// ECRecover an address from a witness
-    #[cfg(feature = "std")]
     pub fn recover_witness(
         &self,
         txhash: &TxId,
diff --git a/fuel-tx/src/transaction/validity.rs b/fuel-tx/src/transaction/validity.rs
index 95633bd9e..2fc8f1be4 100644
--- a/fuel-tx/src/transaction/validity.rs
+++ b/fuel-tx/src/transaction/validity.rs
@@ -11,19 +11,16 @@ use fuel_types::{
     BlockHeight,
 };
 
-#[cfg(feature = "std")]
 use crate::Transaction;
 
-#[cfg(feature = "std")]
 use fuel_types::{
     Address,
     Bytes32,
     ChainId,
 };
 
+use hashbrown::HashMap;
 use itertools::Itertools;
-#[cfg(feature = "std")]
-use std::collections::HashMap;
 
 mod error;
 
@@ -52,7 +49,6 @@ use crate::{
 pub use error::CheckError;
 
 impl Input {
-    #[cfg(feature = "std")]
     pub fn check(
         &self,
         index: usize,
@@ -69,7 +65,6 @@ impl Input {
         Ok(())
     }
 
-    #[cfg(feature = "std")]
     pub fn check_signature(
         &self,
         index: usize,
@@ -247,7 +242,6 @@ impl Output {
 /// such as spendable input balances or remaining gas. Primarily involves validating that
 /// transaction fields are correctly formatted and signed.
 pub trait FormatValidityChecks {
-    #[cfg(feature = "std")]
     /// Performs all stateless transaction validity checks. This includes the validity
     /// of fields according to rules in the specification and validity of signatures.
     fn check(
@@ -261,7 +255,6 @@ pub trait FormatValidityChecks {
         Ok(())
     }
 
-    #[cfg(feature = "std")]
     /// Validates that all required signatures are set in the transaction and that they
     /// are valid.
     fn check_signatures(&self, chain_id: &ChainId) -> Result<(), CheckError>;
@@ -275,7 +268,6 @@ pub trait FormatValidityChecks {
     ) -> Result<(), CheckError>;
 }
 
-#[cfg(feature = "std")]
 impl FormatValidityChecks for Transaction {
     fn check_signatures(&self, chain_id: &ChainId) -> Result<(), CheckError> {
         match self {
diff --git a/fuel-tx/src/transaction/validity/error.rs b/fuel-tx/src/transaction/validity/error.rs
index 472719574..009b231ad 100644
--- a/fuel-tx/src/transaction/validity/error.rs
+++ b/fuel-tx/src/transaction/validity/error.rs
@@ -6,14 +6,10 @@ use fuel_types::{
     ContractId,
     MessageId,
 };
-#[cfg(feature = "std")]
-use std::{
-    error,
-    io,
-};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
 #[non_exhaustive]
 pub enum CheckError {
     /// Transaction doesn't have spendable input message or coin.
@@ -134,17 +130,3 @@ impl fmt::Display for CheckError {
         write!(f, "{self:?}")
     }
 }
-
-#[cfg(feature = "std")]
-impl error::Error for CheckError {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<CheckError> for io::Error {
-    fn from(v: CheckError) -> io::Error {
-        io::Error::new(io::ErrorKind::Other, v)
-    }
-}
diff --git a/fuel-tx/test-helpers/src/lib.rs b/fuel-tx/test-helpers/src/lib.rs
index 59391d2a1..c4d3dd555 100644
--- a/fuel-tx/test-helpers/src/lib.rs
+++ b/fuel-tx/test-helpers/src/lib.rs
@@ -40,6 +40,7 @@ where
 
 #[cfg(feature = "std")]
 mod use_std {
+    use core::marker::PhantomData;
     use fuel_crypto::SecretKey;
     use fuel_tx::{
         field,
@@ -65,7 +66,6 @@ mod use_std {
         Rng,
         SeedableRng,
     };
-    use std::marker::PhantomData;
 
     use crate::{
         generate_bytes,
diff --git a/fuel-vm/Cargo.toml b/fuel-vm/Cargo.toml
index d122ee47f..d2fc234b7 100644
--- a/fuel-vm/Cargo.toml
+++ b/fuel-vm/Cargo.toml
@@ -18,28 +18,31 @@ bitflags = "1"
 derivative = "2.2"
 dyn-clone = { version = "1.0", optional = true }
 ethnum = "1.3"
-fuel-asm = { workspace = true }
+fuel-asm = { workspace = true, default-features = false }
 fuel-crypto = { workspace = true, default-features = false }
-fuel-merkle = { workspace = true }
+fuel-merkle = { workspace = true, default-features = false }
 fuel-storage = { workspace = true }
-fuel-tx = { workspace = true, features = ["builder", "std"] }
-fuel-types = { workspace = true }
-itertools = "0.10"
+fuel-tx = { workspace = true, default-features = false }
+fuel-types = { workspace = true, default-features = false }
+hashbrown = "0.14"
+itertools = { version = "0.10", default-features = false }
+libm = { version = "0.2", default-features = false }
 paste = "1.0"
+percent-encoding = { version = "2.3", features = ["alloc"], default-features = false }
 primitive-types = { version = "0.12", default-features = false }
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }
-sha3 = "0.10"
+sha3 = { version = "0.10", default-features = false }
 static_assertions = "1.1"
-strum = { version = "0.24", features = ["derive"], optional = true }
-tai64 = "4.0"
-thiserror = "1.0"
+strum = { version = "0.24", features = ["derive"], default-features = false }
+tai64 = { version = "4.0", default-features = false }
+thiserror = { version = "1.0", optional = true }
 
 [dev-dependencies]
 ed25519-dalek = { version = "2.0.0", features = ["rand_core"] }
 fuel-crypto = { workspace = true, features = ["test-helpers"] }
 fuel-tx = { workspace = true, features = ["builder"] }
-fuel-vm = { path = ".", default-features = false, features = ["test-helpers", "serde", "profile-coverage", "profile-gas"] }
+fuel-vm = { path = ".", default-features = false, features = ["test-helpers", "serde", "profile-coverage", "profile-gas", "random"] }
 futures = "0.3.28"
 num-integer = "0.1.45"
 p256 = "0.13"
@@ -54,12 +57,12 @@ tokio-rayon = "2.1.0"
 
 [features]
 default = ["std"]
-std = ["fuel-crypto/std"]
+std = ["alloc", "fuel-crypto/std", "fuel-types/std", "fuel-asm/std", "fuel-tx/std", "itertools/use_std", "thiserror"]
+alloc = ["fuel-asm/alloc", "fuel-tx/alloc", "fuel-tx/builder"]
 arbitrary = ["fuel-asm/arbitrary"]
-optimized = []
 profile-gas = ["profile-any"]
 profile-coverage = ["profile-any"]
 profile-any = ["dyn-clone"] # All profiling features should depend on this
 random = ["fuel-crypto/random", "fuel-types/random", "fuel-tx/random", "rand"]
-serde = ["dep:serde", "fuel-asm/serde", "fuel-types/serde", "fuel-tx/serde"]
-test-helpers = ["fuel-tx/builder", "random", "dep:anyhow", "fuel-crypto/test-helpers"]
+serde = ["dep:serde", "hashbrown/serde", "fuel-asm/serde", "fuel-types/serde", "fuel-tx/serde"]
+test-helpers = ["fuel-tx/builder", "alloc", "random", "dep:anyhow", "fuel-crypto/test-helpers"]
diff --git a/fuel-vm/src/arith.rs b/fuel-vm/src/arith.rs
index d7247a1eb..87c63959e 100644
--- a/fuel-vm/src/arith.rs
+++ b/fuel-vm/src/arith.rs
@@ -5,8 +5,6 @@ use fuel_asm::{
     Word,
 };
 
-use crate::error::RuntimeError;
-
 /// Add two unchecked words, returning an error if overflow
 #[inline(always)]
 pub fn checked_add_word(a: Word, b: Word) -> Result<Word, PanicReason> {
@@ -30,55 +28,3 @@ pub fn checked_add_usize(a: usize, b: usize) -> Result<usize, PanicReason> {
 pub fn checked_sub_usize(a: usize, b: usize) -> Result<usize, PanicReason> {
     a.checked_sub(b).ok_or(PanicReason::ArithmeticOverflow)
 }
-
-/// Add two checked words. Might wrap if overflow
-///
-/// The function is inlined so it will be optimized to `a + b` if `optimized` feature is
-/// enabled so the operation is unchecked.
-///
-/// This should be used in contexts that are checked and guaranteed by the protocol to
-/// never overflow, but then they might due to some bug in the code.
-#[inline(always)]
-pub fn add_word(a: Word, b: Word) -> Result<Word, RuntimeError> {
-    #[cfg(feature = "optimized")]
-    #[allow(clippy::arithmetic_side_effects)]
-    {
-        Ok(a + b)
-    }
-
-    #[cfg(not(feature = "optimized"))]
-    {
-        a.checked_add(b)
-            .ok_or_else(|| RuntimeError::unexpected_behavior("unexpected overflow"))
-    }
-}
-
-/// Subtract two checked words. Might wrap if overflow
-///
-/// The function is inlined so it will be optimized to `a + b` if `optimized` feature is
-/// enabled so the operation is unchecked.
-///
-/// This should be used in contexts that are checked and guaranteed by the protocol to
-/// never overflow, but then they might due to some bug in the code.
-#[inline(always)]
-#[allow(clippy::arithmetic_side_effects)]
-pub fn sub_word(a: Word, b: Word) -> Result<Word, RuntimeError> {
-    #[cfg(feature = "optimized")]
-    {
-        Ok(a - b)
-    }
-
-    #[cfg(not(feature = "optimized"))]
-    {
-        a.checked_sub(b)
-            .ok_or_else(|| RuntimeError::unexpected_behavior("unexpected underflow"))
-    }
-}
-
-/// Add two numbers. Should be used only in compile-time evaluations so the code won't
-/// compile in case of unexpected overflow.
-#[inline(always)]
-#[allow(clippy::arithmetic_side_effects)]
-pub const fn add_usize(a: usize, b: usize) -> usize {
-    a + b
-}
diff --git a/fuel-vm/src/backtrace.rs b/fuel-vm/src/backtrace.rs
index a139b74ba..dd5dad788 100644
--- a/fuel-vm/src/backtrace.rs
+++ b/fuel-vm/src/backtrace.rs
@@ -2,6 +2,11 @@
 //!
 //! As of the moment, doesn't support predicates.
 
+use alloc::{
+    borrow::ToOwned,
+    vec::Vec,
+};
+
 use crate::{
     call::CallFrame,
     consts::*,
diff --git a/fuel-vm/src/call.rs b/fuel-vm/src/call.rs
index a80321a1a..75cbaf676 100644
--- a/fuel-vm/src/call.rs
+++ b/fuel-vm/src/call.rs
@@ -211,7 +211,7 @@ impl TryFrom<&[u8]> for Call {
 }
 
 #[cfg(test)]
-impl From<Call> for Vec<u8> {
+impl From<Call> for alloc::vec::Vec<u8> {
     fn from(call: Call) -> Self {
         use fuel_types::canonical::SerializedSize;
         call.to_bytes()
@@ -219,7 +219,7 @@ impl From<Call> for Vec<u8> {
 }
 
 #[cfg(test)]
-impl From<CallFrame> for Vec<u8> {
+impl From<CallFrame> for alloc::vec::Vec<u8> {
     fn from(call: CallFrame) -> Self {
         use fuel_types::canonical::SerializedSize;
         call.to_bytes()
diff --git a/fuel-vm/src/checked_transaction.rs b/fuel-vm/src/checked_transaction.rs
index f0aaba303..84818af81 100644
--- a/fuel-vm/src/checked_transaction.rs
+++ b/fuel-vm/src/checked_transaction.rs
@@ -19,9 +19,16 @@ use fuel_types::{
     ChainId,
 };
 
-use core::borrow::Borrow;
+use alloc::{
+    boxed::Box,
+    vec::Vec,
+};
+use core::{
+    borrow::Borrow,
+    future::Future,
+};
+
 use fuel_tx::ConsensusParameters;
-use std::future::Future;
 
 mod balances;
 pub mod builder;
@@ -607,9 +614,11 @@ impl IntoChecked for Transaction {
     }
 }
 
+#[cfg(feature = "random")]
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::vec;
     use fuel_asm::op;
     use fuel_crypto::SecretKey;
     use fuel_tx::{
@@ -1069,6 +1078,7 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "std")]
     #[test]
     fn basic_check_marks_basic_flag() {
         let block_height = 1.into();
diff --git a/fuel-vm/src/checked_transaction/balances.rs b/fuel-vm/src/checked_transaction/balances.rs
index 45d047319..dae1c9bf3 100644
--- a/fuel-vm/src/checked_transaction/balances.rs
+++ b/fuel-vm/src/checked_transaction/balances.rs
@@ -23,7 +23,8 @@ use fuel_types::{
     AssetId,
     Word,
 };
-use std::collections::BTreeMap;
+
+use alloc::collections::BTreeMap;
 
 pub(crate) fn initial_free_balances<T>(
     transaction: &T,
diff --git a/fuel-vm/src/checked_transaction/builder.rs b/fuel-vm/src/checked_transaction/builder.rs
index 4f4b6ccad..ebc18eae3 100644
--- a/fuel-vm/src/checked_transaction/builder.rs
+++ b/fuel-vm/src/checked_transaction/builder.rs
@@ -8,6 +8,10 @@ use crate::{
     checked_transaction::CheckPredicates,
     prelude::*,
 };
+use fuel_tx::{
+    Finalizable,
+    TransactionBuilder,
+};
 use fuel_types::BlockHeight;
 
 /// Extension trait for [`fuel_tx::TransactionBuilder`] adding finalization methods
diff --git a/fuel-vm/src/checked_transaction/types.rs b/fuel-vm/src/checked_transaction/types.rs
index fe684bfcb..bab5011d9 100644
--- a/fuel-vm/src/checked_transaction/types.rs
+++ b/fuel-vm/src/checked_transaction/types.rs
@@ -4,11 +4,11 @@ pub use self::{
     create::CheckedMetadata as CreateCheckedMetadata,
     script::CheckedMetadata as ScriptCheckedMetadata,
 };
+use alloc::collections::BTreeMap;
 use fuel_types::{
     AssetId,
     Word,
 };
-use std::collections::BTreeMap;
 
 /// The spendable unrestricted initial assets.
 /// More information about it in the specification:
diff --git a/fuel-vm/src/constraints.rs b/fuel-vm/src/constraints.rs
index a845d2786..730c0ecbf 100644
--- a/fuel-vm/src/constraints.rs
+++ b/fuel-vm/src/constraints.rs
@@ -1,10 +1,13 @@
 //! Types to help constrain inputs to functions to only what is used.
-use std::ops::{
+use core::ops::{
     Deref,
     DerefMut,
 };
 
-use fuel_asm::Word;
+use fuel_asm::{
+    PanicReason,
+    Word,
+};
 use fuel_types::ContractId;
 
 #[cfg(test)]
@@ -12,10 +15,7 @@ use fuel_types::canonical::Deserialize;
 
 use crate::{
     consts::MEM_SIZE,
-    prelude::{
-        MemoryRange,
-        RuntimeError,
-    },
+    prelude::MemoryRange,
 };
 
 pub mod reg_key;
@@ -34,7 +34,7 @@ pub struct CheckedMemValue<T>(MemoryRange, core::marker::PhantomData<T>);
 
 impl<T> CheckedMemValue<T> {
     /// Create a new const sized memory range.
-    pub fn new<const SIZE: usize>(address: Word) -> Result<Self, RuntimeError> {
+    pub fn new<const SIZE: usize>(address: Word) -> Result<Self, PanicReason> {
         Ok(Self(
             MemoryRange::new_const::<_, SIZE>(address)?,
             core::marker::PhantomData,
@@ -42,10 +42,10 @@ impl<T> CheckedMemValue<T> {
     }
 
     /// Try to read a value of type `T` from memory.
-    pub fn try_from(self, memory: &[u8; MEM_SIZE]) -> Result<T, RuntimeError>
+    pub fn try_from(self, memory: &[u8; MEM_SIZE]) -> Result<T, PanicReason>
     where
         T: for<'a> TryFrom<&'a [u8]>,
-        RuntimeError: for<'a> From<<T as TryFrom<&'a [u8]>>::Error>,
+        PanicReason: for<'a> From<<T as TryFrom<&'a [u8]>>::Error>,
     {
         Ok(T::try_from(&memory[self.0.usizes()])?)
     }
@@ -73,7 +73,7 @@ impl<T> CheckedMemValue<T> {
 
 impl<const LEN: usize> CheckedMemConstLen<LEN> {
     /// Create a new const sized memory range.
-    pub fn new(address: Word) -> Result<Self, RuntimeError> {
+    pub fn new(address: Word) -> Result<Self, PanicReason> {
         Ok(Self(MemoryRange::new_const::<_, LEN>(address)?))
     }
 
diff --git a/fuel-vm/src/constraints/reg_key.rs b/fuel-vm/src/constraints/reg_key.rs
index 52c4f029c..870188ed0 100644
--- a/fuel-vm/src/constraints/reg_key.rs
+++ b/fuel-vm/src/constraints/reg_key.rs
@@ -2,7 +2,7 @@
 //! the register index is valid.
 //!
 //! This module also provides utilities for mutably accessing multiple registers.
-use std::ops::{
+use core::ops::{
     Deref,
     DerefMut,
 };
@@ -14,13 +14,10 @@ use fuel_asm::{
     Word,
 };
 
-use crate::{
-    consts::{
-        VM_REGISTER_COUNT,
-        VM_REGISTER_PROGRAM_COUNT,
-        VM_REGISTER_SYSTEM_COUNT,
-    },
-    prelude::RuntimeError,
+use crate::consts::{
+    VM_REGISTER_COUNT,
+    VM_REGISTER_PROGRAM_COUNT,
+    VM_REGISTER_SYSTEM_COUNT,
 };
 
 #[cfg(test)]
@@ -42,7 +39,7 @@ pub struct WriteRegKey(usize);
 impl WriteRegKey {
     /// Create a new writable register key if the index is within the bounds
     /// of the writable registers.
-    pub fn new(k: impl Into<usize>) -> Result<Self, RuntimeError> {
+    pub fn new(k: impl Into<usize>) -> Result<Self, PanicReason> {
         let k = k.into();
         is_register_writable(&k)?;
         Ok(Self(k))
@@ -59,15 +56,13 @@ impl WriteRegKey {
 
 /// Check that the register is above the system registers and below the total
 /// number of registers.
-pub(crate) fn is_register_writable(r: &RegisterId) -> Result<(), RuntimeError> {
+pub(crate) fn is_register_writable(r: &RegisterId) -> Result<(), PanicReason> {
     const W_USIZE: usize = RegId::WRITABLE.to_u8() as usize;
     const RANGE: core::ops::Range<usize> = W_USIZE..(W_USIZE + VM_REGISTER_PROGRAM_COUNT);
     if RANGE.contains(r) {
         Ok(())
     } else {
-        Err(RuntimeError::Recoverable(
-            PanicReason::ReservedRegisterNotWritable,
-        ))
+        Err(PanicReason::ReservedRegisterNotWritable)
     }
 }
 
@@ -284,7 +279,7 @@ impl<'r> ProgramRegisters<'r> {
         b: WriteRegKey,
     ) -> Option<(&mut Word, &mut Word)> {
         match a.cmp(&b) {
-            std::cmp::Ordering::Less => {
+            core::cmp::Ordering::Less => {
                 // Translate the `a` absolute register index to a program register index.
                 let a = a.translate();
                 // Split the array at the first register which is a.
@@ -300,8 +295,8 @@ impl<'r> ProgramRegisters<'r> {
                 Some((i, j))
             }
             // Cannot mutably borrow the same register twice.
-            std::cmp::Ordering::Equal => None,
-            std::cmp::Ordering::Greater => {
+            core::cmp::Ordering::Equal => None,
+            core::cmp::Ordering::Greater => {
                 // Translate the `b` absolute register index to a program register index.
                 let b = b.translate();
                 // Split the array at the first register which is b.
@@ -379,7 +374,7 @@ impl<'a> From<ProgramRegisters<'a>> for ProgramRegistersRef<'a> {
 }
 
 impl TryFrom<RegisterId> for WriteRegKey {
-    type Error = RuntimeError;
+    type Error = PanicReason;
 
     fn try_from(r: RegisterId) -> Result<Self, Self::Error> {
         Self::new(r)
diff --git a/fuel-vm/src/constraints/reg_key/tests.rs b/fuel-vm/src/constraints/reg_key/tests.rs
index 7d5ae2509..a10ee47ad 100644
--- a/fuel-vm/src/constraints/reg_key/tests.rs
+++ b/fuel-vm/src/constraints/reg_key/tests.rs
@@ -1,10 +1,12 @@
+use alloc::vec::Vec;
+
 use super::*;
 use test_case::test_case;
 
 #[test]
 fn can_split() {
     let mut reg: [Word; VM_REGISTER_COUNT] =
-        std::iter::successors(Some(0), |x| Some(x + 1))
+        core::iter::successors(Some(0), |x| Some(x + 1))
             .take(VM_REGISTER_COUNT)
             .collect::<Vec<_>>()
             .try_into()
@@ -71,7 +73,7 @@ fn can_split() {
 #[test_case(4, 2 => Some((4, 2)))]
 fn can_split_writes(a: usize, b: usize) -> Option<(Word, Word)> {
     let mut reg: [Word; VM_REGISTER_PROGRAM_COUNT] =
-        std::iter::successors(Some(0), |x| Some(x + 1))
+        core::iter::successors(Some(0), |x| Some(x + 1))
             .take(VM_REGISTER_PROGRAM_COUNT)
             .collect::<Vec<_>>()
             .try_into()
diff --git a/fuel-vm/src/consts.rs b/fuel-vm/src/consts.rs
index 619966589..b5c9cd857 100644
--- a/fuel-vm/src/consts.rs
+++ b/fuel-vm/src/consts.rs
@@ -5,7 +5,7 @@ use fuel_types::{
     Word,
 };
 
-use std::mem;
+use core::mem;
 
 /// Register count for checking constraints
 pub const VM_REGISTER_COUNT: usize = 64;
diff --git a/fuel-vm/src/crypto.rs b/fuel-vm/src/crypto.rs
index 584fbbf48..d3c010ac2 100644
--- a/fuel-vm/src/crypto.rs
+++ b/fuel-vm/src/crypto.rs
@@ -24,6 +24,11 @@ fn ephemeral_merkle_root_returns_the_expected_root() {
         SeedableRng,
     };
 
+    use alloc::{
+        vec,
+        vec::Vec,
+    };
+
     use crate::prelude::*;
 
     let mut rng = StdRng::seed_from_u64(2322u64);
diff --git a/fuel-vm/src/error.rs b/fuel-vm/src/error.rs
index 74a5b2657..0f6972d09 100644
--- a/fuel-vm/src/error.rs
+++ b/fuel-vm/src/error.rs
@@ -6,49 +6,61 @@ use fuel_asm::{
     RawInstruction,
 };
 use fuel_tx::CheckError;
+
+#[cfg(feature = "std")]
 use thiserror::Error;
 
-use std::{
-    convert::Infallible as StdInfallible,
-    error::Error as StdError,
+use alloc::{
+    format,
+    string::{
+        String,
+        ToString,
+    },
+};
+use core::{
+    convert::Infallible,
     fmt,
-    io,
 };
 
+use crate::storage::predicate;
+
 /// Interpreter runtime error variants.
-#[derive(Debug, Error)]
-pub enum InterpreterError {
+#[cfg_attr(feature = "std", derive(Error))]
+#[derive(Debug)]
+pub enum InterpreterError<StorageError> {
     /// The instructions execution resulted in a well-formed panic, caused by an
     /// explicit instruction.
-    #[error("Execution error: {0:?}")]
+    #[cfg_attr(feature = "std", error("Execution error: {0:?}"))]
     PanicInstruction(PanicInstruction),
     /// The VM execution resulted in a well-formed panic. This panic wasn't
     /// caused by an instruction contained in the transaction or a called
     /// contract.
-    #[error("Execution error: {0:?}")]
+    #[cfg_attr(feature = "std", error("Execution error: {0:?}"))]
     Panic(PanicReason),
     /// The provided transaction isn't valid.
-    #[error("Failed to check the transaction: {0}")]
-    CheckError(#[from] CheckError),
-    /// The predicate verification failed.
-    #[error("Execution error")]
-    PredicateFailure,
+    #[cfg_attr(feature = "std", error("Failed to check the transaction: {0}"))]
+    CheckError(CheckError),
     /// No transaction was initialized in the interpreter. It cannot provide
     /// state transitions.
-    #[error("Execution error")]
+    #[cfg_attr(feature = "std", error("Execution error"))]
     NoTransactionInitialized,
-    /// I/O and OS related errors.
-    #[error("Unrecoverable error: {0}")]
-    Io(#[from] io::Error),
-
-    #[error("Execution error")]
+    #[cfg_attr(feature = "std", error("Execution error"))]
     /// The debug state is not initialized; debug routines can't be called.
     DebugStateNotInitialized,
+    /// Storage I/O error
+    #[cfg_attr(feature = "std", error("Storage error: {0}"))]
+    Storage(StorageError),
+    /// Encountered a bug
+    #[cfg_attr(feature = "std", error("Bug: {0}"))]
+    Bug(Bug),
 }
 
-impl InterpreterError {
+impl<StorageError> InterpreterError<StorageError> {
     /// Describe the error as recoverable or halt.
-    pub fn from_runtime(error: RuntimeError, instruction: RawInstruction) -> Self {
+    pub fn from_runtime(
+        error: RuntimeError<StorageError>,
+        instruction: RawInstruction,
+    ) -> Self {
         match error {
             RuntimeError::Recoverable(reason) => {
                 Self::PanicInstruction(PanicInstruction::error(reason, instruction))
@@ -82,41 +94,53 @@ impl InterpreterError {
             _ => None,
         }
     }
+}
 
-    /// Produces a `halt` error from `io`.
-    pub fn from_io<E>(e: E) -> Self
-    where
-        E: Into<io::Error>,
-    {
-        Self::Io(e.into())
+impl<StorageError> InterpreterError<StorageError>
+where
+    StorageError: fmt::Debug,
+{
+    /// Make non-generic by converting the storage error to a string.
+    pub fn erase_generics(&self) -> InterpreterError<String> {
+        match self {
+            Self::Storage(e) => InterpreterError::Storage(format!("{e:?}")),
+            Self::PanicInstruction(e) => InterpreterError::PanicInstruction(*e),
+            Self::Panic(e) => InterpreterError::Panic(*e),
+            Self::CheckError(e) => InterpreterError::CheckError(e.clone()),
+            Self::NoTransactionInitialized => InterpreterError::NoTransactionInitialized,
+            Self::DebugStateNotInitialized => InterpreterError::DebugStateNotInitialized,
+            Self::Bug(e) => InterpreterError::Bug(e.clone()),
+        }
     }
 }
 
-impl From<RuntimeError> for InterpreterError {
-    fn from(error: RuntimeError) -> Self {
+impl<StorageError> From<RuntimeError<StorageError>> for InterpreterError<StorageError> {
+    fn from(error: RuntimeError<StorageError>) -> Self {
         match error {
             RuntimeError::Recoverable(e) => Self::Panic(e),
-            RuntimeError::Halt(e) => Self::Io(e),
+            RuntimeError::Bug(e) => Self::Bug(e),
+            RuntimeError::Storage(e) => Self::Storage(e),
         }
     }
 }
 
-impl From<InterpreterError> for io::Error {
-    fn from(e: InterpreterError) -> Self {
-        io::Error::new(io::ErrorKind::Other, e)
+impl<StorageError> From<CheckError> for InterpreterError<StorageError> {
+    fn from(error: CheckError) -> Self {
+        Self::CheckError(error)
     }
 }
 
-impl PartialEq for InterpreterError {
+impl<StorageError> PartialEq for InterpreterError<StorageError>
+where
+    StorageError: PartialEq,
+{
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::PanicInstruction(s), Self::PanicInstruction(o)) => s == o,
             (Self::Panic(s), Self::Panic(o)) => s == o,
             (Self::CheckError(s), Self::CheckError(o)) => s == o,
-            (Self::PredicateFailure, Self::PredicateFailure) => true,
             (Self::NoTransactionInitialized, Self::NoTransactionInitialized) => true,
-            (Self::Io(s), Self::Io(o)) => s.kind() == o.kind(),
-
+            (Self::Storage(a), Self::Storage(b)) => a == b,
             (Self::DebugStateNotInitialized, Self::DebugStateNotInitialized) => true,
 
             _ => false,
@@ -124,19 +148,32 @@ impl PartialEq for InterpreterError {
     }
 }
 
-#[derive(Debug, Error)]
+impl<StorageError> From<Bug> for InterpreterError<StorageError> {
+    fn from(bug: Bug) -> Self {
+        Self::Bug(bug)
+    }
+}
+
+impl<StorageError> From<Infallible> for InterpreterError<StorageError> {
+    fn from(_: Infallible) -> Self {
+        unreachable!()
+    }
+}
+
 /// Runtime error description that should either be specified in the protocol or
 /// halt the execution.
-pub enum RuntimeError {
-    /// Specified error with well-formed fallback strategy.
-    #[error(transparent)]
-    Recoverable(#[from] PanicReason),
-    /// Unspecified error that should halt the execution.
-    #[error(transparent)]
-    Halt(#[from] io::Error), // TODO: a more generic error type
+#[derive(Debug)]
+#[must_use]
+pub enum RuntimeError<StorageError> {
+    /// Specified error with well-formed fallback strategy, i.e. vm panics.
+    Recoverable(PanicReason),
+    /// Invalid interpreter state reached unexpectedly, this is a bug
+    Bug(Bug),
+    /// Storage io error
+    Storage(StorageError),
 }
 
-impl RuntimeError {
+impl<StorageError> RuntimeError<StorageError> {
     /// Flag whether the error is recoverable.
     pub const fn is_recoverable(&self) -> bool {
         matches!(self, Self::Recoverable(_))
@@ -144,118 +181,113 @@ impl RuntimeError {
 
     /// Flag whether the error must halt the execution.
     pub const fn must_halt(&self) -> bool {
-        matches!(self, Self::Halt(_))
-    }
-
-    /// Produces a `halt` error from `io`.
-    pub fn from_io<E>(e: E) -> Self
-    where
-        E: Into<io::Error>,
-    {
-        Self::Halt(e.into())
-    }
-
-    /// Unexpected behavior occurred
-    pub fn unexpected_behavior<E>(error: E) -> Self
-    where
-        E: Into<Box<dyn StdError + Send + Sync>>,
-    {
-        Self::Halt(io::Error::new(io::ErrorKind::Other, error))
+        !self.is_recoverable()
     }
 }
 
-impl PartialEq for RuntimeError {
+impl<StorageError: PartialEq> PartialEq for RuntimeError<StorageError> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (RuntimeError::Recoverable(s), RuntimeError::Recoverable(o)) => s == o,
-            (RuntimeError::Halt(s), RuntimeError::Halt(o)) => s.kind() == o.kind(),
+            (RuntimeError::Recoverable(a), RuntimeError::Recoverable(b)) => a == b,
+            (RuntimeError::Bug(a), RuntimeError::Bug(b)) => a == b,
+            (RuntimeError::Storage(a), RuntimeError::Storage(b)) => a == b,
             _ => false,
         }
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-/// Infallible implementation that converts into [`io::Error`].
-pub struct Infallible(StdInfallible);
-
-impl fmt::Display for Infallible {
+impl<StorageError: core::fmt::Debug> fmt::Display for RuntimeError<StorageError> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl StdError for Infallible {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        Some(&self.0)
-    }
-}
-
-impl<E> From<E> for Infallible
-where
-    E: Into<StdInfallible>,
-{
-    fn from(e: E) -> Infallible {
-        Self(e.into())
+        match self {
+            Self::Recoverable(reason) => write!(f, "Recoverable error: {}", reason),
+            Self::Bug(err) => write!(f, "Bug: {}", err),
+            Self::Storage(err) => write!(f, "Unrecoverable storage error: {:?}", err),
+        }
     }
 }
 
-impl From<Infallible> for InterpreterError {
-    fn from(_e: Infallible) -> InterpreterError {
-        unreachable!()
+impl<StorageError> From<PanicReason> for RuntimeError<StorageError> {
+    fn from(value: PanicReason) -> Self {
+        Self::Recoverable(value)
     }
 }
 
-impl From<Infallible> for RuntimeError {
-    fn from(_e: Infallible) -> RuntimeError {
-        unreachable!()
+impl<StorageError> From<core::array::TryFromSliceError> for RuntimeError<StorageError> {
+    fn from(value: core::array::TryFromSliceError) -> Self {
+        Self::Recoverable(value.into())
     }
 }
 
-impl From<Infallible> for PanicReason {
-    fn from(_e: Infallible) -> PanicReason {
-        unreachable!()
+impl<StorageError> From<Bug> for RuntimeError<StorageError> {
+    fn from(bug: Bug) -> Self {
+        Self::Bug(bug)
     }
 }
 
-impl From<Infallible> for io::Error {
-    fn from(_e: Infallible) -> io::Error {
+impl<StorageError> From<Infallible> for RuntimeError<StorageError> {
+    fn from(_: Infallible) -> Self {
         unreachable!()
     }
 }
 
-impl From<core::array::TryFromSliceError> for RuntimeError {
-    fn from(value: core::array::TryFromSliceError) -> Self {
-        Self::Recoverable(value.into())
-    }
-}
-
 /// Predicates checking failed
-#[derive(Debug, Error)]
+#[cfg_attr(feature = "std", derive(Error))]
+#[derive(Debug)]
 pub enum PredicateVerificationFailed {
     /// The predicate did not use the amount of gas provided
-    #[error("Predicate used less than the required amount of gas")]
+    #[cfg_attr(
+        feature = "std",
+        error("Predicate used less than the required amount of gas")
+    )]
     GasMismatch,
     /// The transaction doesn't contain enough gas to evaluate the predicate
-    #[error("Insufficient gas available for single predicate")]
+    #[cfg_attr(
+        feature = "std",
+        error("Insufficient gas available for single predicate")
+    )]
     OutOfGas,
     /// The predicate owner does not correspond to the predicate code
-    #[error("Predicate owner invalid, doesn't match code root")]
+    #[cfg_attr(
+        feature = "std",
+        error("Predicate owner invalid, doesn't match code root")
+    )]
     InvalidOwner,
     /// The predicate wasn't successfully evaluated to true
-    #[error("Predicate failed to evaluate")]
+    #[cfg_attr(feature = "std", error("Predicate failed to evaluate"))]
     False,
     /// The predicate gas used was not specified before execution
-    #[error("Predicate failed to evaluate")]
+    #[cfg_attr(feature = "std", error("Predicate failed to evaluate"))]
     GasNotSpecified,
     /// The transaction doesn't contain enough gas to evaluate all predicates
-    #[error("Insufficient gas available for all predicates")]
+    #[cfg_attr(
+        feature = "std",
+        error("Insufficient gas available for all predicates")
+    )]
     CumulativePredicateGasExceededTxGasLimit,
     /// The cumulative gas overflowed the u64 accumulator
-    #[error("Cumulative gas computation overflowed the u64 accumulator")]
+    #[cfg_attr(
+        feature = "std",
+        error("Cumulative gas computation overflowed the u64 accumulator")
+    )]
     GasOverflow,
-    /// An unexpected error occurred.
-    #[error(transparent)]
-    Io(#[from] io::Error),
+    /// Invalid interpreter state reached unexpectedly, this is a bug
+    #[cfg_attr(
+        feature = "std",
+        error("Invalid interpreter state reached unexpectedly")
+    )]
+    Bug(Bug),
+    /// The VM execution resulted in a well-formed panic, caused by an instruction.
+    #[cfg_attr(feature = "std", error("Execution error: {0:?}"))]
+    PanicInstruction(PanicInstruction),
+    /// The VM execution resulted in a well-formed panic not caused by an instruction.
+    #[cfg_attr(feature = "std", error("Execution error: {0:?}"))]
+    Panic(PanicReason),
+    /// Predicate verification failed since it attempted to access storage
+    #[cfg_attr(
+        feature = "std",
+        error("Predicate verification failed since it attempted to access storage")
+    )]
+    Storage,
 }
 
 impl From<PredicateVerificationFailed> for CheckError {
@@ -267,121 +299,139 @@ impl From<PredicateVerificationFailed> for CheckError {
     }
 }
 
-impl From<InterpreterError> for PredicateVerificationFailed {
-    fn from(error: InterpreterError) -> Self {
+impl From<InterpreterError<predicate::StorageUnavailable>>
+    for PredicateVerificationFailed
+{
+    fn from(error: InterpreterError<predicate::StorageUnavailable>) -> Self {
         match error {
             error if error.panic_reason() == Some(PanicReason::OutOfGas) => {
                 PredicateVerificationFailed::OutOfGas
             }
-            InterpreterError::Io(e) => PredicateVerificationFailed::Io(e),
+            InterpreterError::Storage(_) => PredicateVerificationFailed::Storage,
             _ => PredicateVerificationFailed::False,
         }
     }
 }
 
-/// Unique bug identifier
-#[allow(missing_docs)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "strum", derive(strum::EnumVariantNames))]
-pub enum BugId {
-    // Not used
-    ID001,
-    ID002,
-    ID003,
-    ID004,
-    // Not used
-    ID005,
-    // Not used
-    ID006,
-    ID007,
-    ID008,
+impl From<Bug> for PredicateVerificationFailed {
+    fn from(bug: Bug) -> Self {
+        Self::Bug(bug)
+    }
+}
+
+impl From<PanicReason> for PredicateVerificationFailed {
+    fn from(reason: PanicReason) -> Self {
+        Self::Panic(reason)
+    }
+}
+
+impl From<PanicOrBug> for PredicateVerificationFailed {
+    fn from(err: PanicOrBug) -> Self {
+        match err {
+            PanicOrBug::Panic(reason) => Self::from(reason),
+            PanicOrBug::Bug(bug) => Self::Bug(bug),
+        }
+    }
 }
 
 /// Traceable bug variants
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumMessage)]
 pub enum BugVariant {
     /// Context gas increase has overflow
+    #[strum(
+        message = "The context gas cannot overflow since it was created by a valid transaction and the total gas does not increase - hence, it always fits a word."
+    )]
     ContextGasOverflow,
 
     /// Context gas increase has underflow
+    #[strum(
+        message = "The context gas cannot underflow since any script should halt upon gas exhaustion."
+    )]
     ContextGasUnderflow,
 
     /// Global gas subtraction has underflow
+    #[strum(
+        message = "The gas consumption cannot exceed the gas context since it is capped by the transaction gas limit."
+    )]
     GlobalGasUnderflow,
 
+    /// The global gas is less than the context gas.
+    #[strum(message = "The global gas cannot ever be less than the context gas. ")]
+    GlobalGasLessThanContext,
+
     /// The stack point has overflow
+    #[strum(message = "The stack pointer cannot overflow under checked operations.")]
     StackPointerOverflow,
 
-    /// The global gas is less than the context gas.
-    GlobalGasLessThanContext,
+    /// Code size of a contract doesn't fit into a Word. This is prevented by tx size
+    /// limit.
+    #[strum(message = "Contract size doesn't fit into a word.")]
+    CodeSizeOverflow,
+
+    /// Refund cannot be computed in the current vm state.
+    #[strum(message = "Refund cannot be computed in the current vm state.")]
+    UncomputableRefund,
 }
 
 impl fmt::Display for BugVariant {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::ContextGasOverflow => write!(
-                f,
-                r#"The context gas cannot overflow since it was created by a valid transaction and the total gas does not increase - hence, it always fits a word.
-
-                This overflow means the registers are corrupted."#
-            ),
-
-            Self::ContextGasUnderflow => write!(
-                f,
-                r#"The context gas cannot underflow since any script should halt upon gas exhaustion.
-
-                This underflow means the registers are corrupted."#
-            ),
-
-            Self::GlobalGasUnderflow => write!(
-                f,
-                r#"The gas consumption cannot exceed the gas context since it is capped by the transaction gas limit.
-
-                This underflow means the registers are corrupted."#
-            ),
-
-            Self::StackPointerOverflow => write!(
-                f,
-                r#"The stack pointer cannot overflow under checked operations.
-
-                This overflow means the registers are corrupted."#
-            ),
-
-            Self::GlobalGasLessThanContext => write!(
-                f,
-                r#"The global gas cannot ever be less than the context gas. 
-
-                This means the registers are corrupted."#
-            ),
+        use strum::EnumMessage;
+        if let Some(msg) = self.get_message() {
+            write!(f, "{}", msg)
+        } else {
+            write!(f, "{:?}", self)
         }
     }
 }
 
-/// Bug information with backtrace data
+/// VM encountered unexpected state. This is a bug.
+/// The execution must terminate since the VM is in an invalid state.
+///
+/// The bug it self is identified by the caller location.
 #[derive(Debug, Clone)]
+#[must_use]
 pub struct Bug {
-    id: BugId,
+    /// Source code location of the bug, in `path/to/file.rs:line:column` notation
+    location: String,
+
+    /// Type of bug
     variant: BugVariant,
 
+    /// Additional error message for the bug, if it's caused by a runtime error
+    inner_message: Option<String>,
+
+    /// Optionally include a backtrace for the instruction triggering this bug.
+    /// This is only available when the `backtrace` feature is enabled.
     #[cfg(feature = "backtrace")]
     bt: backtrace::Backtrace,
 }
 
 impl Bug {
-    #[cfg(not(feature = "backtrace"))]
-    /// Report a bug without backtrace data
-    pub const fn new(id: BugId, variant: BugVariant) -> Self {
-        Self { id, variant }
+    /// Construct a new bug with the specified variant, using caller location for
+    /// idenitfying the bug.
+    #[track_caller]
+    pub fn new(variant: BugVariant) -> Self {
+        let caller = core::panic::Location::caller();
+        let location = format!("{}:{}:{}", caller.file(), caller.line(), caller.column());
+        Self {
+            location,
+            variant,
+            inner_message: None,
+            #[cfg(feature = "backtrace")]
+            bt: backtrace::Backtrace::new(),
+        }
     }
 
-    /// Unique bug identifier per location
-    pub const fn id(&self) -> BugId {
-        self.id
+    /// Set an additional error message.
+    pub fn with_message<E: ToString>(mut self, error: E) -> Self {
+        self.inner_message = Some(error.to_string());
+        self
     }
+}
 
-    /// Class variant of the bug
-    pub const fn variant(&self) -> BugVariant {
-        self.variant
+impl PartialEq for Bug {
+    fn eq(&self, other: &Self) -> bool {
+        self.location == other.location
     }
 }
 
@@ -389,62 +439,124 @@ impl Bug {
 mod bt {
     use super::*;
     use backtrace::Backtrace;
-    use core::ops::Deref;
 
     impl Bug {
-        /// Report a bug with backtrace data
-        pub fn new(id: BugId, variant: BugVariant) -> Self {
-            let bt = Backtrace::new();
-
-            Self { id, variant, bt }
-        }
-
         /// Backtrace data
         pub const fn bt(&self) -> &Backtrace {
             &self.bt
         }
     }
-
-    impl Deref for Bug {
-        type Target = Backtrace;
-
-        fn deref(&self) -> &Self::Target {
-            &self.bt
-        }
-    }
 }
 
 impl fmt::Display for Bug {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use percent_encoding::{
+            utf8_percent_encode,
+            NON_ALPHANUMERIC,
+        };
+
+        let issue_title = format!("Bug report: {:?} in {}", self.variant, self.location);
+
+        let issue_body = format!(
+            "Error: {:?} {}\nLocation: {}\nVersion: {} {}\n",
+            self.variant,
+            self.inner_message
+                .as_ref()
+                .map(|msg| format!("({msg})"))
+                .unwrap_or_default(),
+            self.location,
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION")
+        );
+
         write!(
             f,
-            "This is a bug [{:?}]! Please, report this incident as an issue in fuel-vm repository\n\n",
-            self.id()
+            concat!(
+                "Encountered a bug! Please report this using the following link: ",
+                "https://github.com/FuelLabs/fuel-vm/issues/new",
+                "?title={}",
+                "&body={}",
+                "\n\n",
+                "{:?} error in {}: {} {}\n",
+            ),
+            utf8_percent_encode(&issue_title, NON_ALPHANUMERIC),
+            utf8_percent_encode(&issue_body, NON_ALPHANUMERIC),
+            self.variant,
+            self.location,
+            self.variant,
+            self.inner_message
+                .as_ref()
+                .map(|msg| format!("({msg})"))
+                .unwrap_or_default(),
         )?;
 
-        write!(f, "{}", self.variant())?;
+        #[cfg(feature = "backtrace")]
+        {
+            write!(f, "\nBacktrace:\n{:?}\n", self.bt)?;
+        }
 
         Ok(())
     }
 }
 
-impl StdError for Bug {}
+/// Runtime error description that should either be specified in the protocol or
+/// halt the execution.
+#[derive(Debug, Clone, PartialEq)]
+#[must_use]
+pub enum PanicOrBug {
+    /// VM panic
+    Panic(PanicReason),
+    /// Invalid interpreter state reached unexpectedly, this is a bug
+    Bug(Bug),
+}
 
-impl From<Bug> for RuntimeError {
-    fn from(bug: Bug) -> Self {
-        Self::Halt(io::Error::new(io::ErrorKind::Other, bug))
+impl From<PanicReason> for PanicOrBug {
+    fn from(panic: PanicReason) -> Self {
+        Self::Panic(panic)
     }
 }
 
-impl From<Bug> for InterpreterError {
+impl From<Bug> for PanicOrBug {
     fn from(bug: Bug) -> Self {
-        RuntimeError::from(bug).into()
+        Self::Bug(bug)
     }
 }
 
-impl From<Bug> for PredicateVerificationFailed {
-    fn from(bug: Bug) -> Self {
-        let e: InterpreterError = bug.into();
-        e.into()
+impl<StorageError> From<PanicOrBug> for RuntimeError<StorageError> {
+    fn from(value: PanicOrBug) -> Self {
+        match value {
+            PanicOrBug::Panic(reason) => Self::Recoverable(reason),
+            PanicOrBug::Bug(bug) => Self::Bug(bug),
+        }
+    }
+}
+
+impl<StorageError> From<PanicOrBug> for InterpreterError<StorageError> {
+    fn from(value: PanicOrBug) -> Self {
+        match value {
+            PanicOrBug::Panic(reason) => Self::Panic(reason),
+            PanicOrBug::Bug(bug) => Self::Bug(bug),
+        }
+    }
+}
+
+/// Result of a operation that doesn't access storage
+pub type SimpleResult<T> = Result<T, PanicOrBug>;
+
+/// Result of a operation that accesses storage
+pub type IoResult<T, S> = Result<T, RuntimeError<S>>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bug_report_message() {
+        let bug = Bug::new(BugVariant::ContextGasOverflow).with_message("Test message");
+        let text = format!("{}", bug);
+        assert!(text.contains(file!()));
+        assert!(text.contains("https://github.com/FuelLabs/fuel-vm/issues/new"));
+        assert!(text.contains("ContextGasOverflow"));
+        assert!(text.contains("Test message"));
     }
 }
diff --git a/fuel-vm/src/interpreter.rs b/fuel-vm/src/interpreter.rs
index 4d743d374..2322ab284 100644
--- a/fuel-vm/src/interpreter.rs
+++ b/fuel-vm/src/interpreter.rs
@@ -6,9 +6,14 @@ use crate::{
     constraints::reg_key::*,
     consts::*,
     context::Context,
+    error::SimpleResult,
     state::Debugger,
 };
-use std::{
+use alloc::{
+    borrow::ToOwned,
+    vec::Vec,
+};
+use core::{
     mem,
     ops::Index,
 };
@@ -354,9 +359,9 @@ pub trait ExecutableTransaction:
         &mut self,
         idx: usize,
         output: Output,
-    ) -> Result<(), PanicReason> {
+    ) -> SimpleResult<()> {
         if !output.is_variable() {
-            return Err(PanicReason::ExpectedOutputVariable)
+            return Err(PanicReason::ExpectedOutputVariable.into())
         }
 
         // TODO increase the error granularity for this case - create a new variant of
@@ -368,8 +373,8 @@ pub trait ExecutableTransaction:
                 _ => None,
             })
             .map(|o| mem::replace(o, output))
-            .map(|_| ())
-            .ok_or(PanicReason::OutputNotFound)
+            .ok_or(PanicReason::OutputNotFound)?;
+        Ok(())
     }
 
     /// Update change and variable outputs.
@@ -568,10 +573,10 @@ impl<'vm, I: Iterator<Item = &'vm ContractId>> InputContracts<'vm, I> {
     }
 
     /// Checks that the contract is declared in the transaction inputs.
-    pub fn check(&mut self, contract: &ContractId) -> Result<(), PanicReason> {
+    pub fn check(&mut self, contract: &ContractId) -> SimpleResult<()> {
         if !self.tx_input_contracts.any(|input| input == contract) {
             *self.panic_context = PanicContext::ContractId(*contract);
-            Err(PanicReason::ContractNotInInputs)
+            Err(PanicReason::ContractNotInInputs.into())
         } else {
             Ok(())
         }
diff --git a/fuel-vm/src/interpreter/alu.rs b/fuel-vm/src/interpreter/alu.rs
index 7d44ee7f6..d71a91956 100644
--- a/fuel-vm/src/interpreter/alu.rs
+++ b/fuel-vm/src/interpreter/alu.rs
@@ -7,7 +7,7 @@ use super::{
 };
 use crate::{
     constraints::reg_key::*,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_asm::PanicReason;
@@ -33,7 +33,7 @@ where
         f: F,
         b: B,
         c: C,
-    ) -> Result<(), RuntimeError>
+    ) -> SimpleResult<()>
     where
         F: FnOnce(B, C) -> (u128, bool),
     {
@@ -55,7 +55,7 @@ where
         f: F,
         b: B,
         c: C,
-    ) -> Result<(), RuntimeError>
+    ) -> SimpleResult<()>
     where
         F: FnOnce(B, C) -> (Word, bool),
     {
@@ -77,7 +77,7 @@ where
         b: B,
         c: C,
         err_bool: bool,
-    ) -> Result<(), RuntimeError>
+    ) -> SimpleResult<()>
     where
         F: FnOnce(B, C) -> Word,
     {
@@ -92,11 +92,7 @@ where
         alu_error(dest, flag.as_ref(), common, f, b, c, err_bool)
     }
 
-    pub(crate) fn alu_set(
-        &mut self,
-        ra: RegisterId,
-        b: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn alu_set(&mut self, ra: RegisterId, b: Word) -> SimpleResult<()> {
         let (SystemRegisters { of, err, pc, .. }, mut w) =
             split_registers(&mut self.registers);
         let dest = &mut w[ra.try_into()?];
@@ -104,7 +100,7 @@ where
         alu_set(dest, common, b)
     }
 
-    pub(crate) fn alu_clear(&mut self) -> Result<(), RuntimeError> {
+    pub(crate) fn alu_clear(&mut self) -> SimpleResult<()> {
         let (SystemRegisters { of, err, pc, .. }, _) =
             split_registers(&mut self.registers);
         let common = AluCommonReg { of, err, pc };
@@ -136,7 +132,7 @@ pub(crate) fn alu_capture_overflow<F, B, C>(
     f: F,
     b: B,
     c: C,
-) -> Result<(), RuntimeError>
+) -> SimpleResult<()>
 where
     F: FnOnce(B, C) -> (u128, bool),
 {
@@ -153,7 +149,7 @@ where
     // set the return value to the low bits of the u128 result
     *dest = (result & Word::MAX as u128) as u64;
 
-    inc_pc(common.pc)
+    Ok(inc_pc(common.pc)?)
 }
 
 /// Set RegId::OF to true and zero the result register if overflow occurred.
@@ -164,7 +160,7 @@ pub(crate) fn alu_boolean_overflow<F, B, C>(
     f: F,
     b: B,
     c: C,
-) -> Result<(), RuntimeError>
+) -> SimpleResult<()>
 where
     F: FnOnce(B, C) -> (Word, bool),
 {
@@ -180,7 +176,7 @@ where
 
     *dest = if overflow { 0 } else { result };
 
-    inc_pc(common.pc)
+    Ok(inc_pc(common.pc)?)
 }
 
 pub(crate) fn alu_error<F, B, C>(
@@ -191,7 +187,7 @@ pub(crate) fn alu_error<F, B, C>(
     b: B,
     c: C,
     err_bool: bool,
-) -> Result<(), RuntimeError>
+) -> SimpleResult<()>
 where
     F: FnOnce(B, C) -> Word,
 {
@@ -204,25 +200,25 @@ where
 
     *dest = if err_bool { 0 } else { f(b, c) };
 
-    inc_pc(common.pc)
+    Ok(inc_pc(common.pc)?)
 }
 
 pub(crate) fn alu_set(
     dest: &mut Word,
     mut common: AluCommonReg,
     b: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     *common.of = 0;
     *common.err = 0;
 
     *dest = b;
 
-    inc_pc(common.pc)
+    Ok(inc_pc(common.pc)?)
 }
 
-pub(crate) fn alu_clear(mut common: AluCommonReg) -> Result<(), RuntimeError> {
+pub(crate) fn alu_clear(mut common: AluCommonReg) -> SimpleResult<()> {
     *common.of = 0;
     *common.err = 0;
 
-    inc_pc(common.pc)
+    Ok(inc_pc(common.pc)?)
 }
diff --git a/fuel-vm/src/interpreter/alu/muldiv.rs b/fuel-vm/src/interpreter/alu/muldiv.rs
index 13336624d..638759797 100644
--- a/fuel-vm/src/interpreter/alu/muldiv.rs
+++ b/fuel-vm/src/interpreter/alu/muldiv.rs
@@ -6,7 +6,7 @@ use super::super::{
 };
 use crate::{
     constraints::reg_key::*,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_asm::PanicReason;
@@ -26,7 +26,7 @@ where
         lhs: Word,
         rhs: Word,
         divider: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (
             SystemRegisters {
                 flag,
@@ -49,7 +49,8 @@ where
         *err = 0;
         *dest = result;
 
-        inc_pc(pc)
+        inc_pc(pc)?;
+        Ok(())
     }
 }
 
diff --git a/fuel-vm/src/interpreter/alu/tests.rs b/fuel-vm/src/interpreter/alu/tests.rs
index 54ef22518..6ca6ea030 100644
--- a/fuel-vm/src/interpreter/alu/tests.rs
+++ b/fuel-vm/src/interpreter/alu/tests.rs
@@ -1,8 +1,11 @@
+use alloc::vec::Vec;
+
 use super::*;
+use core::ops::Div;
 use fuel_asm::Imm12;
-use std::ops::Div;
 use test_case::test_case;
 
+use crate::error::PanicOrBug;
 #[derive(Debug, PartialEq, Eq)]
 struct CommonInput {
     of: Word,
@@ -27,7 +30,7 @@ struct CommonInput {
 )]
 #[test_case(
     CommonInput { of: 0, err: 0, pc: 0 },
-    0b00, u64::MAX as u128, 1 => Err(RuntimeError::Recoverable(PanicReason::ArithmeticOverflow));
+    0b00, u64::MAX as u128, 1 => Err(PanicOrBug::Panic(PanicReason::ArithmeticOverflow));
     "add u64::MAX 1 not wrapping"
 )]
 #[test_case(
@@ -44,7 +47,7 @@ fn test_add(
     flag: Word,
     b: u128,
     c: u128,
-) -> Result<(Word, CommonInput), RuntimeError> {
+) -> SimpleResult<(Word, CommonInput)> {
     let common = AluCommonReg {
         of: RegMut::new(&mut of),
         err: RegMut::new(&mut err),
@@ -74,7 +77,7 @@ fn test_add(
 )]
 #[test_case(
     CommonInput { of: 0, err: 0, pc: 0 },
-    0b0, 10, 0, true => Err(RuntimeError::Recoverable(PanicReason::ArithmeticError));
+    0b0, 10, 0, true => Err(PanicOrBug::Panic(PanicReason::ArithmeticError));
     "div 10 0 error flag"
 )]
 #[test_case(
@@ -92,7 +95,7 @@ fn test_div(
     b: u64,
     c: u64,
     err_bool: bool,
-) -> Result<(Word, CommonInput), RuntimeError> {
+) -> SimpleResult<(Word, CommonInput)> {
     let common = AluCommonReg {
         of: RegMut::new(&mut of),
         err: RegMut::new(&mut err),
@@ -118,12 +121,12 @@ fn test_div(
 )]
 #[test_case(
     CommonInput { of: 0, err: 0, pc: 0 },
-    0b00, 10, u64::MAX - 100 => Err(RuntimeError::Recoverable(PanicReason::ArithmeticOverflow));
+    0b00, 10, u64::MAX - 100 => Err(PanicOrBug::Panic(PanicReason::ArithmeticOverflow));
     "larger than 32 bit exp"
 )]
 #[test_case(
     CommonInput { of: 0, err: 0, pc: 0 },
-    0b00, 10, (u32::MAX as u64)+ 1 => Err(RuntimeError::Recoverable(PanicReason::ArithmeticOverflow));
+    0b00, 10, (u32::MAX as u64)+ 1 => Err(PanicOrBug::Panic(PanicReason::ArithmeticOverflow));
     "just larger than 32 bit exp"
 )]
 #[test_case(
@@ -140,7 +143,7 @@ fn test_exp(
     flag: Word,
     b: u64,
     c: u64,
-) -> Result<(Word, CommonInput), RuntimeError> {
+) -> SimpleResult<(Word, CommonInput)> {
     let common = AluCommonReg {
         of: RegMut::new(&mut of),
         err: RegMut::new(&mut err),
diff --git a/fuel-vm/src/interpreter/alu/wideint.rs b/fuel-vm/src/interpreter/alu/wideint.rs
index b02a76e15..21134aa45 100644
--- a/fuel-vm/src/interpreter/alu/wideint.rs
+++ b/fuel-vm/src/interpreter/alu/wideint.rs
@@ -18,7 +18,7 @@ use super::super::{
 };
 use crate::{
     constraints::reg_key::*,
-    error::RuntimeError,
+    error::SimpleResult,
     interpreter::memory::{
         read_bytes,
         write_bytes,
@@ -76,7 +76,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     args: CompareArgs,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
                     let dest: &mut Word = &mut w[ra.try_into()?];
 
@@ -92,7 +92,8 @@ macro_rules! wideint_ops {
 
                     *dest = [<cmp_ $t:lower>](lhs, rhs, args.mode);
 
-                    inc_pc(pc)
+                    inc_pc(pc)?;
+                    Ok(())
                 }
 
                 pub(crate) fn [<alu_wideint_op_ $t:lower>](
@@ -101,7 +102,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     args: MathArgs,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);
 
@@ -126,7 +127,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, wrapped.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
 
                 pub(crate) fn [<alu_wideint_mul_ $t:lower>](
@@ -135,7 +136,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     args: MulArgs,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);
 
@@ -163,7 +164,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, wrapped.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
 
                 pub(crate) fn [<alu_wideint_div_ $t:lower>](
@@ -172,7 +173,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     args: DivArgs,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);
 
@@ -208,7 +209,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, result.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
 
                 pub(crate) fn [<alu_wideint_addmod_ $t:lower>](
@@ -217,7 +218,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     d: Word,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);
 
@@ -248,7 +249,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, result.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
 
                 pub(crate) fn [<alu_wideint_mulmod_ $t:lower>](
@@ -257,7 +258,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     d: Word,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);
 
@@ -289,7 +290,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, result.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
 
                 pub(crate) fn [<alu_wideint_muldiv_ $t:lower>](
@@ -298,7 +299,7 @@ macro_rules! wideint_ops {
                     b: Word,
                     c: Word,
                     d: Word,
-                ) -> Result<(), RuntimeError> {
+                ) -> SimpleResult<()> {
                     let owner_regs = self.ownership_registers();
                     let (SystemRegisters { mut of, mut err, pc, flag, .. }, _) = split_registers(&mut self.registers);
 
@@ -333,7 +334,7 @@ macro_rules! wideint_ops {
 
                     write_bytes(&mut self.memory, owner_regs, dest_addr, result.to_be_bytes())?;
 
-                    inc_pc(pc)
+                    Ok(inc_pc(pc)?)
                 }
             }
 
diff --git a/fuel-vm/src/interpreter/balances.rs b/fuel-vm/src/interpreter/balances.rs
index 052c1e347..f5cda7ef8 100644
--- a/fuel-vm/src/interpreter/balances.rs
+++ b/fuel-vm/src/interpreter/balances.rs
@@ -1,11 +1,11 @@
 use crate::{
     consts::*,
+    error::SimpleResult,
     interpreter::{
         ExecutableTransaction,
         InitialBalances,
         Interpreter,
     },
-    prelude::RuntimeError,
 };
 
 use fuel_asm::{
@@ -16,13 +16,9 @@ use fuel_tx::CheckError;
 use fuel_types::AssetId;
 use itertools::Itertools;
 
-use std::{
-    collections::{
-        BTreeMap,
-        HashMap,
-    },
-    ops::Index,
-};
+use alloc::collections::BTreeMap;
+use core::ops::Index;
+use hashbrown::HashMap;
 
 use super::MemoryRange;
 
@@ -115,7 +111,7 @@ impl RuntimeBalances {
     fn set_memory_balance_inner(
         balance: &Balance,
         memory: &mut [u8; MEM_SIZE],
-    ) -> Result<Word, RuntimeError> {
+    ) -> SimpleResult<Word> {
         let value = balance.value();
         let offset = balance.offset();
 
@@ -217,6 +213,7 @@ impl PartialEq for RuntimeBalances {
 #[test]
 fn writes_to_memory_correctly() {
     use crate::prelude::*;
+    use alloc::vec;
     use rand::{
         rngs::StdRng,
         Rng,
@@ -264,6 +261,7 @@ fn writes_to_memory_correctly() {
 #[test]
 fn try_from_iter_wont_overflow() {
     use crate::prelude::*;
+    use alloc::vec;
     use rand::{
         rngs::StdRng,
         Rng,
@@ -314,6 +312,7 @@ fn try_from_iter_wont_overflow() {
 #[test]
 fn checked_add_and_sub_works() {
     use crate::prelude::*;
+    use alloc::vec;
     use rand::{
         rngs::StdRng,
         Rng,
diff --git a/fuel-vm/src/interpreter/blockchain.rs b/fuel-vm/src/interpreter/blockchain.rs
index f90aceafc..af38f8529 100644
--- a/fuel-vm/src/interpreter/blockchain.rs
+++ b/fuel-vm/src/interpreter/blockchain.rs
@@ -1,3 +1,5 @@
+use alloc::vec::Vec;
+
 use super::{
     contract::{
         balance,
@@ -39,24 +41,24 @@ use crate::{
     },
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::{
+        IoResult,
+        RuntimeError,
+        SimpleResult,
+    },
     interpreter::{
         receipts::ReceiptsCtx,
         InputContracts,
     },
     prelude::Profiler,
     storage::{
-        ContractsAssets,
         ContractsAssetsStorage,
         ContractsRawCode,
         InterpreterStorage,
     },
 };
 use fuel_asm::PanicReason;
-use fuel_storage::{
-    StorageInspect,
-    StorageSize,
-};
+use fuel_storage::StorageSize;
 use fuel_tx::{
     ContractIdExt,
     DependentCost,
@@ -84,8 +86,8 @@ mod test;
 
 impl<S, Tx> Interpreter<S, Tx>
 where
-    S: InterpreterStorage,
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     /// Loads contract ID pointed by `a`, and then for that contract,
     /// copies `c` bytes from it starting from offset `b` into the stack.
@@ -99,7 +101,7 @@ where
         a: Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let contract_max_size = self.contract_max_size();
         let (
             SystemRegisters {
@@ -129,7 +131,7 @@ where
         input.load_contract_code(a, b, c)
     }
 
-    pub(crate) fn burn(&mut self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn burn(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, pc, is, .. }, _) =
             split_registers(&mut self.registers);
@@ -149,7 +151,7 @@ where
         .burn(a, b)
     }
 
-    pub(crate) fn mint(&mut self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn mint(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, pc, is, .. }, _) =
             split_registers(&mut self.registers);
@@ -175,7 +177,7 @@ where
         b: Word,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let owner = self.ownership_registers();
         let input = CodeCopyCtx {
             memory: &mut self.memory,
@@ -190,7 +192,7 @@ where
         input.code_copy(a, b, c, d)
     }
 
-    pub(crate) fn block_hash(&mut self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn block_hash(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
         let owner = self.ownership_registers();
         block_hash(
             &self.storage,
@@ -202,13 +204,13 @@ where
         )
     }
 
-    pub(crate) fn block_height(&mut self, ra: RegisterId) -> Result<(), RuntimeError> {
+    pub(crate) fn block_height(&mut self, ra: RegisterId) -> IoResult<(), S::DataError> {
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
-        block_height(&self.context, pc, result)
+        Ok(block_height(&self.context, pc, result)?)
     }
 
-    pub(crate) fn block_proposer(&mut self, a: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn block_proposer(&mut self, a: Word) -> IoResult<(), S::DataError> {
         let owner = self.ownership_registers();
         coinbase(
             &self.storage,
@@ -219,7 +221,7 @@ where
         )
     }
 
-    pub(crate) fn code_root(&mut self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn code_root(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
         let owner = self.ownership_registers();
         CodeRootCtx {
             memory: &mut self.memory,
@@ -238,7 +240,7 @@ where
         &mut self,
         ra: RegisterId,
         b: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let gas_cost = self.gas_costs().csiz;
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?
@@ -273,7 +275,7 @@ where
         a: Word,
         rb: RegisterId,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let contract_id = self.internal_contract().copied();
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(rb)?];
@@ -293,7 +295,7 @@ where
         ra: RegisterId,
         rb: RegisterId,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let (SystemRegisters { fp, pc, .. }, mut w) =
             split_registers(&mut self.registers);
         let (result, got_result) = w
@@ -327,7 +329,7 @@ where
         rb: RegisterId,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let owner = self.ownership_registers();
         let contract_id = self.internal_contract().copied();
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
@@ -348,7 +350,7 @@ where
         a: Word,
         rb: RegisterId,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let (SystemRegisters { fp, pc, .. }, mut w) =
             split_registers(&mut self.registers);
         let exists = &mut w[WriteRegKey::try_from(rb)?];
@@ -378,7 +380,7 @@ where
         rb: RegisterId,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let contract_id = self.internal_contract().copied();
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(rb)?];
@@ -397,7 +399,7 @@ where
         &mut self,
         ra: RegisterId,
         b: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let block_height = self.get_block_height()?;
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
@@ -410,7 +412,7 @@ where
         b: Word,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let base_asset_id = self.interpreter_params.base_asset_id;
         let max_message_data_length = self.max_message_data_length();
         let tx_offset = self.tx_offset();
@@ -448,7 +450,10 @@ struct LoadContractCodeCtx<'vm, S, I> {
     pc: RegMut<'vm, PC>,
 }
 
-impl<'vm, S, I> LoadContractCodeCtx<'vm, S, I> {
+impl<'vm, S, I> LoadContractCodeCtx<'vm, S, I>
+where
+    S: InterpreterStorage,
+{
     /// Loads contract ID pointed by `a`, and then for that contract,
     /// copies `c` bytes from it starting from offset `b` into the stack.
     /// ```txt
@@ -461,7 +466,7 @@ impl<'vm, S, I> LoadContractCodeCtx<'vm, S, I> {
         contract_id_addr: Word,
         contract_offset: Word,
         length_unpadded: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> IoResult<(), S::DataError>
     where
         I: Iterator<Item = &'vm ContractId>,
         S: InterpreterStorage,
@@ -534,7 +539,7 @@ impl<'vm, S, I> LoadContractCodeCtx<'vm, S, I> {
                 .copy_from_slice(&new_code_size.to_be_bytes());
         }
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -550,9 +555,8 @@ struct BurnCtx<'vm, S> {
 impl<'vm, S> BurnCtx<'vm, S>
 where
     S: ContractsAssetsStorage,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
-    pub(crate) fn burn(self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn burn(self, a: Word, b: Word) -> IoResult<(), S::Error> {
         let range = internal_contract_bounds(self.context, self.fp)?;
         let sub_id_range = CheckedMemConstLen::<{ Bytes32::LEN }>::new(b)?;
         let memory = &*self.append.memory;
@@ -569,13 +573,13 @@ where
 
         self.storage
             .merkle_contract_asset_id_balance_insert(contract_id, &asset_id, balance)
-            .map_err(RuntimeError::from_io)?;
+            .map_err(RuntimeError::Storage)?;
 
         let receipt = Receipt::burn(*sub_id, *contract_id, a, *self.pc, *self.is);
 
         append_receipt(self.append, receipt);
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -591,9 +595,8 @@ struct MintCtx<'vm, S> {
 impl<'vm, S> MintCtx<'vm, S>
 where
     S: ContractsAssetsStorage,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
-    pub(crate) fn mint(self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn mint(self, a: Word, b: Word) -> Result<(), RuntimeError<S::Error>> {
         let range = internal_contract_bounds(self.context, self.fp)?;
         let sub_id_range = CheckedMemConstLen::<{ Bytes32::LEN }>::new(b)?;
         let memory = &*self.append.memory;
@@ -608,13 +611,13 @@ where
 
         self.storage
             .merkle_contract_asset_id_balance_insert(contract_id, &asset_id, balance)
-            .map_err(RuntimeError::from_io)?;
+            .map_err(RuntimeError::Storage)?;
 
         let receipt = Receipt::mint(*sub_id, *contract_id, a, *self.pc, *self.is);
 
         append_receipt(self.append, receipt);
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -626,14 +629,17 @@ struct CodeCopyCtx<'vm, S, I> {
     pc: RegMut<'vm, PC>,
 }
 
-impl<'vm, S, I> CodeCopyCtx<'vm, S, I> {
+impl<'vm, S, I> CodeCopyCtx<'vm, S, I>
+where
+    S: InterpreterStorage,
+{
     pub(crate) fn code_copy(
         mut self,
         dst_addr: Word,
         contract_id_addr: Word,
         contract_offset: Word,
         length: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> IoResult<(), S::DataError>
     where
         I: Iterator<Item = &'vm ContractId>,
         S: InterpreterStorage,
@@ -664,7 +670,7 @@ impl<'vm, S, I> CodeCopyCtx<'vm, S, I> {
             length,
         )?;
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -675,29 +681,31 @@ pub(crate) fn block_hash<S: InterpreterStorage>(
     pc: RegMut<PC>,
     a: Word,
     b: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let height = u32::try_from(b)
         .map_err(|_| PanicReason::ArithmeticOverflow)?
         .into();
-    let hash = storage.block_hash(height).map_err(|e| e.into())?;
+    let hash = storage.block_hash(height).map_err(RuntimeError::Storage)?;
 
     try_mem_write(a, hash.as_ref(), owner, memory)?;
 
-    inc_pc(pc)
+    inc_pc(pc)?;
+    Ok(())
 }
 
 pub(crate) fn block_height(
     context: &Context,
     pc: RegMut<PC>,
     result: &mut Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     context
         .block_height()
         .map(|h| *h as Word)
         .map(|h| *result = h)
         .ok_or(PanicReason::TransactionValidity)?;
 
-    inc_pc(pc)
+    inc_pc(pc)?;
+    Ok(())
 }
 
 pub(crate) fn coinbase<S: InterpreterStorage>(
@@ -706,10 +714,11 @@ pub(crate) fn coinbase<S: InterpreterStorage>(
     owner: OwnershipRegisters,
     pc: RegMut<PC>,
     a: Word,
-) -> Result<(), RuntimeError> {
-    let coinbase = storage.coinbase().map_err(RuntimeError::from_io)?;
+) -> IoResult<(), S::DataError> {
+    let coinbase = storage.coinbase().map_err(RuntimeError::Storage)?;
     try_mem_write(a, coinbase.as_ref(), owner, memory)?;
-    inc_pc(pc)
+    inc_pc(pc)?;
+    Ok(())
 }
 
 struct CodeRootCtx<'vm, S, I> {
@@ -721,7 +730,7 @@ struct CodeRootCtx<'vm, S, I> {
 }
 
 impl<'vm, S, I: Iterator<Item = &'vm ContractId>> CodeRootCtx<'vm, S, I> {
-    pub(crate) fn code_root(mut self, a: Word, b: Word) -> Result<(), RuntimeError>
+    pub(crate) fn code_root(mut self, a: Word, b: Word) -> IoResult<(), S::DataError>
     where
         S: InterpreterStorage,
     {
@@ -737,12 +746,12 @@ impl<'vm, S, I: Iterator<Item = &'vm ContractId>> CodeRootCtx<'vm, S, I> {
             .storage_contract_root(contract_id)
             .transpose()
             .ok_or(PanicReason::ContractNotFound)?
-            .map_err(RuntimeError::from_io)?
+            .map_err(RuntimeError::Storage)?
             .into_owned();
 
         try_mem_write(a, root.as_ref(), self.owner, self.memory)?;
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -764,10 +773,9 @@ impl<'vm, S, I: Iterator<Item = &'vm ContractId>> CodeSizeCtx<'vm, S, I> {
         mut self,
         result: &mut Word,
         b: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> Result<(), RuntimeError<S::Error>>
     where
         S: StorageSize<ContractsRawCode>,
-        <S as StorageInspect<ContractsRawCode>>::Error: Into<std::io::Error>,
     {
         let contract_id = CheckedMemConstLen::<{ ContractId::LEN }>::new(b)?;
 
@@ -785,7 +793,7 @@ impl<'vm, S, I: Iterator<Item = &'vm ContractId>> CodeSizeCtx<'vm, S, I> {
         dependent_gas_charge(self.cgas, self.ggas, profiler, self.gas_cost, len)?;
         *result = len;
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -808,7 +816,7 @@ pub(crate) fn state_read_word<S: InterpreterStorage>(
     result: &mut Word,
     got_result: &mut Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let key = CheckedMemConstLen::<{ Bytes32::LEN }>::new(c)?;
 
     let contract = internal_contract(context, fp, memory)?;
@@ -817,7 +825,7 @@ pub(crate) fn state_read_word<S: InterpreterStorage>(
 
     let value = storage
         .merkle_contract_state(contract, key)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .map(|bytes| {
             Word::from_be_bytes(
                 bytes[..8]
@@ -829,7 +837,7 @@ pub(crate) fn state_read_word<S: InterpreterStorage>(
     *result = value.unwrap_or(0);
     *got_result = value.is_some() as Word;
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn state_write_word<S: InterpreterStorage>(
@@ -843,7 +851,7 @@ pub(crate) fn state_write_word<S: InterpreterStorage>(
     a: Word,
     exists: &mut Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let key = CheckedMemConstLen::<{ Bytes32::LEN }>::new(a)?;
 
     let contract = internal_contract_bounds(context, fp)?;
@@ -858,20 +866,20 @@ pub(crate) fn state_write_word<S: InterpreterStorage>(
 
     let result = storage
         .merkle_contract_state_insert(contract, key, &value)
-        .map_err(RuntimeError::from_io)?;
+        .map_err(RuntimeError::Storage)?;
 
     *exists = result.is_some() as Word;
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
-pub(crate) fn timestamp(
-    storage: &impl InterpreterStorage,
+pub(crate) fn timestamp<S: InterpreterStorage>(
+    storage: &S,
     block_height: BlockHeight,
     pc: RegMut<PC>,
     result: &mut Word,
     b: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let b = u32::try_from(b)
         .map_err(|_| PanicReason::ArithmeticOverflow)?
         .into();
@@ -879,14 +887,13 @@ pub(crate) fn timestamp(
         .then_some(())
         .ok_or(PanicReason::TransactionValidity)?;
 
-    *result = storage.timestamp(b).map_err(|e| e.into())?;
+    *result = storage.timestamp(b).map_err(RuntimeError::Storage)?;
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 struct MessageOutputCtx<'vm, Tx, S>
 where
     S: ContractsAssetsStorage + ?Sized,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
     base_asset_id: AssetId,
     max_message_data_length: u64,
@@ -912,9 +919,8 @@ where
 impl<Tx, S> MessageOutputCtx<'_, Tx, S>
 where
     S: ContractsAssetsStorage + ?Sized,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
-    pub(crate) fn message_output(self) -> Result<(), RuntimeError>
+    pub(crate) fn message_output(self) -> Result<(), RuntimeError<S::Error>>
     where
         Tx: ExecutableTransaction,
     {
@@ -972,7 +978,7 @@ where
             receipt,
         );
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
@@ -991,7 +997,7 @@ impl StateReadQWord {
         origin_key_memory_address: Word,
         num_slots: Word,
         ownership_registers: OwnershipRegisters,
-    ) -> Result<Self, RuntimeError> {
+    ) -> SimpleResult<Self> {
         let destination_address_memory_range = MemoryRange::new(
             destination_memory_address,
             (Bytes32::LEN as Word).saturating_mul(num_slots),
@@ -1008,20 +1014,20 @@ impl StateReadQWord {
     }
 }
 
-fn state_read_qword(
+fn state_read_qword<S: InterpreterStorage>(
     contract_id: &ContractId,
-    storage: &impl InterpreterStorage,
+    storage: &S,
     memory: &mut [u8; MEM_SIZE],
     pc: RegMut<PC>,
     result_register: &mut Word,
     input: StateReadQWord,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let origin_key = Bytes32::from_bytes_ref(input.origin_key_memory_range.read(memory));
 
     let mut all_set = true;
     let result: Vec<u8> = storage
         .merkle_contract_state_range(contract_id, origin_key, input.num_slots)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .into_iter()
         .flat_map(|bytes| match bytes {
             Some(bytes) => **bytes,
@@ -1053,7 +1059,7 @@ impl StateWriteQWord {
         starting_storage_key_memory_address: Word,
         source_memory_address: Word,
         num_slots: Word,
-    ) -> Result<Self, RuntimeError> {
+    ) -> SimpleResult<Self> {
         let source_address_memory_range = MemoryRange::new(
             source_memory_address,
             (Bytes32::LEN as Word).saturating_mul(num_slots),
@@ -1071,14 +1077,14 @@ impl StateWriteQWord {
     }
 }
 
-fn state_write_qword(
+fn state_write_qword<S: InterpreterStorage>(
     contract_id: &ContractId,
-    storage: &mut impl InterpreterStorage,
+    storage: &mut S,
     memory: &[u8; MEM_SIZE],
     pc: RegMut<PC>,
     result_register: &mut Word,
     input: StateWriteQWord,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let destination_key =
         Bytes32::from_bytes_ref(input.starting_storage_key_memory_range.read(memory));
 
@@ -1089,7 +1095,7 @@ fn state_write_qword(
 
     let any_none = storage
         .merkle_contract_state_insert_range(contract_id, destination_key, &values)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .is_some();
     *result_register = any_none as Word;
 
@@ -1110,7 +1116,7 @@ impl StateClearQWord {
     fn new(
         start_storage_key_memory_address: Word,
         num_slots: Word,
-    ) -> Result<Self, RuntimeError> {
+    ) -> SimpleResult<Self> {
         let start_storage_key_memory_range = CheckedMemConstLen::<{ Bytes32::LEN }>::new(
             start_storage_key_memory_address,
         )?;
@@ -1121,20 +1127,20 @@ impl StateClearQWord {
     }
 }
 
-fn state_clear_qword(
+fn state_clear_qword<S: InterpreterStorage>(
     contract_id: &ContractId,
-    storage: &mut impl InterpreterStorage,
+    storage: &mut S,
     memory: &[u8; MEM_SIZE],
     pc: RegMut<PC>,
     result_register: &mut Word,
     input: StateClearQWord,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), S::DataError> {
     let start_key =
         Bytes32::from_bytes_ref(input.start_storage_key_memory_range.read(memory));
 
     let all_previously_set = storage
         .merkle_contract_state_remove_range(contract_id, start_key, input.num_slots)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .is_some();
 
     *result_register = all_previously_set as Word;
diff --git a/fuel-vm/src/interpreter/blockchain/code_tests.rs b/fuel-vm/src/interpreter/blockchain/code_tests.rs
index f244652ac..c2d35881e 100644
--- a/fuel-vm/src/interpreter/blockchain/code_tests.rs
+++ b/fuel-vm/src/interpreter/blockchain/code_tests.rs
@@ -1,3 +1,7 @@
+use core::convert::Infallible;
+
+use alloc::vec;
+
 use super::*;
 use crate::{
     interpreter::{
@@ -9,7 +13,7 @@ use crate::{
 use fuel_tx::Contract;
 
 #[test]
-fn test_load_contract() -> Result<(), RuntimeError> {
+fn test_load_contract() -> IoResult<(), Infallible> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
@@ -51,7 +55,7 @@ fn test_load_contract() -> Result<(), RuntimeError> {
 }
 
 #[test]
-fn test_code_copy() -> Result<(), RuntimeError> {
+fn test_code_copy() -> IoResult<(), Infallible> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
diff --git a/fuel-vm/src/interpreter/blockchain/other_tests.rs b/fuel-vm/src/interpreter/blockchain/other_tests.rs
index d7be55cf4..9b170d01a 100644
--- a/fuel-vm/src/interpreter/blockchain/other_tests.rs
+++ b/fuel-vm/src/interpreter/blockchain/other_tests.rs
@@ -1,8 +1,13 @@
+use alloc::vec;
+
 use crate::{
     interpreter::memory::Memory,
     storage::MemoryStorage,
 };
-use std::iter;
+use core::{
+    convert::Infallible,
+    iter,
+};
 
 use super::*;
 use crate::interpreter::PanicContext;
@@ -25,7 +30,7 @@ fn test_burn(
     initialize: impl Into<Option<Word>>,
     amount: Word,
     sub_id: [u8; 32],
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let contract_id = ContractId::from([3u8; 32]);
@@ -107,7 +112,7 @@ fn test_mint(
     initialize: impl Into<Option<Word>>,
     amount: Word,
     sub_id: [u8; 32],
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let contract_id = ContractId::from([3u8; 32]);
@@ -240,7 +245,7 @@ fn test_code_root() {
     let mut pc = 4;
     let input_contracts = [contract_id];
     let mut panic_context = PanicContext::None;
-    CodeRootCtx {
+    let _ = CodeRootCtx {
         memory: &mut memory,
         input_contracts: InputContracts::new(input_contracts.iter(), &mut panic_context),
         storage: &storage,
@@ -288,7 +293,7 @@ fn test_code_root() {
             block_height: Default::default(),
         },
     };
-    CodeRootCtx {
+    let _ = CodeRootCtx {
         memory: &mut memory,
         input_contracts: InputContracts::new(iter::empty(), &mut panic_context),
         storage: &storage,
@@ -330,7 +335,7 @@ fn test_code_size() {
         is: Reg::new(&is),
     };
     let mut result = 0;
-    input
+    let _ = input
         .code_size(&mut result, 1)
         .expect_err("Contract is not found");
     assert_eq!(pc, 4);
@@ -371,7 +376,7 @@ fn test_code_size() {
         is: Reg::new(&is),
     };
     let mut result = 0;
-    input
+    let _ = input
         .code_size(&mut result, 0)
         .expect_err("The contract is not in the input");
 }
@@ -381,7 +386,7 @@ fn test_timestamp() {
     let storage = MemoryStorage::new(Default::default(), Default::default());
     let mut pc = 4;
     let mut result = 0;
-    timestamp(
+    let _ = timestamp(
         &storage,
         Default::default(),
         RegMut::new(&mut pc),
@@ -389,7 +394,7 @@ fn test_timestamp() {
         1,
     )
     .expect_err("Height is greater then current block height");
-    timestamp(
+    let _ = timestamp(
         &storage,
         u32::MAX.into(),
         RegMut::new(&mut pc),
diff --git a/fuel-vm/src/interpreter/blockchain/smo_tests.rs b/fuel-vm/src/interpreter/blockchain/smo_tests.rs
index 015255513..fc7f46d62 100644
--- a/fuel-vm/src/interpreter/blockchain/smo_tests.rs
+++ b/fuel-vm/src/interpreter/blockchain/smo_tests.rs
@@ -1,3 +1,10 @@
+use core::convert::Infallible;
+
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     interpreter::{
         contract::balance as contract_balance,
@@ -201,7 +208,7 @@ fn test_smo(
         max_message_data_length,
         initial_balance,
     }: Input,
-) -> Result<Output, RuntimeError> {
+) -> Result<Output, RuntimeError<Infallible>> {
     let mut rng = StdRng::seed_from_u64(100);
     let base_asset_id = rng.gen();
 
diff --git a/fuel-vm/src/interpreter/blockchain/test.rs b/fuel-vm/src/interpreter/blockchain/test.rs
index 9939cad21..ad5881d75 100644
--- a/fuel-vm/src/interpreter/blockchain/test.rs
+++ b/fuel-vm/src/interpreter/blockchain/test.rs
@@ -1,4 +1,12 @@
-use std::ops::Range;
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
+use core::{
+    convert::Infallible,
+    ops::Range,
+};
 
 use crate::{
     context::Context,
@@ -50,7 +58,7 @@ fn test_state_read_word(
     fp: Word,
     insert: impl Into<Option<Word>>,
     key: Word,
-) -> Result<(Word, Word), RuntimeError> {
+) -> Result<(Word, Word), RuntimeError<Infallible>> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[0..ContractId::LEN].copy_from_slice(&[3u8; ContractId::LEN][..]);
@@ -111,7 +119,7 @@ fn test_state_write_word(
     fp: Word,
     insert: bool,
     key: Word,
-) -> Result<Word, RuntimeError> {
+) -> Result<Word, RuntimeError<Infallible>> {
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[0..ContractId::LEN].copy_from_slice(&[3u8; ContractId::LEN][..]);
diff --git a/fuel-vm/src/interpreter/blockchain/test/scwq.rs b/fuel-vm/src/interpreter/blockchain/test/scwq.rs
index 1e90e71f3..3cac9e7f5 100644
--- a/fuel-vm/src/interpreter/blockchain/test/scwq.rs
+++ b/fuel-vm/src/interpreter/blockchain/test/scwq.rs
@@ -1,5 +1,10 @@
 #![allow(clippy::type_complexity)]
 
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::storage::{
     ContractsState,
     MemoryStorage,
@@ -123,6 +128,6 @@ fn test_state_clear_qword(input: SCWQInput) -> (Vec<([u8; 32], [u8; 32])>, bool)
 fn test_state_clear_qword_input(
     start_key_memory_address: Word,
     num_slots: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     StateClearQWord::new(start_key_memory_address, num_slots).map(|_| ())
 }
diff --git a/fuel-vm/src/interpreter/blockchain/test/srwq.rs b/fuel-vm/src/interpreter/blockchain/test/srwq.rs
index cd3d187a2..6b1706055 100644
--- a/fuel-vm/src/interpreter/blockchain/test/srwq.rs
+++ b/fuel-vm/src/interpreter/blockchain/test/srwq.rs
@@ -21,7 +21,7 @@ impl StateReadQWord {
         destination_memory_address: Word,
         origin_key_memory_address: Word,
         num_slots: Word,
-    ) -> Result<Self, RuntimeError> {
+    ) -> SimpleResult<Self> {
         let r = OwnershipRegisters {
             sp: u64::MAX / 2,
             ssp: 0,
@@ -171,7 +171,7 @@ fn test_state_read_qword_input(
     origin_key_memory_address: Word,
     num_slots: Word,
     ownership_registers: OwnershipRegisters,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     StateReadQWord::new(
         destination_memory_address,
         origin_key_memory_address,
diff --git a/fuel-vm/src/interpreter/blockchain/test/swwq.rs b/fuel-vm/src/interpreter/blockchain/test/swwq.rs
index 1491e2793..a286e57c7 100644
--- a/fuel-vm/src/interpreter/blockchain/test/swwq.rs
+++ b/fuel-vm/src/interpreter/blockchain/test/swwq.rs
@@ -1,5 +1,10 @@
 #![allow(clippy::type_complexity)]
 
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::storage::{
     ContractsState,
     MemoryStorage,
@@ -173,7 +178,7 @@ fn test_state_write_qword_input(
     start_key_memory_address: Word,
     source_memory_address: Word,
     num_slots: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     StateWriteQWord::new(start_key_memory_address, source_memory_address, num_slots)
         .map(|_| ())
 }
diff --git a/fuel-vm/src/interpreter/constructors.rs b/fuel-vm/src/interpreter/constructors.rs
index 5ff7d9700..cbd1f3dac 100644
--- a/fuel-vm/src/interpreter/constructors.rs
+++ b/fuel-vm/src/interpreter/constructors.rs
@@ -17,6 +17,8 @@ use crate::{
     storage::MemoryStorage,
 };
 
+use alloc::vec;
+
 #[cfg(feature = "profile-any")]
 use crate::profiler::ProfileReceiver;
 
@@ -57,7 +59,7 @@ where
     where
         P: ProfileReceiver + Send + Sync + 'static,
     {
-        self.profiler.set_receiver(Box::new(receiver));
+        self.profiler.set_receiver(alloc::boxed::Box::new(receiver));
         self
     }
 }
@@ -83,6 +85,7 @@ where
     }
 }
 
+#[cfg(test)]
 impl<Tx> Interpreter<(), Tx>
 where
     Tx: ExecutableTransaction,
diff --git a/fuel-vm/src/interpreter/contract.rs b/fuel-vm/src/interpreter/contract.rs
index 24a9cc54f..5f4c57924 100644
--- a/fuel-vm/src/interpreter/contract.rs
+++ b/fuel-vm/src/interpreter/contract.rs
@@ -19,14 +19,16 @@ use crate::{
     },
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::{
+        IoResult,
+        RuntimeError,
+    },
     interpreter::{
         receipts::ReceiptsCtx,
         InputContracts,
         PanicContext,
     },
     storage::{
-        ContractsAssets,
         ContractsAssetsStorage,
         ContractsRawCode,
         InterpreterStorage,
@@ -37,10 +39,7 @@ use fuel_asm::{
     RegisterId,
     Word,
 };
-use fuel_storage::{
-    StorageInspect,
-    StorageSize,
-};
+use fuel_storage::StorageSize;
 use fuel_tx::{
     Contract,
     Output,
@@ -52,7 +51,7 @@ use fuel_types::{
     ContractId,
 };
 
-use std::borrow::Cow;
+use alloc::borrow::Cow;
 
 #[cfg(test)]
 mod tests;
@@ -67,7 +66,7 @@ where
         ra: RegisterId,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> Result<(), RuntimeError<S::DataError>> {
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
         let input = ContractBalanceCtx {
@@ -79,7 +78,8 @@ where
                 &mut self.panic_context,
             ),
         };
-        input.contract_balance(result, b, c)
+        input.contract_balance(result, b, c)?;
+        Ok(())
     }
 
     pub(crate) fn transfer(
@@ -87,7 +87,7 @@ where
         a: Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
@@ -112,7 +112,7 @@ where
         b: Word,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
@@ -134,23 +134,23 @@ where
     pub(crate) fn check_contract_exists(
         &self,
         contract: &ContractId,
-    ) -> Result<bool, RuntimeError> {
+    ) -> IoResult<bool, S::DataError> {
         self.storage
             .storage_contract_exists(contract)
-            .map_err(RuntimeError::from_io)
+            .map_err(RuntimeError::Storage)
     }
 }
 
 pub(crate) fn contract<'s, S>(
     storage: &'s S,
     contract: &ContractId,
-) -> Result<Cow<'s, Contract>, RuntimeError>
+) -> IoResult<Cow<'s, Contract>, S::DataError>
 where
     S: InterpreterStorage,
 {
     storage
         .storage_contract(contract)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .ok_or_else(|| PanicReason::ContractNotFound.into())
 }
 
@@ -167,11 +167,10 @@ impl<'vm, S, I> ContractBalanceCtx<'vm, S, I> {
         result: &mut Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> IoResult<(), S::Error>
     where
         I: Iterator<Item = &'vm ContractId>,
         S: ContractsAssetsStorage,
-        <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
     {
         let asset_id = CheckedMemConstLen::<{ AssetId::LEN }>::new(b)?;
         let contract = CheckedMemConstLen::<{ ContractId::LEN }>::new(c)?;
@@ -185,7 +184,7 @@ impl<'vm, S, I> ContractBalanceCtx<'vm, S, I> {
 
         *result = balance;
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 struct TransferCtx<'vm, S, Tx> {
@@ -213,11 +212,10 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
         recipient_contract_id_offset: Word,
         transfer_amount: Word,
         asset_id_offset: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> IoResult<(), S::Error>
     where
         Tx: ExecutableTransaction,
         S: ContractsAssetsStorage,
-        <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
     {
         let amount = transfer_amount;
         let destination =
@@ -236,9 +234,9 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             // optimistically attempt to load the internal contract id
             Ok(source_contract) => Some(*source_contract),
             // revert to external context if no internal contract is set
-            Err(RuntimeError::Recoverable(PanicReason::ExpectedInternalContext)) => None,
+            Err(PanicReason::ExpectedInternalContext) => None,
             // bubble up any other kind of errors
-            Err(e) => return Err(e),
+            Err(e) => return Err(e.into()),
         };
 
         if let Some(source_contract) = internal_context {
@@ -270,7 +268,7 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             receipt,
         );
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 
     /// In Fuel specs:
@@ -285,11 +283,10 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
         output_index: Word,
         transfer_amount: Word,
         asset_id_offset: Word,
-    ) -> Result<(), RuntimeError>
+    ) -> IoResult<(), S::Error>
     where
         Tx: ExecutableTransaction,
         S: ContractsAssetsStorage,
-        <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
     {
         let out_idx = output_index as usize;
         let to = Address::from(read_bytes(self.memory, recipient_offset)?);
@@ -305,9 +302,9 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             // optimistically attempt to load the internal contract id
             Ok(source_contract) => Some(*source_contract),
             // revert to external context if no internal contract is set
-            Err(RuntimeError::Recoverable(PanicReason::ExpectedInternalContext)) => None,
+            Err(PanicReason::ExpectedInternalContext) => None,
             // bubble up any other kind of errors
-            Err(e) => return Err(e),
+            Err(e) => return Err(e.into()),
         };
 
         if let Some(source_contract) = internal_context {
@@ -342,21 +339,20 @@ impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
             receipt,
         );
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
 
 pub(crate) fn contract_size<S>(
     storage: &S,
     contract: &ContractId,
-) -> Result<Word, RuntimeError>
+) -> IoResult<Word, S::Error>
 where
     S: StorageSize<ContractsRawCode> + ?Sized,
-    <S as StorageInspect<ContractsRawCode>>::Error: Into<std::io::Error>,
 {
     Ok(storage
         .size_of_value(contract)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .ok_or(PanicReason::ContractNotFound)? as Word)
 }
 
@@ -364,14 +360,13 @@ pub(crate) fn balance<S>(
     storage: &S,
     contract: &ContractId,
     asset_id: &AssetId,
-) -> Result<Word, RuntimeError>
+) -> IoResult<Word, S::Error>
 where
     S: ContractsAssetsStorage + ?Sized,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
     Ok(storage
         .merkle_contract_asset_id_balance(contract, asset_id)
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .unwrap_or_default())
 }
 
@@ -381,10 +376,9 @@ pub(crate) fn balance_increase<S>(
     contract: &ContractId,
     asset_id: &AssetId,
     amount: Word,
-) -> Result<Word, RuntimeError>
+) -> IoResult<Word, S::Error>
 where
     S: ContractsAssetsStorage + ?Sized,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
     let balance = balance(storage, contract, asset_id)?;
     let balance = balance
@@ -392,7 +386,7 @@ where
         .ok_or(PanicReason::ArithmeticOverflow)?;
     storage
         .merkle_contract_asset_id_balance_insert(contract, asset_id, balance)
-        .map_err(RuntimeError::from_io)?;
+        .map_err(RuntimeError::Storage)?;
     Ok(balance)
 }
 
@@ -402,10 +396,9 @@ pub(crate) fn balance_decrease<S>(
     contract: &ContractId,
     asset_id: &AssetId,
     amount: Word,
-) -> Result<Word, RuntimeError>
+) -> IoResult<Word, S::Error>
 where
     S: ContractsAssetsStorage + ?Sized,
-    <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
 {
     let balance = balance(storage, contract, asset_id)?;
     let balance = balance
@@ -413,6 +406,6 @@ where
         .ok_or(PanicReason::NotEnoughBalance)?;
     storage
         .merkle_contract_asset_id_balance_insert(contract, asset_id, balance)
-        .map_err(RuntimeError::from_io)?;
+        .map_err(RuntimeError::Storage)?;
     Ok(balance)
 }
diff --git a/fuel-vm/src/interpreter/contract/tests.rs b/fuel-vm/src/interpreter/contract/tests.rs
index 95296041f..5dcd48639 100644
--- a/fuel-vm/src/interpreter/contract/tests.rs
+++ b/fuel-vm/src/interpreter/contract/tests.rs
@@ -1,3 +1,7 @@
+use core::convert::Infallible;
+
+use alloc::vec;
+
 use crate::{
     interpreter::memory::Memory,
     storage::MemoryStorage,
@@ -17,7 +21,7 @@ use fuel_types::canonical::Deserialize;
 use test_case::test_case;
 
 #[test_case(0, 32 => Ok(()); "Can read contract balance")]
-fn test_contract_balance(b: Word, c: Word) -> Result<(), RuntimeError> {
+fn test_contract_balance(b: Word, c: Word) -> IoResult<(), Infallible> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[b as usize..(b as usize + AssetId::LEN)]
         .copy_from_slice(&[2u8; AssetId::LEN][..]);
@@ -71,7 +75,7 @@ fn test_transfer(
     transfer_amount: Word,
     requested_asset_id_offset: Word,
     real_asset_id_offset: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     // Given
 
     const ASSET_ID: AssetId = AssetId::new([2u8; AssetId::LEN]);
@@ -206,7 +210,7 @@ fn test_transfer_output(
     transfer_amount: Word,
     requested_asset_id_offset: Word,
     real_asset_id_offset: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     // Given
 
     const ASSET_ID: AssetId = AssetId::new([2u8; AssetId::LEN]);
@@ -340,7 +344,7 @@ fn test_transfer_output(
 fn test_balance_increase(
     initial: impl Into<Option<Word>>,
     amount: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     let contract_id = ContractId::from([3u8; 32]);
     let asset_id = AssetId::from([2u8; 32]);
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
@@ -375,7 +379,7 @@ fn test_balance_increase(
 fn test_balance_decrease(
     initial: impl Into<Option<Word>>,
     amount: Word,
-) -> Result<(), RuntimeError> {
+) -> IoResult<(), Infallible> {
     let contract_id = ContractId::from([3u8; 32]);
     let asset_id = AssetId::from([2u8; 32]);
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
diff --git a/fuel-vm/src/interpreter/crypto.rs b/fuel-vm/src/interpreter/crypto.rs
index 9edcee829..75efe87af 100644
--- a/fuel-vm/src/interpreter/crypto.rs
+++ b/fuel-vm/src/interpreter/crypto.rs
@@ -16,7 +16,7 @@ use super::{
 use crate::{
     constraints::reg_key::*,
     consts::*,
-    error::RuntimeError,
+    error::SimpleResult,
     prelude::MemoryRange,
 };
 
@@ -44,7 +44,7 @@ where
         a: Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
         secp256k1_recover(&mut self.memory, owner, err, pc, a, b, c)
@@ -55,7 +55,7 @@ where
         a: Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
         secp256r1_recover(&mut self.memory, owner, err, pc, a, b, c)
@@ -66,27 +66,17 @@ where
         a: Word,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
         ed25519_verify(&mut self.memory, err, pc, a, b, c)
     }
 
-    pub(crate) fn keccak256(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn keccak256(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         keccak256(&mut self.memory, owner, self.registers.pc_mut(), a, b, c)
     }
 
-    pub(crate) fn sha256(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn sha256(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         sha256(&mut self.memory, owner, self.registers.pc_mut(), a, b, c)
     }
@@ -100,7 +90,7 @@ pub(crate) fn secp256k1_recover(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let sig = Bytes64::from(read_bytes(memory, b)?);
     let msg = Bytes32::from(read_bytes(memory, c)?);
 
@@ -118,7 +108,7 @@ pub(crate) fn secp256k1_recover(
         }
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn secp256r1_recover(
@@ -129,7 +119,7 @@ pub(crate) fn secp256r1_recover(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let sig = Bytes64::from(read_bytes(memory, b)?);
     let msg = Bytes32::from(read_bytes(memory, c)?);
     let message = Message::from_bytes_ref(&msg);
@@ -145,7 +135,7 @@ pub(crate) fn secp256r1_recover(
         }
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn ed25519_verify(
@@ -155,7 +145,7 @@ pub(crate) fn ed25519_verify(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let pub_key = Bytes32::from(read_bytes(memory, a)?);
     let sig = Bytes64::from(read_bytes(memory, b)?);
     let msg = Bytes32::from(read_bytes(memory, c)?);
@@ -167,7 +157,7 @@ pub(crate) fn ed25519_verify(
         set_err(err);
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn keccak256(
@@ -177,7 +167,7 @@ pub(crate) fn keccak256(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     use sha3::{
         Digest,
         Keccak256,
@@ -189,7 +179,7 @@ pub(crate) fn keccak256(
 
     try_mem_write(a, h.finalize().as_slice(), owner, memory)?;
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn sha256(
@@ -199,7 +189,7 @@ pub(crate) fn sha256(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let src_range = MemoryRange::new(b, c)?;
 
     try_mem_write(
@@ -209,5 +199,5 @@ pub(crate) fn sha256(
         memory,
     )?;
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
diff --git a/fuel-vm/src/interpreter/crypto/tests.rs b/fuel-vm/src/interpreter/crypto/tests.rs
index 867eebbc1..7fbd04028 100644
--- a/fuel-vm/src/interpreter/crypto/tests.rs
+++ b/fuel-vm/src/interpreter/crypto/tests.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use fuel_crypto::SecretKey;
 use rand::{
     rngs::StdRng,
@@ -11,8 +13,9 @@ use crate::{
 
 use super::*;
 
+#[cfg(feature = "random")]
 #[test]
-fn test_recover_secp256k1() -> Result<(), RuntimeError> {
+fn test_recover_secp256k1() -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let owner = OwnershipRegisters {
         sp: 1000,
@@ -57,7 +60,7 @@ fn test_recover_secp256k1() -> Result<(), RuntimeError> {
 }
 
 #[test]
-fn test_recover_secp256r1() -> Result<(), RuntimeError> {
+fn test_recover_secp256r1() -> SimpleResult<()> {
     use fuel_crypto::secp256r1::encode_pubkey;
     use p256::ecdsa::SigningKey;
 
@@ -109,7 +112,7 @@ fn test_recover_secp256r1() -> Result<(), RuntimeError> {
 }
 
 #[test]
-fn test_verify_ed25519() -> Result<(), RuntimeError> {
+fn test_verify_ed25519() -> SimpleResult<()> {
     use ed25519_dalek::Signer;
 
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
@@ -146,7 +149,7 @@ fn test_verify_ed25519() -> Result<(), RuntimeError> {
 }
 
 #[test]
-fn test_keccak256() -> Result<(), RuntimeError> {
+fn test_keccak256() -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let owner = OwnershipRegisters {
         sp: 1000,
@@ -175,7 +178,7 @@ fn test_keccak256() -> Result<(), RuntimeError> {
 }
 
 #[test]
-fn test_sha256() -> Result<(), RuntimeError> {
+fn test_sha256() -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let owner = OwnershipRegisters {
         sp: 1000,
diff --git a/fuel-vm/src/interpreter/debug.rs b/fuel-vm/src/interpreter/debug.rs
index 3a3171fe9..8fa02d03c 100644
--- a/fuel-vm/src/interpreter/debug.rs
+++ b/fuel-vm/src/interpreter/debug.rs
@@ -1,3 +1,9 @@
+#[cfg(test)]
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use super::Interpreter;
 use crate::prelude::*;
 use fuel_asm::RegId;
diff --git a/fuel-vm/src/interpreter/diff.rs b/fuel-vm/src/interpreter/diff.rs
index 25bd9f0a8..98b9d1cf0 100644
--- a/fuel-vm/src/interpreter/diff.rs
+++ b/fuel-vm/src/interpreter/diff.rs
@@ -4,16 +4,19 @@
 //! This module is experimental work in progress and currently only used in testing
 //! although it could potentially stabilize to be used in production.
 
-use std::{
+use alloc::{
+    sync::Arc,
+    vec::Vec,
+};
+use core::{
     any::Any,
-    collections::{
-        HashMap,
-        HashSet,
-    },
     fmt::Debug,
     hash::Hash,
     ops::AddAssign,
-    sync::Arc,
+};
+use hashbrown::{
+    HashMap,
+    HashSet,
 };
 
 use fuel_asm::Word;
@@ -109,7 +112,7 @@ where
 pub trait VmStateCapture {
     /// The actual type is defined by the implementations of
     /// the Capture trait.
-    type State<S: std::fmt::Debug + Clone>: std::fmt::Debug + Clone;
+    type State<S: core::fmt::Debug + Clone>: core::fmt::Debug + Clone;
 }
 
 #[derive(Debug, Clone)]
@@ -119,7 +122,7 @@ pub trait VmStateCapture {
 pub struct Deltas;
 
 impl VmStateCapture for Deltas {
-    type State<S: std::fmt::Debug + Clone> = Delta<S>;
+    type State<S: core::fmt::Debug + Clone> = Delta<S>;
 }
 
 #[derive(Debug, Clone)]
@@ -137,7 +140,7 @@ pub struct Delta<S> {
 pub struct InitialVmState;
 
 impl VmStateCapture for InitialVmState {
-    type State<S: std::fmt::Debug + Clone> = Previous<S>;
+    type State<S: core::fmt::Debug + Clone> = Previous<S>;
 }
 #[derive(Debug, Clone)]
 /// The State type when capturing the initial state of the VM.
@@ -175,7 +178,7 @@ struct Memory {
 }
 
 impl Debug for Memory {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         if f.alternate() {
             f.debug_struct("Memory")
                 .field("start", &self.start)
@@ -196,7 +199,7 @@ fn capture_buffer_state<'iter, I, T>(
     change: fn(Delta<VecState<T>>) -> Change<Deltas>,
 ) -> impl Iterator<Item = Change<Deltas>> + 'iter
 where
-    T: 'static + std::cmp::PartialEq + Clone,
+    T: 'static + core::cmp::PartialEq + Clone,
     I: Iterator<Item = &'iter T> + 'iter,
 {
     a.enumerate().zip(b).filter_map(move |(a, b)| {
@@ -223,8 +226,8 @@ fn capture_map_state<'iter, K, V>(
     change: ChangeDeltaVariant<MapState<K, Option<V>>>,
 ) -> Vec<Change<Deltas>>
 where
-    K: 'static + std::cmp::PartialEq + Eq + Clone + Hash + Debug,
-    V: 'static + std::cmp::PartialEq + Clone + Debug,
+    K: 'static + PartialEq + Eq + Clone + Hash + Debug,
+    V: 'static + core::cmp::PartialEq + Clone + Debug,
 {
     let a_keys: HashSet<_> = a.keys().collect();
     let b_keys: HashSet<_> = b.keys().collect();
@@ -240,13 +243,13 @@ fn capture_map_state_inner<'iter, K, V>(
     b_keys: &'iter HashSet<&K>,
 ) -> impl Iterator<Item = Delta<MapState<K, Option<V>>>> + 'iter
 where
-    K: 'static + std::cmp::PartialEq + Eq + Clone + Hash + Debug,
-    V: 'static + std::cmp::PartialEq + Clone + Debug,
+    K: 'static + PartialEq + Eq + Clone + Hash + Debug,
+    V: 'static + core::cmp::PartialEq + Clone + Debug,
 {
     let a_diff = a_keys.difference(b_keys).map(|k| Delta {
         from: MapState {
             key: (*k).clone(),
-            value: Some(a[k].clone()),
+            value: Some(a[*k].clone()),
         },
         to: MapState {
             key: (*k).clone(),
@@ -260,12 +263,12 @@ where
         },
         to: MapState {
             key: (*k).clone(),
-            value: Some(b[k].clone()),
+            value: Some(b[*k].clone()),
         },
     });
     let intersection = a_keys.intersection(b_keys).filter_map(|k| {
-        let value_a = &a[k];
-        let value_b = &b[k];
+        let value_a = &a[*k];
+        let value_b = &b[*k];
         (value_a != value_b).then(|| Delta {
             from: MapState {
                 key: (*k).clone(),
@@ -287,7 +290,7 @@ fn capture_vec_state<'iter, I, T>(
     change: ChangeDeltaVariant<VecState<Option<T>>>,
 ) -> impl Iterator<Item = Change<Deltas>> + 'iter
 where
-    T: 'static + std::cmp::PartialEq + Clone,
+    T: 'static + core::cmp::PartialEq + Clone,
     I: Iterator<Item = &'iter T> + 'iter,
 {
     capture_vec_state_inner(a, b).map(move |(index, a, b)| {
@@ -302,13 +305,13 @@ fn capture_vec_state_inner<'iter, I, T>(
     b: I,
 ) -> impl Iterator<Item = (usize, Option<T>, Option<T>)> + 'iter
 where
-    T: 'static + std::cmp::PartialEq + Clone,
+    T: 'static + core::cmp::PartialEq + Clone,
     I: Iterator<Item = &'iter T> + 'iter,
 {
     a.map(Some)
-        .chain(std::iter::repeat(None))
+        .chain(core::iter::repeat(None))
         .enumerate()
-        .zip(b.map(Some).chain(std::iter::repeat(None)))
+        .zip(b.map(Some).chain(core::iter::repeat(None)))
         .take_while(|((_, a), b)| a.is_some() || b.is_some())
         .filter_map(|((index, a), b)| {
             b.map_or(true, |b| a.map_or(true, |a| a != b))
@@ -360,8 +363,8 @@ impl<S, Tx> Interpreter<S, Tx> {
                 .take_while(|((_, a), b)| a != b)
                 .map(|((_, a), b)| (*a, *b))
                 .unzip();
-            from.splice(..0, std::iter::once(s_from)).next();
-            to.splice(..0, std::iter::once(s_to)).next();
+            from.splice(..0, core::iter::once(s_from)).next();
+            to.splice(..0, core::iter::once(s_to)).next();
             diff.changes.push(Change::Memory(Delta {
                 from: Memory { start, bytes: from },
                 to: Memory { start, bytes: to },
@@ -422,7 +425,7 @@ impl<S, Tx> Interpreter<S, Tx> {
 }
 
 fn invert_vec<T: Clone>(vector: &mut Vec<T>, value: &VecState<Option<T>>) {
-    use std::cmp::Ordering;
+    use core::cmp::Ordering;
     match (&value, value.index.cmp(&vector.len())) {
         (
             VecState {
diff --git a/fuel-vm/src/interpreter/diff/storage.rs b/fuel-vm/src/interpreter/diff/storage.rs
index 7f68d01c8..762e3c0e2 100644
--- a/fuel-vm/src/interpreter/diff/storage.rs
+++ b/fuel-vm/src/interpreter/diff/storage.rs
@@ -1,7 +1,5 @@
-use std::{
-    collections::HashMap,
-    fmt::Debug,
-};
+use core::fmt::Debug;
+use hashbrown::HashMap;
 
 use fuel_storage::{
     StorageRead,
@@ -234,7 +232,7 @@ fn mappable_delta_to_hashmap<'value, K, V>(
     state: &mut Delta<HashMap<K, &'value V>>,
     delta: &'value MappableDelta<K, V>,
 ) where
-    K: Copy + PartialEq + Eq + std::hash::Hash + 'static,
+    K: Copy + PartialEq + Eq + core::hash::Hash + 'static,
     V: Clone + 'static,
 {
     match delta {
@@ -299,7 +297,7 @@ where
     fn get(
         &self,
         key: &<Type as Mappable>::Key,
-    ) -> Result<Option<std::borrow::Cow<<Type as Mappable>::OwnedValue>>, Self::Error>
+    ) -> Result<Option<alloc::borrow::Cow<<Type as Mappable>::OwnedValue>>, Self::Error>
     {
         <S as StorageInspect<Type>>::get(&self.0, key)
     }
@@ -418,7 +416,7 @@ where
         id: &ContractId,
         start_key: &Bytes32,
         range: Word,
-    ) -> Result<Vec<Option<std::borrow::Cow<Bytes32>>>, Self::DataError> {
+    ) -> Result<Vec<Option<alloc::borrow::Cow<Bytes32>>>, Self::DataError> {
         self.0.merkle_contract_state_range(id, start_key, range)
     }
 
@@ -437,7 +435,7 @@ where
         contract: &ContractId,
         start_key: &Bytes32,
         range: Word,
-    ) -> Result<Option<()>, Self::DataError> {
+    ) -> Result<Option<()>, S::DataError> {
         self.0
             .merkle_contract_state_remove_range(contract, start_key, range)
     }
diff --git a/fuel-vm/src/interpreter/diff/tests.rs b/fuel-vm/src/interpreter/diff/tests.rs
index abf6816c1..613c06743 100644
--- a/fuel-vm/src/interpreter/diff/tests.rs
+++ b/fuel-vm/src/interpreter/diff/tests.rs
@@ -1,3 +1,9 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+use hashbrown::HashMap;
+
 use fuel_asm::op;
 use fuel_tx::{
     ConsensusParameters,
diff --git a/fuel-vm/src/interpreter/executors/debug.rs b/fuel-vm/src/interpreter/executors/debug.rs
index 33a81d9b4..357a66b79 100644
--- a/fuel-vm/src/interpreter/executors/debug.rs
+++ b/fuel-vm/src/interpreter/executors/debug.rs
@@ -14,7 +14,7 @@ where
     Tx: ExecutableTransaction,
 {
     /// Continue the execution from a previously interrupted program flow.
-    pub fn resume(&mut self) -> Result<ProgramState, InterpreterError> {
+    pub fn resume(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>> {
         let state = self
             .debugger_last_state()
             .ok_or(InterpreterError::DebugStateNotInitialized)?;
diff --git a/fuel-vm/src/interpreter/executors/instruction.rs b/fuel-vm/src/interpreter/executors/instruction.rs
index 8e028cb67..a66528a5e 100644
--- a/fuel-vm/src/interpreter/executors/instruction.rs
+++ b/fuel-vm/src/interpreter/executors/instruction.rs
@@ -2,6 +2,7 @@ use crate::{
     constraints::reg_key::ProgramRegistersSegment,
     error::{
         InterpreterError,
+        IoResult,
         RuntimeError,
     },
     interpreter::{
@@ -26,7 +27,7 @@ use fuel_asm::{
 };
 use fuel_types::Word;
 
-use std::ops::Div;
+use core::ops::Div;
 
 impl<S, Tx> Interpreter<S, Tx>
 where
@@ -34,7 +35,7 @@ where
     Tx: ExecutableTransaction,
 {
     /// Execute the current instruction located in `$m[$pc]`.
-    pub fn execute(&mut self) -> Result<ExecuteState, InterpreterError> {
+    pub fn execute(&mut self) -> Result<ExecuteState, InterpreterError<S::DataError>> {
         if let Some(raw_instruction) = self.fetch_instruction() {
             self.instruction(raw_instruction)
         } else {
@@ -57,7 +58,7 @@ where
     pub fn instruction<R: Into<RawInstruction> + Copy>(
         &mut self,
         raw: R,
-    ) -> Result<ExecuteState, InterpreterError> {
+    ) -> Result<ExecuteState, InterpreterError<S::DataError>> {
         if self.debugger.is_active() {
             let debug = self.eval_debugger_state();
             if !debug.should_continue() {
@@ -72,7 +73,7 @@ where
     fn instruction_inner(
         &mut self,
         raw: RawInstruction,
-    ) -> Result<ExecuteState, RuntimeError> {
+    ) -> IoResult<ExecuteState, S::DataError> {
         let instruction = Instruction::try_from(raw)
             .map_err(|_| RuntimeError::from(PanicReason::ErrorFlag))?;
 
@@ -571,7 +572,7 @@ where
                 let (a, b) = retd.unpack();
                 let len = r!(b);
                 self.dependent_gas_charge(self.gas_costs().retd, len)?;
-                return self.ret_data(r!(a), len).map(ExecuteState::ReturnData)
+                return Ok(self.ret_data(r!(a), len).map(ExecuteState::ReturnData)?)
             }
 
             Instruction::RVRT(rvrt) => {
@@ -907,7 +908,13 @@ fn checked_nth_root(target: u64, nth_root: u64) -> Option<u64> {
 
     // Use floating point operation to get an approximation for the starting point.
     // This is at most off by one in either direction.
-    let guess = (target as f64).powf((nth_root as f64).recip()) as u64;
+
+    #[cfg(feature = "std")]
+    let powf = f64::powf;
+    #[cfg(not(feature = "std"))]
+    let powf = libm::pow;
+
+    let guess = powf(target as f64, (nth_root as f64).recip()) as u64;
 
     debug_assert!(guess != 0, "This should never occur for {{target, n}} > 1");
 
diff --git a/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs b/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
index 2652e10d7..cdabdddae 100644
--- a/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
+++ b/fuel-vm/src/interpreter/executors/instruction/tests/reserved_registers.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    format,
+    vec,
+};
+
 use super::*;
 use crate::{
     checked_transaction::IntoChecked,
diff --git a/fuel-vm/src/interpreter/executors/main.rs b/fuel-vm/src/interpreter/executors/main.rs
index 9bd6f8f4e..a7c9e4208 100644
--- a/fuel-vm/src/interpreter/executors/main.rs
+++ b/fuel-vm/src/interpreter/executors/main.rs
@@ -1,6 +1,11 @@
 #[cfg(test)]
 mod tests;
 
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     checked_transaction::{
         Checked,
@@ -10,8 +15,6 @@ use crate::{
     context::Context,
     error::{
         Bug,
-        BugId,
-        BugVariant,
         InterpreterError,
         PredicateVerificationFailed,
     },
@@ -23,6 +26,10 @@ use crate::{
         RuntimeBalances,
     },
     predicate::RuntimePredicate,
+    prelude::{
+        BugVariant,
+        RuntimeError,
+    },
     state::{
         ExecuteState,
         ProgramState,
@@ -37,7 +44,6 @@ use crate::{
 
 use crate::{
     checked_transaction::CheckPredicateParams,
-    error::BugVariant::GlobalGasUnderflow,
     interpreter::InterpreterParams,
 };
 use fuel_asm::{
@@ -332,7 +338,7 @@ impl<T> Interpreter<PredicateStorage, T> {
 
         let gas_used = available_gas
             .checked_sub(vm.remaining_gas())
-            .ok_or_else(|| Bug::new(BugId::ID004, GlobalGasUnderflow))?;
+            .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
 
         if let PredicateAction::Verifying = predicate_action {
             if !is_successful {
@@ -419,11 +425,11 @@ where
         initial_balances: InitialBalances,
         fee_params: &FeeParameters,
         base_asset_id: &AssetId,
-    ) -> Result<(), InterpreterError> {
+    ) -> Result<(), InterpreterError<S::DataError>> {
         let remaining_gas = create
             .limit()
             .checked_sub(create.gas_used_by_predicates())
-            .ok_or_else(|| InterpreterError::Panic(PanicReason::OutOfGas))?;
+            .ok_or(InterpreterError::Panic(PanicReason::OutOfGas))?;
 
         let metadata = create.metadata().as_ref();
         debug_assert!(
@@ -454,7 +460,7 @@ where
         // Prevent redeployment of contracts
         if storage
             .storage_contract_exists(&id)
-            .map_err(InterpreterError::from_io)?
+            .map_err(RuntimeError::Storage)?
         {
             return Err(InterpreterError::Panic(
                 PanicReason::ContractIdAlreadyDeployed,
@@ -463,7 +469,7 @@ where
 
         storage
             .deploy_contract_with_id(salt, storage_slots, &contract, &root, &id)
-            .map_err(InterpreterError::from_io)?;
+            .map_err(RuntimeError::Storage)?;
         Self::finalize_outputs(
             create,
             fee_params,
@@ -482,13 +488,15 @@ where
     S: InterpreterStorage,
     Tx: ExecutableTransaction,
 {
-    fn update_transaction_outputs(&mut self) -> Result<(), InterpreterError> {
+    fn update_transaction_outputs(
+        &mut self,
+    ) -> Result<(), InterpreterError<S::DataError>> {
         let outputs = self.transaction().outputs().len();
         (0..outputs).try_for_each(|o| self.update_memory_output(o))?;
         Ok(())
     }
 
-    pub(crate) fn run(&mut self) -> Result<ProgramState, InterpreterError> {
+    pub(crate) fn run(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>> {
         // TODO: Remove `Create` from here
         let fee_params = *self.fee_params();
         let base_asset_id = *self.base_asset_id();
@@ -545,7 +553,7 @@ where
                 .transaction()
                 .limit()
                 .checked_sub(self.remaining_gas())
-                .ok_or_else(|| Bug::new(BugId::ID002, BugVariant::GlobalGasUnderflow))?;
+                .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
 
             // Catch VM panic and don't propagate, generating a receipt
             let (status, program) = match program {
@@ -605,7 +613,9 @@ where
         Ok(state)
     }
 
-    pub(crate) fn run_program(&mut self) -> Result<ProgramState, InterpreterError> {
+    pub(crate) fn run_program(
+        &mut self,
+    ) -> Result<ProgramState, InterpreterError<S::DataError>> {
         loop {
             // Check whether the instruction will be executed in a call context
             let in_call = !self.frames.is_empty();
@@ -647,7 +657,7 @@ where
         storage: S,
         tx: Checked<Tx>,
         params: InterpreterParams,
-    ) -> Result<StateTransition<Tx>, InterpreterError> {
+    ) -> Result<StateTransition<Tx>, InterpreterError<S::DataError>> {
         let mut interpreter = Interpreter::with_storage(storage, params);
         interpreter
             .transact(tx)
@@ -664,11 +674,17 @@ where
     pub fn transact(
         &mut self,
         tx: Checked<Tx>,
-    ) -> Result<StateTransitionRef<'_, Tx>, InterpreterError> {
+    ) -> Result<StateTransitionRef<'_, Tx>, InterpreterError<S::DataError>> {
         let state_result = self.init_script(tx).and_then(|_| self.run());
 
         #[cfg(feature = "profile-any")]
-        self.profiler.on_transaction(&state_result);
+        {
+            let r = match &state_result {
+                Ok(state) => Ok(state),
+                Err(err) => Err(err.erase_generics()),
+            };
+            self.profiler.on_transaction(r);
+        }
 
         let state = state_result?;
         Ok(StateTransitionRef::new(
@@ -687,7 +703,10 @@ where
     /// the last state of execution of the `Script` transaction.
     ///
     /// Returns `Create` transaction with all modifications after execution.
-    pub fn deploy(&mut self, tx: Checked<Create>) -> Result<Create, InterpreterError> {
+    pub fn deploy(
+        &mut self,
+        tx: Checked<Create>,
+    ) -> Result<Create, InterpreterError<S::DataError>> {
         let (mut create, metadata) = tx.into();
         let fee_params = *self.fee_params();
         let base_asset_id = *self.base_asset_id();
diff --git a/fuel-vm/src/interpreter/executors/main/tests.rs b/fuel-vm/src/interpreter/executors/main/tests.rs
index b701b4883..03f8e5ef1 100644
--- a/fuel-vm/src/interpreter/executors/main/tests.rs
+++ b/fuel-vm/src/interpreter/executors/main/tests.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use fuel_asm::{
     op,
     RegId,
diff --git a/fuel-vm/src/interpreter/executors/predicate.rs b/fuel-vm/src/interpreter/executors/predicate.rs
index 981f5e1d4..82ac25794 100644
--- a/fuel-vm/src/interpreter/executors/predicate.rs
+++ b/fuel-vm/src/interpreter/executors/predicate.rs
@@ -1,6 +1,10 @@
 use crate::{
-    error::InterpreterError,
+    error::{
+        InterpreterError,
+        PredicateVerificationFailed,
+    },
     prelude::{
+        CheckError,
         ExecutableTransaction,
         Interpreter,
     },
@@ -20,11 +24,15 @@ impl<Tx> Interpreter<PredicateStorage, Tx>
 where
     Tx: ExecutableTransaction,
 {
-    pub(crate) fn verify_predicate(&mut self) -> Result<ProgramState, InterpreterError> {
+    pub(crate) fn verify_predicate(
+        &mut self,
+    ) -> Result<ProgramState, PredicateVerificationFailed> {
         let range = self
             .context
             .predicate()
-            .ok_or(InterpreterError::PredicateFailure)?
+            .ok_or(InterpreterError::CheckError(
+                CheckError::PredicateVerificationFailed,
+            ))?
             .program()
             .words();
 
@@ -33,7 +41,7 @@ where
 
         loop {
             if range.end <= self.registers[RegId::PC] {
-                return Err(InterpreterError::Panic(PanicReason::MemoryOverflow))
+                return Err(PanicReason::MemoryOverflow.into())
             }
 
             match self.execute()? {
@@ -41,13 +49,13 @@ where
                     if r == 1 {
                         return Ok(ProgramState::Return(r))
                     } else {
-                        return Err(InterpreterError::PredicateFailure)
+                        return Err(PanicReason::ContractInstructionNotAllowed.into())
                     }
                 }
 
                 // A predicate is not expected to return data
                 ExecuteState::ReturnData(_) => {
-                    return Err(InterpreterError::PredicateFailure)
+                    return Err(PanicReason::ContractInstructionNotAllowed.into())
                 }
 
                 ExecuteState::Revert(r) => return Ok(ProgramState::Revert(r)),
diff --git a/fuel-vm/src/interpreter/flow.rs b/fuel-vm/src/interpreter/flow.rs
index 4fa8d2e1b..7a396e9ab 100644
--- a/fuel-vm/src/interpreter/flow.rs
+++ b/fuel-vm/src/interpreter/flow.rs
@@ -34,20 +34,29 @@ use crate::{
     },
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::{
+        IoResult,
+        RuntimeError,
+        SimpleResult,
+    },
     interpreter::{
         receipts::ReceiptsCtx,
         InputContracts,
         PanicContext,
     },
+    prelude::{
+        Bug,
+        BugVariant,
+    },
     profiler::Profiler,
     storage::{
-        ContractsAssets,
         ContractsAssetsStorage,
         ContractsRawCode,
         InterpreterStorage,
     },
 };
+use alloc::vec::Vec;
+use core::cmp;
 use fuel_asm::{
     Instruction,
     PanicInstruction,
@@ -55,7 +64,6 @@ use fuel_asm::{
 };
 use fuel_storage::{
     StorageAsRef,
-    StorageInspect,
     StorageRead,
     StorageSize,
 };
@@ -72,7 +80,6 @@ use fuel_types::{
     ContractId,
     Word,
 };
-use std::cmp;
 
 #[cfg(test)]
 mod jump_tests;
@@ -85,12 +92,12 @@ impl<S, Tx> Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
 {
-    pub(crate) fn jump(&mut self, args: JumpArgs) -> Result<(), RuntimeError> {
+    pub(crate) fn jump(&mut self, args: JumpArgs) -> SimpleResult<()> {
         let (SystemRegisters { pc, is, .. }, _) = split_registers(&mut self.registers);
         args.jump(is.as_ref(), pc)
     }
 
-    pub(crate) fn ret(&mut self, a: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn ret(&mut self, a: Word) -> SimpleResult<()> {
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?
                 .copied();
@@ -110,7 +117,7 @@ where
         input.ret(a)
     }
 
-    pub(crate) fn ret_data(&mut self, a: Word, b: Word) -> Result<Bytes32, RuntimeError> {
+    pub(crate) fn ret_data(&mut self, a: Word, b: Word) -> SimpleResult<Bytes32> {
         let current_contract =
             current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?
                 .copied();
@@ -178,7 +185,7 @@ struct RetCtx<'vm> {
 }
 
 impl RetCtx<'_> {
-    pub(crate) fn ret(self, a: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn ret(self, a: Word) -> SimpleResult<()> {
         let receipt = Receipt::ret(
             self.current_contract.unwrap_or_else(ContractId::zeroed),
             a,
@@ -193,16 +200,14 @@ impl RetCtx<'_> {
         self.return_from_context(receipt)
     }
 
-    pub(crate) fn return_from_context(
-        mut self,
-        receipt: Receipt,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn return_from_context(mut self, receipt: Receipt) -> SimpleResult<()> {
         if let Some(frame) = self.frames.pop() {
             let registers = &mut self.registers;
             let context = &mut self.context;
 
-            registers[RegId::CGAS] =
-                arith::add_word(registers[RegId::CGAS], frame.context_gas())?;
+            registers[RegId::CGAS] = registers[RegId::CGAS]
+                .checked_add(frame.context_gas())
+                .ok_or_else(|| Bug::new(BugVariant::ContextGasOverflow))?;
 
             let cgas = registers[RegId::CGAS];
             let ggas = registers[RegId::GGAS];
@@ -224,10 +229,10 @@ impl RetCtx<'_> {
 
         append_receipt(self.append, receipt);
 
-        inc_pc(self.registers.pc_mut())
+        Ok(inc_pc(self.registers.pc_mut())?)
     }
 
-    pub(crate) fn ret_data(self, a: Word, b: Word) -> Result<Bytes32, RuntimeError> {
+    pub(crate) fn ret_data(self, a: Word, b: Word) -> SimpleResult<Bytes32> {
         let range = MemoryRange::new(a, b)?;
 
         let receipt = Receipt::return_data(
@@ -314,13 +319,9 @@ impl JumpArgs {
         self
     }
 
-    pub(crate) fn jump(
-        &self,
-        is: Reg<IS>,
-        mut pc: RegMut<PC>,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn jump(&self, is: Reg<IS>, mut pc: RegMut<PC>) -> SimpleResult<()> {
         if !self.condition {
-            return inc_pc(pc)
+            return Ok(inc_pc(pc)?)
         }
 
         let offset_instructions = match self.mode {
@@ -339,7 +340,7 @@ impl JumpArgs {
             JumpMode::RelativeForwards => pc.saturating_add(offset_bytes),
             JumpMode::RelativeBackwards => pc
                 .checked_sub(offset_bytes)
-                .ok_or_else(|| RuntimeError::Recoverable(PanicReason::MemoryOverflow))?,
+                .ok_or(PanicReason::MemoryOverflow)?,
         };
 
         if target_addr >= VM_MAX_RAM {
@@ -363,7 +364,7 @@ where
         rb: RegId,
         rc: RegId,
         rd: RegId,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         self.prepare_call_inner(
             self.registers[ra],
             self.registers[rb],
@@ -379,7 +380,7 @@ where
         amount_of_coins_to_forward: Word,
         asset_id_mem_address: Word,
         amount_of_gas_to_forward: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> IoResult<(), S::DataError> {
         let params = PrepareCallParams {
             call_params_mem_address,
             amount_of_coins_to_forward,
@@ -487,16 +488,15 @@ struct PrepareCallCtx<'vm, S, I> {
 
 impl<'vm, S, I> PrepareCallCtx<'vm, S, I>
 where
+    S: InterpreterStorage,
     I: Iterator<Item = &'vm ContractId>,
 {
-    fn prepare_call(mut self) -> Result<(), RuntimeError>
+    fn prepare_call(mut self) -> IoResult<(), S::DataError>
     where
         S: StorageSize<ContractsRawCode>
             + ContractsAssetsStorage
             + StorageRead<ContractsRawCode>
             + StorageAsRef,
-        <S as StorageInspect<ContractsRawCode>>::Error: Into<std::io::Error>,
-        <S as StorageInspect<ContractsAssets>>::Error: Into<std::io::Error>,
     {
         let call = self.memory.call_params.try_from(self.memory.memory)?;
         let asset_id = self.memory.asset_id.try_from(self.memory.memory)?;
@@ -555,14 +555,17 @@ where
         );
 
         // subtract gas
-        *self.registers.system_registers.cgas =
-            arith::sub_word(*self.registers.system_registers.cgas, forward_gas_amount)?;
+        *self.registers.system_registers.cgas = (*self.registers.system_registers.cgas)
+            .checked_sub(forward_gas_amount)
+            .ok_or_else(|| Bug::new(BugVariant::ContextGasUnderflow))?;
 
         *frame.context_gas_mut() = *self.registers.system_registers.cgas;
         *frame.global_gas_mut() = *self.registers.system_registers.ggas;
 
         let frame_bytes = frame.to_bytes();
-        let len = arith::add_word(frame_bytes.len() as Word, frame.total_code_size())?;
+        let len = (frame_bytes.len() as Word)
+            .checked_add(frame.total_code_size())
+            .ok_or_else(|| Bug::new(BugVariant::CodeSizeOverflow))?;
 
         if len > *self.registers.system_registers.hp
             || *self.registers.system_registers.sp
@@ -635,10 +638,9 @@ fn write_call_to_memory<S>(
     code_mem_range: MemoryRange,
     memory: &mut [u8; MEM_SIZE],
     storage: &S,
-) -> Result<Word, RuntimeError>
+) -> IoResult<Word, S::Error>
 where
     S: StorageSize<ContractsRawCode> + StorageRead<ContractsRawCode> + StorageAsRef,
-    <S as StorageInspect<ContractsRawCode>>::Error: Into<std::io::Error>,
 {
     let mut code_frame_range = code_mem_range.clone();
     // Addition is safe because code size + padding is always less than len
@@ -654,7 +656,7 @@ where
     let bytes_read = storage
         .storage::<ContractsRawCode>()
         .read(frame.to(), code_range.write(memory))
-        .map_err(RuntimeError::from_io)?
+        .map_err(RuntimeError::Storage)?
         .ok_or(PanicReason::ContractNotFound)?;
     if bytes_read as Word != frame.code_size() {
         return Err(PanicReason::ContractMismatch.into())
@@ -674,10 +676,9 @@ fn call_frame<S>(
     storage: &S,
     call: Call,
     asset_id: AssetId,
-) -> Result<CallFrame, RuntimeError>
+) -> IoResult<CallFrame, S::Error>
 where
     S: StorageSize<ContractsRawCode> + ?Sized,
-    <S as StorageInspect<ContractsRawCode>>::Error: Into<std::io::Error>,
 {
     let (to, a, b) = call.into_inner();
 
@@ -760,7 +761,7 @@ impl<'reg> From<SystemRegisters<'reg>>
 impl<'mem> TryFrom<(&'mem mut [u8; MEM_SIZE], &PrepareCallParams)>
     for PrepareCallMemory<'mem>
 {
-    type Error = RuntimeError;
+    type Error = PanicReason;
 
     fn try_from(
         (memory, params): (&'mem mut [u8; MEM_SIZE], &PrepareCallParams),
diff --git a/fuel-vm/src/interpreter/flow/jump_tests.rs b/fuel-vm/src/interpreter/flow/jump_tests.rs
index c06416039..19a77f90d 100644
--- a/fuel-vm/src/interpreter/flow/jump_tests.rs
+++ b/fuel-vm/src/interpreter/flow/jump_tests.rs
@@ -1,11 +1,13 @@
 use super::*;
 use test_case::test_case;
 
+use crate::error::PanicOrBug;
+
 #[test_case(0, 0, 0 => Ok(0); "noop jump")]
 #[test_case(0, 0, 20 => Ok(80); "jump forwards")]
 #[test_case(0, 80, 10 => Ok(40); "jump backwards")]
-#[test_case(0, 40, VM_MAX_RAM => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "jump too far forward")]
-fn test_absolute_jump(is: Word, mut pc: Word, j: Word) -> Result<Word, RuntimeError> {
+#[test_case(0, 40, VM_MAX_RAM => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "jump too far forward")]
+fn test_absolute_jump(is: Word, mut pc: Word, j: Word) -> SimpleResult<Word> {
     JumpArgs::new(JumpMode::Absolute)
         .to_address(j)
         .jump(Reg::new(&is), RegMut::new(&mut pc))
@@ -14,12 +16,8 @@ fn test_absolute_jump(is: Word, mut pc: Word, j: Word) -> Result<Word, RuntimeEr
 
 #[test_case(0, 0, 20 => Ok(84); "jump from zero")]
 #[test_case(0, 80, 10 => Ok(124); "jump from nonzero")]
-#[test_case(0, 40, VM_MAX_RAM => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "jump too far forward")]
-fn test_relative_forwards_jump(
-    is: Word,
-    mut pc: Word,
-    j: Word,
-) -> Result<Word, RuntimeError> {
+#[test_case(0, 40, VM_MAX_RAM => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "jump too far forward")]
+fn test_relative_forwards_jump(is: Word, mut pc: Word, j: Word) -> SimpleResult<Word> {
     JumpArgs::new(JumpMode::RelativeForwards)
         .to_address(j)
         .jump(Reg::new(&is), RegMut::new(&mut pc))
@@ -28,14 +26,10 @@ fn test_relative_forwards_jump(
 
 #[test_case(0, 20, 4 => Ok(0); "jump to zero")]
 #[test_case(0, 80, 10 => Ok(36); "jump to nonzero")]
-#[test_case(0, 0, 0 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "jump below zero from zero 0")]
-#[test_case(0, 0, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "jump below zero from zero 1")]
-#[test_case(0, 20, 50 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "jump below zero from nonzero")]
-fn test_relative_backwards_jump(
-    is: Word,
-    mut pc: Word,
-    j: Word,
-) -> Result<Word, RuntimeError> {
+#[test_case(0, 0, 0 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "jump below zero from zero 0")]
+#[test_case(0, 0, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "jump below zero from zero 1")]
+#[test_case(0, 20, 50 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "jump below zero from nonzero")]
+fn test_relative_backwards_jump(is: Word, mut pc: Word, j: Word) -> SimpleResult<Word> {
     JumpArgs::new(JumpMode::RelativeBackwards)
         .to_address(j)
         .jump(Reg::new(&is), RegMut::new(&mut pc))
@@ -53,7 +47,7 @@ fn test_not_performed_conditional_jump(
     is: Word,
     mut pc: Word,
     j: Word,
-) -> Result<Word, RuntimeError> {
+) -> SimpleResult<Word> {
     JumpArgs::new(mode)
         .with_condition(false)
         .to_address(j)
diff --git a/fuel-vm/src/interpreter/flow/ret_tests.rs b/fuel-vm/src/interpreter/flow/ret_tests.rs
index c59beb93d..af95da884 100644
--- a/fuel-vm/src/interpreter/flow/ret_tests.rs
+++ b/fuel-vm/src/interpreter/flow/ret_tests.rs
@@ -1,10 +1,18 @@
-use crate::interpreter::memory::Memory;
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
+use crate::{
+    error::PanicOrBug,
+    interpreter::memory::Memory,
+};
 
 use super::*;
 
 #[test]
 fn test_return() {
-    let mut frame_reg: [Word; VM_REGISTER_COUNT] = std::array::from_fn(|i| i as Word);
+    let mut frame_reg: [Word; VM_REGISTER_COUNT] = core::array::from_fn(|i| i as Word);
     frame_reg[RegId::CGAS] = 100;
     let mut expected = frame_reg;
     let frame = CallFrame::new(
@@ -77,10 +85,7 @@ fn test_return() {
         &mut context,
     )
     .ret_data(Word::MAX, Word::MAX);
-    assert_eq!(
-        r,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(r, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 
     let r = input(
         &mut frames,
@@ -90,10 +95,7 @@ fn test_return() {
         &mut context,
     )
     .ret_data(VM_MAX_RAM, 1);
-    assert_eq!(
-        r,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(r, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 
     let r = input(
         &mut frames,
@@ -103,10 +105,7 @@ fn test_return() {
         &mut context,
     )
     .ret_data(0, VM_MAX_RAM + 1);
-    assert_eq!(
-        r,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(r, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 
     let r = input(
         &mut frames,
diff --git a/fuel-vm/src/interpreter/flow/tests.rs b/fuel-vm/src/interpreter/flow/tests.rs
index 1ec294c52..249acd026 100644
--- a/fuel-vm/src/interpreter/flow/tests.rs
+++ b/fuel-vm/src/interpreter/flow/tests.rs
@@ -1,3 +1,10 @@
+use core::convert::Infallible;
+
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     interpreter::memory::Memory,
     storage::MemoryStorage,
@@ -84,8 +91,8 @@ struct Output {
     script: Option<Script>,
 }
 
-impl std::fmt::Debug for Output {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Output {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Output")
             .field("reg", &self.reg)
             .field("memory", &"[..]")
@@ -321,7 +328,7 @@ fn mem(set: &[(usize, Vec<u8>)]) -> Memory<MEM_SIZE> {
         ..Default::default()
     } => using check_output(Err(RuntimeError::Recoverable(PanicReason::NotEnoughBalance))); "Transfer too many coins internally"
 )]
-fn test_prepare_call(input: Input) -> Result<Output, RuntimeError> {
+fn test_prepare_call(input: Input) -> Result<Output, RuntimeError<Infallible>> {
     let Input {
         params,
         mut reg,
@@ -391,8 +398,8 @@ fn test_prepare_call(input: Input) -> Result<Output, RuntimeError> {
 }
 
 fn check_output(
-    expected: Result<Output, RuntimeError>,
-) -> impl FnOnce(Result<Output, RuntimeError>) {
+    expected: Result<Output, RuntimeError<Infallible>>,
+) -> impl FnOnce(Result<Output, RuntimeError<Infallible>>) {
     move |result| match (expected, result) {
         (Ok(e), Ok(r)) => {
             assert_eq!(e.reg, r.reg);
@@ -432,7 +439,7 @@ fn check_output(
 fn test_write_call_to_memory(
     call_frame: CallFrame,
     code_mem_range: MemoryRange,
-) -> Result<Word, RuntimeError> {
+) -> IoResult<Word, Infallible> {
     let frame_bytes = call_frame.to_bytes();
     let mut storage = MemoryStorage::new(Default::default(), Default::default());
     let code = vec![6u8; call_frame.code_size() as usize];
diff --git a/fuel-vm/src/interpreter/gas.rs b/fuel-vm/src/interpreter/gas.rs
index 44a062c52..743258baf 100644
--- a/fuel-vm/src/interpreter/gas.rs
+++ b/fuel-vm/src/interpreter/gas.rs
@@ -1,11 +1,12 @@
 use super::Interpreter;
 use crate::{
-    arith,
     constraints::reg_key::*,
-    error::RuntimeError,
+    error::{
+        PanicOrBug,
+        SimpleResult,
+    },
     prelude::{
         Bug,
-        BugId,
         BugVariant,
     },
     profiler::Profiler,
@@ -42,7 +43,7 @@ impl<S, Tx> Interpreter<S, Tx> {
         &mut self,
         gas_cost: DependentCost,
         arg: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let current_contract = self.contract_id();
         let SystemRegisters {
             pc, ggas, cgas, is, ..
@@ -57,7 +58,7 @@ impl<S, Tx> Interpreter<S, Tx> {
     }
 
     /// Do a gas charge with the given amount, panicing when running out of gas.
-    pub(crate) fn gas_charge(&mut self, gas: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn gas_charge(&mut self, gas: Word) -> SimpleResult<()> {
         let current_contract = self.contract_id();
         let SystemRegisters {
             pc, ggas, cgas, is, ..
@@ -79,7 +80,7 @@ pub(crate) fn dependent_gas_charge(
     mut profiler: ProfileGas<'_>,
     gas_cost: DependentCost,
     arg: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     if gas_cost.dep_per_unit == 0 {
         gas_charge(cgas, ggas, profiler, gas_cost.base)
     } else {
@@ -94,7 +95,7 @@ fn dependent_gas_charge_inner(
     ggas: RegMut<GGAS>,
     gas_cost: DependentCost,
     arg: Word,
-) -> Result<Word, RuntimeError> {
+) -> Result<Word, PanicOrBug> {
     let cost = gas_cost
         .base
         .saturating_add(arg.saturating_div(gas_cost.dep_per_unit));
@@ -106,7 +107,7 @@ pub(crate) fn gas_charge(
     ggas: RegMut<GGAS>,
     mut profiler: ProfileGas<'_>,
     gas: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     profiler.profile(cgas.as_ref(), gas);
     gas_charge_inner(cgas, ggas, gas)
 }
@@ -115,17 +116,23 @@ fn gas_charge_inner(
     mut cgas: RegMut<CGAS>,
     mut ggas: RegMut<GGAS>,
     gas: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     if *cgas > *ggas {
-        Err(Bug::new(BugId::ID008, BugVariant::GlobalGasLessThanContext).into())
+        Err(Bug::new(BugVariant::GlobalGasLessThanContext).into())
     } else if gas > *cgas {
-        *ggas = arith::sub_word(*ggas, *cgas)?;
+        *ggas = (*ggas)
+            .checked_sub(*cgas)
+            .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
         *cgas = 0;
 
         Err(PanicReason::OutOfGas.into())
     } else {
-        *cgas = arith::sub_word(*cgas, gas)?;
-        *ggas = arith::sub_word(*ggas, gas)?;
+        *cgas = (*cgas)
+            .checked_sub(gas)
+            .ok_or_else(|| Bug::new(BugVariant::ContextGasUnderflow))?;
+        *ggas = (*ggas)
+            .checked_sub(gas)
+            .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
 
         Ok(())
     }
diff --git a/fuel-vm/src/interpreter/gas/tests.rs b/fuel-vm/src/interpreter/gas/tests.rs
index d0304e716..103546d35 100644
--- a/fuel-vm/src/interpreter/gas/tests.rs
+++ b/fuel-vm/src/interpreter/gas/tests.rs
@@ -12,13 +12,13 @@ struct GasChargeOutput {
     ggas: u64,
 }
 #[test_case(GasChargeInput{cgas: 0, ggas: 0, dependent_factor: 0} => Ok(GasChargeOutput{ cgas: 0, ggas: 0}); "zero")]
-#[test_case(GasChargeInput{cgas: 0, ggas: 0, dependent_factor: 1} => Err(RuntimeError::Recoverable(PanicReason::OutOfGas)); "no gas")]
-#[test_case(GasChargeInput{cgas: 2, ggas: 0, dependent_factor: 1} => matches Err(RuntimeError::Halt(_)); "global gas less than context")]
-#[test_case(GasChargeInput{cgas: 0, ggas: 2, dependent_factor: 1} => Err(RuntimeError::Recoverable(PanicReason::OutOfGas)); "no call gas")]
+#[test_case(GasChargeInput{cgas: 0, ggas: 0, dependent_factor: 1} => Err(PanicOrBug::Panic(PanicReason::OutOfGas)); "no gas")]
+#[test_case(GasChargeInput{cgas: 2, ggas: 0, dependent_factor: 1} => matches Err(PanicOrBug::Bug(_)); "global gas less than context")]
+#[test_case(GasChargeInput{cgas: 0, ggas: 2, dependent_factor: 1} => Err(PanicOrBug::Panic(PanicReason::OutOfGas)); "no call gas")]
 #[test_case(GasChargeInput{cgas: 1, ggas: 1, dependent_factor: 1} => Ok(GasChargeOutput{ cgas: 0, ggas: 0}); "just enough")]
 #[test_case(GasChargeInput{cgas: 10, ggas: 15, dependent_factor: 1} => Ok(GasChargeOutput{ cgas: 9, ggas: 14}); "heaps")]
 
-fn test_gas_charge(input: GasChargeInput) -> Result<GasChargeOutput, RuntimeError> {
+fn test_gas_charge(input: GasChargeInput) -> SimpleResult<GasChargeOutput> {
     let GasChargeInput {
         mut cgas,
         mut ggas,
@@ -41,7 +41,7 @@ fn test_gas_charges_ggas_on_out_of_gas() {
     let gas = 20;
     let mut cgas = RegMut::new(&mut cgas);
     let mut ggas = RegMut::new(&mut ggas);
-    gas_charge_inner(cgas.as_mut(), ggas.as_mut(), gas)
+    let _ = gas_charge_inner(cgas.as_mut(), ggas.as_mut(), gas)
         .expect_err("Gas charge should fail");
     assert_eq!(*ggas, 5);
     assert_eq!(*cgas, 0);
@@ -86,17 +86,15 @@ struct DepGasChargeInput {
     DepGasChargeInput{
         input: GasChargeInput{cgas: 0, ggas: 1, dependent_factor: 0},
         gas_cost: DependentCost{base: 1, dep_per_unit: 1}
-    } => Err(RuntimeError::Recoverable(PanicReason::OutOfGas)); "just base with no cgas"
+    } => Err(PanicOrBug::Panic(PanicReason::OutOfGas)); "just base with no cgas"
 )]
 #[test_case(
     DepGasChargeInput{
         input: GasChargeInput{cgas: 5, ggas: 10, dependent_factor: 25},
         gas_cost: DependentCost{base: 1, dep_per_unit: 5}
-    } => Err(RuntimeError::Recoverable(PanicReason::OutOfGas)); "unit with not enough cgas"
+    } => Err(PanicOrBug::Panic(PanicReason::OutOfGas)); "unit with not enough cgas"
 )]
-fn test_dependent_gas_charge(
-    input: DepGasChargeInput,
-) -> Result<GasChargeOutput, RuntimeError> {
+fn test_dependent_gas_charge(input: DepGasChargeInput) -> SimpleResult<GasChargeOutput> {
     let DepGasChargeInput { input, gas_cost } = input;
     let GasChargeInput {
         mut cgas,
diff --git a/fuel-vm/src/interpreter/initialization.rs b/fuel-vm/src/interpreter/initialization.rs
index 4e3109d6e..17afc376d 100644
--- a/fuel-vm/src/interpreter/initialization.rs
+++ b/fuel-vm/src/interpreter/initialization.rs
@@ -13,9 +13,9 @@ use crate::{
     context::Context,
     error::{
         Bug,
-        BugId,
         InterpreterError,
     },
+    prelude::RuntimeError,
     storage::InterpreterStorage,
 };
 
@@ -29,11 +29,11 @@ use crate::{
     error::BugVariant::GlobalGasUnderflow,
     interpreter::CheckedMetadata,
 };
-use std::io;
 
 impl<S, Tx> Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     /// Initialize the VM with a given transaction
     fn init_inner(
@@ -42,7 +42,7 @@ where
         initial_balances: InitialBalances,
         runtime_balances: RuntimeBalances,
         gas_limit: Word,
-    ) -> Result<(), InterpreterError> {
+    ) -> Result<(), RuntimeError<S::DataError>> {
         self.tx = tx;
 
         self.initial_balances = initial_balances.clone();
@@ -59,21 +59,18 @@ where
         // Set heap area
         self.registers[RegId::HP] = VM_MAX_RAM;
 
-        self.push_stack(self.transaction().id(&self.chain_id()).as_ref())
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+        self.push_stack(self.transaction().id(&self.chain_id()).as_ref())?;
 
         runtime_balances.to_vm(self);
 
         let tx_size = self.transaction().size() as Word;
         self.set_gas(gas_limit);
 
-        self.push_stack(&tx_size.to_be_bytes())
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+        self.push_stack(&tx_size.to_be_bytes())?;
 
         let tx_bytes = self.tx.to_bytes();
 
-        self.push_stack(tx_bytes.as_slice())
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+        self.push_stack(tx_bytes.as_slice())?;
 
         self.registers[RegId::SP] = self.registers[RegId::SSP];
 
@@ -84,6 +81,7 @@ where
 impl<S, Tx> Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     /// Initialize the VM for a predicate context
     pub fn init_predicate(
@@ -91,19 +89,20 @@ where
         context: Context,
         mut tx: Tx,
         gas_limit: Word,
-    ) -> Result<(), InterpreterError> {
+    ) -> Result<(), InterpreterError<S::DataError>> {
         self.context = context;
         tx.prepare_init_predicate();
 
         let initial_balances: InitialBalances = Default::default();
         let runtime_balances = initial_balances.clone().try_into()?;
-        self.init_inner(tx, initial_balances, runtime_balances, gas_limit)
+        Ok(self.init_inner(tx, initial_balances, runtime_balances, gas_limit)?)
     }
 }
 
 impl<S, Tx> Interpreter<S, Tx>
 where
     S: InterpreterStorage,
+    <S as InterpreterStorage>::DataError: From<S::DataError>,
     Tx: ExecutableTransaction,
     <Tx as IntoChecked>::Metadata: CheckedMetadata,
 {
@@ -111,11 +110,11 @@ where
     /// allows execution of contract opcodes.
     ///
     /// For predicate estimation and verification, check [`Self::init_predicate`]
-    pub fn init_script(&mut self, checked: Checked<Tx>) -> Result<(), InterpreterError> {
-        let block_height = self
-            .storage
-            .block_height()
-            .map_err(InterpreterError::from_io)?;
+    pub fn init_script(
+        &mut self,
+        checked: Checked<Tx>,
+    ) -> Result<(), InterpreterError<S::DataError>> {
+        let block_height = self.storage.block_height().map_err(RuntimeError::Storage)?;
 
         self.context = Context::Script { block_height };
 
@@ -125,10 +124,10 @@ where
         let gas_limit = tx
             .limit()
             .checked_sub(gas_used_by_predicates)
-            .ok_or_else(|| Bug::new(BugId::ID003, GlobalGasUnderflow))?;
+            .ok_or_else(|| Bug::new(GlobalGasUnderflow))?;
 
         let initial_balances = metadata.balances();
         let runtime_balances = initial_balances.try_into()?;
-        self.init_inner(tx, metadata.balances(), runtime_balances, gas_limit)
+        Ok(self.init_inner(tx, metadata.balances(), runtime_balances, gas_limit)?)
     }
 }
diff --git a/fuel-vm/src/interpreter/internal.rs b/fuel-vm/src/interpreter/internal.rs
index 65ab6b2e9..a7cbcccfd 100644
--- a/fuel-vm/src/interpreter/internal.rs
+++ b/fuel-vm/src/interpreter/internal.rs
@@ -12,7 +12,7 @@ use crate::{
     },
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_asm::{
@@ -46,17 +46,14 @@ use core::mem;
 
 #[cfg(test)]
 mod message_tests;
-#[cfg(all(test, feature = "random"))]
+#[cfg(test)]
 mod tests;
 
 impl<S, Tx> Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
 {
-    pub(crate) fn update_memory_output(
-        &mut self,
-        idx: usize,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn update_memory_output(&mut self, idx: usize) -> SimpleResult<()> {
         let tx_offset = self.tx_offset();
         update_memory_output(&mut self.tx, &mut self.memory, tx_offset, idx)
     }
@@ -83,7 +80,7 @@ pub(crate) fn set_variable_output<Tx: ExecutableTransaction>(
     tx_offset: usize,
     idx: usize,
     variable: Output,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     tx.replace_variable_output(idx, variable)?;
     update_memory_output(tx, memory, tx_offset, idx)
 }
@@ -100,7 +97,7 @@ pub(crate) fn absolute_output_mem_range<Tx: Outputs>(
     tx: &Tx,
     tx_offset: usize,
     idx: usize,
-) -> Result<Option<MemoryRange>, RuntimeError> {
+) -> Result<Option<MemoryRange>, PanicReason> {
     absolute_output_offset(tx, tx_offset, idx)
         .and_then(|offset| tx.outputs().get(idx).map(|output| (offset, output.size())))
         .map_or(Ok(None), |(offset, output_size)| {
@@ -113,7 +110,7 @@ pub(crate) fn update_memory_output<Tx: ExecutableTransaction>(
     memory: &mut [u8; MEM_SIZE],
     tx_offset: usize,
     idx: usize,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let mem_range = absolute_output_mem_range(tx, tx_offset, idx)?
         .ok_or(PanicReason::OutputNotFound)?;
     let mut mem = mem_range.write(memory);
@@ -160,17 +157,17 @@ pub(crate) fn append_receipt(input: AppendReceipt, receipt: Receipt) {
 }
 
 impl<S, Tx> Interpreter<S, Tx> {
-    pub(crate) fn reserve_stack(&mut self, len: Word) -> Result<Word, RuntimeError> {
+    pub(crate) fn reserve_stack(&mut self, len: Word) -> Result<Word, PanicReason> {
         let (ssp, overflow) = self.registers[RegId::SSP].overflowing_add(len);
 
         if overflow || !self.is_external_context() && ssp > self.registers[RegId::SP] {
-            Err(PanicReason::MemoryOverflow.into())
+            Err(PanicReason::MemoryOverflow)
         } else {
             Ok(mem::replace(&mut self.registers[RegId::SSP], ssp))
         }
     }
 
-    pub(crate) fn push_stack(&mut self, data: &[u8]) -> Result<(), RuntimeError> {
+    pub(crate) fn push_stack(&mut self, data: &[u8]) -> SimpleResult<()> {
         let ssp = self.reserve_stack(data.len() as Word)?;
 
         self.memory[ssp as usize..self.registers[RegId::SSP] as usize]
@@ -179,7 +176,7 @@ impl<S, Tx> Interpreter<S, Tx> {
         Ok(())
     }
 
-    pub(crate) fn set_flag(&mut self, a: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn set_flag(&mut self, a: Word) -> SimpleResult<()> {
         let (SystemRegisters { flag, pc, .. }, _) = split_registers(&mut self.registers);
         set_flag(flag, pc, a)
     }
@@ -199,7 +196,7 @@ impl<S, Tx> Interpreter<S, Tx> {
         )
     }
 
-    pub(crate) fn internal_contract(&self) -> Result<&ContractId, RuntimeError> {
+    pub(crate) fn internal_contract(&self) -> Result<&ContractId, PanicReason> {
         internal_contract(&self.context, self.registers.fp(), &self.memory)
     }
 
@@ -230,19 +227,19 @@ pub(crate) fn set_flag(
     mut flag: RegMut<FLAG>,
     pc: RegMut<PC>,
     a: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let Some(flags) = Flags::from_bits(a) else {
         return Err(PanicReason::ErrorFlag.into())
     };
 
     *flag = flags.bits();
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
-pub(crate) fn inc_pc(mut pc: RegMut<PC>) -> Result<(), RuntimeError> {
+pub(crate) fn inc_pc(mut pc: RegMut<PC>) -> Result<(), PanicReason> {
     pc.checked_add(Instruction::SIZE as Word)
-        .ok_or_else(|| PanicReason::MemoryOverflow.into())
+        .ok_or(PanicReason::MemoryOverflow)
         .map(|i| *pc = i)
 }
 
@@ -260,7 +257,7 @@ pub(crate) fn base_asset_balance_sub(
     balances: &mut RuntimeBalances,
     memory: &mut [u8; MEM_SIZE],
     value: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     external_asset_id_balance_sub(balances, memory, base_asset_id, value)
 }
 
@@ -270,7 +267,7 @@ pub(crate) fn external_asset_id_balance_sub(
     memory: &mut [u8; MEM_SIZE],
     asset_id: &AssetId,
     value: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     balances
         .checked_balance_sub(memory, asset_id, value)
         .ok_or(PanicReason::NotEnoughBalance)?;
@@ -291,7 +288,7 @@ pub(crate) fn current_contract<'a>(
     context: &Context,
     fp: Reg<FP>,
     memory: &'a [u8; MEM_SIZE],
-) -> Result<Option<&'a ContractId>, RuntimeError> {
+) -> Result<Option<&'a ContractId>, PanicReason> {
     if context.is_internal() {
         Ok(Some(internal_contract(context, fp, memory)?))
     } else {
@@ -303,7 +300,7 @@ pub(crate) fn internal_contract<'a>(
     context: &Context,
     register: Reg<FP>,
     memory: &'a [u8; MEM_SIZE],
-) -> Result<&'a ContractId, RuntimeError> {
+) -> Result<&'a ContractId, PanicReason> {
     let range = internal_contract_bounds(context, register)?;
 
     // Safety: Memory bounds logically verified by the interpreter
@@ -315,11 +312,11 @@ pub(crate) fn internal_contract<'a>(
 pub(crate) fn internal_contract_bounds(
     context: &Context,
     fp: Reg<FP>,
-) -> Result<CheckedMemConstLen<{ ContractId::LEN }>, RuntimeError> {
+) -> Result<CheckedMemConstLen<{ ContractId::LEN }>, PanicReason> {
     if context.is_internal() {
         CheckedMemConstLen::new(*fp)
     } else {
-        Err(PanicReason::ExpectedInternalContext.into())
+        Err(PanicReason::ExpectedInternalContext)
     }
 }
 
diff --git a/fuel-vm/src/interpreter/internal/message_tests.rs b/fuel-vm/src/interpreter/internal/message_tests.rs
index 254e9d1f4..fb96bb547 100644
--- a/fuel-vm/src/interpreter/internal/message_tests.rs
+++ b/fuel-vm/src/interpreter/internal/message_tests.rs
@@ -1,4 +1,12 @@
-use crate::interpreter::memory::Memory;
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
+use crate::{
+    error::PanicOrBug,
+    interpreter::memory::Memory,
+};
 
 use super::*;
 use fuel_tx::Create;
@@ -34,14 +42,14 @@ fn test_absolute_output_offset(
     ; "Output at 200 in memory"
 )]
 #[test_case(
-    MEM_SIZE - 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
+    MEM_SIZE - 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow))
     ; "Output at MEM_SIZE - 1 should overflow"
 )]
 #[test_case(
-    MEM_SIZE - 1 - 112 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
+    MEM_SIZE - 1 - 112 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow))
     ; "Output at MEM_SIZE - 1 - output_size should overflow"
 )]
-fn test_update_memory_output(tx_offset: usize) -> Result<Memory<MEM_SIZE>, RuntimeError> {
+fn test_update_memory_output(tx_offset: usize) -> SimpleResult<Memory<MEM_SIZE>> {
     let mut tx = Create::default();
     *tx.outputs_mut() = vec![Output::default()];
     let mut memory: Memory<MEM_SIZE> = vec![0; MEM_SIZE].try_into().unwrap();
diff --git a/fuel-vm/src/interpreter/internal/tests.rs b/fuel-vm/src/interpreter/internal/tests.rs
index 845fe37b2..904c51b0e 100644
--- a/fuel-vm/src/interpreter/internal/tests.rs
+++ b/fuel-vm/src/interpreter/internal/tests.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use crate::{
     constraints::reg_key::RegMut,
     interpreter::{
diff --git a/fuel-vm/src/interpreter/log.rs b/fuel-vm/src/interpreter/log.rs
index f8d789da0..a0e1b2061 100644
--- a/fuel-vm/src/interpreter/log.rs
+++ b/fuel-vm/src/interpreter/log.rs
@@ -14,7 +14,7 @@ use crate::{
     constraints::reg_key::*,
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_tx::{
@@ -30,13 +30,7 @@ impl<S, Tx> Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
 {
-    pub(crate) fn log(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-        d: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn log(&mut self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
@@ -59,7 +53,7 @@ where
         b: Word,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { fp, is, pc, .. }, _) =
             split_registers(&mut self.registers);
@@ -89,13 +83,7 @@ struct LogInput<'vm> {
 }
 
 impl LogInput<'_> {
-    pub(crate) fn log(
-        self,
-        a: Word,
-        b: Word,
-        c: Word,
-        d: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn log(self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
         let receipt = Receipt::log(
             internal_contract_or_default(self.context, self.fp, self.memory),
             a,
@@ -116,16 +104,10 @@ impl LogInput<'_> {
             receipt,
         );
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 
-    pub(crate) fn log_data(
-        self,
-        a: Word,
-        b: Word,
-        c: Word,
-        d: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn log_data(self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
         let range = MemoryRange::new(c, d)?;
 
         let receipt = Receipt::log_data(
@@ -148,6 +130,6 @@ impl LogInput<'_> {
             receipt,
         );
 
-        inc_pc(self.pc)
+        Ok(inc_pc(self.pc)?)
     }
 }
diff --git a/fuel-vm/src/interpreter/log/tests.rs b/fuel-vm/src/interpreter/log/tests.rs
index 65fbf93fd..d6ce9e153 100644
--- a/fuel-vm/src/interpreter/log/tests.rs
+++ b/fuel-vm/src/interpreter/log/tests.rs
@@ -1,9 +1,11 @@
+use alloc::vec;
+
 use crate::interpreter::memory::Memory;
 
 use super::*;
 
 #[test]
-fn test_log() -> Result<(), RuntimeError> {
+fn test_log() -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let context = Context::Script {
         block_height: Default::default(),
diff --git a/fuel-vm/src/interpreter/memory.rs b/fuel-vm/src/interpreter/memory.rs
index 0b796e54c..55fea69fb 100644
--- a/fuel-vm/src/interpreter/memory.rs
+++ b/fuel-vm/src/interpreter/memory.rs
@@ -7,7 +7,7 @@ use crate::{
     constraints::reg_key::*,
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_asm::{
@@ -20,7 +20,8 @@ use fuel_types::{
     Word,
 };
 
-use std::{
+use alloc::boxed::Box;
+use core::{
     ops,
     ops::Range,
 };
@@ -42,20 +43,20 @@ pub trait ToAddr {
     /// Converts a value to `usize` used for memory addresses.
     /// Returns `Err` with `MemoryOverflow` if the resulting value does't fit in the VM
     /// memory. This can be used for both addresses and offsets.
-    fn to_addr(self) -> Result<usize, RuntimeError>;
+    fn to_addr(self) -> Result<usize, PanicReason>;
 }
 
 impl ToAddr for usize {
-    fn to_addr(self) -> Result<usize, RuntimeError> {
+    fn to_addr(self) -> Result<usize, PanicReason> {
         if self > MEM_SIZE {
-            return Err(PanicReason::MemoryOverflow.into())
+            return Err(PanicReason::MemoryOverflow)
         }
         Ok(self)
     }
 }
 
 impl ToAddr for Word {
-    fn to_addr(self) -> Result<usize, RuntimeError> {
+    fn to_addr(self) -> Result<usize, PanicReason> {
         let value = usize::try_from(self).map_err(|_| PanicReason::MemoryOverflow)?;
         value.to_addr()
     }
@@ -64,7 +65,7 @@ impl ToAddr for Word {
 #[cfg(feature = "test-helpers")]
 /// Implemented for `i32` to allow integer literals. Panics on negative values.
 impl ToAddr for i32 {
-    fn to_addr(self) -> Result<usize, RuntimeError> {
+    fn to_addr(self) -> Result<usize, PanicReason> {
         if self < 0 {
             panic!("Negative memory address");
         }
@@ -94,13 +95,13 @@ impl ops::Deref for MemoryRange {
 
 impl MemoryRange {
     /// Create a new memory range represented as `[address, address + size[`.
-    pub fn new<A: ToAddr, B: ToAddr>(address: A, size: B) -> Result<Self, RuntimeError> {
+    pub fn new<A: ToAddr, B: ToAddr>(address: A, size: B) -> Result<Self, PanicReason> {
         let start = address.to_addr()?;
         let size = size.to_addr()?;
         let end = start.checked_add(size).ok_or(PanicReason::MemoryOverflow)?;
 
         if end > MEM_SIZE {
-            return Err(PanicReason::MemoryOverflow.into())
+            return Err(PanicReason::MemoryOverflow)
         }
 
         Ok(Self(start..end))
@@ -109,7 +110,7 @@ impl MemoryRange {
     /// Create a new const sized memory range.
     pub fn new_const<A: ToAddr, const SIZE: usize>(
         address: A,
-    ) -> Result<Self, RuntimeError> {
+    ) -> Result<Self, PanicReason> {
         Self::new(address, SIZE)
     }
 
@@ -121,13 +122,13 @@ impl MemoryRange {
         base: T,
         offset: T,
         size: A,
-    ) -> Result<Self, RuntimeError>
+    ) -> Result<Self, PanicReason>
     where
         F: FnOnce(T, T) -> (T, bool),
     {
         let (addr, overflow) = overflowing_op(base, offset);
         if overflow {
-            return Err(PanicReason::MemoryOverflow.into())
+            return Err(PanicReason::MemoryOverflow)
         }
         Self::new(addr, size)
     }
@@ -208,11 +209,7 @@ where
         OwnershipRegisters::new(self)
     }
 
-    pub(crate) fn stack_pointer_overflow<F>(
-        &mut self,
-        f: F,
-        v: Word,
-    ) -> Result<(), RuntimeError>
+    pub(crate) fn stack_pointer_overflow<F>(&mut self, f: F, v: Word) -> SimpleResult<()>
     where
         F: FnOnce(Word, Word) -> (Word, bool),
     {
@@ -229,7 +226,7 @@ where
         &mut self,
         segment: ProgramRegistersSegment,
         bitmask: Imm24,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (
             SystemRegisters {
                 sp, ssp, hp, pc, ..
@@ -252,7 +249,7 @@ where
         &mut self,
         segment: ProgramRegistersSegment,
         bitmask: Imm24,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (
             SystemRegisters {
                 sp, ssp, hp, pc, ..
@@ -276,7 +273,7 @@ where
         ra: RegisterId,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
         load_byte(&self.memory, pc, result, b, c)
@@ -287,49 +284,34 @@ where
         ra: RegisterId,
         b: Word,
         c: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
         load_word(&self.memory, pc, result, b, c)
     }
 
-    pub(crate) fn store_byte(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn store_byte(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         store_byte(&mut self.memory, owner, self.registers.pc_mut(), a, b, c)
     }
 
-    pub(crate) fn store_word(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn store_word(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         store_word(&mut self.memory, owner, self.registers.pc_mut(), a, b, c)
     }
 
-    pub(crate) fn malloc(&mut self, a: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn malloc(&mut self, a: Word) -> SimpleResult<()> {
         let (SystemRegisters { hp, sp, pc, .. }, _) =
             split_registers(&mut self.registers);
         malloc(hp, sp.as_ref(), pc, a)
     }
 
-    pub(crate) fn memclear(&mut self, a: Word, b: Word) -> Result<(), RuntimeError> {
+    pub(crate) fn memclear(&mut self, a: Word, b: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         memclear(&mut self.memory, owner, self.registers.pc_mut(), a, b)
     }
 
-    pub(crate) fn memcopy(
-        &mut self,
-        a: Word,
-        b: Word,
-        c: Word,
-    ) -> Result<(), RuntimeError> {
+    pub(crate) fn memcopy(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
         let owner = self.ownership_registers();
         memcopy(&mut self.memory, owner, self.registers.pc_mut(), a, b, c)
     }
@@ -340,7 +322,7 @@ where
         b: Word,
         c: Word,
         d: Word,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
         memeq(&mut self.memory, result, pc, b, c, d)
@@ -353,7 +335,7 @@ pub(crate) fn try_update_stack_pointer(
     ssp: Reg<SSP>,
     hp: Reg<HP>,
     new_sp: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     if new_sp >= *hp || new_sp < *ssp {
         Err(PanicReason::MemoryOverflow.into())
     } else {
@@ -369,7 +351,7 @@ pub(crate) fn stack_pointer_overflow<F>(
     pc: RegMut<PC>,
     f: F,
     v: Word,
-) -> Result<(), RuntimeError>
+) -> SimpleResult<()>
 where
     F: FnOnce(Word, Word) -> (Word, bool),
 {
@@ -380,7 +362,7 @@ where
     }
 
     try_update_stack_pointer(sp, ssp, hp, new_sp)?;
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -393,7 +375,7 @@ pub(crate) fn push_selected_registers(
     program_regs: &ProgramRegisters,
     segment: ProgramRegistersSegment,
     bitmask: Imm24,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let bitmask = bitmask.to_u32();
 
     // First update the new stack pointer, as that's the only error condition
@@ -412,7 +394,7 @@ pub(crate) fn push_selected_registers(
         }
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -425,7 +407,7 @@ pub(crate) fn pop_selected_registers(
     program_regs: &mut ProgramRegisters,
     segment: ProgramRegistersSegment,
     bitmask: Imm24,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let bitmask = bitmask.to_u32();
 
     // First update the stack pointer, as that's the only error condition
@@ -447,7 +429,7 @@ pub(crate) fn pop_selected_registers(
         }
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn load_byte(
@@ -456,10 +438,10 @@ pub(crate) fn load_byte(
     result: &mut Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new_overflowing_op(Word::overflowing_add, b, c, 1u64)?;
     *result = memory[range.start] as Word;
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn load_word(
@@ -468,12 +450,12 @@ pub(crate) fn load_word(
     result: &mut Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     // C is expressed in words; mul by 8. This cannot overflow since it's a 12 bit
     // immediate value.
     let addr = b.checked_add(c * 8).ok_or(PanicReason::MemoryOverflow)?;
     *result = Word::from_be_bytes(read_bytes(memory, addr)?);
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn store_byte(
@@ -483,9 +465,9 @@ pub(crate) fn store_byte(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     write_bytes(memory, owner, a.saturating_add(c), [b as u8])?;
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn store_word(
@@ -495,12 +477,12 @@ pub(crate) fn store_word(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     // C is expressed in words; mul by 8. This cannot overflow since it's a 12 bit
     // immediate value.
     let addr = a.checked_add(c * 8).ok_or(PanicReason::MemoryOverflow)?;
     write_bytes(memory, owner, addr, b.to_be_bytes())?;
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn malloc(
@@ -508,7 +490,7 @@ pub(crate) fn malloc(
     sp: Reg<SP>,
     pc: RegMut<PC>,
     a: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let (result, overflow) = hp.overflowing_sub(a);
 
     if overflow || result < *sp {
@@ -516,7 +498,7 @@ pub(crate) fn malloc(
     } else {
         *hp = result;
 
-        inc_pc(pc)
+        Ok(inc_pc(pc)?)
     }
 }
 
@@ -526,11 +508,11 @@ pub(crate) fn memclear(
     pc: RegMut<PC>,
     a: Word,
     b: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new(a, b)?;
     owner.verify_ownership(&range)?;
     memory[range.usizes()].fill(0);
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn memcopy(
@@ -540,7 +522,7 @@ pub(crate) fn memcopy(
     a: Word,
     b: Word,
     c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let dst_range = MemoryRange::new(a, c)?;
     let src_range = MemoryRange::new(b, c)?;
 
@@ -563,7 +545,7 @@ pub(crate) fn memcopy(
         dst[..len].copy_from_slice(&src[src_range.usizes()]);
     }
 
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 pub(crate) fn memeq(
@@ -573,11 +555,11 @@ pub(crate) fn memeq(
     b: Word,
     c: Word,
     d: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range1 = MemoryRange::new(b, d)?;
     let range2 = MemoryRange::new(c, d)?;
     *result = (memory[range1.usizes()] == memory[range2.usizes()]) as Word;
-    inc_pc(pc)
+    Ok(inc_pc(pc)?)
 }
 
 #[derive(Debug)]
@@ -671,7 +653,7 @@ pub(crate) fn try_mem_write<A: ToAddr>(
     data: &[u8],
     owner: OwnershipRegisters,
     memory: &mut [u8; MEM_SIZE],
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new(addr, data.len())?;
     owner.verify_ownership(&range)?;
     memory[range.usizes()].copy_from_slice(data);
@@ -683,7 +665,7 @@ pub(crate) fn try_zeroize<A: ToAddr, B: ToAddr>(
     len: B,
     owner: OwnershipRegisters,
     memory: &mut [u8; MEM_SIZE],
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new(addr, len)?;
     owner.verify_ownership(&range)?;
     memory[range.usizes()].fill(0);
@@ -695,7 +677,7 @@ pub(crate) fn try_zeroize<A: ToAddr, B: ToAddr>(
 pub(crate) fn read_bytes<const COUNT: usize>(
     memory: &[u8; MEM_SIZE],
     addr: Word,
-) -> Result<[u8; COUNT], RuntimeError> {
+) -> Result<[u8; COUNT], PanicReason> {
     let range = MemoryRange::new_const::<_, COUNT>(addr)?;
     Ok(<[u8; COUNT]>::try_from(&memory[range.usizes()])
         .unwrap_or_else(|_| unreachable!()))
@@ -708,7 +690,7 @@ pub(crate) fn write_bytes<const COUNT: usize>(
     owner: OwnershipRegisters,
     addr: Word,
     bytes: [u8; COUNT],
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new_const::<_, COUNT>(addr)?;
     owner.verify_ownership(&range)?;
     memory[range.usizes()].copy_from_slice(&bytes);
@@ -723,7 +705,7 @@ pub(crate) fn copy_from_slice_zero_fill_noownerchecks<A: ToAddr, B: ToAddr>(
     dst_addr: A,
     src_offset: usize,
     len: B,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let range = MemoryRange::new(dst_addr, len)?;
 
     let src_end = src_offset.saturating_add(range.len()).min(src.len());
diff --git a/fuel-vm/src/interpreter/memory/allocation_tests.rs b/fuel-vm/src/interpreter/memory/allocation_tests.rs
index 4c09eac31..72d6c59bd 100644
--- a/fuel-vm/src/interpreter/memory/allocation_tests.rs
+++ b/fuel-vm/src/interpreter/memory/allocation_tests.rs
@@ -1,16 +1,20 @@
+use alloc::vec;
+
 use super::*;
 use test_case::test_case;
 
+use crate::error::PanicOrBug;
+
 #[test_case(0, 0, 0 => Ok(0))]
-#[test_case(0, 0, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Underflow")]
-#[test_case(10, 0, 11 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Underflow more")]
-#[test_case(12, 10, 3 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Into stack")]
+#[test_case(0, 0, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Underflow")]
+#[test_case(10, 0, 11 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Underflow more")]
+#[test_case(12, 10, 3 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Into stack")]
 #[test_case(10, 10, 0 => Ok(10); "No available memory")]
-#[test_case(15, 10, 6 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Insufficient memory")]
+#[test_case(15, 10, 6 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Insufficient memory")]
 #[test_case(20, 10, 0 => Ok(20); "Zero allocation size")]
 #[test_case(20, 10, 10 => Ok(10); "Allocation size equal to available memory")]
 #[test_case(20, 10, 5 => Ok(15); "Allocation size smaller than available memory")]
-fn test_malloc(mut hp: Word, sp: Word, a: Word) -> Result<Word, RuntimeError> {
+fn test_malloc(mut hp: Word, sp: Word, a: Word) -> SimpleResult<Word> {
     let mut pc = 4;
     malloc(RegMut::new(&mut hp), Reg::new(&sp), RegMut::new(&mut pc), a)?;
     assert_eq!(pc, 8);
@@ -19,11 +23,11 @@ fn test_malloc(mut hp: Word, sp: Word, a: Word) -> Result<Word, RuntimeError> {
 }
 
 #[test_case(true, 1, 10 => Ok(()); "Can clear some bytes")]
-#[test_case(false, 1, 10 => Err(RuntimeError::Recoverable(PanicReason::MemoryOwnership)); "No ownership")]
+#[test_case(false, 1, 10 => Err(PanicOrBug::Panic(PanicReason::MemoryOwnership)); "No ownership")]
 #[test_case(true, 0, 10 => Ok(()); "Memory range starts at 0")]
 #[test_case(true, MEM_SIZE as Word - 10, 10 => Ok(()); "Memory range ends at last address")]
-#[test_case(true, 1, VM_MAX_RAM + 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Memory range size exceeds limit")]
-fn test_memclear(has_ownership: bool, a: Word, b: Word) -> Result<(), RuntimeError> {
+#[test_case(true, 1, VM_MAX_RAM + 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Memory range size exceeds limit")]
+fn test_memclear(has_ownership: bool, a: Word, b: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
     let mut owner = OwnershipRegisters {
@@ -57,12 +61,7 @@ fn test_memclear(has_ownership: bool, a: Word, b: Word) -> Result<(), RuntimeErr
 #[test_case(true, 14, 20, 10 => Err(PanicReason::MemoryWriteOverlap.into()); "b < ac <= bc")]
 #[test_case(true, 21, 22, 10 => Err(PanicReason::MemoryWriteOverlap.into()); "a <= b < ac")]
 #[test_case(true, 21, 20, 10 => Err(PanicReason::MemoryWriteOverlap.into()); "a < bc <= ac")]
-fn test_memcopy(
-    has_ownership: bool,
-    a: Word,
-    b: Word,
-    c: Word,
-) -> Result<(), RuntimeError> {
+fn test_memcopy(has_ownership: bool, a: Word, b: Word, c: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[b as usize..b as usize + c as usize].copy_from_slice(&vec![2u8; c as usize]);
     let mut pc = 4;
@@ -90,14 +89,14 @@ fn test_memcopy(
 }
 
 #[test_case(1, 20, 10 => Ok(()); "Can compare some bytes")]
-#[test_case(MEM_SIZE as Word, 1, 2 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "b+d > MAX_RAM")]
-#[test_case(1, MEM_SIZE as Word, 2 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "c+d > MAX_RAM")]
-#[test_case(1, 1, VM_MAX_RAM + 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "d > VM_MAX_RAM")]
-#[test_case(u64::MAX/2, 1, u64::MAX/2 + 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "b+d overflows")]
-#[test_case(1, u64::MAX/2, u64::MAX/2 + 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "c+d overflows")]
+#[test_case(MEM_SIZE as Word, 1, 2 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "b+d > MAX_RAM")]
+#[test_case(1, MEM_SIZE as Word, 2 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "c+d > MAX_RAM")]
+#[test_case(1, 1, VM_MAX_RAM + 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "d > VM_MAX_RAM")]
+#[test_case(u64::MAX/2, 1, u64::MAX/2 + 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "b+d overflows")]
+#[test_case(1, u64::MAX/2, u64::MAX/2 + 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "c+d overflows")]
 #[test_case(0, 0, 0 => Ok(()); "smallest input values")]
 #[test_case(0, VM_MAX_RAM/2, VM_MAX_RAM/2 => Ok(()); "maximum range of addressable memory")]
-fn test_memeq(b: Word, c: Word, d: Word) -> Result<(), RuntimeError> {
+fn test_memeq(b: Word, c: Word, d: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let r = (b as usize).min(MEM_SIZE)
         ..((b as usize).min(MEM_SIZE) + (d as usize).min(MEM_SIZE)).min(MEM_SIZE);
@@ -118,18 +117,18 @@ fn test_memeq(b: Word, c: Word, d: Word) -> Result<(), RuntimeError> {
 
 #[test_case(true, 20, 0, 40, 10 => Ok(()); "Can move sp up")]
 #[test_case(false, 20, 0, 40, 10 => Ok(()); "Can move sp down")]
-#[test_case(true, u64::MAX - 10, 0, u64::MAX, 20 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Panics on overflowing addition")]
-#[test_case(false, 10, 0, 11, 20 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Panics on underflowing subtraction")]
-#[test_case(true, u64::MAX, 0, u64::MAX, 0 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Panics on equality check for overflowing addition")]
-#[test_case(false, 0, 0, u64::MAX, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Panics on zero check for underflowing subtraction")]
-#[test_case(false, 8, 8, u64::MAX, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Panics on sp < ssp")]
+#[test_case(true, u64::MAX - 10, 0, u64::MAX, 20 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Panics on overflowing addition")]
+#[test_case(false, 10, 0, 11, 20 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Panics on underflowing subtraction")]
+#[test_case(true, u64::MAX, 0, u64::MAX, 0 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Panics on equality check for overflowing addition")]
+#[test_case(false, 0, 0, u64::MAX, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Panics on zero check for underflowing subtraction")]
+#[test_case(false, 8, 8, u64::MAX, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Panics on sp < ssp")]
 fn test_stack_pointer_overflow(
     add: bool,
     mut sp: Word,
     ssp: Word,
     hp: Word,
     v: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let mut pc = 4;
     let old_sp = sp;
 
@@ -157,12 +156,12 @@ fn test_stack_pointer_overflow(
 
 #[test_case(20, 20 => Ok(()); "Can load a byte")]
 #[test_case(0, 0 => Ok(()); "handles memory loading at address 0")]
-#[test_case(VM_MAX_RAM + 1, 0 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "b > VM_MAX_RAM")]
+#[test_case(VM_MAX_RAM + 1, 0 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "b > VM_MAX_RAM")]
 #[test_case(VM_MAX_RAM - 1, 0 => Ok(()); "b eq VM_MAX_RAM - 1")]
-#[test_case(0, VM_MAX_RAM + 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "c > VM_MAX_RAM")]
+#[test_case(0, VM_MAX_RAM + 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "c > VM_MAX_RAM")]
 #[test_case(0, VM_MAX_RAM - 1 => Ok(()); "c eq VM_MAX_RAM - 1")]
-#[test_case(u32::MAX as u64, u32::MAX as u64 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "b + c overflow")]
-fn test_load_byte(b: Word, c: Word) -> Result<(), RuntimeError> {
+#[test_case(u32::MAX as u64, u32::MAX as u64 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "b + c overflow")]
+fn test_load_byte(b: Word, c: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     memory[((b + c) as usize).min(MEM_SIZE - 1)] = 2;
     let mut pc = 4;
@@ -177,8 +176,8 @@ fn test_load_byte(b: Word, c: Word) -> Result<(), RuntimeError> {
 }
 
 #[test_case(20, 20 => Ok(()); "Can load a word")]
-#[test_case(VM_MAX_RAM, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "b + 8 * c gteq VM_MAX_RAM")]
-fn test_load_word(b: Word, c: Word) -> Result<(), RuntimeError> {
+#[test_case(VM_MAX_RAM, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "b + 8 * c gteq VM_MAX_RAM")]
+fn test_load_word(b: Word, c: Word) -> SimpleResult<()> {
     // create a mutable memory with size `MEM_SIZE`
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
 
@@ -207,15 +206,10 @@ fn test_load_word(b: Word, c: Word) -> Result<(), RuntimeError> {
 }
 
 #[test_case(true, 20, 30, 40 => Ok(()); "Can store a byte")]
-#[test_case(false, VM_MAX_RAM - 1, 100, 2 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Memory overflow on heap")]
-#[test_case(false, 0, 100, VM_MAX_RAM - 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOwnership)); "Memory overflow on stack")]
-#[test_case(true, VM_MAX_RAM, 1, 1 => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Memory overflow by address range")]
-fn test_store_byte(
-    has_ownership: bool,
-    a: Word,
-    b: Word,
-    c: Word,
-) -> Result<(), RuntimeError> {
+#[test_case(false, VM_MAX_RAM - 1, 100, 2 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Memory overflow on heap")]
+#[test_case(false, 0, 100, VM_MAX_RAM - 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOwnership)); "Memory overflow on stack")]
+#[test_case(true, VM_MAX_RAM, 1, 1 => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Memory overflow by address range")]
+fn test_store_byte(has_ownership: bool, a: Word, b: Word, c: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
     let mut owner = OwnershipRegisters {
@@ -245,7 +239,7 @@ fn test_store_byte_more(
     #[values(0, 1, VM_MAX_RAM - 1, VM_MAX_RAM)] a: Word,
     #[values(0, 1, 0xff, 0x100)] b: Word,
     #[values(0, 1, 2)] c: Word,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
 
@@ -268,7 +262,7 @@ fn test_store_byte_more(
         }
         Err(e) => {
             assert!(is_error);
-            assert_eq!(e, RuntimeError::Recoverable(PanicReason::MemoryOverflow));
+            assert_eq!(e, PanicOrBug::Panic(PanicReason::MemoryOverflow));
         }
     }
 
@@ -276,14 +270,9 @@ fn test_store_byte_more(
 }
 
 #[test_case(true, 20, 30, 40 => Ok(()); "Can store a word")]
-#[test_case(true, 20, 30, VM_MAX_RAM => Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow)); "Fails due to memory overflow")]
-#[test_case(false, 20, 30, 40 => Err(RuntimeError::Recoverable(PanicReason::MemoryOwnership)); "Fails due to not having ownership of the range")]
-fn test_store_word(
-    has_ownership: bool,
-    a: Word,
-    b: Word,
-    c: Word,
-) -> Result<(), RuntimeError> {
+#[test_case(true, 20, 30, VM_MAX_RAM => Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)); "Fails due to memory overflow")]
+#[test_case(false, 20, 30, 40 => Err(PanicOrBug::Panic(PanicReason::MemoryOwnership)); "Fails due to not having ownership of the range")]
+fn test_store_word(has_ownership: bool, a: Word, b: Word, c: Word) -> SimpleResult<()> {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 4;
     let mut owner = OwnershipRegisters {
diff --git a/fuel-vm/src/interpreter/memory/stack_tests.rs b/fuel-vm/src/interpreter/memory/stack_tests.rs
index efd7c317a..3559983b0 100644
--- a/fuel-vm/src/interpreter/memory/stack_tests.rs
+++ b/fuel-vm/src/interpreter/memory/stack_tests.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use fuel_asm::{
     Imm24,
     PanicReason,
@@ -6,12 +8,12 @@ use fuel_asm::{
 use crate::{
     constraints::reg_key::*,
     consts::*,
+    error::PanicOrBug,
     interpreter::memory::{
         pop_selected_registers,
         push_selected_registers,
         Memory,
     },
-    prelude::RuntimeError,
 };
 
 #[rstest::rstest]
@@ -29,7 +31,7 @@ fn test_push_pop(
         Imm24::MAX.into(),
     )]
     bitmask: u32,
-) -> Result<(), RuntimeError> {
+) {
     let mut memory: Memory<MEM_SIZE> = vec![1u8; MEM_SIZE].try_into().unwrap();
     let mut pc = 0;
     let mut sp = 0;
@@ -85,8 +87,6 @@ fn test_push_pop(
             .count() as u64,
         popcnt
     );
-
-    Ok(())
 }
 
 #[test]
@@ -110,10 +110,7 @@ fn test_push_stack_overflow() {
         Imm24::new(1),
     );
 
-    assert_eq!(
-        result,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(result, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 }
 
 #[test]
@@ -137,10 +134,7 @@ fn test_pop_from_empty_stack() {
         Imm24::new(0b111),
     );
 
-    assert_eq!(
-        result,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(result, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 }
 
 #[test]
@@ -164,8 +158,5 @@ fn test_pop_sp_overflow() {
         Imm24::new(0b111),
     );
 
-    assert_eq!(
-        result,
-        Err(RuntimeError::Recoverable(PanicReason::MemoryOverflow))
-    );
+    assert_eq!(result, Err(PanicOrBug::Panic(PanicReason::MemoryOverflow)));
 }
diff --git a/fuel-vm/src/interpreter/memory/tests.rs b/fuel-vm/src/interpreter/memory/tests.rs
index 482abb31c..a6f5784ed 100644
--- a/fuel-vm/src/interpreter/memory/tests.rs
+++ b/fuel-vm/src/interpreter/memory/tests.rs
@@ -1,4 +1,5 @@
-use std::ops::Range;
+use alloc::vec;
+use core::ops::Range;
 
 use super::*;
 use crate::{
@@ -9,6 +10,7 @@ use fuel_asm::op;
 use fuel_tx::ConsensusParameters;
 use test_case::test_case;
 
+#[cfg(feature = "random")]
 #[test]
 fn memcopy() {
     let tx_params = TxParameters::default().with_max_gas_per_tx(Word::MAX / 2);
diff --git a/fuel-vm/src/interpreter/metadata.rs b/fuel-vm/src/interpreter/metadata.rs
index 49a245e1a..debf1d400 100644
--- a/fuel-vm/src/interpreter/metadata.rs
+++ b/fuel-vm/src/interpreter/metadata.rs
@@ -8,7 +8,7 @@ use crate::{
     constraints::reg_key::*,
     consts::*,
     context::Context,
-    error::RuntimeError,
+    error::SimpleResult,
 };
 
 use fuel_asm::{
@@ -52,7 +52,7 @@ where
         &mut self,
         ra: RegisterId,
         imm: Immediate18,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let chain_id = self.chain_id();
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
@@ -64,7 +64,7 @@ where
         ra: RegisterId,
         b: Word,
         imm: Immediate12,
-    ) -> Result<(), RuntimeError> {
+    ) -> SimpleResult<()> {
         let tx_offset = self.tx_offset();
         let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
         let result = &mut w[WriteRegKey::try_from(ra)?];
@@ -84,7 +84,7 @@ pub(crate) fn metadata(
     result: &mut Word,
     imm: Immediate18,
     chain_id: ChainId,
-) -> Result<(), RuntimeError> {
+) -> SimpleResult<()> {
     let external = context.is_external();
     let args = GMArgs::try_from(imm)?;
 
@@ -125,7 +125,8 @@ pub(crate) fn metadata(
         }
     }
 
-    inc_pc(pc)
+    inc_pc(pc)?;
+    Ok(())
 }
 
 struct GTFInput<'vm, Tx> {
@@ -140,7 +141,7 @@ impl<Tx> GTFInput<'_, Tx> {
         result: &mut Word,
         b: Word,
         imm: Immediate12,
-    ) -> Result<(), RuntimeError>
+    ) -> SimpleResult<()>
     where
         Tx: ExecutableTransaction,
     {
@@ -590,6 +591,7 @@ impl<Tx> GTFInput<'_, Tx> {
 
         *result = a;
 
-        inc_pc(self.pc)
+        inc_pc(self.pc)?;
+        Ok(())
     }
 }
diff --git a/fuel-vm/src/interpreter/metadata/tests.rs b/fuel-vm/src/interpreter/metadata/tests.rs
index b7fec3ab3..6a9920367 100644
--- a/fuel-vm/src/interpreter/metadata/tests.rs
+++ b/fuel-vm/src/interpreter/metadata/tests.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use fuel_tx::Script;
 use fuel_types::BlockHeight;
 use test_case::test_case;
diff --git a/fuel-vm/src/interpreter/post_execution.rs b/fuel-vm/src/interpreter/post_execution.rs
index c27c56fab..db103bdc3 100644
--- a/fuel-vm/src/interpreter/post_execution.rs
+++ b/fuel-vm/src/interpreter/post_execution.rs
@@ -1,4 +1,6 @@
 use crate::prelude::{
+    Bug,
+    BugVariant,
     ExecutableTransaction,
     Interpreter,
     InterpreterStorage,
@@ -14,7 +16,6 @@ use fuel_types::{
     AssetId,
     Word,
 };
-use std::io;
 
 impl<S, T> Interpreter<S, T>
 where
@@ -40,15 +41,19 @@ where
         remaining_gas: Word,
         initial_balances: &InitialBalances,
         balances: &RuntimeBalances,
-    ) -> Result<(), RuntimeError>
+    ) -> Result<(), RuntimeError<S::DataError>>
     where
         Tx: ExecutableTransaction,
     {
-        tx.update_outputs(revert, remaining_gas, initial_balances, balances, fee_params, base_asset_id)
-            .map_err(|e| io::Error::new(
-                io::ErrorKind::Other,
-                format!("a valid VM execution shouldn't result in a state where it can't compute its refund. This is a bug! {e}")
-            ))?;
+        tx.update_outputs(
+            revert,
+            remaining_gas,
+            initial_balances,
+            balances,
+            fee_params,
+            base_asset_id,
+        )
+        .map_err(|e| Bug::new(BugVariant::UncomputableRefund).with_message(e))?;
 
         Ok(())
     }
diff --git a/fuel-vm/src/interpreter/receipts.rs b/fuel-vm/src/interpreter/receipts.rs
index d4c462f57..07253926a 100644
--- a/fuel-vm/src/interpreter/receipts.rs
+++ b/fuel-vm/src/interpreter/receipts.rs
@@ -1,5 +1,8 @@
-use core::ops::Index;
-use std::mem;
+use alloc::vec::Vec;
+use core::{
+    mem,
+    ops::Index,
+};
 
 use fuel_merkle::binary;
 use fuel_tx::Receipt;
@@ -122,9 +125,11 @@ mod tests {
         crypto::ephemeral_merkle_root,
         interpreter::receipts::ReceiptsCtx,
     };
+    use core::iter;
     use fuel_tx::Receipt;
     use fuel_types::canonical::SerializedSize;
-    use std::iter;
+
+    use alloc::vec::Vec;
 
     fn create_receipt() -> Receipt {
         Receipt::call(
diff --git a/fuel-vm/src/lib.rs b/fuel-vm/src/lib.rs
index e0f76bd97..5f9dda13d 100644
--- a/fuel-vm/src/lib.rs
+++ b/fuel-vm/src/lib.rs
@@ -1,10 +1,18 @@
 //! FuelVM implementation
 
+#![cfg_attr(not(feature = "std"), no_std)]
 #![warn(missing_docs)]
 #![deny(unsafe_code)]
+#![deny(unused_must_use)]
 #![deny(unused_crate_dependencies)]
 #![deny(clippy::string_slice)]
 
+#[doc(hidden)] // Needed by some of the exported macros
+pub extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate libm as _; // Not needed with stdlib
+
 pub mod arith;
 pub mod backtrace;
 pub mod call;
@@ -116,9 +124,7 @@ pub mod prelude {
         context::Context,
         error::{
             Bug,
-            BugId,
             BugVariant,
-            Infallible,
             InterpreterError,
             RuntimeError,
         },
@@ -157,7 +163,11 @@ pub mod prelude {
         IntoChecked,
     };
 
-    #[cfg(all(feature = "profile-gas", any(test, feature = "test-helpers")))]
+    #[cfg(all(
+        feature = "profile-gas",
+        feature = "std",
+        any(test, feature = "test-helpers")
+    ))]
     pub use crate::util::gas_profiling::GasProfiler;
 
     pub use crate::profiler::Profiler;
diff --git a/fuel-vm/src/predicate.rs b/fuel-vm/src/predicate.rs
index 144b18b12..2fb6be7d3 100644
--- a/fuel-vm/src/predicate.rs
+++ b/fuel-vm/src/predicate.rs
@@ -40,19 +40,29 @@ impl RuntimePredicate {
     }
 }
 
+#[cfg(test)]
 #[test]
 fn from_tx_works() {
+    use alloc::{
+        vec,
+        vec::Vec,
+    };
     use fuel_asm::op;
     use fuel_tx::TransactionBuilder;
     use fuel_types::bytes;
-    use fuel_vm::prelude::*;
     use rand::{
         rngs::StdRng,
         Rng,
         SeedableRng,
     };
 
-    use std::iter;
+    use core::iter;
+
+    use crate::{
+        interpreter::InterpreterParams,
+        prelude::*,
+        storage::PredicateStorage,
+    };
 
     let rng = &mut StdRng::seed_from_u64(2322u64);
 
@@ -123,11 +133,12 @@ fn from_tx_works() {
 
         assert_eq!(idx, runtime.idx());
 
-        let mut interpreter = Interpreter::without_storage();
+        let mut interpreter =
+            Interpreter::with_storage(PredicateStorage, InterpreterParams::default());
 
         assert!(interpreter
             .init_predicate(
-                fuel_vm::context::Context::PredicateVerification {
+                Context::PredicateVerification {
                     program: Default::default()
                 },
                 tx.transaction().clone(),
diff --git a/fuel-vm/src/profiler.rs b/fuel-vm/src/profiler.rs
index 4ffd69f9b..7f13e93a1 100644
--- a/fuel-vm/src/profiler.rs
+++ b/fuel-vm/src/profiler.rs
@@ -1,9 +1,16 @@
 //! Profiler, can be used to export profiling data from VM runs
 
-use std::{
-    collections::HashMap,
-    fmt,
+use alloc::{
+    boxed::Box,
+    format,
+    string::{
+        String,
+        ToString,
+    },
+    vec::Vec,
 };
+use core::fmt;
+use hashbrown::HashMap;
 
 use dyn_clone::DynClone;
 
@@ -42,7 +49,7 @@ impl<'de> serde::de::Visitor<'de> for InstructionLocationVisitor {
     where
         E: serde::de::Error,
     {
-        use std::str::FromStr;
+        use core::str::FromStr;
 
         Ok(if let Some((l, r)) = value.split_once(':') {
             let context = Some(ContractId::from_str(l).map_err(|_| {
@@ -109,9 +116,7 @@ impl fmt::Display for InstructionLocation {
 type PerLocation<T> = HashMap<InstructionLocation, T>;
 
 /// Iterates through location (key, value) pairs
-pub struct PerLocationIter<'a, T>(
-    std::collections::hash_map::Iter<'a, InstructionLocation, T>,
-);
+pub struct PerLocationIter<'a, T>(hashbrown::hash_map::Iter<'a, InstructionLocation, T>);
 impl<'a, T> Iterator for PerLocationIter<'a, T> {
     type Item = (&'a InstructionLocation, &'a T);
 
@@ -121,9 +126,7 @@ impl<'a, T> Iterator for PerLocationIter<'a, T> {
 }
 
 /// Iterates through location keys
-pub struct PerLocationKeys<'a, T>(
-    std::collections::hash_map::Keys<'a, InstructionLocation, T>,
-);
+pub struct PerLocationKeys<'a, T>(hashbrown::hash_map::Keys<'a, InstructionLocation, T>);
 impl<'a, T> Iterator for PerLocationKeys<'a, T> {
     type Item = &'a InstructionLocation;
 
@@ -134,7 +137,7 @@ impl<'a, T> Iterator for PerLocationKeys<'a, T> {
 
 /// Iterates through location values
 pub struct PerLocationValues<'a, T>(
-    std::collections::hash_map::Values<'a, InstructionLocation, T>,
+    hashbrown::hash_map::Values<'a, InstructionLocation, T>,
 );
 impl<'a, T> Iterator for PerLocationValues<'a, T> {
     type Item = &'a T;
@@ -149,7 +152,7 @@ pub trait ProfileReceiver: DynClone {
     /// Called after a transaction has completed
     fn on_transaction(
         &mut self,
-        state: &Result<ProgramState, InterpreterError>,
+        state: Result<&ProgramState, InterpreterError<String>>,
         data: &ProfilingData,
     );
 }
@@ -161,11 +164,13 @@ dyn_clone::clone_trait_object!(ProfileReceiver);
 pub struct StderrReceiver;
 
 impl ProfileReceiver for StderrReceiver {
+    #[cfg_attr(not(feature = "std"), allow(unused_variables))]
     fn on_transaction(
         &mut self,
-        state: &Result<ProgramState, InterpreterError>,
+        state: Result<&ProgramState, InterpreterError<String>>,
         data: &ProfilingData,
     ) {
+        #[cfg(feature = "std")]
         eprintln!("PROFILER: {state:?} {data:?}");
     }
 }
@@ -183,7 +188,7 @@ impl Profiler {
     /// Called by the VM after a transaction, send collected data to receiver
     pub fn on_transaction(
         &mut self,
-        state_result: &Result<ProgramState, InterpreterError>,
+        state_result: Result<&ProgramState, InterpreterError<String>>,
     ) {
         if let Some(r) = &mut self.receiver {
             r.on_transaction(state_result, &self.data);
diff --git a/fuel-vm/src/state.rs b/fuel-vm/src/state.rs
index 747ad1da9..0fa840670 100644
--- a/fuel-vm/src/state.rs
+++ b/fuel-vm/src/state.rs
@@ -1,5 +1,7 @@
 //! Runtime state representation for the VM
 
+use alloc::vec::Vec;
+
 use fuel_tx::Receipt;
 use fuel_types::{
     Bytes32,
diff --git a/fuel-vm/src/state/debugger.rs b/fuel-vm/src/state/debugger.rs
index ca9289255..46419d878 100644
--- a/fuel-vm/src/state/debugger.rs
+++ b/fuel-vm/src/state/debugger.rs
@@ -9,7 +9,7 @@ use fuel_types::{
     Word,
 };
 
-use std::collections::{
+use hashbrown::{
     HashMap,
     HashSet,
 };
diff --git a/fuel-vm/src/storage.rs b/fuel-vm/src/storage.rs
index a7dffe843..f017e8c82 100644
--- a/fuel-vm/src/storage.rs
+++ b/fuel-vm/src/storage.rs
@@ -12,7 +12,7 @@ use fuel_types::{
 
 mod interpreter;
 mod memory;
-mod predicate;
+pub(crate) mod predicate;
 
 pub use interpreter::{
     ContractsAssetsStorage,
diff --git a/fuel-vm/src/storage/interpreter.rs b/fuel-vm/src/storage/interpreter.rs
index 9e90addec..948110388 100644
--- a/fuel-vm/src/storage/interpreter.rs
+++ b/fuel-vm/src/storage/interpreter.rs
@@ -22,20 +22,25 @@ use fuel_types::{
     Word,
 };
 
-use crate::storage::{
-    ContractsAssets,
-    ContractsInfo,
-    ContractsRawCode,
-    ContractsState,
+use crate::{
+    prelude::{
+        InterpreterError,
+        RuntimeError,
+    },
+    storage::{
+        ContractsAssets,
+        ContractsInfo,
+        ContractsRawCode,
+        ContractsState,
+    },
 };
-use std::{
+use alloc::{
     borrow::Cow,
-    error::Error as StdError,
-    io,
-    ops::{
-        Deref,
-        DerefMut,
-    },
+    vec::Vec,
+};
+use core::ops::{
+    Deref,
+    DerefMut,
 };
 
 /// When this trait is implemented, the underlying interpreter is guaranteed to
@@ -49,7 +54,9 @@ pub trait InterpreterStorage:
     + ContractsAssetsStorage<Error = Self::DataError>
 {
     /// Error implementation for reasons unspecified in the protocol.
-    type DataError: StdError + Into<io::Error>;
+    type DataError: Into<InterpreterError<Self::DataError>>
+        + Into<RuntimeError<Self::DataError>>
+        + core::fmt::Debug;
 
     /// Provide the current block height in which the transactions should be
     /// executed.
@@ -244,7 +251,7 @@ impl<S> InterpreterStorage for &mut S
 where
     S: InterpreterStorage,
 {
-    type DataError = S::DataError;
+    type DataError = <S as InterpreterStorage>::DataError;
 
     fn block_height(&self) -> Result<BlockHeight, Self::DataError> {
         <S as InterpreterStorage>::block_height(self.deref())
diff --git a/fuel-vm/src/storage/memory.rs b/fuel-vm/src/storage/memory.rs
index 3eb3bfe9a..930a7a5fc 100644
--- a/fuel-vm/src/storage/memory.rs
+++ b/fuel-vm/src/storage/memory.rs
@@ -1,6 +1,5 @@
 use crate::{
     crypto,
-    error::Infallible,
     storage::{
         ContractsAssetKey,
         ContractsAssets,
@@ -36,11 +35,12 @@ use fuel_types::{
 use itertools::Itertools;
 use tai64::Tai64;
 
-use std::{
+use alloc::{
     borrow::Cow,
     collections::BTreeMap,
-    io::Read,
+    vec::Vec,
 };
+use core::convert::Infallible;
 
 use super::interpreter::ContractsAssetsStorage;
 
@@ -205,11 +205,11 @@ impl StorageRead<ContractsRawCode> for MemoryStorage {
         key: &ContractId,
         buf: &mut [u8],
     ) -> Result<Option<usize>, Self::Error> {
-        Ok(self
-            .memory
-            .contracts
-            .get(key)
-            .and_then(|c| c.as_ref().read(buf).ok()))
+        Ok(self.memory.contracts.get(key).map(|c| {
+            let len = buf.len().min(c.as_ref().len());
+            buf.copy_from_slice(&c.as_ref()[..len]);
+            len
+        }))
     }
 
     fn read_alloc(&self, key: &ContractId) -> Result<Option<Vec<u8>>, Self::Error> {
@@ -387,7 +387,7 @@ impl InterpreterStorage for MemoryStorage {
         let mut iter = self.memory.contract_state.range(start..end);
 
         let mut next_item = iter.next();
-        Ok(std::iter::successors(Some(**start_key), |n| {
+        Ok(core::iter::successors(Some(**start_key), |n| {
             let mut n = *n;
             if add_one(&mut n) {
                 None
@@ -397,15 +397,15 @@ impl InterpreterStorage for MemoryStorage {
         })
         .map(|next_key: [u8; 32]| match next_item.take() {
             Some((k, v)) => match next_key.cmp(k.state_key()) {
-                std::cmp::Ordering::Less => {
+                core::cmp::Ordering::Less => {
                     next_item = Some((k, v));
                     None
                 }
-                std::cmp::Ordering::Equal => {
+                core::cmp::Ordering::Equal => {
                     next_item = iter.next();
                     Some(Cow::Borrowed(v))
                 }
-                std::cmp::Ordering::Greater => None,
+                core::cmp::Ordering::Greater => None,
             },
             None => None,
         })
@@ -420,7 +420,7 @@ impl InterpreterStorage for MemoryStorage {
         values: &[Bytes32],
     ) -> Result<Option<()>, Self::DataError> {
         let mut any_unset_key = false;
-        let values: Vec<_> = std::iter::successors(Some(**start_key), |n| {
+        let values: Vec<_> = core::iter::successors(Some(**start_key), |n| {
             let mut n = *n;
             if add_one(&mut n) {
                 None
@@ -446,8 +446,8 @@ impl InterpreterStorage for MemoryStorage {
         range: Word,
     ) -> Result<Option<()>, Self::DataError> {
         let mut all_set_key = true;
-        let mut values: std::collections::HashSet<_> =
-            std::iter::successors(Some(**start_key), |n| {
+        let mut values: hashbrown::HashSet<_> =
+            core::iter::successors(Some(**start_key), |n| {
                 let mut n = *n;
                 if add_one(&mut n) {
                     None
@@ -484,6 +484,7 @@ fn add_one(a: &mut [u8; 32]) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::vec;
     use test_case::test_case;
 
     const fn key(k: u8) -> [u8; 32] {
diff --git a/fuel-vm/src/storage/predicate.rs b/fuel-vm/src/storage/predicate.rs
index 98dac034f..350647232 100644
--- a/fuel-vm/src/storage/predicate.rs
+++ b/fuel-vm/src/storage/predicate.rs
@@ -1,7 +1,13 @@
-use std::borrow::Cow;
+use alloc::{
+    borrow::Cow,
+    vec::Vec,
+};
 
 use crate::{
-    error::InterpreterError,
+    prelude::{
+        InterpreterError,
+        RuntimeError,
+    },
     storage::InterpreterStorage,
 };
 
@@ -36,18 +42,35 @@ use super::{
 #[derive(Debug, Default, Clone, Copy)]
 pub struct PredicateStorage;
 
+/// Storage is unavailable in predicate context.
+#[derive(Debug, Clone, Copy)]
+pub struct StorageUnavailable;
+
+impl From<StorageUnavailable> for InterpreterError<StorageUnavailable> {
+    fn from(val: StorageUnavailable) -> Self {
+        let rt: RuntimeError<StorageUnavailable> = val.into();
+        rt.into()
+    }
+}
+
+impl From<StorageUnavailable> for RuntimeError<StorageUnavailable> {
+    fn from(val: StorageUnavailable) -> Self {
+        RuntimeError::Storage(val)
+    }
+}
+
 impl<Type: Mappable> StorageInspect<Type> for PredicateStorage {
-    type Error = InterpreterError;
+    type Error = StorageUnavailable;
 
     fn get(
         &self,
         _key: &Type::Key,
-    ) -> Result<Option<Cow<'_, Type::OwnedValue>>, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<Cow<'_, Type::OwnedValue>>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
-    fn contains_key(&self, _key: &Type::Key) -> Result<bool, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    fn contains_key(&self, _key: &Type::Key) -> Result<bool, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
 
@@ -56,15 +79,15 @@ impl<Type: Mappable> StorageMutate<Type> for PredicateStorage {
         &mut self,
         _key: &Type::Key,
         _value: &Type::Value,
-    ) -> Result<Option<Type::OwnedValue>, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<Type::OwnedValue>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn remove(
         &mut self,
         _key: &Type::Key,
-    ) -> Result<Option<Type::OwnedValue>, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<Type::OwnedValue>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
 
@@ -72,8 +95,8 @@ impl StorageSize<ContractsRawCode> for PredicateStorage {
     fn size_of_value(
         &self,
         _key: &ContractId,
-    ) -> Result<Option<usize>, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<usize>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
 
@@ -82,46 +105,46 @@ impl StorageRead<ContractsRawCode> for PredicateStorage {
         &self,
         _key: &<ContractsRawCode as Mappable>::Key,
         _buf: &mut [u8],
-    ) -> Result<Option<usize>, Self::Error> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<usize>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn read_alloc(
         &self,
         _key: &<ContractsRawCode as Mappable>::Key,
-    ) -> Result<Option<Vec<u8>>, Self::Error> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<Vec<u8>>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
 
 impl<Key, Type: Mappable> MerkleRootStorage<Key, Type> for PredicateStorage {
-    fn root(&self, _parent: &Key) -> Result<MerkleRoot, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    fn root(&self, _parent: &Key) -> Result<MerkleRoot, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
 
 impl ContractsAssetsStorage for PredicateStorage {}
 
 impl InterpreterStorage for PredicateStorage {
-    type DataError = InterpreterError;
+    type DataError = StorageUnavailable;
 
-    fn block_height(&self) -> Result<BlockHeight, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    fn block_height(&self) -> Result<BlockHeight, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
-    fn timestamp(&self, _height: BlockHeight) -> Result<Word, Self::DataError> {
-        Err(InterpreterError::PredicateFailure)
+    fn timestamp(&self, _height: BlockHeight) -> Result<Word, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn block_hash(
         &self,
         _block_height: BlockHeight,
-    ) -> Result<Bytes32, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Bytes32, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
-    fn coinbase(&self) -> Result<Address, InterpreterError> {
-        Err(InterpreterError::PredicateFailure)
+    fn coinbase(&self) -> Result<Address, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn merkle_contract_state_range(
@@ -129,8 +152,8 @@ impl InterpreterStorage for PredicateStorage {
         _id: &ContractId,
         _start_key: &Bytes32,
         _range: Word,
-    ) -> Result<Vec<Option<Cow<Bytes32>>>, Self::DataError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Vec<Option<Cow<Bytes32>>>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn merkle_contract_state_insert_range(
@@ -138,8 +161,8 @@ impl InterpreterStorage for PredicateStorage {
         _contract: &ContractId,
         _start_key: &Bytes32,
         _values: &[Bytes32],
-    ) -> Result<Option<()>, Self::DataError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<()>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 
     fn merkle_contract_state_remove_range(
@@ -147,7 +170,7 @@ impl InterpreterStorage for PredicateStorage {
         _contract: &ContractId,
         _start_key: &Bytes32,
         _range: Word,
-    ) -> Result<Option<()>, Self::DataError> {
-        Err(InterpreterError::PredicateFailure)
+    ) -> Result<Option<()>, StorageUnavailable> {
+        Err(StorageUnavailable)
     }
 }
diff --git a/fuel-vm/src/tests/alu.rs b/fuel-vm/src/tests/alu.rs
index 28d2165a0..e038490f2 100644
--- a/fuel-vm/src/tests/alu.rs
+++ b/fuel-vm/src/tests/alu.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use crate::prelude::*;
 use fuel_asm::{
     op,
diff --git a/fuel-vm/src/tests/backtrace.rs b/fuel-vm/src/tests/backtrace.rs
index f1cfe2f7d..6108b8011 100644
--- a/fuel-vm/src/tests/backtrace.rs
+++ b/fuel-vm/src/tests/backtrace.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use crate::{
     consts::*,
     prelude::*,
diff --git a/fuel-vm/src/tests/blockchain.rs b/fuel-vm/src/tests/blockchain.rs
index a2b7bc48e..c1cdcc407 100644
--- a/fuel-vm/src/tests/blockchain.rs
+++ b/fuel-vm/src/tests/blockchain.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use fuel_asm::RegId;
 use fuel_crypto::{
     Hasher,
diff --git a/fuel-vm/src/tests/cgas.rs b/fuel-vm/src/tests/cgas.rs
index 69f16443f..eaa288efc 100644
--- a/fuel-vm/src/tests/cgas.rs
+++ b/fuel-vm/src/tests/cgas.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     prelude::*,
     script_with_data_offset,
diff --git a/fuel-vm/src/tests/code_coverage.rs b/fuel-vm/src/tests/code_coverage.rs
index 01f32d992..d0d9fedd5 100644
--- a/fuel-vm/src/tests/code_coverage.rs
+++ b/fuel-vm/src/tests/code_coverage.rs
@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::{
     op,
     RegId,
@@ -66,7 +68,7 @@ fn code_coverage() {
     impl ProfileReceiver for ProfilingOutput {
         fn on_transaction(
             &mut self,
-            _state: &Result<ProgramState, InterpreterError>,
+            _state: Result<&ProgramState, InterpreterError<String>>,
             data: &ProfilingData,
         ) {
             let mut guard = self.data.lock().unwrap();
@@ -101,7 +103,7 @@ fn code_coverage() {
 
     assert_eq!(items.len(), expect.len());
 
-    for (item, expect) in items.into_iter().zip(expect.into_iter()) {
+    for (item, expect) in items.into_iter().zip(expect) {
         assert_eq!(
             *item,
             InstructionLocation::new(None, expect * HALF_WORD_SIZE)
diff --git a/fuel-vm/src/tests/contract.rs b/fuel-vm/src/tests/contract.rs
index 615218928..0a862520f 100644
--- a/fuel-vm/src/tests/contract.rs
+++ b/fuel-vm/src/tests/contract.rs
@@ -3,6 +3,10 @@ use crate::{
     script_with_data_offset,
     util::test_helpers::TestBuilder,
 };
+use alloc::{
+    vec,
+    vec::Vec,
+};
 use fuel_asm::{
     op,
     RegId,
diff --git a/fuel-vm/src/tests/crypto.rs b/fuel-vm/src/tests/crypto.rs
index caaeb5785..70aaf44ba 100644
--- a/fuel-vm/src/tests/crypto.rs
+++ b/fuel-vm/src/tests/crypto.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use fuel_asm::{
     op,
     GTFArgs,
@@ -29,12 +31,15 @@ use sha3::{
 };
 
 use crate::{
-    checked_transaction::CheckPredicateParams,
     prelude::*,
-    tests::predicate::TokioWithRayon,
     util::test_helpers::check_expected_reason_for_instructions,
 };
 
+#[cfg(feature = "std")]
+use crate::checked_transaction::CheckPredicateParams;
+#[cfg(feature = "std")]
+use crate::tests::predicate::TokioWithRayon;
+
 #[test]
 fn secp256k1_recover() {
     let rng = &mut StdRng::seed_from_u64(2322u64);
@@ -151,6 +156,7 @@ fn ecrecover_tx_id() {
     assert!(success);
 }
 
+#[cfg(feature = "std")]
 #[tokio::test]
 async fn recover_tx_id_predicate() {
     use crate::checked_transaction::EstimatePredicates;
diff --git a/fuel-vm/src/tests/encoding.rs b/fuel-vm/src/tests/encoding.rs
index d93c3c90a..254438b34 100644
--- a/fuel-vm/src/tests/encoding.rs
+++ b/fuel-vm/src/tests/encoding.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use fuel_vm::{
     consts::*,
     prelude::*,
@@ -8,6 +13,7 @@ use rand::{
     SeedableRng,
 };
 
+use core::fmt;
 use fuel_types::{
     canonical::{
         Deserialize,
@@ -15,7 +21,6 @@ use fuel_types::{
     },
     Word,
 };
-use std::fmt;
 
 pub fn assert_encoding_correct<T>(data: &[T])
 where
diff --git a/fuel-vm/src/tests/flow.rs b/fuel-vm/src/tests/flow.rs
index fc061ff6c..a52ac5de7 100644
--- a/fuel-vm/src/tests/flow.rs
+++ b/fuel-vm/src/tests/flow.rs
@@ -1,3 +1,9 @@
+use alloc::{
+    borrow::ToOwned,
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     consts::*,
     prelude::*,
diff --git a/fuel-vm/src/tests/gas_factor.rs b/fuel-vm/src/tests/gas_factor.rs
index b47401df3..6c22b8f64 100644
--- a/fuel-vm/src/tests/gas_factor.rs
+++ b/fuel-vm/src/tests/gas_factor.rs
@@ -1,13 +1,15 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::op;
 use fuel_vm::prelude::*;
 
+use core::iter;
 use fuel_tx::{
     field::Outputs,
     ConsensusParameters,
     FeeParameters,
 };
 use fuel_vm::interpreter::InterpreterParams;
-use std::iter;
 
 #[test]
 fn gas_factor_rounds_correctly() {
diff --git a/fuel-vm/src/tests/jump_absolute.rs b/fuel-vm/src/tests/jump_absolute.rs
index 02964f513..96f7f5ab1 100644
--- a/fuel-vm/src/tests/jump_absolute.rs
+++ b/fuel-vm/src/tests/jump_absolute.rs
@@ -1,3 +1,5 @@
+use alloc::vec;
+
 use super::test_helpers::run_script;
 use fuel_asm::{
     op,
diff --git a/fuel-vm/src/tests/jump_relative.rs b/fuel-vm/src/tests/jump_relative.rs
index d80cb033d..6ab484fe9 100644
--- a/fuel-vm/src/tests/jump_relative.rs
+++ b/fuel-vm/src/tests/jump_relative.rs
@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::{
     op,
     Imm18,
diff --git a/fuel-vm/src/tests/log.rs b/fuel-vm/src/tests/log.rs
index 386ab2982..6c5dbad42 100644
--- a/fuel-vm/src/tests/log.rs
+++ b/fuel-vm/src/tests/log.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use super::test_helpers;
 use fuel_asm::*;
 use fuel_tx::Receipt;
diff --git a/fuel-vm/src/tests/memory.rs b/fuel-vm/src/tests/memory.rs
index 20f356b8c..0483560f2 100644
--- a/fuel-vm/src/tests/memory.rs
+++ b/fuel-vm/src/tests/memory.rs
@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::PanicReason;
 use test_case::test_case;
 
diff --git a/fuel-vm/src/tests/metadata.rs b/fuel-vm/src/tests/metadata.rs
index 08d3531bd..c5c993df6 100644
--- a/fuel-vm/src/tests/metadata.rs
+++ b/fuel-vm/src/tests/metadata.rs
@@ -1,3 +1,9 @@
+use alloc::{
+    borrow::ToOwned,
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     consts::*,
     interpreter::InterpreterParams,
diff --git a/fuel-vm/src/tests/mod.rs b/fuel-vm/src/tests/mod.rs
index 9a06f7a00..152aa9dea 100644
--- a/fuel-vm/src/tests/mod.rs
+++ b/fuel-vm/src/tests/mod.rs
@@ -1,3 +1,7 @@
+use futures as _;
+use tokio as _;
+use tokio_rayon as _;
+
 mod test_helpers;
 
 mod alu;
diff --git a/fuel-vm/src/tests/outputs.rs b/fuel-vm/src/tests/outputs.rs
index b0828e6f4..e425ec37d 100644
--- a/fuel-vm/src/tests/outputs.rs
+++ b/fuel-vm/src/tests/outputs.rs
@@ -1,3 +1,9 @@
+use alloc::{
+    borrow::ToOwned,
+    vec,
+    vec::Vec,
+};
+
 use crate::{
     prelude::{
         field::Outputs,
diff --git a/fuel-vm/src/tests/predicate.rs b/fuel-vm/src/tests/predicate.rs
index 8708f1188..499c1015b 100644
--- a/fuel-vm/src/tests/predicate.rs
+++ b/fuel-vm/src/tests/predicate.rs
@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::{
     op,
     GMArgs,
diff --git a/fuel-vm/src/tests/profile_gas.rs b/fuel-vm/src/tests/profile_gas.rs
index 9ad9c4d8c..2d3083786 100644
--- a/fuel-vm/src/tests/profile_gas.rs
+++ b/fuel-vm/src/tests/profile_gas.rs
@@ -1,3 +1,5 @@
+#![cfg(feature = "std")]
+
 use fuel_asm::{
     op,
     RegId,
diff --git a/fuel-vm/src/tests/spec.rs b/fuel-vm/src/tests/spec.rs
index 706dc00df..15dd62ce5 100644
--- a/fuel-vm/src/tests/spec.rs
+++ b/fuel-vm/src/tests/spec.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use fuel_asm::*;
 use fuel_tx::Receipt;
 use fuel_types::Immediate18;
diff --git a/fuel-vm/src/tests/test_helpers.rs b/fuel-vm/src/tests/test_helpers.rs
index 1221dd1d7..a15db2852 100644
--- a/fuel-vm/src/tests/test_helpers.rs
+++ b/fuel-vm/src/tests/test_helpers.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use fuel_asm::{
     op,
     Instruction,
diff --git a/fuel-vm/src/tests/wideint.rs b/fuel-vm/src/tests/wideint.rs
index a9b3be5c7..459425f64 100644
--- a/fuel-vm/src/tests/wideint.rs
+++ b/fuel-vm/src/tests/wideint.rs
@@ -1,3 +1,8 @@
+use alloc::{
+    vec,
+    vec::Vec,
+};
+
 use ethnum::U256;
 
 use fuel_asm::{
diff --git a/fuel-vm/src/transactor.rs b/fuel-vm/src/transactor.rs
index 1124c500a..dd1ca5d3a 100644
--- a/fuel-vm/src/transactor.rs
+++ b/fuel-vm/src/transactor.rs
@@ -36,14 +36,18 @@ use fuel_tx::{
 /// builder`.
 ///
 /// Based on <https://doc.rust-lang.org/1.5.0/style/ownership/builders.html#non-consuming-builders-preferred>
-pub struct Transactor<S, Tx> {
+pub struct Transactor<S, Tx>
+where
+    S: InterpreterStorage,
+{
     interpreter: Interpreter<S, Tx>,
     program_state: Option<ProgramState>,
-    error: Option<InterpreterError>,
+    error: Option<InterpreterError<S::DataError>>,
 }
 
 impl<'a, S, Tx> Transactor<S, Tx>
 where
+    S: InterpreterStorage,
     Tx: ExecutableTransaction,
 {
     /// Transactor constructor
@@ -86,7 +90,7 @@ where
     ///
     /// Will be `None` if the last transaction resulted successful, or if no
     /// transaction was executed.
-    pub const fn error(&self) -> Option<&InterpreterError> {
+    pub const fn error(&self) -> Option<&InterpreterError<S::DataError>> {
         self.error.as_ref()
     }
 
@@ -104,7 +108,9 @@ where
     /// Result representation of the last executed transaction.
     ///
     /// Will return `None` if no transaction was executed.
-    pub fn result(&'a self) -> Result<StateTransitionRef<'a, Tx>, &InterpreterError> {
+    pub fn result(
+        &'a self,
+    ) -> Result<StateTransitionRef<'a, Tx>, &InterpreterError<S::DataError>> {
         let state = self.state_transition();
         let error = self.error.as_ref();
 
@@ -133,7 +139,10 @@ where
     }
 }
 
-impl<S> Transactor<S, Script> {
+impl<S> Transactor<S, Script>
+where
+    S: InterpreterStorage,
+{
     /// Receipts after the execution of a transaction.
     ///
     /// Follows the same criteria as [`Self::state_transition`] to return
@@ -162,7 +171,7 @@ where
     pub fn deploy(
         &mut self,
         checked: Checked<Create>,
-    ) -> Result<Create, InterpreterError> {
+    ) -> Result<Create, InterpreterError<S::DataError>> {
         self.interpreter.deploy(checked)
     }
 }
@@ -193,6 +202,7 @@ where
 impl<S, Tx> From<Interpreter<S, Tx>> for Transactor<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     fn from(interpreter: Interpreter<S, Tx>) -> Self {
         let program_state = None;
@@ -209,6 +219,7 @@ where
 impl<S, Tx> From<Transactor<S, Tx>> for Interpreter<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     fn from(transactor: Transactor<S, Tx>) -> Self {
         transactor.interpreter
@@ -218,6 +229,7 @@ where
 impl<S, Tx> AsRef<Interpreter<S, Tx>> for Transactor<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     fn as_ref(&self) -> &Interpreter<S, Tx> {
         &self.interpreter
@@ -227,6 +239,7 @@ where
 impl<S, Tx> AsRef<S> for Transactor<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     fn as_ref(&self) -> &S {
         self.interpreter.as_ref()
@@ -236,6 +249,7 @@ where
 impl<S, Tx> AsMut<S> for Transactor<S, Tx>
 where
     Tx: ExecutableTransaction,
+    S: InterpreterStorage,
 {
     fn as_mut(&mut self) -> &mut S {
         self.interpreter.as_mut()
@@ -244,7 +258,7 @@ where
 
 impl<S, Tx> Default for Transactor<S, Tx>
 where
-    S: Default,
+    S: InterpreterStorage + Default,
     Tx: ExecutableTransaction,
 {
     fn default() -> Self {
diff --git a/fuel-vm/src/util.rs b/fuel-vm/src/util.rs
index 61c9485ee..1d6a294e2 100644
--- a/fuel-vm/src/util.rs
+++ b/fuel-vm/src/util.rs
@@ -42,6 +42,7 @@
 ///     TxParameters::DEFAULT.tx_offset()
 /// );
 /// ```
+#[cfg(feature = "alloc")]
 #[macro_export]
 macro_rules! script_with_data_offset {
     ($offset:ident, $script:expr, $tx_offset:expr) => {{
@@ -52,8 +53,8 @@ macro_rules! script_with_data_offset {
                 0 as Immediate18
             };
             // evaluate script expression with zeroed data offset to get the script length
-            let script_bytes: ::std::vec::Vec<u8> =
-                ::std::iter::IntoIterator::into_iter({ $script }).collect();
+            let script_bytes: $crate::alloc::vec::Vec<u8> =
+                ::core::iter::IntoIterator::into_iter({ $script }).collect();
             // compute the script data offset within the VM memory given the script length
             {
                 use $crate::{
@@ -76,9 +77,15 @@ macro_rules! script_with_data_offset {
 }
 
 #[allow(missing_docs)]
+#[cfg(feature = "random")]
 #[cfg(any(test, feature = "test-helpers"))]
 /// Testing utilities
 pub mod test_helpers {
+    use alloc::{
+        vec,
+        vec::Vec,
+    };
+
     use crate::{
         checked_transaction::{
             builder::TransactionBuilderExt,
@@ -686,7 +693,11 @@ pub mod test_helpers {
 }
 
 #[allow(missing_docs)]
-#[cfg(all(feature = "profile-gas", any(test, feature = "test-helpers")))]
+#[cfg(all(
+    feature = "profile-gas",
+    feature = "std",
+    any(test, feature = "test-helpers")
+))]
 /// Gas testing utilities
 pub mod gas_profiling {
     use crate::prelude::*;
@@ -712,7 +723,7 @@ pub mod gas_profiling {
     impl ProfileReceiver for GasProfiler {
         fn on_transaction(
             &mut self,
-            _state: &Result<ProgramState, InterpreterError>,
+            _state: Result<&ProgramState, InterpreterError<String>>,
             data: &ProfilingData,
         ) {
             let mut guard = self.data.lock().unwrap();