Cargo fmt with default nightly

sanket1729 · sanket1729 · commit cb90aa78dda9 · 2022-10-19T14:23:09.000-07:00
diff --git a/examples/taproot.rs b/examples/taproot.rs
@@ -124,7 +124,9 @@ fn main() {
     assert_eq!(max_sat_wt, 273);
 
     // Compute the bitcoin address and check if it matches
-    let addr = real_desc.address(&elements::AddressParams::ELEMENTS).unwrap();
+    let addr = real_desc
+        .address(&elements::AddressParams::ELEMENTS)
+        .unwrap();
     let expected_addr = elements::Address::from_str(
         "ert1pxx6wkfdnnx97akwws8l8xdmx5n03qftvx2t269k4sn9adm2emz0sdnytn4",
     )
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
@@ -29,8 +29,8 @@ use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    elementssig_to_rawsig, BareCtx, Error, ForEachKey, Miniscript, MiniscriptKey,
-    Satisfier, ToPublicKey, TranslatePk, Translator,
+    elementssig_to_rawsig, BareCtx, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, Translator,
 };
 
 /// Create a Bare Descriptor. That is descriptor that is
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
@@ -1065,15 +1065,24 @@ impl<Ext: Extension> Descriptor<DefiniteDescriptorKey, Ext> {
                 Ok(*sha256)
             }
 
-            fn hash256(&mut self, hash256: &hash256::Hash) -> Result<hash256::Hash, ConversionError> {
+            fn hash256(
+                &mut self,
+                hash256: &hash256::Hash,
+            ) -> Result<hash256::Hash, ConversionError> {
                 Ok(*hash256)
             }
 
-            fn ripemd160(&mut self, ripemd160: &ripemd160::Hash) -> Result<ripemd160::Hash, ConversionError> {
+            fn ripemd160(
+                &mut self,
+                ripemd160: &ripemd160::Hash,
+            ) -> Result<ripemd160::Hash, ConversionError> {
                 Ok(*ripemd160)
             }
 
-            fn hash160(&mut self, hash160: &hash160::Hash) -> Result<hash160::Hash, ConversionError> {
+            fn hash160(
+                &mut self,
+                hash160: &hash160::Hash,
+            ) -> Result<hash160::Hash, ConversionError> {
                 Ok(*hash160)
             }
         }
diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs
@@ -28,8 +28,8 @@ use crate::miniscript::context::{ScriptContext, ScriptContextError};
 use crate::policy::{semantic, Liftable};
 use crate::util::varint_len;
 use crate::{
-    elementssig_to_rawsig, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier,
-    Segwitv0, ToPublicKey, TranslatePk, Translator,
+    elementssig_to_rawsig, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
+    ToPublicKey, TranslatePk, Translator,
 };
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
@@ -27,8 +27,8 @@ use crate::miniscript::decode::Terminal;
 use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::miniscript::{self};
 use crate::{
-    errstr, expression, policy, script_num_size, Error, ForEachKey, Miniscript,
-    MiniscriptKey, Satisfier, ToPublicKey, Translator,
+    errstr, expression, policy, script_num_size, Error, ForEachKey, Miniscript, MiniscriptKey,
+    Satisfier, ToPublicKey, Translator,
 };
 
 /// Contents of a "sortedmulti" descriptor
diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs
@@ -20,8 +20,8 @@ use crate::policy::semantic::Policy;
 use crate::policy::Liftable;
 use crate::util::{varint_len, witness_size};
 use crate::{
-    errstr, Error, Extension, ForEachKey, MiniscriptKey, NoExt, Satisfier, Tap,
-    ToPublicKey, TranslateExt, TranslatePk, Translator,
+    errstr, Error, Extension, ForEachKey, MiniscriptKey, NoExt, Satisfier, Tap, ToPublicKey,
+    TranslateExt, TranslatePk, Translator,
 };
 
 /// A Taproot Tree representation.
diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs
@@ -24,7 +24,9 @@ use crate::descriptor::{CovOperations, LegacyCSFSCov};
 use crate::extensions::ParseableExt;
 use crate::miniscript::context::{NoChecks, ScriptContext};
 use crate::util::is_v1_p2tr;
-use crate::{hash256, BareCtx, Extension, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap, Translator};
+use crate::{
+    hash256, BareCtx, Extension, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap, Translator,
+};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
 /// if asked to, but otherwise dropping it
diff --git a/src/interpreter/stack.rs b/src/interpreter/stack.rs
@@ -24,8 +24,7 @@ use super::error::PkEvalErrInner;
 use super::{
     verify_sersig, BitcoinKey, Error, HashLockType, KeySigPair, SatisfiedConstraint, TypedHash160,
 };
-use crate::hash256;
-use crate::Extension;
+use crate::{hash256, Extension};
 
 /// Definition of Stack Element of the Stack used for interpretation of Miniscript.
 /// All stack elements with vec![] go to Dissatisfied and vec![1] are marked to Satisfied.
diff --git a/src/lib.rs b/src/lib.rs
@@ -110,9 +110,9 @@ compile_error!(
     "elements-miniscript currently only supports architectures with pointers wider than 16 bits"
 );
 
-pub use {bitcoin, elements};
 #[cfg(feature = "serde")]
 pub use actual_serde as serde;
+pub use {bitcoin, elements};
 #[cfg(all(test, feature = "unstable"))]
 extern crate test;
 
@@ -123,14 +123,14 @@ extern crate test;
 pub(crate) use bitcoin_miniscript::expression::{FromTree as BtcFromTree, Tree as BtcTree};
 pub(crate) use bitcoin_miniscript::policy::semantic::Policy as BtcPolicy;
 pub(crate) use bitcoin_miniscript::policy::Liftable as BtcLiftable;
-pub(crate) use bitcoin_miniscript::{
-    Descriptor as BtcDescriptor, Error as BtcError, Miniscript as BtcMiniscript,
-    Satisfier as BtcSatisfier, Segwitv0 as BtcSegwitv0, Terminal as BtcTerminal,
-};
 // re-export imports
 pub use bitcoin_miniscript::{
     hash256, DummyKey, DummyKeyHash, ForEachKey, MiniscriptKey, ToPublicKey,
 };
+pub(crate) use bitcoin_miniscript::{
+    Descriptor as BtcDescriptor, Error as BtcError, Miniscript as BtcMiniscript,
+    Satisfier as BtcSatisfier, Segwitv0 as BtcSegwitv0, Terminal as BtcTerminal,
+};
 // End imports
 
 #[macro_use]
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
@@ -24,15 +24,16 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use elements::{opcodes, script};
+
 use super::limits::{MAX_SCRIPT_ELEMENT_SIZE, MAX_STANDARD_P2WSH_STACK_ITEM_SIZE};
 use crate::extensions::ParseableExt;
 use crate::miniscript::context::SigType;
 use crate::miniscript::types::{self, Property};
 use crate::miniscript::ScriptContext;
 use crate::util::MsKeyBuilder;
 use crate::{
-    errstr, expression, script_num_size, Error, ExtTranslator, Extension, ForEachKey,
-    Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslateExt, TranslatePk, Translator,
+    errstr, expression, script_num_size, Error, ExtTranslator, Extension, ForEachKey, Miniscript,
+    MiniscriptKey, Terminal, ToPublicKey, TranslateExt, TranslatePk, Translator,
 };
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension> Terminal<Pk, Ctx, Ext> {
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
@@ -53,8 +53,8 @@ use crate::miniscript::decode::Terminal;
 use crate::miniscript::types::extra_props::ExtData;
 use crate::miniscript::types::Type;
 use crate::{
-    expression, Error, ExtTranslator, Extension, ForEachKey, MiniscriptKey, NoExt,
-    ToPublicKey, TranslateExt, TranslatePk, Translator,
+    expression, Error, ExtTranslator, Extension, ForEachKey, MiniscriptKey, NoExt, ToPublicKey,
+    TranslateExt, TranslatePk, Translator,
 };
 #[cfg(test)]
 mod ms_tests;
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
@@ -338,7 +338,10 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_pk(pkh)
     }
 
-    fn lookup_pkh_ecdsa_sig(&self, pkh: &Pk::RawPkHash) -> Option<(bitcoin::PublicKey, ElementsSig)> {
+    fn lookup_pkh_ecdsa_sig(
+        &self,
+        pkh: &Pk::RawPkHash,
+    ) -> Option<(bitcoin::PublicKey, ElementsSig)> {
         (**self).lookup_pkh_ecdsa_sig(pkh)
     }
 
@@ -461,7 +464,10 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
         (**self).lookup_pkh_pk(pkh)
     }
 
-    fn lookup_pkh_ecdsa_sig(&self, pkh: &Pk::RawPkHash) -> Option<(bitcoin::PublicKey, ElementsSig)> {
+    fn lookup_pkh_ecdsa_sig(
+        &self,
+        pkh: &Pk::RawPkHash,
+    ) -> Option<(bitcoin::PublicKey, ElementsSig)> {
         (**self).lookup_pkh_ecdsa_sig(pkh)
     }
 
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
@@ -266,10 +266,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// is also *cost-efficient*.
     // TODO: We might require other compile errors for Taproot.
     #[cfg(feature = "compiler")]
-    pub fn compile_tr(
-        &self,
-        unspendable_key: Option<Pk>,
-    ) -> Result<Descriptor<Pk, NoExt>, Error> {
+    pub fn compile_tr(&self, unspendable_key: Option<Pk>) -> Result<Descriptor<Pk, NoExt>, Error> {
         self.is_valid()?; // Check for validity
         match self.is_safe_nonmalleable() {
             (false, _) => Err(Error::from(CompilerError::TopLevelNonSafe)),
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
@@ -362,7 +362,10 @@ impl<'psbt, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfie
         }
     }
 
-    fn lookup_pkh_ecdsa_sig(&self, pkh: &Pk::RawPkHash) -> Option<(bitcoin::PublicKey, ElementsSig)> {
+    fn lookup_pkh_ecdsa_sig(
+        &self,
+        pkh: &Pk::RawPkHash,
+    ) -> Option<(bitcoin::PublicKey, ElementsSig)> {
         if let Some((pk, sig)) = self.psbt.inputs()[self.index]
             .partial_sigs
             .iter()
diff --git a/src/test_utils.rs b/src/test_utils.rs
@@ -6,7 +6,8 @@ use std::str::FromStr;
 use bitcoin::hashes::{hash160, ripemd160, sha256};
 use bitcoin::secp256k1;
 
-use crate::extensions::{param::ExtParamTranslator, CovExtArgs};
+use crate::extensions::param::ExtParamTranslator;
+use crate::extensions::CovExtArgs;
 use crate::{hash256, MiniscriptKey, Translator};
 
 /// Translate from a String MiniscriptKey type to bitcoin::PublicKey
diff --git a/tests/setup/test_util.rs b/tests/setup/test_util.rs
@@ -26,10 +26,11 @@ use bitcoin::secp256k1;
 use elements::hashes::hex::FromHex;
 use elements::{confidential, encode, AddressParams, BlockHash};
 use miniscript::descriptor::{SinglePub, SinglePubKey};
-use miniscript::extensions::{param::ExtParamTranslator, CovExtArgs, CsfsKey, CsfsMsg};
+use miniscript::extensions::param::ExtParamTranslator;
+use miniscript::extensions::{CovExtArgs, CsfsKey, CsfsMsg};
 use miniscript::{
-    hash256, CovenantExt, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext, TranslateExt,
-    TranslatePk, Translator,
+    hash256, CovenantExt, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext,
+    TranslateExt, TranslatePk, Translator,
 };
 use rand::RngCore;
 use {actual_rand as rand, elements_miniscript as miniscript};
diff --git a/tests/test_arith.rs b/tests/test_arith.rs
@@ -51,8 +51,8 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
     let desc_address = derived_desc.address(&PARAMS).unwrap(); // No blinding
 
     // Next send some btc to each address corresponding to the miniscript
-    let txid = cl.send_to_address(&desc_address, "1");  // 1 BTC
-    // Wait for the funds to mature.
+    let txid = cl.send_to_address(&desc_address, "1"); // 1 BTC
+                                                       // Wait for the funds to mature.
     cl.generate(2);
     // Create a PSBT for each transaction.
     // Spend one input and spend one output for simplicity.
diff --git a/tests/test_csfs.rs b/tests/test_csfs.rs
@@ -51,8 +51,8 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
     let desc_address = derived_desc.address(&PARAMS).unwrap(); // No blinding
 
     // Next send some btc to each address corresponding to the miniscript
-    let txid = cl.send_to_address(&desc_address, "1");  // 1 BTC
-    // Wait for the funds to mature.
+    let txid = cl.send_to_address(&desc_address, "1"); // 1 BTC
+                                                       // Wait for the funds to mature.
     cl.generate(2);
     // Create a PSBT for each transaction.
     // Spend one input and spend one output for simplicity.
diff --git a/tests/test_desc.rs b/tests/test_desc.rs
@@ -86,8 +86,8 @@ pub fn test_desc_satisfy(
     let desc_address = desc_address.map_err(|_x| DescError::AddressComputationError)?;
 
     // Next send some btc to each address corresponding to the miniscript
-    let txid = cl.send_to_address(&desc_address, "1");  // 1 BTC
-    // Wait for the funds to mature.
+    let txid = cl.send_to_address(&desc_address, "1"); // 1 BTC
+                                                       // Wait for the funds to mature.
     cl.generate(2);
     // Create a PSBT for each transaction.
     // Spend one input and spend one output for simplicity.
@@ -312,7 +312,7 @@ pub fn test_desc_satisfy(
         .as_u64()
         .unwrap();
     assert!(num_conf > 0);
-    return Ok(tx.input[0].witness.script_witness.clone())
+    return Ok(tx.input[0].witness.script_witness.clone());
 }
 
 // Find all secret corresponding to the known public keys in ms
diff --git a/tests/test_introspect.rs b/tests/test_introspect.rs
@@ -51,8 +51,8 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
     let desc_address = derived_desc.address(&PARAMS).unwrap(); // No blinding
 
     // Next send some btc to each address corresponding to the miniscript
-    let txid = cl.send_to_address(&desc_address, "1");  // 1 BTC
-    // Wait for the funds to mature.
+    let txid = cl.send_to_address(&desc_address, "1"); // 1 BTC
+                                                       // Wait for the funds to mature.
     cl.generate(2);
     // Create a PSBT for each transaction.
     // Spend one input and spend one output for simplicity.

Original file line number	Diff line number	Diff line change
`@@ -1065,15 +1065,24 @@ impl<Ext: Extension> Descriptor<DefiniteDescriptorKey, Ext> {`
`1065`	`1065`	`Ok(*sha256)`
`1066`	`1066`	`}`
`1067`	`1067`
`1068`		`- fn hash256(&mut self, hash256: &hash256::Hash) -> Result<hash256::Hash, ConversionError> {`
	`1068`	`+ fn hash256(`
	`1069`	`+ &mut self,`
	`1070`	`+ hash256: &hash256::Hash,`
	`1071`	`+ ) -> Result<hash256::Hash, ConversionError> {`
`1069`	`1072`	`Ok(*hash256)`
`1070`	`1073`	`}`
`1071`	`1074`
`1072`		`- fn ripemd160(&mut self, ripemd160: &ripemd160::Hash) -> Result<ripemd160::Hash, ConversionError> {`
	`1075`	`+ fn ripemd160(`
	`1076`	`+ &mut self,`
	`1077`	`+ ripemd160: &ripemd160::Hash,`
	`1078`	`+ ) -> Result<ripemd160::Hash, ConversionError> {`
`1073`	`1079`	`Ok(*ripemd160)`
`1074`	`1080`	`}`
`1075`	`1081`
`1076`		`- fn hash160(&mut self, hash160: &hash160::Hash) -> Result<hash160::Hash, ConversionError> {`
	`1082`	`+ fn hash160(`
	`1083`	`+ &mut self,`
	`1084`	`+ hash160: &hash160::Hash,`
	`1085`	`+ ) -> Result<hash160::Hash, ConversionError> {`
`1077`	`1086`	`Ok(*hash160)`
`1078`	`1087`	`}`
`1079`	`1088`	`}`