Merge #1990: How can we be happy if clippy is not?

f4e158a chore(esplora): Allow `dead_code` for helper methods (志宇)
cb7a980 chore: Make clippy happy (志宇)
93657a0 chore: `.gitignore` Exclude criterion results (志宇)

Pull request description:

  ### Description

  I made clippy happy.

  ### Checklists

  #### All Submissions:

  * [x] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)

Top commit has no ACKs.

Tree-SHA512: b28afe91dd5d47dfc83a4d14bc47d8efa1e5077448cbbddd1fd74a74232a120e0823d778fa007cde7cfbea52d07ee1f5e719590a56fa143ec9288efc4e56afe1

Author: evanlinjin

.gitignore

@@ -8,3 +8,5 @@ Cargo.lock
 # Example persisted files.
 *.db
 *.sqlite*
+
+crates/electrum/target

crates/bitcoind_rpc/examples/filter_iter.rs

@@ -73,7 +73,7 @@ fn main() -> anyhow::Result<()> {
             // apply relevant blocks
             if let Event::Block(EventInner { height, ref block }) = event {
                 let _ = graph.apply_block_relevant(block, height);
-                println!("Matched block {}", curr);
+                println!("Matched block {curr}");
             }
             if curr % 1000 == 0 {
                 let progress = (curr - start_height) as f32 / blocks_to_scan as f32;
@@ -107,7 +107,7 @@ fn main() -> anyhow::Result<()> {
 
     let unused_spk = graph.index.reveal_next_spk("external").unwrap().0 .1;
     let unused_address = Address::from_script(&unused_spk, NETWORK)?;
-    println!("Next external address: {}", unused_address);
+    println!("Next external address: {unused_address}");
 
     Ok(())
 }

crates/bitcoind_rpc/src/lib.rs

@@ -480,8 +480,7 @@ mod test {
             for txid in &mempool_txids {
                 assert!(
                     emitter.expected_mempool_txids.contains(txid),
-                    "Expected txid {:?} missing",
-                    txid
+                    "Expected txid {txid:?} missing"
                 );
             }
         }
@@ -502,15 +501,13 @@ mod test {
             for txid in confirmed_txids {
                 assert!(
                     !emitter.expected_mempool_txids.contains(&txid),
-                    "Expected txid {:?} should have been removed",
-                    txid
+                    "Expected txid {txid:?} should have been removed"
                 );
             }
             for txid in &mempool_txids {
                 assert!(
                     emitter.expected_mempool_txids.contains(txid),
-                    "Expected txid {:?} missing",
-                    txid
+                    "Expected txid {txid:?} missing"
                 );
             }
         }

crates/bitcoind_rpc/tests/test_emitter.rs

@@ -408,8 +408,7 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {
                 confirmed: SEND_AMOUNT * (ADDITIONAL_COUNT - reorg_count) as u64,
                 ..Balance::default()
             },
-            "reorg_count: {}",
-            reorg_count,
+            "reorg_count: {reorg_count}",
         );
     }
 

crates/chain/src/indexer/keychain_txout.rs

@@ -594,15 +594,15 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {
                 let _inserted = self
                     .inner
                     .insert_spk((keychain.clone(), new_index), new_spk);
-                debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={:?}, lookahead={}, next_index={}", keychain, lookahead, next_index);
+                debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={keychain:?}, lookahead={lookahead}, next_index={next_index}");
             }
         } else {
             let spk_iter = SpkIterator::new_with_range(descriptor, next_index..stop_index);
             for (new_index, new_spk) in spk_iter {
                 let _inserted = self
                     .inner
                     .insert_spk((keychain.clone(), new_index), new_spk);
-                debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={:?}, lookahead={}, next_index={}", keychain, lookahead, next_index);
+                debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={keychain:?}, lookahead={lookahead}, next_index={next_index}");
             }
         }
     }

crates/chain/src/rusqlite_impl.rs

@@ -22,17 +22,14 @@ pub const SCHEMAS_TABLE_NAME: &str = "bdk_schemas";
 
 /// Initialize the schema table.
 fn init_schemas_table(db_tx: &Transaction) -> rusqlite::Result<()> {
-    let sql = format!("CREATE TABLE IF NOT EXISTS {}( name TEXT PRIMARY KEY NOT NULL, version INTEGER NOT NULL ) STRICT", SCHEMAS_TABLE_NAME);
+    let sql = format!("CREATE TABLE IF NOT EXISTS {SCHEMAS_TABLE_NAME}( name TEXT PRIMARY KEY NOT NULL, version INTEGER NOT NULL ) STRICT");
     db_tx.execute(&sql, ())?;
     Ok(())
 }
 
 /// Get schema version of `schema_name`.
 fn schema_version(db_tx: &Transaction, schema_name: &str) -> rusqlite::Result<Option<u32>> {
-    let sql = format!(
-        "SELECT version FROM {} WHERE name=:name",
-        SCHEMAS_TABLE_NAME
-    );
+    let sql = format!("SELECT version FROM {SCHEMAS_TABLE_NAME} WHERE name=:name");
     db_tx
         .query_row(&sql, named_params! { ":name": schema_name }, |row| {
             row.get::<_, u32>("version")
@@ -46,10 +43,7 @@ fn set_schema_version(
     schema_name: &str,
     schema_version: u32,
 ) -> rusqlite::Result<()> {
-    let sql = format!(
-        "REPLACE INTO {}(name, version) VALUES(:name, :version)",
-        SCHEMAS_TABLE_NAME,
-    );
+    let sql = format!("REPLACE INTO {SCHEMAS_TABLE_NAME}(name, version) VALUES(:name, :version)");
     db_tx.execute(
         &sql,
         named_params! { ":name": schema_name, ":version": schema_version },
@@ -799,7 +793,7 @@ mod test {
                     ":block_hash": Impl(anchor_block.hash),
                 }) {
                     Ok(updated) => assert_eq!(updated, 1),
-                    Err(err) => panic!("update failed: {}", err),
+                    Err(err) => panic!("update failed: {err}"),
                 }
             }
         }

crates/chain/src/tx_graph.rs

@@ -281,8 +281,7 @@ impl fmt::Display for CalculateFeeError {
         match self {
             CalculateFeeError::MissingTxOut(outpoints) => write!(
                 f,
-                "missing `TxOut` for one or more of the inputs of the tx: {:?}",
-                outpoints
+                "missing `TxOut` for one or more of the inputs of the tx: {outpoints:?}",
             ),
             CalculateFeeError::NegativeFee(fee) => write!(
                 f,
@@ -1119,12 +1118,7 @@ impl<A: Anchor> TxGraph<A> {
             if !canonical_tx.tx_node.tx.is_coinbase() {
                 for txin in &canonical_tx.tx_node.tx.input {
                     let _res = canon_spends.insert(txin.previous_output, txid);
-                    assert!(
-                        _res.is_none(),
-                        "tried to replace {:?} with {:?}",
-                        _res,
-                        txid
-                    );
+                    assert!(_res.is_none(), "tried to replace {_res:?} with {txid:?}",);
                 }
             }
             canon_txs.insert(txid, canonical_tx);

crates/chain/tests/test_indexed_tx_graph.rs

@@ -281,7 +281,7 @@ fn test_list_owned_txouts() {
             let chain_tip = local_chain
                 .get(height)
                 .map(|cp| cp.block_id())
-                .unwrap_or_else(|| panic!("block must exist at {}", height));
+                .unwrap_or_else(|| panic!("block must exist at {height}"));
             let txouts = graph
                 .graph()
                 .filter_chain_txouts(

crates/chain/tests/test_local_chain.rs

@@ -371,10 +371,9 @@ fn local_chain_insert_block() {
         assert_eq!(
             chain.insert_block(t.insert.into()),
             t.expected_result,
-            "[{}] unexpected result when inserting block",
-            i,
+            "[{i}] unexpected result when inserting block",
         );
-        assert_eq!(chain, t.expected_final, "[{}] unexpected final chain", i,);
+        assert_eq!(chain, t.expected_final, "[{i}] unexpected final chain",);
     }
 }
 

crates/chain/tests/test_tx_graph.rs

@@ -598,7 +598,7 @@ fn test_calculate_fee_on_coinbase() {
 fn test_walk_ancestors() {
     let local_chain = LocalChain::from_blocks(
         (0..=20)
-            .map(|ht| (ht, BlockHash::hash(format!("Block Hash {}", ht).as_bytes())))
+            .map(|ht| (ht, BlockHash::hash(format!("Block Hash {ht}").as_bytes())))
             .collect(),
     )
     .expect("must contain genesis hash");
@@ -935,7 +935,7 @@ fn test_descendants_no_repeat() {
 fn test_chain_spends() {
     let local_chain = LocalChain::from_blocks(
         (0..=100)
-            .map(|ht| (ht, BlockHash::hash(format!("Block Hash {}", ht).as_bytes())))
+            .map(|ht| (ht, BlockHash::hash(format!("Block Hash {ht}").as_bytes())))
             .collect(),
     )
     .expect("must have genesis hash");
@@ -1453,23 +1453,19 @@ fn tx_graph_update_conversion() {
                 .iter()
                 .map(|tx| tx.compute_txid())
                 .collect::<HashSet<Txid>>(),
-            "{}: txs do not match",
-            test_name
+            "{test_name}: txs do not match"
         );
         assert_eq!(
             update.txouts, update_from_tx_graph.txouts,
-            "{}: txouts do not match",
-            test_name
+            "{test_name}: txouts do not match"
         );
         assert_eq!(
             update.anchors, update_from_tx_graph.anchors,
-            "{}: anchors do not match",
-            test_name
+            "{test_name}: anchors do not match"
         );
         assert_eq!(
             update.seen_ats, update_from_tx_graph.seen_ats,
-            "{}: seen_ats do not match",
-            test_name
+            "{test_name}: seen_ats do not match"
         );
     }
 }