Merge branch 'main' into get-block

mergify[bot] · web-flow · commit 957aca13f15a · 2024-11-29T23:19:55.000Z
diff --git a/tower-fallback/tests/fallback.rs b/tower-fallback/tests/fallback.rs
@@ -1,3 +1,5 @@
+//! Tests for tower-fallback
+
 use tower::{service_fn, Service, ServiceExt};
 use tower_fallback::Fallback;
 
diff --git a/zebra-chain/src/chain_tip.rs b/zebra-chain/src/chain_tip.rs
@@ -139,7 +139,7 @@ impl<'f> BestTipChanged<'f> {
     }
 }
 
-impl<'f> Future for BestTipChanged<'f> {
+impl Future for BestTipChanged<'_> {
     type Output = Result<(), BoxError>;
 
     fn poll(
diff --git a/zebra-chain/src/orchard/shielded_data.rs b/zebra-chain/src/orchard/shielded_data.rs
@@ -270,6 +270,6 @@ impl ZcashDeserialize for Flags {
         // the reserved bits 2..7 of the flagsOrchard field MUST be zero."
         // https://zips.z.cash/protocol/protocol.pdf#txnencodingandconsensus
         Flags::from_bits(reader.read_u8()?)
-            .ok_or_else(|| SerializationError::Parse("invalid reserved orchard flags"))
+            .ok_or(SerializationError::Parse("invalid reserved orchard flags"))
     }
 }
diff --git a/zebra-chain/src/serialization/tests.rs b/zebra-chain/src/serialization/tests.rs
@@ -1,2 +1,4 @@
+//! Serialization tests.
+
 mod preallocate;
 mod prop;
diff --git a/zebra-chain/src/transaction.rs b/zebra-chain/src/transaction.rs
@@ -231,7 +231,7 @@ impl Transaction {
         &'a self,
         branch_id: ConsensusBranchId,
         all_previous_outputs: &'a [transparent::Output],
-    ) -> sighash::SigHasher {
+    ) -> sighash::SigHasher<'a> {
         sighash::SigHasher::new(self, branch_id, all_previous_outputs)
     }
 
diff --git a/zebra-chain/src/transaction/serialize.rs b/zebra-chain/src/transaction/serialize.rs
@@ -889,7 +889,7 @@ impl ZcashDeserialize for Transaction {
                 // Convert it to a NetworkUpgrade
                 let network_upgrade =
                     NetworkUpgrade::from_branch_id(limited_reader.read_u32::<LittleEndian>()?)
-                        .ok_or_else(|| {
+                        .ok_or({
                             SerializationError::Parse(
                                 "expected a valid network upgrade from the consensus branch id",
                             )
diff --git a/zebra-network/src/protocol/external/codec.rs b/zebra-network/src/protocol/external/codec.rs
@@ -508,7 +508,9 @@ impl Codec {
             timestamp: Utc
                 .timestamp_opt(reader.read_i64::<LittleEndian>()?, 0)
                 .single()
-                .ok_or_else(|| Error::Parse("version timestamp is out of range for DateTime"))?,
+                .ok_or(Error::Parse(
+                    "version timestamp is out of range for DateTime",
+                ))?,
             address_recv: AddrInVersion::zcash_deserialize(&mut reader)?,
             address_from: AddrInVersion::zcash_deserialize(&mut reader)?,
             nonce: Nonce(reader.read_u64::<LittleEndian>()?),
diff --git a/zebra-scan/src/service.rs b/zebra-scan/src/service.rs
@@ -93,18 +93,18 @@ impl Service<Request> for ScanService {
             Request::Info => {
                 let db = self.db.clone();
 
-                return async move {
+                async move {
                     Ok(Response::Info {
                         min_sapling_birthday_height: db.network().sapling_activation_height(),
                     })
                 }
-                .boxed();
+                .boxed()
             }
 
             Request::RegisterKeys(keys) => {
                 let mut scan_task = self.scan_task.clone();
 
-                return async move {
+                async move {
                     let newly_registered_keys = scan_task.register_keys(keys)?.await?;
                     if !newly_registered_keys.is_empty() {
                         Ok(Response::RegisteredKeys(newly_registered_keys))
@@ -113,14 +113,14 @@ impl Service<Request> for ScanService {
                         are valid Sapling extended full viewing keys".into())
                     }
                 }
-                .boxed();
+                .boxed()
             }
 
             Request::DeleteKeys(keys) => {
                 let mut db = self.db.clone();
                 let mut scan_task = self.scan_task.clone();
 
-                return async move {
+                async move {
                     // Wait for a message to confirm that the scan task has removed the key up to `DELETE_KEY_TIMEOUT`
                     let remove_keys_result = tokio::time::timeout(
                         DELETE_KEY_TIMEOUT,
@@ -141,13 +141,13 @@ impl Service<Request> for ScanService {
 
                     Ok(Response::DeletedKeys)
                 }
-                .boxed();
+                .boxed()
             }
 
             Request::Results(keys) => {
                 let db = self.db.clone();
 
-                return async move {
+                async move {
                     let mut final_result = BTreeMap::new();
                     for key in keys {
                         let db = db.clone();
@@ -168,26 +168,26 @@ impl Service<Request> for ScanService {
 
                     Ok(Response::Results(final_result))
                 }
-                .boxed();
+                .boxed()
             }
 
             Request::SubscribeResults(keys) => {
                 let mut scan_task = self.scan_task.clone();
 
-                return async move {
+                async move {
                     let results_receiver = scan_task.subscribe(keys)?.await.map_err(|_| {
                         "scan task dropped responder, check that keys are registered"
                     })?;
 
                     Ok(Response::SubscribeResults(results_receiver))
                 }
-                .boxed();
+                .boxed()
             }
 
             Request::ClearResults(keys) => {
                 let mut db = self.db.clone();
 
-                return async move {
+                async move {
                     // Clear results from db for the provided `keys`
                     tokio::task::spawn_blocking(move || {
                         db.delete_sapling_results(keys);
@@ -196,7 +196,7 @@ impl Service<Request> for ScanService {
 
                     Ok(Response::ClearedResults)
                 }
-                .boxed();
+                .boxed()
             }
         }
     }
diff --git a/zebra-scan/src/storage/db/sapling.rs b/zebra-scan/src/storage/db/sapling.rs
@@ -265,7 +265,7 @@ trait InsertSaplingHeight {
     fn insert_sapling_height(self, sapling_key: &SaplingScanningKey, height: Height) -> Self;
 }
 
-impl<'cf> InsertSaplingHeight for WriteSaplingTxIdsBatch<'cf> {
+impl InsertSaplingHeight for WriteSaplingTxIdsBatch<'_> {
     /// Insert sapling height with no results.
     ///
     /// If a result already exists for the coinbase transaction at that height,
@@ -283,7 +283,7 @@ trait DeleteSaplingKeys {
     fn delete_sapling_keys(self, sapling_key: Vec<SaplingScanningKey>) -> Self;
 }
 
-impl<'cf> DeleteSaplingKeys for WriteSaplingTxIdsBatch<'cf> {
+impl DeleteSaplingKeys for WriteSaplingTxIdsBatch<'_> {
     /// Delete sapling keys and their results.
     fn delete_sapling_keys(mut self, sapling_keys: Vec<SaplingScanningKey>) -> Self {
         for key in &sapling_keys {
diff --git a/zebra-scan/tests/scan_task_commands.rs b/zebra-scan/tests/scan_task_commands.rs
@@ -5,7 +5,7 @@
 //!
 //! export ZEBRA_CACHED_STATE_DIR="/path/to/zebra/state"
 //! cargo test scan_task_commands --features="shielded-scan" -- --ignored --nocapture
-#![allow(dead_code)]
+#![allow(dead_code, non_local_definitions)]
 
 use std::{fs, time::Duration};
 
@@ -26,6 +26,7 @@ use zebra_scan::{
 
 use zebra_state::{ChainTipChange, LatestChainTip};
 
+/// Boxed state service.
 pub type BoxStateService =
     BoxService<zebra_state::Request, zebra_state::Response, zebra_state::BoxError>;
 
@@ -162,6 +163,7 @@ pub(crate) async fn run() -> Result<()> {
     Ok(())
 }
 
+/// Starts the state service with the provided cache directory.
 pub async fn start_state_service_with_cache_dir(
     network: &Network,
     cache_dir: impl Into<std::path::PathBuf>,
diff --git a/zebra-state/src/service/finalized_state/column_family.rs b/zebra-state/src/service/finalized_state/column_family.rs
@@ -63,7 +63,7 @@ where
     batch: Batch,
 }
 
-impl<'cf, Key, Value> Debug for TypedColumnFamily<'cf, Key, Value>
+impl<Key, Value> Debug for TypedColumnFamily<'_, Key, Value>
 where
     Key: IntoDisk + FromDisk + Debug,
     Value: IntoDisk + FromDisk,
@@ -80,7 +80,7 @@ where
     }
 }
 
-impl<'cf, Key, Value> PartialEq for TypedColumnFamily<'cf, Key, Value>
+impl<Key, Value> PartialEq for TypedColumnFamily<'_, Key, Value>
 where
     Key: IntoDisk + FromDisk + Debug,
     Value: IntoDisk + FromDisk,
@@ -90,7 +90,7 @@ where
     }
 }
 
-impl<'cf, Key, Value> Eq for TypedColumnFamily<'cf, Key, Value>
+impl<Key, Value> Eq for TypedColumnFamily<'_, Key, Value>
 where
     Key: IntoDisk + FromDisk + Debug,
     Value: IntoDisk + FromDisk,
@@ -243,7 +243,7 @@ where
     }
 }
 
-impl<'cf, Key, Value> TypedColumnFamily<'cf, Key, Value>
+impl<Key, Value> TypedColumnFamily<'_, Key, Value>
 where
     Key: IntoDisk + FromDisk + Debug + Ord,
     Value: IntoDisk + FromDisk,
@@ -259,7 +259,7 @@ where
     }
 }
 
-impl<'cf, Key, Value> TypedColumnFamily<'cf, Key, Value>
+impl<Key, Value> TypedColumnFamily<'_, Key, Value>
 where
     Key: IntoDisk + FromDisk + Debug + Hash + Eq,
     Value: IntoDisk + FromDisk,
@@ -275,7 +275,7 @@ where
     }
 }
 
-impl<'cf, Key, Value, Batch> WriteTypedBatch<'cf, Key, Value, Batch>
+impl<Key, Value, Batch> WriteTypedBatch<'_, Key, Value, Batch>
 where
     Key: IntoDisk + FromDisk + Debug,
     Value: IntoDisk + FromDisk,
@@ -312,7 +312,7 @@ where
 }
 
 // Writing a batch to the database requires an owned batch.
-impl<'cf, Key, Value> WriteTypedBatch<'cf, Key, Value, DiskWriteBatch>
+impl<Key, Value> WriteTypedBatch<'_, Key, Value, DiskWriteBatch>
 where
     Key: IntoDisk + FromDisk + Debug,
     Value: IntoDisk + FromDisk,
diff --git a/zebra-state/src/service/finalized_state/disk_format.rs b/zebra-state/src/service/finalized_state/disk_format.rs
@@ -68,7 +68,7 @@ pub trait FromDisk: Sized {
 
 // Generic serialization impls
 
-impl<'a, T> IntoDisk for &'a T
+impl<T> IntoDisk for &T
 where
     T: IntoDisk,
 {
diff --git a/zebra-state/src/service/non_finalized_state/chain.rs b/zebra-state/src/service/non_finalized_state/chain.rs
@@ -1272,7 +1272,7 @@ impl Chain {
     pub fn partial_transparent_indexes<'a>(
         &'a self,
         addresses: &'a HashSet<transparent::Address>,
-    ) -> impl Iterator<Item = &TransparentTransfers> {
+    ) -> impl Iterator<Item = &'a TransparentTransfers> {
         addresses
             .iter()
             .flat_map(|address| self.partial_transparent_transfers.get(address))
diff --git a/zebrad/src/commands.rs b/zebrad/src/commands.rs
@@ -1,5 +1,7 @@
 //! Zebrad Subcommands
 
+#![allow(non_local_definitions)]
+
 use std::path::PathBuf;
 
 use abscissa_core::{config::Override, Command, Configurable, FrameworkError, Runnable};
diff --git a/zebrad/src/components/metrics.rs b/zebrad/src/components/metrics.rs
@@ -1,5 +1,7 @@
 //! An HTTP endpoint for metrics collection.
 
+#![allow(non_local_definitions)]
+
 use std::net::SocketAddr;
 
 use abscissa_core::{Component, FrameworkError};
diff --git a/zebrad/src/components/tokio.rs b/zebrad/src/components/tokio.rs
@@ -7,6 +7,8 @@
 //! The rayon thread pool is used for:
 //! - long-running CPU-bound tasks like cryptography, via [`rayon::spawn_fifo`].
 
+#![allow(non_local_definitions)]
+
 use std::{future::Future, time::Duration};
 
 use abscissa_core::{Component, FrameworkError, Shutdown};
diff --git a/zebrad/src/components/tracing/endpoint.rs b/zebrad/src/components/tracing/endpoint.rs
@@ -1,5 +1,7 @@
 //! An HTTP endpoint for dynamically setting tracing filters.
 
+#![allow(non_local_definitions)]
+
 use std::net::SocketAddr;
 
 use abscissa_core::{Component, FrameworkError};

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+//! Tests for tower-fallback`
	`2`	`+`
`1`	`3`	`use tower::{service_fn, Service, ServiceExt};`
`2`	`4`	`use tower_fallback::Fallback;`
`3`	`5`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ impl<'f> BestTipChanged<'f> {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`-impl<'f> Future for BestTipChanged<'f> {`
	`142`	`+impl Future for BestTipChanged<'_> {`
`143`	`143`	`type Output = Result<(), BoxError>;`
`144`	`144`
`145`	`145`	`fn poll(`
Original file line number	Diff line number	Diff line change
`@@ -270,6 +270,6 @@ impl ZcashDeserialize for Flags {`
`270`	`270`	`// the reserved bits 2..7 of the flagsOrchard field MUST be zero."`
`271`	`271`	`// https://zips.z.cash/protocol/protocol.pdf#txnencodingandconsensus`
`272`	`272`	`Flags::from_bits(reader.read_u8()?)`
`273`		`- .ok_or_else(\|\| SerializationError::Parse("invalid reserved orchard flags"))`
	`273`	`+ .ok_or(SerializationError::Parse("invalid reserved orchard flags"))`
`274`	`274`	`}`
`275`	`275`	`}`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ impl Transaction {`
`231`	`231`	`&'a self,`
`232`	`232`	`branch_id: ConsensusBranchId,`
`233`	`233`	`all_previous_outputs: &'a [transparent::Output],`
`234`		`- ) -> sighash::SigHasher {`
	`234`	`+ ) -> sighash::SigHasher<'a> {`
`235`	`235`	`sighash::SigHasher::new(self, branch_id, all_previous_outputs)`
`236`	`236`	`}`
`237`	`237`
Original file line number	Diff line number	Diff line change
`@@ -889,7 +889,7 @@ impl ZcashDeserialize for Transaction {`
`889`	`889`	`// Convert it to a NetworkUpgrade`
`890`	`890`	`let network_upgrade =`
`891`	`891`	`NetworkUpgrade::from_branch_id(limited_reader.read_u32::<LittleEndian>()?)`
`892`		`- .ok_or_else(\|\| {`
	`892`	`+ .ok_or({`
`893`	`893`	`SerializationError::Parse(`
`894`	`894`	`"expected a valid network upgrade from the consensus branch id",`
`895`	`895`	`)`
Original file line number	Diff line number	Diff line change
`@@ -93,18 +93,18 @@ impl Service<Request> for ScanService {`
`93`	`93`	`Request::Info => {`
`94`	`94`	`let db = self.db.clone();`
`95`	`95`
`96`		`- return async move {`
	`96`	`+ async move {`
`97`	`97`	`Ok(Response::Info {`
`98`	`98`	`min_sapling_birthday_height: db.network().sapling_activation_height(),`
`99`	`99`	`})`
`100`	`100`	`}`
`101`		`- .boxed();`
	`101`	`+ .boxed()`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`Request::RegisterKeys(keys) => {`
`105`	`105`	`let mut scan_task = self.scan_task.clone();`
`106`	`106`
`107`		`- return async move {`
	`107`	`+ async move {`
`108`	`108`	`let newly_registered_keys = scan_task.register_keys(keys)?.await?;`
`109`	`109`	`if !newly_registered_keys.is_empty() {`
`110`	`110`	`Ok(Response::RegisteredKeys(newly_registered_keys))`
`@@ -113,14 +113,14 @@ impl Service<Request> for ScanService {`
`113`	`113`	`are valid Sapling extended full viewing keys".into())`
`114`	`114`	`}`
`115`	`115`	`}`
`116`		`- .boxed();`
	`116`	`+ .boxed()`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`Request::DeleteKeys(keys) => {`
`120`	`120`	`let mut db = self.db.clone();`
`121`	`121`	`let mut scan_task = self.scan_task.clone();`
`122`	`122`
`123`		`- return async move {`
	`123`	`+ async move {`
`124`	`124`	// Wait for a message to confirm that the scan task has removed the key up to `DELETE_KEY_TIMEOUT`
`125`	`125`	`let remove_keys_result = tokio::time::timeout(`
`126`	`126`	`DELETE_KEY_TIMEOUT,`
`@@ -141,13 +141,13 @@ impl Service<Request> for ScanService {`
`141`	`141`
`142`	`142`	`Ok(Response::DeletedKeys)`
`143`	`143`	`}`
`144`		`- .boxed();`
	`144`	`+ .boxed()`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`Request::Results(keys) => {`
`148`	`148`	`let db = self.db.clone();`
`149`	`149`
`150`		`- return async move {`
	`150`	`+ async move {`
`151`	`151`	`let mut final_result = BTreeMap::new();`
`152`	`152`	`for key in keys {`
`153`	`153`	`let db = db.clone();`
`@@ -168,26 +168,26 @@ impl Service<Request> for ScanService {`
`168`	`168`
`169`	`169`	`Ok(Response::Results(final_result))`
`170`	`170`	`}`
`171`		`- .boxed();`
	`171`	`+ .boxed()`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`Request::SubscribeResults(keys) => {`
`175`	`175`	`let mut scan_task = self.scan_task.clone();`
`176`	`176`
`177`		`- return async move {`
	`177`	`+ async move {`
`178`	`178`	`let results_receiver = scan_task.subscribe(keys)?.await.map_err(\|_\| {`
`179`	`179`	`"scan task dropped responder, check that keys are registered"`
`180`	`180`	`})?;`
`181`	`181`
`182`	`182`	`Ok(Response::SubscribeResults(results_receiver))`
`183`	`183`	`}`
`184`		`- .boxed();`
	`184`	`+ .boxed()`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`Request::ClearResults(keys) => {`
`188`	`188`	`let mut db = self.db.clone();`
`189`	`189`
`190`		`- return async move {`
	`190`	`+ async move {`
`191`	`191`	// Clear results from db for the provided `keys`
`192`	`192`	`tokio::task::spawn_blocking(move \|\| {`
`193`	`193`	`db.delete_sapling_results(keys);`
`@@ -196,7 +196,7 @@ impl Service<Request> for ScanService {`
`196`	`196`
`197`	`197`	`Ok(Response::ClearedResults)`
`198`	`198`	`}`
`199`		`- .boxed();`
	`199`	`+ .boxed()`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ where`
`63`	`63`	`batch: Batch,`
`64`	`64`	`}`
`65`	`65`
`66`		`-impl<'cf, Key, Value> Debug for TypedColumnFamily<'cf, Key, Value>`
	`66`	`+impl<Key, Value> Debug for TypedColumnFamily<'_, Key, Value>`
`67`	`67`	`where`
`68`	`68`	`Key: IntoDisk + FromDisk + Debug,`
`69`	`69`	`Value: IntoDisk + FromDisk,`
`@@ -80,7 +80,7 @@ where`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`-impl<'cf, Key, Value> PartialEq for TypedColumnFamily<'cf, Key, Value>`
	`83`	`+impl<Key, Value> PartialEq for TypedColumnFamily<'_, Key, Value>`
`84`	`84`	`where`
`85`	`85`	`Key: IntoDisk + FromDisk + Debug,`
`86`	`86`	`Value: IntoDisk + FromDisk,`
`@@ -90,7 +90,7 @@ where`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`		`-impl<'cf, Key, Value> Eq for TypedColumnFamily<'cf, Key, Value>`
	`93`	`+impl<Key, Value> Eq for TypedColumnFamily<'_, Key, Value>`
`94`	`94`	`where`
`95`	`95`	`Key: IntoDisk + FromDisk + Debug,`
`96`	`96`	`Value: IntoDisk + FromDisk,`
`@@ -243,7 +243,7 @@ where`
`243`	`243`	`}`
`244`	`244`	`}`
`245`	`245`
`246`		`-impl<'cf, Key, Value> TypedColumnFamily<'cf, Key, Value>`
	`246`	`+impl<Key, Value> TypedColumnFamily<'_, Key, Value>`
`247`	`247`	`where`
`248`	`248`	`Key: IntoDisk + FromDisk + Debug + Ord,`
`249`	`249`	`Value: IntoDisk + FromDisk,`
`@@ -259,7 +259,7 @@ where`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
`262`		`-impl<'cf, Key, Value> TypedColumnFamily<'cf, Key, Value>`
	`262`	`+impl<Key, Value> TypedColumnFamily<'_, Key, Value>`
`263`	`263`	`where`
`264`	`264`	`Key: IntoDisk + FromDisk + Debug + Hash + Eq,`
`265`	`265`	`Value: IntoDisk + FromDisk,`
`@@ -275,7 +275,7 @@ where`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
`278`		`-impl<'cf, Key, Value, Batch> WriteTypedBatch<'cf, Key, Value, Batch>`
	`278`	`+impl<Key, Value, Batch> WriteTypedBatch<'_, Key, Value, Batch>`
`279`	`279`	`where`
`280`	`280`	`Key: IntoDisk + FromDisk + Debug,`
`281`	`281`	`Value: IntoDisk + FromDisk,`
`@@ -312,7 +312,7 @@ where`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`// Writing a batch to the database requires an owned batch.`
`315`		`-impl<'cf, Key, Value> WriteTypedBatch<'cf, Key, Value, DiskWriteBatch>`
	`315`	`+impl<Key, Value> WriteTypedBatch<'_, Key, Value, DiskWriteBatch>`
`316`	`316`	`where`
`317`	`317`	`Key: IntoDisk + FromDisk + Debug,`
`318`	`318`	`Value: IntoDisk + FromDisk,`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ pub trait FromDisk: Sized {`
`68`	`68`
`69`	`69`	`// Generic serialization impls`
`70`	`70`
`71`		`-impl<'a, T> IntoDisk for &'a T`
	`71`	`+impl<T> IntoDisk for &T`
`72`	`72`	`where`
`73`	`73`	`T: IntoDisk,`
`74`	`74`	`{`