Allow contract to create blobs (#4247)

## Motivation

In order for the EVM to be able to create contracts, it needs to be able
to create the corresponding data blobs.
However, for publishing application, we need blobs that are not data
blobs and so the `publish_module` is also added.

Fixes #3707 

## Proposal

The following was done:
* Add the `create_data_blob` functionality to the runtime, thereby
addressing the issue.
* Add the `publish_bytecode` functionality to the runtime so that smart
contracts can create modules.
* The use of `fn compress` on the web forced the insertion of a relevant
function using `ruzstd` and the corresponding version bump.

## Test Plan

The CI, and 4 tests that have been introduced.

## Release Plan

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

## Links

None

Author: MathieuDutSik

Cargo.lock

@@ -202,7 +202,7 @@ revm-state = { version = "4.0.1", default-features = false, features = [
     "serde",
 ] }
 rocksdb = "0.21.0"
-ruzstd = "0.7.1"
+ruzstd = "0.8.1"
 scylla = "1.1.0"
 semver = "1.0.22"
 serde = { version = "1.0.197", features = ["derive"] }

Cargo.toml

@@ -1088,7 +1088,7 @@ impl ApplicationDescription {
 }
 
 /// A WebAssembly module's bytecode.
-#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, WitType, WitLoad, WitStore)]
 pub struct Bytecode {
     /// Bytes of the bytecode.
     #[serde(with = "serde_bytes")]
@@ -1118,6 +1118,23 @@ impl Bytecode {
 
         CompressedBytecode { compressed_bytes }
     }
+
+    /// Compresses the [`Bytecode`] into a [`CompressedBytecode`].
+    #[cfg(target_arch = "wasm32")]
+    pub fn compress(&self) -> CompressedBytecode {
+        use ruzstd::encoding::{CompressionLevel, FrameCompressor};
+
+        #[cfg(with_metrics)]
+        let _compression_latency = metrics::BYTECODE_COMPRESSION_LATENCY.measure_latency();
+
+        let mut compressed_bytes = Vec::new();
+        let mut compressor = FrameCompressor::new(CompressionLevel::Fastest);
+        compressor.set_source(&*self.bytes);
+        compressor.set_drain(&mut compressed_bytes);
+        compressor.compress();
+
+        CompressedBytecode { compressed_bytes }
+    }
 }
 
 impl AsRef<[u8]> for Bytecode {
@@ -1180,10 +1197,10 @@ impl CompressedBytecode {
         compressed_bytes: &[u8],
         limit: u64,
     ) -> Result<bool, DecompressionError> {
+        use ruzstd::decoding::StreamingDecoder;
         let limit = usize::try_from(limit).unwrap_or(usize::MAX);
         let mut writer = LimitedWriter::new(io::sink(), limit);
-        let mut decoder = ruzstd::streaming_decoder::StreamingDecoder::new(compressed_bytes)
-            .map_err(io::Error::other)?;
+        let mut decoder = StreamingDecoder::new(compressed_bytes).map_err(io::Error::other)?;
 
         // TODO(#2710): Decode multiple frames, if present
         match io::copy(&mut decoder, &mut writer) {
@@ -1197,7 +1214,7 @@ impl CompressedBytecode {
 
     /// Decompresses a [`CompressedBytecode`] into a [`Bytecode`].
     pub fn decompress(&self) -> Result<Bytecode, DecompressionError> {
-        use ruzstd::{io::Read, streaming_decoder::StreamingDecoder};
+        use ruzstd::{decoding::StreamingDecoder, io::Read};
 
         #[cfg(with_metrics)]
         let _decompression_latency = BYTECODE_DECOMPRESSION_LATENCY.measure_latency();

examples/Cargo.lock

@@ -36,7 +36,8 @@ use linera_base::{
     crypto::{BcsHashable, CryptoHash},
     data_types::{
         Amount, ApplicationDescription, ApplicationPermissions, ArithmeticError, Blob, BlockHeight,
-        DecompressionError, Epoch, NetworkDescription, SendMessageRequest, StreamUpdate, Timestamp,
+        Bytecode, DecompressionError, Epoch, NetworkDescription, SendMessageRequest, StreamUpdate,
+        Timestamp,
     },
     doc_scalar, hex_debug, http,
     identifiers::{
@@ -819,6 +820,17 @@ pub trait ContractRuntime: BaseRuntime {
         required_application_ids: Vec<ApplicationId>,
     ) -> Result<ApplicationId, ExecutionError>;
 
+    /// Creates a new data blob and returns its ID.
+    fn create_data_blob(&mut self, bytes: Vec<u8>) -> Result<BlobId, ExecutionError>;
+
+    /// Publishes a module with contract and service bytecode and returns the module ID.
+    fn publish_module(
+        &mut self,
+        contract: Bytecode,
+        service: Bytecode,
+        vm_runtime: VmRuntime,
+    ) -> Result<ModuleId, ExecutionError>;
+
     /// Returns the round in which this block was validated.
     fn validation_round(&mut self) -> Result<Option<u32>, ExecutionError>;
 

linera-base/src/data_types.rs

@@ -13,8 +13,8 @@ use custom_debug_derive::Debug;
 use linera_base::{
     crypto::CryptoHash,
     data_types::{
-        Amount, ApplicationPermissions, ArithmeticError, BlockHeight, OracleResponse,
-        SendMessageRequest, Timestamp,
+        Amount, ApplicationPermissions, ArithmeticError, Blob, BlockHeight, Bytecode,
+        OracleResponse, SendMessageRequest, Timestamp,
     },
     ensure, http,
     identifiers::{
@@ -1590,6 +1590,27 @@ impl ContractRuntime for ContractSyncRuntimeHandle {
         Ok(app_id)
     }
 
+    fn create_data_blob(&mut self, bytes: Vec<u8>) -> Result<BlobId, ExecutionError> {
+        let blob = Blob::new_data(bytes);
+        let blob_id = blob.id();
+        self.inner().transaction_tracker.add_created_blob(blob);
+        Ok(blob_id)
+    }
+
+    fn publish_module(
+        &mut self,
+        contract: Bytecode,
+        service: Bytecode,
+        vm_runtime: VmRuntime,
+    ) -> Result<ModuleId, ExecutionError> {
+        let (blobs, module_id) =
+            crate::runtime::create_bytecode_blobs_sync(contract, service, vm_runtime);
+        for blob in blobs {
+            self.inner().transaction_tracker.add_created_blob(blob);
+        }
+        Ok(module_id)
+    }
+
     fn validation_round(&mut self) -> Result<Option<u32>, ExecutionError> {
         let mut this = self.inner();
         let round =
@@ -1828,3 +1849,32 @@ impl From<&MessageContext> for ExecutingMessage {
         }
     }
 }
+
+/// Creates a compressed contract and service bytecode synchronously.
+pub fn create_bytecode_blobs_sync(
+    contract: Bytecode,
+    service: Bytecode,
+    vm_runtime: VmRuntime,
+) -> (Vec<Blob>, ModuleId) {
+    match vm_runtime {
+        VmRuntime::Wasm => {
+            let compressed_contract = contract.compress();
+            let compressed_service = service.compress();
+            let contract_blob = Blob::new_contract_bytecode(compressed_contract);
+            let service_blob = Blob::new_service_bytecode(compressed_service);
+            let module_id =
+                ModuleId::new(contract_blob.id().hash, service_blob.id().hash, vm_runtime);
+            (vec![contract_blob, service_blob], module_id)
+        }
+        VmRuntime::Evm => {
+            let compressed_contract = contract.compress();
+            let evm_contract_blob = Blob::new_evm_bytecode(compressed_contract);
+            let module_id = ModuleId::new(
+                evm_contract_blob.id().hash,
+                evm_contract_blob.id().hash,
+                vm_runtime,
+            );
+            (vec![evm_contract_blob], module_id)
+        }
+    }
+}

linera-execution/src/lib.rs

@@ -5,9 +5,11 @@ use std::{any::Any, collections::HashMap, marker::PhantomData};
 
 use linera_base::{
     crypto::CryptoHash,
-    data_types::{Amount, ApplicationPermissions, BlockHeight, SendMessageRequest, Timestamp},
+    data_types::{
+        Amount, ApplicationPermissions, BlockHeight, Bytecode, SendMessageRequest, Timestamp,
+    },
     http,
-    identifiers::{Account, AccountOwner, ApplicationId, ChainId, MessageId, StreamName},
+    identifiers::{Account, AccountOwner, ApplicationId, BlobId, ChainId, MessageId, StreamName},
     ownership::{ChainOwnership, ChangeApplicationPermissionsError, CloseChainError},
     vm::VmRuntime,
 };
@@ -531,6 +533,29 @@ where
             .map_err(|error| RuntimeError::Custom(error.into()))
     }
 
+    /// Creates a new data blob and returns its ID.
+    fn create_data_blob(caller: &mut Caller, bytes: Vec<u8>) -> Result<BlobId, RuntimeError> {
+        caller
+            .user_data_mut()
+            .runtime
+            .create_data_blob(bytes)
+            .map_err(|error| RuntimeError::Custom(error.into()))
+    }
+
+    /// Publishes a module with contract and service bytecode and returns the module ID.
+    fn publish_module(
+        caller: &mut Caller,
+        contract: Bytecode,
+        service: Bytecode,
+        vm_runtime: VmRuntime,
+    ) -> Result<ModuleId, RuntimeError> {
+        caller
+            .user_data_mut()
+            .runtime
+            .publish_module(contract, service, vm_runtime)
+            .map_err(|error| RuntimeError::Custom(error.into()))
+    }
+
     /// Calls another application.
     fn try_call_application(
         caller: &mut Caller,