diff --git a/flake.lock b/flake.lock
index ea9e1ee7b9fa..90b16421e13a 100644
--- a/flake.lock
+++ b/flake.lock
@@ -127,11 +127,11 @@
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1748399823,
-        "narHash": "sha256-kahD8D5hOXOsGbNdoLLnqCL887cjHkx98Izc37nDjlA=",
+        "lastModified": 1752806774,
+        "narHash": "sha256-4cHeoR2roN7d/3J6gT+l6o7J2hTrBIUiCwVdDNMeXzE=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "d68a69dc71bc19beb3479800392112c2f6218159",
+        "rev": "3c90219b3ba1c9790c45a078eae121de48a39c55",
         "type": "github"
       },
       "original": {
diff --git a/linera-base/src/command.rs b/linera-base/src/command.rs
index dc27140e9d04..f64c2fe38f82 100644
--- a/linera-base/src/command.rs
+++ b/linera-base/src/command.rs
@@ -137,7 +137,7 @@ pub trait CommandExt: std::fmt::Debug {
 
     /// Description used for error reporting.
     fn description(&self) -> String {
-        format!("While executing {:?}", self)
+        format!("While executing {self:?}")
     }
 }
 
diff --git a/linera-base/src/crypto/ed25519.rs b/linera-base/src/crypto/ed25519.rs
index a5b172470533..e79478fe997c 100644
--- a/linera-base/src/crypto/ed25519.rs
+++ b/linera-base/src/crypto/ed25519.rs
@@ -363,7 +363,7 @@ impl Ed25519Signature {
     {
         Ed25519Signature::verify_batch_internal(value, votes).map_err(|error| {
             CryptoError::InvalidSignature {
-                error: format!("batched {}", error),
+                error: format!("batched {error}"),
                 type_name: T::type_name().to_string(),
             }
         })
@@ -411,7 +411,7 @@ impl<'de> Deserialize<'de> for Ed25519Signature {
 impl fmt::Display for Ed25519Signature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = hex::encode(self.0.to_bytes());
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
diff --git a/linera-base/src/crypto/mod.rs b/linera-base/src/crypto/mod.rs
index 4ddddfd2ac3a..8d97451375b3 100644
--- a/linera-base/src/crypto/mod.rs
+++ b/linera-base/src/crypto/mod.rs
@@ -399,7 +399,7 @@ where
     fn write(&self, hasher: &mut Hasher) {
         let name = <Self as HasTypeName>::type_name();
         // Note: This assumes that names never contain the separator `::`.
-        write!(hasher, "{}::", name).expect("Hasher should not fail");
+        write!(hasher, "{name}::").expect("Hasher should not fail");
         bcs::serialize_into(hasher, &self).expect("Message serialization should not fail");
     }
 }
diff --git a/linera-base/src/crypto/secp256k1/evm.rs b/linera-base/src/crypto/secp256k1/evm.rs
index 97a5741ce865..d30300c534c4 100644
--- a/linera-base/src/crypto/secp256k1/evm.rs
+++ b/linera-base/src/crypto/secp256k1/evm.rs
@@ -239,7 +239,7 @@ impl TryFrom<&[u8]> for EvmPublicKey {
 impl fmt::Display for EvmPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let str = hex::encode(self.as_bytes());
-        write!(f, "{}", str)
+        write!(f, "{str}")
     }
 }
 
@@ -553,7 +553,7 @@ impl<'de> Deserialize<'de> for EvmSignature {
 impl fmt::Display for EvmSignature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = hex::encode(self.as_bytes());
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
diff --git a/linera-base/src/crypto/secp256k1/mod.rs b/linera-base/src/crypto/secp256k1/mod.rs
index 867408282c10..bf178674f217 100644
--- a/linera-base/src/crypto/secp256k1/mod.rs
+++ b/linera-base/src/crypto/secp256k1/mod.rs
@@ -184,7 +184,7 @@ impl TryFrom<&[u8]> for Secp256k1PublicKey {
 impl fmt::Display for Secp256k1PublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let str = hex::encode(self.as_bytes());
-        write!(f, "{}", str)
+        write!(f, "{str}")
     }
 }
 
@@ -459,7 +459,7 @@ impl<'de> Deserialize<'de> for Secp256k1Signature {
 impl fmt::Display for Secp256k1Signature {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = hex::encode(self.as_bytes());
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
diff --git a/linera-base/src/data_types.rs b/linera-base/src/data_types.rs
index d5fdf83a2d92..b6061368fa1c 100644
--- a/linera-base/src/data_types.rs
+++ b/linera-base/src/data_types.rs
@@ -615,9 +615,9 @@ impl Display for Round {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Round::Fast => write!(f, "fast round"),
-            Round::MultiLeader(r) => write!(f, "multi-leader round {}", r),
-            Round::SingleLeader(r) => write!(f, "single-leader round {}", r),
-            Round::Validator(r) => write!(f, "validator round {}", r),
+            Round::MultiLeader(r) => write!(f, "multi-leader round {r}"),
+            Round::SingleLeader(r) => write!(f, "single-leader round {r}"),
+            Round::Validator(r) => write!(f, "validator round {r}"),
         }
     }
 }
diff --git a/linera-base/src/identifiers.rs b/linera-base/src/identifiers.rs
index 9d4b97abcf48..9cd4806d0cb9 100644
--- a/linera-base/src/identifiers.rs
+++ b/linera-base/src/identifiers.rs
@@ -205,7 +205,7 @@ impl BlobType {
 
 impl fmt::Display for BlobType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
@@ -213,8 +213,7 @@ impl std::str::FromStr for BlobType {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        serde_json::from_str(&format!("\"{s}\""))
-            .with_context(|| format!("Invalid BlobType: {}", s))
+        serde_json::from_str(&format!("\"{s}\"")).with_context(|| format!("Invalid BlobType: {s}"))
     }
 }
 
@@ -1015,7 +1014,7 @@ impl fmt::Display for AccountOwner {
             AccountOwner::Reserved(value) => {
                 write!(f, "0x{}", hex::encode(&value.to_be_bytes()[..]))?
             }
-            AccountOwner::Address32(value) => write!(f, "0x{}", value)?,
+            AccountOwner::Address32(value) => write!(f, "0x{value}")?,
             AccountOwner::Address20(value) => write!(f, "0x{}", hex::encode(&value[..]))?,
         };
 
diff --git a/linera-base/src/port.rs b/linera-base/src/port.rs
index bb312df48a02..737a18ccd67a 100644
--- a/linera-base/src/port.rs
+++ b/linera-base/src/port.rs
@@ -23,5 +23,5 @@ pub async fn get_free_port() -> Result<u16> {
 /// Provides a local endpoint that is currently available
 pub async fn get_free_endpoint() -> Result<String> {
     let port = get_free_port().await?;
-    Ok(format!("127.0.0.1:{}", port))
+    Ok(format!("127.0.0.1:{port}"))
 }
diff --git a/linera-chain/src/unit_tests/data_types_tests.rs b/linera-chain/src/unit_tests/data_types_tests.rs
index 8216df75f7ff..629b545776d8 100644
--- a/linera-chain/src/unit_tests/data_types_tests.rs
+++ b/linera-chain/src/unit_tests/data_types_tests.rs
@@ -14,7 +14,7 @@ use crate::{
 };
 
 fn dummy_chain_id(index: u32) -> ChainId {
-    ChainId(CryptoHash::test_hash(format!("chain{}", index)))
+    ChainId(CryptoHash::test_hash(format!("chain{index}")))
 }
 
 #[test]
diff --git a/linera-core/src/unit_tests/test_utils.rs b/linera-core/src/unit_tests/test_utils.rs
index 81a863700dbc..8a415d9a0c76 100644
--- a/linera-core/src/unit_tests/test_utils.rs
+++ b/linera-core/src/unit_tests/test_utils.rs
@@ -588,7 +588,7 @@ where
             Ok(certificates) => match ResultReadCertificates::new(certificates, hashes) {
                 ResultReadCertificates::Certificates(certificates) => Ok(certificates),
                 ResultReadCertificates::InvalidHashes(hashes) => {
-                    panic!("Missing certificates: {:?}", hashes)
+                    panic!("Missing certificates: {hashes:?}")
                 }
             },
         };
@@ -802,7 +802,7 @@ where
             let validator_public_key = validator_keypair.public_key;
             let storage = storage_builder.build().await?;
             let state = WorkerState::new(
-                format!("Node {}", i),
+                format!("Node {i}"),
                 Some(validator_keypair.secret_key),
                 storage.clone(),
             )
@@ -999,7 +999,7 @@ where
             self.admin_id(),
             false,
             [chain_id],
-            format!("Client node for {:.8}", chain_id),
+            format!("Client node for {chain_id:.8}"),
             Duration::from_secs(30),
             ChainClientOptions::test_default(),
         ));
diff --git a/linera-ethereum/src/common.rs b/linera-ethereum/src/common.rs
index 6af07502c0b3..7f9467df8226 100644
--- a/linera-ethereum/src/common.rs
+++ b/linera-ethereum/src/common.rs
@@ -102,7 +102,7 @@ pub fn event_name_from_expanded(event_name_expanded: &str) -> String {
 fn parse_entry(entry: B256, ethereum_type: &str) -> Result<EthereumDataType, EthereumServiceError> {
     if ethereum_type == "address" {
         let address = Address::from_word(entry);
-        let address = format!("{:?}", address);
+        let address = format!("{address:?}");
         return Ok(EthereumDataType::Address(address));
     }
     if ethereum_type == "uint256" {
diff --git a/linera-ethereum/src/test_utils/mod.rs b/linera-ethereum/src/test_utils/mod.rs
index 42b2d4b7f526..063593dde3e9 100644
--- a/linera-ethereum/src/test_utils/mod.rs
+++ b/linera-ethereum/src/test_utils/mod.rs
@@ -94,7 +94,7 @@ pub async fn get_anvil() -> anyhow::Result<AnvilTest> {
 impl AnvilTest {
     pub fn get_address(&self, index: usize) -> String {
         let address = self.anvil_instance.addresses()[index];
-        format!("{:?}", address)
+        format!("{address:?}")
     }
 }
 
@@ -111,7 +111,7 @@ impl SimpleTokenContractFunction {
             SimpleTokenContract::deploy(&anvil_test.ethereum_client.provider, initial_supply)
                 .await?;
         let contract_address = simple_token.address();
-        let contract_address = format!("{:?}", contract_address);
+        let contract_address = format!("{contract_address:?}");
         Ok(Self {
             contract_address,
             anvil_test,
@@ -173,7 +173,7 @@ impl EventNumericsContractFunction {
                 .await?;
         // Getting the contract address
         let contract_address = event_numerics.address();
-        let contract_address = format!("{:?}", contract_address);
+        let contract_address = format!("{contract_address:?}");
         Ok(Self {
             contract_address,
             anvil_test,
diff --git a/linera-execution/src/evm/database.rs b/linera-execution/src/evm/database.rs
index 157d3fe36993..3896ce57f69a 100644
--- a/linera-execution/src/evm/database.rs
+++ b/linera-execution/src/evm/database.rs
@@ -353,7 +353,7 @@ where
         // concept in Linera
         let basefee = 0;
         let chain_id = runtime.chain_id()?;
-        let entry = format!("{}{}", chain_id, block_height_linera);
+        let entry = format!("{chain_id}{block_height_linera}");
         // The randomness beacon being used.
         let prevrandao = keccak256(entry.as_bytes());
         // The blob excess gas and price is not relevant to the execution
diff --git a/linera-execution/src/evm/revm.rs b/linera-execution/src/evm/revm.rs
index c874fd474383..3e13790f27d7 100644
--- a/linera-execution/src/evm/revm.rs
+++ b/linera-execution/src/evm/revm.rs
@@ -1333,7 +1333,7 @@ where
                 inspector,
             )
             .map_err(|error| {
-                let error = format!("{:?}", error);
+                let error = format!("{error:?}");
                 EvmExecutionError::TransactCommitError(error)
             })
         }?;
@@ -1486,7 +1486,7 @@ where
                 inspector,
             )
             .map_err(|error| {
-                let error = format!("{:?}", error);
+                let error = format!("{error:?}");
                 EvmExecutionError::TransactCommitError(error)
             })
         }?;
diff --git a/linera-execution/src/test_utils/solidity.rs b/linera-execution/src/test_utils/solidity.rs
index 8ee8881922fb..65b403591485 100644
--- a/linera-execution/src/test_utils/solidity.rs
+++ b/linera-execution/src/test_utils/solidity.rs
@@ -95,7 +95,7 @@ pub fn get_bytecode(source_code: &str, contract_name: &str) -> anyhow::Result<Ve
         ] {
             let test_code_path = path.join(file_name);
             let mut test_code_file = File::create(&test_code_path)?;
-            writeln!(test_code_file, "{}", literal_path)?;
+            writeln!(test_code_file, "{literal_path}")?;
         }
     }
     if source_code.contains("@openzeppelin") {
@@ -111,7 +111,7 @@ pub fn get_bytecode(source_code: &str, contract_name: &str) -> anyhow::Result<Ve
     let file_name = "test_code.sol";
     let test_code_path = path.join(file_name);
     let mut test_code_file = File::create(&test_code_path)?;
-    writeln!(test_code_file, "{}", source_code)?;
+    writeln!(test_code_file, "{source_code}")?;
     get_bytecode_path(path, file_name, contract_name)
 }
 
diff --git a/linera-explorer/src/entrypoint.rs b/linera-explorer/src/entrypoint.rs
index 1eaa15940533..38813f29efce 100644
--- a/linera-explorer/src/entrypoint.rs
+++ b/linera-explorer/src/entrypoint.rs
@@ -41,7 +41,7 @@ fn forge_arg_type(arg: &Value, non_null: bool) -> Option<String> {
                 .iter()
                 .filter_map(|x| {
                     let name = x["name"].as_str().unwrap();
-                    forge_arg_type(&x["type"], false).map(|arg| format!("{}: {}", name, arg))
+                    forge_arg_type(&x["type"], false).map(|arg| format!("{name}: {arg}"))
                 })
                 .collect::<Vec<_>>();
             Some(format!("{{{}}}", args.join(", ")))
@@ -126,7 +126,7 @@ pub async fn query(app: JsValue, query: JsValue, kind: String) {
     let name = fetch_json["name"].as_str().unwrap();
     let args = fetch_json["args"].as_array().unwrap().to_vec();
     let args = forge_args(args);
-    let input = format!("{}{}", name, args);
+    let input = format!("{name}{args}");
     let response = forge_response(&fetch_json["type"]);
     let body =
         serde_json::json!({ "query": format!("{} {{{} {}}}", kind, input, response) }).to_string();
diff --git a/linera-explorer/src/graphql.rs b/linera-explorer/src/graphql.rs
index 008be3f06c85..0a767550b09f 100644
--- a/linera-explorer/src/graphql.rs
+++ b/linera-explorer/src/graphql.rs
@@ -36,7 +36,7 @@ pub async fn introspection(url: &str) -> Result<Value> {
            ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType {kind name} } } } } } } }";
     let res = client
         .post(url)
-        .body(format!("{{\"query\":\"{}\"}}", graphql_query))
+        .body(format!("{{\"query\":\"{graphql_query}\"}}"))
         .send()
         .await?
         .text()
diff --git a/linera-explorer/src/js_utils.rs b/linera-explorer/src/js_utils.rs
index a07f166692ba..50879e546ab8 100644
--- a/linera-explorer/src/js_utils.rs
+++ b/linera-explorer/src/js_utils.rs
@@ -11,12 +11,12 @@ pub const SER: Serializer =
 
 pub fn setf(target: &JsValue, field: &str, value: &JsValue) {
     js_sys::Reflect::set(target, &JsValue::from_str(field), value)
-        .unwrap_or_else(|_| panic!("failed to set JS field '{}'", field));
+        .unwrap_or_else(|_| panic!("failed to set JS field '{field}'"));
 }
 
 pub fn getf(target: &JsValue, field: &str) -> JsValue {
     js_sys::Reflect::get(target, &JsValue::from_str(field))
-        .unwrap_or_else(|_| panic!("failed to get JS field '{}'", field))
+        .unwrap_or_else(|_| panic!("failed to get JS field '{field}'"))
 }
 
 pub fn log(x: &JsValue) {
diff --git a/linera-explorer/src/lib.rs b/linera-explorer/src/lib.rs
index 17eccb444752..36c11f410cfc 100644
--- a/linera-explorer/src/lib.rs
+++ b/linera-explorer/src/lib.rs
@@ -167,7 +167,7 @@ fn url(config: &Config, protocol: Protocol, kind: AddressKind) -> String {
         AddressKind::Node => &config.node,
         AddressKind::Indexer => &config.indexer,
     };
-    format!("{}{}://{}", protocol, tls, address)
+    format!("{protocol}{tls}://{address}")
 }
 
 async fn get_chain(node: &str, chain_id: ChainId) -> Result<Box<Chain>> {
@@ -214,7 +214,7 @@ async fn get_applications(node: &str, chain_id: ChainId) -> Result<Vec<Applicati
 
 async fn get_operations(indexer: &str, chain_id: ChainId) -> Result<Vec<Operations>> {
     let client = reqwest_client();
-    let operations_indexer = format!("{}/operations", indexer);
+    let operations_indexer = format!("{indexer}/operations");
     let variables = operations::Variables {
         from: OperationsKeyKind::Last(chain_id),
         limit: None,
@@ -242,7 +242,7 @@ async fn home(node: &str, chain_id: ChainId) -> Result<(Page, String)> {
             blocks,
             apps,
         },
-        format!("/?chain={}", chain_id),
+        format!("/?chain={chain_id}"),
     ))
 }
 
@@ -255,7 +255,7 @@ async fn blocks(
 ) -> Result<(Page, String)> {
     // TODO: limit is not used in the UI, it should be implemented with some path arguments and select input
     let blocks = get_blocks(node, chain_id, from, limit).await?;
-    Ok((Page::Blocks(blocks), format!("/blocks?chain={}", chain_id)))
+    Ok((Page::Blocks(blocks), format!("/blocks?chain={chain_id}")))
 }
 
 /// Returns the block page.
@@ -269,7 +269,7 @@ async fn block(node: &str, chain_id: ChainId, hash: Option<CryptoHash>) -> Resul
     let hash = block.hash;
     Ok((
         Page::Block(Box::new(block)),
-        format!("/block/{}?chain={}", hash, chain_id),
+        format!("/block/{hash}?chain={chain_id}"),
     ))
 }
 
@@ -307,7 +307,7 @@ async fn applications(node: &str, chain_id: ChainId) -> Result<(Page, String)> {
     let applications = get_applications(node, chain_id).await?;
     Ok((
         Page::Applications(applications),
-        format!("/applications?chain={}", chain_id),
+        format!("/applications?chain={chain_id}"),
     ))
 }
 
@@ -316,7 +316,7 @@ async fn operations(indexer: &str, chain_id: ChainId) -> Result<(Page, String)>
     let operations = get_operations(indexer, chain_id).await?;
     Ok((
         Page::Operations(operations),
-        format!("/operations?chain={}", chain_id),
+        format!("/operations?chain={chain_id}"),
     ))
 }
 
@@ -327,7 +327,7 @@ async fn operation(
     chain_id: ChainId,
 ) -> Result<(Page, String)> {
     let client = reqwest_client();
-    let operations_indexer = format!("{}/operations", indexer);
+    let operations_indexer = format!("{indexer}/operations");
     let key = match key {
         Some(key) => OperationKeyKind::Key(key),
         None => OperationKeyKind::Last(chain_id),
@@ -469,7 +469,7 @@ async fn application(app: Application) -> Result<(Page, String)> {
 
 /// Returns the plugin page.
 async fn plugin(plugin: &str, indexer: &str) -> Result<(Page, String)> {
-    let link = format!("{}/{}", indexer, plugin);
+    let link = format!("{indexer}/{plugin}");
     let schema = graphql::introspection(&link).await?;
     let sch = &schema["data"]["__schema"];
     let types = sch["types"]
@@ -479,7 +479,7 @@ async fn plugin(plugin: &str, indexer: &str) -> Result<(Page, String)> {
     let queries =
         list_entrypoints(&types, &sch["queryType"]["name"]).unwrap_or(Value::Array(Vec::new()));
     let queries = fill_type(&queries, &types);
-    let pathname = format!("/plugin?plugin={}", plugin);
+    let pathname = format!("/plugin?plugin={plugin}");
     Ok((
         Page::Plugin {
             name: plugin.to_string(),
@@ -685,7 +685,7 @@ pub async fn route(app: JsValue, path: JsValue, args: JsValue) {
 #[wasm_bindgen]
 pub fn short_crypto_hash(s: String) -> String {
     let hash = CryptoHash::from_str(&s).expect("not a crypto hash");
-    format!("{:?}", hash)
+    format!("{hash:?}")
 }
 
 #[wasm_bindgen]
@@ -705,12 +705,10 @@ fn set_onpopstate(app: JsValue) {
 
 /// Subscribes to notifications for one chain
 async fn subscribe_chain(app: &JsValue, address: &str, chain: ChainId) {
-    let (ws, mut wsio) = WsMeta::connect(
-        &format!("{}/ws", address),
-        Some(vec!["graphql-transport-ws"]),
-    )
-    .await
-    .expect("cannot connect to websocket");
+    let (ws, mut wsio) =
+        WsMeta::connect(&format!("{address}/ws"), Some(vec!["graphql-transport-ws"]))
+            .await
+            .expect("cannot connect to websocket");
     wsio.send(WsMessage::Text(
         "{\"type\": \"connection_init\", \"payload\": {}}".to_string(),
     ))
@@ -718,13 +716,9 @@ async fn subscribe_chain(app: &JsValue, address: &str, chain: ChainId) {
     .expect("cannot send to websocket");
     wsio.next().await;
     let uuid = Uuid::new_v3(&Uuid::NAMESPACE_DNS, b"linera.dev");
-    let payload_query = format!(
-        r#"subscription {{ notifications(chainId: \"{}\") }}"#,
-        chain
-    );
+    let payload_query = format!(r#"subscription {{ notifications(chainId: \"{chain}\") }}"#);
     let query = format!(
-        r#"{{ "id": "{}", "type": "subscribe", "payload": {{"query": "{}"}} }}"#,
-        uuid, payload_query
+        r#"{{ "id": "{uuid}", "type": "subscribe", "payload": {{"query": "{payload_query}"}} }}"#
     );
     wsio.send(WsMessage::Text(query))
         .await
@@ -807,7 +801,7 @@ pub async fn start(app: JsValue) {
                         Some("block".to_string())
                     }
                     (_, Some(app_id)) => {
-                        let link = format!("{}/applications/{}", address, app_id);
+                        let link = format!("{address}/applications/{app_id}");
                         let app =
                             serde_json::json!({"id": app_id, "link": link, "description": ""})
                                 .to_string();
diff --git a/linera-rpc/src/simple/transport.rs b/linera-rpc/src/simple/transport.rs
index 55ca2cf29ed7..be8de0367120 100644
--- a/linera-rpc/src/simple/transport.rs
+++ b/linera-rpc/src/simple/transport.rs
@@ -383,7 +383,7 @@ where
     ) -> Result<(), std::io::Error> {
         let listener = TcpListener::bind(address).await?;
 
-        let mut accept_stream = stream::try_unfold(listener, |listener| async move {
+        let accept_stream = stream::try_unfold(listener, |listener| async move {
             let (socket, _) = listener.accept().await?;
             Ok::<_, io::Error>(Some((socket, listener)))
         });
diff --git a/linera-sdk-derive/src/lib.rs b/linera-sdk-derive/src/lib.rs
index 6516c1905fe7..9e9956544bad 100644
--- a/linera-sdk-derive/src/lib.rs
+++ b/linera-sdk-derive/src/lib.rs
@@ -135,7 +135,7 @@ pub mod tests {
 
     fn assert_eq_no_whitespace(mut actual: String, mut expected: String) {
         // Intentionally left here for debugging purposes
-        println!("{}", actual);
+        println!("{actual}");
 
         actual.retain(|c| !c.is_whitespace());
         expected.retain(|c| !c.is_whitespace());
diff --git a/linera-sdk-derive/src/utils.rs b/linera-sdk-derive/src/utils.rs
index d8b62bf7c45b..9336ee36eccf 100644
--- a/linera-sdk-derive/src/utils.rs
+++ b/linera-sdk-derive/src/utils.rs
@@ -11,7 +11,7 @@ pub fn snakify(ident: &Ident) -> Ident {
 
 /// Extends an identifier with a suffix.
 pub fn concat(ident: &Ident, suffix: &str) -> Ident {
-    transform_non_keyword_ident(ident, |s: String| format!("{}{}", s, suffix))
+    transform_non_keyword_ident(ident, |s: String| format!("{s}{suffix}"))
 }
 
 /// Applies a string transformation (`transform`) to the input `Ident`.
diff --git a/linera-sdk/src/util.rs b/linera-sdk/src/util.rs
index f982fc9972f1..3b7238011ecc 100644
--- a/linera-sdk/src/util.rs
+++ b/linera-sdk/src/util.rs
@@ -58,7 +58,7 @@ where
 {
     type Output = AnyFuture::Output;
 
-    fn blocking_wait(mut self) -> Self::Output {
+    fn blocking_wait(self) -> Self::Output {
         let waker = task::noop_waker();
         let mut task_context = Context::from_waker(&waker);
         let mut future = pin!(self);
diff --git a/linera-storage-service/src/server.rs b/linera-storage-service/src/server.rs
index 9b135808b526..abf6b9db6a68 100644
--- a/linera-storage-service/src/server.rs
+++ b/linera-storage-service/src/server.rs
@@ -70,12 +70,12 @@ impl ServiceStoreServer {
             ServiceStoreServerInternal::Memory(store) => store
                 .read_value_bytes(key)
                 .await
-                .map_err(|e| Status::unknown(format!("Memory error {:?} at read_value_bytes", e))),
+                .map_err(|e| Status::unknown(format!("Memory error {e:?} at read_value_bytes"))),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => store
                 .read_value_bytes(key)
                 .await
-                .map_err(|e| Status::unknown(format!("RocksDB error {:?} at read_value_bytes", e))),
+                .map_err(|e| Status::unknown(format!("RocksDB error {e:?} at read_value_bytes"))),
         }
     }
 
@@ -84,12 +84,12 @@ impl ServiceStoreServer {
             ServiceStoreServerInternal::Memory(store) => store
                 .contains_key(key)
                 .await
-                .map_err(|e| Status::unknown(format!("Memory error {:?} at contains_key", e))),
+                .map_err(|e| Status::unknown(format!("Memory error {e:?} at contains_key"))),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => store
                 .contains_key(key)
                 .await
-                .map_err(|e| Status::unknown(format!("RocksDB error {:?} at contains_key", e))),
+                .map_err(|e| Status::unknown(format!("RocksDB error {e:?} at contains_key"))),
         }
     }
 
@@ -98,12 +98,12 @@ impl ServiceStoreServer {
             ServiceStoreServerInternal::Memory(store) => store
                 .contains_keys(keys)
                 .await
-                .map_err(|e| Status::unknown(format!("Memory error {:?} at contains_keys", e))),
+                .map_err(|e| Status::unknown(format!("Memory error {e:?} at contains_keys"))),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => store
                 .contains_keys(keys)
                 .await
-                .map_err(|e| Status::unknown(format!("RocksDB error {:?} at contains_keys", e))),
+                .map_err(|e| Status::unknown(format!("RocksDB error {e:?} at contains_keys"))),
         }
     }
 
@@ -114,13 +114,13 @@ impl ServiceStoreServer {
         match &self.store {
             ServiceStoreServerInternal::Memory(store) => {
                 store.read_multi_values_bytes(keys).await.map_err(|e| {
-                    Status::unknown(format!("Memory error {:?} at read_multi_values_bytes", e))
+                    Status::unknown(format!("Memory error {e:?} at read_multi_values_bytes"))
                 })
             }
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => {
                 store.read_multi_values_bytes(keys).await.map_err(|e| {
-                    Status::unknown(format!("RocksDB error {:?} at read_multi_values_bytes", e))
+                    Status::unknown(format!("RocksDB error {e:?} at read_multi_values_bytes"))
                 })
             }
         }
@@ -128,15 +128,14 @@ impl ServiceStoreServer {
 
     pub async fn find_keys_by_prefix(&self, key_prefix: &[u8]) -> Result<Vec<Vec<u8>>, Status> {
         match &self.store {
-            ServiceStoreServerInternal::Memory(store) => {
-                store.find_keys_by_prefix(key_prefix).await.map_err(|e| {
-                    Status::unknown(format!("Memory error {:?} at find_keys_by_prefix", e))
-                })
-            }
+            ServiceStoreServerInternal::Memory(store) => store
+                .find_keys_by_prefix(key_prefix)
+                .await
+                .map_err(|e| Status::unknown(format!("Memory error {e:?} at find_keys_by_prefix"))),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => {
                 store.find_keys_by_prefix(key_prefix).await.map_err(|e| {
-                    Status::unknown(format!("RocksDB error {:?} at find_keys_by_prefix", e))
+                    Status::unknown(format!("RocksDB error {e:?} at find_keys_by_prefix"))
                 })
             }
         }
@@ -151,17 +150,14 @@ impl ServiceStoreServer {
                 .find_key_values_by_prefix(key_prefix)
                 .await
                 .map_err(|e| {
-                    Status::unknown(format!("Memory error {:?} at find_key_values_by_prefix", e))
+                    Status::unknown(format!("Memory error {e:?} at find_key_values_by_prefix"))
                 }),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => store
                 .find_key_values_by_prefix(key_prefix)
                 .await
                 .map_err(|e| {
-                    Status::unknown(format!(
-                        "RocksDB error {:?} at find_key_values_by_prefix",
-                        e
-                    ))
+                    Status::unknown(format!("RocksDB error {e:?} at find_key_values_by_prefix"))
                 }),
         }
     }
@@ -171,12 +167,12 @@ impl ServiceStoreServer {
             ServiceStoreServerInternal::Memory(store) => store
                 .write_batch(batch)
                 .await
-                .map_err(|e| Status::unknown(format!("Memory error {:?} at write_batch", e))),
+                .map_err(|e| Status::unknown(format!("Memory error {e:?} at write_batch"))),
             #[cfg(with_rocksdb)]
             ServiceStoreServerInternal::RocksDb(store) => store
                 .write_batch(batch)
                 .await
-                .map_err(|e| Status::unknown(format!("RocksDB error {:?} at write_batch", e))),
+                .map_err(|e| Status::unknown(format!("RocksDB error {e:?} at write_batch"))),
         }
     }
 
@@ -610,7 +606,7 @@ async fn main() {
                         _ => panic!("test-log: RUST_LOG_SPAN_EVENTS must contain filters separated by `,`.\n\t\
                                      For example: `active` or `new,close`\n\t\
                                      Supported filters: new, enter, exit, close, active, full\n\t\
-                                     Got: {}", value),
+                                     Got: {value}"),
                     })
                     .fold(FmtSpan::NONE, |acc, filter| filter | acc)
             }
diff --git a/linera-storage/src/lib.rs b/linera-storage/src/lib.rs
index 2ff6b581da6b..eba5a123ebfe 100644
--- a/linera-storage/src/lib.rs
+++ b/linera-storage/src/lib.rs
@@ -187,7 +187,7 @@ pub trait Storage: Sized {
             let committee_blob = self
                 .read_blob(blob_id)
                 .await?
-                .ok_or_else(|| ViewError::NotFound(format!("blob {}", blob_id)))?;
+                .ok_or_else(|| ViewError::NotFound(format!("blob {blob_id}")))?;
             Ok(bcs::from_bytes(committee_blob.bytes())?)
         };
 
diff --git a/linera-summary/src/github.rs b/linera-summary/src/github.rs
index 5b2326edc14e..9cb4653ce8ab 100644
--- a/linera-summary/src/github.rs
+++ b/linera-summary/src/github.rs
@@ -192,7 +192,7 @@ impl Github {
 
         // Always print the summary to stdout, as we'll use it to set the job summary in CI.
         info!("Printing summary to stdout...");
-        println!("{}", body);
+        println!("{body}");
 
         if let Some(existing_comment_id) = existing_comment_id {
             if self.is_local {
diff --git a/linera-summary/src/performance_summary.rs b/linera-summary/src/performance_summary.rs
index bbb0674a1200..d076db3147f6 100644
--- a/linera-summary/src/performance_summary.rs
+++ b/linera-summary/src/performance_summary.rs
@@ -73,7 +73,7 @@ impl PerformanceSummary {
 
         markdown_content.push_str("### CI Runtime Comparison\n\n");
         for (workflow_name, comparisons) in self.ci_runtime_comparison.0.iter() {
-            markdown_content.push_str(&format!("#### Workflow: {}\n\n", workflow_name));
+            markdown_content.push_str(&format!("#### Workflow: {workflow_name}\n\n"));
             markdown_content
                 .push_str("| Job Name | Base Runtime | PR Runtime | Runtime Difference (%) |\n");
             markdown_content.push_str("| --- | --- | --- | --- |\n");
diff --git a/linera-version/src/version_info/type.rs b/linera-version/src/version_info/type.rs
index 9852e887ffe1..0c14746f54e1 100644
--- a/linera-version/src/version_info/type.rs
+++ b/linera-version/src/version_info/type.rs
@@ -216,7 +216,7 @@ impl VersionInfo {
                     == Some(1);
                 git_outcome.output[..10].to_owned()
             } else {
-                format!("v{}", crate_version)
+                format!("v{crate_version}")
             }
         }
         .into();
diff --git a/linera-views/src/backends/metering.rs b/linera-views/src/backends/metering.rs
index bfd99ff119ff..b5301b39aaf8 100644
--- a/linera-views/src/backends/metering.rs
+++ b/linera-views/src/backends/metering.rs
@@ -94,139 +94,139 @@ impl KeyValueStoreMetrics {
         let var_name = name.replace(' ', "_");
         let title_name = name.to_case(Case::Snake);
 
-        let entry1 = format!("{}_read_value_bytes_latency", var_name);
-        let entry2 = format!("{} read value bytes latency", title_name);
+        let entry1 = format!("{var_name}_read_value_bytes_latency");
+        let entry2 = format!("{title_name} read value bytes latency");
         let read_value_bytes_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_contains_key_latency", var_name);
-        let entry2 = format!("{} contains key latency", title_name);
+        let entry1 = format!("{var_name}_contains_key_latency");
+        let entry2 = format!("{title_name} contains key latency");
         let contains_key_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_contains_keys_latency", var_name);
-        let entry2 = format!("{} contains keys latency", title_name);
+        let entry1 = format!("{var_name}_contains_keys_latency");
+        let entry2 = format!("{title_name} contains keys latency");
         let contains_keys_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_read_multi_value_bytes_latency", var_name);
-        let entry2 = format!("{} read multi value bytes latency", title_name);
+        let entry1 = format!("{var_name}_read_multi_value_bytes_latency");
+        let entry2 = format!("{title_name} read multi value bytes latency");
         let read_multi_values_bytes_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_keys_by_prefix_latency", var_name);
-        let entry2 = format!("{} find keys by prefix latency", title_name);
+        let entry1 = format!("{var_name}_find_keys_by_prefix_latency");
+        let entry2 = format!("{title_name} find keys by prefix latency");
         let find_keys_by_prefix_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_key_values_by_prefix_latency", var_name);
-        let entry2 = format!("{} find key values by prefix latency", title_name);
+        let entry1 = format!("{var_name}_find_key_values_by_prefix_latency");
+        let entry2 = format!("{title_name} find key values by prefix latency");
         let find_key_values_by_prefix_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_write_batch_latency", var_name);
-        let entry2 = format!("{} write batch latency", title_name);
+        let entry1 = format!("{var_name}_write_batch_latency");
+        let entry2 = format!("{title_name} write batch latency");
         let write_batch_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_clear_journal_latency", var_name);
-        let entry2 = format!("{} clear journal latency", title_name);
+        let entry1 = format!("{var_name}_clear_journal_latency");
+        let entry2 = format!("{title_name} clear journal latency");
         let clear_journal_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_connect_latency", var_name);
-        let entry2 = format!("{} connect latency", title_name);
+        let entry1 = format!("{var_name}_connect_latency");
+        let entry2 = format!("{title_name} connect latency");
         let connect_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_open_exclusive_latency", var_name);
-        let entry2 = format!("{} clone with root key latency", title_name);
+        let entry1 = format!("{var_name}_open_exclusive_latency");
+        let entry2 = format!("{title_name} clone with root key latency");
         let open_exclusive_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_list_all_latency", var_name);
-        let entry2 = format!("{} list all latency", title_name);
+        let entry1 = format!("{var_name}_list_all_latency");
+        let entry2 = format!("{title_name} list all latency");
         let list_all_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_list_root_keys_latency", var_name);
-        let entry2 = format!("{} list root keys latency", title_name);
+        let entry1 = format!("{var_name}_list_root_keys_latency");
+        let entry2 = format!("{title_name} list root keys latency");
         let list_root_keys_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_delete_all_latency", var_name);
-        let entry2 = format!("{} delete all latency", title_name);
+        let entry1 = format!("{var_name}_delete_all_latency");
+        let entry2 = format!("{title_name} delete all latency");
         let delete_all_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_exists_latency", var_name);
-        let entry2 = format!("{} exists latency", title_name);
+        let entry1 = format!("{var_name}_exists_latency");
+        let entry2 = format!("{title_name} exists latency");
         let exists_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_create_latency", var_name);
-        let entry2 = format!("{} create latency", title_name);
+        let entry1 = format!("{var_name}_create_latency");
+        let entry2 = format!("{title_name} create latency");
         let create_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_delete_latency", var_name);
-        let entry2 = format!("{} delete latency", title_name);
+        let entry1 = format!("{var_name}_delete_latency");
+        let entry2 = format!("{title_name} delete latency");
         let delete_latency = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_read_value_none_cases", var_name);
-        let entry2 = format!("{} read value none cases", title_name);
+        let entry1 = format!("{var_name}_read_value_none_cases");
+        let entry2 = format!("{title_name} read value none cases");
         let read_value_none_cases = register_int_counter_vec(&entry1, &entry2, &[]);
 
-        let entry1 = format!("{}_read_value_key_size", var_name);
-        let entry2 = format!("{} read value key size", title_name);
+        let entry1 = format!("{var_name}_read_value_key_size");
+        let entry2 = format!("{title_name} read value key size");
         let read_value_key_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_read_value_value_size", var_name);
-        let entry2 = format!("{} read value value size", title_name);
+        let entry1 = format!("{var_name}_read_value_value_size");
+        let entry2 = format!("{title_name} read value value size");
         let read_value_value_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_read_multi_values_num_entries", var_name);
-        let entry2 = format!("{} read multi values num entries", title_name);
+        let entry1 = format!("{var_name}_read_multi_values_num_entries");
+        let entry2 = format!("{title_name} read multi values num entries");
         let read_multi_values_num_entries = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_read_multi_values_key_sizes", var_name);
-        let entry2 = format!("{} read multi values key sizes", title_name);
+        let entry1 = format!("{var_name}_read_multi_values_key_sizes");
+        let entry2 = format!("{title_name} read multi values key sizes");
         let read_multi_values_key_sizes = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_contains_keys_num_entries", var_name);
-        let entry2 = format!("{} contains keys num entries", title_name);
+        let entry1 = format!("{var_name}_contains_keys_num_entries");
+        let entry2 = format!("{title_name} contains keys num entries");
         let contains_keys_num_entries = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_contains_keys_key_sizes", var_name);
-        let entry2 = format!("{} contains keys key sizes", title_name);
+        let entry1 = format!("{var_name}_contains_keys_key_sizes");
+        let entry2 = format!("{title_name} contains keys key sizes");
         let contains_keys_key_sizes = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_contains_key_key_size", var_name);
-        let entry2 = format!("{} contains key key size", title_name);
+        let entry1 = format!("{var_name}_contains_key_key_size");
+        let entry2 = format!("{title_name} contains key key size");
         let contains_key_key_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_keys_by_prefix_prefix_size", var_name);
-        let entry2 = format!("{} find keys by prefix prefix size", title_name);
+        let entry1 = format!("{var_name}_find_keys_by_prefix_prefix_size");
+        let entry2 = format!("{title_name} find keys by prefix prefix size");
         let find_keys_by_prefix_prefix_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_keys_by_prefix_num_keys", var_name);
-        let entry2 = format!("{} find keys by prefix num keys", title_name);
+        let entry1 = format!("{var_name}_find_keys_by_prefix_num_keys");
+        let entry2 = format!("{title_name} find keys by prefix num keys");
         let find_keys_by_prefix_num_keys = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_keys_by_prefix_keys_size", var_name);
-        let entry2 = format!("{} find keys by prefix keys size", title_name);
+        let entry1 = format!("{var_name}_find_keys_by_prefix_keys_size");
+        let entry2 = format!("{title_name} find keys by prefix keys size");
         let find_keys_by_prefix_keys_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_key_values_by_prefix_prefix_size", var_name);
-        let entry2 = format!("{} find key values by prefix prefix size", title_name);
+        let entry1 = format!("{var_name}_find_key_values_by_prefix_prefix_size");
+        let entry2 = format!("{title_name} find key values by prefix prefix size");
         let find_key_values_by_prefix_prefix_size =
             register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_key_values_by_prefix_num_keys", var_name);
-        let entry2 = format!("{} find key values by prefix num keys", title_name);
+        let entry1 = format!("{var_name}_find_key_values_by_prefix_num_keys");
+        let entry2 = format!("{title_name} find key values by prefix num keys");
         let find_key_values_by_prefix_num_keys =
             register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_find_key_values_by_prefix_key_values_size", var_name);
-        let entry2 = format!("{} find key values by prefix key values size", title_name);
+        let entry1 = format!("{var_name}_find_key_values_by_prefix_key_values_size");
+        let entry2 = format!("{title_name} find key values by prefix key values size");
         let find_key_values_by_prefix_key_values_size =
             register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_write_batch_size", var_name);
-        let entry2 = format!("{} write batch size", title_name);
+        let entry1 = format!("{var_name}_write_batch_size");
+        let entry2 = format!("{title_name} write batch size");
         let write_batch_size = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_list_all_sizes", var_name);
-        let entry2 = format!("{} list all sizes", title_name);
+        let entry1 = format!("{var_name}_list_all_sizes");
+        let entry2 = format!("{title_name} list all sizes");
         let list_all_sizes = register_histogram_vec(&entry1, &entry2, &[], None);
 
-        let entry1 = format!("{}_exists_true_cases", var_name);
-        let entry2 = format!("{} exists true cases", title_name);
+        let entry1 = format!("{var_name}_exists_true_cases");
+        let entry2 = format!("{title_name} exists true cases");
         let exists_true_cases = register_int_counter_vec(&entry1, &entry2, &[]);
 
         KeyValueStoreMetrics {
diff --git a/linera-witty/src/wit_generation/mod.rs b/linera-witty/src/wit_generation/mod.rs
index 22382dcac2e1..dc94b2c70fb1 100644
--- a/linera-witty/src/wit_generation/mod.rs
+++ b/linera-witty/src/wit_generation/mod.rs
@@ -66,13 +66,13 @@ impl FileContentGenerator for WitInterfaceWriter {
         writeln!(writer, "interface {} {{", self.name)?;
 
         for function in &self.functions {
-            writeln!(writer, "{}", function)?;
+            writeln!(writer, "{function}")?;
         }
 
         for type_declaration in self.types.values() {
             if !type_declaration.is_empty() {
                 writeln!(writer)?;
-                write!(writer, "{}", type_declaration)?;
+                write!(writer, "{type_declaration}")?;
             }
         }
 
@@ -124,13 +124,13 @@ impl WitWorldWriter {
 impl FileContentGenerator for WitWorldWriter {
     fn generate_file_contents(&self, mut writer: impl Write) -> std::io::Result<()> {
         if let Some(package) = &self.package {
-            writeln!(writer, "package {};\n", package)?;
+            writeln!(writer, "package {package};\n")?;
         }
 
         writeln!(writer, "world {} {{", &self.name)?;
 
         for import in &self.imports {
-            writeln!(writer, "    import {};", import)?;
+            writeln!(writer, "    import {import};")?;
         }
 
         if !self.imports.is_empty() {
@@ -138,7 +138,7 @@ impl FileContentGenerator for WitWorldWriter {
         }
 
         for export in &self.exports {
-            writeln!(writer, "    export {};", export)?;
+            writeln!(writer, "    export {export};")?;
         }
 
         writeln!(writer, "}}")?;
diff --git a/toolchains/stable/rust-toolchain.toml b/toolchains/stable/rust-toolchain.toml
index 7e81ac1c7fbc..7c609f535629 100644
--- a/toolchains/stable/rust-toolchain.toml
+++ b/toolchains/stable/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.86.0"
+channel = "1.88.0"
 components = [ "clippy", "rustfmt", "rust-src" ]
 targets = [ "wasm32-unknown-unknown" ]
 profile = "minimal"