Do not read from state when writing aligned, slot sized values (#7470)

Author: vaivaswatha

forc-plugins/forc-client/tests/deploy.rs

@@ -377,7 +377,7 @@ async fn test_simple_deploy() {
     node.kill().unwrap();
     let expected = vec![DeployedPackage::Contract(DeployedContract {
         id: ContractId::from_str(
-            "91c435d6cdb720db92097958163bc43dbc5c4acfbb3d98025039addb9e2da8bb",
+            "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8",
         )
         .unwrap(),
         proxy: None,
@@ -421,7 +421,7 @@ async fn test_deploy_submit_only() {
     node.kill().unwrap();
     let expected = vec![DeployedPackage::Contract(DeployedContract {
         id: ContractId::from_str(
-            "91c435d6cdb720db92097958163bc43dbc5c4acfbb3d98025039addb9e2da8bb",
+            "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8",
         )
         .unwrap(),
         proxy: None,
@@ -468,12 +468,12 @@ async fn test_deploy_fresh_proxy() {
     node.kill().unwrap();
     let impl_contract = DeployedPackage::Contract(DeployedContract {
         id: ContractId::from_str(
-            "91c435d6cdb720db92097958163bc43dbc5c4acfbb3d98025039addb9e2da8bb",
+            "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8",
         )
         .unwrap(),
         proxy: Some(
             ContractId::from_str(
-                "212c0edca7ddbb762d93a2446083d94df2db059d1f41ad49807223e8249669e5",
+                "e597d0ef3dc3375402f32bcaa7fc66940f92c31a916e87e7eebb32fcd147d752",
             )
             .unwrap(),
         ),

sway-lib-std/src/storage/storage_api.sw

@@ -43,6 +43,13 @@ pub fn write<T>(slot: b256, offset: u64, value: T) {
     // Determine how many slots and where the value is to be stored.
     let (offset_slot, number_of_slots, place_in_slot) = slot_calculator::<T>(slot, offset);
 
+    if __size_of::<T>() % 32 == 0 && place_in_slot == 0 {
+        // If the value is aligned to the start of a slot and occupies full slots, we can store it directly.
+        let value_addr = __addr_of::<T>(value);
+        let _ = __state_store_quad(offset_slot, value_addr, number_of_slots);
+        return;
+    }
+
     // Allocate enough memory on the heap for `value` as well as any potential padding required due 
     // to `offset`.
     let padded_value = alloc::<u64>(number_of_slots * 32);

test/src/e2e_vm_tests/test_programs/should_pass/language/storage_slot_sized/Forc.lock

@@ -0,0 +1,8 @@
+[[package]]
+name = "std"
+source = "path+from-root-0377E0F41F094EDB"
+
+[[package]]
+name = "storage_slot_sized"
+source = "member"
+dependencies = ["std"]

test/src/e2e_vm_tests/test_programs/should_pass/language/storage_slot_sized/Forc.toml

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

test/src/e2e_vm_tests/test_programs/should_pass/language/storage_slot_sized/src/main.sw

@@ -0,0 +1,59 @@
+contract;
+
+struct S1 {
+  f1: u64,
+  f2: u64,
+  f3: u64,
+  f4: u64,
+}
+
+impl PartialEq for S1 {
+  fn eq(self, other: Self) -> bool {
+      self.f1 == other.f1 && self.f2 == other.f2 && self.f3 == other.f3 && self.f4 == other.f4
+  }
+}
+
+impl Eq for S1 {}
+
+storage {
+    var1: S1 = S1 { f1: 1, f2: 2, f3: 3, f4: 4 },
+    var2: (S1, S1) = (S1 { f1: 11, f2: 21, f3: 31, f4: 41 }, S1 { f1: 12, f2: 22, f3: 32, f4: 42 })
+}
+
+impl Contract {
+    #[storage(write)]
+    fn store_something_1(x: S1) {
+        storage.var1.write(x);
+    }
+
+    #[storage(read)]
+    fn check_store_1(x: S1) {
+       assert_eq(storage.var1.read(), x);
+    }
+
+    #[storage(write)]
+    fn store_something_2(x: (S1, S1)) {
+        storage.var2.write(x);
+    }
+
+    #[storage(read)]
+    fn check_store_2(x: (S1, S1)) {
+       assert_eq(storage.var2.read(), x);
+    }
+}
+
+#[test]
+fn test_store_something() {
+    let storage_test = abi(StorageSlotSizedAbi, CONTRACT_ID);
+    let x1 = S1 { f1: 1, f2: 2, f3: 3, f4: 4 };
+    storage_test.check_store_1(x1);
+    let x2 = S1 { f1: 2, f2: 3, f3: 4, f4: 5 };
+    storage_test.store_something_1(x2);
+    storage_test.check_store_1(x2);
+
+    let x3 = (S1 { f1: 11, f2: 21, f3: 31, f4: 41 }, S1 { f1: 12, f2: 22, f3: 32, f4: 42 });
+    let x4 = (S1 { f1: 111, f2: 211, f3: 311, f4: 411 }, S1 { f1: 121, f2: 221, f3: 321, f4: 421 });
+    storage_test.check_store_2(x3);
+    storage_test.store_something_2(x4);
+    storage_test.check_store_2(x4)
+}

test/src/e2e_vm_tests/test_programs/should_pass/language/storage_slot_sized/test.toml

@@ -0,0 +1,2 @@
+category = "unit_tests_pass"
+

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

@@ -4,7 +4,7 @@ use basic_storage_abi::{BasicStorage, Quad};
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0x94db39f409a31b9f2ebcadeea44378e419208c20de90f5d8e1e33dc1523754cb;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0x55a636b2843307e245948ea70b113b81d1f30307d4fa6fa0f4bb27c0149afd5c; // AUTO-CONTRACT-ID ../../test_contracts/basic_storage --release
+const CONTRACT_ID = 0x841aa8d101ee9b06ff89b72bb5a2bdb46cd6981ba602619fda7424b8b7d47ada; // AUTO-CONTRACT-ID ../../test_contracts/basic_storage --release
 
 fn main() -> u64 {
     let addr = abi(BasicStorage, CONTRACT_ID);

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

@@ -5,7 +5,7 @@ use storage_enum_abi::*;
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0xc601d11767195485a6654d566c67774134668863d8c797a8c69e8778fb1f89e9;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xc7d95c0fdae3df8de6a55f9a8f18c85e2434295d5ca25fe3ccb22fe19658a4d2; // AUTO-CONTRACT-ID ../../test_contracts/storage_enum_contract --release
+const CONTRACT_ID = 0x000c798c2f211f31bb2fb6c02fac49dcd461bab4b3c6ade2977ae71537f77406; // AUTO-CONTRACT-ID ../../test_contracts/storage_enum_contract --release
 
 fn main() -> u64 {
     let caller = abi(StorageEnum, CONTRACT_ID);

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

@@ -6,7 +6,7 @@ use std::hash::*;
 #[cfg(experimental_new_encoding = false)]
 const CONTRACT_ID = 0x3bc28acd66d327b8c1b9624c1fabfc07e9ffa1b5d71c2832c3bfaaf8f4b805e9;
 #[cfg(experimental_new_encoding = true)]
-const CONTRACT_ID = 0xcd9abae820c4d2570e8f62c3d49a5fed51df1e64ee6c8ba1af7d9a1e91a074e0; // AUTO-CONTRACT-ID ../../test_contracts/storage_access_contract --release
+const CONTRACT_ID = 0x4dc4ea62820f5db502781296582ac9e02132eec4452af5a994f92ad2185bb398; // AUTO-CONTRACT-ID ../../test_contracts/storage_access_contract --release
 
 fn main() -> bool {
     let caller = abi(StorageAccess, CONTRACT_ID);