Add actual-arbitrary dependency

The actual-arbitrary dependency groups two features, arbitrary and
units/arbitrary in the bitcoin crate.  Similar functionality can be
achieved using the `dep:` syntax, however that violates the crates
current MSRV.

Author: yancyribbens

bitcoin/Cargo.toml

@@ -22,7 +22,7 @@ serde = ["actual-serde", "hashes/serde", "secp256k1/serde", "internals/serde", "
 secp-lowmemory = ["secp256k1/lowmemory"]
 secp-recovery = ["secp256k1/recovery"]
 bitcoinconsensus-std = ["bitcoinconsensus/std", "std"]
-arbitrary-units = ["units/arbitrary"]
+arbitrary = ["actual-arbitrary", "units/arbitrary"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -37,7 +37,7 @@ hex_lit = "0.1.1"
 internals = { package = "bitcoin-internals", version = "0.3.0", features = ["alloc"] }
 io = { package = "bitcoin-io", version = "0.1.1", default-features = false, features = ["alloc"] }
 secp256k1 = { version = "0.29.0", default-features = false, features = ["hashes", "alloc"] }
-units = { package = "bitcoin-units", path = "../units", default-features = false, features = ["alloc"] }
+units = { package = "bitcoin-units", version = "0.1.0", default-features = false, features = ["alloc"] }
 
 base64 = { version = "0.21.3", optional = true }
 ordered = { version = "0.2.0", optional = true }

bitcoin/src/bip152.rs

@@ -10,7 +10,7 @@ use core::{convert, fmt, mem};
 use std::error;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hashes::{sha256, siphash24, Hash};
 use internals::impl_array_newtype;
 use io::{Read, Write};
@@ -376,7 +376,7 @@ impl BlockTransactions {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockTransactions {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(BlockTransactions {
             block_hash: u.arbitrary()?,
             transactions: Vec::<Transaction>::arbitrary(u)?,
@@ -386,7 +386,7 @@ impl<'a> Arbitrary<'a> for BlockTransactions {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockTransactionsRequest {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(BlockTransactionsRequest {
             block_hash: u.arbitrary()?,
             indexes: Vec::<u64>::arbitrary(u)?,
@@ -396,7 +396,7 @@ impl<'a> Arbitrary<'a> for BlockTransactionsRequest {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for HeaderAndShortIds {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(HeaderAndShortIds {
             header: u.arbitrary()?,
             nonce: u.arbitrary()?,
@@ -408,14 +408,14 @@ impl<'a> Arbitrary<'a> for HeaderAndShortIds {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for PrefilledTransaction {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(PrefilledTransaction { idx: u.arbitrary()?, tx: u.arbitrary()? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ShortId {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(ShortId(u.arbitrary()?))
     }
 }

bitcoin/src/bip158.rs

@@ -42,7 +42,7 @@ use core::cmp::{self, Ordering};
 use core::fmt::{self, Display, Formatter};
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hashes::{sha256d, siphash24, Hash};
 use internals::write_err;
 use io::{Read, Write};
@@ -563,14 +563,14 @@ impl<'a, W: Write> BitStreamWriter<'a, W> {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for FilterHash {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(FilterHash::from_byte_array(u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for FilterHeader {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(FilterHeader::from_byte_array(u.arbitrary()?))
     }
 }

bitcoin/src/blockdata/block.rs

@@ -11,7 +11,7 @@
 use core::fmt;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hashes::{sha256d, Hash, HashEngine};
 use io::{Read, Write};
 
@@ -488,21 +488,21 @@ impl std::error::Error for ValidationError {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Block {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(Block { header: Header::arbitrary(u)?, txdata: Vec::<Transaction>::arbitrary(u)? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for BlockHash {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(BlockHash::from_byte_array(u.arbitrary()?))
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Header {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(Header {
             version: Version::arbitrary(u)?,
             prev_blockhash: BlockHash::from_byte_array(u.arbitrary()?),
@@ -516,7 +516,7 @@ impl<'a> Arbitrary<'a> for Header {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Version {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         // Equally weight known versions and arbitrary versions
         let choice = u.int_in_range(0..=3)?;
         match choice {

bitcoin/src/blockdata/locktime/absolute.rs

@@ -11,7 +11,7 @@ use core::fmt;
 use core::str::FromStr;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use io::{Read, Write};
 #[cfg(all(test, mutate))]
 use mutagen::mutate;
@@ -438,7 +438,7 @@ impl ordered::ArbitraryOrd for LockTime {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for LockTime {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let l = u32::arbitrary(u)?;
         Ok(LockTime::from_consensus(l))
     }

bitcoin/src/blockdata/script/owned.rs

@@ -4,7 +4,7 @@
 use core::ops::Deref;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hex::FromHex;
 use secp256k1::{Secp256k1, Verification};
 
@@ -362,7 +362,7 @@ impl<'a> Extend<Instruction<'a>> for ScriptBuf {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ScriptBuf {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let v = Vec::<u8>::arbitrary(u)?;
         Ok(ScriptBuf(v))
     }

bitcoin/src/blockdata/transaction.rs

@@ -39,7 +39,7 @@ use crate::{Amount, SignedAmount, VarInt};
 pub use crate::consensus::validation::TxVerifyError;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 
 hashes::hash_newtype! {
     /// A bitcoin transaction hash/transaction ID.
@@ -1650,7 +1650,7 @@ impl InputWeightPrediction {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for InputWeightPrediction {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         // limit script size to 4Mwu block size.
         let max_block = Weight::MAX_BLOCK.to_wu() as usize;
         let input_script_len = u.int_in_range(0..=max_block)?;
@@ -1681,14 +1681,14 @@ impl<'a> Arbitrary<'a> for InputWeightPrediction {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for OutPoint {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(OutPoint { txid: Txid::arbitrary(u)?, vout: u32::arbitrary(u)? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Sequence {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let choice_range = 8;
 
         // Equally weight the cases of meaningful sequence numbers
@@ -1709,7 +1709,7 @@ impl<'a> Arbitrary<'a> for Sequence {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Transaction {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         use absolute::LockTime;
 
         Ok(Transaction {
@@ -1723,7 +1723,7 @@ impl<'a> Arbitrary<'a> for Transaction {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for TxIn {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(TxIn {
             previous_output: OutPoint::arbitrary(u)?,
             script_sig: ScriptBuf::arbitrary(u)?,
@@ -1735,7 +1735,7 @@ impl<'a> Arbitrary<'a> for TxIn {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Txid {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let arbitrary_bytes = u.arbitrary()?;
         let t = sha256d::Hash::from_byte_array(arbitrary_bytes);
         Ok(Txid(t))
@@ -1744,14 +1744,14 @@ impl<'a> Arbitrary<'a> for Txid {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for TxOut {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(TxOut { value: Amount::arbitrary(u)?, script_pubkey: ScriptBuf::arbitrary(u)? })
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Version {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         // Equally weight the case of normal version numbers
         let choice = u.int_in_range(0..=2)?;
         match choice {
@@ -1764,7 +1764,7 @@ impl<'a> Arbitrary<'a> for Version {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Wtxid {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         Ok(Wtxid::from_byte_array(u.arbitrary()?))
     }
 }

bitcoin/src/blockdata/witness.rs

@@ -9,7 +9,7 @@ use core::fmt;
 use core::ops::Index;
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use io::{Read, Write};
 
 use crate::consensus::encode::{Error, MAX_VEC_SIZE};
@@ -695,7 +695,7 @@ impl Default for Witness {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Witness {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let arbitrary_bytes = Vec::<Vec<u8>>::arbitrary(u)?;
         Ok(Witness::from_slice(&arbitrary_bytes))
     }

bitcoin/src/crypto/ecdsa.rs

@@ -8,7 +8,7 @@ use core::str::FromStr;
 use core::{fmt, iter};
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hex::FromHex;
 use internals::write_err;
 use io::Write;
@@ -258,7 +258,7 @@ impl From<hex::HexToBytesError> for Error {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Signature {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         // The valid range of r and s should be between 0 and n-1 where
         // n = 0xFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141
         let high_min = 0x0u128;

bitcoin/src/crypto/sighash.rs

@@ -14,7 +14,7 @@
 use core::{fmt, str};
 
 #[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
+use actual_arbitrary::{Arbitrary, Unstructured};
 use hashes::{hash_newtype, sha256, sha256d, sha256t_hash_newtype, Hash};
 use internals::write_err;
 use io::Write;
@@ -1450,7 +1450,7 @@ impl<E: std::error::Error + 'static> std::error::Error for SigningDataError<E> {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for EcdsaSighashType {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=5)?;
         match choice {
             0 => Ok(EcdsaSighashType::All),
@@ -1465,7 +1465,7 @@ impl<'a> Arbitrary<'a> for EcdsaSighashType {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for TapSighashType {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> actual_arbitrary::Result<Self> {
         let choice = u.int_in_range(0..=6)?;
         match choice {
             0 => Ok(TapSighashType::Default),