diff --git a/ic-agent/src/agent/agent_error.rs b/ic-agent/src/agent/agent_error.rs
index b346c537..dc2b03c4 100644
--- a/ic-agent/src/agent/agent_error.rs
+++ b/ic-agent/src/agent/agent_error.rs
@@ -98,7 +98,7 @@ pub enum AgentError {
     #[error("The request status ({1}) at path {0:?} is invalid.")]
     InvalidRequestStatus(Vec<Label>, String),
 
-    /// The certificate verification for a read_state call failed.
+    /// The certificate verification for a `read_state` call failed.
     #[error("Certificate verification failed.")]
     CertificateVerificationFailed(),
 
@@ -106,7 +106,7 @@ pub enum AgentError {
     #[error("Query signature verification failed.")]
     QuerySignatureVerificationFailed,
 
-    /// The certificate contained a delegation that does not include the effective_canister_id in the canister_ranges field.
+    /// The certificate contained a delegation that does not include the `effective_canister_id` in the `canister_ranges` field.
     #[error("Certificate is not authorized to respond to queries for this canister. While developing: Did you forget to set effective_canister_id?")]
     CertificateNotAuthorized(),
 
@@ -211,7 +211,7 @@ impl PartialEq for AgentError {
     fn eq(&self, other: &Self) -> bool {
         // Verify the debug string is the same. Some of the subtypes of this error
         // don't implement Eq or PartialEq, so we cannot rely on derive.
-        format!("{:?}", self) == format!("{:?}", other)
+        format!("{self:?}") == format!("{other:?}")
     }
 }
 
@@ -239,7 +239,7 @@ impl HttpErrorPayload {
         f.write_fmt(format_args!(
             "Http Error: status {}, content type {:?}, content: {}",
             http::StatusCode::from_u16(self.status)
-                .map_or_else(|_| format!("{}", self.status), |code| format!("{}", code)),
+                .map_or_else(|_| format!("{}", self.status), |code| format!("{code}")),
             self.content_type.clone().unwrap_or_default(),
             String::from_utf8(self.content.clone()).unwrap_or_else(|_| format!(
                 "(unable to decode content as UTF-8: {:?})",
diff --git a/ic-agent/src/agent/agent_test.rs b/ic-agent/src/agent/agent_test.rs
index 622635fa..6cf92633 100644
--- a/ic-agent/src/agent/agent_test.rs
+++ b/ic-agent/src/agent/agent_test.rs
@@ -37,7 +37,7 @@ fn make_untimed_agent(url: &str) -> Agent {
     Agent::builder()
         .with_url(url)
         .with_verify_query_signatures(false)
-        .with_ingress_expiry(Duration::from_secs(u32::MAX as _))
+        .with_ingress_expiry(Duration::from_secs(u32::MAX.into()))
         .build()
         .unwrap()
 }
@@ -45,7 +45,7 @@ fn make_untimed_agent(url: &str) -> Agent {
 fn make_certifying_agent(url: &str) -> Agent {
     Agent::builder()
         .with_url(url)
-        .with_ingress_expiry(Duration::from_secs(u32::MAX as _))
+        .with_ingress_expiry(Duration::from_secs(u32::MAX.into()))
         .build()
         .unwrap()
 }
@@ -238,7 +238,7 @@ async fn call_rejected_without_error_code() -> Result<(), AgentError> {
 
     let (call_mock, url) = mock(
         "POST",
-        format!("/api/v3/canister/{}/call", canister_id_str).as_str(),
+        format!("/api/v3/canister/{canister_id_str}/call").as_str(),
         200,
         body,
         Some("application/cbor"),
@@ -475,7 +475,7 @@ async fn wrong_subnet_query_certificate() {
     let response = QueryResponse::Replied {
         reply: ReplyResponse { arg: blob.clone() },
         signatures: vec![NodeSignature {
-            timestamp: 1697831349698624964,
+            timestamp: 1_697_831_349_698_624_964,
             signature: hex::decode("4bb6ba316623395d56d8e2834ece39d2c81d47e76a9fd122e1457963be6a83a5589e2c98c7b4d8b3c6c7b11c74b8ce9dcb345b5d1bd91706a643f33c7b509b0b").unwrap(),
             identity: "oo4np-rrvnz-5vram-kglex-enhkp-uew6q-vdf6z-whj4x-v44jd-tebaw-nqe".parse().unwrap()
         }],
@@ -543,14 +543,14 @@ const RESP_WITH_SUBNET_KEY: &[u8] = include_bytes!("agent_test/with_subnet_key.b
 #[cfg_attr(target_family = "wasm", wasm_bindgen_test)]
 async fn too_many_delegations() {
     // Use the certificate as its own delegation, and repeat the process the specified number of times
-    fn self_delegate_cert(subnet_id: Vec<u8>, cert: &Certificate, depth: u32) -> Certificate {
+    fn self_delegate_cert(subnet_id: &[u8], cert: &Certificate, depth: u32) -> Certificate {
         let mut current = cert.clone();
         for _ in 0..depth {
             current = Certificate {
                 tree: current.tree.clone(),
                 signature: current.signature.clone(),
                 delegation: Some(Delegation {
-                    subnet_id: subnet_id.clone(),
+                    subnet_id: subnet_id.to_vec(),
                     certificate: serde_cbor::to_vec(&current).unwrap(),
                 }),
             }
@@ -568,7 +568,7 @@ async fn too_many_delegations() {
 
     let (_read_mock, url) = mock(
         "POST",
-        format!("/api/v2/canister/{}/read_state", canister_id_str).as_str(),
+        format!("/api/v2/canister/{canister_id_str}/read_state").as_str(),
         200,
         RESP_WITH_SUBNET_KEY.into(),
         Some("application/cbor"),
@@ -580,7 +580,7 @@ async fn too_many_delegations() {
         .read_state_raw(vec![vec![path_label]], canister_id)
         .await
         .expect("read state failed");
-    let new_cert = self_delegate_cert(subnet_id, &cert, 1);
+    let new_cert = self_delegate_cert(&subnet_id, &cert, 1);
     assert!(matches!(
         agent.verify(&new_cert, canister_id).unwrap_err(),
         AgentError::CertificateHasTooManyDelegations
diff --git a/ic-agent/src/agent/builder.rs b/ic-agent/src/agent/builder.rs
index 027cff00..cc42752f 100644
--- a/ic-agent/src/agent/builder.rs
+++ b/ic-agent/src/agent/builder.rs
@@ -50,7 +50,7 @@ impl AgentBuilder {
         self.with_route_provider(url.into().parse::<Url>().unwrap())
     }
 
-    /// Add a NonceFactory to this Agent. By default, no nonce is produced.
+    /// Add a `NonceFactory` to this Agent. By default, no nonce is produced.
     pub fn with_nonce_factory(self, nonce_factory: NonceFactory) -> AgentBuilder {
         self.with_nonce_generator(nonce_factory)
     }
diff --git a/ic-agent/src/agent/mod.rs b/ic-agent/src/agent/mod.rs
index 3de2aa26..466ad660 100644
--- a/ic-agent/src/agent/mod.rs
+++ b/ic-agent/src/agent/mod.rs
@@ -243,9 +243,8 @@ impl Agent {
             return Ok(());
         }
         let status = self.status().await?;
-        let root_key = match status.root_key {
-            Some(key) => key,
-            None => return Err(AgentError::NoRootKeyInStatus(status)),
+        let Some(root_key) = status.root_key else {
+            return Err(AgentError::NoRootKeyInStatus(status));
         };
         self.set_root_key(root_key);
         Ok(())
@@ -270,7 +269,7 @@ impl Agent {
         if self.ingress_expiry.as_secs() > 90 {
             rounded = rounded.replace_second(0).unwrap();
         }
-        rounded.unix_timestamp_nanos() as u64
+        rounded.unix_timestamp_nanos().try_into().unwrap()
     }
 
     /// Return the principal of the identity.
@@ -402,7 +401,7 @@ impl Agent {
         .await
     }
 
-    /// Helper function for performing both the query call and possibly a read_state to check the subnet node keys.
+    /// Helper function for performing both the query call and possibly a `read_state` to check the subnet node keys.
     ///
     /// This should be used instead of `query_endpoint`. No validation is performed on `signed_query`.
     async fn query_inner(
@@ -427,7 +426,7 @@ impl Agent {
             }
             for signature in response.signatures() {
                 if OffsetDateTime::now_utc()
-                    - OffsetDateTime::from_unix_timestamp_nanos(signature.timestamp as _).unwrap()
+                    - OffsetDateTime::from_unix_timestamp_nanos(signature.timestamp.into()).unwrap()
                     > self.ingress_expiry
                 {
                     return Err(AgentError::CertificateOutdated(self.ingress_expiry));
@@ -622,7 +621,7 @@ impl Agent {
             .build()
     }
 
-    /// Wait for request_status to return a Replied response and return the arg.
+    /// Wait for `request_status` to return a Replied response and return the arg.
     pub async fn wait_signed(
         &self,
         request_id: &RequestId,
@@ -671,7 +670,7 @@ impl Agent {
         }
     }
 
-    /// Call request_status on the RequestId in a loop and return the response as a byte vector.
+    /// Call `request_status` on the `RequestId` in a loop and return the response as a byte vector.
     pub async fn wait(
         &self,
         request_id: &RequestId,
@@ -877,7 +876,7 @@ impl Agent {
                     delegation.subnet_id.as_ref(),
                     "public_key".as_bytes(),
                 ];
-                lookup_value(&cert.tree, public_key_path).map(|pk| pk.to_vec())
+                lookup_value(&cert.tree, public_key_path).map(<[u8]>::to_vec)
             }
         }
     }
@@ -973,9 +972,9 @@ impl Agent {
         lookup_request_status(cert, request_id)
     }
 
-    /// Send the signed request_status to the network. Will return [`RequestStatusResponse`].
-    /// The bytes will be checked to verify that it is a valid request_status.
-    /// If you want to inspect the fields of the request_status, use [`signed_request_status_inspect`] before calling this method.
+    /// Send the signed `request_status` to the network. Will return [`RequestStatusResponse`].
+    /// The bytes will be checked to verify that it is a valid `request_status`.
+    /// If you want to inspect the fields of the `request_status`, use [`signed_request_status_inspect`] before calling this method.
     pub async fn request_status_signed(
         &self,
         request_id: &RequestId,
@@ -994,7 +993,7 @@ impl Agent {
         lookup_request_status(cert, request_id)
     }
 
-    /// Returns an UpdateBuilder enabling the construction of an update call without
+    /// Returns an `UpdateBuilder` enabling the construction of an update call without
     /// passing all arguments.
     pub fn update<S: Into<String>>(
         &self,
@@ -1015,14 +1014,14 @@ impl Agent {
         Status::try_from(&cbor).map_err(|_| AgentError::InvalidReplicaStatus)
     }
 
-    /// Returns a QueryBuilder enabling the construction of a query call without
+    /// Returns a `QueryBuilder` enabling the construction of a query call without
     /// passing all arguments.
     pub fn query<S: Into<String>>(&self, canister_id: &Principal, method_name: S) -> QueryBuilder {
         QueryBuilder::new(self, *canister_id, method_name.into())
     }
 
-    /// Sign a request_status call. This will return a [`signed::SignedRequestStatus`]
-    /// which contains all fields of the request_status and the signed request_status in CBOR encoding
+    /// Sign a `request_status` call. This will return a [`signed::SignedRequestStatus`]
+    /// which contains all fields of the `request_status` and the signed `request_status` in CBOR encoding
     pub fn sign_request_status(
         &self,
         effective_canister_id: Principal,
@@ -1059,7 +1058,7 @@ impl Agent {
         }
     }
 
-    /// Retrieve all existing API boundary nodes from the state tree via endpoint /api/v2/canister/<effective_canister_id>/read_state
+    /// Retrieve all existing API boundary nodes from the state tree via endpoint `/api/v2/canister/<effective_canister_id>/read_state`
     pub async fn fetch_api_boundary_nodes_by_canister_id(
         &self,
         canister_id: Principal,
@@ -1070,7 +1069,7 @@ impl Agent {
         Ok(api_boundary_nodes)
     }
 
-    /// Retrieve all existing API boundary nodes from the state tree via endpoint /api/v2/subnet/<subnet_id>/read_state
+    /// Retrieve all existing API boundary nodes from the state tree via endpoint `/api/v2/subnet/<subnet_id>/read_state`
     pub async fn fetch_api_boundary_nodes_by_subnet_id(
         &self,
         subnet_id: Principal,
@@ -1110,7 +1109,7 @@ impl Agent {
             http_request
                 .headers_mut()
                 .insert(CONTENT_TYPE, "application/cbor".parse().unwrap());
-            *http_request.body_mut() = body.as_ref().cloned().map(Body::from);
+            *http_request.body_mut() = body.clone().map(Body::from);
             Ok(http_request)
         };
 
@@ -1128,7 +1127,7 @@ impl Agent {
         // Size Check (Content-Length)
         if matches!(self
             .max_response_body_size
-            .zip(response.content_length()), Some((size_limit, content_length)) if content_length as usize > size_limit)
+            .zip(response.content_length()), Some((size_limit, content_length)) if content_length > size_limit as u64)
         {
             return Err(AgentError::ResponseSizeExceededLimit());
         }
@@ -1161,9 +1160,7 @@ impl Agent {
         endpoint: &str,
         body: Option<Vec<u8>>,
     ) -> Result<(StatusCode, Vec<u8>), AgentError> {
-        let request_result = self
-            .request(method.clone(), endpoint, body.as_ref().cloned())
-            .await?;
+        let request_result = self.request(method.clone(), endpoint, body.clone()).await?;
 
         let status = request_result.0;
         let headers = request_result.1;
@@ -1175,13 +1172,12 @@ impl Agent {
                 content_type: headers
                     .get(CONTENT_TYPE)
                     .and_then(|value| value.to_str().ok())
-                    .map(|x| x.to_string()),
+                    .map(str::to_string),
                 content: body,
             }))
         } else if !(status == StatusCode::OK || status == StatusCode::ACCEPTED) {
             Err(AgentError::InvalidHttpResponse(format!(
-                "Expected `200`, `202`, 4xx`, or `5xx` HTTP status code. Got: {}",
-                status
+                "Expected `200`, `202`, 4xx`, or `5xx` HTTP status code. Got: {status}",
             )))
         } else {
             Ok((status, body))
@@ -1270,8 +1266,8 @@ pub fn signed_query_inspect(
             if arg != *arg_cbor {
                 return Err(AgentError::CallDataMismatch {
                     field: "arg".to_string(),
-                    value_arg: format!("{:?}", arg),
-                    value_cbor: format!("{:?}", arg_cbor),
+                    value_arg: format!("{arg:?}"),
+                    value_cbor: format!("{arg_cbor:?}"),
                 });
             }
         }
@@ -1345,8 +1341,8 @@ pub fn signed_update_inspect(
             if arg != *arg_cbor {
                 return Err(AgentError::CallDataMismatch {
                     field: "arg".to_string(),
-                    value_arg: format!("{:?}", arg),
-                    value_cbor: format!("{:?}", arg_cbor),
+                    value_arg: format!("{arg:?}"),
+                    value_cbor: format!("{arg_cbor:?}"),
                 });
             }
         }
@@ -1368,8 +1364,8 @@ pub fn signed_update_inspect(
     Ok(())
 }
 
-/// Inspect the bytes to be sent as a request_status
-/// Return Ok only when the bytes can be deserialized as a request_status and all fields match with the arguments
+/// Inspect the bytes to be sent as a `request_status`
+/// Return Ok only when the bytes can be deserialized as a `request_status` and all fields match with the arguments
 pub fn signed_request_status_inspect(
     sender: Principal,
     request_id: &RequestId,
@@ -1403,8 +1399,8 @@ pub fn signed_request_status_inspect(
             if paths != *paths_cbor {
                 return Err(AgentError::CallDataMismatch {
                     field: "paths".to_string(),
-                    value_arg: format!("{:?}", paths),
-                    value_cbor: format!("{:?}", paths_cbor),
+                    value_arg: format!("{paths:?}"),
+                    value_cbor: format!("{paths_cbor:?}"),
                 });
             }
         }
@@ -1552,13 +1548,13 @@ impl<'agent> QueryBuilder<'agent> {
         self
     }
 
-    /// Sets ingress_expiry_datetime to the provided timestamp, at nanosecond precision.
+    /// Sets `ingress_expiry_datetime` to the provided timestamp, at nanosecond precision.
     pub fn expire_at(mut self, time: impl Into<OffsetDateTime>) -> Self {
         self.ingress_expiry_datetime = Some(time.into().unix_timestamp_nanos() as u64);
         self
     }
 
-    /// Sets ingress_expiry_datetime to `max(now, 4min)`.
+    /// Sets `ingress_expiry_datetime` to `max(now, 4min)`.
     pub fn expire_after(mut self, duration: Duration) -> Self {
         self.ingress_expiry_datetime = Some(
             OffsetDateTime::now_utc()
@@ -1593,7 +1589,7 @@ impl<'agent> QueryBuilder<'agent> {
     /// Make a query call with signature verification. This will return a byte vector.
     ///
     /// Compared with [call][Self::call], this method will **always** verify the signature of the query response
-    /// regardless the Agent level configuration from [AgentBuilder::with_verify_query_signatures].
+    /// regardless the Agent level configuration from [`AgentBuilder::with_verify_query_signatures`].
     pub async fn call_with_verification(self) -> Result<Vec<u8>, AgentError> {
         self.agent
             .query_raw(
@@ -1611,7 +1607,7 @@ impl<'agent> QueryBuilder<'agent> {
     /// Make a query call without signature verification. This will return a byte vector.
     ///
     /// Compared with [call][Self::call], this method will **never** verify the signature of the query response
-    /// regardless the Agent level configuration from [AgentBuilder::with_verify_query_signatures].
+    /// regardless the Agent level configuration from [`AgentBuilder::with_verify_query_signatures`].
     pub async fn call_without_verification(self) -> Result<Vec<u8>, AgentError> {
         self.agent
             .query_raw(
@@ -1756,13 +1752,13 @@ impl<'agent> UpdateBuilder<'agent> {
         self
     }
 
-    /// Sets ingress_expiry_datetime to the provided timestamp, at nanosecond precision.
+    /// Sets `ingress_expiry_datetime` to the provided timestamp, at nanosecond precision.
     pub fn expire_at(mut self, time: impl Into<OffsetDateTime>) -> Self {
         self.ingress_expiry_datetime = Some(time.into().unix_timestamp_nanos() as u64);
         self
     }
 
-    /// Sets ingress_expiry_datetime to `min(now, 4min)`.
+    /// Sets `ingress_expiry_datetime` to `min(now, 4min)`.
     pub fn expire_after(mut self, duration: Duration) -> Self {
         self.ingress_expiry_datetime = Some(
             OffsetDateTime::now_utc()
@@ -1772,14 +1768,14 @@ impl<'agent> UpdateBuilder<'agent> {
         self
     }
 
-    /// Make an update call. This will call request_status on the RequestId in a loop and return
+    /// Make an update call. This will call `request_status` on the `RequestId` in a loop and return
     /// the response as a byte vector.
     pub async fn call_and_wait(self) -> Result<Vec<u8>, AgentError> {
         self.call().and_wait().await
     }
 
-    /// Make an update call. This will return a RequestId.
-    /// The RequestId should then be used for request_status (most likely in a loop).
+    /// Make an update call. This will return a `RequestId`.
+    /// The `RequestId` should then be used for `request_status` (most likely in a loop).
     pub fn call(self) -> UpdateCall<'agent> {
         let response_future = async move {
             self.agent
diff --git a/ic-agent/src/agent/route_provider.rs b/ic-agent/src/agent/route_provider.rs
index 029508e9..77344b8b 100644
--- a/ic-agent/src/agent/route_provider.rs
+++ b/ic-agent/src/agent/route_provider.rs
@@ -89,11 +89,11 @@ impl RoundRobinRouteProvider {
                     // rewrite *.ic0.app to ic0.app
                     if let Some(domain) = url.domain() {
                         if domain.ends_with(IC0_SUB_DOMAIN) {
-                            url.set_host(Some(IC0_DOMAIN))?
+                            url.set_host(Some(IC0_DOMAIN))?;
                         } else if domain.ends_with(ICP0_SUB_DOMAIN) {
-                            url.set_host(Some(ICP0_DOMAIN))?
+                            url.set_host(Some(ICP0_DOMAIN))?;
                         } else if domain.ends_with(ICP_API_SUB_DOMAIN) {
-                            url.set_host(Some(ICP_API_DOMAIN))?
+                            url.set_host(Some(ICP_API_DOMAIN))?;
                         } else if domain.ends_with(LOCALHOST_SUB_DOMAIN) {
                             url.set_host(Some(LOCALHOST_DOMAIN))?;
                         }
diff --git a/ic-agent/src/agent/route_provider/dynamic_routing/dynamic_route_provider.rs b/ic-agent/src/agent/route_provider/dynamic_routing/dynamic_route_provider.rs
index 8c245380..92b18d4a 100644
--- a/ic-agent/src/agent/route_provider/dynamic_routing/dynamic_route_provider.rs
+++ b/ic-agent/src/agent/route_provider/dynamic_routing/dynamic_route_provider.rs
@@ -29,7 +29,7 @@ use crate::{
     AgentError,
 };
 
-///
+/// The default seed domain for boundary node discovery.
 pub const IC0_SEED_DOMAIN: &str = "ic0.app";
 
 const MAINNET_ROOT_SUBNET_ID: &str =
diff --git a/ic-agent/src/agent/status.rs b/ic-agent/src/agent/status.rs
index 60f78203..bd601abf 100644
--- a/ic-agent/src/agent/status.rs
+++ b/ic-agent/src/agent/status.rs
@@ -87,7 +87,7 @@ fn cbor_value_to_value(value: &serde_cbor::Value) -> Result<Value, ()> {
         )),
         serde_cbor::Value::Map(m) => {
             let mut map = BTreeMap::new();
-            for (key, value) in m.iter() {
+            for (key, value) in m {
                 let k = match key {
                     serde_cbor::Value::Text(t) => t.to_owned(),
                     serde_cbor::Value::Integer(i) => i.to_string(),
diff --git a/ic-agent/src/identity/delegated.rs b/ic-agent/src/identity/delegated.rs
index ed482b89..08b362ec 100644
--- a/ic-agent/src/identity/delegated.rs
+++ b/ic-agent/src/identity/delegated.rs
@@ -81,7 +81,7 @@ impl DelegatedIdentity {
                     .map_err(|_| DelegationError::BrokenChain {
                         from: last_verified.clone(),
                         to: Some(delegation.delegation.clone()),
-                    })?
+                    })?;
             } else {
                 return Err(DelegationError::UnknownAlgorithm);
             }
@@ -109,8 +109,8 @@ impl DelegatedIdentity {
     ) -> Self {
         Self {
             to,
-            from_key,
             chain,
+            from_key,
         }
     }
 
diff --git a/ic-agent/src/identity/prime256v1.rs b/ic-agent/src/identity/prime256v1.rs
index 4cec9a0b..7555fa7c 100644
--- a/ic-agent/src/identity/prime256v1.rs
+++ b/ic-agent/src/identity/prime256v1.rs
@@ -95,7 +95,7 @@ impl Identity for Prime256v1Identity {
         let ecdsa_sig: ecdsa::Signature = self
             .private_key
             .try_sign(content)
-            .map_err(|err| format!("Cannot create prime256v1 signature: {}", err))?;
+            .map_err(|err| format!("Cannot create prime256v1 signature: {err}"))?;
         let r = ecdsa_sig.r().as_ref().to_bytes();
         let s = ecdsa_sig.s().as_ref().to_bytes();
         let mut bytes = [0u8; 64];
diff --git a/ic-agent/src/identity/secp256k1.rs b/ic-agent/src/identity/secp256k1.rs
index 73670987..d1cd082c 100644
--- a/ic-agent/src/identity/secp256k1.rs
+++ b/ic-agent/src/identity/secp256k1.rs
@@ -95,7 +95,7 @@ impl Identity for Secp256k1Identity {
         let ecdsa_sig: ecdsa::Signature = self
             .private_key
             .try_sign(content)
-            .map_err(|err| format!("Cannot create secp256k1 signature: {}", err))?;
+            .map_err(|err| format!("Cannot create secp256k1 signature: {err}"))?;
         let r = ecdsa_sig.r().as_ref().to_bytes();
         let s = ecdsa_sig.s().as_ref().to_bytes();
         let mut bytes = [0u8; 64];
diff --git a/ic-identity-hsm/src/hsm.rs b/ic-identity-hsm/src/hsm.rs
index 706de909..36795b6b 100644
--- a/ic-identity-hsm/src/hsm.rs
+++ b/ic-identity-hsm/src/hsm.rs
@@ -33,7 +33,7 @@ type Sha256Hash = GenericArray<u8, <Sha256 as OutputSizeUser>::OutputSize>;
 // We expect the parameters to be curve secp256r1.  This is the base127 encoded form:
 const EXPECTED_EC_PARAMS: &[u8; 10] = b"\x06\x08\x2a\x86\x48\xce\x3d\x03\x01\x07";
 
-/// An error happened related to a HardwareIdentity.
+/// An error happened related to a `HardwareIdentity`.
 #[derive(Error, Debug)]
 pub enum HardwareIdentityError {
     /// A PKCS11 error occurred.
@@ -61,11 +61,11 @@ pub enum HardwareIdentityError {
     #[error("Unexpected key type {0}")]
     UnexpectedKeyType(CK_KEY_TYPE),
 
-    /// An EcPoint block was expected to be an OctetString, but was not.
+    /// An `EcPoint` block was expected to be an `OctetString`, but was not.
     #[error("Expected EcPoint to be an OctetString")]
     ExpectedEcPointOctetString,
 
-    /// An EcPoint block was unexpectedly empty.
+    /// An `EcPoint` block was unexpectedly empty.
     #[error("EcPoint is empty")]
     EcPointEmpty,
 
@@ -73,12 +73,12 @@ pub enum HardwareIdentityError {
     #[error("Attribute with type={0} not found")]
     AttributeNotFound(CK_ATTRIBUTE_TYPE),
 
-    /// The EcParams given were not the ones the crate expected.
+    /// The `EcParams` given were not the ones the crate expected.
     #[error("Invalid EcParams.  Expected prime256v1 {:02x?}, actual is {:02x?}", .expected, .actual)]
     InvalidEcParams {
-        /// The expected value of the EcParams.
+        /// The expected value of the `EcParams`.
         expected: Vec<u8>,
-        /// The actual value of the EcParams.
+        /// The actual value of the `EcParams`.
         actual: Vec<u8>,
     },
 
@@ -104,9 +104,11 @@ pub struct HardwareIdentity {
 impl HardwareIdentity {
     /// Create an identity using a specific key on an HSM.
     /// The filename will be something like /usr/local/lib/opensc-pkcs11.s
-    /// The key_id must refer to a ECDSA key with parameters prime256v1 (secp256r1)
+    /// The `key_id` must refer to a ECDSA key with parameters prime256v1 (secp256r1)
     /// The key must already have been created.  You can create one with pkcs11-tool:
-    /// $ pkcs11-tool -k --slot $SLOT -d $KEY_ID --key-type EC:prime256v1 --pin $PIN
+    /// ```sh
+    /// pkcs11-tool -k --slot $SLOT -d $KEY_ID --key-type EC:prime256v1 --pin $PIN
+    /// ```
     pub fn new<P, PinFn>(
         pkcs11_lib_path: P,
         slot_index: usize,
@@ -167,7 +169,7 @@ fn get_slot_id(ctx: &Ctx, slot_index: usize) -> Result<CK_SLOT_ID, HardwareIdent
     ctx.get_slot_list(true)?
         .get(slot_index)
         .ok_or(HardwareIdentityError::NoSuchSlotIndex(slot_index))
-        .map(|x| *x)
+        .copied()
 }
 
 // We open a session for the duration of the lifetime of the HardwareIdentity.
@@ -245,10 +247,10 @@ fn validate_key_type(
 
     let mut attribute_types = vec![CK_ATTRIBUTE::new(CKA_KEY_TYPE).with_ck_ulong(&kt)];
     ctx.get_attribute_value(session_handle, object_handle, &mut attribute_types)?;
-    if kt != CKK_ECDSA {
-        Err(HardwareIdentityError::UnexpectedKeyType(kt))
-    } else {
+    if kt == CKK_ECDSA {
         Ok(())
+    } else {
+        Err(HardwareIdentityError::UnexpectedKeyType(kt))
     }
 }
 
@@ -260,13 +262,13 @@ fn validate_ec_params(
     object_handle: CK_OBJECT_HANDLE,
 ) -> Result<(), HardwareIdentityError> {
     let ec_params = get_ec_params(ctx, session_handle, object_handle)?;
-    if ec_params != EXPECTED_EC_PARAMS {
+    if ec_params == EXPECTED_EC_PARAMS {
+        Ok(())
+    } else {
         Err(HardwareIdentityError::InvalidEcParams {
             expected: EXPECTED_EC_PARAMS.to_vec(),
             actual: ec_params,
         })
-    } else {
-        Ok(())
     }
 }
 
@@ -376,7 +378,7 @@ impl HardwareIdentity {
     fn sign_hash(&self, hash: &Sha256Hash) -> Result<Vec<u8>, String> {
         let private_key_handle =
             get_private_key_handle(&self.ctx, self.session_handle, &self.key_id)
-                .map_err(|e| format!("Failed to get private key handle: {}", e))?;
+                .map_err(|e| format!("Failed to get private key handle: {e}"))?;
 
         let mechanism = CK_MECHANISM {
             mechanism: CKM_ECDSA,
@@ -385,10 +387,10 @@ impl HardwareIdentity {
         };
         self.ctx
             .sign_init(self.session_handle, &mechanism, private_key_handle)
-            .map_err(|e| format!("Failed to initialize signature: {}", e))?;
+            .map_err(|e| format!("Failed to initialize signature: {e}"))?;
         self.ctx
             .sign(self.session_handle, hash)
-            .map_err(|e| format!("Failed to generate signature: {}", e))
+            .map_err(|e| format!("Failed to generate signature: {e}"))
     }
 }
 
diff --git a/ic-transport-types/src/lib.rs b/ic-transport-types/src/lib.rs
index 206bec35..125cab10 100644
--- a/ic-transport-types/src/lib.rs
+++ b/ic-transport-types/src/lib.rs
@@ -193,7 +193,7 @@ impl<T> CallResponse<Option<T>> {
 }
 
 impl<T> CallResponse<(T,)> {
-    /// Extracts the inner value of a 1-tuple, if this is `Response`.`
+    /// Extracts the inner value of a 1-tuple, if this is `Response`.
     #[inline]
     pub fn detuple(self) -> CallResponse<T> {
         match self {
@@ -272,10 +272,8 @@ impl QueryResponse {
 
     /// Helper function to get the signatures field present in both variants.
     pub fn signatures(&self) -> &[NodeSignature] {
-        match self {
-            Self::Rejected { signatures, .. } => signatures,
-            Self::Replied { signatures, .. } => signatures,
-        }
+        let (Self::Rejected { signatures, .. } | Self::Replied { signatures, .. }) = self;
+        signatures
     }
 }
 
diff --git a/ic-transport-types/src/request_id.rs b/ic-transport-types/src/request_id.rs
index 4e1f54d2..446f5d41 100644
--- a/ic-transport-types/src/request_id.rs
+++ b/ic-transport-types/src/request_id.rs
@@ -14,7 +14,12 @@ use serde::{
     Deserialize, Deserializer, Serialize, Serializer,
 };
 use sha2::{Digest, Sha256};
-use std::{io::Write, ops::Deref, str::FromStr};
+use std::{
+    fmt::{self, Display, Formatter},
+    io::Write,
+    ops::Deref,
+    str::FromStr,
+};
 
 mod error;
 #[doc(inline)]
@@ -99,6 +104,12 @@ impl From<RequestId> for String {
     }
 }
 
+impl Display for RequestId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        hex::encode(self.0).fmt(f)
+    }
+}
+
 // Request ID hashing in all contexts is implemented as a serde Serializer to eliminate any special-casing.
 struct RequestIdSerializer;
 
@@ -187,20 +198,14 @@ impl Serializer for RequestIdSerializer {
 
     // Newtypes, including Option::Some, are transparent.
 
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_some<T: Serialize + ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> {
         value.serialize(self)
     }
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T: Serialize + ?Sized>(
         self,
         _name: &'static str,
         value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
+    ) -> Result<Self::Ok, Self::Error> {
         value.serialize(self)
     }
 
@@ -252,16 +257,13 @@ impl Serializer for RequestIdSerializer {
     // We apply serde_json's handling of complex variants. That is,
     // the body is placed within a struct with one field, named the same thing as the variant.
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T: Serialize + ?Sized>(
         self,
         name: &'static str,
         _variant_index: u32,
         variant: &'static str,
         value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
+    ) -> Result<Self::Ok, Self::Error> {
         let mut s = self.serialize_struct(name, 1)?;
         SerializeStruct::serialize_field(&mut s, variant, value)?;
         SerializeStruct::end(s)
@@ -303,10 +305,7 @@ impl Serializer for RequestIdSerializer {
         false
     }
     // Optimized version of serialize_str for types that serialize by rendering themselves to strings.
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: std::fmt::Display,
-    {
+    fn collect_str<T: Display + ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> {
         let mut hasher = Sha256::new();
         write!(hasher, "{value}").map_err(|e| RequestIdError::CustomSerdeError(format!("{e}")))?;
         Ok(Some(hasher.finalize().into()))
@@ -323,14 +322,11 @@ struct StructSerializer {
 impl SerializeStruct for StructSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_field<T: ?Sized>(
+    fn serialize_field<T: Serialize + ?Sized>(
         &mut self,
         key: &'static str,
         value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    ) -> Result<(), Self::Error> {
         if let Some(hash) = value.serialize(RequestIdSerializer)? {
             self.fields
                 .push((Sha256::digest(key.as_bytes()).into(), hash));
@@ -338,7 +334,7 @@ impl SerializeStruct for StructSerializer {
         Ok(())
     }
     fn end(mut self) -> Result<Self::Ok, Self::Error> {
-        self.fields.sort();
+        self.fields.sort_unstable();
         let mut hasher = Sha256::new();
         for (key, value) in self.fields {
             hasher.update(key);
@@ -353,10 +349,7 @@ impl SerializeMap for StructSerializer {
     type Error = RequestIdError;
     // This implementation naïvely assumes serialize_key is called before serialize_value, with no checks.
     // SerializeMap's documentation states that such a case is 'allowed to panic or produce bogus results.'
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_key<T: Serialize + ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> {
         match key.serialize(RequestIdSerializer)? {
             Some(hash) => {
                 self.field_name = hash;
@@ -365,10 +358,7 @@ impl SerializeMap for StructSerializer {
             None => Err(RequestIdError::KeyWasNone),
         }
     }
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_value<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> {
         if let Some(hash) = value.serialize(RequestIdSerializer)? {
             self.fields.push((self.field_name, hash));
         }
@@ -388,10 +378,7 @@ struct SeqSerializer {
 impl SerializeSeq for SeqSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> {
         if let Some(hash) = value.serialize(RequestIdSerializer)? {
             self.elems.push(hash);
         }
@@ -409,10 +396,7 @@ impl SerializeSeq for SeqSerializer {
 impl SerializeTuple for SeqSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> {
         SerializeSeq::serialize_element(self, value)
     }
     fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -423,10 +407,7 @@ impl SerializeTuple for SeqSerializer {
 impl SerializeTupleStruct for SeqSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> {
         SerializeSeq::serialize_element(self, value)
     }
     fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -445,14 +426,11 @@ struct StructVariantSerializer {
 impl SerializeStructVariant for StructVariantSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_field<T: ?Sized>(
+    fn serialize_field<T: Serialize + ?Sized>(
         &mut self,
         key: &'static str,
         value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    ) -> Result<(), Self::Error> {
         SerializeStruct::serialize_field(&mut self.struct_ser, key, value)
     }
     fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -478,10 +456,7 @@ struct TupleVariantSerializer {
 impl SerializeTupleVariant for TupleVariantSerializer {
     type Ok = Option<Sha256Hash>;
     type Error = RequestIdError;
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
+    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> {
         SerializeSeq::serialize_element(&mut self.seq_ser, value)
     }
     fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -600,7 +575,7 @@ mod tests {
         let current = PublicSpecExampleStruct {
             request_type: "call",
             sender: Some(Principal::anonymous()),
-            ingress_expiry: Some(1685570400000000000),
+            ingress_expiry: Some(1_685_570_400_000_000_000),
             canister_id: Principal::from_slice(b"\x00\x00\x00\x00\x00\x00\x04\xD2"),
             method_name: "hello",
             arg: b"DIDL\x00\xFD*",
@@ -630,7 +605,7 @@ mod tests {
         );
     }
 
-    /// The same example as above, except we use the ApiClient enum newtypes.
+    /// The same example as above, except we use the `ApiClient` enum newtypes.
     #[test]
     fn public_spec_example_api_client() {
         #[derive(Serialize)]
@@ -648,7 +623,7 @@ mod tests {
         }
         let current = PublicSpec::Call {
             sender: Some(Principal::anonymous()),
-            ingress_expiry: Some(1685570400000000000),
+            ingress_expiry: Some(1_685_570_400_000_000_000),
             canister_id: Principal::from_slice(b"\x00\x00\x00\x00\x00\x00\x04\xD2"),
             method_name: "hello".to_owned(),
             arg: Some(b"DIDL\x00\xFD*".to_vec()),
diff --git a/ic-transport-types/src/request_id/error.rs b/ic-transport-types/src/request_id/error.rs
index 58028860..f53a6c02 100644
--- a/ic-transport-types/src/request_id/error.rs
+++ b/ic-transport-types/src/request_id/error.rs
@@ -1,7 +1,7 @@
-//! Error type for the RequestId calculation.
+//! Error type for the `RequestId` calculation.
 use thiserror::Error;
 
-/// Errors from reading a RequestId from a string. This is not the same as
+/// Errors from reading a `RequestId` from a string. This is not the same as
 /// deserialization.
 #[derive(Error, Debug)]
 pub enum RequestIdFromStringError {
@@ -14,7 +14,7 @@ pub enum RequestIdFromStringError {
     FromHexError(hex::FromHexError),
 }
 
-/// An error during the calculation of the RequestId.
+/// An error during the calculation of the `RequestId`.
 ///
 /// Since we use serde for serializing a data type into a hash, this has to support traits that
 /// serde expects, such as Display
diff --git a/ic-utils/src/call.rs b/ic-utils/src/call.rs
index 79d7ea44..845e3f2b 100644
--- a/ic-utils/src/call.rs
+++ b/ic-utils/src/call.rs
@@ -241,7 +241,7 @@ impl<'agent, Out> AsyncCaller<'agent, Out>
 where
     Out: for<'de> ArgumentDecoder<'de> + Send + 'agent,
 {
-    /// Build an UpdateBuilder call that can be used directly with the [Agent]. This is
+    /// Build an `UpdateBuilder` call that can be used directly with the [Agent]. This is
     /// essentially downleveling this type into the lower level [ic-agent] abstraction.
     pub fn build_call(self) -> Result<UpdateBuilder<'agent>, AgentError> {
         let mut builder = self.agent.update(&self.canister_id, &self.method_name);
@@ -320,7 +320,7 @@ where
     }
 }
 
-/// An AsyncCall that applies a transform function to the result of the call. Because of
+/// An `AsyncCall` that applies a transform function to the result of the call. Because of
 /// constraints on the type system in Rust, both the input and output to the function must be
 /// deserializable.
 pub struct AndThenAsyncCaller<
diff --git a/ic-utils/src/canister.rs b/ic-utils/src/canister.rs
index 50f88100..615a0afb 100644
--- a/ic-utils/src/canister.rs
+++ b/ic-utils/src/canister.rs
@@ -97,7 +97,7 @@ impl<'agent> Canister<'agent> {
         &self.canister_id
     }
 
-    /// Create an AsyncCallBuilder to do an update call.
+    /// Create an `AsyncCallBuilder` to do an update call.
     /// Prefer using [`update`](Canister::update) instead.
     pub fn update_<'canister>(
         &'canister self,
@@ -106,7 +106,7 @@ impl<'agent> Canister<'agent> {
         AsyncCallBuilder::new(self, method_name)
     }
 
-    /// Create an AsyncCallBuilder to do an update call.
+    /// Create an `AsyncCallBuilder` to do an update call.
     pub fn update<'canister>(
         &'canister self,
         method_name: &str,
@@ -114,7 +114,7 @@ impl<'agent> Canister<'agent> {
         AsyncCallBuilder::new(self, method_name)
     }
 
-    /// Create a SyncCallBuilder to do a query call.
+    /// Create a `SyncCallBuilder` to do a query call.
     /// Prefer using [`query`](Canister::query) instead.
     pub fn query_<'canister>(
         &'canister self,
@@ -123,7 +123,7 @@ impl<'agent> Canister<'agent> {
         SyncCallBuilder::new(self, method_name)
     }
 
-    /// Create a SyncCallBuilder to do a query call.
+    /// Create a `SyncCallBuilder` to do a query call.
     pub fn query<'canister>(
         &'canister self,
         method_name: &str,
@@ -131,7 +131,7 @@ impl<'agent> Canister<'agent> {
         SyncCallBuilder::new(self, method_name)
     }
 
-    /// Call request_status on the RequestId in a loop and return the response as a byte vector.
+    /// Call `request_status` on the `RequestId` in a loop and return the response as a byte vector.
     pub async fn wait<'canister>(
         &'canister self,
         request_id: &RequestId,
@@ -155,7 +155,7 @@ impl<'agent> Canister<'agent> {
         }
     }
 
-    /// Create a CanisterBuilder instance to build a canister abstraction.
+    /// Create a `CanisterBuilder` instance to build a canister abstraction.
     pub fn builder() -> CanisterBuilder<'agent> {
         Default::default()
     }
@@ -174,7 +174,7 @@ impl Argument {
         }
     }
 
-    /// Set an IDLValue Argument. Can only be called at most once.
+    /// Set an `IDLValue` Argument. Can only be called at most once.
     pub fn set_value_arg(&mut self, arg: IDLValue) {
         match self.0 {
             None => {
@@ -182,7 +182,7 @@ impl Argument {
                 let result = builder
                     .value_arg(&arg)
                     .and_then(|builder| builder.serialize_to_vec())
-                    .map_err(|e| e.into());
+                    .map_err(Into::into);
                 self.0 = Some(result);
             }
             Some(_) => panic!("argument is being set more than once"),
@@ -217,20 +217,20 @@ impl Argument {
         Self(Some(Ok(raw)))
     }
 
-    /// Creates an argument from an existing Candid ArgumentEncoder.
+    /// Creates an argument from an existing Candid `ArgumentEncoder`.
     pub fn from_candid(tuple: impl ArgumentEncoder) -> Self {
         let mut builder = IDLBuilder::new();
         let result = tuple
             .encode(&mut builder)
             .and_then(|_| builder.serialize_to_vec())
-            .map_err(|e| e.into());
+            .map_err(Into::into);
         Self(Some(result))
     }
 }
 
 /// A builder for a synchronous call (ie. query) to the Internet Computer.
 ///
-/// See [SyncCaller] for a description of this structure once built.
+/// See [`SyncCaller`] for a description of this structure once built.
 #[derive(Debug)]
 pub struct SyncCallBuilder<'agent, 'canister> {
     canister: &'canister Canister<'agent>,
@@ -240,7 +240,7 @@ pub struct SyncCallBuilder<'agent, 'canister> {
 }
 
 impl<'agent: 'canister, 'canister> SyncCallBuilder<'agent, 'canister> {
-    /// Create a new instance of an AsyncCallBuilder.
+    /// Create a new instance of an `AsyncCallBuilder`.
     pub(super) fn new<M: Into<String>>(
         canister: &'canister Canister<'agent>,
         method_name: M,
@@ -265,14 +265,12 @@ impl<'agent: 'canister, 'canister> SyncCallBuilder<'agent, 'canister> {
     }
     /// Set the argument with multiple arguments as tuple. Can be called at most once.
     pub fn with_args(mut self, tuple: impl ArgumentEncoder) -> Self {
-        if self.arg.0.is_some() {
-            panic!("argument is being set more than once");
-        }
+        assert!(self.arg.0.is_none(), "argument is being set more than once");
         self.arg = Argument::from_candid(tuple);
         self
     }
 
-    /// Set the argument with IDLValue argument. Can be called at most once.
+    /// Set the argument with `IDLValue` argument. Can be called at most once.
     ///
     /// TODO: make this method unnecessary ([#132](https://github.com/dfinity/agent-rs/issues/132))
     pub fn with_value_arg(mut self, arg: IDLValue) -> Self {
@@ -292,7 +290,7 @@ impl<'agent: 'canister, 'canister> SyncCallBuilder<'agent, 'canister> {
         self
     }
 
-    /// Builds a [SyncCaller] from this builder's state.
+    /// Builds a [`SyncCaller`] from this builder's state.
     pub fn build<Output>(self) -> SyncCaller<'agent, Output>
     where
         Output: for<'de> ArgumentDecoder<'de> + Send + Sync,
@@ -312,7 +310,7 @@ impl<'agent: 'canister, 'canister> SyncCallBuilder<'agent, 'canister> {
 
 /// A builder for an asynchronous call (ie. update) to the Internet Computer.
 ///
-/// See [AsyncCaller] for a description of this structure.
+/// See [`AsyncCaller`] for a description of this structure.
 #[derive(Debug)]
 pub struct AsyncCallBuilder<'agent, 'canister> {
     canister: &'canister Canister<'agent>,
@@ -322,7 +320,7 @@ pub struct AsyncCallBuilder<'agent, 'canister> {
 }
 
 impl<'agent: 'canister, 'canister> AsyncCallBuilder<'agent, 'canister> {
-    /// Create a new instance of an AsyncCallBuilder.
+    /// Create a new instance of an `AsyncCallBuilder`.
     pub(super) fn new(
         canister: &'canister Canister<'agent>,
         method_name: &str,
@@ -347,9 +345,7 @@ impl<'agent: 'canister, 'canister> AsyncCallBuilder<'agent, 'canister> {
     }
     /// Set the argument with multiple arguments as tuple. Can be called at most once.
     pub fn with_args(mut self, tuple: impl ArgumentEncoder) -> Self {
-        if self.arg.0.is_some() {
-            panic!("argument is being set more than once");
-        }
+        assert!(self.arg.0.is_none(), "argument is being set more than once");
         self.arg = Argument::from_candid(tuple);
         self
     }
@@ -366,7 +362,7 @@ impl<'agent: 'canister, 'canister> AsyncCallBuilder<'agent, 'canister> {
         self
     }
 
-    /// Builds an [AsyncCaller] from this builder's state.
+    /// Builds an [`AsyncCaller`] from this builder's state.
     pub fn build<Output>(self) -> AsyncCaller<'agent, Output>
     where
         Output: for<'de> ArgumentDecoder<'de> + Send + Sync,
diff --git a/ic-utils/src/interfaces/bitcoin_canister.rs b/ic-utils/src/interfaces/bitcoin_canister.rs
index 184c7ce8..f34ca52e 100644
--- a/ic-utils/src/interfaces/bitcoin_canister.rs
+++ b/ic-utils/src/interfaces/bitcoin_canister.rs
@@ -269,7 +269,7 @@ pub struct GetUtxosResponse {
     pub next_page: Option<Vec<u8>>,
 }
 
-/// Response type for the ``.
+/// Response type for the [`BitcoinCanister::get_block_headers`] function.
 #[derive(Debug, Clone, CandidType, Deserialize)]
 pub struct GetBlockHeadersResponse {
     /// The tip of the chain, current to when the headers were fetched.
diff --git a/ic-utils/src/interfaces/http_request.rs b/ic-utils/src/interfaces/http_request.rs
index fa5ee82f..ab7e7363 100644
--- a/ic-utils/src/interfaces/http_request.rs
+++ b/ic-utils/src/interfaces/http_request.rs
@@ -576,13 +576,13 @@ mod test {
         fn decode<C: CandidType + DeserializeOwned>(bytes: &[u8]) {
             let response = Decode!(bytes, HttpResponse::<_, C>).unwrap();
             assert_eq!(response.status_code, 100);
-            let token = match response.streaming_strategy {
-                Some(StreamingStrategy::Callback(CallbackStrategy { token, .. })) => token,
-                _ => panic!("streaming_strategy was missing"),
+            let Some(StreamingStrategy::Callback(CallbackStrategy { token, .. })) =
+                response.streaming_strategy
+            else {
+                panic!("streaming_strategy was missing");
             };
-            let fields = match token {
-                Token(IDLValue::Record(fields)) => fields,
-                _ => panic!("token type mismatched {:?}", token),
+            let Token(IDLValue::Record(fields)) = token else {
+                panic!("token type mismatched {token:?}");
             };
             assert!(fields.contains(&IDLField {
                 id: Label::Named("key".into()),
@@ -669,9 +669,8 @@ mod test {
 
         let response = Decode!(&bytes, StreamingCallbackHttpResponse).unwrap();
         assert_eq!(response.body, b"this is a body");
-        let fields = match response.token {
-            Some(Token(IDLValue::Record(fields))) => fields,
-            _ => panic!("token type mismatched {:?}", response.token),
+        let Some(Token(IDLValue::Record(fields))) = response.token else {
+            panic!("token type mismatched {:?}", response.token);
         };
         assert!(fields.contains(&IDLField {
             id: Label::Named("key".into()),
diff --git a/ic-utils/src/interfaces/management_canister.rs b/ic-utils/src/interfaces/management_canister.rs
index 485880a0..ffdf2420 100644
--- a/ic-utils/src/interfaces/management_canister.rs
+++ b/ic-utils/src/interfaces/management_canister.rs
@@ -112,7 +112,7 @@ impl<'agent> ManagementCanister<'agent> {
 }
 
 /// The complete canister status information of a canister. This includes
-/// the CanisterStatus, a hash of the module installed on the canister (None if nothing installed),
+/// the `CanisterStatus`, a hash of the module installed on the canister (None if nothing installed),
 /// the controller of the canister, the canister's memory size, and its balance in cycles.
 #[derive(Clone, Debug, Deserialize, CandidType)]
 pub struct StatusCallResult {
@@ -236,10 +236,10 @@ pub struct ChunkHash {
     pub hash: Vec<u8>,
 }
 
-/// Return type of [ManagementCanister::stored_chunks].
+/// Return type of [`ManagementCanister::stored_chunks`].
 pub type StoreChunksResult = Vec<ChunkHash>;
 
-/// Return type of [ManagementCanister::upload_chunk].
+/// Return type of [`ManagementCanister::upload_chunk`].
 pub type UploadChunkResult = ChunkHash;
 
 /// A recorded snapshot of a canister. Can be restored with [`ManagementCanister::load_canister_snapshot`].
@@ -311,9 +311,9 @@ impl<'agent> ManagementCanister<'agent> {
     }
 
     /// Until developers can convert real ICP tokens to a top up an existing canister,
-    /// the system provides the provisional_top_up_canister method.
+    /// the system provides the `provisional_top_up_canister` method.
     /// It adds amount cycles to the balance of canister identified by amount
-    /// (implicitly capping it at MAX_CANISTER_BALANCE).
+    /// (implicitly capping it at `MAX_CANISTER_BALANCE`).
     pub fn provisional_top_up_canister(
         &self,
         canister_id: &Principal,
diff --git a/ic-utils/src/interfaces/management_canister/attributes.rs b/ic-utils/src/interfaces/management_canister/attributes.rs
index 3134e644..d0f00ea4 100644
--- a/ic-utils/src/interfaces/management_canister/attributes.rs
+++ b/ic-utils/src/interfaces/management_canister/attributes.rs
@@ -157,7 +157,7 @@ pub enum ReservedCyclesLimitError {
 
 /// A reserved cycles limit for a canister. Can be anywhere from 0 to 2^128-1 inclusive.
 ///
-/// This represents the upper limit of reserved_cycles for the canister.
+/// This represents the upper limit of `reserved_cycles` for the canister.
 ///
 /// Reserved cycles are cycles that the system sets aside for future use by the canister.
 /// If a subnet's storage exceeds 450 GiB, then every time a canister allocates new storage bytes,
@@ -337,7 +337,7 @@ fn can_convert_reserved_cycles_limit() {
 
     assert_eq!(
         ReservedCyclesLimit::try_from(2u128.pow(127) + 6).unwrap().0,
-        170141183460469231731687303715884105734u128
+        170_141_183_460_469_231_731_687_303_715_884_105_734_u128
     );
 
     let ft = ReservedCyclesLimit(100);
@@ -368,7 +368,7 @@ fn can_convert_wasm_memory_limit() {
     ));
 
     assert!(matches!(
-        WasmMemoryLimit::try_from(562949953421312_u64).unwrap_err(),
-        WasmMemoryLimitError::InvalidMemoryLimit(562949953421312)
+        WasmMemoryLimit::try_from(562_949_953_421_312_u64).unwrap_err(),
+        WasmMemoryLimitError::InvalidMemoryLimit(562_949_953_421_312)
     ));
 }
diff --git a/ic-utils/src/interfaces/management_canister/builders.rs b/ic-utils/src/interfaces/management_canister/builders.rs
index f81d19af..623c3cac 100644
--- a/ic-utils/src/interfaces/management_canister/builders.rs
+++ b/ic-utils/src/interfaces/management_canister/builders.rs
@@ -52,7 +52,7 @@ pub struct CanisterSettings {
     /// If unspecified and a canister is being created with these settings, defaults to 2592000, i.e. ~30 days.
     pub freezing_threshold: Option<Nat>,
 
-    /// The upper limit of reserved_cycles for the canister.
+    /// The upper limit of `reserved_cycles` for the canister.
     ///
     /// Reserved cycles are cycles that the system sets aside for future use by the canister.
     /// If a subnet's storage exceeds 450 GiB, then every time a canister allocates new storage bytes,
@@ -100,7 +100,7 @@ pub struct CreateCanisterBuilder<'agent, 'canister: 'agent> {
 }
 
 impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
-    /// Create an CreateCanister builder, which is also an AsyncCall implementation.
+    /// Create an `CreateCanister` builder, which is also an `AsyncCall` implementation.
     pub fn builder(canister: &'canister Canister<'agent>) -> Self {
         Self {
             canister,
@@ -119,10 +119,10 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
     }
 
     /// Until developers can convert real ICP tokens to provision a new canister with cycles,
-    /// the system provides the provisional_create_canister_with_cycles method.
-    /// It behaves as create_canister, but initializes the canister’s balance with amount fresh cycles
-    /// (using MAX_CANISTER_BALANCE if amount = null, else capping the balance at MAX_CANISTER_BALANCE).
-    /// Cycles added to this call via ic0.call_cycles_add are returned to the caller.
+    /// the system provides the `provisional_create_canister_with_cycles` method.
+    /// It behaves as `create_canister`, but initializes the canister’s balance with amount fresh cycles
+    /// (using `MAX_CANISTER_BALANCE` if amount = null, else capping the balance at `MAX_CANISTER_BALANCE`).
+    /// Cycles added to this call via `ic0.call_cycles_add` are returned to the caller.
     /// This method is only available in local development instances, and will be removed in the future.
     #[allow(clippy::wrong_self_convention)]
     pub fn as_provisional_create_with_amount(self, amount: Option<u128>) -> Self {
@@ -135,7 +135,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
 
     /// Specify the canister id.
     ///
-    /// The effective_canister_id will also be set with the same value so that ic-ref can determine
+    /// The `effective_canister_id` will also be set with the same value so that ic-ref can determine
     /// the target subnet of this request. The replica implementation ignores it.
     pub fn as_provisional_create_with_specified_id(self, specified_id: Principal) -> Self {
         Self {
@@ -170,7 +170,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
     {
         let controller_to_add: Option<Result<Principal, _>> = controller.map(|ca| {
             ca.try_into()
-                .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                .map_err(|e| AgentError::MessageError(format!("{e}")))
         });
         let controllers: Option<Result<Vec<Principal>, _>> =
             match (controller_to_add, self.controllers) {
@@ -209,7 +209,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
         Self {
             compute_allocation: compute_allocation.map(|ca| {
                 ca.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -234,7 +234,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
         Self {
             memory_allocation: memory_allocation.map(|ma| {
                 ma.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -259,7 +259,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
         Self {
             freezing_threshold: freezing_threshold.map(|ma| {
                 ma.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -294,7 +294,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
             reserved_cycles_limit: limit.map(|limit| {
                 limit
                     .try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -320,7 +320,7 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
             wasm_memory_limit: wasm_memory_limit.map(|limit| {
                 limit
                     .try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -346,47 +346,47 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
             log_visibility: log_visibility.map(|visibility| {
                 visibility
                     .try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
     }
 
-    /// Create an [AsyncCall] implementation that, when called, will create a
+    /// Create an [`AsyncCall`] implementation that, when called, will create a
     /// canister.
     pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = (Principal,)>, AgentError> {
         let controllers = match self.controllers {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(x),
             None => None,
         };
         let compute_allocation = match self.compute_allocation {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u8::from(x))),
             None => None,
         };
         let memory_allocation = match self.memory_allocation {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let freezing_threshold = match self.freezing_threshold {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let reserved_cycles_limit = match self.reserved_cycles_limit {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u128::from(x))),
             None => None,
         };
         let wasm_memory_limit = match self.wasm_memory_limit {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let log_visibility = match self.log_visibility {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(x),
             None => None,
         };
@@ -440,12 +440,12 @@ impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
             .map(|result: (Out,)| (result.0.canister_id,)))
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call].
+    /// Make a call. This is equivalent to the [`AsyncCall::call`].
     pub async fn call(self) -> Result<CallResponse<(Principal,)>, AgentError> {
         self.build()?.call().await
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call_and_wait].
+    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
     pub async fn call_and_wait(self) -> Result<(Principal,), AgentError> {
         self.build()?.call_and_wait().await
     }
@@ -496,8 +496,8 @@ pub struct CanisterUpgradeOptions {
 }
 
 /// The install mode of the canister to install. If a canister is already installed,
-/// using [InstallMode::Install] will be an error. [InstallMode::Reinstall] overwrites
-/// the module, and [InstallMode::Upgrade] performs an Upgrade step.
+/// using [`InstallMode::Install`] will be an error. [`InstallMode::Reinstall`] overwrites
+/// the module, and [`InstallMode::Upgrade`] performs an Upgrade step.
 #[derive(Debug, Copy, Clone, CandidType, Deserialize, Eq, PartialEq)]
 pub enum InstallMode {
     /// Install the module into the empty canister.
@@ -534,7 +534,7 @@ impl FromStr for InstallMode {
             "install" => Ok(InstallMode::Install),
             "reinstall" => Ok(InstallMode::Reinstall),
             "upgrade" => Ok(InstallMode::Upgrade(None)),
-            &_ => Err(format!("Invalid install mode: {}", s)),
+            &_ => Err(format!("Invalid install mode: {s}")),
         }
     }
 }
@@ -550,7 +550,7 @@ pub struct InstallCodeBuilder<'agent, 'canister: 'agent> {
 }
 
 impl<'agent, 'canister: 'agent> InstallCodeBuilder<'agent, 'canister> {
-    /// Create an InstallCode builder, which is also an AsyncCall implementation.
+    /// Create an `InstallCode` builder, which is also an `AsyncCall` implementation.
     pub fn builder(
         canister: &'canister Canister<'agent>,
         canister_id: &Principal,
@@ -587,7 +587,7 @@ impl<'agent, 'canister: 'agent> InstallCodeBuilder<'agent, 'canister> {
         self
     }
 
-    /// Pass in the [InstallMode].
+    /// Pass in the [`InstallMode`].
     pub fn with_mode(self, mode: InstallMode) -> Self {
         Self {
             mode: Some(mode),
@@ -595,7 +595,7 @@ impl<'agent, 'canister: 'agent> InstallCodeBuilder<'agent, 'canister> {
         }
     }
 
-    /// Create an [AsyncCall] implementation that, when called, will install the
+    /// Create an [`AsyncCall`] implementation that, when called, will install the
     /// canister.
     pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError> {
         Ok(self
@@ -611,12 +611,12 @@ impl<'agent, 'canister: 'agent> InstallCodeBuilder<'agent, 'canister> {
             .build())
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call].
+    /// Make a call. This is equivalent to the [`AsyncCall::call`].
     pub async fn call(self) -> Result<CallResponse<()>, AgentError> {
         self.build()?.call().await
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call_and_wait].
+    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
     pub async fn call_and_wait(self) -> Result<(), AgentError> {
         self.build()?.call_and_wait().await
     }
@@ -840,7 +840,7 @@ impl<'agent: 'canister, 'canister: 'builder, 'builder> InstallBuilder<'agent, 'c
         self
     }
 
-    /// Pass in the [InstallMode].
+    /// Pass in the [`InstallMode`].
     pub fn with_mode(self, mode: InstallMode) -> Self {
         Self { mode, ..self }
     }
@@ -895,7 +895,7 @@ impl<'agent: 'canister, 'canister: 'builder, 'builder> InstallBuilder<'agent, 'c
                                 .call_and_wait()
                                 .await?;
                             Ok(())
-                        })
+                        });
                     }
                     let install_chunked_code_stream = async move {
                         let results = all_chunks.iter().map(|(hash,_)| ChunkHash{ hash: hash.clone() }).collect();
@@ -960,7 +960,7 @@ pub struct UpdateCanisterBuilder<'agent, 'canister: 'agent> {
 }
 
 impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
-    /// Create an UpdateCanister builder, which is also an AsyncCall implementation.
+    /// Create an `UpdateCanister` builder, which is also an `AsyncCall` implementation.
     pub fn builder(canister: &'canister Canister<'agent>, canister_id: &Principal) -> Self {
         Self {
             canister,
@@ -984,7 +984,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
     {
         let controller_to_add: Option<Result<Principal, _>> = controller.map(|ca| {
             ca.try_into()
-                .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                .map_err(|e| AgentError::MessageError(format!("{e}")))
         });
         let controllers: Option<Result<Vec<Principal>, _>> =
             match (controller_to_add, self.controllers) {
@@ -1024,7 +1024,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
         Self {
             compute_allocation: compute_allocation.map(|ca| {
                 ca.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -1049,7 +1049,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
         Self {
             memory_allocation: memory_allocation.map(|ma| {
                 ma.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -1074,7 +1074,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
         Self {
             freezing_threshold: freezing_threshold.map(|ma| {
                 ma.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -1108,7 +1108,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
         Self {
             reserved_cycles_limit: limit.map(|ma| {
                 ma.try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -1134,7 +1134,7 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
             wasm_memory_limit: wasm_memory_limit.map(|limit| {
                 limit
                     .try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
@@ -1160,13 +1160,13 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
             log_visibility: log_visibility.map(|limit| {
                 limit
                     .try_into()
-                    .map_err(|e| AgentError::MessageError(format!("{}", e)))
+                    .map_err(|e| AgentError::MessageError(format!("{e}")))
             }),
             ..self
         }
     }
 
-    /// Create an [AsyncCall] implementation that, when called, will update a
+    /// Create an [`AsyncCall`] implementation that, when called, will update a
     /// canisters settings.
     pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError> {
         #[derive(CandidType)]
@@ -1176,37 +1176,37 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
         }
 
         let controllers = match self.controllers {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(x),
             None => None,
         };
         let compute_allocation = match self.compute_allocation {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u8::from(x))),
             None => None,
         };
         let memory_allocation = match self.memory_allocation {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let freezing_threshold = match self.freezing_threshold {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let reserved_cycles_limit = match self.reserved_cycles_limit {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u128::from(x))),
             None => None,
         };
         let wasm_memory_limit = match self.wasm_memory_limit {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(Nat::from(u64::from(x))),
             None => None,
         };
         let log_visibility = match self.log_visibility {
-            Some(Err(x)) => return Err(AgentError::MessageError(format!("{}", x))),
+            Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
             Some(Ok(x)) => Some(x),
             None => None,
         };
@@ -1230,12 +1230,12 @@ impl<'agent, 'canister: 'agent> UpdateCanisterBuilder<'agent, 'canister> {
             .build())
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call].
+    /// Make a call. This is equivalent to the [`AsyncCall::call`].
     pub async fn call(self) -> Result<CallResponse<()>, AgentError> {
         self.build()?.call().await
     }
 
-    /// Make a call. This is equivalent to the [AsyncCall::call_and_wait].
+    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
     pub async fn call_and_wait(self) -> Result<(), AgentError> {
         self.build()?.call_and_wait().await
     }
diff --git a/ic-utils/src/interfaces/wallet.rs b/ic-utils/src/interfaces/wallet.rs
index a93041b8..f9019076 100644
--- a/ic-utils/src/interfaces/wallet.rs
+++ b/ic-utils/src/interfaces/wallet.rs
@@ -95,14 +95,14 @@ where
             self.wallet.update("wallet_call128").with_arg(In {
                 canister: self.destination,
                 method_name: self.method_name,
-                args: self.arg.serialize()?.to_vec(),
+                args: self.arg.serialize()?,
                 cycles: self.amount,
             })
         } else {
             self.wallet.update("wallet_call").with_arg(In {
                 canister: self.destination,
                 method_name: self.method_name,
-                args: self.arg.serialize()?.to_vec(),
+                args: self.arg.serialize()?,
                 cycles: u64::try_from(self.amount).map_err(|_| {
                     AgentError::WalletUpgradeRequired(
                         "The installed wallet does not support cycle counts >2^64-1".to_string(),
@@ -239,21 +239,21 @@ impl From<EventKind<u64>> for EventKind {
                 method_name,
             } => CanisterCalled {
                 canister,
-                cycles: cycles as u128,
+                cycles: cycles.into(),
                 method_name,
             },
             CanisterCreated { canister, cycles } => CanisterCreated {
                 canister,
-                cycles: cycles as u128,
+                cycles: cycles.into(),
             },
             CyclesReceived { amount, from, memo } => CyclesReceived {
-                amount: amount as u128,
+                amount: amount.into(),
                 from,
                 memo,
             },
             CyclesSent { amount, refund, to } => CyclesSent {
-                amount: amount as u128,
-                refund: refund as u128,
+                amount: amount.into(),
+                refund: refund.into(),
                 to,
             },
         }
@@ -365,15 +365,15 @@ impl From<ManagedCanisterEventKind<u64>> for ManagedCanisterEventKind {
                 cycles,
                 method_name,
             } => Called {
-                cycles: cycles as u128,
+                cycles: cycles.into(),
                 method_name,
             },
             Created { cycles } => Created {
-                cycles: cycles as u128,
+                cycles: cycles.into(),
             },
             CyclesSent { amount, refund } => CyclesSent {
-                amount: amount as u128,
-                refund: refund as u128,
+                amount: amount.into(),
+                refund: refund.into(),
             },
         }
     }
@@ -543,7 +543,7 @@ impl<'agent> WalletCanister<'agent> {
                 .call()
                 .await
                 .map(|(r,)| BalanceResult {
-                    amount: r.amount as u128,
+                    amount: r.amount.into(),
                 })
         }
     }
@@ -932,7 +932,7 @@ impl<'agent> WalletCanister<'agent> {
     }
 
     /// Store the wallet WASM inside the wallet canister.
-    /// This is needed to enable wallet_create_wallet
+    /// This is needed to enable `wallet_create_wallet`
     pub fn wallet_store_wallet_wasm(
         &self,
         wasm_module: Vec<u8>,
@@ -1017,7 +1017,7 @@ impl<'agent> WalletCanister<'agent> {
             self.get_events64(from, to)
                 .call()
                 .await
-                .map(|(events,)| events.into_iter().map(|event| event.into()).collect())
+                .map(|(events,)| events.into_iter().map(Event::into).collect())
         }
     }
 
@@ -1037,7 +1037,7 @@ impl<'agent> WalletCanister<'agent> {
             wallet: self,
             destination,
             method_name: method_name.into(),
-            amount: amount as u128,
+            amount: amount.into(),
             arg,
             phantom_out: std::marker::PhantomData,
             u128: false,
@@ -1159,7 +1159,8 @@ impl<'agent> WalletCanister<'agent> {
                 .call()
                 .await
                 .map(|(events,)| {
-                    events.map(|events| events.into_iter().map(|event| event.into()).collect())
+                    events
+                        .map(|events| events.into_iter().map(ManagedCanisterEvent::into).collect())
                 })
         }
     }
diff --git a/icx-cert/src/pprint.rs b/icx-cert/src/pprint.rs
index 852843c4..be0b6fee 100644
--- a/icx-cert/src/pprint.rs
+++ b/icx-cert/src/pprint.rs
@@ -99,16 +99,13 @@ pub fn pprint(url: String, accept_encodings: Option<Vec<String>>) -> Result<()>
         .bytes()
         .with_context(|| "failed to get response body")?;
     let certificate_str = certificate_header.to_str().with_context(|| {
-        format!(
-            "failed to convert certificate header {:?} to string",
-            certificate_header
-        )
+        format!("failed to convert certificate header {certificate_header:?} to string")
     })?;
     let structured_header = parse_structured_cert_header(certificate_str)?;
     let tree: HashTree = parse_base64_cbor(structured_header.tree)?;
     let cert: ReplicaCertificate = parse_base64_cbor(structured_header.certificate)?;
 
-    println!("STATUS: {}", status);
+    println!("STATUS: {status}");
     println!("ROOT HASH: {}", hex::encode(cert.tree.digest()));
     if let Some(content_encoding) = content_encoding {
         println!("CONTENT-ENCODING: {}", content_encoding.to_str().unwrap());
@@ -122,12 +119,12 @@ pub fn pprint(url: String, accept_encodings: Option<Vec<String>>) -> Result<()>
     if let LookupResult::Found(mut date_bytes) = cert.tree.lookup_path(&["time"]) {
         let timestamp_nanos = leb128::read::unsigned(&mut date_bytes)
             .with_context(|| "failed to decode certificate time as LEB128")?;
-        let dt = OffsetDateTime::from_unix_timestamp_nanos(timestamp_nanos as i128)
+        let dt = OffsetDateTime::from_unix_timestamp_nanos(timestamp_nanos.into())
             .context("timestamp out of range")?;
         println!("CERTIFICATE TIME: {}", dt.format(&Rfc3339)?);
     }
     println!("CERTIFICATE TREE: {:#?}", cert.tree);
-    println!("TREE:             {:#?}", tree);
+    println!("TREE:             {tree:#?}");
     Ok(())
 }
 
diff --git a/icx/src/main.rs b/icx/src/main.rs
index 450ba721..d82aa287 100644
--- a/icx/src/main.rs
+++ b/icx/src/main.rs
@@ -115,7 +115,7 @@ impl std::str::FromStr for ArgType {
         match s {
             "idl" => Ok(ArgType::Idl),
             "raw" => Ok(ArgType::Raw),
-            other => Err(format!("invalid argument type: {}", other)),
+            other => Err(format!("invalid argument type: {other}")),
         }
     }
 }
@@ -130,25 +130,21 @@ struct PrincipalConvertOpts {
     to_hex: Option<String>,
 }
 
-/// Parse IDL file into TypeEnv. This is a best effort function: it will succeed if
+/// Parse IDL file into `TypeEnv`. This is a best effort function: it will succeed if
 /// the IDL file can be parsed and type checked in Rust parser, and has an
 /// actor in the IDL file. If anything fails, it returns None.
 pub fn get_candid_type(
     idl_path: &std::path::Path,
     method_name: &str,
 ) -> Result<Option<(TypeEnv, Function)>> {
-    let (env, ty) = check_candid_file(idl_path).with_context(|| {
-        format!(
-            "Failed when checking candid file: {}",
-            idl_path.to_string_lossy()
-        )
-    })?;
+    let (env, ty) = check_candid_file(idl_path)
+        .with_context(|| format!("Failed when checking candid file: {}", idl_path.display()))?;
     match ty {
         None => Ok(None),
         Some(actor) => {
             let method = env
                 .get_method(&actor, method_name)
-                .with_context(|| format!("Failed to get method: {}", method_name))?
+                .with_context(|| format!("Failed to get method: {method_name}"))?
                 .clone();
             Ok(Some((env, method)))
         }
@@ -158,17 +154,14 @@ pub fn get_candid_type(
 pub fn check_candid_file(idl_path: &std::path::Path) -> Result<(TypeEnv, Option<Type>)> {
     let idl_file = std::fs::read_to_string(idl_path)
         .with_context(|| format!("Failed to read Candid file: {}", idl_path.to_string_lossy()))?;
-    let ast = idl_file.parse::<IDLProg>().with_context(|| {
-        format!(
-            "Failed to parse the Candid file: {}",
-            idl_path.to_string_lossy()
-        )
-    })?;
+    let ast = idl_file
+        .parse::<IDLProg>()
+        .with_context(|| format!("Failed to parse the Candid file: {}", idl_path.display()))?;
     let mut env = TypeEnv::new();
     let actor = check_prog(&mut env, &ast).with_context(|| {
         format!(
             "Failed to type check the Candid file: {}",
-            idl_path.to_string_lossy()
+            idl_path.display()
         )
     })?;
     Ok((env, actor))
@@ -237,7 +230,7 @@ fn print_idl_blob(
     let hex_string = hex::encode(blob);
     match output_type {
         ArgType::Raw => {
-            println!("{}", hex_string);
+            println!("{hex_string}");
         }
         ArgType::Idl => {
             let result = match method_type {
@@ -246,7 +239,7 @@ fn print_idl_blob(
             };
             println!(
                 "{}",
-                result.with_context(|| format!("Failed to deserialize blob 0x{}", hex_string))?
+                result.with_context(|| format!("Failed to deserialize blob 0x{hex_string}"))?
             );
         }
     }
@@ -271,10 +264,7 @@ pub fn get_effective_canister_id(
 ) -> Result<Principal> {
     if is_management_canister {
         let method_name = MgmtMethod::from_str(method_name).with_context(|| {
-            format!(
-                "Attempted to call an unsupported management canister method: {}",
-                method_name
-            )
+            format!("Attempted to call an unsupported management canister method: {method_name}")
         })?;
         match method_name {
             MgmtMethod::CreateCanister | MgmtMethod::RawRand => bail!(
@@ -367,7 +357,7 @@ async fn main() -> Result<()> {
     match &opts.subcommand {
         SubCommand::Update(t) | SubCommand::Query(t) => {
             let maybe_candid_path = t.candid.as_ref();
-            let expire_after: Option<std::time::Duration> = opts.ttl.map(|ht| ht.into());
+            let expire_after: Option<std::time::Duration> = opts.ttl.map(Into::into);
 
             let method_type = match maybe_candid_path {
                 None => None,
@@ -386,7 +376,51 @@ async fn main() -> Result<()> {
             )
             .context("Failed to get effective_canister_id for this call")?;
 
-            if !t.serialize {
+            if t.serialize {
+                match &opts.subcommand {
+                    SubCommand::Update(_) => {
+                        // For local emulator, we need to fetch the root key for updates.
+                        // So on an air-gapped machine, we can only generate message for the IC main net
+                        // which agent hard-coded its root key
+                        fetch_root_key_from_non_ic(&agent, &opts.replica).await?;
+
+                        let mut builder = agent.update(&t.canister_id, &t.method_name);
+                        if let Some(d) = expire_after {
+                            builder = builder.expire_after(d);
+                        }
+                        let signed_update = builder
+                            .with_arg(arg)
+                            .with_effective_canister_id(effective_canister_id)
+                            .sign()
+                            .context("Failed to sign the update call")?;
+                        let serialized = serde_json::to_string(&signed_update).unwrap();
+                        println!("{serialized}");
+
+                        let signed_request_status = agent
+                            .sign_request_status(effective_canister_id, signed_update.request_id)
+                            .context(
+                                "Failed to sign the request_status call accompany with the update",
+                            )?;
+                        let serialized = serde_json::to_string(&signed_request_status).unwrap();
+                        println!("{serialized}");
+                    }
+                    &SubCommand::Query(_) => {
+                        fetch_root_key_from_non_ic(&agent, &opts.replica).await?;
+                        let mut builder = agent.query(&t.canister_id, &t.method_name);
+                        if let Some(d) = expire_after {
+                            builder = builder.expire_after(d);
+                        }
+                        let signed_query = builder
+                            .with_arg(arg)
+                            .with_effective_canister_id(effective_canister_id)
+                            .sign()
+                            .context("Failed to sign the query call")?;
+                        let serialized = serde_json::to_string(&signed_query).unwrap();
+                        println!("{serialized}");
+                    }
+                    _ => unreachable!(),
+                }
+            } else {
                 let result = match &opts.subcommand {
                     SubCommand::Update(_) => {
                         // We need to fetch the root key for updates.
@@ -443,11 +477,11 @@ async fn main() -> Result<()> {
                         content,
                     })) => {
                         let mut error_message =
-                            format!("Server returned an HTTP Error:\n  Code: {}\n", status);
+                            format!("Server returned an HTTP Error:\n  Code: {status}\n");
                         match content_type.as_deref() {
                             None => error_message
                                 .push_str(&format!("  Content: {}\n", hex::encode(content))),
-                            Some("text/plain; charset=UTF-8") | Some("text/plain") => {
+                            Some("text/plain; charset=UTF-8" | "text/plain") => {
                                 error_message.push_str("  ContentType: text/plain\n");
                                 error_message.push_str(&format!(
                                     "  Content:     {}\n",
@@ -455,7 +489,7 @@ async fn main() -> Result<()> {
                                 ));
                             }
                             Some(x) => {
-                                error_message.push_str(&format!("  ContentType: {}\n", x));
+                                error_message.push_str(&format!("  ContentType: {x}\n"));
                                 error_message.push_str(&format!(
                                     "  Content:     {}\n",
                                     hex::encode(&content)
@@ -466,50 +500,6 @@ async fn main() -> Result<()> {
                     }
                     Err(s) => Err(s).context("Got an error when make the canister call")?,
                 }
-            } else {
-                match &opts.subcommand {
-                    SubCommand::Update(_) => {
-                        // For local emulator, we need to fetch the root key for updates.
-                        // So on an air-gapped machine, we can only generate message for the IC main net
-                        // which agent hard-coded its root key
-                        fetch_root_key_from_non_ic(&agent, &opts.replica).await?;
-
-                        let mut builder = agent.update(&t.canister_id, &t.method_name);
-                        if let Some(d) = expire_after {
-                            builder = builder.expire_after(d);
-                        }
-                        let signed_update = builder
-                            .with_arg(arg)
-                            .with_effective_canister_id(effective_canister_id)
-                            .sign()
-                            .context("Failed to sign the update call")?;
-                        let serialized = serde_json::to_string(&signed_update).unwrap();
-                        println!("{}", serialized);
-
-                        let signed_request_status = agent
-                            .sign_request_status(effective_canister_id, signed_update.request_id)
-                            .context(
-                                "Failed to sign the request_status call accompany with the update",
-                            )?;
-                        let serialized = serde_json::to_string(&signed_request_status).unwrap();
-                        println!("{}", serialized);
-                    }
-                    &SubCommand::Query(_) => {
-                        fetch_root_key_from_non_ic(&agent, &opts.replica).await?;
-                        let mut builder = agent.query(&t.canister_id, &t.method_name);
-                        if let Some(d) = expire_after {
-                            builder = builder.expire_after(d);
-                        }
-                        let signed_query = builder
-                            .with_arg(arg)
-                            .with_effective_canister_id(effective_canister_id)
-                            .sign()
-                            .context("Failed to sign the query call")?;
-                        let serialized = serde_json::to_string(&signed_query).unwrap();
-                        println!("{}", serialized);
-                    }
-                    _ => unreachable!(),
-                }
             }
         }
         SubCommand::Status => {
@@ -517,13 +507,13 @@ async fn main() -> Result<()> {
                 .status()
                 .await
                 .context("Failed to get network status")?;
-            println!("{:#}", status);
+            println!("{status:#}");
         }
         SubCommand::PrincipalConvert(t) => {
             if let Some(hex) = &t.from_hex {
                 let p = Principal::try_from(hex::decode(hex).expect("Could not decode hex: {}"))
                     .expect("Could not transform into a Principal: {}");
-                eprintln!("Principal: {}", p);
+                eprintln!("Principal: {p}");
             } else if let Some(txt) = &t.to_hex {
                 let p = Principal::from_text(txt.as_str())
                     .expect("Could not transform into a Principal: {}");
@@ -541,7 +531,7 @@ async fn main() -> Result<()> {
                 buffer.push_str(&line);
             }
 
-            println!("{}", buffer);
+            println!("{buffer}");
 
             if let Ok(signed_update) = serde_json::from_str::<SignedUpdate>(&buffer) {
                 fetch_root_key_from_non_ic(&agent, &opts.replica).await?;
diff --git a/ref-tests/tests/ic-ref.rs b/ref-tests/tests/ic-ref.rs
index b0fb6975..fa005d7e 100644
--- a/ref-tests/tests/ic-ref.rs
+++ b/ref-tests/tests/ic-ref.rs
@@ -892,7 +892,7 @@ mod management_canister {
     fn subnet_metrics() {
         with_universal_canister(|agent, _| async move {
             let metrics = agent
-                .read_state_subnet_metrics(Principal::self_authenticating(&agent.read_root_key()))
+                .read_state_subnet_metrics(Principal::self_authenticating(agent.read_root_key()))
                 .await?;
             assert!(
                 metrics.num_canisters >= 1,
diff --git a/ref-tests/tests/integration.rs b/ref-tests/tests/integration.rs
index 9ce5b53f..7c49c65f 100644
--- a/ref-tests/tests/integration.rs
+++ b/ref-tests/tests/integration.rs
@@ -261,7 +261,7 @@ fn wallet_canister_create_and_install() {
         let args = Argument::from_candid((install_config,));
 
         wallet
-            .call64(Principal::management_canister(), "install_code", args, 0)
+            .call64::<(), _>(Principal::management_canister(), "install_code", args, 0)
             .call_and_wait()
             .await?;