wip

clippy.toml

@@ -1,2 +1,2 @@
 stack-size-threshold = 200000
-future-size-threshold = 10000
+future-size-threshold = 5000

linera-chain/src/unit_tests/chain_tests.rs

@@ -1,6 +1,8 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+#![allow(clippy::large_futures)]
+
 use std::{iter, sync::Arc};
 
 use assert_matches::assert_matches;

linera-core/src/chain_worker/state.rs

@@ -189,9 +189,7 @@ where
         let local_time = self.storage.clock().current_time();
         let signer = block.authenticated_signer;
 
-        let executed_block = self
-            .chain
-            .execute_block(&block, local_time, None)
+        let executed_block = Box::pin(self.chain.execute_block(&block, local_time, None))
             .await?
             .with(block);
 
@@ -344,10 +342,11 @@ where
         );
         self.storage.clock().sleep_until(block.timestamp).await;
         let local_time = self.storage.clock().current_time();
-        let outcome = self
-            .chain
-            .execute_block(block, local_time, oracle_records.clone())
-            .await?;
+        let outcome = Box::pin(
+            self.chain
+                .execute_block(block, local_time, oracle_records.clone()),
+        )
+        .await?;
         if let Some(lite_certificate) = &validated_block_certificate {
             let value = HashedCertificateValue::new_validated(outcome.clone().with(block.clone()));
             lite_certificate
@@ -534,10 +533,12 @@ where
         // Execute the block and update inboxes.
         self.chain.remove_events_from_inboxes(block).await?;
         let local_time = self.storage.clock().current_time();
-        let verified_outcome = self
-            .chain
-            .execute_block(block, local_time, Some(oracle_records.clone()))
-            .await?;
+        let verified_outcome = Box::pin(self.chain.execute_block(
+            block,
+            local_time,
+            Some(oracle_records.clone()),
+        ))
+        .await?;
         // We should always agree on the messages and state hash.
         ensure!(
             *messages == verified_outcome.messages,

linera-core/src/unit_tests/worker_tests.rs

@@ -2,6 +2,8 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+#![allow(clippy::large_futures)]
+
 #[path = "./wasm_worker_tests.rs"]
 mod wasm;
 
@@ -157,7 +159,7 @@ async fn make_simple_transfer_certificate<S>(
     worker: &WorkerState<S>,
     previous_confirmed_block: Option<&Certificate>,
 ) -> Certificate {
-    make_transfer_certificate_for_epoch(
+    Box::pin(make_transfer_certificate_for_epoch(
         chain_description,
         key_pair,
         None,
@@ -170,7 +172,7 @@ async fn make_simple_transfer_certificate<S>(
         BTreeMap::new(),
         worker,
         previous_confirmed_block,
-    )
+    ))
     .await
 }
 

linera-explorer/src/lib.rs

@@ -680,7 +680,7 @@ pub async fn route(app: JsValue, path: JsValue, args: JsValue) {
     let msg = format!("route: {} {:?}", path.as_deref().unwrap_or("none"), args);
     log_str(&msg);
     let data = from_value::<Data>(app.clone()).expect("cannot parse Vue data");
-    route_aux(&app, &data, &path, &args, false).await
+    Box::pin(route_aux(&app, &data, &path, &args, false)).await
 }
 
 #[wasm_bindgen]
@@ -745,7 +745,8 @@ async fn subscribe_chain(app: &JsValue, address: &str, chain: ChainId) {
                                 from_value::<Data>(app.clone()).expect("cannot parse vue data");
                             if let Reason::NewBlock { .. } = message_data.notifications.reason {
                                 if message_data.notifications.chain_id == chain {
-                                    route_aux(&app, &data, &None, &Vec::new(), false).await
+                                    Box::pin(route_aux(&app, &data, &None, &Vec::new(), false))
+                                        .await
                                 }
                             }
                         }
@@ -772,13 +773,13 @@ pub async fn start(app: JsValue) {
     let default_chain = chains(&app, &address).await;
     match default_chain {
         Err(e) => {
-            route_aux(
+            Box::pin(route_aux(
                 &app,
                 &data,
                 &Some("error".to_string()),
                 &[("msg".to_string(), e.to_string())],
                 true,
-            )
+            ))
             .await
         }
         Ok(default_chain) => {
@@ -818,7 +819,7 @@ pub async fn start(app: JsValue) {
                     _ => None,
                 },
             };
-            route_aux(&app, &data, &path, &args, true).await;
+            Box::pin(route_aux(&app, &data, &path, &args, true)).await;
         }
     }
 }

linera-sdk/src/test/validator.rs

@@ -122,8 +122,12 @@ impl TestValidator {
         Parameters: Serialize,
         InstantiationArgument: Serialize,
     {
-        let (validator, bytecode_id) =
-            TestValidator::with_current_bytecode::<Abi, Parameters, InstantiationArgument>().await;
+        let (validator, bytecode_id) = Box::pin(TestValidator::with_current_bytecode::<
+            Abi,
+            Parameters,
+            InstantiationArgument,
+        >())
+        .await;
 
         let mut creator = validator.new_chain().await;
 

linera-service/src/linera/client_options.rs

@@ -131,14 +131,14 @@ impl ClientOptions {
 
     pub async fn run_command_with_storage(self) -> anyhow::Result<()> {
         let wallet = self.wallet()?;
-        run_with_storage(
+        Box::pin(run_with_storage(
             self.storage_config()?
                 .add_common_config(self.common_config())
                 .await?,
             &wallet.inner().genesis_config().clone(),
             self.wasm_runtime.with_wasm_default(),
             Job(self, wallet),
-        )
+        ))
         .await?;
         Ok(())
     }

linera-service/src/linera/main.rs

@@ -1337,7 +1337,9 @@ async fn run(options: ClientOptions) -> anyhow::Result<()> {
                 let project = Project::from_existing_project(path)?;
                 Ok(project.test().await?)
             }
-            ProjectCommand::PublishAndCreate { .. } => options.run_command_with_storage().await,
+            ProjectCommand::PublishAndCreate { .. } => {
+                Box::pin(options.run_command_with_storage()).await
+            }
         },
 
         ClientCommand::Keygen => {
@@ -1485,12 +1487,12 @@ Make sure to use a Linera client compatible with this network.
                         faucet.is_some(),
                         "Using --with-new-chain requires --faucet to be set"
                     );
-                    options.run_command_with_storage().await?;
+                    Box::pin(options.run_command_with_storage()).await?;
                 }
                 Ok(())
             }
         },
 
-        _ => options.run_command_with_storage().await,
+        _ => Box::pin(options.run_command_with_storage()).await,
     }
 }

linera-service/src/proxy.rs

@@ -335,12 +335,12 @@ impl ProxyOptions {
         let full_storage_config = self.storage_config.add_common_config(common_config).await?;
         let genesis_config = GenesisConfig::read(&self.genesis_config_path)
             .expect("Fail to read initial chain config");
-        run_with_storage(
+        Box::pin(run_with_storage(
             full_storage_config,
             &genesis_config,
             None,
             ProxyContext::from_options(self)?,
-        )
+        ))
         .await
     }
 }

linera-service/src/server.rs

@@ -465,9 +465,14 @@ async fn run(options: ServerOptions) {
                 .add_common_config(common_config)
                 .await
                 .unwrap();
-            run_with_storage(full_storage_config, &genesis_config, wasm_runtime, job)
-                .await
-                .unwrap();
+            Box::pin(run_with_storage(
+                full_storage_config,
+                &genesis_config,
+                wasm_runtime,
+                job,
+            ))
+            .await
+            .unwrap();
         }
 
         ServerCommand::Generate {

linera-service/src/unit_tests/chain_listener.rs

@@ -1,6 +1,8 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+#![allow(clippy::large_futures)]
+
 use std::{collections::BTreeMap, sync::Arc};
 
 use async_trait::async_trait;