Set fn_call_with to 80

Set `rustfmt` config option `fn_call_width` to 80 and run the
formatter.

Author: heap-coder

bitcoind-tests/tests/setup/test_util.rs

@@ -287,43 +287,20 @@ pub fn parse_test_desc(
 
 // substitute hash fragments in the string as the per rules
 fn subs_hash_frag(ms: &str, pubdata: &PubData) -> String {
-    let ms = ms.replace(
-        "sha256(H)",
-        &format!("sha256({})", &pubdata.sha256.to_string()),
-    );
-    let ms = ms.replace(
-        "hash256(H)",
-        &format!("hash256({})", &pubdata.hash256.to_string()),
-    );
-    let ms = ms.replace(
-        "ripemd160(H)",
-        &format!("ripemd160({})", &pubdata.ripemd160.to_string()),
-    );
-    let ms = ms.replace(
-        "hash160(H)",
-        &format!("hash160({})", &pubdata.hash160.to_string()),
-    );
+    let ms = ms.replace("sha256(H)", &format!("sha256({})", &pubdata.sha256.to_string()));
+    let ms = ms.replace("hash256(H)", &format!("hash256({})", &pubdata.hash256.to_string()));
+    let ms = ms.replace("ripemd160(H)", &format!("ripemd160({})", &pubdata.ripemd160.to_string()));
+    let ms = ms.replace("hash160(H)", &format!("hash160({})", &pubdata.hash160.to_string()));
 
     let mut rand_hash32 = [0u8; 32];
     rand::thread_rng().fill_bytes(&mut rand_hash32);
 
     let mut rand_hash20 = [0u8; 20];
     rand::thread_rng().fill_bytes(&mut rand_hash20);
-    let ms = ms.replace(
-        "sha256(H!)",
-        &format!("sha256({})", rand_hash32.to_lower_hex_string()),
-    );
-    let ms = ms.replace(
-        "hash256(H!)",
-        &format!("hash256({})", rand_hash32.to_lower_hex_string()),
-    );
-    let ms = ms.replace(
-        "ripemd160(H!)",
-        &format!("ripemd160({})", rand_hash20.to_lower_hex_string()),
-    );
-    let ms = ms.replace(
-        "hash160(H!)",
-        &format!("hash160({})", rand_hash20.to_lower_hex_string()),
-    );
+    let ms = ms.replace("sha256(H!)", &format!("sha256({})", rand_hash32.to_lower_hex_string()));
+    let ms = ms.replace("hash256(H!)", &format!("hash256({})", rand_hash32.to_lower_hex_string()));
+    let ms =
+        ms.replace("ripemd160(H!)", &format!("ripemd160({})", rand_hash20.to_lower_hex_string()));
+    let ms = ms.replace("hash160(H!)", &format!("hash160({})", rand_hash20.to_lower_hex_string()));
     ms
 }

bitcoind-tests/tests/test_cpp.rs

@@ -70,10 +70,7 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
     let pks = &testdata.pubdata.pks;
     // Generate some blocks
     let blocks = cl
-        .generate_to_address(
-            500,
-            &cl.get_new_address(None, None).unwrap().assume_checked(),
-        )
+        .generate_to_address(500, &cl.get_new_address(None, None).unwrap().assume_checked())
         .unwrap();
     assert_eq!(blocks.len(), 500);
 
@@ -96,10 +93,7 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
     }
     // Wait for the funds to mature.
     let blocks = cl
-        .generate_to_address(
-            50,
-            &cl.get_new_address(None, None).unwrap().assume_checked(),
-        )
+        .generate_to_address(50, &cl.get_new_address(None, None).unwrap().assume_checked())
         .unwrap();
     assert_eq!(blocks.len(), 50);
     // Create a PSBT for each transaction.
@@ -194,23 +188,20 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
             );
         }
         // Add the hash preimages to the psbt
-        psbts[i].inputs[0].sha256_preimages.insert(
-            testdata.pubdata.sha256,
-            testdata.secretdata.sha256_pre.to_vec(),
-        );
+        psbts[i].inputs[0]
+            .sha256_preimages
+            .insert(testdata.pubdata.sha256, testdata.secretdata.sha256_pre.to_vec());
         psbts[i].inputs[0].hash256_preimages.insert(
             sha256d::Hash::from_byte_array(testdata.pubdata.hash256.to_byte_array()),
             testdata.secretdata.hash256_pre.to_vec(),
         );
         println!("{}", ms);
-        psbts[i].inputs[0].hash160_preimages.insert(
-            testdata.pubdata.hash160,
-            testdata.secretdata.hash160_pre.to_vec(),
-        );
-        psbts[i].inputs[0].ripemd160_preimages.insert(
-            testdata.pubdata.ripemd160,
-            testdata.secretdata.ripemd160_pre.to_vec(),
-        );
+        psbts[i].inputs[0]
+            .hash160_preimages
+            .insert(testdata.pubdata.hash160, testdata.secretdata.hash160_pre.to_vec());
+        psbts[i].inputs[0]
+            .ripemd160_preimages
+            .insert(testdata.pubdata.ripemd160, testdata.secretdata.ripemd160_pre.to_vec());
         // Finalize the transaction using psbt
         // Let miniscript do it's magic!
         if let Err(e) = psbts[i].finalize_mall_mut(&secp) {
@@ -230,10 +221,7 @@ pub fn test_from_cpp_ms(cl: &Client, testdata: &TestData) {
     }
     // Finally mine the blocks and await confirmations
     let _blocks = cl
-        .generate_to_address(
-            10,
-            &cl.get_new_address(None, None).unwrap().assume_checked(),
-        )
+        .generate_to_address(10, &cl.get_new_address(None, None).unwrap().assume_checked())
         .unwrap();
     // Get the required transactions from the node mined in the blocks.
     for txid in spend_txids {

bitcoind-tests/tests/test_desc.rs

@@ -272,22 +272,19 @@ pub fn test_desc_satisfy(
         }
     }
     // Add the hash preimages to the psbt
-    psbt.inputs[0].sha256_preimages.insert(
-        testdata.pubdata.sha256,
-        testdata.secretdata.sha256_pre.to_vec(),
-    );
+    psbt.inputs[0]
+        .sha256_preimages
+        .insert(testdata.pubdata.sha256, testdata.secretdata.sha256_pre.to_vec());
     psbt.inputs[0].hash256_preimages.insert(
         sha256d::Hash::from_byte_array(testdata.pubdata.hash256.to_byte_array()),
         testdata.secretdata.hash256_pre.to_vec(),
     );
-    psbt.inputs[0].hash160_preimages.insert(
-        testdata.pubdata.hash160,
-        testdata.secretdata.hash160_pre.to_vec(),
-    );
-    psbt.inputs[0].ripemd160_preimages.insert(
-        testdata.pubdata.ripemd160,
-        testdata.secretdata.ripemd160_pre.to_vec(),
-    );
+    psbt.inputs[0]
+        .hash160_preimages
+        .insert(testdata.pubdata.hash160, testdata.secretdata.hash160_pre.to_vec());
+    psbt.inputs[0]
+        .ripemd160_preimages
+        .insert(testdata.pubdata.ripemd160, testdata.secretdata.ripemd160_pre.to_vec());
     println!("Testing descriptor: {}", definite_desc);
     // Finalize the transaction using psbt
     // Let miniscript do it's magic!

examples/psbt_sign_finalize.rs

@@ -21,14 +21,8 @@ fn main() {
     let bridge_descriptor = Descriptor::from_str(&s).unwrap();
     //let bridge_descriptor = Descriptor::<bitcoin::PublicKey>::from_str(&s).expect("parse descriptor string");
     assert!(bridge_descriptor.sanity_check().is_ok());
-    println!(
-        "Bridge pubkey script: {}",
-        bridge_descriptor.script_pubkey()
-    );
-    println!(
-        "Bridge address: {}",
-        bridge_descriptor.address(Network::Regtest).unwrap()
-    );
+    println!("Bridge pubkey script: {}", bridge_descriptor.script_pubkey());
+    println!("Bridge address: {}", bridge_descriptor.address(Network::Regtest).unwrap());
     println!(
         "Weight for witness satisfaction cost {}",
         bridge_descriptor.max_weight_to_satisfy().unwrap()
@@ -37,37 +31,25 @@ fn main() {
     let master_private_key_str = "cQhdvB3McbBJdx78VSSumqoHQiSXs75qwLptqwxSQBNBMDxafvaw";
     let _master_private_key =
         PrivateKey::from_str(master_private_key_str).expect("Can't create private key");
-    println!(
-        "Master public key: {}",
-        _master_private_key.public_key(&secp256k1)
-    );
+    println!("Master public key: {}", _master_private_key.public_key(&secp256k1));
 
     let backup1_private_key_str = "cWA34TkfWyHa3d4Vb2jNQvsWJGAHdCTNH73Rht7kAz6vQJcassky";
     let backup1_private =
         PrivateKey::from_str(backup1_private_key_str).expect("Can't create private key");
 
-    println!(
-        "Backup1 public key: {}",
-        backup1_private.public_key(&secp256k1)
-    );
+    println!("Backup1 public key: {}", backup1_private.public_key(&secp256k1));
 
     let backup2_private_key_str = "cPJFWUKk8sdL7pcDKrmNiWUyqgovimmhaaZ8WwsByDaJ45qLREkh";
     let backup2_private =
         PrivateKey::from_str(backup2_private_key_str).expect("Can't create private key");
 
-    println!(
-        "Backup2 public key: {}",
-        backup2_private.public_key(&secp256k1)
-    );
+    println!("Backup2 public key: {}", backup2_private.public_key(&secp256k1));
 
     let backup3_private_key_str = "cT5cH9UVm81W5QAf5KABXb23RKNSMbMzMx85y6R2mF42L94YwKX6";
     let _backup3_private =
         PrivateKey::from_str(backup3_private_key_str).expect("Can't create private key");
 
-    println!(
-        "Backup3 public key: {}",
-        _backup3_private.public_key(&secp256k1)
-    );
+    println!("Backup3 public key: {}", _backup3_private.public_key(&secp256k1));
 
     let spend_tx = Transaction {
         version: 2,

examples/taproot.rs

@@ -74,10 +74,7 @@ fn main() {
         );
         assert_eq!(
             iter.next().unwrap(),
-            (
-                1u8,
-                &Miniscript::<String, Tap>::from_str("multi_a(2,hA,S)").unwrap()
-            )
+            (1u8, &Miniscript::<String, Tap>::from_str("multi_a(2,hA,S)").unwrap())
         );
         assert_eq!(iter.next(), None);
     }

rustfmt.toml

@@ -4,7 +4,7 @@ tab_spaces = 4
 newline_style = "Auto"
 indent_style = "Block"
 use_small_heuristics = "Default"
-fn_call_width = 60
+fn_call_width = 80
 attr_fn_like_width = 70
 struct_lit_width = 18
 struct_variant_width = 35

src/descriptor/bare.rs

@@ -376,9 +376,7 @@ impl_from_tree!(
     Pkh<Pk>,
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
         if top.name == "pkh" && top.args.len() == 1 {
-            Ok(Pkh::new(expression::terminal(&top.args[0], |pk| {
-                Pk::from_str(pk)
-            })?)?)
+            Ok(Pkh::new(expression::terminal(&top.args[0], |pk| Pk::from_str(pk))?)?)
         } else {
             Err(Error::Unexpected(format!(
                 "{}({} args) while parsing pkh descriptor",

src/descriptor/checksum.rs

@@ -227,10 +227,7 @@ mod test {
 
         assert_eq!(
             desc_checksum(&invalid_desc).err().unwrap().to_string(),
-            format!(
-                "Invalid descriptor: Invalid character in checksum: '{}'",
-                sparkle_heart
-            )
+            format!("Invalid descriptor: Invalid character in checksum: '{}'", sparkle_heart)
         );
     }
 }