Adjust fuzz targets to use consensus_encoding

diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs
index 0a54dfe6..fe274686 100644
--- a/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_block.rs
@@ -2,14 +2,14 @@
 #![cfg_attr(not(fuzzing), allow(unused))]
 
 use bitcoin::block::{self, Block, BlockCheckedExt as _};
-use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use libfuzzer_sys::fuzz_target;
 
 #[cfg(not(fuzzing))]
 fn main() {}
 
 fn do_test(block: Block) {
-    let serialized = serialize(&block);
+    let serialized = encode_to_vec(&block);
 
     // Manually call all compute functions with unchecked block data.
     let (header, transactions) = block.clone().into_parts();
@@ -24,7 +24,7 @@ fn do_test(block: Block) {
         block.weight();
     }
 
-    let deserialized: Result<Block, _> = deserialize(serialized.as_slice());
+    let deserialized: Result<Block, _> = decode_from_slice(serialized.as_slice());
     assert_eq!(deserialized.unwrap(), block);
 }
 
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
index 5ff5a112..ae97c590 100644
--- a/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_script.rs
@@ -3,7 +3,7 @@
 
 use arbitrary::{Arbitrary, Unstructured};
 use bitcoin::address::Address;
-use bitcoin::consensus::serialize;
+use bitcoin::encoding::encode_to_vec;
 use bitcoin::script::{self, ScriptBuf, ScriptExt as _, ScriptPubKeyExt as _};
 use bitcoin::Network;
 use libfuzzer_sys::fuzz_target;
@@ -16,7 +16,7 @@ fn do_test(data: &[u8]) {
     let s = ScriptBuf::arbitrary(&mut u);
 
     if let Ok(script_buf) = s {
-        let serialized = serialize(&script_buf);
+        let serialized = encode_to_vec(script_buf.as_script());
         let _: Result<Vec<script::Instruction>, script::Error> =
             script_buf.instructions().collect();
 
@@ -45,7 +45,7 @@ fn do_test(data: &[u8]) {
             }
         }
         assert_eq!(builder.into_script(), script_buf);
-        assert_eq!(serialized, &serialize(&script_buf)[..]);
+        assert_eq!(serialized, &encode_to_vec(script_buf.as_script())[..]);
 
         // Check if valid address and if that address roundtrips.
         if let Ok(addr) = Address::from_script(&script_buf, Network::Bitcoin) {
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs
index 65d9c258..2a17d96b 100644
--- a/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_transaction.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
-use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use bitcoin::transaction::TransactionExt as _;
 use bitcoin::Transaction;
 use libfuzzer_sys::fuzz_target;
@@ -10,8 +10,8 @@ use libfuzzer_sys::fuzz_target;
 fn main() {}
 
 fn do_test(mut tx: Transaction) {
-    let serialized = serialize(&tx);
-    let deserialized: Result<Transaction, _> = deserialize(serialized.as_slice());
+    let serialized = encode_to_vec(&tx);
+    let deserialized: Result<Transaction, _> = decode_from_slice(serialized.as_slice());
     assert_eq!(deserialized.unwrap(), tx);
 
     let len = serialized.len();
@@ -19,7 +19,7 @@ fn do_test(mut tx: Transaction) {
     for input in &mut tx.inputs {
         input.witness = bitcoin::witness::Witness::default();
     }
-    let no_witness_len = bitcoin::consensus::encode::serialize(&tx).len();
+    let no_witness_len = encode_to_vec(&tx).len();
     // For 0-input transactions, `no_witness_len` will be incorrect because
     // we serialize as SegWit even after "stripping the witnesses". We need
     // to drop two bytes (i.e. eight weight). Similarly, calculated_weight is
diff --git a/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs b/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs
index 3b337774..023f059b 100644
--- a/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs
+++ b/fuzz/fuzz_targets/bitcoin/arbitrary_witness.rs
@@ -2,7 +2,7 @@
 #![cfg_attr(not(fuzzing), allow(unused))]
 
 use bitcoin::blockdata::witness::WitnessExt;
-use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use bitcoin::Witness;
 use libfuzzer_sys::fuzz_target;
 
@@ -13,12 +13,12 @@ fn do_test(data: (Witness, Vec<u8>)) {
     let mut witness = data.0;
     let element_bytes = data.1;
 
-    let serialized = serialize(&witness);
+    let serialized = encode_to_vec(&witness);
 
     let _ = witness.witness_script();
     let _ = witness.taproot_leaf_script();
 
-    let deserialized: Result<Witness, _> = deserialize(serialized.as_slice());
+    let deserialized: Result<Witness, _> = decode_from_slice(serialized.as_slice());
     assert_eq!(deserialized.unwrap(), witness);
 
     witness.push(element_bytes.as_slice());
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_block.rs b/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
index b5136958..f9f995b3 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_block.rs
@@ -1,18 +1,19 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use libfuzzer_sys::fuzz_target;
 
 #[cfg(not(fuzzing))]
 fn main() {}
 
 fn do_test(data: &[u8]) {
-    let block_result: Result<bitcoin::Block, _> = bitcoin::consensus::encode::deserialize(data);
+    let block_result: Result<bitcoin::Block, _> = decode_from_slice(data);
 
     match block_result {
         Err(_) => {}
         Ok(block) => {
-            let ser = bitcoin::consensus::encode::serialize(&block);
+            let ser = encode_to_vec(&block);
             assert_eq!(&ser[..], data);
         }
     }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 6d9bb129..a31b4cd8 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -8,12 +8,12 @@ fn main() {}
 
 fn do_test(data: &[u8]) {
     let script_result: Result<bitcoin::ScriptPubKeyBuf, _> =
-        bitcoin::consensus::encode::deserialize(data);
+        bitcoin::encoding::decode_from_slice(data);
 
     match script_result {
         Err(_) => {}
         Ok(script) => {
-            let ser = bitcoin::consensus::encode::serialize(&script);
+            let ser = bitcoin::encoding::encode_to_vec(script.as_script());
             assert_eq!(&ser[..], data);
         }
     }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
index 4595ed11..90292171 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
@@ -1,18 +1,19 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use libfuzzer_sys::fuzz_target;
 
 #[cfg(not(fuzzing))]
 fn main() {}
 
 fn do_test(data: &[u8]) {
-    let tx_result: Result<bitcoin::Transaction, _> = bitcoin::consensus::encode::deserialize(data);
+    let tx_result: Result<bitcoin::Transaction, _> = decode_from_slice(data);
 
     match tx_result {
         Err(_) => {}
         Ok(tx) => {
-            let ser = bitcoin::consensus::encode::serialize(&tx);
+            let ser = encode_to_vec(&tx);
             assert_eq!(&ser[..], data);
         }
     }
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs b/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
index bbccd027..3fe9c10c 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_witness.rs
@@ -1,6 +1,7 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
+use bitcoin::encoding::{decode_from_slice, encode_to_vec};
 use bitcoin::witness::Witness;
 use libfuzzer_sys::fuzz_target;
 
@@ -8,12 +9,12 @@ use libfuzzer_sys::fuzz_target;
 fn main() {}
 
 fn do_test(data: &[u8]) {
-    let witness_result: Result<Witness, _> = bitcoin::consensus::encode::deserialize(data);
+    let witness_result: Result<Witness, _> = decode_from_slice(data);
 
     match witness_result {
         Err(_) => {}
         Ok(witness) => {
-            let ser = bitcoin::consensus::encode::serialize(&witness);
+            let ser = encode_to_vec(&witness);
             assert_eq!(&ser[..], data);
         }
     }
diff --git a/fuzz/fuzz_targets/bitcoin/parse_outpoint.rs b/fuzz/fuzz_targets/bitcoin/parse_outpoint.rs
index da7cd87d..3bfa7703 100644
--- a/fuzz/fuzz_targets/bitcoin/parse_outpoint.rs
+++ b/fuzz/fuzz_targets/bitcoin/parse_outpoint.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(fuzzing, no_main)]
 #![cfg_attr(not(fuzzing), allow(unused))]
 
-use bitcoin::consensus::encode;
+use bitcoin::encoding;
 use bitcoin::transaction::OutPoint;
 use libfuzzer_sys::fuzz_target;
 
@@ -31,9 +31,9 @@ fn do_test(data: &[u8]) {
         }
         Err(_) => {
             // If we can't deserialize as a string, try consensus deserializing
-            let res: Result<OutPoint, _> = encode::deserialize(data);
+            let res: Result<OutPoint, _> = encoding::decode_from_slice(data);
             if let Ok(deser) = res {
-                let ser = encode::serialize(&deser);
+                let ser = encoding::encode_to_vec(&deser);
                 assert_eq!(ser, data);
                 let string = deser.to_string();
                 match string.parse::<OutPoint>() {