[chore] use rust 1.88 to fix build (#371)

joyqvq · web-flow · commit 7503603ee778 · 2025-10-29T11:08:22.000-07:00
diff --git a/Dockerfile b/Dockerfile
@@ -1,5 +1,5 @@
 # Start with a Rust base image
-FROM rust:1.87-bullseye  AS builder
+FROM rust:1.88-bullseye  AS builder
 
 ARG PROFILE=release
 
diff --git a/crates/key-server/src/errors.rs b/crates/key-server/src/errors.rs
@@ -34,7 +34,7 @@ impl IntoResponse for InternalError {
     fn into_response(self) -> Response {
         let (status, message) = match self {
             InternalError::InvalidPTB(ref inner) => {
-                (StatusCode::FORBIDDEN, format!("Invalid PTB: {}", inner))
+                (StatusCode::FORBIDDEN, format!("Invalid PTB: {inner}"))
             }
             InternalError::InvalidPackage => {
                 (StatusCode::FORBIDDEN, "Invalid package ID".to_string())
@@ -58,7 +58,7 @@ impl IntoResponse for InternalError {
             ),
             InternalError::MissingRequiredHeader(ref inner) => (
                 StatusCode::BAD_REQUEST,
-                format!("Missing required header: {}", inner).to_string(),
+                format!("Missing required header: {inner}").to_string(),
             ),
             InternalError::InvalidSessionSignature => (
                 StatusCode::FORBIDDEN,
diff --git a/crates/key-server/src/externals.rs b/crates/key-server/src/externals.rs
@@ -163,9 +163,9 @@ mod tests {
                     "0x717d42d8205adeb14b440d6b46c8524d7479952099435261defa1b57f151bf16"
                         .to_string()
                 );
-                println!("First address: {:?}", first);
+                println!("First address: {first:?}");
             }
-            Err(e) => panic!("Test failed with error: {:?}", e),
+            Err(e) => panic!("Test failed with error: {e:?}"),
         }
     }
 
diff --git a/crates/key-server/src/key_server_options.rs b/crates/key-server/src/key_server_options.rs
@@ -565,7 +565,7 @@ server_mode: !Permissioned
         let options: KeyServerOptions =
             serde_yaml::from_str(yaml).expect("Failed to parse valid configuration");
         let result = options.validate();
-        assert!(result.is_err(), "Expected validation to fail for: {}", yaml);
+        assert!(result.is_err(), "Expected validation to fail for: {yaml}");
         assert_eq!(result.unwrap_err().to_string(), expected_error);
     }
 }
diff --git a/crates/key-server/src/periodic_updater.rs b/crates/key-server/src/periodic_updater.rs
@@ -68,6 +68,6 @@ where
     receiver
         .changed()
         .await
-        .unwrap_or_else(|_| panic!("Failed to get {}", value_name));
+        .unwrap_or_else(|_| panic!("Failed to get {value_name}"));
     (receiver, handle)
 }
diff --git a/crates/key-server/src/server.rs b/crates/key-server/src/server.rs
@@ -152,7 +152,7 @@ impl Server {
         );
         info!("Server started with network: {:?}", options.network);
         let master_keys = MasterKeys::load(&options).unwrap_or_else(|e| {
-            panic!("Failed to load master keys: {}", e);
+            panic!("Failed to load master keys: {e}");
         });
 
         let key_server_oid_to_pop = options
@@ -300,8 +300,7 @@ impl Server {
                     }
                 }
                 InternalError::Failure(format!(
-                    "Dry run execution failed ({:?}) (req_id: {:?})",
-                    e, req_id
+                    "Dry run execution failed ({e:?}) (req_id: {req_id:?})"
                 ))
             })?;
 
diff --git a/crates/key-server/src/sui_rpc_client.rs b/crates/key-server/src/sui_rpc_client.rs
@@ -67,7 +67,7 @@ impl RpcError {
     /// Helper to convert gRPC errors to RpcError
     fn from_grpc(e: tonic::Status) -> Self {
         Self {
-            message: format!("gRPC error: {}", e),
+            message: format!("gRPC error: {e}"),
             code: Some(e.code()),
         }
     }
@@ -378,7 +378,7 @@ mod tests {
         if call_count <= fail_count {
             Err(error_type)
         } else {
-            Ok(format!("Success on attempt {}", call_count))
+            Ok(format!("Success on attempt {call_count}"))
         }
     }
 
@@ -546,9 +546,7 @@ mod tests {
         let expected_min_duration = Duration::from_millis(2500);
         assert!(
             elapsed >= expected_min_duration,
-            "Expected at least {:?} but got {:?}",
-            expected_min_duration,
-            elapsed
+            "Expected at least {expected_min_duration:?} but got {elapsed:?}"
         );
     }
 }
diff --git a/crates/key-server/src/tests/whitelist.rs b/crates/key-server/src/tests/whitelist.rs
@@ -54,7 +54,7 @@ async fn test_whitelist_with_upgrade() {
 
     let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/tests/whitelist_v1");
     let (package_id_1, upgrade_cap) = tc.publish_path(path).await;
-    println!("Old pkg: {}", package_id_1);
+    println!("Old pkg: {package_id_1}");
 
     let (whitelist, cap, initial_shared_version) =
         create_whitelist(tc.test_cluster(), package_id_1).await;
diff --git a/crates/key-server/src/types.rs b/crates/key-server/src/types.rs
@@ -47,7 +47,7 @@ impl Network {
                 node_url: std::env::var("NODE_URL").ok(),
                 use_default_mainnet_for_mvr: None,
             },
-            _ => panic!("Unknown network: {}", str),
+            _ => panic!("Unknown network: {str}"),
         }
     }
 }
diff --git a/crates/key-server/src/valid_ptb.rs b/crates/key-server/src/valid_ptb.rs
@@ -29,8 +29,7 @@ impl TryFrom<ProgrammableTransaction> for ValidPtb {
         if ptb.commands.len() > MAX_COMMANDS {
             return_err!(
                 InternalError::InvalidPTB(format!(
-                    "Too many commands in PTB (more than {})",
-                    MAX_COMMANDS
+                    "Too many commands in PTB (more than {MAX_COMMANDS})"
                 )),
                 "Too many commands in PTB: {:?}",
                 ptb
diff --git a/crates/seal-cli/src/main.rs b/crates/seal-cli/src/main.rs
@@ -49,15 +49,14 @@ pub async fn fetch_key_server_urls(
         "testnet" => "https://fullnode.testnet.sui.io:443",
         _ => {
             return Err(FastCryptoError::GeneralError(format!(
-                "Invalid network: {}. Use 'mainnet' or 'testnet'",
-                network
+                "Invalid network: {network}. Use 'mainnet' or 'testnet'"
             )))
         }
     };
     let sui_client = SuiClientBuilder::default()
         .build(sui_rpc)
         .await
-        .map_err(|e| FastCryptoError::GeneralError(format!("Failed to build Sui client: {}", e)))?;
+        .map_err(|e| FastCryptoError::GeneralError(format!("Failed to build Sui client: {e}")))?;
     let mut key_servers = Vec::new();
     for object_id in key_server_ids {
         // Get the dynamic field object for version 1
@@ -83,23 +82,20 @@ pub async fn fetch_key_server_urls(
                             // Convert fields to JSON value for access
                             let fields_json = serde_json::to_value(fields).map_err(|e| {
                                 FastCryptoError::GeneralError(format!(
-                                    "Failed to serialize fields: {}",
-                                    e
+                                    "Failed to serialize fields: {e}"
                                 ))
                             })?;
 
                             // Extract URL and name from the nested 'value' field
                             let value_struct = fields_json.get("value").ok_or_else(|| {
                                 FastCryptoError::GeneralError(format!(
-                                    "Missing 'value' field for object {}",
-                                    object_id
+                                    "Missing 'value' field for object {object_id}"
                                 ))
                             })?;
 
                             let value_fields = value_struct.get("fields").ok_or_else(|| {
                                 FastCryptoError::GeneralError(format!(
-                                    "Missing 'fields' in value struct for object {}",
-                                    object_id
+                                    "Missing 'fields' in value struct for object {object_id}"
                                 ))
                             })?;
 
@@ -108,7 +104,7 @@ pub async fn fetch_key_server_urls(
                                     serde_json::Value::String(s) => Some(s.clone()),
                                     _ => None,
                                 })
-                                .ok_or_else(|| FastCryptoError::GeneralError(format!("Missing or invalid 'url' field in value fields for object {}", object_id)))?;
+                                .ok_or_else(|| FastCryptoError::GeneralError(format!("Missing or invalid 'url' field in value fields for object {object_id}")))?;
 
                             let name = value_fields
                                 .get("name")
@@ -131,7 +127,7 @@ pub async fn fetch_key_server_urls(
                                     serde_json::Value::String(s) => Some(s.clone()),
                                     _ => None,
                                 })
-                                .ok_or_else(|| FastCryptoError::GeneralError(format!("Missing or invalid 'pk' field in value fields for object {}", object_id)))?;
+                                .ok_or_else(|| FastCryptoError::GeneralError(format!("Missing or invalid 'pk' field in value fields for object {object_id}")))?;
 
                             key_servers.push(KeyServerInfo {
                                 object_id: *object_id,
@@ -141,27 +137,23 @@ pub async fn fetch_key_server_urls(
                             });
                         } else {
                             return Err(FastCryptoError::GeneralError(format!(
-                                "Unexpected content type for object {}",
-                                object_id
+                                "Unexpected content type for object {object_id}"
                             )));
                         }
                     } else {
                         return Err(FastCryptoError::GeneralError(format!(
-                            "No content found for object {}",
-                            object_id
+                            "No content found for object {object_id}"
                         )));
                     }
                 } else {
                     return Err(FastCryptoError::GeneralError(format!(
-                        "Object {} not found",
-                        object_id
+                        "Object {object_id} not found"
                     )));
                 }
             }
             Err(e) => {
                 return Err(FastCryptoError::GeneralError(format!(
-                    "Failed to fetch dynamic field for object {}: {}",
-                    object_id, e
+                    "Failed to fetch dynamic field for object {object_id}: {e}"
                 )));
             }
         }
@@ -520,15 +512,15 @@ async fn main() -> FastCryptoResult<()> {
             let key_server_infos = fetch_key_server_urls(&key_server_ids, &network)
                 .await
                 .map_err(|e| {
-                    FastCryptoError::GeneralError(format!("Failed to fetch key server info: {}", e))
+                    FastCryptoError::GeneralError(format!("Failed to fetch key server info: {e}"))
                 })?;
 
             // Parse public keys from fetched data
             let pks: Vec<IBEPublicKey> = key_server_infos
                 .iter()
                 .map(|info| -> Result<IBEPublicKey, FastCryptoError> {
                     let bytes = Hex::decode(&info.public_key).map_err(|e| {
-                        FastCryptoError::GeneralError(format!("Invalid public key hex: {}", e))
+                        FastCryptoError::GeneralError(format!("Invalid public key hex: {e}"))
                     })?;
                     let pk = IBEPublicKey::from_byte_array(&bytes.try_into().map_err(|_| {
                         FastCryptoError::GeneralError("Invalid public key length".to_string())
@@ -538,9 +530,10 @@ async fn main() -> FastCryptoResult<()> {
                 .collect::<Result<Vec<_>, _>>()?;
 
             // Encrypt the secret
-            let package_id = NewObjectID::new(package_id.as_bytes().try_into().map_err(|e| {
-                FastCryptoError::GeneralError(format!("Invalid package ID: {}", e))
-            })?);
+            let package_id =
+                NewObjectID::new(package_id.as_bytes().try_into().map_err(|e| {
+                    FastCryptoError::GeneralError(format!("Invalid package ID: {e}"))
+                })?);
             let mut encrypted_objects = Vec::new();
             for (id, secret) in ids.into_iter().zip(secrets.into_iter()) {
                 let (encrypted_object, _) = seal_encrypt(
@@ -554,7 +547,7 @@ async fn main() -> FastCryptoResult<()> {
                         aad: None,
                     },
                 )
-                .map_err(|e| FastCryptoError::GeneralError(format!("Encryption failed: {}", e)))?;
+                .map_err(|e| FastCryptoError::GeneralError(format!("Encryption failed: {e}")))?;
                 encrypted_objects.push(encrypted_object);
             }
             format!(
@@ -571,8 +564,7 @@ async fn main() -> FastCryptoResult<()> {
             // Parse fetch keys request.
             let request: FetchKeyRequest = bcs::from_bytes(&request.0).map_err(|e| {
                 FastCryptoError::GeneralError(format!(
-                    "Failed to parse FetchKeyRequest from BCS: {}",
-                    e
+                    "Failed to parse FetchKeyRequest from BCS: {e}"
                 ))
             })?;
 
@@ -582,7 +574,7 @@ async fn main() -> FastCryptoResult<()> {
             for server in &fetch_key_server_urls(&key_server_ids, &network)
                 .await
                 .map_err(|e| {
-                    FastCryptoError::GeneralError(format!("Failed to fetch key server URLs: {}", e))
+                    FastCryptoError::GeneralError(format!("Failed to fetch key server URLs: {e}"))
                 })?
             {
                 println!(
@@ -613,16 +605,16 @@ async fn main() -> FastCryptoResult<()> {
                                 .text()
                                 .await
                                 .unwrap_or_else(|_| "Unknown error".to_string());
-                            eprintln!("Server returned error: {}", error_text);
+                            eprintln!("Server returned error: {error_text}");
                         }
                     }
                     Err(e) => {
-                        eprintln!("Failed: {}", e);
+                        eprintln!("Failed: {e}");
                     }
                 }
 
                 if seal_responses.len() >= threshold as usize {
-                    println!("Reached threshold of {} responses", threshold);
+                    println!("Reached threshold of {threshold} responses");
                     break;
                 }
             }
@@ -642,7 +634,7 @@ async fn main() -> FastCryptoResult<()> {
             )
         }
     };
-    println!("{}", output);
+    println!("{output}");
     Ok(())
 }
 
@@ -684,8 +676,8 @@ fn serializable_to_string<T: Serialize>(t: &T) -> String {
 }
 
 pub fn parse_serializable<T: for<'a> Deserialize<'a>, E: Encoding>(s: &str) -> Result<T, String> {
-    let bytes = E::decode(s).map_err(|e| format!("{}", e))?;
-    bcs::from_bytes(&bytes).map_err(|e| format!("{}", e))
+    let bytes = E::decode(s).map_err(|e| format!("{e}"))?;
+    bcs::from_bytes(&bytes).map_err(|e| format!("{e}"))
 }
 
 impl Display for GenkeyOutput {
@@ -749,7 +741,7 @@ impl Display for ParseOutput {
         writeln!(f, "ID: {}", DefaultEncoding::encode(&self.0.id))?;
         writeln!(f, "Services: share index:")?;
         for (id, index) in &self.0.services {
-            writeln!(f, "  {}: {}", id, index)?;
+            writeln!(f, "  {id}: {index}")?;
         }
         writeln!(f, "Threshold: {}", self.0.threshold)?;
         writeln!(f, "Ciphertext:")?;
diff --git a/crates/seal-proxy/src/config.rs b/crates/seal-proxy/src/config.rs
@@ -93,7 +93,7 @@ pub fn load<P: AsRef<std::path::Path>, T: DeserializeOwned + Serialize + std::fm
     info!("Reading config from {:?}", path);
     // deserialize the config file and put it into a BearerTokenConfig
     let config: T = serde_yaml::from_reader(
-        std::fs::File::open(path).context(format!("cannot open {:?}", path))?,
+        std::fs::File::open(path).context(format!("cannot open {path:?}"))?,
     )?;
     Ok(config)
 }
diff --git a/crates/seal-sdk/src/lib.rs b/crates/seal-sdk/src/lib.rs
@@ -84,15 +84,13 @@ pub fn seal_decrypt_all_objects(
     for (server_id, seal_response) in seal_responses.iter() {
         if !processed_servers.insert(*server_id) {
             return Err(FastCryptoError::GeneralError(format!(
-                "Duplicate server_id {} in seal_responses",
-                server_id
+                "Duplicate server_id {server_id} in seal_responses"
             )));
         }
 
         let public_key = server_pk_map.get(server_id).ok_or_else(|| {
             FastCryptoError::GeneralError(format!(
-                "No public key configured for server {}",
-                server_id
+                "No public key configured for server {server_id}"
             ))
         })?;
 
@@ -125,16 +123,14 @@ pub fn seal_decrypt_all_objects(
         for (server_id, _index) in encrypted_object.services.iter() {
             let user_secret_key = keys_for_id.get(server_id).ok_or_else(|| {
                 FastCryptoError::GeneralError(format!(
-                    "Object requires key from server {} but no response was provided from that server",
-                    server_id
+                    "Object requires key from server {server_id} but no response was provided from that server"
                 ))
             })?;
             usks.insert(*server_id, *user_secret_key);
 
             let pk = server_pk_map.get(server_id).ok_or_else(|| {
                 FastCryptoError::GeneralError(format!(
-                    "No public key configured for server {}",
-                    server_id
+                    "No public key configured for server {server_id}"
                 ))
             })?;
             pks.push(*pk);
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.87"
+channel = "1.88"
 components = ["clippy", "rustfmt"]

Original file line number	Diff line number	Diff line change
`@@ -163,9 +163,9 @@ mod tests {`
`163`	`163`	`"0x717d42d8205adeb14b440d6b46c8524d7479952099435261defa1b57f151bf16"`
`164`	`164`	`.to_string()`
`165`	`165`	`);`
`166`		`- println!("First address: {:?}", first);`
	`166`	`+ println!("First address: {first:?}");`
`167`	`167`	`}`
`168`		`- Err(e) => panic!("Test failed with error: {:?}", e),`
	`168`	`+ Err(e) => panic!("Test failed with error: {e:?}"),`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`
Original file line number	Diff line number	Diff line change
`@@ -565,7 +565,7 @@ server_mode: !Permissioned`
`565`	`565`	`let options: KeyServerOptions =`
`566`	`566`	`serde_yaml::from_str(yaml).expect("Failed to parse valid configuration");`
`567`	`567`	`let result = options.validate();`
`568`		`- assert!(result.is_err(), "Expected validation to fail for: {}", yaml);`
	`568`	`+ assert!(result.is_err(), "Expected validation to fail for: {yaml}");`
`569`	`569`	`assert_eq!(result.unwrap_err().to_string(), expected_error);`
`570`	`570`	`}`
`571`	`571`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,6 @@ where`
`68`	`68`	`receiver`
`69`	`69`	`.changed()`
`70`	`70`	`.await`
`71`		`- .unwrap_or_else(\|_\| panic!("Failed to get {}", value_name));`
	`71`	`+ .unwrap_or_else(\|_\| panic!("Failed to get {value_name}"));`
`72`	`72`	`(receiver, handle)`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ impl RpcError {`
`67`	`67`	`/// Helper to convert gRPC errors to RpcError`
`68`	`68`	`fn from_grpc(e: tonic::Status) -> Self {`
`69`	`69`	`Self {`
`70`		`- message: format!("gRPC error: {}", e),`
	`70`	`+ message: format!("gRPC error: {e}"),`
`71`	`71`	`code: Some(e.code()),`
`72`	`72`	`}`
`73`	`73`	`}`
`@@ -378,7 +378,7 @@ mod tests {`
`378`	`378`	`if call_count <= fail_count {`
`379`	`379`	`Err(error_type)`
`380`	`380`	`} else {`
`381`		`- Ok(format!("Success on attempt {}", call_count))`
	`381`	`+ Ok(format!("Success on attempt {call_count}"))`
`382`	`382`	`}`
`383`	`383`	`}`
`384`	`384`
`@@ -546,9 +546,7 @@ mod tests {`
`546`	`546`	`let expected_min_duration = Duration::from_millis(2500);`
`547`	`547`	`assert!(`
`548`	`548`	`elapsed >= expected_min_duration,`
`549`		`- "Expected at least {:?} but got {:?}",`
`550`		`- expected_min_duration,`
`551`		`- elapsed`
	`549`	`+ "Expected at least {expected_min_duration:?} but got {elapsed:?}"`
`552`	`550`	`);`
`553`	`551`	`}`
`554`	`552`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ impl Network {`
`47`	`47`	`node_url: std::env::var("NODE_URL").ok(),`
`48`	`48`	`use_default_mainnet_for_mvr: None,`
`49`	`49`	`},`
`50`		`- _ => panic!("Unknown network: {}", str),`
	`50`	`+ _ => panic!("Unknown network: {str}"),`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`	`}`