Change the API to return true of the state is trivial.

Author: MathieuDutSik

linera-execution/src/execution_state_actor.rs

@@ -669,7 +669,7 @@ where
                 callback.respond(validation_round);
             }
 
-            HasNonTrivialStorage {
+            TotalStorageSize {
                 application,
                 callback,
             } => {
@@ -681,6 +681,7 @@ where
                     }
                     None => (0, 0),
                 };
+                tracing::info!("TotalStorageSize, result={result:?}");
                 callback.respond(result);
             }
         }
@@ -1231,7 +1232,7 @@ pub enum ExecutionRequest {
         callback: Sender<Option<u32>>,
     },
 
-    HasNonTrivialStorage {
+    TotalStorageSize {
         application: ApplicationId,
         #[debug(skip)]
         callback: Sender<(u32, u32)>,

linera-execution/src/lib.rs

@@ -735,11 +735,8 @@ 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>;
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    fn has_trivial_storage(&mut self, application: ApplicationId) -> Result<bool, ExecutionError>;
 }
 
 pub trait ServiceRuntime: BaseRuntime {

linera-execution/src/runtime.rs

@@ -898,19 +898,16 @@ where
             .recv_response()
     }
 
-    fn has_non_trivial_storage(
-        &mut self,
-        application: ApplicationId,
-    ) -> Result<bool, ExecutionError> {
+    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::HasNonTrivialStorage {
+            .send_request(move |callback| ExecutionRequest::TotalStorageSize {
                 application,
                 callback,
             })?
             .recv_response()?;
-        Ok(key_size > 0 || value_size > 0)
+        Ok(key_size + value_size == 0)
     }
 }
 

linera-execution/src/wasm/runtime_api.rs

@@ -232,14 +232,14 @@ where
     }
 
     /// Returns true if the corresponding contract uses a non-zero amount of storage.
-    fn has_non_trivial_storage(
+    fn has_trivial_storage(
         caller: &mut Caller,
         application: ApplicationId,
     ) -> Result<bool, RuntimeError> {
         caller
             .user_data_mut()
             .runtime
-            .has_non_trivial_storage(application)
+            .has_trivial_storage(application)
             .map_err(|error| RuntimeError::Custom(error.into()))
     }
 

linera-sdk/src/contract/runtime.rs

@@ -166,8 +166,8 @@ where
     }
 
     /// 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())
+    pub fn has_trivial_storage(&mut self, application: ApplicationId) -> bool {
+        base_wit::has_trivial_storage(application.into())
     }
 }
 

linera-sdk/src/contract/test_runtime.rs

@@ -78,7 +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_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>,
@@ -128,7 +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_has_trivial_storage_requests: VecDeque::new(),
             expected_open_chain_calls: VecDeque::new(),
             expected_publish_module_calls: VecDeque::new(),
             expected_create_application_calls: VecDeque::new(),
@@ -938,13 +938,13 @@ 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(
+    /// 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_non_trivial_storage_requests
+        self.expected_has_trivial_storage_requests
             .push_back((application, response));
     }
 
@@ -1009,11 +1009,11 @@ 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();
+    /// 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_non_trivial_storage request");
+            maybe_request.expect("Unexpected has_trivial_storage request");
         assert_eq!(application, expected_application_id);
         response
     }

linera-sdk/src/service/runtime.rs

@@ -160,9 +160,9 @@ where
         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())
+    /// Returns true if the corresponding contract uses a zero amount of storage.
+    pub fn has_trivial_storage(&self, application: ApplicationId) -> bool {
+        base_wit::has_trivial_storage(application.into())
     }
 }
 

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

@@ -16,7 +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;
+    has-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;