fuzz: rename old_bitcoin to bitcoin_0_32

diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index c54c9c60..916556fa 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -13,7 +13,7 @@ cargo-fuzz = true
 # We shouldn't need an explicit version on the next line, but Andrew's tools
 # choke on it otherwise. See https://github.com/nix-community/crate2nix/issues/373
 bitcoin = { path = "../bitcoin", version = "0.33.0-beta", features = [ "serde", "arbitrary" ] }
-old_bitcoin = { version = "0.32.101", package = "bitcoin", features = [ "encoding", "serde" ] }
+bitcoin_0_32 = { version = "0.32.101", package = "bitcoin", features = [ "encoding", "serde" ] }
 bitcoin_consensus_encoding = { path = "../consensus_encoding", package = "bitcoin-consensus-encoding" }
 p2p = { path = "../p2p", package = "bitcoin-p2p-messages", features = ["arbitrary"] }
 
diff --git a/fuzz/fuzz_targets/bitcoin/compare_consensus_encoding.rs b/fuzz/fuzz_targets/bitcoin/compare_consensus_encoding.rs
index d74327f4..e3e272a7 100644
--- a/fuzz/fuzz_targets/bitcoin/compare_consensus_encoding.rs
+++ b/fuzz/fuzz_targets/bitcoin/compare_consensus_encoding.rs
@@ -71,19 +71,19 @@ fn is_known_decoder_divergence(err: &(dyn std::error::Error + 'static)) -> bool
 macro_rules! compare_encoding {
     // Simple path for top-level types
     ($data:expr, $ty:ident) => {
-        compare_encoding!($data, bitcoin::$ty, old_bitcoin::$ty);
+        compare_encoding!($data, bitcoin::$ty, bitcoin_0_32::$ty);
     };
 
     // Types in submodules need this because we can't easily concatenate crate prefixes.
     ($data:expr, $new_ty:ty, $old_ty:ty) => {{
         // Try to deserialise using both bitcoin crates. Skip if it can't be deserialised
-        let old_result: Result<$old_ty, _> = old_bitcoin::consensus::encode::deserialize($data);
+        let old_result: Result<$old_ty, _> = bitcoin_0_32::consensus::encode::deserialize($data);
         let new_result: Result<$new_ty, _> = decode_from_slice($data);
 
         match (old_result, new_result) {
             (Ok(old_obj), Ok(new_obj)) => {
                 // Encode with old bitcoin and then compare against new encoding
-                let old_encoded = old_bitcoin::consensus::encode::serialize(&old_obj);
+                let old_encoded = bitcoin_0_32::consensus::encode::serialize(&old_obj);
                 // Uncomment the following two lines if you need to see the difference
                 // in serialisation.
                 // let new_encoded = bitcoin_consensus_encoding::encode_to_vec(&new_obj);
@@ -169,49 +169,49 @@ fn do_test(data: &[u8]) {
     compare_encoding!(data, TxMerkleNode);
     compare_encoding!(data, WitnessMerkleNode);
 
-    compare_encoding!(data, bitcoin::block::Header, old_bitcoin::block::Header);
-    compare_encoding!(data, bitcoin::absolute::LockTime, old_bitcoin::absolute::LockTime);
-    compare_encoding!(data, bitcoin::block::Version, old_bitcoin::block::Version);
-    compare_encoding!(data, bitcoin::transaction::Version, old_bitcoin::transaction::Version);
+    compare_encoding!(data, bitcoin::block::Header, bitcoin_0_32::block::Header);
+    compare_encoding!(data, bitcoin::absolute::LockTime, bitcoin_0_32::absolute::LockTime);
+    compare_encoding!(data, bitcoin::block::Version, bitcoin_0_32::block::Version);
+    compare_encoding!(data, bitcoin::transaction::Version, bitcoin_0_32::transaction::Version);
 
     // P2P types
-    compare_encoding!(data, p2p::ServiceFlags, old_bitcoin::p2p::ServiceFlags);
-    compare_encoding!(data, p2p::Magic, old_bitcoin::p2p::Magic);
-    compare_encoding!(data, p2p::address::Address, old_bitcoin::p2p::address::Address);
-    compare_encoding!(data, p2p::bip152::BlockTransactions, old_bitcoin::bip152::BlockTransactions);
-    compare_encoding!(data, p2p::bip152::BlockTransactionsRequest, old_bitcoin::bip152::BlockTransactionsRequest);
-    compare_encoding!(data, p2p::bip152::HeaderAndShortIds, old_bitcoin::bip152::HeaderAndShortIds);
-    compare_encoding!(data, p2p::bip152::PrefilledTransaction, old_bitcoin::bip152::PrefilledTransaction);
-    compare_encoding!(data, p2p::bip152::ShortId, old_bitcoin::bip152::ShortId);
-    compare_encoding!(data, p2p::merkle_tree::MerkleBlock, old_bitcoin::MerkleBlock);
-    compare_encoding!(data, p2p::merkle_tree::PartialMerkleTree, old_bitcoin::merkle_tree::PartialMerkleTree);
-    compare_encoding!(data, p2p::message_blockdata::GetBlocksMessage, old_bitcoin::p2p::message_blockdata::GetBlocksMessage);
-    compare_encoding!(data, p2p::message_blockdata::GetHeadersMessage, old_bitcoin::p2p::message_blockdata::GetHeadersMessage);
-    compare_encoding!(data, p2p::message_bloom::FilterAdd, old_bitcoin::p2p::message_bloom::FilterAdd);
-    compare_encoding!(data, p2p::message_bloom::FilterLoad, old_bitcoin::p2p::message_bloom::FilterLoad);
-    compare_encoding!(data, p2p::message_bloom::BloomFlags, old_bitcoin::p2p::message_bloom::BloomFlags);
-    compare_encoding!(data, p2p::message_compact_blocks::SendCmpct, old_bitcoin::p2p::message_compact_blocks::SendCmpct);
-    compare_encoding!(data, p2p::message_filter::CFHeaders, old_bitcoin::p2p::message_filter::CFHeaders);
-    compare_encoding!(data, p2p::message_filter::CFilter, old_bitcoin::p2p::message_filter::CFilter);
-    compare_encoding!(data, p2p::message_filter::CFCheckpt, old_bitcoin::p2p::message_filter::CFCheckpt);
-    compare_encoding!(data, p2p::message_filter::GetCFCheckpt, old_bitcoin::p2p::message_filter::GetCFCheckpt);
-    compare_encoding!(data, p2p::message_filter::GetCFHeaders, old_bitcoin::p2p::message_filter::GetCFHeaders);
-    compare_encoding!(data, p2p::message_filter::GetCFilters, old_bitcoin::p2p::message_filter::GetCFilters);
-    compare_encoding!(data, p2p::message_filter::FilterHash, old_bitcoin::bip158::FilterHash);
-    compare_encoding!(data, p2p::message_filter::FilterHeader, old_bitcoin::bip158::FilterHeader);
-    compare_encoding!(data, p2p::message_network::Reject, old_bitcoin::p2p::message_network::Reject);
-    compare_encoding!(data, p2p::message_network::RejectReason, old_bitcoin::p2p::message_network::RejectReason);
-    compare_encoding!(data, p2p::message_network::VersionMessage, old_bitcoin::p2p::message_network::VersionMessage);
+    compare_encoding!(data, p2p::ServiceFlags, bitcoin_0_32::p2p::ServiceFlags);
+    compare_encoding!(data, p2p::Magic, bitcoin_0_32::p2p::Magic);
+    compare_encoding!(data, p2p::address::Address, bitcoin_0_32::p2p::address::Address);
+    compare_encoding!(data, p2p::bip152::BlockTransactions, bitcoin_0_32::bip152::BlockTransactions);
+    compare_encoding!(data, p2p::bip152::BlockTransactionsRequest, bitcoin_0_32::bip152::BlockTransactionsRequest);
+    compare_encoding!(data, p2p::bip152::HeaderAndShortIds, bitcoin_0_32::bip152::HeaderAndShortIds);
+    compare_encoding!(data, p2p::bip152::PrefilledTransaction, bitcoin_0_32::bip152::PrefilledTransaction);
+    compare_encoding!(data, p2p::bip152::ShortId, bitcoin_0_32::bip152::ShortId);
+    compare_encoding!(data, p2p::merkle_tree::MerkleBlock, bitcoin_0_32::MerkleBlock);
+    compare_encoding!(data, p2p::merkle_tree::PartialMerkleTree, bitcoin_0_32::merkle_tree::PartialMerkleTree);
+    compare_encoding!(data, p2p::message_blockdata::GetBlocksMessage, bitcoin_0_32::p2p::message_blockdata::GetBlocksMessage);
+    compare_encoding!(data, p2p::message_blockdata::GetHeadersMessage, bitcoin_0_32::p2p::message_blockdata::GetHeadersMessage);
+    compare_encoding!(data, p2p::message_bloom::FilterAdd, bitcoin_0_32::p2p::message_bloom::FilterAdd);
+    compare_encoding!(data, p2p::message_bloom::FilterLoad, bitcoin_0_32::p2p::message_bloom::FilterLoad);
+    compare_encoding!(data, p2p::message_bloom::BloomFlags, bitcoin_0_32::p2p::message_bloom::BloomFlags);
+    compare_encoding!(data, p2p::message_compact_blocks::SendCmpct, bitcoin_0_32::p2p::message_compact_blocks::SendCmpct);
+    compare_encoding!(data, p2p::message_filter::CFHeaders, bitcoin_0_32::p2p::message_filter::CFHeaders);
+    compare_encoding!(data, p2p::message_filter::CFilter, bitcoin_0_32::p2p::message_filter::CFilter);
+    compare_encoding!(data, p2p::message_filter::CFCheckpt, bitcoin_0_32::p2p::message_filter::CFCheckpt);
+    compare_encoding!(data, p2p::message_filter::GetCFCheckpt, bitcoin_0_32::p2p::message_filter::GetCFCheckpt);
+    compare_encoding!(data, p2p::message_filter::GetCFHeaders, bitcoin_0_32::p2p::message_filter::GetCFHeaders);
+    compare_encoding!(data, p2p::message_filter::GetCFilters, bitcoin_0_32::p2p::message_filter::GetCFilters);
+    compare_encoding!(data, p2p::message_filter::FilterHash, bitcoin_0_32::bip158::FilterHash);
+    compare_encoding!(data, p2p::message_filter::FilterHeader, bitcoin_0_32::bip158::FilterHeader);
+    compare_encoding!(data, p2p::message_network::Reject, bitcoin_0_32::p2p::message_network::Reject);
+    compare_encoding!(data, p2p::message_network::RejectReason, bitcoin_0_32::p2p::message_network::RejectReason);
+    compare_encoding!(data, p2p::message_network::VersionMessage, bitcoin_0_32::p2p::message_network::VersionMessage);
 
     // Types that only exist in new bitcoin, but can encode the same as some known type
     compare_encoding!(data, p2p::ProtocolVersion, u32);
-    compare_encoding!(data, p2p::address::AddrV1Message, (u32, old_bitcoin::p2p::Address));
-    compare_encoding!(data, p2p::message::AddrPayload, Vec<(u32, old_bitcoin::p2p::Address)>);
-    compare_encoding!(data, p2p::message::NetworkHeader, (old_bitcoin::block::Header, u8));
+    compare_encoding!(data, p2p::address::AddrV1Message, (u32, bitcoin_0_32::p2p::Address));
+    compare_encoding!(data, p2p::message::AddrPayload, Vec<(u32, bitcoin_0_32::p2p::Address)>);
+    compare_encoding!(data, p2p::message::NetworkHeader, (bitcoin_0_32::block::Header, u8));
     compare_encoding!(data, p2p::message::Ping, u64);
     compare_encoding!(data, p2p::message::Pong, u64);
-    compare_encoding!(data, p2p::message::V1NetworkMessage, old_bitcoin::p2p::message::RawNetworkMessage);
-    compare_encoding!(data, p2p::message_blockdata::BlockLocator, Vec<old_bitcoin::BlockHash>);
+    compare_encoding!(data, p2p::message::V1NetworkMessage, bitcoin_0_32::p2p::message::RawNetworkMessage);
+    compare_encoding!(data, p2p::message_blockdata::BlockLocator, Vec<bitcoin_0_32::BlockHash>);
     compare_encoding!(data, p2p::message_network::Alert, Vec<u8>);
     compare_encoding!(data, p2p::message_network::UserAgent, String);
     compare_encoding!(data, bitcoin::BlockHeight, u32);
@@ -222,18 +222,18 @@ fn do_test(data: &[u8]) {
     // ServiceFlags > 0x0200_0000 are not supported by the old decoder.
     // Skip inputs that would trigger either known divergence.
     if data.first() != Some(&0x03) {
-        compare_encoding!(data, p2p::address::AddrV2, old_bitcoin::p2p::address::AddrV2);
+        compare_encoding!(data, p2p::address::AddrV2, bitcoin_0_32::p2p::address::AddrV2);
     }
     if !addrv2_message_should_skip(data) {
-        compare_encoding!(data, p2p::address::AddrV2Message, old_bitcoin::p2p::address::AddrV2Message);
+        compare_encoding!(data, p2p::address::AddrV2Message, bitcoin_0_32::p2p::address::AddrV2Message);
     }
     if !addrv2_payload_should_skip(data) {
-        compare_encoding!(data, p2p::message::AddrV2Payload, Vec<old_bitcoin::p2p::address::AddrV2Message>);
+        compare_encoding!(data, p2p::message::AddrV2Payload, Vec<bitcoin_0_32::p2p::address::AddrV2Message>);
     }
     // Inventory::Error (type_id=0) encodes differently between old/new bitcoin: old omits the
     // 32-byte hash field, new includes it. Skip inputs that would decode as the Error variant.
     if data.get(..4) != Some(&[0u8; 4]) {
-        compare_encoding!(data, p2p::message_blockdata::Inventory, old_bitcoin::p2p::message_blockdata::Inventory);
+        compare_encoding!(data, p2p::message_blockdata::Inventory, bitcoin_0_32::p2p::message_blockdata::Inventory);
     }
 }
 
diff --git a/fuzz/fuzz_targets/bitcoin_0_32/compare_consensus_encoding.rs b/fuzz/fuzz_targets/bitcoin_0_32/compare_consensus_encoding.rs
index e84e8710..38bbcfeb 100644
--- a/fuzz/fuzz_targets/bitcoin_0_32/compare_consensus_encoding.rs
+++ b/fuzz/fuzz_targets/bitcoin_0_32/compare_consensus_encoding.rs
@@ -2,17 +2,17 @@
 #![cfg_attr(not(fuzzing), allow(unused))]
 
 use libfuzzer_sys::fuzz_target;
-use old_bitcoin::absolute;
-use old_bitcoin::consensus::encode::deserialize_partial;
-use old_bitcoin::consensus::serialize;
-use old_bitcoin::encoding::{self, decode_from_slice_unbounded};
+use bitcoin_0_32::absolute;
+use bitcoin_0_32::consensus::encode::deserialize_partial;
+use bitcoin_0_32::consensus::serialize;
+use bitcoin_0_32::encoding::{self, decode_from_slice_unbounded};
 
 #[cfg(not(fuzzing))]
 fn main() {}
 
 macro_rules! compare_encoding {
     ($data:expr, $ty:ident) => {
-        compare_encoding!($data, old_bitcoin::$ty);
+        compare_encoding!($data, bitcoin_0_32::$ty);
     };
 
     ($data:expr, $ty:ty) => {{
diff --git a/fuzz/fuzz_targets/bitcoin_0_32/deser_net_msg.rs b/fuzz/fuzz_targets/bitcoin_0_32/deser_net_msg.rs
index 530487f3..2ca7568c 100644
--- a/fuzz/fuzz_targets/bitcoin_0_32/deser_net_msg.rs
+++ b/fuzz/fuzz_targets/bitcoin_0_32/deser_net_msg.rs
@@ -7,8 +7,8 @@ use libfuzzer_sys::fuzz_target;
 fn main() {}
 
 fn do_test(data: &[u8]) {
-    let _: Result<old_bitcoin::p2p::message::RawNetworkMessage, _> =
-        old_bitcoin::consensus::encode::deserialize(data);
+    let _: Result<bitcoin_0_32::p2p::message::RawNetworkMessage, _> =
+        bitcoin_0_32::consensus::encode::deserialize(data);
 }
 
 fuzz_target!(|data: &[u8]| {
diff --git a/fuzz/fuzz_targets/bitcoin_0_32/deserialize_address.rs b/fuzz/fuzz_targets/bitcoin_0_32/deserialize_address.rs
index ca15faa0..5b643027 100644
--- a/fuzz/fuzz_targets/bitcoin_0_32/deserialize_address.rs
+++ b/fuzz/fuzz_targets/bitcoin_0_32/deserialize_address.rs
@@ -8,7 +8,7 @@ fn main() {}
 
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
-    let addr = match data_str.parse::<old_bitcoin::address::Address<_>>() {
+    let addr = match data_str.parse::<bitcoin_0_32::address::Address<_>>() {
         Ok(addr) => addr.assume_checked(),
         Err(_) => return,
     };
diff --git a/fuzz/fuzz_targets/bitcoin_0_32/deserialize_psbt.rs b/fuzz/fuzz_targets/bitcoin_0_32/deserialize_psbt.rs
index ecc69121..ef38b910 100644
--- a/fuzz/fuzz_targets/bitcoin_0_32/deserialize_psbt.rs
+++ b/fuzz/fuzz_targets/bitcoin_0_32/deserialize_psbt.rs
@@ -7,14 +7,14 @@ use libfuzzer_sys::fuzz_target;
 fn main() {}
 
 fn do_test(data: &[u8]) {
-    let psbt: Result<old_bitcoin::psbt::Psbt, _> = old_bitcoin::psbt::Psbt::deserialize(data);
+    let psbt: Result<bitcoin_0_32::psbt::Psbt, _> = bitcoin_0_32::psbt::Psbt::deserialize(data);
     match psbt {
         Err(_) => {}
         Ok(psbt) => {
-            let ser = old_bitcoin::psbt::Psbt::serialize(&psbt);
-            let deser = old_bitcoin::psbt::Psbt::deserialize(&ser).unwrap();
+            let ser = bitcoin_0_32::psbt::Psbt::serialize(&psbt);
+            let deser = bitcoin_0_32::psbt::Psbt::deserialize(&ser).unwrap();
             // Since the fuzz data could order psbt fields differently, we compare to our deser/ser instead of data
-            assert_eq!(ser, old_bitcoin::psbt::Psbt::serialize(&deser));
+            assert_eq!(ser, bitcoin_0_32::psbt::Psbt::serialize(&deser));
         }
     }
 }
diff --git a/fuzz/fuzz_targets/bitcoin_0_32/outpoint_string.rs b/fuzz/fuzz_targets/bitcoin_0_32/outpoint_string.rs
index 19ca07da..d1b7385b 100644
--- a/fuzz/fuzz_targets/bitcoin_0_32/outpoint_string.rs
+++ b/fuzz/fuzz_targets/bitcoin_0_32/outpoint_string.rs
@@ -23,19 +23,19 @@ fn do_test(data: &[u8]) {
         Err(_) => return,
         Ok(s) => s,
     };
-    match data_str.parse::<old_bitcoin::blockdata::transaction::OutPoint>() {
+    match data_str.parse::<bitcoin_0_32::blockdata::transaction::OutPoint>() {
         Ok(op) => {
             assert_eq!(op.to_string().as_bytes(), data_str.as_bytes());
         }
         Err(_) => {
             // If we can't deserialize as a string, try consensus deserializing
-            let res: Result<old_bitcoin::blockdata::transaction::OutPoint, _> =
-                old_bitcoin::consensus::encode::deserialize(data);
+            let res: Result<bitcoin_0_32::blockdata::transaction::OutPoint, _> =
+                bitcoin_0_32::consensus::encode::deserialize(data);
             if let Ok(deser) = res {
-                let ser = old_bitcoin::consensus::encode::serialize(&deser);
+                let ser = bitcoin_0_32::consensus::encode::serialize(&deser);
                 assert_eq!(ser, data);
                 let string = deser.to_string();
-                match string.parse::<old_bitcoin::blockdata::transaction::OutPoint>() {
+                match string.parse::<bitcoin_0_32::blockdata::transaction::OutPoint>() {
                     Ok(destring) => assert_eq!(destring, deser),
                     Err(_) => panic!(),
                 }
diff --git a/fuzz/fuzz_targets/hashes_0_32/cbor.rs b/fuzz/fuzz_targets/hashes_0_32/cbor.rs
index bd95b367..62677570 100644
--- a/fuzz/fuzz_targets/hashes_0_32/cbor.rs
+++ b/fuzz/fuzz_targets/hashes_0_32/cbor.rs
@@ -6,15 +6,15 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize)]
 struct Hmacs {
-    sha1: old_bitcoin::hashes::hmac::Hmac<old_bitcoin::hashes::sha1::Hash>,
-    sha512: old_bitcoin::hashes::hmac::Hmac<old_bitcoin::hashes::sha512::Hash>,
+    sha1: bitcoin_0_32::hashes::hmac::Hmac<bitcoin_0_32::hashes::sha1::Hash>,
+    sha512: bitcoin_0_32::hashes::hmac::Hmac<bitcoin_0_32::hashes::sha512::Hash>,
 }
 
 #[derive(Deserialize, Serialize)]
 struct Main {
     hmacs: Hmacs,
-    ripemd: old_bitcoin::hashes::ripemd160::Hash,
-    sha2d: old_bitcoin::hashes::sha256d::Hash,
+    ripemd: bitcoin_0_32::hashes::ripemd160::Hash,
+    sha2d: bitcoin_0_32::hashes::sha256d::Hash,
 }
 
 #[cfg(not(fuzzing))]
diff --git a/fuzz/fuzz_targets/units_0_32/deserialize_amount.rs b/fuzz/fuzz_targets/units_0_32/deserialize_amount.rs
index 04f80417..a6ef0e9f 100644
--- a/fuzz/fuzz_targets/units_0_32/deserialize_amount.rs
+++ b/fuzz/fuzz_targets/units_0_32/deserialize_amount.rs
@@ -11,22 +11,22 @@ fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
 
     // signed
-    let samt = match old_bitcoin::amount::SignedAmount::from_str(&data_str) {
+    let samt = match bitcoin_0_32::amount::SignedAmount::from_str(&data_str) {
         Ok(amt) => amt,
         Err(_) => return,
     };
-    let samt_roundtrip = match old_bitcoin::amount::SignedAmount::from_str(&samt.to_string()) {
+    let samt_roundtrip = match bitcoin_0_32::amount::SignedAmount::from_str(&samt.to_string()) {
         Ok(amt) => amt,
         Err(_) => return,
     };
     assert_eq!(samt, samt_roundtrip);
 
     // unsigned
-    let amt = match old_bitcoin::amount::Amount::from_str(&data_str) {
+    let amt = match bitcoin_0_32::amount::Amount::from_str(&data_str) {
         Ok(amt) => amt,
         Err(_) => return,
     };
-    let amt_roundtrip = match old_bitcoin::amount::Amount::from_str(&amt.to_string()) {
+    let amt_roundtrip = match bitcoin_0_32::amount::Amount::from_str(&amt.to_string()) {
         Ok(amt) => amt,
         Err(_) => return,
     };
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
index 770c6a46..d36e048a 100755
--- a/fuzz/generate-files.sh
+++ b/fuzz/generate-files.sh
@@ -26,7 +26,7 @@ cargo-fuzz = true
 # We shouldn't need an explicit version on the next line, but Andrew's tools
 # choke on it otherwise. See https://github.com/nix-community/crate2nix/issues/373
 bitcoin = { path = "../bitcoin", version = "0.33.0-beta", features = [ "serde", "arbitrary" ] }
-old_bitcoin = { version = "0.32.101", package = "bitcoin", features = [ "encoding", "serde" ] }
+bitcoin_0_32 = { version = "0.32.101", package = "bitcoin", features = [ "encoding", "serde" ] }
 bitcoin_consensus_encoding = { path = "../consensus_encoding", package = "bitcoin-consensus-encoding" }
 p2p = { path = "../p2p", package = "bitcoin-p2p-messages", features = ["arbitrary"] }