Introduce the VmRuntime.

linera-base/src/data_types.rs

@@ -32,8 +32,8 @@ use crate::{
     crypto::{BcsHashable, CryptoHash},
     doc_scalar, hex_debug, http,
     identifiers::{
-        ApplicationId, BlobId, BlobType, BytecodeId, ChainId, Destination, EventId,
-        GenericApplicationId, MessageId, StreamId, UserApplicationId,
+        ApplicationId, BlobId, BlobType, ChainId, Destination, EventId, GenericApplicationId,
+        StreamId,
     },
     limited_writer::{LimitedWriter, LimitedWriterError},
     time::{Duration, SystemTime},
@@ -782,30 +782,6 @@ pub enum OracleResponse {
 
 impl<'de> BcsHashable<'de> for OracleResponse {}
 
-/// Description of the necessary information to run a user application.
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Hash, Serialize)]
-pub struct UserApplicationDescription {
-    /// The unique ID of the bytecode to use for the application.
-    pub bytecode_id: BytecodeId,
-    /// The unique ID of the application's creation.
-    pub creation: MessageId,
-    /// The parameters of the application.
-    #[serde(with = "serde_bytes")]
-    #[debug(with = "hex_debug")]
-    pub parameters: Vec<u8>,
-    /// Required dependencies.
-    pub required_application_ids: Vec<UserApplicationId>,
-}
-
-impl From<&UserApplicationDescription> for UserApplicationId {
-    fn from(description: &UserApplicationDescription) -> Self {
-        UserApplicationId {
-            bytecode_id: description.bytecode_id,
-            creation: description.creation,
-        }
-    }
-}
-
 /// A WebAssembly module's bytecode.
 #[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub struct Bytecode {
@@ -1156,10 +1132,6 @@ doc_scalar!(
     Blob,
     "A blob of binary data, with its content-addressed blob ID."
 );
-doc_scalar!(
-    UserApplicationDescription,
-    "Description of the necessary information to run a user application"
-);
 
 /// The time it takes to compress a bytecode.
 #[cfg(with_metrics)]

linera-chain/src/chain.rs

@@ -12,9 +12,7 @@ use async_graphql::SimpleObject;
 use futures::stream::{self, StreamExt, TryStreamExt};
 use linera_base::{
     crypto::{CryptoHash, ValidatorPublicKey},
-    data_types::{
-        Amount, ArithmeticError, BlockHeight, OracleResponse, Timestamp, UserApplicationDescription,
-    },
+    data_types::{Amount, ArithmeticError, BlockHeight, OracleResponse, Timestamp},
     ensure,
     identifiers::{
         ChainId, ChannelFullName, Destination, GenericApplicationId, MessageId, Owner,
@@ -28,7 +26,7 @@ use linera_execution::{
     ExecutionOutcome, ExecutionRuntimeContext, ExecutionStateView, Message, MessageContext,
     Operation, OperationContext, Query, QueryContext, QueryOutcome, RawExecutionOutcome,
     RawOutgoingMessage, ResourceController, ResourceTracker, ServiceRuntimeEndpoint,
-    TransactionTracker,
+    TransactionTracker, UserApplicationDescription,
 };
 use linera_views::{
     context::Context,

linera-chain/src/unit_tests/chain_tests.rs

@@ -8,10 +8,7 @@ use std::{collections::BTreeMap, iter};
 use assert_matches::assert_matches;
 use linera_base::{
     crypto::{AccountPublicKey, CryptoHash, ValidatorPublicKey},
-    data_types::{
-        Amount, ApplicationPermissions, Blob, BlockHeight, Bytecode, Timestamp,
-        UserApplicationDescription,
-    },
+    data_types::{Amount, ApplicationPermissions, Blob, BlockHeight, Bytecode, Timestamp},
     hashed::Hashed,
     identifiers::{ApplicationId, BytecodeId, ChainId, MessageId},
     ownership::ChainOwnership,
@@ -22,6 +19,7 @@ use linera_execution::{
     test_utils::{ExpectedCall, MockApplication},
     ExecutionError, ExecutionRuntimeConfig, ExecutionRuntimeContext, Message, MessageKind,
     Operation, ResourceControlPolicy, SystemMessage, SystemOperation, TestExecutionRuntimeContext,
+    UserApplicationDescription, VmRuntime,
 };
 use linera_views::{
     context::{Context as _, MemoryContext},
@@ -66,11 +64,13 @@ fn make_app_description() -> (UserApplicationDescription, Blob, Blob) {
     let service = Bytecode::new(b"service".into());
     let contract_blob = Blob::new_contract_bytecode(contract.compress());
     let service_blob = Blob::new_service_bytecode(service.compress());
+    let vm_runtime = VmRuntime::default();
 
     let bytecode_id = BytecodeId::new(contract_blob.id().hash, service_blob.id().hash);
     (
         UserApplicationDescription {
             bytecode_id,
+            vm_runtime,
             creation: make_admin_message_id(BlockHeight(2)),
             required_application_ids: vec![],
             parameters: vec![],

linera-client/src/client_options.rs

@@ -19,7 +19,7 @@ use linera_base::{
     time::Duration,
 };
 use linera_core::{client::BlanketMessagePolicy, DEFAULT_GRACE_PERIOD};
-use linera_execution::{ResourceControlPolicy, WasmRuntime, WithWasmDefault as _};
+use linera_execution::{ResourceControlPolicy, VmRuntime};
 use linera_views::store::CommonStoreConfig;
 
 #[cfg(feature = "fs")]
@@ -96,10 +96,6 @@ pub struct ClientOptions {
     #[arg(long, default_value = "10")]
     pub max_pending_message_bundles: usize,
 
-    /// The WebAssembly runtime to use.
-    #[arg(long)]
-    pub wasm_runtime: Option<WasmRuntime>,
-
     /// The maximal number of chains loaded in memory at a given time.
     #[arg(long, default_value = "40")]
     pub max_loaded_chains: NonZeroUsize,
@@ -202,7 +198,6 @@ impl ClientOptions {
                 .add_common_config(self.common_config())
                 .await?,
             &genesis_config,
-            self.wasm_runtime.with_wasm_default(),
             job,
         ))
         .await?;
@@ -802,6 +797,10 @@ pub enum ClientCommand {
         /// The bytecode ID of the application to create.
         bytecode_id: BytecodeId,
 
+        /// The virtual machine runtime to use.
+        #[arg(long)]
+        vm_runtime: Option<VmRuntime>,
+
         /// An optional chain ID to host the application. The default chain of the wallet
         /// is used otherwise.
         creator: Option<ChainId>,
@@ -835,6 +834,10 @@ pub enum ClientCommand {
         /// Path to the Wasm file for the application "service" bytecode.
         service: PathBuf,
 
+        /// The virtual machine runtime to use.
+        #[arg(long)]
+        vm_runtime: Option<VmRuntime>,
+
         /// An optional chain ID to publish the bytecode. The default chain of the wallet
         /// is used otherwise.
         publisher: Option<ChainId>,
@@ -1241,6 +1244,10 @@ pub enum ProjectCommand {
         /// is used otherwise.
         publisher: Option<ChainId>,
 
+        /// The virtual machine runtime to use.
+        #[arg(long)]
+        vm_runtime: Option<VmRuntime>,
+
         /// The shared parameters as JSON string.
         #[arg(long)]
         json_parameters: Option<String>,

linera-client/src/storage.rs

@@ -5,7 +5,6 @@ use std::{fmt, str::FromStr};
 
 use async_trait::async_trait;
 use linera_base::identifiers::{BlobId, ChainId};
-use linera_execution::WasmRuntime;
 #[cfg(with_storage)]
 use linera_storage::{list_all_blob_ids, list_all_chain_ids};
 use linera_storage::{DbStorage, Storage};
@@ -637,7 +636,6 @@ pub trait Runnable {
 pub async fn run_with_storage<Job>(
     config: StoreConfig,
     genesis_config: &GenesisConfig,
-    wasm_runtime: Option<WasmRuntime>,
     job: Job,
 ) -> Result<Job::Output, Error>
 where
@@ -647,37 +645,29 @@ where
         StoreConfig::Memory(config, namespace) => {
             let store_config = MemoryStoreConfig::new(config.common_config.max_stream_queries);
             let mut storage =
-                DbStorage::<MemoryStore, _>::new(store_config, &namespace, ROOT_KEY, wasm_runtime)
-                    .await?;
+                DbStorage::<MemoryStore, _>::new(store_config, &namespace, ROOT_KEY).await?;
             genesis_config.initialize_storage(&mut storage).await?;
             Ok(job.run(storage).await)
         }
         #[cfg(feature = "storage-service")]
         StoreConfig::Service(config, namespace) => {
             let storage =
-                DbStorage::<ServiceStoreClient, _>::new(config, &namespace, ROOT_KEY, wasm_runtime)
-                    .await?;
+                DbStorage::<ServiceStoreClient, _>::new(config, &namespace, ROOT_KEY).await?;
             Ok(job.run(storage).await)
         }
         #[cfg(feature = "rocksdb")]
         StoreConfig::RocksDb(config, namespace) => {
-            let storage =
-                DbStorage::<RocksDbStore, _>::new(config, &namespace, ROOT_KEY, wasm_runtime)
-                    .await?;
+            let storage = DbStorage::<RocksDbStore, _>::new(config, &namespace, ROOT_KEY).await?;
             Ok(job.run(storage).await)
         }
         #[cfg(feature = "dynamodb")]
         StoreConfig::DynamoDb(config, namespace) => {
-            let storage =
-                DbStorage::<DynamoDbStore, _>::new(config, &namespace, ROOT_KEY, wasm_runtime)
-                    .await?;
+            let storage = DbStorage::<DynamoDbStore, _>::new(config, &namespace, ROOT_KEY).await?;
             Ok(job.run(storage).await)
         }
         #[cfg(feature = "scylladb")]
         StoreConfig::ScyllaDb(config, namespace) => {
-            let storage =
-                DbStorage::<ScyllaDbStore, _>::new(config, &namespace, ROOT_KEY, wasm_runtime)
-                    .await?;
+            let storage = DbStorage::<ScyllaDbStore, _>::new(config, &namespace, ROOT_KEY).await?;
             Ok(job.run(storage).await)
         }
     }
@@ -694,50 +684,27 @@ pub async fn full_initialize_storage(
         )),
         #[cfg(feature = "storage-service")]
         StoreConfig::Service(config, namespace) => {
-            let wasm_runtime = None;
-            let mut storage = DbStorage::<ServiceStoreClient, _>::initialize(
-                config,
-                &namespace,
-                ROOT_KEY,
-                wasm_runtime,
-            )
-            .await?;
+            let mut storage =
+                DbStorage::<ServiceStoreClient, _>::initialize(config, &namespace, ROOT_KEY)
+                    .await?;
             Ok(genesis_config.initialize_storage(&mut storage).await?)
         }
         #[cfg(feature = "rocksdb")]
         StoreConfig::RocksDb(config, namespace) => {
-            let wasm_runtime = None;
-            let mut storage = DbStorage::<RocksDbStore, _>::initialize(
-                config,
-                &namespace,
-                ROOT_KEY,
-                wasm_runtime,
-            )
-            .await?;
+            let mut storage =
+                DbStorage::<RocksDbStore, _>::initialize(config, &namespace, ROOT_KEY).await?;
             Ok(genesis_config.initialize_storage(&mut storage).await?)
         }
         #[cfg(feature = "dynamodb")]
         StoreConfig::DynamoDb(config, namespace) => {
-            let wasm_runtime = None;
-            let mut storage = DbStorage::<DynamoDbStore, _>::initialize(
-                config,
-                &namespace,
-                ROOT_KEY,
-                wasm_runtime,
-            )
-            .await?;
+            let mut storage =
+                DbStorage::<DynamoDbStore, _>::initialize(config, &namespace, ROOT_KEY).await?;
             Ok(genesis_config.initialize_storage(&mut storage).await?)
         }
         #[cfg(feature = "scylladb")]
         StoreConfig::ScyllaDb(config, namespace) => {
-            let wasm_runtime = None;
-            let mut storage = DbStorage::<ScyllaDbStore, _>::initialize(
-                config,
-                &namespace,
-                ROOT_KEY,
-                wasm_runtime,
-            )
-            .await?;
+            let mut storage =
+                DbStorage::<ScyllaDbStore, _>::initialize(config, &namespace, ROOT_KEY).await?;
             Ok(genesis_config.initialize_storage(&mut storage).await?)
         }
     }

linera-core/src/chain_worker/actor.rs

@@ -12,7 +12,7 @@ use std::{
 use custom_debug_derive::Debug;
 use linera_base::{
     crypto::{CryptoHash, ValidatorPublicKey},
-    data_types::{Blob, BlockHeight, Timestamp, UserApplicationDescription},
+    data_types::{Blob, BlockHeight, Timestamp},
     hashed::Hashed,
     identifiers::{BlobId, ChainId, UserApplicationId},
 };
@@ -22,7 +22,9 @@ use linera_chain::{
     ChainStateView,
 };
 use linera_execution::{
-    committee::Epoch, Query, QueryContext, QueryOutcome, ServiceRuntimeEndpoint, ServiceSyncRuntime,
+    committee::{Epoch, ValidatorName},
+    Query, QueryContext, QueryOutcome, ServiceRuntimeEndpoint, ServiceSyncRuntime,
+    UserApplicationDescription,
 };
 use linera_storage::Storage;
 use tokio::sync::{mpsc, oneshot, OwnedRwLockReadGuard};

linera-core/src/chain_worker/state/mod.rs

@@ -14,7 +14,7 @@ use std::{
 
 use linera_base::{
     crypto::{CryptoHash, ValidatorPublicKey},
-    data_types::{Blob, BlockHeight, UserApplicationDescription},
+    data_types::{Blob, BlockHeight},
     ensure,
     hashed::Hashed,
     identifiers::{BlobId, ChainId, UserApplicationId},
@@ -27,8 +27,9 @@ use linera_chain::{
     ChainError, ChainStateView,
 };
 use linera_execution::{
-    committee::Epoch, Message, Query, QueryContext, QueryOutcome, ServiceRuntimeEndpoint,
-    SystemMessage,
+    committee::{Epoch, ValidatorName},
+    Message, Query, QueryContext, QueryOutcome, ServiceRuntimeEndpoint, SystemMessage,
+    UserApplicationDescription,
 };
 use linera_storage::{Clock as _, Storage};
 use linera_views::views::{ClonableView, ViewError};

linera-core/src/chain_worker/state/temporary_changes.rs

@@ -4,15 +4,15 @@
 //! Operations that don't persist any changes to the chain state.
 
 use linera_base::{
-    data_types::{ArithmeticError, Timestamp, UserApplicationDescription},
+    data_types::{ArithmeticError, Timestamp},
     ensure,
     identifiers::{AccountOwner, ChannelFullName, GenericApplicationId, UserApplicationId},
 };
 use linera_chain::data_types::{
     BlockExecutionOutcome, ExecutedBlock, IncomingBundle, Medium, MessageAction, ProposalContent,
     ProposedBlock,
 };
-use linera_execution::{ChannelSubscription, Query, QueryOutcome};
+use linera_execution::{ChannelSubscription, Query, QueryOutcome, UserApplicationDescription};
 use linera_storage::{Clock as _, Storage};
 use linera_views::views::View;
 #[cfg(with_testing)]

linera-core/src/client/mod.rs

@@ -59,7 +59,7 @@ use linera_execution::{
         CREATE_APPLICATION_MESSAGE_INDEX, OPEN_CHAIN_MESSAGE_INDEX,
     },
     ExecutionError, Operation, Query, QueryOutcome, QueryResponse, SystemExecutionError,
-    SystemQuery, SystemResponse,
+    SystemQuery, SystemResponse, VmRuntime,
 };
 use linera_storage::{Clock as _, Storage};
 use linera_views::views::ViewError;
@@ -2912,6 +2912,7 @@ where
     >(
         &self,
         bytecode_id: BytecodeId<A, Parameters, InstantiationArgument>,
+        vm_runtime: VmRuntime,
         parameters: &Parameters,
         instantiation_argument: &InstantiationArgument,
         required_application_ids: Vec<UserApplicationId>,
@@ -2922,6 +2923,7 @@ where
         Ok(self
             .create_application_untyped(
                 bytecode_id.forget_abi(),
+                vm_runtime,
                 parameters,
                 instantiation_argument,
                 required_application_ids,
@@ -2944,13 +2946,15 @@ where
     pub async fn create_application_untyped(
         &self,
         bytecode_id: BytecodeId,
+        vm_runtime: VmRuntime,
         parameters: Vec<u8>,
         instantiation_argument: Vec<u8>,
         required_application_ids: Vec<UserApplicationId>,
     ) -> Result<ClientOutcome<(UserApplicationId, ConfirmedBlockCertificate)>, ChainClientError>
     {
         self.execute_operation(Operation::System(SystemOperation::CreateApplication {
             bytecode_id,
+            vm_runtime,
             parameters,
             instantiation_argument,
             required_application_ids,