Insertion of the has_non_trivial_storage code.

Author: MathieuDutSik

linera-execution/src/execution_state_actor.rs

@@ -659,6 +659,21 @@ where
                     .to_round()?;
                 callback.respond(validation_round);
             }
+
+            HasNonTrivialStorage {
+                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),
+                };
+                callback.respond(result);
+            }
         }
 
         Ok(())
@@ -1206,4 +1221,10 @@ pub enum ExecutionRequest {
         #[debug(skip)]
         callback: Sender<Option<u32>>,
     },
+
+    HasNonTrivialStorage {
+        application: ApplicationId,
+        #[debug(skip)]
+        callback: Sender<(u32, u32)>,
+    },
 }

linera-execution/src/lib.rs

@@ -668,6 +668,12 @@ pub trait BaseRuntime {
 
     /// Asserts the existence of a data blob with the given hash.
     fn assert_data_blob_exists(&mut self, hash: DataBlobHash) -> Result<(), ExecutionError>;
+
+    /// Returns true if the corresponding contract uses a non-zero amount of storage.
+    fn has_non_trivial_storage(
+        &mut self,
+        application: ApplicationId,
+    ) -> Result<bool, ExecutionError>;
 }
 
 pub trait ServiceRuntime: BaseRuntime {

linera-execution/src/runtime.rs

@@ -897,6 +897,21 @@ where
             .send_request(|callback| ExecutionRequest::AssertBlobExists { blob_id, callback })?
             .recv_response()
     }
+
+    fn has_non_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::HasNonTrivialStorage {
+                application,
+                callback,
+            })?
+            .recv_response()?;
+        Ok(key_size > 0 || value_size > 0)
+    }
 }
 
 /// An extension trait to determine in compile time the different behaviors between contract and

linera-execution/src/wasm/runtime_api.rs

@@ -231,6 +231,18 @@ where
             .map_err(|error| RuntimeError::Custom(error.into()))
     }
 
+    /// Returns true if the corresponding contract uses a non-zero amount of storage.
+    fn has_non_trivial_storage(
+        caller: &mut Caller,
+        application: ApplicationId,
+    ) -> Result<bool, RuntimeError> {
+        caller
+            .user_data_mut()
+            .runtime
+            .has_non_trivial_storage(application)
+            .map_err(|error| RuntimeError::Custom(error.into()))
+    }
+
     /// Logs a `message` with the provided information `level`.
     fn log(_caller: &mut Caller, message: String, level: log::Level) -> Result<(), RuntimeError> {
         match level {

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 non-zero amount of storage.
+    pub fn has_non_trivial_storage(&mut self, application: ApplicationId) -> bool {
+        base_wit::has_non_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_non_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_non_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_non_trivial_storage` call, and the response it should return in the test.
+    pub fn add_expected_has_non_trivial_storage_requests(
+        &mut self,
+        application: ApplicationId,
+        response: bool,
+    ) {
+        self.expected_has_non_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 non-zero amount of storage.
+    pub fn has_non_trivial_storage(&mut self, application: ApplicationId) -> bool {
+        let maybe_request = self.expected_has_non_trivial_storage_requests.pop_front();
+        let (expected_application_id, response) =
+            maybe_request.expect("Unexpected has_non_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

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

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

@@ -16,6 +16,7 @@ interface base-runtime-api {
     assert-before: func(timestamp: timestamp);
     read-data-blob: func(hash: data-blob-hash) -> list<u8>;
     assert-data-blob-exists: func(hash: data-blob-hash);
+    has-non-trivial-storage: func(application: application-id) -> bool;
     log: func(message: string, level: log-level);
     contains-key-new: func(key: list<u8>) -> u32;
     contains-key-wait: func(promise-id: u32) -> bool;