feat(wasm-utxo): use rust idiomatic style for boolean expressions

Replace boolean equality comparisons with direct assertions and other idiomatic
patterns throughout the codebase. Improve function parameter handling by
removing unnecessary references and dereferences.

Issue: BTC-2652

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

packages/wasm-utxo/src/address/cashaddr.rs

@@ -474,7 +474,7 @@ mod tests {
         // Test roundtrip
         let (decoded_hash, is_p2sh) = decode_cashaddr(&address, "bitcoincash").unwrap();
         assert_eq!(decoded_hash, hash);
-        assert_eq!(is_p2sh, false);
+        assert!(!is_p2sh);
     }
 
     #[test]
@@ -490,7 +490,7 @@ mod tests {
         // Test roundtrip
         let (decoded_hash, is_p2sh) = decode_cashaddr(&address, "bchtest").unwrap();
         assert_eq!(decoded_hash, hash);
-        assert_eq!(is_p2sh, true);
+        assert!(is_p2sh);
     }
 
     #[test]
@@ -503,7 +503,7 @@ mod tests {
         // Test roundtrip
         let (decoded_hash, is_p2sh) = decode_cashaddr(&address, "pref").unwrap();
         assert_eq!(decoded_hash, hash);
-        assert_eq!(is_p2sh, true);
+        assert!(is_p2sh);
     }
 
     #[test]
@@ -585,7 +585,7 @@ mod tests {
         let (hash, is_p2sh) = decode_cashaddr(uppercase, "bitcoincash").unwrap();
 
         assert_eq!(hex::encode(hash).to_uppercase(), TEST_HASH_20);
-        assert_eq!(is_p2sh, false);
+        assert!(!is_p2sh);
     }
 
     #[test]
@@ -628,7 +628,7 @@ mod tests {
         // Test roundtrip
         let (decoded_hash, is_p2sh) = decode_cashaddr(&address, "ecash").unwrap();
         assert_eq!(decoded_hash, hash);
-        assert_eq!(is_p2sh, false);
+        assert!(!is_p2sh);
     }
 
     #[test]

packages/wasm-utxo/src/descriptor.rs

@@ -1,6 +1,6 @@
 use crate::error::WasmMiniscriptError;
 use crate::try_into_js_value::TryIntoJsValue;
-use miniscript::bitcoin::secp256k1::{Context, Secp256k1, Signing};
+use miniscript::bitcoin::secp256k1::{Secp256k1, Signing};
 use miniscript::bitcoin::ScriptBuf;
 use miniscript::descriptor::KeyMap;
 use miniscript::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
@@ -115,7 +115,7 @@ impl WrapDescriptor {
         secp: &Secp256k1<C>,
         descriptor: &str,
     ) -> Result<WrapDescriptor, WasmMiniscriptError> {
-        let (desc, keys) = Descriptor::parse_descriptor(&secp, descriptor)?;
+        let (desc, keys) = Descriptor::parse_descriptor(secp, descriptor)?;
         Ok(WrapDescriptor(WrapDescriptorEnum::Derivable(desc, keys)))
     }
 
@@ -217,15 +217,14 @@ mod tests {
         )
         .unwrap();
 
-        assert_eq!(desc.has_wildcard(), false);
-        assert_eq!(
+        assert!(!desc.has_wildcard());
+        assert!(
             match desc {
                 WrapDescriptor {
                     0: crate::descriptor::WrapDescriptorEnum::Definite(_),
                 } => true,
                 _ => false,
-            },
-            true
+            }
         );
     }
 }

packages/wasm-utxo/src/fixed_script_wallet/wallet_scripts/checkmultisig.rs

@@ -9,7 +9,7 @@ pub fn build_multisig_script_2_of_3(keys: &PubTriple) -> ScriptBuf {
     let total_count = 3;
     let mut builder = Builder::default().push_int(quorum as i64);
     for key in keys {
-        builder = builder.push_slice(&key.to_bytes())
+        builder = builder.push_slice(key.to_bytes())
     }
     builder
         .push_int(total_count as i64)
@@ -150,7 +150,7 @@ mod tests {
         // Test script with wrong number of instructions
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_2)
-            .push_slice(&[0x02; 33]) // Only one key instead of three
+            .push_slice([0x02; 33]) // Only one key instead of three
             .push_opcode(OP_PUSHNUM_3)
             .push_opcode(OP_CHECKMULTISIG)
             .into_script();
@@ -173,9 +173,9 @@ mod tests {
         // Build script with wrong quorum (OP_1 instead of OP_2)
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_1)
-            .push_slice(&pub_triple[0].to_bytes())
-            .push_slice(&pub_triple[1].to_bytes())
-            .push_slice(&pub_triple[2].to_bytes())
+            .push_slice(pub_triple[0].to_bytes())
+            .push_slice(pub_triple[1].to_bytes())
+            .push_slice(pub_triple[2].to_bytes())
             .push_opcode(OP_PUSHNUM_3)
             .push_opcode(OP_CHECKMULTISIG)
             .into_script();
@@ -198,9 +198,9 @@ mod tests {
         // Build script with wrong total (OP_4 instead of OP_3)
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_2)
-            .push_slice(&pub_triple[0].to_bytes())
-            .push_slice(&pub_triple[1].to_bytes())
-            .push_slice(&pub_triple[2].to_bytes())
+            .push_slice(pub_triple[0].to_bytes())
+            .push_slice(pub_triple[1].to_bytes())
+            .push_slice(pub_triple[2].to_bytes())
             .push_opcode(OP_PUSHNUM_4)
             .push_opcode(OP_CHECKMULTISIG)
             .into_script();
@@ -223,9 +223,9 @@ mod tests {
         // Build script without OP_CHECKMULTISIG
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_2)
-            .push_slice(&pub_triple[0].to_bytes())
-            .push_slice(&pub_triple[1].to_bytes())
-            .push_slice(&pub_triple[2].to_bytes())
+            .push_slice(pub_triple[0].to_bytes())
+            .push_slice(pub_triple[1].to_bytes())
+            .push_slice(pub_triple[2].to_bytes())
             .push_opcode(OP_PUSHNUM_3)
             .push_opcode(OP_PUSHNUM_1) // Wrong opcode instead of OP_CHECKMULTISIG
             .into_script();
@@ -242,9 +242,9 @@ mod tests {
         // Build script with invalid public key data
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_2)
-            .push_slice(&[0x00; 10]) // Invalid public key (too short)
-            .push_slice(&[0x02; 33]) // Valid compressed pubkey format
-            .push_slice(&[0x03; 33]) // Valid compressed pubkey format
+            .push_slice([0x00; 10]) // Invalid public key (too short)
+            .push_slice([0x02; 33]) // Valid compressed pubkey format
+            .push_slice([0x03; 33]) // Valid compressed pubkey format
             .push_opcode(OP_PUSHNUM_3)
             .push_opcode(OP_CHECKMULTISIG)
             .into_script();
@@ -262,8 +262,8 @@ mod tests {
         let script = Builder::new()
             .push_opcode(OP_PUSHNUM_2)
             .push_opcode(OP_PUSHNUM_1) // Wrong: should be pubkey bytes
-            .push_slice(&[0x02; 33])
-            .push_slice(&[0x03; 33])
+            .push_slice([0x02; 33])
+            .push_slice([0x03; 33])
             .push_opcode(OP_PUSHNUM_3)
             .push_opcode(OP_CHECKMULTISIG)
             .into_script();

packages/wasm-utxo/src/fixed_script_wallet/wallet_scripts/checksigverify.rs

@@ -20,7 +20,7 @@ pub fn build_p2tr_ns_script(keys: &[CompressedPublicKey]) -> ScriptBuf {
     for (i, key) in keys.iter().enumerate() {
         // convert to xonly key
         let key_bytes = to_xonly_pubkey(*key);
-        builder = builder.push_slice(&key_bytes);
+        builder = builder.push_slice(key_bytes);
         if i == keys.len() - 1 {
             builder = builder.push_opcode(OP_CHECKSIG);
         } else {
@@ -89,11 +89,11 @@ impl ScriptP2tr {
 
     pub fn output_script(&self) -> ScriptBuf {
         let output_key = self.spend_info.output_key().to_inner();
-        let output_script = Builder::new()
+        
+        Builder::new()
             .push_int(1)
             .push_slice(output_key.serialize())
-            .into_script();
-        output_script
+            .into_script()
     }
 }
 

packages/wasm-utxo/src/fixed_script_wallet/wallet_scripts/mod.rs

@@ -39,11 +39,11 @@ impl std::fmt::Display for WalletScripts {
             f,
             "{}",
             match self {
-                WalletScripts::P2sh(_) => format!("P2sh"),
-                WalletScripts::P2shP2wsh(_) => format!("P2shP2wsh"),
-                WalletScripts::P2wsh(_) => format!("P2wsh"),
-                WalletScripts::P2trLegacy(_) => format!("P2trLegacy"),
-                WalletScripts::P2trMusig2(_) => format!("P2trMusig2"),
+                WalletScripts::P2sh(_) => "P2sh".to_string(),
+                WalletScripts::P2shP2wsh(_) => "P2shP2wsh".to_string(),
+                WalletScripts::P2wsh(_) => "P2wsh".to_string(),
+                WalletScripts::P2trLegacy(_) => "P2trLegacy".to_string(),
+                WalletScripts::P2trMusig2(_) => "P2trMusig2".to_string(),
             }
         )
     }
@@ -165,7 +165,7 @@ pub fn derive_xpubs_with_path(
 ) -> XpubTriple {
     let derived = xpubs
         .iter()
-        .map(|k| k.derive_pub(&ctx, &p).unwrap())
+        .map(|k| k.derive_pub(ctx, &p).unwrap())
         .collect::<Vec<_>>();
     derived.try_into().expect("could not convert vec to array")
 }
@@ -182,7 +182,7 @@ pub fn derive_xpubs(
             index: chain as u32,
         })
         .child(ChildNumber::Normal { index });
-    derive_xpubs_with_path(&xpubs, ctx, p)
+    derive_xpubs_with_path(xpubs, ctx, p)
 }
 
 #[cfg(test)]
@@ -383,14 +383,14 @@ mod tests {
             .expect("Failed to find input with script type");
 
         let (chain, index) =
-            parse_fixture_paths(&input_fixture).expect("Failed to parse fixture paths");
+            parse_fixture_paths(input_fixture).expect("Failed to parse fixture paths");
         let scripts = WalletScripts::from_xpubs(&xpubs, chain, index);
 
         // Use the new helper methods for validation
         match (scripts, input_fixture) {
             (WalletScripts::P2sh(scripts), fixtures::PsbtInputFixture::P2sh(fixture_input)) => {
                 let vout = fixture.inputs[input_index].index as usize;
-                let output_script = get_output_script_from_non_witness_utxo(&fixture_input, vout);
+                let output_script = get_output_script_from_non_witness_utxo(fixture_input, vout);
                 fixture_input
                     .assert_matches_wallet_scripts(&scripts, &output_script)
                     .expect("P2sh validation failed");

packages/wasm-utxo/src/fixed_script_wallet/wallet_scripts/singlesig.rs

@@ -7,7 +7,7 @@ use crate::bitcoin::{CompressedPublicKey, ScriptBuf};
 /// Build bare p2pk script (used for p2sh-p2pk replay protection)
 pub fn build_p2pk_script(key: CompressedPublicKey) -> ScriptBuf {
     Builder::default()
-        .push_slice(&key.to_bytes())
+        .push_slice(key.to_bytes())
         .push_opcode(OP_CHECKSIG)
         .into_script()
 }
@@ -57,8 +57,7 @@ mod tests {
         // Get the expected values from the fixture
         let expected_redeem_script = &p2shp2pk_input.redeem_script;
         let expected_pubkey = p2shp2pk_input
-            .partial_sig
-            .get(0)
+            .partial_sig.first()
             .map(|sig| &sig.pubkey)
             .expect("No partial signature found");
 

packages/wasm-utxo/src/psbt.rs

@@ -3,8 +3,8 @@ use crate::error::WasmMiniscriptError;
 use crate::try_into_js_value::TryIntoJsValue;
 use crate::WrapDescriptor;
 use miniscript::bitcoin::bip32::Fingerprint;
-use miniscript::bitcoin::secp256k1::{Context, Secp256k1, Signing};
-use miniscript::bitcoin::{bip32, psbt, secp256k1, PublicKey, XOnlyPublicKey};
+use miniscript::bitcoin::secp256k1::{Secp256k1, Signing};
+use miniscript::bitcoin::{bip32, psbt, PublicKey, XOnlyPublicKey};
 use miniscript::bitcoin::{PrivateKey, Psbt};
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::psbt::PsbtExt;
@@ -46,23 +46,23 @@ impl psbt::GetKey for SingleKeySigner {
     fn get_key<C: Signing>(
         &self,
         key_request: psbt::KeyRequest,
-        secp: &Secp256k1<C>,
+        _secp: &Secp256k1<C>,
     ) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             // NOTE: this KeyRequest does not occur for taproot signatures
             // even if the descriptor keys are definite, we will receive a bip32 request
             // instead based on `DescriptorPublicKey::Single(SinglePub { origin: None, key, })`
             psbt::KeyRequest::Pubkey(req_pubkey) => {
                 if req_pubkey == self.pubkey {
-                    Ok(Some(self.privkey.clone()))
+                    Ok(Some(self.privkey))
                 } else {
                     Ok(None)
                 }
             }
 
-            psbt::KeyRequest::Bip32((fingerprint, path)) => {
+            psbt::KeyRequest::Bip32((fingerprint, _path)) => {
                 if fingerprint.eq(&self.fingerprint) || fingerprint.eq(&self.fingerprint_xonly) {
-                    Ok(Some(self.privkey.clone()))
+                    Ok(Some(self.privkey))
                 } else {
                     Ok(None)
                 }
@@ -99,7 +99,7 @@ impl WrapPsbt {
         match &descriptor.0 {
             WrapDescriptorEnum::Definite(d) => self
                 .0
-                .update_input_with_descriptor(input_index, &d)
+                .update_input_with_descriptor(input_index, d)
                 .map_err(JsError::from),
             WrapDescriptorEnum::Derivable(_, _) => Err(JsError::new(
                 "Cannot update input with a derivable descriptor",
@@ -119,7 +119,7 @@ impl WrapPsbt {
         match &descriptor.0 {
             WrapDescriptorEnum::Definite(d) => self
                 .0
-                .update_output_with_descriptor(output_index, &d)
+                .update_output_with_descriptor(output_index, d)
                 .map_err(JsError::from),
             WrapDescriptorEnum::Derivable(_, _) => Err(JsError::new(
                 "Cannot update output with a derivable descriptor",
@@ -149,7 +149,7 @@ impl WrapPsbt {
         let secp = Secp256k1::new();
         self.0
             .sign(&SingleKeySigner::from_privkey(privkey, &secp), &secp)
-            .map_err(|(r, errors)| {
+            .map_err(|(_r, errors)| {
                 WasmMiniscriptError::new(&format!("{} errors: {:?}", errors.len(), errors))
             })
             .and_then(|r| r.try_to_js_value())
@@ -200,7 +200,7 @@ mod tests {
             .values()
             .for_each(|key_source| {
                 let key_source_ref: KeySource = (
-                    Fingerprint::from_hex(&"aeee1e6a").unwrap(),
+                    Fingerprint::from_hex("aeee1e6a").unwrap(),
                     DerivationPath::from(vec![]),
                 );
                 assert_eq!(key_source.1, key_source_ref);

packages/wasm-utxo/src/try_into_js_value.rs

@@ -286,7 +286,7 @@ impl TryIntoJsValue for SigningKeysMap {
             js_sys::Reflect::set(
                 &obj,
                 &key.to_string().into(),
-                &value.try_to_js_value()?.into(),
+                &value.try_to_js_value()?,
             )
             .map_err(|_| WasmMiniscriptError::new("Failed to set object property"))?;
         }