Storage with more than one word. (#1235)

* Store more than one word.

* test: add new storage test project

* build: rename default contract & abi

* test: fix path to abi.json

* test: work on tests

* test: work on test contract

* test: add storage tests to harness

* test: add test for store_u64

* test: add tests for b256

* test: remove dbg!

* test: update tests

* feat: start to draft the read function

* Fixing some issues and adding to the test

* more tests

* minor improvements

* fix some contract IDs

* address comments from reviewers

* small renaming for clarity

* fix contract IDs again

* fixing SDK API in storage test

Co-authored-by: Nick Furfaro <nfurfaro33@gmail.com>
Co-authored-by: Mohammad Fawaz <mohammadfawaz89@gmail.com>

Author: 3 people

sway-lib-std/src/storage.sw

@@ -1,14 +1,93 @@
 library storage;
 
+use ::hash::sha256;
+use ::context::registers::stack_ptr;
+
+/// Store a stack variable in storage.
 pub fn store<T>(key: b256, value: T) {
-    asm(r1: key, r2: value) {
-        sww r1 r2;
+    if !__is_reference_type::<T>() {
+        // If copy type, then it's a single word and can be stored with a single SWW.
+        asm(k: key, v: value) {
+            sww k v;
+        };
+    } else {
+        // If reference type, then it's more than a word. Loop over every 32
+        // bytes and store sequentially.
+        let mut size_left = __size_of::<T>();
+        let mut local_key = key;
+
+        // Cast the the pointer to `value` to a u64. This lets us increment
+        // this pointer later on to iterate over 32 byte chunks of `value`.
+        let mut ptr_to_value = asm(v: value) {
+            v
+        };
+
+        while size_left > 32 {
+            // Store a 4 words (32 byte) at a time using `swwq`
+            asm(k: local_key, v: ptr_to_value) {
+                swwq k v;
+            };
+
+            // Move by 32 bytes
+            ptr_to_value = ptr_to_value + 32;
+            size_left = size_left - 32;
+
+            // Generate a new key for each 32 byte chunk TODO Should eventually
+            // replace this with `local_key = local_key + 1
+            local_key = sha256(local_key);
+        }
+
+        // Store the leftover bytes using a single `swwq`
+        asm(k: local_key, v: ptr_to_value) {
+            swwq k v;
+        };
     };
 }
 
+/// Load a stack variable from storage.
 pub fn get<T>(key: b256) -> T {
-    asm(r1: key, r2) {
-        srw r2 r1;
-        r2: T
+    if !__is_reference_type::<T>() {
+        // If copy type, then it's a single word and can be read with a single
+        // SRW.
+        asm(k: key, v) {
+            srw v k;
+            v: T
+        }
+    } else {
+        // If reference type, then it's more than a word. Loop over every 32
+        // bytes and read sequentially.
+        let mut size_left = __size_of::<T>();
+        let mut local_key = key;
+
+        // Keep track of the base pointer for the final result
+        let result_ptr = stack_ptr();
+
+        while size_left > 32 {
+            // Read 4 words (32 bytes) at a time using `srwq`
+            let current_pointer = stack_ptr();
+            asm(k: local_key, v: current_pointer) {
+                cfei i32;
+                srwq v k;
+            };
+
+            // Move by 32 bytes
+            size_left = size_left - 32;
+
+            // Generate a new key for each 32 byte chunk TODO Should eventually
+            // replace this with `local_key = local_key + 1
+            local_key = sha256(local_key);
+        }
+
+        // Read the leftover bytes using a single `srwq`
+        let current_pointer = stack_ptr();
+        asm(k: local_key, v: current_pointer) {
+            cfei i32;
+            srwq v k;
+        }
+
+        // Return the final result as type T
+        asm(res: result_ptr) {
+            res: T
+        }
     }
 }

test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw

@@ -3,7 +3,7 @@ use basic_storage_abi::StoreU64;
 use std::assert::assert;
 
 fn main() -> u64 {
-    let addr = abi(StoreU64, 0x804a1248edf8b46a40e31283020337da84bb81eb8a2eaaa929b99bf0c93fbf12);
+    let addr = abi(StoreU64, 0x76c37f1f22b25f7f063483fe57ada77db8bb9799c43a3105996ada9e7dcd20dc);
     let key = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
     let value = 4242;
 

test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw

@@ -4,7 +4,7 @@ use increment_abi::Incrementor;
 use std::assert::assert;
 
 fn main() -> bool {
-    let the_abi = abi(Incrementor, 0x924e7fba0dee39fa0e5506b631e664c0adf63cda6589833bf47f5926ef065477);
+    let the_abi = abi(Incrementor, 0xb735d4f30161b1898a99816eac7c4ed02b80253af1f4ce6d10b5773bd3004e9e);
     the_abi.initialize(0); // comment this line out to just increment without initializing
     the_abi.increment(5);
     the_abi.increment(5);

test/src/sdk-harness/test_projects/harness.rs

@@ -7,5 +7,6 @@ mod hashing;
 mod logging;
 mod reentrancy;
 mod registers;
+mod storage;
 mod token_ops;
 mod tx_fields;

test/src/sdk-harness/test_projects/storage/.gitignore

@@ -0,0 +1,2 @@
+out
+target

test/src/sdk-harness/test_projects/storage/Forc.lock

@@ -0,0 +1,11 @@
+[[package]]
+name = 'core'
+dependencies = []
+
+[[package]]
+name = 'std'
+dependencies = ['core']
+
+[[package]]
+name = 'storage'
+dependencies = ['std']

test/src/sdk-harness/test_projects/storage/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "storage"
+
+[dependencies]
+std = { path = "../../../../../sway-lib-std" }

test/src/sdk-harness/test_projects/storage/mod.rs

@@ -0,0 +1,172 @@
+use fuels::prelude::*;
+use fuels_abigen_macro::abigen;
+
+abigen!(
+    TestStorageContract,
+    "test_projects/storage/out/debug/storage-abi.json",
+);
+
+async fn get_test_storage_instance() -> TestStorageContract {
+    let wallet = launch_provider_and_get_single_wallet().await;
+    let id = Contract::deploy(
+        "test_projects/storage/out/debug/storage.bin",
+        &wallet,
+        TxParameters::default(),
+    )
+    .await
+    .unwrap();
+
+    TestStorageContract::new(id.to_string(), wallet)
+}
+
+#[tokio::test]
+async fn can_store_and_get_bool() {
+    let instance = get_test_storage_instance().await;
+    let b = true;
+    instance.store_bool(b).call().await.unwrap();
+    let result = instance.get_bool().call().await.unwrap();
+    assert_eq!(result.value, b);
+}
+
+#[tokio::test]
+async fn can_store_and_get_u8() {
+    let instance = get_test_storage_instance().await;
+    let n = 8;
+    instance.store_u8(n).call().await.unwrap();
+    let result = instance.get_u8().call().await.unwrap();
+    assert_eq!(result.value, n);
+}
+
+#[tokio::test]
+async fn can_store_and_get_u16() {
+    let instance = get_test_storage_instance().await;
+    let n = 16;
+    instance.store_u16(n).call().await.unwrap();
+    let result = instance.get_u16().call().await.unwrap();
+    assert_eq!(result.value, n);
+}
+
+#[tokio::test]
+async fn can_store_and_get_u32() {
+    let instance = get_test_storage_instance().await;
+    let n = 32;
+    instance.store_u32(n).call().await.unwrap();
+    let result = instance.get_u32().call().await.unwrap();
+    assert_eq!(result.value, n);
+}
+
+#[tokio::test]
+async fn can_store_and_get_u64() {
+    let instance = get_test_storage_instance().await;
+    let n = 64;
+    instance.store_u64(n).call().await.unwrap();
+    let result = instance.get_u64().call().await.unwrap();
+    assert_eq!(result.value, n);
+}
+
+#[tokio::test]
+async fn can_store_b256() {
+    let instance = get_test_storage_instance().await;
+    let n: [u8; 32] = [2; 32];
+    instance.store_b256(n).call().await.unwrap();
+    let result = instance.get_b256().call().await.unwrap();
+    assert_eq!(result.value, n);
+}
+
+#[tokio::test]
+async fn can_store_small_struct() {
+    let instance = get_test_storage_instance().await;
+    let s = SmallStruct { x: 42 };
+    instance.store_small_struct(s.clone()).call().await.unwrap();
+    let result = instance.get_small_struct().call().await.unwrap();
+    assert_eq!(result.value, s);
+}
+
+#[tokio::test]
+async fn can_store_medium_struct() {
+    let instance = get_test_storage_instance().await;
+    let s = MediumStruct { x: 42, y: 66 };
+    instance
+        .store_medium_struct(s.clone())
+        .call()
+        .await
+        .unwrap();
+    let result = instance.get_medium_struct().call().await.unwrap();
+    assert_eq!(result.value, s);
+}
+
+#[tokio::test]
+async fn can_store_large_struct() {
+    let instance = get_test_storage_instance().await;
+    let s = LargeStruct {
+        x: 13,
+        y: [6; 32],
+        z: 77,
+    };
+    instance.store_large_struct(s.clone()).call().await.unwrap();
+    let result = instance.get_large_struct().call().await.unwrap();
+    assert_eq!(result.value, s);
+}
+
+#[tokio::test]
+async fn can_store_very_large_struct() {
+    let instance = get_test_storage_instance().await;
+    let s = VeryLargeStruct {
+        x: 42,
+        y: [9; 32],
+        z: [7; 32],
+    };
+    instance
+        .store_very_large_struct(s.clone())
+        .call()
+        .await
+        .unwrap();
+    let result = instance.get_very_large_struct().call().await.unwrap();
+    assert_eq!(result.value, s);
+}
+
+#[tokio::test]
+async fn can_store_enum() {
+    let instance = get_test_storage_instance().await;
+    let e1 = StorageEnum::V1([3; 32]);
+    instance.store_enum(e1.clone()).call().await.unwrap();
+    let result = instance.get_enum().call().await.unwrap();
+    assert_eq!(result.value, e1);
+
+    let e2 = StorageEnum::V2(99);
+    instance.store_enum(e2.clone()).call().await.unwrap();
+    let result = instance.get_enum().call().await.unwrap();
+    assert_eq!(result.value, e2);
+
+    let e3 = StorageEnum::V3([4; 32]);
+    instance.store_enum(e3.clone()).call().await.unwrap();
+    let result = instance.get_enum().call().await.unwrap();
+    assert_eq!(result.value, e3);
+}
+
+#[tokio::test]
+async fn can_store_tuple() {
+    let instance = get_test_storage_instance().await;
+    let t = ([7; 32], 8, [6; 32]);
+    instance.store_tuple(t.clone()).call().await.unwrap();
+    let result = instance.get_tuple().call().await.unwrap();
+    assert_eq!(result.value, t);
+}
+
+#[tokio::test]
+async fn can_store_string() {
+    let instance = get_test_storage_instance().await;
+    let s = "fastest_modular_execution_layer".to_string();
+    instance.store_string(s.clone()).call().await.unwrap();
+    let result = instance.get_string().call().await.unwrap();
+    assert_eq!(result.value, s);
+}
+
+#[tokio::test]
+async fn can_store_array() {
+    let instance = get_test_storage_instance().await;
+    let a = [[153; 32], [136; 32], [119; 32]].to_vec();
+    instance.store_array().call().await.unwrap();
+    let result = instance.get_array().call().await.unwrap();
+    assert_eq!(result.value, a);
+}