From dfc3e76101818774fdc3ac923d18aff18b699056 Mon Sep 17 00:00:00 2001 From: "Tobin C. Harding" Date: Thu, 28 Apr 2022 11:14:20 +1000 Subject: [PATCH] Configure imports_granularity Configure `imports_granularity = "Module"`. The benefit of this option is that it increases uniformity in the code base over the default "Preserve" and also, from my personal experience, it tends to reduce the noise in diffs from adding/removing imports. --- examples/parse.rs | 3 ++- rustfmt.toml | 2 +- src/descriptor/bare.rs | 12 ++++++------ src/descriptor/key.rs | 19 ++++++++----------- src/descriptor/mod.rs | 18 +++++++----------- src/descriptor/pretaproot.rs | 15 ++++++--------- src/descriptor/segwitv0.rs | 9 ++++----- src/descriptor/sh.rs | 17 ++++++++--------- src/descriptor/sortedmulti.rs | 16 +++++++++------- src/descriptor/tr.rs | 12 ++++++------ src/expression.rs | 4 +--- src/interpreter/error.rs | 3 ++- src/interpreter/inner.rs | 4 +--- src/interpreter/mod.rs | 9 ++------- src/lib.rs | 3 ++- src/miniscript/analyzable.rs | 3 +-- src/miniscript/astelem.rs | 8 ++++---- src/miniscript/context.rs | 4 +--- src/miniscript/decode.rs | 8 ++------ src/miniscript/mod.rs | 14 ++++++-------- src/miniscript/ms_tests.rs | 3 ++- src/miniscript/satisfy.rs | 6 +----- src/miniscript/types/extra_props.rs | 4 +--- src/miniscript/types/mod.rs | 6 +++--- src/policy/compiler.rs | 6 ++---- src/policy/concrete.rs | 3 +-- src/policy/mod.rs | 14 +++++--------- src/policy/semantic.rs | 4 +--- src/psbt/finalizer.rs | 9 ++------- src/psbt/mod.rs | 12 +++++------- src/util.rs | 3 +-- 31 files changed, 103 insertions(+), 150 deletions(-) diff --git a/examples/parse.rs b/examples/parse.rs index f4c07a798..a7651f86c 100644 --- a/examples/parse.rs +++ b/examples/parse.rs @@ -19,7 +19,8 @@ extern crate miniscript; use std::str::FromStr; -use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait}; +use miniscript::descriptor::DescriptorType; +use miniscript::{Descriptor, DescriptorTrait}; fn main() { let my_descriptor = miniscript::Descriptor::::from_str( diff --git a/rustfmt.toml b/rustfmt.toml index f61bac29a..f3bff64fa 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -27,7 +27,7 @@ fn_single_line = false where_single_line = false imports_indent = "Block" imports_layout = "Mixed" -imports_granularity = "Preserve" +imports_granularity = "Module" # Default "Preserve" group_imports = "StdExternalCrate" # Default "Preserve" reorder_imports = true reorder_modules = true diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs index d05b5ddfe..aca61be78 100644 --- a/src/descriptor/bare.rs +++ b/src/descriptor/bare.rs @@ -18,9 +18,11 @@ //! Also includes pk, and pkh descriptors //! -use std::{fmt, str::FromStr}; +use std::fmt; +use std::str::FromStr; -use bitcoin::{self, blockdata::script, Script}; +use bitcoin::blockdata::script; +use bitcoin::{self, Script}; use expression::{self, FromTree}; use miniscript::context::ScriptContext; use policy::{semantic, Liftable}; @@ -30,10 +32,8 @@ use { TranslatePk, }; -use super::{ - checksum::{desc_checksum, verify_checksum}, - DescriptorTrait, -}; +use super::checksum::{desc_checksum, verify_checksum}; +use super::DescriptorTrait; /// Create a Bare Descriptor. That is descriptor that is /// not wrapped in sh or wsh. This covers the Pk descriptor diff --git a/src/descriptor/key.rs b/src/descriptor/key.rs index 926165a3d..0e152af55 100644 --- a/src/descriptor/key.rs +++ b/src/descriptor/key.rs @@ -1,14 +1,11 @@ -use std::{error, fmt, str::FromStr}; - -use bitcoin::{ - self, - hashes::Hash, - hashes::{hex::FromHex, HashEngine}, - secp256k1, - secp256k1::{Secp256k1, Signing}, - util::bip32, - XOnlyPublicKey, XpubIdentifier, -}; +use std::str::FromStr; +use std::{error, fmt}; + +use bitcoin::hashes::hex::FromHex; +use bitcoin::hashes::{Hash, HashEngine}; +use bitcoin::secp256k1::{Secp256k1, Signing}; +use bitcoin::util::bip32; +use bitcoin::{self, secp256k1, XOnlyPublicKey, XpubIdentifier}; use {MiniscriptKey, ToPublicKey}; /// Single public key without any origin or range information diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs index 24019e411..afa269d28 100644 --- a/src/descriptor/mod.rs +++ b/src/descriptor/mod.rs @@ -23,20 +23,17 @@ //! these with BIP32 paths, pay-to-contract instructions, etc. //! -use std::{collections::HashMap, sync::Arc}; -use std::{ - fmt, - str::{self, FromStr}, -}; +use std::collections::HashMap; +use std::fmt; +use std::str::{self, FromStr}; +use std::sync::Arc; use bitcoin::blockdata::witness::Witness; use bitcoin::{self, secp256k1, Script}; -use expression; -use miniscript; use miniscript::{Legacy, Miniscript, Segwitv0}; use { - BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk, - TranslatePk2, + expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, + ToPublicKey, TranslatePk, TranslatePk2, }; use self::checksum::verify_checksum; @@ -839,10 +836,9 @@ mod tests { use descriptor::{ DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePub, DescriptorXKey, }; - use hex_script; #[cfg(feature = "compiler")] use policy; - use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2}; + use {hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2}; use super::checksum::desc_checksum; use super::tr::Tr; diff --git a/src/descriptor/pretaproot.rs b/src/descriptor/pretaproot.rs index 3140583df..2f1c21842 100644 --- a/src/descriptor/pretaproot.rs +++ b/src/descriptor/pretaproot.rs @@ -1,12 +1,11 @@ -use std::{ - fmt, - str::{self, FromStr}, -}; +use std::fmt; +use std::str::{self, FromStr}; use bitcoin::{self, Script}; use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey}; -use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh}; +use super::checksum::verify_checksum; +use super::{Bare, Pkh, Sh, Wpkh, Wsh}; /// Script descriptor #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -240,10 +239,8 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor"); // Have the trait in a separate module to avoid conflicts pub(crate) mod traits { use bitcoin::Script; - use { - descriptor::{Pkh, Sh, Wpkh, Wsh}, - DescriptorTrait, MiniscriptKey, ToPublicKey, - }; + use descriptor::{Pkh, Sh, Wpkh, Wsh}; + use {DescriptorTrait, MiniscriptKey, ToPublicKey}; use super::PreTaprootDescriptor; diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs index d1e4af883..6d77b2ffa 100644 --- a/src/descriptor/segwitv0.rs +++ b/src/descriptor/segwitv0.rs @@ -16,7 +16,8 @@ //! Implementation of Segwit Descriptors. Contains the implementation //! of wsh, wpkh and sortedmulti inside wsh. -use std::{fmt, str::FromStr}; +use std::fmt; +use std::str::FromStr; use bitcoin::{self, Script}; use expression::{self, FromTree}; @@ -28,10 +29,8 @@ use { TranslatePk, }; -use super::{ - checksum::{desc_checksum, verify_checksum}, - DescriptorTrait, SortedMultiVec, -}; +use super::checksum::{desc_checksum, verify_checksum}; +use super::{DescriptorTrait, SortedMultiVec}; /// A Segwitv0 wsh descriptor #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)] pub struct Wsh { diff --git a/src/descriptor/sh.rs b/src/descriptor/sh.rs index d04bbed78..767fe6c1a 100644 --- a/src/descriptor/sh.rs +++ b/src/descriptor/sh.rs @@ -18,23 +18,22 @@ //! sh(miniscript), and sh(wpkh) //! -use std::{fmt, str::FromStr}; +use std::fmt; +use std::str::FromStr; -use bitcoin::{self, blockdata::script, Script}; +use bitcoin::blockdata::script; +use bitcoin::{self, Script}; use expression::{self, FromTree}; use miniscript::context::ScriptContext; use policy::{semantic, Liftable}; -use push_opcode_size; use util::{varint_len, witness_to_scriptsig}; use { - Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0, - ToPublicKey, TranslatePk, + push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, + Segwitv0, ToPublicKey, TranslatePk, }; -use super::{ - checksum::{desc_checksum, verify_checksum}, - DescriptorTrait, SortedMultiVec, Wpkh, Wsh, -}; +use super::checksum::{desc_checksum, verify_checksum}; +use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh}; /// A Legacy p2sh Descriptor #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)] diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs index 475ef3307..f3d039636 100644 --- a/src/descriptor/sortedmulti.rs +++ b/src/descriptor/sortedmulti.rs @@ -16,16 +16,18 @@ //! Implementation of sorted multi primitive for descriptors //! -use std::{fmt, marker::PhantomData, str::FromStr}; +use std::fmt; +use std::marker::PhantomData; +use std::str::FromStr; use bitcoin::blockdata::script; -use expression; -use miniscript::{ - self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG, +use miniscript::context::ScriptContext; +use miniscript::decode::Terminal; +use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG; +use { + errstr, expression, miniscript, policy, script_num_size, Error, ForEach, ForEachKey, + Miniscript, MiniscriptKey, Satisfier, ToPublicKey, }; -use policy; -use script_num_size; -use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey}; /// Contents of a "sortedmulti" descriptor #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs index 8e9504c27..5d870b343 100644 --- a/src/descriptor/tr.rs +++ b/src/descriptor/tr.rs @@ -1,9 +1,9 @@ // Tapscript use std::cmp::{self, max}; -use std::hash; +use std::str::FromStr; use std::sync::{Arc, Mutex}; -use std::{fmt, str::FromStr}; +use std::{fmt, hash}; use bitcoin::blockdata::opcodes; use bitcoin::util::taproot::{ @@ -11,15 +11,15 @@ use bitcoin::util::taproot::{ TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE, }; use bitcoin::{self, secp256k1, Script}; -use errstr; use expression::{self, FromTree}; use miniscript::Miniscript; use policy::semantic::Policy; use policy::Liftable; use util::{varint_len, witness_size}; -use Tap; -use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk}; -use {Error, MiniscriptKey}; +use { + errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap, + ToPublicKey, TranslatePk, +}; use super::checksum::{desc_checksum, verify_checksum}; diff --git a/src/expression.rs b/src/expression.rs index 596cfce02..a079533cf 100644 --- a/src/expression.rs +++ b/src/expression.rs @@ -17,9 +17,7 @@ use std::str::FromStr; -use errstr; -use Error; -use MAX_RECURSION_DEPTH; +use {errstr, Error, MAX_RECURSION_DEPTH}; #[derive(Debug)] /// A token of the form `x(...)` or `x` diff --git a/src/interpreter/error.rs b/src/interpreter/error.rs index 32bebf52c..45318f620 100644 --- a/src/interpreter/error.rs +++ b/src/interpreter/error.rs @@ -14,7 +14,8 @@ use std::{error, fmt}; -use bitcoin::hashes::{hash160, hex::ToHex}; +use bitcoin::hashes::hash160; +use bitcoin::hashes::hex::ToHex; use bitcoin::util::taproot; use bitcoin::{self, secp256k1}; diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs index f95aca0fa..dd566f7dd 100644 --- a/src/interpreter/inner.rs +++ b/src/interpreter/inner.rs @@ -12,13 +12,11 @@ // If not, see . // -use bitcoin; use bitcoin::blockdata::witness::Witness; use bitcoin::hashes::{hash160, sha256, Hash}; use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX}; use miniscript::context::{NoChecks, ScriptContext}; -use {BareCtx, Legacy, Segwitv0, Tap}; -use {Miniscript, MiniscriptKey}; +use {bitcoin, BareCtx, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap}; use super::{stack, BitcoinKey, Error, Stack, TypedHash160}; diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs index 2577a041b..0e2314f62 100644 --- a/src/interpreter/mod.rs +++ b/src/interpreter/mod.rs @@ -29,9 +29,7 @@ use bitcoin::util::{sighash, taproot}; use bitcoin::{self, secp256k1, TxOut}; use miniscript::context::NoChecks; use miniscript::ScriptContext; -use Miniscript; -use Terminal; -use {Descriptor, ToPublicKey}; +use {Descriptor, Miniscript, Terminal, ToPublicKey}; mod error; mod inner; @@ -1030,13 +1028,10 @@ fn verify_sersig<'txin>( #[cfg(test)] mod tests { - use bitcoin; use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash}; use bitcoin::secp256k1::{self, Secp256k1}; use miniscript::context::NoChecks; - use Miniscript; - use MiniscriptKey; - use ToPublicKey; + use {bitcoin, Miniscript, MiniscriptKey, ToPublicKey}; use super::inner::ToNoChecks; use super::*; diff --git a/src/lib.rs b/src/lib.rs index aac9c6750..8d36b5677 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -121,7 +121,8 @@ use std::{error, fmt, hash, str}; use bitcoin::blockdata::{opcodes, script}; use bitcoin::hashes::{hash160, sha256, Hash}; -pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor}; +pub use descriptor::pretaproot::traits::PreTaprootDescriptorTrait; +pub use descriptor::pretaproot::PreTaprootDescriptor; pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait}; pub use interpreter::Interpreter; pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap}; diff --git a/src/miniscript/analyzable.rs b/src/miniscript/analyzable.rs index 6487c100a..25202ae39 100644 --- a/src/miniscript/analyzable.rs +++ b/src/miniscript/analyzable.rs @@ -20,9 +20,8 @@ use std::collections::HashSet; use std::fmt; -use error; use miniscript::iter::PkPkh; -use {Miniscript, MiniscriptKey, ScriptContext}; +use {error, Miniscript, MiniscriptKey, ScriptContext}; /// Possible reasons Miniscript guarantees can fail /// We currently mark Miniscript as Non-Analyzable if /// 1. It is unsafe(does not require a digital signature to spend it) diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs index 21c5d7f86..11971e1d1 100644 --- a/src/miniscript/astelem.rs +++ b/src/miniscript/astelem.rs @@ -26,14 +26,14 @@ use std::{fmt, str}; use bitcoin::blockdata::{opcodes, script}; use bitcoin::hashes::hex::FromHex; use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash}; -use errstr; -use expression; use miniscript::context::SigType; use miniscript::types::{self, Property}; use miniscript::ScriptContext; -use script_num_size; use util::MsKeyBuilder; -use {Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk}; +use { + errstr, expression, script_num_size, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, + Terminal, ToPublicKey, TranslatePk, +}; impl Terminal { /// Internal helper function for displaying wrapper types; returns diff --git a/src/miniscript/context.rs b/src/miniscript/context.rs index 7602ee092..b4798fa92 100644 --- a/src/miniscript/context.rs +++ b/src/miniscript/context.rs @@ -14,7 +14,6 @@ use std::{fmt, hash}; -use bitcoin; use bitcoin::blockdata::constants::MAX_BLOCK_WEIGHT; use miniscript::limits::{ MAX_OPS_PER_SCRIPT, MAX_PUBKEYS_PER_MULTISIG, MAX_SCRIPTSIG_SIZE, MAX_SCRIPT_ELEMENT_SIZE, @@ -23,8 +22,7 @@ use miniscript::limits::{ }; use miniscript::types; use util::witness_to_scriptsig; -use Error; -use {Miniscript, MiniscriptKey, Terminal}; +use {bitcoin, Error, Miniscript, MiniscriptKey, Terminal}; use super::decode::ParseableKey; diff --git a/src/miniscript/decode.rs b/src/miniscript/decode.rs index d42591db7..500788000 100644 --- a/src/miniscript/decode.rs +++ b/src/miniscript/decode.rs @@ -26,13 +26,9 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash}; use miniscript::lex::{Token as Tk, TokenIter}; use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG; use miniscript::types::extra_props::ExtData; -use miniscript::types::Property; -use miniscript::types::Type; +use miniscript::types::{Property, Type}; use miniscript::ScriptContext; -use Error; -use MiniscriptKey; -use ToPublicKey; -use {bitcoin, Miniscript}; +use {bitcoin, Error, Miniscript, MiniscriptKey, ToPublicKey}; fn return_none(_: usize) -> Option { None diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs index 4e569f5f6..165a71aaa 100644 --- a/src/miniscript/mod.rs +++ b/src/miniscript/mod.rs @@ -49,8 +49,7 @@ pub use miniscript::context::ScriptContext; use miniscript::decode::Terminal; use miniscript::types::extra_props::ExtData; use miniscript::types::Type; -use MiniscriptKey; -use {expression, Error, ForEach, ForEachKey, ToPublicKey, TranslatePk}; +use {expression, Error, ForEach, ForEachKey, MiniscriptKey, ToPublicKey, TranslatePk}; use self::lex::{lex, TokenIter}; use self::types::Property; @@ -473,16 +472,15 @@ mod tests { use bitcoin::secp256k1::XOnlyPublicKey; use bitcoin::util::taproot::TapLeafHash; use bitcoin::{self, secp256k1}; - use hex_script; use miniscript::types::{self, ExtData, Property, Type}; use miniscript::Terminal; use policy::Liftable; - use TranslatePk2; - use {DummyKey, DummyKeyHash, MiniscriptKey, TranslatePk, TranslatePk1}; - use {Satisfier, ToPublicKey}; + use { + hex_script, DummyKey, DummyKeyHash, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk, + TranslatePk1, TranslatePk2, + }; - use super::{Miniscript, ScriptContext}; - use super::{Segwitv0, Tap}; + use super::{Miniscript, ScriptContext, Segwitv0, Tap}; type Segwitv0Script = Miniscript; type Tapscript = Miniscript; diff --git a/src/miniscript/ms_tests.rs b/src/miniscript/ms_tests.rs index f706768f3..4bdd874f0 100644 --- a/src/miniscript/ms_tests.rs +++ b/src/miniscript/ms_tests.rs @@ -20,7 +20,8 @@ mod tests { use std::fmt; - use {miniscript::types, Miniscript, Segwitv0}; + use miniscript::types; + use {Miniscript, Segwitv0}; struct TestType(types::Type); diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs index 323490e50..a53968fc7 100644 --- a/src/miniscript/satisfy.rs +++ b/src/miniscript/satisfy.rs @@ -22,7 +22,6 @@ use std::collections::{BTreeMap, HashMap}; use std::sync::Arc; use std::{cmp, i64, mem}; -use bitcoin; use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d}; use bitcoin::secp256k1::XOnlyPublicKey; use bitcoin::util::taproot::{ControlBlock, LeafVersion, TapLeafHash}; @@ -30,10 +29,7 @@ use miniscript::limits::{ HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_LOCKTIME_TYPE_FLAG, }; use util::witness_size; -use Miniscript; -use ScriptContext; -use Terminal; -use {MiniscriptKey, ToPublicKey}; +use {bitcoin, Miniscript, MiniscriptKey, ScriptContext, Terminal, ToPublicKey}; /// Type alias for 32 byte Preimage. pub type Preimage32 = [u8; 32]; diff --git a/src/miniscript/types/extra_props.rs b/src/miniscript/types/extra_props.rs index d28f46024..f4ddea460 100644 --- a/src/miniscript/types/extra_props.rs +++ b/src/miniscript/types/extra_props.rs @@ -7,9 +7,7 @@ use std::iter::once; use miniscript::limits::{ HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_LOCKTIME_TYPE_FLAG, }; -use script_num_size; -use MiniscriptKey; -use Terminal; +use {script_num_size, MiniscriptKey, Terminal}; use super::{Error, ErrorKind, Property, ScriptContext}; diff --git a/src/miniscript/types/mod.rs b/src/miniscript/types/mod.rs index eef2f2771..53e4aa9c4 100644 --- a/src/miniscript/types/mod.rs +++ b/src/miniscript/types/mod.rs @@ -22,13 +22,13 @@ pub mod malleability; use std::{error, fmt}; -use MiniscriptKey; -use Terminal; +use {MiniscriptKey, Terminal}; pub use self::correctness::{Base, Correctness, Input}; pub use self::extra_props::ExtData; pub use self::malleability::{Dissat, Malleability}; -use super::{limits::SEQUENCE_LOCKTIME_DISABLE_FLAG, ScriptContext}; +use super::limits::SEQUENCE_LOCKTIME_DISABLE_FLAG; +use super::ScriptContext; /// None-returning function to help type inference when we need a /// closure that simply returns `None` diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs index 8d511a6e2..67b6fb92a 100644 --- a/src/policy/compiler.rs +++ b/src/policy/compiler.rs @@ -20,17 +20,15 @@ use std::collections::vec_deque::VecDeque; use std::collections::BTreeMap; use std::convert::From; -use std::hash; use std::marker::PhantomData; use std::sync::Arc; -use std::{cmp, error, f64, fmt, mem}; +use std::{cmp, error, f64, fmt, hash, mem}; use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG; use miniscript::types::{self, ErrorKind, ExtData, Property, Type}; use miniscript::ScriptContext; use policy::Concrete; -use {policy, Terminal}; -use {Miniscript, MiniscriptKey}; +use {policy, Miniscript, MiniscriptKey, Terminal}; type PolicyCache = BTreeMap<(Concrete, OrdF64, Option), BTreeMap>>; diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs index a189b39f4..b38176fc7 100644 --- a/src/policy/concrete.rs +++ b/src/policy/concrete.rs @@ -20,7 +20,6 @@ use std::{error, fmt, str}; use bitcoin::hashes::hex::FromHex; use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d}; -use errstr; use expression::{self, FromTree}; use miniscript::limits::{HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_TYPE_FLAG}; use miniscript::types::extra_props::TimeLockInfo; @@ -32,7 +31,7 @@ use policy::compiler; use policy::compiler::CompilerError; #[cfg(feature = "compiler")] use Miniscript; -use {Error, ForEach, ForEachKey, MiniscriptKey}; +use {errstr, Error, ForEach, ForEachKey, MiniscriptKey}; use super::ENTAILMENT_MAX_TERMINALS; /// Concrete policy which corresponds directly to a Miniscript structure, diff --git a/src/policy/mod.rs b/src/policy/mod.rs index 3a1ccea94..aff3b379d 100644 --- a/src/policy/mod.rs +++ b/src/policy/mod.rs @@ -30,9 +30,7 @@ pub mod semantic; use descriptor::Descriptor; use miniscript::{Miniscript, ScriptContext}; -use Error; -use MiniscriptKey; -use Terminal; +use {Error, MiniscriptKey, Terminal}; pub use self::concrete::Policy as Concrete; /// Semantic policies are "abstract" policies elsewhere; but we @@ -230,13 +228,11 @@ impl Liftable for Concrete { mod tests { use std::str::FromStr; - use bitcoin; - use DummyKey; + use {bitcoin, DummyKey}; - use super::{ - super::miniscript::{context::Segwitv0, Miniscript}, - Concrete, Liftable, Semantic, - }; + use super::super::miniscript::context::Segwitv0; + use super::super::miniscript::Miniscript; + use super::{Concrete, Liftable, Semantic}; type ConcretePol = Concrete; type SemanticPol = Semantic; diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs index 28e0edb95..9ae9d37b7 100644 --- a/src/policy/semantic.rs +++ b/src/policy/semantic.rs @@ -19,9 +19,7 @@ use std::{fmt, str}; use bitcoin::hashes::hex::FromHex; use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d}; -use errstr; -use Error; -use {expression, ForEach, ForEachKey, MiniscriptKey}; +use {errstr, expression, Error, ForEach, ForEachKey, MiniscriptKey}; use super::concrete::PolicyError; use super::ENTAILMENT_MAX_TERMINALS; diff --git a/src/psbt/finalizer.rs b/src/psbt/finalizer.rs index 609c8e819..95c10738f 100644 --- a/src/psbt/finalizer.rs +++ b/src/psbt/finalizer.rs @@ -28,15 +28,10 @@ use bitcoin::util::sighash::Prevouts; use bitcoin::util::taproot::LeafVersion; use bitcoin::{self, PublicKey, Script, TxOut}; use descriptor::DescriptorTrait; -use interpreter; use util::witness_size; -use Descriptor; -use Miniscript; -use Satisfier; -use {BareCtx, Legacy, Segwitv0, Tap}; +use {interpreter, BareCtx, Descriptor, Legacy, Miniscript, Satisfier, Segwitv0, Tap}; -use super::{sanity_check, Psbt}; -use super::{Error, InputError, PsbtInputSatisfier}; +use super::{sanity_check, Error, InputError, Psbt, PsbtInputSatisfier}; // Satisfy the taproot descriptor. It is not possible to infer the complete // descriptor from psbt because the information about all the scripts might not diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs index 994b1ae21..9147d9aed 100644 --- a/src/psbt/mod.rs +++ b/src/psbt/mod.rs @@ -28,15 +28,13 @@ use bitcoin::secp256k1::{self, Secp256k1}; use bitcoin::util::psbt::PartiallySignedTransaction as Psbt; use bitcoin::util::sighash::SighashCache; use bitcoin::util::taproot::{self, ControlBlock, LeafVersion, TapLeafHash}; -use bitcoin::{self, SchnorrSighashType}; -use bitcoin::{EcdsaSighashType, Script}; -use descriptor; -use interpreter; +use bitcoin::{self, EcdsaSighashType, SchnorrSighashType, Script}; use miniscript::limits::SEQUENCE_LOCKTIME_DISABLE_FLAG; use miniscript::satisfy::{After, Older}; -use Preimage32; -use Satisfier; -use {Descriptor, DescriptorPublicKey, DescriptorTrait, MiniscriptKey, ToPublicKey}; +use { + descriptor, interpreter, Descriptor, DescriptorPublicKey, DescriptorTrait, MiniscriptKey, + Preimage32, Satisfier, ToPublicKey, +}; mod finalizer; diff --git a/src/util.rs b/src/util.rs index ab957ccde..8d3fcf979 100644 --- a/src/util.rs +++ b/src/util.rs @@ -1,8 +1,7 @@ -use bitcoin; use bitcoin::blockdata::script; use bitcoin::Script; use miniscript::context; -use {ScriptContext, ToPublicKey}; +use {bitcoin, ScriptContext, ToPublicKey}; pub(crate) fn varint_len(n: usize) -> usize { bitcoin::VarInt(n as u64).len() }