Switch the Blob from Box<[u8]> to Arc<Box<[u8]>>. (#4399)

## Motivation

We are doing some cloning operations for blobs. This occurs in the
`TransactionTracker` with the `previously_created_blobs`.

Fixes #2389

## Proposal

The implementation is done with the `serde_with` for the serialization.

## Test Plan

The CI.
A test has been introduced for this serialization and hash.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None

Author: MathieuDutSik

linera-base/Cargo.toml

@@ -52,7 +52,7 @@ prometheus = { workspace = true, optional = true }
 proptest = { workspace = true, optional = true, features = ["alloc"] }
 rand.workspace = true
 reqwest = { workspace = true, optional = true }
-serde.workspace = true
+serde = { workspace = true, features = ["rc"] }
 serde-name.workspace = true
 serde_bytes.workspace = true
 serde_json.workspace = true

linera-base/src/data_types.rs

@@ -15,6 +15,7 @@ use std::{
     ops::{Bound, RangeBounds},
     path::Path,
     str::FromStr,
+    sync::Arc,
 };
 
 use alloy_primitives::U256;
@@ -1246,22 +1247,28 @@ impl CompressedBytecode {
 
 impl BcsHashable<'_> for BlobContent {}
 
+use serde_with::*;
+
 /// A blob of binary data.
+#[serde_as]
 #[derive(Hash, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct BlobContent {
     /// The type of data represented by the bytes.
     blob_type: BlobType,
     /// The binary data.
-    #[serde(with = "serde_bytes")]
     #[debug(skip)]
-    bytes: Box<[u8]>,
+    #[serde_as(as = "Arc<Bytes>")]
+    bytes: Arc<Box<[u8]>>,
 }
 
 impl BlobContent {
     /// Creates a new [`BlobContent`] from the provided bytes and [`BlobId`].
     pub fn new(blob_type: BlobType, bytes: impl Into<Box<[u8]>>) -> Self {
         let bytes = bytes.into();
-        BlobContent { blob_type, bytes }
+        BlobContent {
+            blob_type,
+            bytes: Arc::new(bytes),
+        }
     }
 
     /// Creates a new data [`BlobContent`] from the provided bytes.
@@ -1313,9 +1320,10 @@ impl BlobContent {
         &self.bytes
     }
 
-    /// Gets the inner blob's bytes, consuming the blob.
-    pub fn into_bytes(self) -> Box<[u8]> {
-        self.bytes
+    /// Convert a BlobContent into `Vec<u8>` without cloning if possible.
+    pub fn into_vec_or_clone(self) -> Vec<u8> {
+        let bytes = Arc::unwrap_or_clone(self.bytes);
+        bytes.into_vec()
     }
 
     /// Returns the type of data represented by this blob's bytes.
@@ -1363,11 +1371,12 @@ impl Blob {
 
     /// Creates a blob without checking that the hash actually matches the content.
     pub fn new_with_id_unchecked(blob_id: BlobId, bytes: impl Into<Box<[u8]>>) -> Self {
+        let bytes = bytes.into();
         Blob {
             hash: blob_id.hash,
             content: BlobContent {
                 blob_type: blob_id.blob_type,
-                bytes: bytes.into(),
+                bytes: Arc::new(bytes),
             },
         }
     }
@@ -1432,11 +1441,6 @@ impl Blob {
         self.content.bytes()
     }
 
-    /// Gets the inner blob's bytes.
-    pub fn into_bytes(self) -> Box<[u8]> {
-        self.content.into_bytes()
-    }
-
     /// Loads data blob from a file.
     pub async fn load_data_blob_from_file(path: impl AsRef<Path>) -> io::Result<Self> {
         Ok(Self::new_data(fs::read(path)?))
@@ -1590,7 +1594,8 @@ mod metrics {
 mod tests {
     use std::str::FromStr;
 
-    use super::Amount;
+    use super::{Amount, BlobContent};
+    use crate::identifiers::BlobType;
 
     #[test]
     fn display_amount() {
@@ -1617,4 +1622,35 @@ mod tests {
             format!("{:~^+9.1}", Amount::from_str("12.34").unwrap())
         );
     }
+
+    #[test]
+    fn blob_content_serialization_deserialization() {
+        let test_data = b"Hello, world!".as_slice();
+        let original_blob = BlobContent::new(BlobType::Data, test_data);
+
+        let serialized = bcs::to_bytes(&original_blob).expect("Failed to serialize BlobContent");
+        let deserialized: BlobContent =
+            bcs::from_bytes(&serialized).expect("Failed to deserialize BlobContent");
+        assert_eq!(original_blob, deserialized);
+
+        let serialized =
+            serde_json::to_vec(&original_blob).expect("Failed to serialize BlobContent");
+        let deserialized: BlobContent =
+            serde_json::from_slice(&serialized).expect("Failed to deserialize BlobContent");
+        assert_eq!(original_blob, deserialized);
+    }
+
+    #[test]
+    fn blob_content_hash_consistency() {
+        let test_data = b"Hello, world!";
+        let blob1 = BlobContent::new(BlobType::Data, test_data.as_slice());
+        let blob2 = BlobContent::new(BlobType::Data, Vec::from(test_data.as_slice()));
+
+        // Both should have same hash since they contain the same data
+        let hash1 = crate::crypto::CryptoHash::new(&blob1);
+        let hash2 = crate::crypto::CryptoHash::new(&blob2);
+
+        assert_eq!(hash1, hash2, "Hashes should be equal for same content");
+        assert_eq!(blob1.bytes(), blob2.bytes(), "Byte content should be equal");
+    }
 }

linera-execution/src/runtime.rs

@@ -946,7 +946,7 @@ where
             this.transaction_tracker
                 .replay_oracle_response(OracleResponse::Blob(blob_id))?;
         }
-        Ok(content.into_bytes().into_vec())
+        Ok(content.into_vec_or_clone())
     }
 
     fn assert_data_blob_exists(&mut self, hash: DataBlobHash) -> Result<(), ExecutionError> {

linera-execution/tests/test_execution.rs

@@ -1237,8 +1237,8 @@ async fn test_open_chain() -> anyhow::Result<()> {
     let new_blob = &txn_outcome.blobs[0];
     assert_eq!(new_blob.id().hash, child_id.0);
     assert_eq!(new_blob.id().blob_type, BlobType::ChainDescription);
-    let created_description: ChainDescription = bcs::from_bytes(&new_blob.clone().into_bytes())
-        .expect("should deserialize a chain description");
+    let created_description: ChainDescription =
+        bcs::from_bytes(new_blob.bytes()).expect("should deserialize a chain description");
     assert_eq!(created_description.config().balance, Amount::ONE);
     assert_eq!(created_description.config().ownership, child_ownership);
 

linera-storage/src/lib.rs

@@ -276,7 +276,7 @@ pub trait Storage: Sized {
                 .into_content(),
         };
         let compressed_contract_bytecode = CompressedBytecode {
-            compressed_bytes: content.into_bytes().into_vec(),
+            compressed_bytes: content.into_vec_or_clone(),
         };
         #[cfg_attr(not(any(with_wasm_runtime, with_revm)), allow(unused_variables))]
         let contract_bytecode =
@@ -343,7 +343,7 @@ pub trait Storage: Sized {
                 .into_content(),
         };
         let compressed_service_bytecode = CompressedBytecode {
-            compressed_bytes: content.into_bytes().into_vec(),
+            compressed_bytes: content.into_vec_or_clone(),
         };
         #[cfg_attr(not(any(with_wasm_runtime, with_revm)), allow(unused_variables))]
         let service_bytecode = linera_base::task::Blocking::<linera_base::task::NoInput, _>::spawn(