feat: improve state copying between host and WASM contracts

- Remove 3 unnecessary WrappedState .clone() calls in contract.rs;
  write() only needs AsRef<[u8]>, no ownership transfer required
- Add init_buf_with_capacity() to allocate WASM buffers by size
  without needing the data upfront
- Use bincode::serialize_into to write RelatedContracts and UpdateData
  directly into WASM memory, eliminating intermediate Vec allocations
- Fix pre-existing clippy warnings in test code (wildcard_enum_match_arm,
  assertions_on_constants)

Depends on freenet/freenet-stdlib#62 for the std::io::Write impl
on BufferMut.

Author: iduartgomez

Cargo.lock

@@ -134,7 +134,7 @@ winapi = "0.3"
 zip = { version = "8", default-features = false, features = ["deflate", "time"] }
 
 # Freenet
-freenet-stdlib = "0.3.2"
+freenet-stdlib = { git = "https://github.com/freenet/freenet-stdlib", branch = "feat/improve-state-copying" }
 
 [profile.dev.package."*"]
 opt-level = 3

Cargo.toml

@@ -3382,6 +3382,7 @@ mod messages {
 }
 
 #[cfg(test)]
+#[allow(clippy::wildcard_enum_match_arm)]
 mod tests {
     use super::*;
     use crate::message::Transaction;

crates/core/src/operations/get.rs

@@ -2053,6 +2053,7 @@ mod messages {
 }
 
 #[cfg(test)]
+#[allow(clippy::wildcard_enum_match_arm)]
 mod tests {
     use super::*;
     use crate::message::Transaction;

crates/core/src/operations/put.rs

@@ -2444,6 +2444,7 @@ pub enum UpdateState {
 }
 
 #[cfg(test)]
+#[allow(clippy::wildcard_enum_match_arm)]
 mod tests {
     use super::*;
     use crate::operations::test_utils::make_contract_key;

crates/core/src/operations/update.rs

@@ -585,13 +585,16 @@ mod packet_type_discrimination_tests {
         // the IPv6 minimum MTU (1280), which is the most restrictive common path.
         const UDP_HEADER: usize = 8;
         const IPV4_HEADER: usize = 20;
-        assert!(
-            MAX_PACKET_SIZE + UDP_HEADER + IPV4_HEADER <= 1280,
-            "MAX_PACKET_SIZE {} would cause IP fragmentation on IPv6 minimum MTU paths \
-             (total {} > 1280)",
-            MAX_PACKET_SIZE,
-            MAX_PACKET_SIZE + UDP_HEADER + IPV4_HEADER,
-        );
+        #[allow(clippy::assertions_on_constants)]
+        {
+            assert!(
+                MAX_PACKET_SIZE + UDP_HEADER + IPV4_HEADER <= 1280,
+                "MAX_PACKET_SIZE {} would cause IP fragmentation on IPv6 minimum MTU paths \
+                 (total {} > 1280)",
+                MAX_PACKET_SIZE,
+                MAX_PACKET_SIZE + UDP_HEADER + IPV4_HEADER,
+            );
+        }
     }
 
     #[test]
@@ -600,12 +603,15 @@ mod packet_type_discrimination_tests {
         // Verify that MAX_RECV_PACKET_SIZE can hold these and that PacketData
         // can be constructed at the receive buffer size.
         const OLD_MAX_PACKET_SIZE: usize = 1492;
-        assert!(
-            OLD_MAX_PACKET_SIZE <= MAX_RECV_PACKET_SIZE,
-            "Receive buffer ({}) must accommodate old peer packets ({})",
-            MAX_RECV_PACKET_SIZE,
-            OLD_MAX_PACKET_SIZE,
-        );
+        #[allow(clippy::assertions_on_constants)]
+        {
+            assert!(
+                OLD_MAX_PACKET_SIZE <= MAX_RECV_PACKET_SIZE,
+                "Receive buffer ({}) must accommodate old peer packets ({})",
+                MAX_RECV_PACKET_SIZE,
+                OLD_MAX_PACKET_SIZE,
+            );
+        }
 
         // Verify PacketData can be constructed from old-size received data.
         // In production, recv_from fills a [0u8; MAX_RECV_PACKET_SIZE] buffer,

crates/core/src/transport/packet_data.rs

@@ -96,9 +96,9 @@ impl ContractRuntimeInterface for super::Runtime {
                 state_buf.ptr()
             };
             let related_buf_ptr = {
-                let serialized = bincode::serialize(related)?;
-                let mut related_buf = self.init_buf(&running.handle, &serialized)?;
-                related_buf.write(serialized)?;
+                let size = bincode::serialized_size(related)? as usize;
+                let mut related_buf = self.init_buf_with_capacity(&running.handle, size)?;
+                bincode::serialize_into(&mut related_buf, related)?;
                 related_buf.ptr()
             };
 
@@ -147,13 +147,13 @@ impl ContractRuntimeInterface for super::Runtime {
             };
             let state_buf_ptr = {
                 let mut state_buf = self.init_buf(&running.handle, state)?;
-                state_buf.write(state.clone())?;
+                state_buf.write(state)?;
                 state_buf.ptr()
             };
             let update_data_buf_ptr = {
-                let serialized = bincode::serialize(update_data)?;
-                let mut update_data_buf = self.init_buf(&running.handle, &serialized)?;
-                update_data_buf.write(serialized)?;
+                let size = bincode::serialized_size(update_data)? as usize;
+                let mut update_data_buf = self.init_buf_with_capacity(&running.handle, size)?;
+                bincode::serialize_into(&mut update_data_buf, update_data)?;
                 update_data_buf.ptr()
             };
 
@@ -200,7 +200,7 @@ impl ContractRuntimeInterface for super::Runtime {
             };
             let state_buf_ptr = {
                 let mut state_buf = self.init_buf(&running.handle, state)?;
-                state_buf.write(state.clone())?;
+                state_buf.write(state)?;
                 state_buf.ptr()
             };
 
@@ -247,7 +247,7 @@ impl ContractRuntimeInterface for super::Runtime {
             };
             let state_buf_ptr = {
                 let mut state_buf = self.init_buf(&running.handle, state)?;
-                state_buf.write(state.clone())?;
+                state_buf.write(state)?;
                 state_buf.ptr()
             };
             let summary_buf_ptr = {

crates/core/src/wasm_runtime/contract.rs

@@ -316,6 +316,23 @@ impl Runtime {
         }
     }
 
+    pub(super) fn init_buf_with_capacity(
+        &mut self,
+        handle: &InstanceHandle,
+        capacity: usize,
+    ) -> RuntimeResult<BufferMut<'_>> {
+        let builder_ptr = self.engine.initiate_buffer(handle, capacity as u32)?;
+        let linear_mem = self.linear_mem(handle)?;
+        // SAFETY: `builder_ptr` is returned by the WASM allocator and points to a valid
+        // `BufferBuilder` within the instance's linear memory described by `linear_mem`.
+        unsafe {
+            Ok(BufferMut::from_ptr(
+                builder_ptr as *mut BufferBuilder,
+                linear_mem,
+            ))
+        }
+    }
+
     pub(super) fn linear_mem(&mut self, handle: &InstanceHandle) -> RuntimeResult<WasmLinearMem> {
         let (ptr, size) = self.engine.memory_info(handle)?;
         // SAFETY: `ptr` and `size` come from the engine's live memory export for this