Use package in manifest and shorten import

We can use `package` to rename `bitcoin_hashes` to `hashes` and
`bitcoin_internals` to `internals`. This makes imports more terse with
no loss of meaning.

bitcoin/Cargo.toml

@@ -16,7 +16,7 @@ exclude = ["tests", "contrib"]
 default = [ "std", "secp-recovery" ]
 rand-std = ["secp256k1/rand-std"]
 rand = ["secp256k1/rand"]
-serde = ["actual-serde", "bitcoin_hashes/serde", "secp256k1/serde"]
+serde = ["actual-serde", "hashes/serde", "secp256k1/serde"]
 secp-lowmemory = ["secp256k1/lowmemory"]
 secp-recovery = ["secp256k1/recovery"]
 bitcoinconsensus-std = ["bitcoinconsensus/std", "std"]
@@ -26,17 +26,17 @@ bitcoinconsensus-std = ["bitcoinconsensus/std", "std"]
 # The no-std feature doesn't disable std - you need to turn off the std feature for that by disabling default.
 # Instead no-std enables additional features required for this crate to be usable without std.
 # As a result, both can be enabled without conflict.
-std = ["secp256k1/std", "bitcoin_hashes/std", "bech32/std", "bitcoin-internals/std"]
-no-std = ["core2", "bitcoin_hashes/alloc", "bitcoin_hashes/core2", "secp256k1/alloc"]
+std = ["secp256k1/std", "hashes/std", "bech32/std", "internals/std"]
+no-std = ["core2", "hashes/alloc", "hashes/core2", "secp256k1/alloc"]
 
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-bitcoin-internals = { path = "../internals", package = "bitcoin-private", version = "0.1.0" }
+internals = { package = "bitcoin-private", version = "0.1.0", path = "../internals" }
 bech32 = { version = "0.9.0", default-features = false }
-bitcoin_hashes = { version = "0.12.0", default-features = false }
+hashes = { package = "bitcoin_hashes", version = "0.12.0", default-features = false }
 secp256k1 = { version = "0.27.0", default-features = false, features = ["bitcoin_hashes"] }
 hex_lit = "0.1.1"
 

bitcoin/src/address.rs

@@ -33,8 +33,8 @@ use core::marker::PhantomData;
 use core::str::FromStr;
 
 use bech32;
-use bitcoin_internals::write_err;
 use hashes::{sha256, Hash, HashEngine};
+use internals::write_err;
 use secp256k1::{Secp256k1, Verification, XOnlyPublicKey};
 
 use crate::base58;

bitcoin/src/bip152.rs

@@ -10,8 +10,8 @@ use core::{convert, fmt, mem};
 #[cfg(feature = "std")]
 use std::error;
 
-use bitcoin_internals::impl_array_newtype;
 use hashes::{sha256, siphash24, Hash};
+use internals::impl_array_newtype;
 
 use crate::consensus::encode::{self, Decodable, Encodable, VarInt};
 use crate::internal_macros::{impl_bytes_newtype, impl_consensus_encoding};

bitcoin/src/bip158.rs

@@ -43,8 +43,8 @@ use core::cmp::{self, Ordering};
 use core::convert::TryInto;
 use core::fmt::{self, Display, Formatter};
 
-use bitcoin_internals::write_err;
 use hashes::{siphash24, Hash};
+use internals::write_err;
 
 use crate::blockdata::block::Block;
 use crate::blockdata::script::Script;

bitcoin/src/bip32.rs

@@ -13,8 +13,8 @@ use core::fmt;
 use core::ops::Index;
 use core::str::FromStr;
 
-use bitcoin_internals::{impl_array_newtype, write_err};
 use hashes::{hex, sha512, Hash, HashEngine, Hmac, HmacEngine};
+use internals::{impl_array_newtype, write_err};
 use secp256k1::{self, Secp256k1, XOnlyPublicKey};
 #[cfg(feature = "serde")]
 use serde;

bitcoin/src/blockdata/constants.rs

@@ -10,9 +10,9 @@
 
 use core::default::Default;
 
-use bitcoin_internals::impl_array_newtype;
 use hashes::{sha256d, Hash};
 use hex_lit::hex;
+use internals::impl_array_newtype;
 
 use crate::blockdata::block::{self, Block};
 use crate::blockdata::locktime::absolute;

bitcoin/src/blockdata/locktime/absolute.rs

@@ -10,7 +10,7 @@
 use core::cmp::{Ordering, PartialOrd};
 use core::{fmt, mem};
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 #[cfg(all(test, mutate))]
 use mutagen::mutate;
 

bitcoin/src/blockdata/opcodes.rs

@@ -12,7 +12,7 @@
 use core::convert::From;
 use core::fmt;
 
-use bitcoin_internals::debug_from_display;
+use internals::debug_from_display;
 #[cfg(feature = "serde")]
 use serde;
 

bitcoin/src/blockdata/script/builder.rs

@@ -148,4 +148,4 @@ impl fmt::Display for Builder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt_asm(f) }
 }
 
-bitcoin_internals::debug_from_display!(Builder);
+internals::debug_from_display!(Builder);

bitcoin/src/blockdata/script/mod.rs

@@ -735,7 +735,7 @@ mod bitcoinconsensus_hack {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         #[cfg(feature = "bitcoinconsensus")]
-        use bitcoin_internals::write_err;
+        use internals::write_err;
 
         match *self {
             Error::NonMinimalPush => f.write_str("non-minimal datapush"),

bitcoin/src/blockdata/transaction.rs

@@ -16,8 +16,8 @@ use core::convert::TryFrom;
 use core::default::Default;
 use core::{cmp, fmt, str};
 
-use bitcoin_internals::write_err;
 use hashes::{self, sha256d, Hash};
+use internals::write_err;
 
 use super::Weight;
 use crate::blockdata::constants::WITNESS_SCALE_FACTOR;
@@ -549,9 +549,9 @@ impl<E> EncodeSigningDataResult<E> {
     ///
     /// ```rust
     /// # use bitcoin::consensus::deserialize;
+    /// # use bitcoin::hashes::{Hash, hex::FromHex};
     /// # use bitcoin::sighash::{LegacySighash, SighashCache};
     /// # use bitcoin::Transaction;
-    /// # use bitcoin_hashes::{Hash, hex::FromHex};
     /// # let mut writer = LegacySighash::engine();
     /// # let input_index = 0;
     /// # let script_pubkey = bitcoin::ScriptBuf::new();

bitcoin/src/consensus/encode.rs

@@ -19,8 +19,8 @@
 use core::convert::From;
 use core::{fmt, mem, u32};
 
-use bitcoin_internals::write_err;
 use hashes::{sha256, sha256d, Hash};
+use internals::write_err;
 
 use crate::bip152::{PrefilledTransaction, ShortId};
 use crate::blockdata::transaction::{Transaction, TxIn, TxOut};

bitcoin/src/consensus/serde.rs

@@ -36,7 +36,6 @@ pub mod hex {
     use core::fmt;
     use core::marker::PhantomData;
 
-    use bitcoin_internals as internals;
     use internals::hex::BufEncoder;
 
     /// Marker for upper/lower case type-level flags ("type-level enum").
@@ -51,8 +50,6 @@ pub mod hex {
     pub enum Upper {}
 
     mod sealed {
-        use bitcoin_internals as internals;
-
         pub trait Case {
             /// Internal detail, don't depend on it!!!
             const INTERNAL_CASE: internals::hex::Case;
@@ -103,18 +100,18 @@ pub mod hex {
 
     /// Error returned when a hex string decoder can't be created.
     #[derive(Debug)]
-    pub struct DecodeInitError(bitcoin_hashes::hex::Error);
+    pub struct DecodeInitError(hashes::hex::Error);
 
     /// Error returned when a hex string contains invalid characters.
     #[derive(Debug)]
-    pub struct DecodeError(bitcoin_hashes::hex::Error);
+    pub struct DecodeError(hashes::hex::Error);
 
     /// Hex decoder state.
-    pub struct Decoder<'a>(bitcoin_hashes::hex::HexIterator<'a>);
+    pub struct Decoder<'a>(hashes::hex::HexIterator<'a>);
 
     impl<'a> Decoder<'a> {
         fn new(s: &'a str) -> Result<Self, DecodeInitError> {
-            match bitcoin_hashes::hex::HexIterator::new(s) {
+            match hashes::hex::HexIterator::new(s) {
                 Ok(iter) => Ok(Decoder(iter)),
                 Err(error) => Err(DecodeInitError(error)),
             }
@@ -139,7 +136,7 @@ pub mod hex {
 
     impl super::IntoDeError for DecodeInitError {
         fn into_de_error<E: serde::de::Error>(self) -> E {
-            use bitcoin_hashes::hex::Error;
+            use hashes::hex::Error;
 
             match self.0 {
                 Error::OddLengthString(len) =>
@@ -151,7 +148,7 @@ pub mod hex {
 
     impl super::IntoDeError for DecodeError {
         fn into_de_error<E: serde::de::Error>(self) -> E {
-            use bitcoin_hashes::hex::Error;
+            use hashes::hex::Error;
             use serde::de::Unexpected;
 
             const EXPECTED_CHAR: &str = "an ASCII-encoded hex digit";

bitcoin/src/crypto/ecdsa.rs

@@ -8,9 +8,9 @@
 use core::str::FromStr;
 use core::{fmt, iter};
 
-use bitcoin_internals::hex::display::DisplayHex;
-use bitcoin_internals::write_err;
 use hashes::hex::{self, FromHex};
+use internals::hex::display::DisplayHex;
+use internals::write_err;
 use secp256k1;
 
 use crate::prelude::*;

bitcoin/src/crypto/key.rs

@@ -10,9 +10,9 @@ use core::fmt::{self, Write};
 use core::ops;
 use core::str::FromStr;
 
-use bitcoin_internals::write_err;
 use hashes::hex::FromHex;
 use hashes::{hash160, hex, Hash};
+use internals::write_err;
 pub use secp256k1::{self, constants, KeyPair, Parity, Secp256k1, Verification, XOnlyPublicKey};
 
 use crate::hash_types::{PubkeyHash, WPubkeyHash};

bitcoin/src/crypto/taproot.rs

@@ -8,7 +8,7 @@
 
 use core::fmt;
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 pub use secp256k1::{self, constants, KeyPair, Parity, Secp256k1, Verification, XOnlyPublicKey};
 
 use crate::prelude::*;

bitcoin/src/error.rs

@@ -2,7 +2,7 @@
 
 use core::fmt;
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 
 use crate::consensus::encode;
 pub use crate::parse::ParseIntError;

bitcoin/src/internal_macros.rs

@@ -84,14 +84,14 @@ macro_rules! impl_bytes_newtype {
 
         impl core::fmt::LowerHex for $t {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                use bitcoin_internals::hex::{display, Case};
+                use internals::hex::{display, Case};
                 display::fmt_hex_exact!(f, $len, &self.0, Case::Lower)
             }
         }
 
         impl core::fmt::UpperHex for $t {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-                use bitcoin_internals::hex::{display, Case};
+                use internals::hex::{display, Case};
                 display::fmt_hex_exact!(f, $len, &self.0, Case::Upper)
             }
         }

bitcoin/src/lib.rs

@@ -60,10 +60,10 @@ extern crate alloc;
 #[cfg_attr(docsrs, doc(cfg(feature = "base64")))]
 pub extern crate base64;
 pub extern crate bech32;
-pub extern crate bitcoin_hashes as hashes;
 #[cfg(feature = "bitcoinconsensus")]
 #[cfg_attr(docsrs, doc(cfg(feature = "bitcoinconsensus")))]
 pub extern crate bitcoinconsensus;
+pub extern crate hashes;
 pub extern crate secp256k1;
 
 #[cfg(feature = "serde")]
@@ -177,7 +177,7 @@ mod prelude {
     #[cfg(not(feature = "std"))]
     pub use crate::io_extras::sink;
 
-    pub use bitcoin_internals::hex::display::DisplayHex;
+    pub use internals::hex::display::DisplayHex;
 }
 
 #[cfg(bench)]

bitcoin/src/network/constants.rs

@@ -32,8 +32,8 @@ use core::fmt::Display;
 use core::str::FromStr;
 use core::{fmt, ops};
 
-use bitcoin_internals::{debug_from_display, write_err};
 use hashes::hex::{Error, FromHex};
+use internals::{debug_from_display, write_err};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -317,7 +317,7 @@ impl TryFrom<Magic> for Network {
 
 impl fmt::Display for Magic {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        bitcoin_internals::fmt_hex_exact!(f, 4, &self.0, bitcoin_internals::hex::Case::Lower)?;
+        internals::fmt_hex_exact!(f, 4, &self.0, internals::hex::Case::Lower)?;
         Ok(())
     }
 }
@@ -325,14 +325,14 @@ debug_from_display!(Magic);
 
 impl fmt::LowerHex for Magic {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        bitcoin_internals::fmt_hex_exact!(f, 4, &self.0, bitcoin_internals::hex::Case::Lower)?;
+        internals::fmt_hex_exact!(f, 4, &self.0, internals::hex::Case::Lower)?;
         Ok(())
     }
 }
 
 impl fmt::UpperHex for Magic {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        bitcoin_internals::fmt_hex_exact!(f, 4, &self.0, bitcoin_internals::hex::Case::Upper)?;
+        internals::fmt_hex_exact!(f, 4, &self.0, internals::hex::Case::Upper)?;
         Ok(())
     }
 }

bitcoin/src/parse.rs

@@ -2,7 +2,7 @@ use core::convert::TryFrom;
 use core::fmt;
 use core::str::FromStr;
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 
 use crate::error::impl_std_error;
 use crate::prelude::*;

bitcoin/src/pow.rs

@@ -776,13 +776,13 @@ macro_rules! impl_hex {
     ($hex:ident, $case:expr) => {
         impl $hex for U256 {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                bitcoin_internals::hex::display::fmt_hex_exact!(f, 32, &self.to_be_bytes(), $case)
+                internals::hex::display::fmt_hex_exact!(f, 32, &self.to_be_bytes(), $case)
             }
         }
     };
 }
-impl_hex!(LowerHex, bitcoin_internals::hex::Case::Lower);
-impl_hex!(UpperHex, bitcoin_internals::hex::Case::Upper);
+impl_hex!(LowerHex, internals::hex::Case::Lower);
+impl_hex!(UpperHex, internals::hex::Case::Upper);
 
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]

bitcoin/src/psbt/error.rs

@@ -2,7 +2,7 @@
 
 use core::fmt;
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 
 use crate::bip32::ExtendedPubKey;
 use crate::blockdata::transaction::Transaction;

bitcoin/src/psbt/mod.rs

@@ -11,7 +11,7 @@ use core::{cmp, fmt};
 #[cfg(feature = "std")]
 use std::collections::{HashMap, HashSet};
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 use secp256k1::{Message, Secp256k1, Signing};
 
 use crate::bip32::{self, ExtendedPrivKey, ExtendedPubKey, KeySource};
@@ -756,7 +756,7 @@ mod display_from_str {
     use core::str::FromStr;
 
     use base64::display::Base64Display;
-    use bitcoin_internals::write_err;
+    use internals::write_err;
 
     use super::{Error, PartiallySignedTransaction};
 

bitcoin/src/serde_utils.rs

@@ -12,7 +12,7 @@ impl<'a> serde::Serialize for SerializeBytesAsHex<'a> {
     where
         S: serde::Serializer,
     {
-        use bitcoin_internals::hex::display::DisplayHex;
+        use internals::hex::display::DisplayHex;
 
         serializer.collect_str(&format_args!("{:x}", self.0.as_hex()))
     }

bitcoin/src/sign_message.rs

@@ -21,8 +21,8 @@ pub const BITCOIN_SIGNED_MSG_PREFIX: &[u8] = b"\x18Bitcoin Signed Message:\n";
 mod message_signing {
     use core::fmt;
 
-    use bitcoin_internals::write_err;
     use hashes::sha256d;
+    use internals::write_err;
     use secp256k1;
     use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
 

bitcoin/src/string.rs

@@ -7,7 +7,7 @@
 
 use core::fmt;
 
-use bitcoin_internals::write_err;
+use internals::write_err;
 
 use crate::prelude::String;
 

bitcoin/src/taproot.rs

@@ -10,8 +10,8 @@ use core::convert::TryFrom;
 use core::fmt;
 use core::iter::FusedIterator;
 
-use bitcoin_internals::write_err;
 use hashes::{sha256t_hash_newtype, Hash, HashEngine};
+use internals::write_err;
 use secp256k1::{self, Scalar, Secp256k1};
 
 use crate::consensus::Encodable;