diff --git a/chronik/bitcoinsuite-core/src/script/script.rs b/chronik/bitcoinsuite-core/src/script/script.rs
index 7a811de24..b2cdf01d2 100644
--- a/chronik/bitcoinsuite-core/src/script/script.rs
+++ b/chronik/bitcoinsuite-core/src/script/script.rs
@@ -1,249 +1,258 @@
 // Copyright (c) 2023 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 use bytes::Bytes;
 
 use crate::{
+    error::DataError,
     hash::{Hashed, ShaRmd160},
     script::{opcode::*, PubKey, ScriptMut, ScriptOpIter, UncompressedPubKey},
     ser::{BitcoinSer, BitcoinSerializer},
 };
 
 /// A Bitcoin script.
 ///
 /// This is immutable, and uses [`Bytes`] to store the bytecode, making it cheap
 /// to copy.
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Script(Bytes);
 
 impl Script {
     /// Create a new script from the given bytecode.
     pub fn new(bytecode: Bytes) -> Self {
         Script(bytecode)
     }
 
     /// Pay-to-public-key-hash:
     /// `OP_DUP OP_HASH160 <hash> OP_EQUALVERIFY OP_CHECKSIG`
     /// ```
     /// # use bitcoinsuite_core::{script::Script, hash::ShaRmd160};
     /// # use hex_literal::hex;
     /// let hash = ShaRmd160(hex!("00112233445566778899aabbccddeeff00112233"));
     /// let script = Script::p2pkh(&hash);
     /// assert_eq!(
     ///     script.hex(),
     ///     "76a91400112233445566778899aabbccddeeff0011223388ac",
     /// );
     /// ```
     pub fn p2pkh(hash: &ShaRmd160) -> Script {
         let mut script = ScriptMut::with_capacity(2 + 1 + ShaRmd160::SIZE + 2);
         script.put_opcodes([OP_DUP, OP_HASH160]);
         script.put_bytecode(&[ShaRmd160::SIZE as u8]);
         script.put_bytecode(hash.as_le_bytes());
         script.put_opcodes([OP_EQUALVERIFY, OP_CHECKSIG]);
         script.freeze()
     }
 
     /// Pay-to-script-hash: `OP_HASH160 <script hash> OP_EQUAL`
     /// ```
     /// # use bitcoinsuite_core::{script::Script, hash::ShaRmd160};
     /// # use hex_literal::hex;
     /// let hash = ShaRmd160(hex!("00112233445566778899aabbccddeeff00112233"));
     /// let script = Script::p2sh(&hash);
     /// assert_eq!(
     ///     script.hex(),
     ///     "a91400112233445566778899aabbccddeeff0011223387",
     /// );
     /// ```
     pub fn p2sh(hash: &ShaRmd160) -> Script {
         let mut script = ScriptMut::with_capacity(1 + 1 + ShaRmd160::SIZE + 1);
         script.put_opcodes([OP_HASH160]);
         script.put_bytecode(&[ShaRmd160::SIZE as u8]);
         script.put_bytecode(hash.as_le_bytes());
         script.put_opcodes([OP_EQUAL]);
         script.freeze()
     }
 
     /// Pay-to-public-key (compressed): `<pubkey> OP_CHECKSIG`
     /// ```
     /// # use bitcoinsuite_core::{script::{PubKey, Script}, hash::ShaRmd160};
     /// # use hex_literal::hex;
     /// let pubkey = PubKey(hex!(
     ///     "0200112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
     /// ));
     /// let script = Script::p2pk(&pubkey);
     /// assert_eq!(
     ///     script.hex(),
     ///     "210200112233445566778899aabbccddeeff00112233445566778899aabbccddee\
     ///      ffac",
     /// );
     /// ```
     pub fn p2pk(pubkey: &PubKey) -> Script {
         let mut script = ScriptMut::with_capacity(1 + PubKey::SIZE + 1);
         script.put_bytecode(&[PubKey::SIZE as u8]);
         script.put_bytecode(pubkey.as_slice());
         script.put_opcodes([OP_CHECKSIG]);
         script.freeze()
     }
 
     /// Pay-to-public-key (uncompressed): `<pubkey> OP_CHECKSIG`
     /// ```
     /// # use bitcoinsuite_core::{
     /// #     script::{UncompressedPubKey, Script},
     /// #     hash::ShaRmd160,
     /// # };
     /// # use hex_literal::hex;
     /// let pubkey = UncompressedPubKey(hex!(
     ///     "0400112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
     ///     "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
     /// ));
     /// let script = Script::p2pk_uncompressed(&pubkey);
     /// assert_eq!(
     ///     script.hex(),
     ///     "410400112233445566778899aabbccddeeff00112233445566778899aabbccddee\
     ///      ff00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff\
     ///      ac",
     /// );
     /// ```
     pub fn p2pk_uncompressed(pubkey: &UncompressedPubKey) -> Script {
         let mut script =
             ScriptMut::with_capacity(1 + UncompressedPubKey::SIZE + 1);
         script.put_bytecode(&[UncompressedPubKey::SIZE as u8]);
         script.put_bytecode(pubkey.as_ref());
         script.put_opcodes([OP_CHECKSIG]);
         script.freeze()
     }
 
     /// Return the bytecode of the script.
     /// ```
     /// # use bitcoinsuite_core::script::Script;
     /// use bytes::Bytes;
     /// let bytecode = Bytes::from(vec![0x51]);
     /// assert_eq!(Script::new(bytecode.clone()).bytecode(), &bytecode);
     /// ```
     pub fn bytecode(&self) -> &Bytes {
         &self.0
     }
 
     /// Return the bytecode of the script as a [`Vec<u8>`].
     /// ```
     /// # use bitcoinsuite_core::script::Script;
     /// use bytes::Bytes;
     /// let bytecode = Bytes::from(vec![0x51]);
     /// assert_eq!(Script::new(bytecode.clone()).to_vec(), vec![0x51]);
     /// ```
     pub fn to_vec(&self) -> Vec<u8> {
         self.0.to_vec()
     }
 
     /// Hex of the bytecode.
     /// ```
     /// # use bitcoinsuite_core::script::Script;
     /// use bytes::Bytes;
     /// let bytecode = Bytes::from(vec![0x51]);
     /// assert_eq!(Script::new(bytecode.clone()).hex(), "51");
     /// ```
     pub fn hex(&self) -> String {
         hex::encode(&self.0)
     }
 
     /// Whether this script is an OP_RETURN script.
     /// ```
     /// # use bitcoinsuite_core::script::Script;
     /// assert!(Script::new(vec![0x6a].into()).is_opreturn());
     /// assert!(Script::new(vec![0x6a, 0x00].into()).is_opreturn());
     /// assert!(!Script::new(vec![0x6f].into()).is_opreturn());
     /// ```
     pub fn is_opreturn(&self) -> bool {
         match self.0.first() {
             Some(&byte) => byte == OP_RETURN.number(),
             None => false,
         }
     }
 
     /// Iterator over the operations in this script.
     ///
     /// ```
     /// # use bitcoinsuite_core::{
     /// #     script::{opcode::*, Op, Script},
     /// #     error::DataError,
     /// # };
     /// # use hex_literal::hex;
     /// #
     /// // Simple script
     /// let script = Script::new(hex!("0301020387").to_vec().into());
     /// let mut iter = script.iter_ops();
     /// assert_eq!(
     ///     iter.next(),
     ///     Some(Ok(Op::Push(Opcode(3), vec![1, 2, 3].into()))),
     /// );
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_EQUAL))));
     /// assert_eq!(iter.next(), None);
     ///
     /// // Complex script; has invalid op at the end
     /// let script = hex!("6a504c021234004d01001260884cffabcd");
     /// let script = Script::new(script.to_vec().into());
     /// let mut iter = script.iter_ops();
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_RETURN))));
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_RESERVED))));
     /// assert_eq!(
     ///     iter.next(),
     ///     Some(Ok(Op::Push(OP_PUSHDATA1, vec![0x12, 0x34].into()))),
     /// );
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_0))));
     /// assert_eq!(
     ///     iter.next(),
     ///     Some(Ok(Op::Push(OP_PUSHDATA2, vec![0x12].into()))),
     /// );
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_16))));
     /// assert_eq!(iter.next(), Some(Ok(Op::Code(OP_EQUALVERIFY))));
     /// assert_eq!(
     ///     iter.next(),
     ///     Some(Err(DataError::InvalidLength {
     ///         expected: 0xff,
     ///         actual: 2
     ///     })),
     /// );
     /// assert_eq!(iter.next(), None);
     /// ```
     pub fn iter_ops(&self) -> ScriptOpIter {
         ScriptOpIter::new(self.0.clone())
     }
 }
 
 impl AsRef<[u8]> for Script {
     fn as_ref(&self) -> &[u8] {
         self.0.as_ref()
     }
 }
 
 impl BitcoinSer for Script {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         self.0.ser_to(bytes)
     }
+
+    fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+        Ok(Script(Bytes::deser(data)?))
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use bytes::Bytes;
+
     use crate::{script::Script, ser::BitcoinSer};
 
     fn verify_ser(a: Script, b: &[u8]) {
         assert_eq!(a.ser().as_ref(), b);
         assert_eq!(a.ser_len(), b.len());
+        let mut bytes = Bytes::copy_from_slice(b);
+        assert_eq!(a, Script::deser(&mut bytes).unwrap());
     }
 
     #[test]
     fn test_ser_script() {
         verify_ser(Script::default(), &[0x00]);
         verify_ser(Script::new(vec![0x51].into()), &[0x01, 0x51]);
         verify_ser(Script::new(vec![0x51, 0x52].into()), &[0x02, 0x51, 0x52]);
         verify_ser(
             Script::new(vec![4; 0xfd].into()),
             &[[0xfd, 0xfd, 0].as_ref(), &[4; 0xfd]].concat(),
         );
         verify_ser(
             Script::new(vec![5; 0x10000].into()),
             &[[0xfe, 0, 0, 1, 0].as_ref(), &vec![5; 0x10000]].concat(),
         );
     }
 }
diff --git a/chronik/bitcoinsuite-core/src/ser.rs b/chronik/bitcoinsuite-core/src/ser.rs
index 139742f76..3a0708527 100644
--- a/chronik/bitcoinsuite-core/src/ser.rs
+++ b/chronik/bitcoinsuite-core/src/ser.rs
@@ -1,239 +1,288 @@
 // Copyright (c) 2023 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 //! Module containing [`BitcoinSer`].
 
 use bytes::{Bytes, BytesMut};
 
+use crate::{
+    bytes::{read_array, read_bytes},
+    error::DataError,
+};
+
 /// Serializer for implementors of [`BitcoinSer`].
 pub trait BitcoinSerializer {
     /// Serialize the given slice of data.
     fn put(&mut self, slice: &[u8]);
 }
 
 /// Trait for serializing data using the serialization Bitcoin is using.
-pub trait BitcoinSer {
+pub trait BitcoinSer: Sized {
     /// Serialize to the given serializer
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S);
 
     /// Serialize to bytes.
     fn ser(&self) -> Bytes {
         let mut bytes = BytesMut::new();
         self.ser_to(&mut bytes);
         bytes.freeze()
     }
 
     /// Measure the length of the serialized result without storing the
     /// serialization.
     fn ser_len(&self) -> usize {
         let mut len = 0usize;
         self.ser_to(&mut len);
         len
     }
+
+    /// Deserialize the given bytes to `Self`
+    fn deser(data: &mut Bytes) -> Result<Self, DataError>;
 }
 
 impl BitcoinSerializer for BytesMut {
     fn put(&mut self, slice: &[u8]) {
         use bytes::BufMut;
         self.put_slice(slice);
     }
 }
 
 impl BitcoinSerializer for usize {
     fn put(&mut self, slice: &[u8]) {
         *self += slice.len();
     }
 }
 
 impl BitcoinSer for Bytes {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         write_compact_size(bytes, self.len() as u64);
         bytes.put(self.as_ref());
     }
+
+    fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+        let size = read_compact_size(data)?;
+        read_bytes(data, size as usize)
+    }
 }
 
 impl<const N: usize> BitcoinSer for [u8; N] {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         bytes.put(self.as_ref());
     }
+
+    fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+        read_array::<N>(data)
+    }
 }
 
 impl<T: BitcoinSer> BitcoinSer for Vec<T> {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         write_compact_size(bytes, self.len() as u64);
         for part in self {
             part.ser_to(bytes);
         }
     }
+
+    fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+        let size = read_compact_size(data)? as usize;
+        let mut entries = Vec::with_capacity(size.min(0x10000));
+        for _ in 0..size {
+            entries.push(T::deser(data)?);
+        }
+        Ok(entries)
+    }
 }
 
 impl BitcoinSer for bool {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         bytes.put(&[*self as u8]);
     }
+
+    fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+        Ok(read_array::<1>(data)?[0] != 0)
+    }
 }
 
 macro_rules! integer_impls {
     ($($T:ident $SIZE:literal,)+) => {
         $(
             impl BitcoinSer for $T {
                 fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
                     bytes.put(&self.to_le_bytes())
                 }
+
+                fn deser(data: &mut Bytes) -> Result<Self, DataError> {
+                    let value = $T::from_le_bytes(read_array::<$SIZE>(data)?);
+                    Ok(value)
+                }
             }
         )+
     }
 }
 
 integer_impls! {
     u8 1, i8 1, u16 2, i16 2, u32 4, i32 4, u64 8, i64 8, u128 16, i128 16,
 }
 
 fn write_compact_size<S: BitcoinSerializer>(bytes: &mut S, size: u64) {
     match size {
         0..=0xfc => bytes.put(&[size as u8]),
         0xfd..=0xffff => {
             bytes.put(&[0xfd]);
             bytes.put(&(size as u16).to_le_bytes());
         }
         0x10000..=0xffff_ffff => {
             bytes.put(&[0xfe]);
             bytes.put(&(size as u32).to_le_bytes());
         }
         _ => {
             bytes.put(&[0xff]);
             bytes.put(&size.to_le_bytes());
         }
     }
 }
 
+fn read_compact_size(bytes: &mut Bytes) -> Result<u64, DataError> {
+    let first_byte = read_array::<1>(bytes)?[0];
+    match first_byte {
+        0..=0xfc => Ok(first_byte as u64),
+        0xfd => Ok(u16::from_le_bytes(read_array::<2>(bytes)?) as u64),
+        0xfe => Ok(u32::from_le_bytes(read_array::<4>(bytes)?) as u64),
+        0xff => Ok(u64::from_le_bytes(read_array::<8>(bytes)?)),
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use std::fmt::Debug;
+
     use bytes::Bytes;
 
     use crate::ser::BitcoinSer;
 
-    fn verify_ser<T: BitcoinSer>(a: T, b: &[u8]) {
+    fn verify_ser<T: BitcoinSer + Debug + PartialEq>(a: T, b: &[u8]) {
         assert_eq!(a.ser().as_ref(), b);
         assert_eq!(a.ser_len(), b.len());
+        let mut bytes = Bytes::copy_from_slice(b);
+        assert_eq!(a, T::deser(&mut bytes).unwrap());
     }
 
     #[test]
     fn test_ser_bytes() {
         verify_ser(Bytes::new(), &[0]);
         verify_ser(Bytes::from(vec![1]), &[1, 1]);
         verify_ser(Bytes::from(vec![1, 2, 3]), &[3, 1, 2, 3]);
         verify_ser(
             Bytes::from(vec![4; 0xfc]),
             &[[0xfc].as_ref(), &[4; 0xfc]].concat(),
         );
         verify_ser(
             Bytes::from(vec![5; 0xfd]),
             &[[0xfd, 0xfd, 0].as_ref(), &[5; 0xfd]].concat(),
         );
         verify_ser(
             Bytes::from(vec![6; 0xfe]),
             &[[0xfd, 0xfe, 0].as_ref(), &[6; 0xfe]].concat(),
         );
         verify_ser(
             Bytes::from(vec![7; 0xffff]),
             &[[0xfd, 0xff, 0xff].as_ref(), &vec![7; 0xffff]].concat(),
         );
         verify_ser(
             Bytes::from(vec![8; 0x10000]),
             &[[0xfe, 0, 0, 1, 0].as_ref(), &vec![8; 0x10000]].concat(),
         );
     }
 
     #[test]
     fn test_ser_byte_array() {
         verify_ser([], &[]);
         verify_ser([1u8], &[1]);
         verify_ser([1u8, 2], &[1, 2]);
         verify_ser([1u8, 2, 3], &[1, 2, 3]);
         verify_ser([4u8; 32], &[4; 32]);
         verify_ser([5u8; 0xff], &[5; 0xff]);
     }
 
     #[test]
     fn test_ser_vec() {
         verify_ser(Vec::<u32>::new(), &[0]);
         verify_ser(vec![1u8], &[1, 1]);
         verify_ser(vec![1u32], &[1, 1, 0, 0, 0]);
         verify_ser(vec![1u8, 2, 3], &[3, 1, 2, 3]);
         verify_ser(vec![1u16, 2, 3], &[3, 1, 0, 2, 0, 3, 0]);
         let vec_bytes = vec![
             Bytes::new(),
             Bytes::from([1].as_ref()),
             Bytes::from([1, 2, 3].as_ref()),
         ];
         verify_ser(vec_bytes, &[3, 0, 1, 1, 3, 1, 2, 3]);
     }
 
     #[test]
     fn test_ser_bool() {
         verify_ser(true, &[1]);
         verify_ser(false, &[0]);
     }
 
     #[test]
     fn test_ser_integers() {
         verify_ser(128u8, &[128]);
         verify_ser(123u8, &[123]);
         verify_ser(123i8, &[123]);
         verify_ser(-123i8, &[133]);
         verify_ser(0x1234u16, &[0x34, 0x12]);
         verify_ser(0x9234u16, &[0x34, 0x92]);
         verify_ser(0x1234i16, &[0x34, 0x12]);
         verify_ser(-0x1234i16, &[0xcc, 0xed]);
         verify_ser(0x12345678u32, &[0x78, 0x56, 0x34, 0x12]);
         verify_ser(0x92345678u32, &[0x78, 0x56, 0x34, 0x92]);
         verify_ser(0x12345678i32, &[0x78, 0x56, 0x34, 0x12]);
         verify_ser(-0x12345678i32, &[0x88, 0xa9, 0xcb, 0xed]);
         verify_ser(
             0x1234567890abcdefu64,
             &[0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12],
         );
         verify_ser(
             0x9234567890abcdefu64,
             &[0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x92],
         );
         verify_ser(
             0x1234567890abcdefi64,
             &[0xef, 0xcd, 0xab, 0x90, 0x78, 0x56, 0x34, 0x12],
         );
         verify_ser(
             -0x1234567890abcdefi64,
             &[0x11, 0x32, 0x54, 0x6f, 0x87, 0xa9, 0xcb, 0xed],
         );
         verify_ser(
             0x1234567890abcdeffedcba0123456789u128,
             &[
                 0x89, 0x67, 0x45, 0x23, 0x01, 0xba, 0xdc, 0xfe, 0xef, 0xcd,
                 0xab, 0x90, 0x78, 0x56, 0x34, 0x12,
             ],
         );
         verify_ser(
             0x9234567890abcdeffedcba0123456789u128,
             &[
                 0x89, 0x67, 0x45, 0x23, 0x01, 0xba, 0xdc, 0xfe, 0xef, 0xcd,
                 0xab, 0x90, 0x78, 0x56, 0x34, 0x92,
             ],
         );
         verify_ser(
             0x1234567890abcdeffedcba0123456789i128,
             &[
                 0x89, 0x67, 0x45, 0x23, 0x01, 0xba, 0xdc, 0xfe, 0xef, 0xcd,
                 0xab, 0x90, 0x78, 0x56, 0x34, 0x12,
             ],
         );
         verify_ser(
             -0x1234567890abcdeffedcba0123456789i128,
             &[
                 0x77, 0x98, 0xba, 0xdc, 0xfe, 0x45, 0x23, 0x01, 0x10, 0x32,
                 0x54, 0x6f, 0x87, 0xa9, 0xcb, 0xed,
             ],
         );
     }
 }
diff --git a/chronik/bitcoinsuite-core/src/tx/tx.rs b/chronik/bitcoinsuite-core/src/tx/tx.rs
index 3bf488f1f..7e6093869 100644
--- a/chronik/bitcoinsuite-core/src/tx/tx.rs
+++ b/chronik/bitcoinsuite-core/src/tx/tx.rs
@@ -1,251 +1,296 @@
 // Copyright (c) 2023 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 use crate::{
+    error::DataError,
     script::Script,
     ser::{BitcoinSer, BitcoinSerializer},
     tx::TxId,
 };
 
 /// CTransaction, a Bitcoin transaction.
 ///
 /// ```
 /// # use bitcoinsuite_core::tx::{Tx, TxId, TxMut};
 /// let txid = TxId::from([3; 32]);
 /// let tx = Tx::with_txid(
 ///     txid,
 ///     TxMut {
 ///         version: 1,
 ///         inputs: vec![],
 ///         outputs: vec![],
 ///         locktime: 0,
 ///     },
 /// );
 /// assert_eq!(tx.txid(), txid);
 /// assert_eq!(tx.version, 1);
 /// assert_eq!(tx.inputs, vec![]);
 /// assert_eq!(tx.outputs, vec![]);
 /// assert_eq!(tx.locktime, 0);
 /// ```
 ///
 /// Immutable version of [`TxMut`], so this will fail:
 /// ```compile_fail
 /// # use bitcoinsuite_core::tx::Tx;
 /// let mut tx = Tx::default();
 /// tx.version = 1;
 /// ```
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Tx {
     txid: TxId,
     tx: TxMut,
 }
 
 /// Bitcoin transaction. Mutable version of [`Tx`], like CMutableTransaction.
 ///
 /// The biggest difference is that it doesn't have a txid() method, which we
 /// cannot know without hashing the tx every time, which would be expensive to
 /// compute.
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct TxMut {
     /// nVersion of the tx.
     pub version: i32,
     /// Tx inputs.
     pub inputs: Vec<TxInput>,
     /// Tx outputs.
     pub outputs: Vec<TxOutput>,
     /// Locktime of the tx.
     pub locktime: u32,
 }
 
 /// COutPoint, pointing to a coin being spent.
 #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct OutPoint {
     /// TxId of the output of the coin.
     pub txid: TxId,
     /// Index in the outputs of the tx of the coin.
     pub out_idx: u32,
 }
 
 /// Points to an input spending a coin.
 #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct SpentBy {
     /// TxId of the tx with the input.
     pub txid: TxId,
     /// Index in the inputs of the tx.
     pub input_idx: u32,
 }
 
 /// CTxIn, spending an unspent output.
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct TxInput {
     /// Points to an output being spent.
     pub prev_out: OutPoint,
     /// scriptSig unlocking the output.
     pub script: Script,
     /// nSequence.
     pub sequence: u32,
     /// Coin being spent by this tx.
     /// May be [`None`] for coinbase txs or if the spent coin is unknown.
     pub coin: Option<Coin>,
 }
 
 /// CTxOut, creating a new output.
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct TxOutput {
     /// Value of the output.
     pub value: i64,
     /// Script locking the output.
     pub script: Script,
 }
 
 /// Coin, can be spent by providing a valid unlocking script.
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct Coin {
     /// Output, locking the coins.
     pub output: TxOutput,
     /// Height of the coin in the chain.
     pub height: i32,
     /// Whether the coin is a coinbase.
     pub is_coinbase: bool,
 }
 
 impl Tx {
     /// Create a new [`Tx`] with a given [`TxId`] and [`TxMut`].
     ///
     /// It is the responsibility of the caller to ensure the `txid` matches
     /// `tx`.
     pub fn with_txid(txid: TxId, tx: TxMut) -> Self {
         Tx { txid, tx }
     }
 
     /// [`TxId`] of this [`Tx`].
     pub fn txid(&self) -> TxId {
         self.txid
     }
 
     /// Like [`Tx::txid`], but as a reference.
     pub fn txid_ref(&self) -> &TxId {
         &self.txid
     }
 }
 
 impl std::ops::Deref for Tx {
     type Target = TxMut;
 
     fn deref(&self) -> &Self::Target {
         &self.tx
     }
 }
 
 impl BitcoinSer for TxMut {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         self.version.ser_to(bytes);
         self.inputs.ser_to(bytes);
         self.outputs.ser_to(bytes);
         self.locktime.ser_to(bytes);
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        Ok(TxMut {
+            version: BitcoinSer::deser(data)?,
+            inputs: BitcoinSer::deser(data)?,
+            outputs: BitcoinSer::deser(data)?,
+            locktime: BitcoinSer::deser(data)?,
+        })
+    }
 }
 
 impl BitcoinSer for Tx {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         TxMut::ser_to(self, bytes)
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        let tx = TxMut::deser(data)?;
+        Ok(Tx::with_txid(TxId::from_tx(&tx), tx))
+    }
 }
 
 impl BitcoinSer for OutPoint {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         self.txid.ser_to(bytes);
         self.out_idx.ser_to(bytes);
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        Ok(OutPoint {
+            txid: BitcoinSer::deser(data)?,
+            out_idx: BitcoinSer::deser(data)?,
+        })
+    }
 }
 
 impl BitcoinSer for TxInput {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         self.prev_out.ser_to(bytes);
         self.script.ser_to(bytes);
         self.sequence.ser_to(bytes);
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        Ok(TxInput {
+            prev_out: BitcoinSer::deser(data)?,
+            script: BitcoinSer::deser(data)?,
+            sequence: BitcoinSer::deser(data)?,
+            coin: None,
+        })
+    }
 }
 
 impl BitcoinSer for TxOutput {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         self.value.ser_to(bytes);
         self.script.ser_to(bytes);
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        Ok(TxOutput {
+            value: BitcoinSer::deser(data)?,
+            script: BitcoinSer::deser(data)?,
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use bytes::Bytes;
+
     use crate::{
         script::Script,
         ser::BitcoinSer,
         tx::{OutPoint, Tx, TxId, TxInput, TxMut, TxOutput},
     };
 
     fn verify_ser(tx: TxMut, ser: &[u8]) {
         assert_eq!(tx.ser().as_ref(), ser);
         assert_eq!(tx.ser_len(), ser.len());
-        let tx = Tx::with_txid(TxId::from([12; 32]), tx);
+        let mut bytes = Bytes::copy_from_slice(ser);
+        assert_eq!(tx, TxMut::deser(&mut bytes).unwrap());
+
+        let tx = Tx::with_txid(TxId::from_tx(&tx), tx);
         assert_eq!(tx.ser().as_ref(), ser);
         assert_eq!(tx.ser_len(), ser.len());
+        let mut bytes = Bytes::copy_from_slice(ser);
+        assert_eq!(tx, Tx::deser(&mut bytes).unwrap());
     }
 
     #[test]
     fn test_ser_tx() -> Result<(), hex::FromHexError> {
         verify_ser(TxMut::default(), &[0; 10]);
         verify_ser(
             TxMut {
                 version: 0x12345678,
                 inputs: vec![],
                 outputs: vec![],
                 locktime: 0x9abcdef1,
             },
             &hex::decode("785634120000f1debc9a")?,
         );
         let genesis_tx = TxMut {
             version: 1,
             inputs: vec![TxInput {
                 prev_out: OutPoint {
                     txid: TxId::from([0; 32]),
                     out_idx: 0xffff_ffff,
                 },
                 script: Script::new(
                     hex::decode(
                         "04ffff001d0104455468652054696d65732030332f4a616e2f3230\
                          3039204368616e63656c6c6f72206f6e206272696e6b206f662073\
                          65636f6e64206261696c6f757420666f722062616e6b73",
                     )?
                     .into(),
                 ),
                 sequence: 0xffff_ffff,
                 coin: None,
             }],
             outputs: vec![TxOutput {
                 value: 5000000000,
                 script: Script::new(
                     hex::decode(
                         "4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a679\
                          62e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7\
                          ba0b8d578a4c702b6bf11d5fac",
                     )?
                     .into(),
                 ),
             }],
             locktime: 0,
         };
         verify_ser(
             genesis_tx,
             &hex::decode(
                 "01000000010000000000000000000000000000000000000000000000000000\
                  000000000000ffffffff4d04ffff001d0104455468652054696d6573203033\
                  2f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f\
                  66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff01\
                  00f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828\
                  e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384d\
                  f7ba0b8d578a4c702b6bf11d5fac00000000"
             )?,
         );
         Ok(())
     }
 }
diff --git a/chronik/bitcoinsuite-core/src/tx/txid.rs b/chronik/bitcoinsuite-core/src/tx/txid.rs
index 63fcdc352..338a3cfb8 100644
--- a/chronik/bitcoinsuite-core/src/tx/txid.rs
+++ b/chronik/bitcoinsuite-core/src/tx/txid.rs
@@ -1,200 +1,205 @@
 // Copyright (c) 2023 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 use crate::{
+    bytes::read_array,
     error::DataError,
     hash::{Hashed, Sha256d},
     ser::{BitcoinSer, BitcoinSerializer},
     tx::TxMut,
 };
 
 /// Wraps a tx ID's [`Sha256d`], to avoid mixing different kinds of hashes.
 /// Txids are always represented with a big-endian hex string, but stored
 /// in little-endian byteorder.
 #[derive(Clone, Copy, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct TxId(Sha256d);
 
 impl std::fmt::Debug for TxId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "TxId({})", self.0.hex_be())
     }
 }
 
 impl std::fmt::Display for TxId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.hex_be().fmt(f)
     }
 }
 
 impl TxId {
     /// Return the [`TxId`] for the given [`TxMut`] (or `Tx`).
     ///
     /// This is done by hashing the serialized tx using [`Sha256d`].
     ///
     /// ```
     /// # use bitcoinsuite_core::tx::{Tx, TxId, TxMut};
     /// let zero_tx_hash =
     ///     "f702453dd03b0f055e5437d76128141803984fb10acb85fc3b2184fae2f3fa78"
     ///         .parse::<TxId>()
     ///         .unwrap();
     /// assert_eq!(TxId::from_tx(&TxMut::default()), zero_tx_hash);
     /// assert_eq!(TxId::from_tx(&Tx::default()), zero_tx_hash);
     /// ```
     pub fn from_tx(tx: &TxMut) -> Self {
         TxId(Sha256d::digest(tx.ser()))
     }
 
     /// Returns the txid bytes in little-endian byte order.
     ///
     /// ```
     /// # use bitcoinsuite_core::{tx::TxId, hash::{Sha256d, Hashed}};
     /// # use hex_literal::hex;
     /// let hash = hex!(
     ///     "3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"
     /// );
     /// let txid = TxId::from(Sha256d(hash));
     /// assert_eq!(txid.to_bytes(), hash);
     /// ```
     pub fn to_bytes(&self) -> [u8; 32] {
         self.0.to_le_bytes()
     }
 
     /// Returns a reference to the txid bytes in little-endian byte order.
     ///
     /// ```
     /// # use bitcoinsuite_core::{tx::TxId, hash::{Sha256d, Hashed}};
     /// # use hex_literal::hex;
     /// let hash = hex!(
     ///     "3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"
     /// );
     /// let txid = TxId::from(Sha256d(hash));
     /// assert_eq!(txid.as_bytes(), &hash);
     /// ```
     pub fn as_bytes(&self) -> &[u8; 32] {
         self.0.as_le_bytes()
     }
 
     /// Returns the txid as [`Vec<u8>`] in little-endian byte order.
     ///
     /// ```
     /// # use bitcoinsuite_core::{tx::TxId, hash::{Sha256d, Hashed}};
     /// # use hex_literal::hex;
     /// let hash = hex!(
     ///     "3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a"
     /// );
     /// let txid = TxId::from(Sha256d(hash));
     /// assert_eq!(txid.to_vec(), hash.to_vec());
     /// ```
     pub fn to_vec(&self) -> Vec<u8> {
         self.to_bytes().to_vec()
     }
 }
 
 impl std::str::FromStr for TxId {
     type Err = DataError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(TxId(Sha256d::from_be_hex(s)?))
     }
 }
 
 impl TryFrom<&'_ [u8]> for TxId {
     type Error = DataError;
 
     fn try_from(value: &'_ [u8]) -> Result<Self, Self::Error> {
         Ok(TxId(Sha256d::from_le_slice(value)?))
     }
 }
 
 impl From<[u8; 32]> for TxId {
     fn from(array: [u8; 32]) -> Self {
         TxId(Sha256d(array))
     }
 }
 
 impl From<Sha256d> for TxId {
     fn from(hash: Sha256d) -> Self {
         TxId(hash)
     }
 }
 
 impl AsRef<[u8]> for TxId {
     fn as_ref(&self) -> &[u8] {
         self.0.as_ref()
     }
 }
 
 impl BitcoinSer for TxId {
     fn ser_to<S: BitcoinSerializer>(&self, bytes: &mut S) {
         bytes.put(self.as_bytes())
     }
+
+    fn deser(data: &mut bytes::Bytes) -> Result<Self, DataError> {
+        Ok(TxId(Sha256d(read_array(data)?)))
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use hex_literal::hex;
 
     use crate::{
         error::DataError,
         hash::{Hashed, Sha256d},
         tx::TxId,
     };
 
     const HASH_HEX: &str =
         "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
 
     fn txid_hash() -> Sha256d {
         let txid_hash = hex!(
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
         Sha256d::from_be_bytes(txid_hash)
     }
 
     #[test]
     fn test_parse() -> Result<(), DataError> {
         let txid = HASH_HEX.parse::<TxId>()?;
         assert_eq!(txid, TxId::from(txid_hash()));
         Ok(())
     }
 
     #[test]
     fn test_parse_fail() {
         assert_eq!(
             "abcd".parse::<TxId>(),
             Err(DataError::InvalidLength {
                 expected: 32,
                 actual: 2,
             }),
         );
     }
 
     #[test]
     fn test_try_from_slice() {
         let hash = txid_hash();
         let slice = hash.as_le_bytes().as_ref();
         let txid: TxId = slice.try_into().unwrap();
         assert_eq!(txid, TxId::from(hash));
         assert_eq!(
             TxId::try_from(b"ab".as_ref()),
             Err(DataError::InvalidLength {
                 expected: 32,
                 actual: 2,
             }),
         );
     }
 
     #[test]
     fn test_debug() {
         assert_eq!(
             format!("{:?}", TxId::from(txid_hash())),
             format!("TxId({})", HASH_HEX),
         );
     }
 
     #[test]
     fn test_display() -> Result<(), DataError> {
         assert_eq!(TxId::from(txid_hash()).to_string(), HASH_HEX);
         Ok(())
     }
 }