feat: Use Vec of Bytes for Contract State

CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+#### Breaking
+
+- [#671](https://github.com/FuelLabs/fuel-vm/pull/671): Support dynamically sized Contract state by changing the storage slot data type to a vector of bytes (`Vec<u8>`).  
+
 ## [Version 0.45.0]
 
 ### Changed

fuel-tx/src/contract.rs

@@ -21,10 +21,7 @@ use fuel_types::{
 };
 
 use alloc::vec::Vec;
-use core::{
-    iter,
-    ops::Deref,
-};
+use core::iter;
 
 /// The target size of Merkle tree leaves in bytes. Contract code will will be divided
 /// into chunks of this size and pushed to the Merkle tree.
@@ -105,13 +102,10 @@ impl Contract {
     where
         I: Iterator<Item = &'a StorageSlot>,
     {
-        let root = SparseMerkleTree::root_from_set(storage_slots.map(|slot| {
-            (
-                MerkleTreeKey::new(*slot.key().deref()),
-                *slot.value().deref(),
-            )
-        }));
-
+        let storage_slots = storage_slots
+            .map(|slot| (*slot.key(), slot.value()))
+            .map(|(key, data)| (MerkleTreeKey::new(key), data));
+        let root = SparseMerkleTree::root_from_set(storage_slots);
         root.into()
     }
 
@@ -185,10 +179,8 @@ impl TryFrom<&Transaction> for Contract {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use fuel_types::{
-        bytes::WORD_SIZE,
-        Bytes64,
-    };
+    use crate::StorageData;
+    use fuel_types::bytes::WORD_SIZE;
     use itertools::Itertools;
     use quickcheck_macros::quickcheck;
     use rand::{
@@ -237,9 +229,8 @@ mod tests {
 
     #[rstest]
     fn state_root_snapshot(
-        #[values(Vec::new(), vec![Bytes64::new([1u8; 64])])] state_slot_bytes: Vec<
-            Bytes64,
-        >,
+        #[values(Vec::new(), vec![ (Bytes32::new([1u8; 32]), vec![1u8; 32]) ] )]
+        state_slot_bytes: Vec<(Bytes32, StorageData)>,
     ) {
         let slots: Vec<StorageSlot> =
             state_slot_bytes.iter().map(Into::into).collect_vec();

fuel-tx/src/lib.rs

@@ -90,6 +90,7 @@ pub use transaction::{
     PredicateParameters,
     Script,
     ScriptParameters,
+    StorageData,
     StorageSlot,
     Transaction,
     TransactionFee,

fuel-tx/src/tests/offset.rs

@@ -29,6 +29,7 @@ use rand::{
     Rng,
     SeedableRng,
 };
+use std::mem::size_of;
 
 // Assert everything is tested. If some of these bools fails, just increase the number of
 // cases
@@ -356,11 +357,13 @@ fn tx_offset_create() {
                         .storage_slots_offset_at(idx)
                         .expect("tx with slots contains offsets");
 
-                    let bytes =
-                        Bytes64::from_bytes_ref_checked(&bytes[ofs..ofs + Bytes64::LEN])
-                            .unwrap();
-
-                    let slot_p = StorageSlot::from(bytes);
+                    let key_range = ofs..ofs + Bytes32::LEN;
+                    let key = Bytes32::from_bytes_ref_checked(&bytes[key_range.clone()])
+                        .unwrap();
+                    let value_range_start = key_range.end + size_of::<u64>();
+                    let value_range = value_range_start..value_range_start + Bytes32::LEN;
+                    let value = bytes[value_range].to_vec();
+                    let slot_p = StorageSlot::from(&(*key, value));
 
                     assert_eq!(slot, &slot_p);
                 });

fuel-tx/src/transaction/id.rs

@@ -171,11 +171,12 @@ mod tests {
     }
 
     fn invert_storage_slot(storage_slot: &mut StorageSlot) {
-        let mut data = [0u8; 64];
+        let mut data = [0u8; 64 + 8];
         storage_slot
             .encode(&mut &mut data[..])
             .expect("Failed to encode storage slot");
         invert(&mut data);
+        invert(&mut data[32..40]);
         *storage_slot =
             StorageSlot::from_bytes(&data).expect("Failed to decode storage slot");
     }

fuel-tx/src/transaction/types.rs

@@ -10,7 +10,10 @@ mod witness;
 pub use create::Create;
 pub use mint::Mint;
 pub use script::Script;
-pub use storage::StorageSlot;
+pub use storage::{
+    StorageData,
+    StorageSlot,
+};
 pub use utxo_id::UtxoId;
 pub use witness::Witness;
 

fuel-tx/src/transaction/types/create.rs

@@ -444,7 +444,13 @@ mod field {
 
         fn storage_slots_offset_at(&self, idx: usize) -> Option<usize> {
             if idx < self.storage_slots.len() {
-                Some(self.storage_slots_offset() + idx * StorageSlot::SLOT_SIZE)
+                let storage_slots_size: usize = self
+                    .storage_slots
+                    .iter()
+                    .take(idx)
+                    .map(|slot| slot.size())
+                    .sum();
+                Some(self.storage_slots_offset() + storage_slots_size)
             } else {
                 None
             }
@@ -464,8 +470,9 @@ mod field {
 
         #[inline(always)]
         fn inputs_offset(&self) -> usize {
-            self.storage_slots_offset()
-                + self.storage_slots.len() * StorageSlot::SLOT_SIZE
+            let storage_slots_size: usize =
+                self.storage_slots.iter().map(|slot| slot.size()).sum();
+            self.storage_slots_offset() + storage_slots_size
         }
 
         #[inline(always)]
@@ -636,12 +643,13 @@ mod tests {
     #[test]
     fn storage_slots_sorting() {
         // Test that storage slots must be sorted correctly
-        let mut slot_data = [0u8; 64];
+        let mut slot_data = ([0u8; 32], vec![0u8; 32]);
 
         let storage_slots = (0..10u64)
             .map(|i| {
-                slot_data[..8].copy_from_slice(&i.to_be_bytes());
-                StorageSlot::from(&slot_data.into())
+                slot_data.0[..8].copy_from_slice(&i.to_be_bytes());
+                let (key, value) = slot_data.clone();
+                StorageSlot::from(&(key.into(), value))
             })
             .collect::<Vec<StorageSlot>>();
 
@@ -664,8 +672,8 @@ mod tests {
     #[test]
     fn storage_slots_no_duplicates() {
         let storage_slots = vec![
-            StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
-            StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
+            StorageSlot::new(Bytes32::zeroed(), Default::default()),
+            StorageSlot::new(Bytes32::zeroed(), Default::default()),
         ];
 
         let err = crate::TransactionBuilder::create(

fuel-tx/src/transaction/types/create/ser_de_tests.rs

@@ -1,3 +1,4 @@
+use crate::StorageData;
 use fuel_types::{
     canonical::{
         Deserialize,
@@ -12,8 +13,8 @@ use super::*;
 fn test_create_serialization() {
     let create = Create {
         storage_slots: vec![
-            StorageSlot::new(Bytes32::from([1u8; 32]), Bytes32::from([2u8; 32])),
-            StorageSlot::new(Bytes32::from([3u8; 32]), Bytes32::from([4u8; 32])),
+            StorageSlot::new(Bytes32::from([1u8; 32]), StorageData::from([2u8; 32])),
+            StorageSlot::new(Bytes32::from([3u8; 32]), StorageData::from([4u8; 32])),
         ],
 
         ..Default::default()

fuel-tx/src/transaction/types/storage.rs

@@ -1,10 +1,10 @@
+use alloc::vec::Vec;
 use fuel_types::{
     canonical::{
         Deserialize,
         Serialize,
     },
     Bytes32,
-    Bytes64,
 };
 
 #[cfg(feature = "random")]
@@ -18,49 +18,38 @@ use rand::{
 
 use core::cmp::Ordering;
 
+pub type StorageData = Vec<u8>;
+
 #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
 #[derive(Deserialize, Serialize)]
 pub struct StorageSlot {
     key: Bytes32,
-    value: Bytes32,
+    value: StorageData,
 }
 
 impl StorageSlot {
-    pub const SLOT_SIZE: usize = Bytes32::LEN + Bytes32::LEN;
-
-    pub const fn new(key: Bytes32, value: Bytes32) -> Self {
+    pub const fn new(key: Bytes32, value: StorageData) -> Self {
         StorageSlot { key, value }
     }
 
     pub const fn key(&self) -> &Bytes32 {
         &self.key
     }
 
-    pub const fn value(&self) -> &Bytes32 {
+    pub const fn value(&self) -> &StorageData {
         &self.value
     }
-}
 
-impl From<&StorageSlot> for Bytes64 {
-    fn from(s: &StorageSlot) -> Self {
-        let mut buf = [0u8; StorageSlot::SLOT_SIZE];
-
-        buf[..Bytes32::LEN].copy_from_slice(s.key.as_ref());
-        buf[Bytes32::LEN..].copy_from_slice(s.value.as_ref());
-
-        buf.into()
+    pub fn size(&self) -> usize {
+        Serialize::size(self)
     }
 }
 
-impl From<&Bytes64> for StorageSlot {
-    fn from(b: &Bytes64) -> Self {
-        let key = <Bytes32 as Deserialize>::from_bytes(&b[..Bytes32::LEN])
-            .expect("Infallible deserialization");
-        let value = <Bytes32 as Deserialize>::from_bytes(&b[Bytes32::LEN..])
-            .expect("Infallible deserialization");
-        Self::new(key, value)
+impl From<&(Bytes32, StorageData)> for StorageSlot {
+    fn from((key, value): &(Bytes32, StorageData)) -> Self {
+        Self::new(*key, value.clone())
     }
 }
 
@@ -69,7 +58,7 @@ impl Distribution<StorageSlot> for Standard {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> StorageSlot {
         StorageSlot {
             key: rng.gen(),
-            value: rng.gen(),
+            value: rng.gen::<Bytes32>().to_vec(),
         }
     }
 }
@@ -89,7 +78,10 @@ impl Ord for StorageSlot {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rand::SeedableRng;
+    use rand::{
+        RngCore,
+        SeedableRng,
+    };
     use std::{
         fs::File,
         path::PathBuf,
@@ -101,7 +93,7 @@ mod tests {
     fn test_storage_slot_serialization() {
         let rng = &mut rand::rngs::StdRng::seed_from_u64(8586);
         let key: Bytes32 = rng.gen();
-        let value: Bytes32 = rng.gen();
+        let value = rng.gen::<Bytes32>().to_vec();
 
         let slot = StorageSlot::new(key, value);
         let slots = vec![slot.clone()];
@@ -124,4 +116,42 @@ mod tests {
             serde_json::from_reader(storage_slots_file).expect("read file");
         assert_eq!(storage_slots.len(), 1);
     }
+
+    #[test]
+    fn test_storage_slot_canonical_serialization() {
+        let rng = &mut rand::rngs::StdRng::seed_from_u64(8586);
+        let key: Bytes32 = rng.gen();
+        let mut value = [0u8; 128];
+        rng.fill_bytes(&mut value);
+
+        let slot = StorageSlot::new(key, value.to_vec());
+
+        let slot_bytes = slot.to_bytes();
+
+        let (slot_key, slot_data) = slot_bytes.split_at(32);
+
+        assert_eq!(slot_key, key.as_ref());
+
+        let slot_data_num_bytes =
+            u64::from_bytes(&slot_data[..8]).expect("read from bytes");
+        assert_eq!(slot_data_num_bytes, 128);
+
+        // `from_bytes` works
+        let recreated_slot =
+            StorageSlot::from_bytes(&slot_bytes).expect("read from bytes");
+        assert_eq!(recreated_slot, slot);
+    }
+
+    #[test]
+    fn test_storage_slot_size() {
+        let rng = &mut rand::rngs::StdRng::seed_from_u64(8586);
+        let key: Bytes32 = rng.gen();
+        let mut value = [0u8; 128];
+        rng.fill_bytes(&mut value);
+
+        let slot = StorageSlot::new(key, value.to_vec());
+        let size = slot.size();
+        let expected_size = 32 + 8 + 128; // Key + u64 (data size) + Data
+        assert_eq!(size, expected_size);
+    }
 }

fuel-vm/src/interpreter/blockchain.rs

@@ -54,7 +54,10 @@ use crate::{
         InterpreterStorage,
     },
 };
-use alloc::vec::Vec;
+use alloc::{
+    vec,
+    vec::Vec,
+};
 use fuel_asm::PanicReason;
 use fuel_storage::StorageSize;
 use fuel_tx::{
@@ -1041,7 +1044,7 @@ pub(crate) fn state_write_word<S: InterpreterStorage>(
     let contract = ContractId::from_bytes_ref(contract.read(memory));
     let key = Bytes32::from_bytes_ref(key.read(memory));
 
-    let mut value = Bytes32::default();
+    let mut value = vec![0; 32];
 
     value[..WORD_SIZE].copy_from_slice(&c.to_be_bytes());
 
@@ -1228,10 +1231,10 @@ fn state_read_qword<S: InterpreterStorage>(
         .map_err(RuntimeError::Storage)?
         .into_iter()
         .flat_map(|bytes| match bytes {
-            Some(bytes) => **bytes,
+            Some(bytes) => bytes.into_owned(),
             None => {
                 all_set = false;
-                *Bytes32::zeroed()
+                vec![0; 32]
             }
         })
         .collect();
@@ -1295,7 +1298,7 @@ fn state_write_qword<'vm, S: InterpreterStorage>(
 
     let values: Vec<_> = memory[input.source_address_memory_range.usizes()]
         .chunks_exact(Bytes32::LEN)
-        .flat_map(|chunk| Some(Bytes32::from(<[u8; 32]>::try_from(chunk).ok()?)))
+        .flat_map(|chunk| Some(chunk.to_vec()))
         .collect();
 
     let unset_count = storage