Implement a function has_trivial_storage in BaseRuntime.

linera-execution/src/execution_state_actor.rs

@@ -659,6 +659,22 @@ where
                     .to_round()?;
                 callback.respond(validation_round);
             }
+
+            TotalStorageSize {
+                application,
+                callback,
+            } => {
+                let view = self.state.users.try_load_entry(&application).await?;
+                let result = match view {
+                    Some(view) => {
+                        let total_size = view.total_size();
+                        (total_size.key, total_size.value)
+                    }
+                    None => (0, 0),
+                };
+                tracing::info!("TotalStorageSize, result={result:?}");
+                callback.respond(result);
+            }
         }
 
         Ok(())
@@ -1206,4 +1222,10 @@ pub enum ExecutionRequest {
         #[debug(skip)]
         callback: Sender<Option<u32>>,
     },
+
+    TotalStorageSize {
+        application: ApplicationId,
+        #[debug(skip)]
+        callback: Sender<(u32, u32)>,
+    },
 }

linera-execution/src/lib.rs

@@ -663,9 +663,10 @@
 
     /// Reads a data blob specified by a given hash.
     fn read_data_blob(&mut self, hash: DataBlobHash) -> Result<Vec<u8>, ExecutionError>;
 
     /// Asserts the existence of a data blob with the given hash.
     fn assert_data_blob_exists(&mut self, hash: DataBlobHash) -> Result<(), ExecutionError>;
+
 }
 
 pub trait ServiceRuntime: BaseRuntime {
@@ -813,6 +814,9 @@
 
     /// Writes a batch of changes.
     fn write_batch(&mut self, batch: Batch) -> Result<(), ExecutionError>;
+
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    fn has_trivial_storage(&mut self, application: ApplicationId) -> Result<bool, ExecutionError>;
 }
 
 /// An operation to be executed in a block.

linera-execution/src/runtime.rs

@@ -894,9 +894,10 @@
         let this = self.inner();
         let blob_id = hash.into();
         this.execution_state_sender
             .send_request(|callback| ExecutionRequest::AssertBlobExists { blob_id, callback })?
             .recv_response()
     }
+
 }
 
 /// An extension trait to determine in compile time the different behaviors between contract and
@@ -1535,6 +1536,18 @@
             .recv_response()?;
         Ok(())
     }
+
+    fn has_trivial_storage(&mut self, application: ApplicationId) -> Result<bool, ExecutionError> {
+        let this = self.inner();
+        let (key_size, value_size) = this
+            .execution_state_sender
+            .send_request(move |callback| ExecutionRequest::TotalStorageSize {
+                application,
+                callback,
+            })?
+            .recv_response()?;
+        Ok(key_size + value_size == 0)
+    }
 }
 
 impl ServiceSyncRuntime {

linera-execution/src/wasm/runtime_api.rs

@@ -669,6 +669,18 @@ where
             .write_batch(Batch { operations })
             .map_err(|error| RuntimeError::Custom(error.into()))
     }
+
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    fn has_trivial_storage(
+        caller: &mut Caller,
+        application: ApplicationId,
+    ) -> Result<bool, RuntimeError> {
+        caller
+            .user_data_mut()
+            .runtime
+            .has_trivial_storage(application)
+            .map_err(|error| RuntimeError::Custom(error.into()))
+    }
 }
 
 /// An implementation of the system API made available to services.

linera-sdk/src/contract/runtime.rs

@@ -164,6 +164,11 @@ where
     pub fn assert_data_blob_exists(&mut self, hash: DataBlobHash) {
         base_wit::assert_data_blob_exists(hash.into())
     }
+
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    pub fn has_trivial_storage(&mut self, application: ApplicationId) -> bool {
+        contract_wit::has_trivial_storage(application.into())
+    }
 }
 
 impl<Application> ContractRuntime<Application>

linera-sdk/src/contract/test_runtime.rs

@@ -78,6 +78,7 @@ where
     expected_http_requests: VecDeque<(http::Request, http::Response)>,
     expected_read_data_blob_requests: VecDeque<(DataBlobHash, Vec<u8>)>,
     expected_assert_data_blob_exists_requests: VecDeque<(DataBlobHash, Option<()>)>,
+    expected_has_trivial_storage_requests: VecDeque<(ApplicationId, bool)>,
     expected_open_chain_calls: VecDeque<(ChainOwnership, ApplicationPermissions, Amount, ChainId)>,
     expected_publish_module_calls: VecDeque<ExpectedPublishModuleCall>,
     expected_create_application_calls: VecDeque<ExpectedCreateApplicationCall>,
@@ -127,6 +128,7 @@ where
             expected_http_requests: VecDeque::new(),
             expected_read_data_blob_requests: VecDeque::new(),
             expected_assert_data_blob_exists_requests: VecDeque::new(),
+            expected_has_trivial_storage_requests: VecDeque::new(),
             expected_open_chain_calls: VecDeque::new(),
             expected_publish_module_calls: VecDeque::new(),
             expected_create_application_calls: VecDeque::new(),
@@ -936,6 +938,16 @@ where
             .push_back((hash, response));
     }
 
+    /// Adds an expected `has_trivial_storage` call, and the response it should return in the test.
+    pub fn add_expected_has_trivial_storage_requests(
+        &mut self,
+        application: ApplicationId,
+        response: bool,
+    ) {
+        self.expected_has_trivial_storage_requests
+            .push_back((application, response));
+    }
+
     /// Queries an application service as an oracle and returns the response.
     ///
     /// Should only be used with queries where it is very likely that all validators will compute
@@ -997,6 +1009,15 @@ where
         response.expect("Blob does not exist!");
     }
 
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    pub fn has_trivial_storage(&mut self, application: ApplicationId) -> bool {
+        let maybe_request = self.expected_has_trivial_storage_requests.pop_front();
+        let (expected_application_id, response) =
+            maybe_request.expect("Unexpected has_trivial_storage request");
+        assert_eq!(application, expected_application_id);
+        response
+    }
+
     /// Returns the round in which this block was validated.
     pub fn validation_round(&mut self) -> Option<u32> {
         self.round

linera-sdk/src/service/runtime.rs

@@ -156,9 +156,10 @@
     }
 
     /// Asserts that a data blob with the given hash exists in storage.
     pub fn assert_data_blob_exists(&self, hash: DataBlobHash) {
         base_wit::assert_data_blob_exists(hash.into())
     }
+
 }
 
 impl<Application> ServiceRuntime<Application>

linera-sdk/wit/contract-runtime-api.wit

@@ -23,6 +23,7 @@ interface contract-runtime-api {
     consume-fuel: func(fuel: u64);
     validation-round: func() -> option<u32>;
     write-batch: func(operations: list<write-operation>);
+    has-trivial-storage: func(application: application-id) -> bool;
 
     record account {
         chain-id: chain-id,

linera-views/src/views/key_value_store_view.rs

@@ -393,11 +393,12 @@
     /// # tokio_test::block_on(async {
     /// # use linera_views::context::MemoryContext;
     /// # use linera_views::key_value_store_view::{KeyValueStoreView, SizeData};
     /// # use linera_views::views::View;
     /// # let context = MemoryContext::new_for_testing(());
     /// let mut view = KeyValueStoreView::load(context).await.unwrap();
+    /// view.insert(vec![0, 1], vec![0,1,2,3,4]).await.unwrap();
     /// let total_size = view.total_size();
-    /// assert_eq!(total_size, SizeData::default());
+    /// assert_eq!(total_size, SizeData { key: 2, value: 5});
     /// # })
     /// ```
     pub fn total_size(&self) -> SizeData {