diff --git a/Cargo.lock b/Cargo.lock
index b6575dd..009c39b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -108,13 +108,23 @@ checksum = "0ea22880d78093b0cbe17c89f64a7d457941e65759157ec6cb31a31d652b05e5"
 
 [[package]]
 name = "bincode"
-version = "1.3.3"
+version = "2.0.0-rc.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+checksum = "f11ea1a0346b94ef188834a65c068a03aec181c94896d481d7a0a40d85b0ce95"
 dependencies = [
+ "bincode_derive",
  "serde",
 ]
 
+[[package]]
+name = "bincode_derive"
+version = "2.0.0-rc.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e30759b3b99a1b802a7a3aa21c85c3ded5c28e1c83170d82d70f08bbf7f3e4c"
+dependencies = [
+ "virtue",
+]
+
 [[package]]
 name = "bindgen"
 version = "0.65.1"
@@ -1068,6 +1078,12 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
+[[package]]
+name = "virtue"
+version = "0.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dcc60c0624df774c82a0ef104151231d37da4962957d691c011c852b2473314"
+
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
diff --git a/Cargo.toml b/Cargo.toml
index 5c6fd2e..ee03c21 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,7 +16,7 @@ exclude = ["**/tests/**", "**/examples/**", "**/benchmarks/**", "docs/**", ".hoo
 [dependencies]
 actix-rt = "2.8.0"
 base64 = "0.20.0"
-bincode = "1.3.3"
+bincode = { version = "2.0.0-rc.3", features = ["serde"] }
 bytes = "1.4.0"
 colored = { version = "2.1.0", optional = true }
 hex = "0.4.3"
diff --git a/src/primitives/block.rs b/src/primitives/block.rs
index 72e07e9..18cb611 100644
--- a/src/primitives/block.rs
+++ b/src/primitives/block.rs
@@ -4,7 +4,6 @@ use crate::crypto::sha3_256::{self, Sha3_256};
 use crate::crypto::sign_ed25519::PublicKey;
 use crate::primitives::asset::Asset;
 use crate::primitives::transaction::{Transaction, TxIn, TxOut};
-use bincode::{deserialize, serialize};
 use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
@@ -82,25 +81,25 @@ impl Block {
 
     /// Sets the internal number of bits based on length
     pub fn set_bits(&mut self) {
-        let bytes = Bytes::from(match serialize(&self) {
+        let bytes = match bincode::serde::encode_to_vec(&self, bincode::config::legacy()) {
             Ok(bytes) => bytes,
             Err(e) => {
                 warn!("Failed to serialize block: {:?}", e);
                 return;
             }
-        });
+        };
         self.header.bits = bytes.len();
     }
 
     /// Checks whether a block has hit its maximum size
     pub fn is_full(&self) -> bool {
-        let bytes = Bytes::from(match serialize(&self) {
+        let bytes = match bincode::serde::encode_to_vec(&self, bincode::config::legacy()) {
             Ok(bytes) => bytes,
             Err(e) => {
                 warn!("Failed to serialize block: {:?}", e);
                 return false;
             }
-        });
+        };
         bytes.len() >= MAX_BLOCK_SIZE
     }
 
@@ -143,7 +142,8 @@ pub fn gen_random_hash() -> String {
 ///
 /// * `transactions`    - Transactions to construct a merkle tree for
 pub fn build_hex_txs_hash(transactions: &[String]) -> String {
-    let txs = match serialize(transactions) {
+    // TODO: This is bad, it won't produce the same result on 32-bit systems
+    let txs = match bincode::serde::encode_to_vec(transactions, bincode::config::legacy()) {
         Ok(bytes) => bytes,
         Err(e) => {
             warn!("Failed to serialize transactions: {:?}", e);
diff --git a/src/primitives/transaction.rs b/src/primitives/transaction.rs
index 08435fd..e1d7236 100644
--- a/src/primitives/transaction.rs
+++ b/src/primitives/transaction.rs
@@ -8,8 +8,6 @@ use crate::primitives::{
 use crate::script::lang::Script;
 use crate::script::{OpCodes, StackEntry};
 use crate::utils::is_valid_amount;
-use bincode::serialize;
-use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
@@ -205,15 +203,6 @@ impl Transaction {
         }
     }
 
-    /// Get the total transaction size in bytes
-    pub fn get_total_size(&self) -> usize {
-        let bytes = match serialize(self) {
-            Ok(bytes) => bytes,
-            Err(_) => vec![],
-        };
-        bytes.len()
-    }
-
     /// Gets the create asset assigned to this transaction, if it exists
     fn get_create_asset(&self) -> Option<&Asset> {
         let is_create = self.inputs.len() == 1
diff --git a/src/script/interface_ops.rs b/src/script/interface_ops.rs
index 7b9875b..ba2a63c 100644
--- a/src/script/interface_ops.rs
+++ b/src/script/interface_ops.rs
@@ -11,8 +11,6 @@ use crate::utils::error_utils::*;
 use crate::utils::transaction_utils::{
     construct_address, construct_address_temp, construct_address_v0,
 };
-use bincode::de;
-use bincode::serialize;
 use bytes::Bytes;
 use hex::encode;
 use std::collections::BTreeMap;
diff --git a/src/script/lang.rs b/src/script/lang.rs
index 259465e..2498e5c 100644
--- a/src/script/lang.rs
+++ b/src/script/lang.rs
@@ -8,8 +8,6 @@ use crate::script::interface_ops::*;
 use crate::script::{OpCodes, StackEntry};
 use crate::utils::error_utils::*;
 use crate::utils::transaction_utils::{construct_address, construct_address_for};
-use bincode::serialize;
-use bytes::Bytes;
 use hex::encode;
 use serde::{Deserialize, Serialize};
 use tracing::{error, warn};
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index adb6987..d7b7f3e 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -8,6 +8,7 @@ use crate::primitives::asset::TokenAmount;
 pub mod druid_utils;
 pub mod error_utils;
 pub mod script_utils;
+pub mod serialize_utils;
 pub mod test_utils;
 pub mod transaction_utils;
 
diff --git a/src/utils/script_utils.rs b/src/utils/script_utils.rs
index a2cd085..fca79da 100644
--- a/src/utils/script_utils.rs
+++ b/src/utils/script_utils.rs
@@ -15,8 +15,6 @@ use crate::utils::transaction_utils::{
     construct_address, construct_tx_hash, construct_tx_in_out_signable_hash,
     construct_tx_in_signable_asset_hash, construct_tx_in_signable_hash,
 };
-use bincode::serialize;
-use bytes::Bytes;
 use hex::encode;
 use ring::error;
 use std::collections::{BTreeMap, BTreeSet};
diff --git a/src/utils/serialize_utils.rs b/src/utils/serialize_utils.rs
new file mode 100644
index 0000000..9053c02
--- /dev/null
+++ b/src/utils/serialize_utils.rs
@@ -0,0 +1,605 @@
+use std::any::TypeId;
+use std::convert::{TryFrom, TryInto};
+use std::fmt;
+use std::io::Write;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+use std::str::FromStr;
+use bincode::{BorrowDecode, Decode, Encode};
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::{SeqAccess, Visitor};
+use serde::ser::{SerializeTuple};
+
+/// Implements `Write` by simply counting the number of bytes written to it.
+#[derive(Copy, Clone, Debug)]
+pub struct ByteCountingWriter {
+    pub count: usize,
+}
+
+impl ByteCountingWriter {
+    /// Creates a new `ByteCountingWriter` with a `count` of 0.
+    pub fn new() -> Self {
+        Self {
+            count: 0,
+        }
+    }
+}
+
+impl Write for ByteCountingWriter {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.count += buf.len();
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Simple wrapper around a fixed-length byte array.
+///
+/// This can be formatted to and parsed from a hexadecimal string using `Display` and `FromStr`.
+/// When serialized as JSON, it is also represented as a hexadecimal string.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Encode, Decode)]
+pub struct FixedByteArray<const N: usize>(
+    #[serde(with = "fixed_array_codec")]
+    [u8; N],
+);
+
+impl<const N: usize> FixedByteArray<N> {
+    pub fn new(arr: [u8; N]) -> Self {
+        Self(arr)
+    }
+}
+
+impl<const N: usize> AsRef<[u8]> for FixedByteArray<N> {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl<const N: usize> AsMut<[u8]> for FixedByteArray<N> {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
+impl<const N: usize> Deref for FixedByteArray<N> {
+    type Target = [u8; N];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const N: usize> DerefMut for FixedByteArray<N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<const N: usize> From<[u8; N]> for FixedByteArray<N> {
+    fn from(value: [u8; N]) -> Self {
+        Self(value)
+    }
+}
+
+impl<const N: usize> From<&[u8; N]> for FixedByteArray<N> {
+    fn from(value: &[u8; N]) -> Self {
+        Self(*value)
+    }
+}
+
+impl<const N: usize> TryFrom<&[u8]> for FixedByteArray<N> {
+    type Error = std::array::TryFromSliceError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        value.try_into().map(Self)
+    }
+}
+
+impl<const N: usize> TryFrom<&Vec<u8>> for FixedByteArray<N> {
+    type Error = std::array::TryFromSliceError;
+
+    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
+        value.as_slice().try_into().map(Self)
+    }
+}
+
+impl<const N: usize> fmt::LowerHex for FixedByteArray<N> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // This is hacky because we can't make an array of type [u8; {N * 2}] due to
+        // generic parameters not being allowed in constant expressions on stable rust
+        assert_eq!(std::mem::size_of::<[u16; N]>(), std::mem::size_of::<[u8; N]>() * 2);
+        let mut buf = [0u16; N];
+        let slice = unsafe { std::slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, N * 2) };
+        hex::encode_to_slice(&self.0, slice).unwrap();
+        f.write_str(std::str::from_utf8(slice).unwrap())
+    }
+}
+
+impl<const N: usize> fmt::Display for FixedByteArray<N> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl<const N: usize> fmt::Debug for FixedByteArray<N> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "FixedByteArray<{N}>({self:x})")
+    }
+}
+
+impl<const N: usize> FromStr for FixedByteArray<N> {
+    type Err = hex::FromHexError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut buf = [0u8; N];
+        hex::decode_to_slice(s, &mut buf)?;
+        Ok(Self(buf))
+    }
+}
+
+/// A serde codec for fixed-size arrays.
+pub mod fixed_array_codec {
+    use super::*;
+
+    pub fn serialize<T: Serialize + 'static, S: Serializer, const N: usize>(
+        values: &[T; N],
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() && serializer.is_human_readable() {
+            // We're serializing a byte array for a human-readable format, make it a hex string
+            vec_codec::serialize(values, serializer)
+        } else {
+            // Serialize the array as a tuple, to avoid adding a length prefix
+            let mut tuple = serializer.serialize_tuple(N)?;
+            for e in values {
+                tuple.serialize_element(e)?;
+            }
+            tuple.end()
+        }
+    }
+
+    pub fn deserialize<'de, T: Deserialize<'de> + 'static, D: Deserializer<'de>, const N: usize>(
+        deserializer: D,
+    ) -> Result<[T; N], D::Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() && deserializer.is_human_readable() {
+            // We're deserializing a byte array for a human-readable format, we'll accept two different
+            // representations:
+            // - A hexadecimal string
+            // - An array of byte literals (this format should never be produced by the serializer
+            //   for human-readable formats, but it was in the past, so we'll still support reading
+            //   it for backwards-compatibility).
+            vec_to_fixed_array(vec_codec::deserialize(deserializer)?)
+        } else {
+            // We're deserializing a binary format, read the array as a tuple
+            // (to avoid adding a length prefix)
+
+            struct FixedArrayVisitor<T, const N: usize>(PhantomData<T>);
+            impl<'de, T: Deserialize<'de>, const N: usize> Visitor<'de> for FixedArrayVisitor<T, N> {
+                type Value = [T; N];
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    write!(formatter, "a sequence")
+                }
+
+                fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
+                    let mut vec = Vec::with_capacity(N);
+                    while let Some(val) = seq.next_element::<T>()? {
+                        vec.push(val)
+                    }
+                    vec_to_fixed_array(vec)
+                }
+            }
+
+            deserializer.deserialize_tuple(N, FixedArrayVisitor(Default::default()))
+        }
+    }
+}
+
+/// A serde codec for variable-length `Vec`s.
+pub mod vec_codec {
+    use super::*;
+
+    pub fn serialize<T: Serialize + 'static, S: Serializer>(
+        values: &[T],
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() && serializer.is_human_readable() {
+            // We're serializing a byte array for a human-readable format, make it a hex string
+            let bytes = unsafe { std::slice::from_raw_parts(values.as_ptr() as *const u8, values.len()) };
+            serializer.serialize_str(&hex::encode(bytes))
+        } else {
+            // Serialize the array as a length-prefixed sequence
+            values.serialize(serializer)
+        }
+    }
+
+    pub fn deserialize<'de, T: Deserialize<'de> + 'static, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Vec<T>, D::Error> {
+        if TypeId::of::<T>() == TypeId::of::<u8>() && deserializer.is_human_readable() {
+            // We're deserializing a byte array for a human-readable format, we'll accept two different
+            // representations:
+            // - A hexadecimal string
+            // - An array of byte literals (this format should never be produced by the serializer
+            //   for human-readable formats, but it was in the past, so we'll still support reading
+            //   it for backwards-compatibility).
+
+            struct HexStringOrBytesVisitor();
+            impl<'de> Visitor<'de> for HexStringOrBytesVisitor {
+                type Value = Vec<u8>;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("hex string or byte array")
+                }
+
+                fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<Self::Value, E> {
+                    hex::decode(value).map_err(E::custom)
+                }
+
+                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
+                    let mut vec = Vec::new();
+                    while let Some(elt) = seq.next_element::<u8>()? {
+                        vec.push(elt);
+                    }
+                    Ok(vec)
+                }
+            }
+
+            Ok(deserializer.deserialize_any(HexStringOrBytesVisitor())?.into_iter()
+                // This is a hack to convert the Vec<u8> into a Vec<T>, even though we already know
+                // that T = u8. This could be done in a much nicer way if trait specialization were
+                // a thing, but unfortunately it's still only available on nightly :(
+                .map(|b| unsafe { std::mem::transmute_copy::<u8, T>(&b) })
+                .collect::<Vec<T>>())
+        } else {
+            // Read a length-prefixed sequence as a Vec<T>
+            <Vec<T>>::deserialize(deserializer)
+        }
+    }
+}
+
+fn vec_to_fixed_array<E: serde::de::Error, T, const N: usize>(
+    vec: Vec<T>,
+) -> Result<[T; N], E> {
+    <[T; N]>::try_from(vec)
+        .map_err(|vec| E::custom(format!("expected exactly {} elements, but read {}", N, vec.len())))
+}
+
+/// Encodes an object into a `Vec<u8>` using bincode 2's standard configuration.
+///
+/// This allows using the turbofish operator to explicitly specify the encode type without also
+/// having to specify the config type.
+///
+/// ### Arguments
+///
+/// * `value` - the value to encode
+#[inline(always)]
+pub fn bincode_encode_to_vec_standard<T: Encode>(
+    value: &T,
+) -> Result<Vec<u8>, bincode::error::EncodeError> {
+    bincode::encode_to_vec(value, bincode::config::standard())
+}
+
+/// Encodes an object into the given `Write` using bincode 2's standard configuration.
+///
+/// This allows using the turbofish operator to explicitly specify the encode type without also
+/// having to specify the config type.
+///
+/// ### Arguments
+///
+/// * `value` - the value to encode
+/// * `write` - the `Write` to encode into
+#[inline(always)]
+pub fn bincode_encode_to_write_standard<T: Encode>(
+    value: &T,
+    write: &mut impl Write,
+) -> Result<usize, bincode::error::EncodeError> {
+    bincode::encode_into_std_write(value, write, bincode::config::standard())
+}
+
+/// Calculates the encoded size of the given object using bincode 2's standard configuration.
+///
+/// ### Arguments
+///
+/// * `value` - the value to encode
+#[inline(always)]
+pub fn bincode_encoded_size_standard<T: Encode>(
+    value: &T,
+) -> Result<usize, bincode::error::EncodeError> {
+    let mut writer = ByteCountingWriter::new();
+    bincode::encode_into_std_write(value, &mut writer, bincode::config::standard())?;
+    Ok(writer.count)
+}
+
+/// Decodes an object from a slice using bincode 2's standard configuration.
+///
+/// This allows using the turbofish operator to explicitly specify the decode type without also
+/// having to specify the config type.
+///
+/// ### Arguments
+///
+/// * `slice` - the slice to decode from
+#[inline(always)]
+pub fn bincode_decode_from_slice_standard<T: Decode>(
+    slice: &[u8],
+) -> Result<(T, usize), bincode::error::DecodeError> {
+    bincode::decode_from_slice(slice, bincode::config::standard())
+}
+
+/// Decodes an object from a slice using bincode 2's standard configuration.
+///
+/// This allows using the turbofish operator to explicitly specify the decode type without also
+/// having to specify the config type.
+///
+/// ### Arguments
+///
+/// * `slice` - the slice to decode from
+pub fn bincode_decode_from_slice_standard_full<T: Decode>(
+    slice: &[u8],
+) -> Result<T, bincode::error::DecodeError> {
+    let (result, read_bytes) = bincode_decode_from_slice_standard::<T>(slice)?;
+    if read_bytes == slice.len() {
+        Ok(result)
+    } else {
+        Err(bincode::error::DecodeError::OtherString(
+            format!("{} bytes left over after decoding", slice.len() - read_bytes)))
+    }
+}
+
+/// Decodes an object from a slice using bincode 2's standard configuration.
+///
+/// This allows using the turbofish operator to explicitly specify the decode type without also
+/// having to specify the config type.
+///
+/// ### Arguments
+///
+/// * `slice` - the slice to decode from
+#[inline(always)]
+pub fn bincode_borrow_decode_from_slice_standard<'a, T: BorrowDecode<'a>>(
+    slice: &'a [u8],
+) -> Result<(T, usize), bincode::error::DecodeError> {
+    bincode::borrow_decode_from_slice(slice, bincode::config::standard())
+}
+
+/*---- TESTS ----*/
+
+#[cfg(test)]
+mod tests {
+    use std::fmt::{Debug, Display};
+
+    use serde::{Deserialize, Serialize};
+    use serde::de::DeserializeOwned;
+    use super::*;
+
+    fn repeat(orig: &str, n: usize) -> String {
+        let mut res = String::with_capacity(orig.len() * n);
+        for _ in 0..n {
+            res.push_str(orig)
+        }
+        res
+    }
+
+    fn test_bin_codec<C: bincode::config::Config, T: Clone + Debug + Eq + Serialize + DeserializeOwned>(
+        config: fn() -> C,
+        obj: T,
+        expect: &str,
+    ) {
+        let bytes = bincode::serde::encode_to_vec(&obj, config()).unwrap();
+        assert_eq!(hex::encode(&bytes), expect);
+        assert_eq!(bincode::serde::decode_from_slice::<T, C>(&bytes, config()).unwrap().0, obj);
+    }
+
+    fn test_json_codec<T: Clone + Debug + Eq + Serialize + DeserializeOwned>(
+        obj: T,
+        expect: &str,
+    ) {
+        let json = serde_json::to_string(&obj).unwrap();
+        assert_eq!(json, expect);
+        assert_eq!(serde_json::from_str::<T>(&json).unwrap(), obj);
+    }
+
+    fn test_json_deserialize<T: Clone + Debug + Eq + DeserializeOwned>(
+        obj: T,
+        json: &str,
+    ) {
+        assert_eq!(serde_json::from_str::<T>(&json).unwrap(), obj);
+    }
+
+    fn test_display_fromstr<T: Clone + Debug + Eq + Display + FromStr>(
+        obj: T,
+        expect: &str,
+    ) {
+        let string = obj.to_string();
+        assert_eq!(string, expect);
+        assert_eq!(<T as FromStr>::from_str(&string).ok().unwrap(), obj);
+    }
+
+    macro_rules! test_fixed_array {
+        ($n:literal) => {
+            test_bin_codec(bincode::config::legacy, [VAL; $n], &repeat(HEX, $n));
+            test_json_codec([VAL; $n], &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+        };
+    }
+
+    macro_rules! test_fixed_array_wrapper {
+        ($e:ty, $t:ident, $n:literal) => {
+            #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+            struct $t([$e; $n]);
+            test_bin_codec(bincode::config::legacy, $t([VAL; $n]), &repeat(HEX, $n));
+            test_json_codec($t([VAL; $n]), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+        };
+    }
+
+    #[test]
+    fn test_fixed_u32_arrays() {
+        const VAL : u32 = 0xDEADBEEF;
+        const HEX : &str = "efbeadde";
+
+        test_fixed_array!(0);
+        test_fixed_array!(1);
+        test_fixed_array!(32);
+
+        test_fixed_array_wrapper!(u32, FixedArrayWrapper0, 0);
+        test_fixed_array_wrapper!(u32, FixedArrayWrapper1, 1);
+        test_fixed_array_wrapper!(u32, FixedArrayWrapper32, 32);
+
+        macro_rules! test_fixed_array_wrapper_codec {
+            ($t:ident, $n:literal) => {
+                #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+                struct $t(#[serde(with = "fixed_array_codec")] [u32; $n]);
+                test_bin_codec(bincode::config::legacy, $t([VAL; $n]), &repeat(HEX, $n));
+                test_json_codec($t([VAL; $n]), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+            };
+        }
+
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper0, 0);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper1, 1);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper32, 32);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper33, 33);
+    }
+
+    #[test]
+    fn test_fixed_u8_arrays() {
+        const VAL : u8 = 123;
+        const HEX : &str = "7b";
+
+        test_fixed_array!(0);
+        test_fixed_array!(1);
+        test_fixed_array!(32);
+
+        test_fixed_array_wrapper!(u8, FixedArrayWrapper0, 0);
+        test_fixed_array_wrapper!(u8, FixedArrayWrapper1, 1);
+        test_fixed_array_wrapper!(u8, FixedArrayWrapper32, 32);
+
+        macro_rules! test_fixed_array_wrapper_codec {
+            ($t:ident, $n:literal) => {
+                #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+                struct $t(#[serde(with = "fixed_array_codec")] [u8; $n]);
+                test_bin_codec(bincode::config::legacy, $t([VAL; $n]), &repeat(HEX, $n));
+                test_json_codec($t([VAL; $n]), &format!("\"{}\"", hex::encode(&[VAL; $n].to_vec())));
+                test_json_deserialize($t([VAL; $n]), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+            };
+        }
+
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper0, 0);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper1, 1);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper32, 32);
+        test_fixed_array_wrapper_codec!(CodecFixedArrayWrapper33, 33);
+    }
+
+    fn size_to_hex_default(n: usize) -> String {
+        hex::encode(&(n as u64).to_le_bytes())
+    }
+
+    macro_rules! test_vec {
+        ($n:literal) => {
+            test_bin_codec(bincode::config::legacy, [VAL; $n].to_vec(), &format!("{}{}", size_to_hex_default($n), repeat(HEX, $n)));
+            test_json_codec([VAL; $n].to_vec(), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+        };
+    }
+
+    macro_rules! test_vec_wrapper {
+        ($n:literal) => {
+            test_bin_codec(bincode::config::legacy, VecWrapper([VAL; $n].to_vec()), &format!("{}{}", size_to_hex_default($n), repeat(HEX, $n)));
+            test_json_codec(VecWrapper([VAL; $n].to_vec()), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+        };
+    }
+
+    #[test]
+    fn test_u32_vecs() {
+        const VAL : u32 = 0xDEADBEEF;
+        const HEX : &str = "efbeadde";
+
+        test_vec!(0);
+        test_vec!(1);
+        test_vec!(32);
+        test_vec!(33);
+
+        #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+        struct VecWrapper(Vec<u32>);
+
+        test_vec_wrapper!(0);
+        test_vec_wrapper!(1);
+        test_vec_wrapper!(32);
+        test_vec_wrapper!(33);
+
+        #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+        struct CodecVecWrapper(#[serde(with = "vec_codec")] Vec<u32>);
+        macro_rules! test_vec_wrapper_codec {
+            ($n:literal) => {
+                test_bin_codec(bincode::config::legacy, CodecVecWrapper([VAL; $n].to_vec()), &format!("{}{}", size_to_hex_default($n), repeat(HEX, $n)));
+                test_json_codec(CodecVecWrapper([VAL; $n].to_vec()), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+            };
+        }
+
+        test_vec_wrapper_codec!(0);
+        test_vec_wrapper_codec!(1);
+        test_vec_wrapper_codec!(32);
+        test_vec_wrapper_codec!(33);
+    }
+
+    #[test]
+    fn test_u8_vecs() {
+        const VAL : u8 = 123;
+        const HEX : &str = "7b";
+
+        test_vec!(0);
+        test_vec!(1);
+        test_vec!(32);
+        test_vec!(33);
+
+        #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+        struct VecWrapper(Vec<u8>);
+
+        test_vec_wrapper!(0);
+        test_vec_wrapper!(1);
+        test_vec_wrapper!(32);
+        test_vec_wrapper!(33);
+
+        #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+        struct CodecVecWrapper(#[serde(with = "vec_codec")] Vec<u8>);
+        macro_rules! test_vec_wrapper_codec {
+            ($n:literal) => {
+                test_bin_codec(bincode::config::legacy, CodecVecWrapper([VAL; $n].to_vec()), &format!("{}{}", size_to_hex_default($n), repeat(HEX, $n)));
+                test_json_codec(CodecVecWrapper([VAL; $n].to_vec()), &format!("\"{}\"", hex::encode(&[VAL; $n].to_vec())));
+                test_json_deserialize(CodecVecWrapper([VAL; $n].to_vec()), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+            };
+        }
+
+        test_vec_wrapper_codec!(0);
+        test_vec_wrapper_codec!(1);
+        test_vec_wrapper_codec!(32);
+        test_vec_wrapper_codec!(33);
+    }
+
+    #[test]
+    fn test_fixed_byte_array() {
+        const VAL : u8 = 123;
+        const HEX : &str = "7b";
+
+        macro_rules! test_fixed_byte_array {
+            ($n:literal) => {
+                test_bin_codec(bincode::config::legacy, FixedByteArray::<$n>([VAL; $n]), &repeat(HEX, $n));
+                test_json_codec(FixedByteArray::<$n>([VAL; $n]), &format!("\"{}\"", repeat(HEX, $n)));
+                test_json_deserialize(FixedByteArray::<$n>([VAL; $n]), &serde_json::to_string(&[VAL; $n].to_vec()).unwrap());
+                test_display_fromstr(FixedByteArray::<$n>([VAL; $n]), &repeat(HEX, $n));
+                assert_eq!(format!("{:x}", FixedByteArray::<$n>([VAL; $n])), repeat(HEX, $n));
+                assert_eq!(
+                    format!("{:?}", FixedByteArray::<$n>([VAL; $n])),
+                    format!("FixedByteArray<{}>({})", $n, repeat(HEX, $n)));
+                assert_eq!(
+                    format!("{:x?}", FixedByteArray::<$n>([VAL; $n])),
+                    format!("FixedByteArray<{}>({})", $n, repeat(HEX, $n)));
+            };
+        }
+
+        test_fixed_byte_array!(0);
+        test_fixed_byte_array!(1);
+        test_fixed_byte_array!(32);
+        test_fixed_byte_array!(33);
+    }
+}
diff --git a/src/utils/transaction_utils.rs b/src/utils/transaction_utils.rs
index 8e9fd99..fbc89e3 100644
--- a/src/utils/transaction_utils.rs
+++ b/src/utils/transaction_utils.rs
@@ -6,7 +6,6 @@ use crate::primitives::druid::{DdeValues, DruidExpectation};
 use crate::primitives::transaction::*;
 use crate::script::lang::Script;
 use crate::script::{OpCodes, StackEntry};
-use bincode::serialize;
 use std::collections::BTreeMap;
 use tracing::debug;
 
@@ -21,10 +20,7 @@ pub struct ReceiverInfo {
 ///
 /// * `script` - Script to build address for
 pub fn construct_p2sh_address(script: &Script) -> String {
-    let bytes = match serialize(script) {
-        Ok(bytes) => bytes,
-        Err(_) => vec![],
-    };
+    let bytes = bincode::serde::encode_to_vec(script, bincode::config::legacy()).unwrap();
     let mut addr = hex::encode(sha3_256::digest(&bytes));
     addr.insert(ZERO, P2SH_PREPEND as char);
     addr.truncate(STANDARD_ADDRESS_LENGTH);
@@ -344,7 +340,7 @@ pub fn update_utxo_set(current_utxo: &mut BTreeMap<OutPoint, Transaction>) {
 ///
 /// * `tx`  - Transaction to hash
 pub fn construct_tx_hash(tx: &Transaction) -> String {
-    let bytes = match serialize(tx) {
+    let bytes = match bincode::serde::encode_to_vec(tx, bincode::config::legacy()) {
         Ok(bytes) => bytes,
         Err(_) => vec![],
     };
@@ -1179,7 +1175,7 @@ mod tests {
             ..Default::default()
         }];
 
-        let bytes = match serialize(&tx_ins) {
+        let bytes = match bincode::serde::encode_to_vec(&tx_ins, bincode::config::legacy()) {
             Ok(bytes) => bytes,
             Err(_) => vec![],
         };