chore: Make clippy happy

evanlinjin · evanlinjin · commit cb7a980b8466 · 2025-07-10T03:04:24.000Z
diff --git a/crates/bitcoind_rpc/examples/filter_iter.rs b/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(())
 }
diff --git a/crates/bitcoind_rpc/src/lib.rs b/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"
                 );
             }
         }
diff --git a/crates/bitcoind_rpc/tests/test_emitter.rs b/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}",
         );
     }
 
diff --git a/crates/chain/src/indexer/keychain_txout.rs b/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}");
             }
         }
     }
diff --git a/crates/chain/src/rusqlite_impl.rs b/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}"),
                 }
             }
         }
diff --git a/crates/chain/src/tx_graph.rs b/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);
diff --git a/crates/chain/tests/test_indexed_tx_graph.rs b/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(
diff --git a/crates/chain/tests/test_local_chain.rs b/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",);
     }
 }
 
diff --git a/crates/chain/tests/test_tx_graph.rs b/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"
         );
     }
 }
diff --git a/crates/core/src/spk_client.rs b/crates/core/src/spk_client.rs
@@ -26,13 +26,13 @@ impl<I: core::fmt::Debug + core::any::Any> core::fmt::Display for SyncItem<'_, I
         match self {
             SyncItem::Spk(i, spk) => {
                 if (i as &dyn core::any::Any).is::<()>() {
-                    write!(f, "script '{}'", spk)
+                    write!(f, "script '{spk}'")
                 } else {
-                    write!(f, "script {:?} '{}'", i, spk)
+                    write!(f, "script {i:?} '{spk}'")
                 }
             }
-            SyncItem::Txid(txid) => write!(f, "txid '{}'", txid),
-            SyncItem::OutPoint(op) => write!(f, "outpoint '{}'", op),
+            SyncItem::Txid(txid) => write!(f, "txid '{txid}'"),
+            SyncItem::OutPoint(op) => write!(f, "outpoint '{op}'"),
         }
     }
 }
diff --git a/crates/electrum/src/bdk_electrum_client.rs b/crates/electrum/src/bdk_electrum_client.rs
@@ -512,7 +512,7 @@ impl<E: ElectrumApi> BdkElectrumClient<E> {
             batch.raw(
                 "blockchain.transaction.get_merkle".into(),
                 vec![
-                    electrum_client::Param::String(format!("{:x}", txid)),
+                    electrum_client::Param::String(format!("{txid:x}")),
                     electrum_client::Param::Usize(height),
                 ],
             );
diff --git a/crates/electrum/tests/test_electrum.rs b/crates/electrum/tests/test_electrum.rs
@@ -723,8 +723,7 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {
                 confirmed: SEND_AMOUNT * (REORG_COUNT - depth) as u64,
                 ..Balance::default()
             },
-            "reorg_count: {}",
-            depth,
+            "reorg_count: {depth}",
         );
     }
 
diff --git a/crates/esplora/src/blocking_ext.rs b/crates/esplora/src/blocking_ext.rs
@@ -866,10 +866,10 @@ mod test {
                 .iter()
                 .map(|&h| {
                     let anchor_blockhash: BlockHash = bdk_chain::bitcoin::hashes::Hash::hash(
-                        &format!("hash_at_height_{}", h).into_bytes(),
+                        &format!("hash_at_height_{h}").into_bytes(),
                     );
                     let txid: Txid = bdk_chain::bitcoin::hashes::Hash::hash(
-                        &format!("txid_at_height_{}", h).into_bytes(),
+                        &format!("txid_at_height_{h}").into_bytes(),
                     );
                     let anchor = ConfirmationBlockTime {
                         block_id: BlockId {
diff --git a/crates/file_store/src/lib.rs b/crates/file_store/src/lib.rs
@@ -25,13 +25,12 @@ pub enum StoreError {
 impl core::fmt::Display for StoreError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::Io(e) => write!(f, "io error trying to read file: {}", e),
+            Self::Io(e) => write!(f, "io error trying to read file: {e}"),
             Self::InvalidMagicBytes { got, expected } => write!(
                 f,
-                "file has invalid magic bytes: expected={:?} got={:?}",
-                expected, got,
+                "file has invalid magic bytes: expected={expected:?} got={got:?}",
             ),
-            Self::Bincode(e) => write!(f, "bincode error while reading entry {}", e),
+            Self::Bincode(e) => write!(f, "bincode error while reading entry {e}"),
         }
     }
 }
diff --git a/crates/file_store/src/store.rs b/crates/file_store/src/store.rs
@@ -246,7 +246,7 @@ where
             .serialize_into(&mut self.db_file, changeset)
             .map_err(|e| match *e {
                 bincode::ErrorKind::Io(error) => error,
-                unexpected_err => panic!("unexpected bincode error: {}", unexpected_err),
+                unexpected_err => panic!("unexpected bincode error: {unexpected_err}"),
             })?;
 
         Ok(())
@@ -323,7 +323,7 @@ mod test {
                 error: StoreError::Io(e),
                 ..
             }) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
-            unexpected => panic!("unexpected result: {:?}", unexpected),
+            unexpected => panic!("unexpected result: {unexpected:?}"),
         };
     }
 
@@ -342,7 +342,7 @@ mod test {
             }) => {
                 assert_eq!(got, invalid_magic_bytes.as_bytes())
             }
-            unexpected => panic!("unexpected result: {:?}", unexpected),
+            unexpected => panic!("unexpected result: {unexpected:?}"),
         };
     }
 
@@ -372,7 +372,7 @@ mod test {
             }) => {
                 assert_eq!(changeset, Some(test_changesets))
             }
-            unexpected_res => panic!("unexpected result: {:?}", unexpected_res),
+            unexpected_res => panic!("unexpected result: {unexpected_res:?}"),
         }
     }
 
@@ -400,7 +400,7 @@ mod test {
             }) => {
                 assert_eq!(changeset, Some(test_changesets))
             }
-            unexpected_res => panic!("unexpected result: {:?}", unexpected_res),
+            unexpected_res => panic!("unexpected result: {unexpected_res:?}"),
         }
     }
 
@@ -476,7 +476,7 @@ mod test {
         let last_changeset_bytes = bincode_options().serialize(&last_changeset).unwrap();
 
         for short_write_len in 1..last_changeset_bytes.len() - 1 {
-            let file_path = temp_dir.path().join(format!("{}.dat", short_write_len));
+            let file_path = temp_dir.path().join(format!("{short_write_len}.dat"));
 
             // simulate creating a file, writing data where the last write is incomplete
             {
diff --git a/examples/example_cli/src/lib.rs b/examples/example_cli/src/lib.rs
@@ -488,12 +488,12 @@ pub fn handle_commands<CS: clap::Subcommand, S: clap::Args>(
                         ..Default::default()
                     })?;
                     let addr = Address::from_script(spk.as_script(), network)?;
-                    println!("[address @ {}] {}", spk_i, addr);
+                    println!("[address @ {spk_i}] {addr}");
                     Ok(())
                 }
                 AddressCmd::Index => {
                     for (keychain, derivation_index) in index.last_revealed_indices() {
-                        println!("{:?}: {}", keychain, derivation_index);
+                        println!("{keychain:?}: {derivation_index}");
                     }
                     Ok(())
                 }
@@ -523,7 +523,7 @@ pub fn handle_commands<CS: clap::Subcommand, S: clap::Args>(
                 title_str: &'a str,
                 items: impl IntoIterator<Item = (&'a str, Amount)>,
             ) {
-                println!("{}:", title_str);
+                println!("{title_str}:");
                 for (name, amount) in items.into_iter() {
                     println!("    {:<10} {:>12} sats", name, amount.to_sat())
                 }
@@ -932,8 +932,8 @@ fn generate_bip86_helper(network: impl Into<NetworkKind>) -> anyhow::Result<()>
     let (internal_descriptor, internal_keymap) =
         <Descriptor<DescriptorPublicKey>>::parse_descriptor(&secp, internal_desc)?;
     println!("Public");
-    println!("{}", descriptor);
-    println!("{}", internal_descriptor);
+    println!("{descriptor}");
+    println!("{internal_descriptor}");
     println!("\nPrivate");
     println!("{}", descriptor.to_string_with_secret(&keymap));
     println!(
diff --git a/examples/example_electrum/src/main.rs b/examples/example_electrum/src/main.rs
@@ -169,9 +169,9 @@ fn main() -> anyhow::Result<()> {
                         let mut once = BTreeSet::new();
                         move |k, spk_i, _| {
                             if once.insert(k) {
-                                eprint!("\nScanning {}: {} ", k, spk_i);
+                                eprint!("\nScanning {k}: {spk_i} ");
                             } else {
-                                eprint!("{} ", spk_i);
+                                eprint!("{spk_i} ");
                             }
                             io::stdout().flush().expect("must flush");
                         }
@@ -213,7 +213,7 @@ fn main() -> anyhow::Result<()> {
                     .chain_tip(chain_tip.clone())
                     .inspect(|item, progress| {
                         let pc = (100 * progress.consumed()) as f32 / progress.total() as f32;
-                        eprintln!("[ SCANNING {:03.0}% ] {}", pc, item);
+                        eprintln!("[ SCANNING {pc:03.0}% ] {item}");
                     });
 
             request = request.expected_spk_txids(graph.list_expected_spk_txids(
diff --git a/examples/example_esplora/src/main.rs b/examples/example_esplora/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -480,8 +480,7 @@ mod test {`
`480`	`480`	`for txid in &mempool_txids {`
`481`	`481`	`assert!(`
`482`	`482`	`emitter.expected_mempool_txids.contains(txid),`
`483`		`- "Expected txid {:?} missing",`
`484`		`- txid`
	`483`	`+ "Expected txid {txid:?} missing"`
`485`	`484`	`);`
`486`	`485`	`}`
`487`	`486`	`}`
`@@ -502,15 +501,13 @@ mod test {`
`502`	`501`	`for txid in confirmed_txids {`
`503`	`502`	`assert!(`
`504`	`503`	`!emitter.expected_mempool_txids.contains(&txid),`
`505`		`- "Expected txid {:?} should have been removed",`
`506`		`- txid`
	`504`	`+ "Expected txid {txid:?} should have been removed"`
`507`	`505`	`);`
`508`	`506`	`}`
`509`	`507`	`for txid in &mempool_txids {`
`510`	`508`	`assert!(`
`511`	`509`	`emitter.expected_mempool_txids.contains(txid),`
`512`		`- "Expected txid {:?} missing",`
`513`		`- txid`
	`510`	`+ "Expected txid {txid:?} missing"`
`514`	`511`	`);`
`515`	`512`	`}`
`516`	`513`	`}`
Original file line number	Diff line number	Diff line change
`@@ -408,8 +408,7 @@ fn tx_can_become_unconfirmed_after_reorg() -> anyhow::Result<()> {`
`408`	`408`	`confirmed: SEND_AMOUNT * (ADDITIONAL_COUNT - reorg_count) as u64,`
`409`	`409`	`..Balance::default()`
`410`	`410`	`},`
`411`		`- "reorg_count: {}",`
`412`		`- reorg_count,`
	`411`	`+ "reorg_count: {reorg_count}",`
`413`	`412`	`);`
`414`	`413`	`}`
`415`	`414`
Original file line number	Diff line number	Diff line change
`@@ -594,15 +594,15 @@ impl<K: Clone + Ord + Debug> KeychainTxOutIndex<K> {`
`594`	`594`	`let _inserted = self`
`595`	`595`	`.inner`
`596`	`596`	`.insert_spk((keychain.clone(), new_index), new_spk);`
`597`		`- debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={:?}, lookahead={}, next_index={}", keychain, lookahead, next_index);`
	`597`	`+ debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={keychain:?}, lookahead={lookahead}, next_index={next_index}");`
`598`	`598`	`}`
`599`	`599`	`} else {`
`600`	`600`	`let spk_iter = SpkIterator::new_with_range(descriptor, next_index..stop_index);`
`601`	`601`	`for (new_index, new_spk) in spk_iter {`
`602`	`602`	`let _inserted = self`
`603`	`603`	`.inner`
`604`	`604`	`.insert_spk((keychain.clone(), new_index), new_spk);`
`605`		`- debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={:?}, lookahead={}, next_index={}", keychain, lookahead, next_index);`
	`605`	`+ debug_assert!(_inserted, "replenish lookahead: must not have existing spk: keychain={keychain:?}, lookahead={lookahead}, next_index={next_index}");`
`606`	`606`	`}`
`607`	`607`	`}`
`608`	`608`	`}`
Original file line number	Diff line number	Diff line change
`@@ -371,10 +371,9 @@ fn local_chain_insert_block() {`
`371`	`371`	`assert_eq!(`
`372`	`372`	`chain.insert_block(t.insert.into()),`
`373`	`373`	`t.expected_result,`
`374`		`- "[{}] unexpected result when inserting block",`
`375`		`- i,`
	`374`	`+ "[{i}] unexpected result when inserting block",`
`376`	`375`	`);`
`377`		`- assert_eq!(chain, t.expected_final, "[{}] unexpected final chain", i,);`
	`376`	`+ assert_eq!(chain, t.expected_final, "[{i}] unexpected final chain",);`
`378`	`377`	`}`
`379`	`378`	`}`
`380`	`379`
Original file line number	Diff line number	Diff line change
`@@ -26,13 +26,13 @@ impl<I: core::fmt::Debug + core::any::Any> core::fmt::Display for SyncItem<'_, I`
`26`	`26`	`match self {`
`27`	`27`	`SyncItem::Spk(i, spk) => {`
`28`	`28`	`if (i as &dyn core::any::Any).is::<()>() {`
`29`		`- write!(f, "script '{}'", spk)`
	`29`	`+ write!(f, "script '{spk}'")`
`30`	`30`	`} else {`
`31`		`- write!(f, "script {:?} '{}'", i, spk)`
	`31`	`+ write!(f, "script {i:?} '{spk}'")`
`32`	`32`	`}`
`33`	`33`	`}`
`34`		`- SyncItem::Txid(txid) => write!(f, "txid '{}'", txid),`
`35`		`- SyncItem::OutPoint(op) => write!(f, "outpoint '{}'", op),`
	`34`	`+ SyncItem::Txid(txid) => write!(f, "txid '{txid}'"),`
	`35`	`+ SyncItem::OutPoint(op) => write!(f, "outpoint '{op}'"),`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`