diff --git a/.config/dictionaries/project.dic b/.config/dictionaries/project.dic
index c6b585602..ebd535eb8 100644
--- a/.config/dictionaries/project.dic
+++ b/.config/dictionaries/project.dic
@@ -10,6 +10,7 @@ Arissara
 asyncio
 Attributes
 auditability
+auxdata
 babystep
 backpressure
 bech
diff --git a/.github/workflows/semantic_pull_request.yml b/.github/workflows/semantic_pull_request.yml
index 6b520e06d..5b0ad2465 100644
--- a/.github/workflows/semantic_pull_request.yml
+++ b/.github/workflows/semantic_pull_request.yml
@@ -26,6 +26,7 @@ jobs:
         rust/cbork
         rust/hermes-ipfs
         rust/rbac-registration
+        rust/cardano-blockchain-types
         dart
         docs
         general
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index e01edc7e3..282be4d5f 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "c509-certificate",
+    "cardano-blockchain-types",
     "cardano-chain-follower",
     "hermes-ipfs",
     "cbork",
diff --git a/rust/Earthfile b/rust/Earthfile
index ea762219c..a97149d7a 100644
--- a/rust/Earthfile
+++ b/rust/Earthfile
@@ -9,6 +9,7 @@ COPY_SRC:
         Cargo.toml clippy.toml deny.toml rustfmt.toml \
         .cargo .config \
         c509-certificate \
+        cardano-blockchain-types \
         cardano-chain-follower \
         catalyst-voting vote-tx-v1 vote-tx-v2 \
         cbork cbork-abnf-parser cbork-cddl-parser \
@@ -53,7 +54,7 @@ build:
 
     DO rust-ci+EXECUTE \
         --cmd="/scripts/std_build.py" \
-        --args1="--libs=c509-certificate --libs=cardano-chain-follower --libs=hermes-ipfs" \
+        --args1="--libs=c509-certificate --libs=cardano-blockchain-types --libs=cardano-chain-follower --libs=hermes-ipfs" \
         --args2="--libs=cbork-cddl-parser --libs=cbork-abnf-parser" \
         --args3="--libs=catalyst-voting --libs=immutable-ledger --libs=vote-tx-v1 --libs=vote-tx-v2" \
         --args4="--bins=cbork/cbork --libs=rbac-registration --libs=signed_doc" \
@@ -63,7 +64,7 @@ build:
         --coverage="cat-libs.coverage.info" \
         --docs="true"
 
-    SAVE ARTIFACT target/$TARGETARCH/doc doc
+    SAVE ARTIFACT target/doc doc
     SAVE ARTIFACT target/release/cbork cbork
 
 # build-src-check: Check for any caching issues with the source we are building against.
diff --git a/rust/cardano-blockchain-types/Cargo.toml b/rust/cardano-blockchain-types/Cargo.toml
new file mode 100644
index 000000000..6c95c7b02
--- /dev/null
+++ b/rust/cardano-blockchain-types/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "cardano-blockchain-types"
+description = "Common Cardano Blockchain data types for use in both applications and crates"
+keywords = ["cardano", "catalyst",]
+version = "0.0.1"
+authors = [
+    "Steven Johnson <steven.johnson@iohk.io>"
+]
+edition.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[lints]
+workspace = true
+
+[dependencies]
+pallas = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
+pallas-crypto = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
+# pallas-hardano = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
+
+ouroboros = "0.18.4"
+tracing = "0.1.41"
+anyhow = "1.0.94"
+chrono = "0.4.39"
+strum = { version = "0.26.3", features = ["derive"] }
+dirs = "5.0.1"
+hex = "0.4.3"
+dashmap = "6.1.0"
+blake2b_simd = "1.0.2"
+minicbor = { version = "0.25.1", features = ["alloc"] }
+num-traits = "0.2.19"
+ed25519-dalek = "2.1.1"
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/Readme.md b/rust/cardano-blockchain-types/Readme.md
new file mode 100644
index 000000000..afa508052
--- /dev/null
+++ b/rust/cardano-blockchain-types/Readme.md
@@ -0,0 +1,6 @@
+# Improved version of Pallas Multi Era Block
+
+Adds features to the Pallas Multi Era Block to allow us to re-use it between the different cardano crates,
+and the services that use them.
+
+The original source was `cardano-chain-follower`.
diff --git a/rust/cardano-blockchain-types/deps.tmp b/rust/cardano-blockchain-types/deps.tmp
new file mode 100644
index 000000000..f65f5bfb5
--- /dev/null
+++ b/rust/cardano-blockchain-types/deps.tmp
@@ -0,0 +1,61 @@
+rbac-registration = { version = "0.0.2", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "v0.0.8" }
+
+thiserror = "1.0.64"
+tokio = { version = "1.40.0", features = [
+    "macros",
+    "rt",
+    "net",
+    "rt-multi-thread",
+] }
+tracing = "0.1.40"
+tracing-log = "0.2.0"
+dashmap = "6.1.0"
+url = "2.5.2"
+anyhow = "1.0.89"
+chrono = "0.4.38"
+async-trait = "0.1.83"
+dirs = "5.0.1"
+futures = "0.3.31"
+humantime = "2.1.0"
+crossbeam-skiplist = "0.1.3"
+crossbeam-channel = "0.5.13"
+crossbeam-epoch = "0.9.18"
+strum = "0.26.3"
+ouroboros = "0.18.4"
+hex = "0.4.3"
+rayon = "1.10.0"
+serde = "1.0.210"
+serde_json = "1.0.128"
+mimalloc = { version = "0.1.43", optional = true }
+memx = "0.1.32"
+fmmap = { version = "0.3.3", features = ["sync", "tokio-async"] }
+minicbor = { version = "0.25.1", features = ["alloc", "derive", "half"] }
+zstd = "0.13.2"
+ed25519-dalek = "2.1.1"
+blake2b_simd = "1.0.2"
+num-traits = "0.2.19"
+logcall = "0.1.9"
+tar = "0.4.42"
+ureq = { version = "2.10.1", features = ["native-certs"] }
+http = "1.1.0"
+hickory-resolver = { version = "0.24.1", features = ["dns-over-rustls"] }
+moka = { version = "0.12.8", features = ["sync"] }
+
+hex = "0.4.3"
+anyhow = "1.0.89"
+strum_macros = "0.26.4"
+regex = "1.11.0"
+minicbor = { version = "0.25.1", features = ["alloc", "derive", "half"] }
+brotli = "7.0.0"
+zstd = "0.13.2"
+x509-cert = "0.2.5"
+der-parser = "9.0.0"
+bech32 = "0.11.0"
+dashmap = "6.1.0"
+blake2b_simd = "1.0.2"
+tracing = "0.1.40"
+ed25519-dalek = "2.1.1"
+uuid = "1.11.0"
+
+c509-certificate = { version = "0.0.3", git = "https://github.com/input-output-hk/catalyst-libs.git" , tag = "v0.0.3" }
+pallas = { version = "0.30.1", git = "https://github.com/input-output-hk/catalyst-pallas.git", rev = "9b5183c8b90b90fe2cc319d986e933e9518957b3" }
diff --git a/rust/cardano-blockchain-types/src/auxdata/aux_data.rs b/rust/cardano-blockchain-types/src/auxdata/aux_data.rs
new file mode 100644
index 000000000..a5b79fefb
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/aux_data.rs
@@ -0,0 +1,172 @@
+//! Auxiliary Data Decoding
+
+use minicbor::Decode;
+
+use super::{
+    metadatum::Metadata,
+    metadatum_label::MetadatumLabel,
+    metadatum_value::MetadatumValue,
+    scripts::{MutableTransactionScriptsMap, ScriptArray, ScriptType, TransactionScripts},
+};
+
+/// Auxiliary Data (Metadata) for a single transaction in a block
+#[derive(Clone, Debug)]
+#[allow(clippy::module_name_repetitions)]
+pub struct TransactionAuxData {
+    /// Metadata attached to a transaction
+    metadata: Metadata,
+    /// Scripts attached to a transaction
+    #[allow(dead_code)]
+    scripts: TransactionScripts,
+}
+
+impl Decode<'_, ()> for TransactionAuxData {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        // Check what kind of aux data we have to deal with
+        match d.datatype() {
+            // Shelley: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L522
+            Ok(minicbor::data::Type::Map) => {
+                Ok(TransactionAuxData {
+                    metadata: Metadata::decode(d, &mut ())?,
+                    scripts: TransactionScripts::default(),
+                })
+            },
+            // Shelley-MA: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L523
+            Ok(minicbor::data::Type::Array) => Self::decode_shelley_ma_array(d),
+            // Maybe Alonzo and beyond: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L526
+            Ok(minicbor::data::Type::Tag) => Self::decode_alonzo_plus_map(d),
+            Ok(unexpected) => {
+                let msg = format!(
+                    "Error decoding Transaction Aux Data: Unexpected datatype {unexpected}"
+                );
+                Err(minicbor::decode::Error::message(&msg))
+            },
+            Err(error) => {
+                let msg = format!("Error decoding Transaction Aux Data: {error}");
+                Err(minicbor::decode::Error::message(msg))
+            },
+        }
+    }
+}
+
+impl TransactionAuxData {
+    /// Get metadata with the given label.
+    #[must_use]
+    pub fn metadata(&self, label: MetadatumLabel) -> Option<&MetadatumValue> {
+        self.metadata.get(label)
+    }
+
+    /// Decode a Shelley-MA auxiliary data array
+    fn decode_shelley_ma_array(d: &mut minicbor::Decoder) -> Result<Self, minicbor::decode::Error> {
+        match d.array() {
+            Ok(Some(entries)) => {
+                if entries != 2 {
+                    let msg = format!(
+                        "Error decoding Transaction Aux Data: Script Data Array Expected 2 entries, found {entries}."
+                    );
+                    return Err(minicbor::decode::Error::message(&msg));
+                }
+            },
+            Ok(None) => {
+                return Err(minicbor::decode::Error::message(
+                    "Error decoding Transaction Aux Data: Indefinite Array found decoding Metadata. Invalid."));
+            },
+            Err(error) => {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding Transaction Aux Data: {error}."
+                )));
+            },
+        };
+
+        let metadata = Metadata::decode(d, &mut ())?;
+        let script_array = ScriptArray::decode(d, &mut ScriptType::Native)?;
+
+        let scripts = MutableTransactionScriptsMap::default();
+        scripts.insert(ScriptType::Native, script_array);
+
+        Ok(Self {
+            metadata,
+            scripts: scripts.into(),
+        })
+    }
+
+    /// Decode an Alonzo Plus MAP
+    fn decode_alonzo_plus_map(d: &mut minicbor::Decoder) -> Result<Self, minicbor::decode::Error> {
+        match d.tag() {
+            Ok(tag) => {
+                // CBOR tag identifier 259 for auxiliary data in the Alonzo and beyond eras
+                // https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L526
+                if tag.as_u64() != 259 {
+                    return Err(minicbor::decode::Error::message(format!(
+                        "Invalid tag for Alonzo+ Aux Data. Expected 259, found {tag}."
+                    )));
+                }
+            },
+            Err(error) => {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding Transaction Alonzo+ Aux Data: {error}."
+                )));
+            },
+        }
+
+        let entries = match d.map() {
+            Ok(Some(entries)) => entries,
+            Ok(None) => {
+                return Err(minicbor::decode::Error::message(
+                    "Indefinite Map found decoding Alonzo+ Metadata. Invalid.",
+                ))
+            },
+            Err(error) => {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding Transaction Alonzo+ Aux Data: {error}."
+                )))
+            },
+        };
+
+        // Make the default versions of the metadata and script types
+        let mut metadata = Metadata::default();
+        let scripts = MutableTransactionScriptsMap::default();
+
+        // iterate the map
+        for _ in 0..entries {
+            let script_type = match d.u64() {
+                Ok(key) => {
+                    if let Ok(script_type) = ScriptType::try_from(key) {
+                        script_type
+                    } else {
+                        // Only fails if its Metadata and not a script.
+                        if metadata.is_empty() {
+                            metadata = Metadata::decode(d, &mut ())?;
+                            continue;
+                        }
+                        return Err(minicbor::decode::Error::message(
+                            "Multiple Alonzo+ Metadata entries found. Invalid.",
+                        ));
+                    }
+                },
+
+                Err(error) => {
+                    return Err(minicbor::decode::Error::message(format!(
+                        "Error decoding Alonzo+ Metadata Aux Data Type Key: {error}"
+                    )));
+                },
+            };
+
+            let mut ctx = script_type;
+
+            let script_array = ScriptArray::decode(d, &mut ctx)?;
+            if scripts.insert(script_type, script_array).is_some() {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Multiple Alonzo+ Script entries of type {script_type} found. Invalid.",
+                )));
+            }
+        }
+
+        Ok(Self {
+            metadata,
+            scripts: scripts.into(),
+        })
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/auxdata/block.rs b/rust/cardano-blockchain-types/src/auxdata/block.rs
new file mode 100644
index 000000000..554ede16b
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/block.rs
@@ -0,0 +1,68 @@
+//! Decoded Metadata for a Block
+
+use std::sync::Arc;
+
+use anyhow::bail;
+use dashmap::DashMap;
+use pallas::ledger::traverse::MultiEraBlock;
+
+use super::aux_data::TransactionAuxData;
+use crate::txn_index::TxnIndex;
+
+/// Auxiliary data for every transaction within a block.
+#[derive(Debug)]
+#[allow(clippy::module_name_repetitions)]
+pub struct BlockAuxData(Arc<dashmap::ReadOnlyView<TxnIndex, TransactionAuxData>>);
+
+impl BlockAuxData {
+    /// Get `TransactionAuxData` for the given `TxnIndex` if any.
+    #[must_use]
+    pub fn get(&self, txn_idx: TxnIndex) -> Option<&TransactionAuxData> {
+        self.0.get(&txn_idx)
+    }
+}
+
+impl Default for BlockAuxData {
+    fn default() -> Self {
+        BlockAuxData(Arc::new(DashMap::default().into_read_only()))
+    }
+}
+
+impl TryFrom<&MultiEraBlock<'_>> for BlockAuxData {
+    type Error = anyhow::Error;
+
+    fn try_from(block: &MultiEraBlock) -> Result<Self, Self::Error> {
+        let aux_data = DashMap::<TxnIndex, TransactionAuxData>::new();
+        // Note, while this code looks redundant, it is not because all the types are not
+        // compatible Even though they have similar names, and ultimately the same inner
+        // functionality. This means we need to distinctly encode the three different
+        // loops with the same code.
+        if block.has_aux_data() {
+            if let Some(_metadata) = block.as_byron() {
+                // Nothing to do here.
+            } else if let Some(alonzo_block) = block.as_alonzo() {
+                for (txn_idx, metadata) in alonzo_block.auxiliary_data_set.iter() {
+                    let mut d = minicbor::Decoder::new(metadata.raw_cbor());
+                    let txn_aux_data = d.decode::<TransactionAuxData>()?;
+                    aux_data.insert(TxnIndex::from_saturating(*txn_idx), txn_aux_data);
+                }
+            } else if let Some(babbage_block) = block.as_babbage() {
+                for (txn_idx, metadata) in babbage_block.auxiliary_data_set.iter() {
+                    let mut d = minicbor::Decoder::new(metadata.raw_cbor());
+                    let txn_aux_data = d.decode::<TransactionAuxData>()?;
+                    aux_data.insert(TxnIndex::from_saturating(*txn_idx), txn_aux_data);
+                }
+            } else if let Some(conway_block) = block.as_conway() {
+                for (txn_idx, metadata) in conway_block.auxiliary_data_set.iter() {
+                    let mut d = minicbor::Decoder::new(metadata.raw_cbor());
+                    let txn_aux_data = d.decode::<TransactionAuxData>()?;
+                    aux_data.insert(TxnIndex::from_saturating(*txn_idx), txn_aux_data);
+                }
+            } else {
+                bail!("Undecodable metadata, unknown Era");
+            };
+        }
+
+        Ok(Self(Arc::new(aux_data.into_read_only())))
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum.rs
new file mode 100644
index 000000000..4b107d13c
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum.rs
@@ -0,0 +1,122 @@
+//! Raw metadata
+
+use std::sync::Arc;
+
+use dashmap::DashMap;
+use minicbor::Decode;
+
+use super::{metadatum_label::MetadatumLabel, metadatum_value::MetadatumValue};
+use crate::conversion::from_saturating;
+
+/// Transaction Metadata
+/// See: <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L519>
+#[derive(Clone, Debug)]
+pub struct Metadata(Arc<MetadataInner>);
+
+#[derive(Clone, Debug)]
+/// Transaction Metadata - inner
+/// See: <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L519>
+pub struct MetadataInner {
+    /// Sequence the metadatum labels appear in the metadata.
+    seq: Vec<MetadatumLabel>,
+    /// K/V of metadata items.
+    map: dashmap::ReadOnlyView<MetadatumLabel, MetadatumValue>,
+}
+
+impl Default for MetadataInner {
+    fn default() -> Self {
+        Self {
+            seq: Vec::new(),
+            map: DashMap::default().into_read_only(),
+        }
+    }
+}
+
+impl Metadata {
+    /// Does the metadata contain the label?
+    #[must_use]
+    pub fn contains(&self, label: MetadatumLabel) -> bool {
+        self.0.map.contains_key(&label)
+    }
+
+    /// Get the requested labels value
+    #[must_use]
+    pub fn get(&self, label: MetadatumLabel) -> Option<&MetadatumValue> {
+        self.0.map.get(&label)
+    }
+
+    /// Are there any entries
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.0.seq.len() == 0
+    }
+}
+
+impl Default for Metadata {
+    fn default() -> Self {
+        Metadata(Arc::new(MetadataInner::default()))
+    }
+}
+
+impl Decode<'_, ()> for Metadata {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        let (entries, mut sequence, metadata) = match d.map() {
+            Ok(Some(entries)) => {
+                (
+                    entries,
+                    Vec::with_capacity(from_saturating(entries)),
+                    DashMap::with_capacity(from_saturating(entries)),
+                )
+            },
+            Ok(None) => {
+                // Sadly... Indefinite Maps are allowed in Cardano CBOR Encoding.
+                (u64::MAX, Vec::new(), DashMap::new())
+            },
+            Err(error) => {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding Metadata map: {error}"
+                )));
+            },
+        };
+
+        for _ in 0..entries {
+            let label = MetadatumLabel::decode(d, ctx)?;
+            let value = MetadatumValue::decode(d, ctx)?;
+
+            sequence.push(label);
+            let _unused = metadata.insert(label, value);
+
+            // Look for end sentinel IF its an indefinite MAP
+            // (which we know because entries is u64::MAX).
+            if entries == u64::MAX {
+                match d.datatype() {
+                    Ok(minicbor::data::Type::Break) => {
+                        // Skip over the break token.
+                        let _unused = d.skip();
+                        break;
+                    },
+                    Ok(_) => (), // Not break, so do next loop, should be the next key.
+                    Err(error) => {
+                        return Err(minicbor::decode::Error::message(format!(
+                            "Error decoding indefinite Metadata map end sentinel: {error}"
+                        )));
+                    },
+                }
+            }
+        }
+
+        // Reduce metadata map and seq to smallest size.
+        sequence.shrink_to_fit();
+        metadata.shrink_to_fit();
+
+        // Make map immutable
+        let metadata = metadata.into_read_only();
+
+        Ok(Self(Arc::new(MetadataInner {
+            seq: sequence,
+            map: metadata,
+        })))
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs
new file mode 100644
index 000000000..2729ae713
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum_label.rs
@@ -0,0 +1,40 @@
+//! Metadatum label
+
+use minicbor::Decode;
+
+/// The identifying key for the Metadata item.
+/// See: <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L518>
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct MetadatumLabel(u64);
+
+impl MetadatumLabel {
+    // TODO: Add all the known labels from https://github.com/cardano-foundation/CIPs/blob/master/CIP-0010/registry.json
+
+    /// CIP-020 Message Metadatum Label
+    pub const CIP020_MESSAGE: MetadatumLabel = MetadatumLabel(674);
+    /// CIP-036 Auxiliary Data Metadatum Label
+    pub const CIP036_AUXDATA: MetadatumLabel = MetadatumLabel(61283);
+    /// CIP-036 Registration Metadatum Label
+    pub const CIP036_REGISTRATION: MetadatumLabel = MetadatumLabel(61284);
+    /// CIP-036 Witness Metadatum Label
+    pub const CIP036_WITNESS: MetadatumLabel = MetadatumLabel(61285);
+    /// CIP-XXX X509 RBAC Registration Metadatum Label
+    pub const CIP509_RBAC: MetadatumLabel = MetadatumLabel(509);
+}
+
+impl Decode<'_, ()> for MetadatumLabel {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        let label = match d.u64() {
+            Ok(key) => key,
+            Err(error) => {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding Metadatum label: {error}"
+                )));
+            },
+        };
+
+        Ok(Self(label))
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs b/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs
new file mode 100644
index 000000000..a8c725204
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/metadatum_value.rs
@@ -0,0 +1,41 @@
+//! Metadatum value
+
+use std::sync::Arc;
+
+use minicbor::Decode;
+
+/// Metadatum CBOR Encoded value
+/// See: <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L511>
+#[derive(Clone, Debug)]
+pub struct MetadatumValue(Arc<Vec<u8>>);
+
+impl Decode<'_, ()> for MetadatumValue {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, _ctx: &mut (),
+    ) -> Result<Self, minicbor::decode::Error> {
+        // Get the start of the raw CBOR value we are going to extract.
+        let value_start = d.position();
+        if let Err(error) = d.skip() {
+            return Err(minicbor::decode::Error::message(format!(
+                "Error decoding Metadatum value: {error}"
+            )));
+        }
+        // Get the end of the raw value
+        let value_end = d.position();
+        let Some(value_slice) = d.input().get(value_start..value_end) else {
+            return Err(minicbor::decode::Error::message(
+                "Error decoding Metadatum value: Unable to extract raw value slice.",
+            ));
+        };
+
+        // Intentionally copy the data into a vec, so that we don't have any self-reference
+        // issues.
+        Ok(Self(Arc::new(value_slice.to_vec())))
+    }
+}
+
+impl AsRef<[u8]> for MetadatumValue {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/auxdata/mod.rs b/rust/cardano-blockchain-types/src/auxdata/mod.rs
new file mode 100644
index 000000000..7a0192b57
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/mod.rs
@@ -0,0 +1,12 @@
+//! Metadata decoding and validating.
+
+// We CAN NOT use the Pallas library metadata decoding because it does not preserve raw
+// metadata values which are critical for performing operations like signature checks on
+// data. So we have a bespoke metadata decoder here.
+
+pub mod aux_data;
+pub mod block;
+pub mod metadatum;
+pub mod metadatum_label;
+pub mod metadatum_value;
+pub mod scripts;
diff --git a/rust/cardano-blockchain-types/src/auxdata/scripts.rs b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
new file mode 100644
index 000000000..8109020c7
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/auxdata/scripts.rs
@@ -0,0 +1,127 @@
+//! Smart Contract types
+
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use dashmap::DashMap;
+
+/// Raw, Script
+#[derive(Clone, Default, Debug)]
+#[allow(dead_code)]
+pub struct Script(Arc<Vec<u8>>);
+
+impl minicbor::Decode<'_, ScriptType> for Script {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, ctx: &mut ScriptType,
+    ) -> Result<Self, minicbor::decode::Error> {
+        let script_type = *ctx;
+
+        if script_type == ScriptType::Native {
+            // Native Scripts are actually CBOR arrays, so capture their data as bytes for
+            // later processing.
+            // See: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L542-L560
+            let value_start = d.position();
+            if let Err(error) = d.skip() {
+                return Err(minicbor::decode::Error::message(format!(
+                    "Error decoding native script value:  {error}"
+                )));
+            }
+            let value_end = d.position();
+            let Some(value_slice) = d.input().get(value_start..value_end) else {
+                return Err(minicbor::decode::Error::message(
+                    "Invalid metadata value found. Unable to extract native script slice.",
+                ));
+            };
+            Ok(Self(Arc::new(value_slice.to_vec())))
+        } else {
+            // Plutus is encoded as a bytes string.  Extract the script contents.
+            // See: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L450-L452
+            let script = match d.bytes() {
+                Ok(script) => script,
+                Err(error) => {
+                    return Err(minicbor::decode::Error::message(format!(
+                        "Error decoding plutus script data: {error}"
+                    )))
+                },
+            };
+            Ok(Self(Arc::new(script.to_vec())))
+        }
+    }
+}
+
+/// Array of Scripts
+#[derive(Default, Clone, Debug)]
+#[allow(dead_code)]
+pub struct ScriptArray(Arc<Vec<Script>>);
+
+impl minicbor::Decode<'_, ScriptType> for ScriptArray {
+    fn decode(
+        d: &mut minicbor::Decoder<'_>, ctx: &mut ScriptType,
+    ) -> Result<Self, minicbor::decode::Error> {
+        let mut scripts: Vec<Script> = Vec::new();
+
+        // Scripts are encoded as arrays of scripts
+        // See: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L527-L530
+        // And: https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L524
+        let entries = match d.array() {
+            Ok(Some(entries)) => entries,
+            Ok(None) => {
+                return Err(minicbor::decode::Error::message(
+                    "Indefinite Script Array found decoding Metadata. Invalid.",
+                ));
+            },
+            Err(error) => {
+                let msg = Arc::new(format!("Error decoding script array: {error}"));
+                return Err(minicbor::decode::Error::message(&msg));
+            },
+        };
+
+        for _entry in 0..entries {
+            scripts.push(Script::decode(d, ctx)?);
+        }
+
+        Ok(Self(Arc::new(scripts)))
+    }
+}
+
+/// What type of smart contract is this list.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, strum::Display, Hash)]
+pub enum ScriptType {
+    /// Native smart contracts
+    Native,
+    /// Plutus smart contracts (with version number 1-x)
+    Plutus(u64),
+}
+
+impl TryFrom<u64> for ScriptType {
+    type Error = anyhow::Error;
+
+    fn try_from(value: u64) -> Result<Self, Self::Error> {
+        match value {
+            0 => Err(anyhow!("Invalid script type: {}", value)),
+            1 => Ok(Self::Native),
+            _ => Ok(Self::Plutus(value - 1)),
+        }
+    }
+}
+
+/// Scripts attached to a transaction
+#[derive(Clone, Debug)]
+#[allow(dead_code, clippy::module_name_repetitions)]
+pub struct TransactionScripts(Arc<dashmap::ReadOnlyView<ScriptType, ScriptArray>>);
+
+impl Default for TransactionScripts {
+    fn default() -> Self {
+        Self(Arc::new(DashMap::default().into_read_only()))
+    }
+}
+
+/// A Mutable version of the `TransactionScripts` because we need to build it iteratively
+/// and in different ways.
+pub(crate) type MutableTransactionScriptsMap = DashMap<ScriptType, ScriptArray>;
+
+impl From<MutableTransactionScriptsMap> for TransactionScripts {
+    fn from(scripts: MutableTransactionScriptsMap) -> Self {
+        Self(Arc::new(scripts.into_read_only()))
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/conversion.rs b/rust/cardano-blockchain-types/src/conversion.rs
new file mode 100644
index 000000000..820a50c67
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/conversion.rs
@@ -0,0 +1,55 @@
+//! Conversion functions
+
+use anyhow::bail;
+
+/// Convert an `<T>` to `<R>` (saturate if out of range).
+/// Note can convert any int to float, or f32 to f64 as well.
+/// can not convert from float to int, or f64 to f32.
+pub(crate) fn from_saturating<
+    R: Copy + num_traits::identities::Zero + num_traits::Bounded,
+    T: Copy
+        + TryInto<R>
+        + std::ops::Sub<Output = T>
+        + std::cmp::PartialOrd<T>
+        + num_traits::identities::Zero,
+>(
+    value: T,
+) -> R {
+    match value.try_into() {
+        Ok(value) => value,
+        Err(_) => {
+            // If we couldn't convert, its out of range for the destination type.
+            if value > T::zero() {
+                // If the number is positive, its out of range in the positive direction.
+                R::max_value()
+            } else {
+                // Otherwise its out of range in the negative direction.
+                R::min_value()
+            }
+        },
+    }
+}
+
+/// Try and convert a byte array into an ed25519 verifying key.
+///
+/// # Errors
+///
+/// Fails if the bytes are not a valid ED25519 Public Key
+pub fn vkey_from_bytes(bytes: &[u8]) -> anyhow::Result<ed25519_dalek::VerifyingKey> {
+    if bytes.len() != ed25519_dalek::PUBLIC_KEY_LENGTH {
+        bail!(
+            "Failed to convert bytes to ED25519 public key. Expected {} bytes, got {}",
+            ed25519_dalek::PUBLIC_KEY_LENGTH,
+            bytes.len()
+        );
+    }
+
+    let mut ed25519 = [0u8; ed25519_dalek::PUBLIC_KEY_LENGTH];
+    ed25519.copy_from_slice(bytes); // Can't panic because we already validated its size.
+
+    let pubkey = match ed25519_dalek::VerifyingKey::from_bytes(&ed25519) {
+        Ok(key) => key,
+        Err(err) => bail!("Failed to convert Ed25519 public key in SimplePublicKeyType {err}"),
+    };
+    Ok(pubkey)
+}
diff --git a/rust/cardano-blockchain-types/src/data/Readme.md b/rust/cardano-blockchain-types/src/data/Readme.md
new file mode 100644
index 000000000..f2012dfaa
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/data/Readme.md
@@ -0,0 +1,15 @@
+# Data files used by the Follower Crate
+
+## Mithril signature genesis keys
+
+These keys are required to validate mithril signatures for each respective Cardano network.
+
+| File | Network | Source |
+| --- | --- | --- |
+| `mainnet-genesis.vkey` | Main network. | [mainnet-genesis.vkey] |
+| `preprod-genesis.vkey` | Pre-production network. | [preprod-genesis.vkey] |
+| `preview-genesis.vkey` | Preview network. | [preview-genesis.vkey] |
+
+[mainnet-genesis.vkey]: https://raw.githubusercontent.com/input-output-hk/mithril/main/mithril-infra/configuration/release-mainnet/genesis.vkey
+[preprod-genesis.vkey]: https://raw.githubusercontent.com/input-output-hk/mithril/main/mithril-infra/configuration/release-preprod/genesis.vkey
+[preview-genesis.vkey]: https://raw.githubusercontent.com/input-output-hk/mithril/main/mithril-infra/configuration/pre-release-preview/genesis.vkey
diff --git a/rust/cardano-blockchain-types/src/data/mainnet-genesis.vkey b/rust/cardano-blockchain-types/src/data/mainnet-genesis.vkey
new file mode 100644
index 000000000..4bbe653ff
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/data/mainnet-genesis.vkey
@@ -0,0 +1 @@
+5b3139312c36362c3134302c3138352c3133382c31312c3233372c3230372c3235302c3134342c32372c322c3138382c33302c31322c38312c3135352c3230342c31302c3137392c37352c32332c3133382c3139362c3231372c352c31342c32302c35372c37392c33392c3137365d
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/src/data/preprod-genesis.vkey b/rust/cardano-blockchain-types/src/data/preprod-genesis.vkey
new file mode 100644
index 000000000..575154ce7
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/data/preprod-genesis.vkey
@@ -0,0 +1 @@
+5b3132372c37332c3132342c3136312c362c3133372c3133312c3231332c3230372c3131372c3139382c38352c3137362c3139392c3136322c3234312c36382c3132332c3131392c3134352c31332c3233322c3234332c34392c3232392c322c3234392c3230352c3230352c33392c3233352c34345d
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/src/data/preview-genesis.vkey b/rust/cardano-blockchain-types/src/data/preview-genesis.vkey
new file mode 100644
index 000000000..575154ce7
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/data/preview-genesis.vkey
@@ -0,0 +1 @@
+5b3132372c37332c3132342c3136312c362c3133372c3133312c3231332c3230372c3131372c3139382c38352c3137362c3139392c3136322c3234312c36382c3132332c3131392c3134352c31332c3233322c3234332c34392c3232392c322c3234392c3230352c3230352c33392c3233352c34345d
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/src/fork.rs b/rust/cardano-blockchain-types/src/fork.rs
new file mode 100644
index 000000000..d65a08196
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/fork.rs
@@ -0,0 +1,51 @@
+//! Fork count is a counter that is incremented every time there is a roll-back in
+//! live-chain It is used to help followers determine how far to roll-back to
+//! resynchronize without storing full block history. The fork count starts at 1 for live
+//! blocks and increments if the live chain tip is purged due to a detected fork, but it
+//! does not track the exact number of forks reported by peers.
+//!
+//! Note: This fork terminology is different from fork in blockchain.
+
+use crate::conversion::from_saturating;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd)]
+/// Counter that is incremented every time there is a roll-back in live-chain.
+pub struct Fork(u64);
+
+impl Fork {
+    /// Convert an `<T>` to `Fork` (saturate if out of range).
+    pub fn from_saturating<
+        T: Copy
+            + TryInto<u64>
+            + std::ops::Sub<Output = T>
+            + std::cmp::PartialOrd<T>
+            + num_traits::identities::Zero,
+    >(
+        value: T,
+    ) -> Self {
+        let value: u64 = from_saturating(value);
+        Self(value)
+    }
+
+    /// Increment the fork count.
+    pub fn incr(&mut self) {
+        self.0 = self.0.saturating_add(1);
+    }
+
+    /// Decrement the fork count.
+    pub fn decr(&mut self) {
+        self.0 = self.0.saturating_sub(1);
+    }
+}
+
+impl From<u64> for Fork {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Fork> for u64 {
+    fn from(val: Fork) -> Self {
+        val.0
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/hashes.rs b/rust/cardano-blockchain-types/src/hashes.rs
new file mode 100644
index 000000000..2baed74cc
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/hashes.rs
@@ -0,0 +1,144 @@
+//! Cardano hashing functions
+
+use std::{fmt, str::FromStr};
+
+use anyhow::bail;
+use blake2b_simd::Params;
+use pallas_crypto::hash::Hash;
+
+/// Number of bytes in a blake2b 224 hash.
+pub const BLAKE_2B224_SIZE: usize = 224 / 8;
+
+/// `Blake2B` 224bit Hash.
+pub type Blake2b224Hash = Blake2bHash<BLAKE_2B224_SIZE>;
+
+/// Number of bytes in a blake2b 256 hash.
+pub const BLAKE_2B256_SIZE: usize = 256 / 8;
+
+/// `Blake2B` 256bit Hash
+pub type Blake2b256Hash = Blake2bHash<BLAKE_2B256_SIZE>;
+
+/// Number of bytes in a blake2b 128 hash.
+pub const BLAKE_2B128_SIZE: usize = 128 / 8;
+
+/// `Blake2B` 128bit Hash
+pub type Blake2b128Hash = Blake2bHash<BLAKE_2B128_SIZE>;
+
+/// data that is a blake2b [`struct@Hash`] of `BYTES` long.
+///
+/// Possible values with Cardano are 32 bytes long (block hash or transaction
+/// hash). Or 28 bytes long (as used in addresses)
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Blake2bHash<const BYTES: usize>(Hash<BYTES>);
+
+impl<const BYTES: usize> Blake2bHash<BYTES> {
+    /// Create a new `Blake2bHash` from a slice of bytes by hashing them.
+    #[must_use]
+    pub fn new(input_bytes: &[u8]) -> Self {
+        let mut bytes: [u8; BYTES] = [0u8; BYTES];
+
+        // Generate a unique hash of the data.
+        let mut hasher = Params::new().hash_length(BYTES).to_state();
+
+        hasher.update(input_bytes);
+        let hash = hasher.finalize();
+
+        // Create a new array containing the first BYTES elements from the original array
+        bytes.copy_from_slice(hash.as_bytes());
+
+        bytes.into()
+    }
+}
+
+impl<const BYTES: usize> From<[u8; BYTES]> for Blake2bHash<BYTES> {
+    #[inline]
+    fn from(bytes: [u8; BYTES]) -> Self {
+        let hash: Hash<BYTES> = bytes.into();
+        hash.into()
+    }
+}
+
+impl<const BYTES: usize> From<Hash<BYTES>> for Blake2bHash<BYTES> {
+    #[inline]
+    fn from(bytes: Hash<BYTES>) -> Self {
+        Self(bytes)
+    }
+}
+
+impl<const BYTES: usize> From<Blake2bHash<BYTES>> for Vec<u8> {
+    fn from(val: Blake2bHash<BYTES>) -> Self {
+        val.0.to_vec()
+    }
+}
+
+/// Convert hash in a form of byte array into the `Blake2bHash` type.
+impl<const BYTES: usize> TryFrom<&[u8]> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if value.len() < BYTES {
+            bail!("Invalid input length");
+        }
+
+        let mut hash = [0; BYTES];
+        hash.copy_from_slice(value);
+        let hash: Hash<BYTES> = hash.into();
+        Ok(hash.into())
+    }
+}
+
+impl<const BYTES: usize> TryFrom<&Vec<u8>> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
+        value.as_slice().try_into()
+    }
+}
+
+impl<const BYTES: usize> TryFrom<Vec<u8>> for Blake2bHash<BYTES> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        value.as_slice().try_into()
+    }
+}
+
+impl<const BYTES: usize> fmt::Debug for Blake2bHash<BYTES> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("{:?}", self.0))
+    }
+}
+
+impl<const BYTES: usize> fmt::Display for Blake2bHash<BYTES> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("{}", self.0))
+    }
+}
+
+impl<const BYTES: usize> FromStr for Blake2bHash<BYTES> {
+    type Err = hex::FromHexError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let hash: Hash<BYTES> = s.parse()?;
+        Ok(hash.into())
+    }
+}
+
+impl<C, const BYTES: usize> minicbor::Encode<C> for Blake2bHash<BYTES> {
+    fn encode<W: minicbor::encode::Write>(
+        &self, e: &mut minicbor::Encoder<W>, _ctx: &mut C,
+    ) -> Result<(), minicbor::encode::Error<W::Error>> {
+        e.bytes(self.0.as_ref())?.ok()
+    }
+}
+
+impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Blake2bHash<BYTES> {
+    fn decode(
+        d: &mut minicbor::Decoder<'a>, _ctx: &mut C,
+    ) -> Result<Self, minicbor::decode::Error> {
+        let bytes = d.bytes()?;
+        bytes.try_into().map_err(|_| {
+            minicbor::decode::Error::message("Invalid hash size for Blake2bHash cbor decode")
+        })
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/lib.rs b/rust/cardano-blockchain-types/src/lib.rs
new file mode 100644
index 000000000..bfc4bff9f
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/lib.rs
@@ -0,0 +1,28 @@
+//! Catalyst Enhanced `MultiEraBlock` Structures
+
+mod auxdata;
+pub mod conversion;
+mod fork;
+pub mod hashes;
+mod multi_era_block_data;
+mod network;
+mod point;
+mod slot;
+mod txn_index;
+mod txn_witness;
+
+pub use auxdata::{
+    aux_data::TransactionAuxData,
+    block::BlockAuxData,
+    metadatum::Metadata,
+    metadatum_label::MetadatumLabel,
+    metadatum_value::MetadatumValue,
+    scripts::{Script, ScriptArray, ScriptType, TransactionScripts},
+};
+pub use fork::Fork;
+pub use multi_era_block_data::MultiEraBlock;
+pub use network::Network;
+pub use point::Point;
+pub use slot::Slot;
+pub use txn_index::TxnIndex;
+pub use txn_witness::{TxnWitness, VKeyHash};
diff --git a/rust/cardano-blockchain-types/src/multi_era_block_data.rs b/rust/cardano-blockchain-types/src/multi_era_block_data.rs
new file mode 100644
index 000000000..ee06c26fa
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/multi_era_block_data.rs
@@ -0,0 +1,754 @@
+//! Multi Era CBOR Encoded Block Data
+//!
+//! Data about how the block/transactions can be encoded is found here:
+//! <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl>
+//!
+//! DO NOT USE the documentation/cddl definitions from the head of this repo because it
+//! currently lacks most of the documentation needed to understand the format and is also
+//! incorrectly generated and contains errors that will be difficult to discern.
+
+use std::{cmp::Ordering, fmt::Display, sync::Arc};
+
+use anyhow::bail;
+use ed25519_dalek::VerifyingKey;
+use ouroboros::self_referencing;
+use tracing::debug;
+
+use crate::{
+    auxdata::{
+        block::BlockAuxData, metadatum_label::MetadatumLabel, metadatum_value::MetadatumValue,
+    },
+    fork::Fork,
+    network::Network,
+    point::Point,
+    txn_index::TxnIndex,
+    txn_witness::{TxnWitness, VKeyHash},
+};
+
+/// Self-referencing CBOR encoded data of a multi-era block.
+/// Note: The fields in the original struct can not be accessed directly
+/// The builder creates accessor methods which are called
+/// `borrow_raw_data()` and `borrow_block()`
+#[self_referencing]
+#[derive(Debug)]
+struct SelfReferencedMultiEraBlock {
+    /// The CBOR encoded data of a multi-era block.
+    raw_data: Vec<u8>,
+
+    /// The decoded multi-era block.
+    /// References the `raw_data` field.
+    #[borrows(raw_data)]
+    #[covariant]
+    block: pallas::ledger::traverse::MultiEraBlock<'this>,
+}
+
+/// Multi-era block - inner.
+#[derive(Debug)]
+struct MultiEraBlockInner {
+    /// What blockchain network was the block produced on.
+    network: Network,
+    /// The Point on the blockchain this block can be found.
+    point: Point,
+    /// The previous point on the blockchain before this block.
+    /// When the current point is Genesis, so is the previous.
+    previous: Point,
+    /// The decoded multi-era block.
+    data: SelfReferencedMultiEraBlock,
+    /// Decoded Metadata in the transactions in the block.
+    aux_data: BlockAuxData,
+    /// A map of public key hashes to the public key and transaction numbers they are in.
+    #[allow(dead_code)]
+    witness_map: Option<TxnWitness>,
+}
+
+/// Multi-era block.
+#[derive(Clone, Debug)]
+pub struct MultiEraBlock {
+    /// What fork is the block on?
+    /// This is NOT part of the inner block, because it is not to be protected by the Arc.
+    /// It can change at any time due to rollbacks detected on the live-chain.
+    /// This means that any holder of a `MultiEraBlock` will have the actual fork their
+    /// block was on when they read it, the live-chain code can modify the actual fork
+    /// count at any time without that impacting consumers processing the data.
+    /// The fork count itself is used so an asynchronous follower can properly work out
+    /// how far to roll back on the live-chain in order to resynchronize, without
+    /// keeping a full state of processed blocks.
+    /// Followers, simply need to step backwards on the live chain until they find the
+    /// previous block they followed, or reach a fork that is <= the fork of the
+    /// previous block they followed. They can then safely re-follow from that earlier
+    /// point, with full integrity. fork is 0 on any immutable block.
+    /// It starts at 1 for live blocks, and is only incremented if the live-chain tip is
+    /// purged because of a detected fork based on data received from the peer node.
+    /// It does NOT count the strict number of forks reported by the peer node.
+    fork: Fork,
+    /// The Immutable decoded data about the block itself.
+    inner: Arc<MultiEraBlockInner>,
+}
+
+impl MultiEraBlock {
+    /// Creates a new `MultiEraBlockData` from the given bytes.
+    ///
+    /// # Errors
+    ///
+    /// If the given bytes cannot be decoded as a multi-era block, an error is returned.
+    fn new_block(
+        network: Network, raw_data: Vec<u8>, previous: &Point, fork: Fork,
+    ) -> anyhow::Result<Self> {
+        let builder = SelfReferencedMultiEraBlockTryBuilder {
+            raw_data,
+            block_builder: |raw_data| -> Result<_, anyhow::Error> {
+                Ok(pallas::ledger::traverse::MultiEraBlock::decode(raw_data)?)
+            },
+        };
+        let self_ref_block = builder.try_build()?;
+        let decoded_block = self_ref_block.borrow_block();
+
+        let witness_map = TxnWitness::new(&decoded_block.txs()).ok();
+
+        let slot = decoded_block.slot();
+
+        let point = Point::new(slot.into(), decoded_block.hash().into());
+
+        let byron_block = matches!(
+            decoded_block,
+            pallas::ledger::traverse::MultiEraBlock::Byron(_)
+        );
+
+        // Validate that the Block point is valid.
+        if !previous.is_origin() {
+            // Every 21600 Blocks, Byron Era has duplicated sequential slot#'s.
+            // So this filters them out from the sequential point check.
+            // The Hash chain is still checked.
+            if (!byron_block || ((slot % 21600) != 0)) && *previous >= slot {
+                bail!("Previous slot is not less than current slot:{slot}");
+            }
+
+            // Special case, when the previous block is actually UNKNOWN, we can't check it.
+            if !previous.is_unknown()
+                    // Otherwise, we make sure the hash chain is intact
+                    && previous != &decoded_block.header().previous_hash()
+            {
+                debug!("{}, {:?}", previous, decoded_block.header().previous_hash());
+
+                bail!("Previous Block Hash mismatch with block");
+            }
+        }
+
+        let aux_data = decoded_block.try_into()?;
+
+        Ok(Self {
+            fork,
+            inner: Arc::new(MultiEraBlockInner {
+                network,
+                point,
+                previous: previous.clone(),
+                data: self_ref_block,
+                aux_data,
+                witness_map,
+            }),
+        })
+    }
+
+    /// Creates a new `MultiEraBlockData` from the given bytes.
+    ///
+    /// # Errors
+    ///
+    /// If the given bytes cannot be decoded as a multi-era block, an error is returned.
+    pub fn new(
+        network: Network, raw_data: Vec<u8>, previous: &Point, fork: Fork,
+    ) -> anyhow::Result<Self> {
+        MultiEraBlock::new_block(network, raw_data, previous, fork)
+    }
+
+    /// Remake the block on a new fork.
+    pub fn set_fork(&mut self, fork: Fork) {
+        self.fork = fork;
+    }
+
+    /// Decodes the data into a multi-era block.
+    ///
+    /// # Returns
+    ///
+    /// The decoded block data, which can easily be processed by a consumer.
+    #[must_use]
+    #[allow(clippy::missing_panics_doc)]
+    pub fn decode(&self) -> &pallas::ledger::traverse::MultiEraBlock {
+        self.inner.data.borrow_block()
+    }
+
+    /// Decodes the data into a multi-era block.
+    ///
+    /// # Returns
+    ///
+    /// The raw byte data of the block.
+    #[must_use]
+    #[allow(clippy::missing_panics_doc)]
+    pub fn raw(&self) -> &Vec<u8> {
+        self.inner.data.borrow_raw_data()
+    }
+
+    /// Returns the block point of this block.
+    ///
+    /// # Returns
+    ///
+    /// The block point of this block.
+    #[must_use]
+    pub fn point(&self) -> Point {
+        self.inner.point.clone()
+    }
+
+    /// Returns the block point of the previous block.
+    ///
+    /// # Returns
+    ///
+    /// The previous blocks `Point`
+    #[must_use]
+    pub fn previous(&self) -> Point {
+        self.inner.previous.clone()
+    }
+
+    /// Is the block data immutable on-chain.
+    ///
+    /// Immutable blocks are by-definition those that exist in the Mithril Snapshot
+    /// (Immutable Database) of the Node.
+    ///
+    /// # Returns
+    ///
+    /// `true` if the block is immutable, `false` otherwise.
+    #[must_use]
+    pub fn is_immutable(&self) -> bool {
+        self.fork == 0.into()
+    }
+
+    /// What fork is the block from.
+    ///
+    /// The fork is a synthetic number that represents how many rollbacks have been
+    /// detected in the running chain.  The fork is:
+    /// - 0 - for all immutable data;
+    /// - 1 - for any data read from the blockchain during a *backfill* on initial sync
+    /// - 2+ - for each subsequent rollback detected while reading live blocks.
+    ///
+    /// # Returns
+    ///
+    /// The fork the block was found on.
+    #[must_use]
+    pub fn fork(&self) -> Fork {
+        self.fork
+    }
+
+    /// What blockchain network was the block from
+    ///
+    /// # Returns
+    ///
+    /// - The network that this block originated on.
+    #[must_use]
+    pub fn network(&self) -> Network {
+        self.inner.network
+    }
+
+    /// Get The Metadata fora a transaction and known label from the block
+    ///
+    /// # Parameters
+    ///
+    /// - `txn_idx` - Index of the Transaction in the Block
+    /// - `label` - The label of the transaction
+    ///
+    /// # Returns
+    ///
+    /// - Metadata for the given label in the transaction.
+    /// - Or None if the label requested isn't present.
+    #[must_use]
+    pub fn txn_metadata(
+        &self, txn_idx: TxnIndex, label: MetadatumLabel,
+    ) -> Option<&MetadatumValue> {
+        let txn = self.inner.aux_data.get(txn_idx)?;
+        txn.metadata(label)
+    }
+
+    /// Returns the witness map for the block.
+    pub(crate) fn witness_map(&self) -> Option<&TxnWitness> {
+        self.inner.witness_map.as_ref()
+    }
+
+    /// If the witness exists for a given transaction then return its public key.
+    #[must_use]
+    pub fn witness_for_tx(&self, vkey_hash: &VKeyHash, tx_num: TxnIndex) -> Option<VerifyingKey> {
+        if let Some(witnesses) = self.witness_map() {
+            if witnesses.check_witness_in_tx(vkey_hash, tx_num) {
+                return witnesses.get_witness_vkey(vkey_hash);
+            }
+        }
+
+        None
+    }
+}
+
+impl Display for MultiEraBlock {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let fork = self.fork;
+        let block_data = &self.inner.data;
+        let block = block_data.borrow_block();
+        let block_number = block.number();
+        let slot = block.slot();
+        let size = block.size();
+        let txns = block.tx_count();
+        let aux_data = block.has_aux_data();
+
+        let fork = if self.is_immutable() {
+            "Immutable".to_string()
+        } else {
+            format!("Fork: {fork:?}")
+        };
+
+        let block_era = match block {
+            pallas::ledger::traverse::MultiEraBlock::EpochBoundary(_) => {
+                "Byron Epoch Boundary".to_string()
+            },
+            pallas::ledger::traverse::MultiEraBlock::AlonzoCompatible(_, era) => {
+                format!("{era}")
+            },
+            pallas::ledger::traverse::MultiEraBlock::Babbage(_) => "Babbage".to_string(),
+            pallas::ledger::traverse::MultiEraBlock::Byron(_) => "Byron".to_string(),
+            pallas::ledger::traverse::MultiEraBlock::Conway(_) => "Conway".to_string(),
+            _ => "Unknown".to_string(),
+        };
+        write!(f, "{block_era} block : {}, Previous {} : Slot# {slot} : {fork} : Block# {block_number} : Size {size} : Txns {txns} : AuxData? {aux_data}",
+    self.point(), self.previous())?;
+        Ok(())
+    }
+}
+
+impl PartialEq for MultiEraBlock {
+    /// Compare two `MultiEraBlock` by their current points.
+    /// Ignores the Hash, we only check for equality of the Slot#.
+    fn eq(&self, other: &Self) -> bool {
+        self.partial_cmp(other) == Some(Ordering::Equal)
+    }
+}
+
+impl Eq for MultiEraBlock {}
+
+impl PartialOrd for MultiEraBlock {
+    /// Compare two `MultiEraBlock` by their points.
+    /// Only checks the Slot#.
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MultiEraBlock {
+    /// Compare two `LiveBlocks` by their points.
+    /// Only checks the Slot#.
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.inner.point.cmp(&other.inner.point)
+    }
+}
+
+// Allows us to compare a MultiEraBlock against a Point directly (Just the slot#).
+impl PartialEq<Point> for MultiEraBlock {
+    // Equality ONLY checks the Slot#
+    fn eq(&self, other: &Point) -> bool {
+        Some(Ordering::Equal) == self.partial_cmp(other)
+    }
+}
+
+impl PartialOrd<Point> for MultiEraBlock {
+    /// Compare a `MultiEraBlock` to a `Point` by their points.
+    /// Only checks the Slot#.
+    fn partial_cmp(&self, other: &Point) -> Option<Ordering> {
+        Some(self.inner.point.cmp(other))
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use std::ops::Add;
+
+    use anyhow::Ok;
+
+    use crate::{multi_era_block_data::MultiEraBlock, network::Network, point::Point};
+
+    struct TestRecord {
+        raw: Vec<u8>,
+        previous: Point,
+    }
+
+    /// Byron Test Block data
+    fn byron_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/byron.block"))
+            .expect("Failed to decode hex block.")
+    }
+
+    /// Shelley Test Block data
+    fn shelley_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/shelley.block"))
+            .expect("Failed to decode hex block.")
+    }
+
+    /// Mary Test Block data
+    fn mary_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/mary.block")).expect("Failed to decode hex block.")
+    }
+
+    /// Allegra Test Block data
+    fn allegra_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/allegra.block"))
+            .expect("Failed to decode hex block.")
+    }
+
+    /// Alonzo Test Block data
+    pub(crate) fn alonzo_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/allegra.block"))
+            .expect("Failed to decode hex block.")
+    }
+
+    /// Babbage Test Block data
+    pub(crate) fn babbage_block() -> Vec<u8> {
+        hex::decode(include_str!("./../test_data/babbage.block"))
+            .expect("Failed to decode hex block.")
+    }
+
+    /// An array of test blocks
+    fn test_blocks() -> Vec<TestRecord> {
+        vec![
+            TestRecord {
+                raw: byron_block(),
+                previous: Point::ORIGIN,
+            },
+            TestRecord {
+                raw: shelley_block(),
+                previous: Point::ORIGIN,
+            },
+            TestRecord {
+                raw: mary_block(),
+                previous: Point::ORIGIN,
+            },
+            TestRecord {
+                raw: allegra_block(),
+                previous: Point::ORIGIN,
+            },
+            TestRecord {
+                raw: alonzo_block(),
+                previous: Point::ORIGIN,
+            },
+        ]
+    }
+
+    // Gets sorted by slot number from highest to lowest
+    fn sorted_test_blocks() -> Vec<Vec<u8>> {
+        vec![
+            mary_block(),    // 27388606
+            allegra_block(), // 18748707
+            alonzo_block(),  // 18748707
+            shelley_block(), // 7948610
+            byron_block(),   // 3241381
+        ]
+    }
+
+    /// Previous Point slot is >= blocks point, but hash is correct (should fail)
+    #[test]
+    fn test_multi_era_block_point_compare_1() -> anyhow::Result<()> {
+        for (i, test_block) in test_blocks().into_iter().enumerate() {
+            let pallas_block =
+                pallas::ledger::traverse::MultiEraBlock::decode(test_block.raw.as_slice())?;
+
+            let previous_point = Point::new(
+                pallas_block.slot().add(i as u64).into(),
+                pallas_block
+                    .header()
+                    .previous_hash()
+                    .expect("cannot get previous hash")
+                    .into(),
+            );
+
+            let block = MultiEraBlock::new(
+                Network::Preprod,
+                test_block.raw.clone(),
+                &previous_point,
+                1.into(),
+            );
+
+            assert!(block.is_err());
+            assert!(block
+                .unwrap_err()
+                .to_string()
+                .contains("Previous slot is not less than current slot"));
+        }
+
+        Ok(())
+    }
+
+    /// Previous Point slot is < blocks point, but hash is different. (should fail).
+    #[test]
+    fn test_multi_era_block_point_compare_2() -> anyhow::Result<()> {
+        for test_block in test_blocks() {
+            let pallas_block =
+                pallas::ledger::traverse::MultiEraBlock::decode(test_block.raw.as_slice())?;
+
+            let previous_point =
+                Point::new((pallas_block.slot() - 1).into(), vec![0; 32].try_into()?);
+
+            let block = MultiEraBlock::new(
+                Network::Preprod,
+                test_block.raw.clone(),
+                &previous_point,
+                1.into(),
+            );
+
+            assert!(block.is_err());
+        }
+
+        Ok(())
+    }
+
+    /// Previous Point slot is < blocks point, and hash is also correct. (should pass).
+    #[test]
+    fn test_multi_era_block_point_compare_3() -> anyhow::Result<()> {
+        for test_block in test_blocks() {
+            let pallas_block =
+                pallas::ledger::traverse::MultiEraBlock::decode(test_block.raw.as_slice())?;
+
+            let previous_point = Point::new(
+                (pallas_block.slot() - 1).into(),
+                pallas_block
+                    .header()
+                    .previous_hash()
+                    .expect("cannot get previous hash")
+                    .into(),
+            );
+
+            let block = MultiEraBlock::new(
+                Network::Preprod,
+                test_block.raw.clone(),
+                &previous_point,
+                1.into(),
+            )?;
+
+            assert_eq!(block.decode().hash(), pallas_block.hash());
+        }
+
+        Ok(())
+    }
+
+    fn mk_test_blocks() -> Vec<MultiEraBlock> {
+        let raw_blocks = sorted_test_blocks();
+        raw_blocks
+            .iter()
+            .map(|block| {
+                let prev_point = pallas::ledger::traverse::MultiEraBlock::decode(block.as_slice())
+                    .map(|block| {
+                        Point::new(
+                            (block.slot() - 1).into(),
+                            block
+                                .header()
+                                .previous_hash()
+                                .expect("cannot get previous hash")
+                                .into(),
+                        )
+                    })
+                    .expect("cannot create point");
+
+                MultiEraBlock::new(Network::Preprod, block.clone(), &prev_point, 1.into())
+                    .expect("cannot create multi-era block")
+            })
+            .collect()
+    }
+
+    fn mk_test_points() -> Vec<Point> {
+        let raw_blocks = sorted_test_blocks();
+        raw_blocks
+            .iter()
+            .map(|block| {
+                pallas::ledger::traverse::MultiEraBlock::decode(block.as_slice())
+                    .map(|block| {
+                        Point::new(
+                            block.slot().into(),
+                            block
+                                .header()
+                                .previous_hash()
+                                .expect("cannot get previous hash")
+                                .into(),
+                        )
+                    })
+                    .expect("cannot create point")
+            })
+            .collect()
+    }
+
+    /// Compares between blocks using comparison operators
+    #[test]
+    fn test_multi_era_block_point_compare_4() -> anyhow::Result<()> {
+        let multi_era_blocks = mk_test_blocks();
+
+        let mary_block = multi_era_blocks.first().expect("cannot get block");
+        let allegra_block = multi_era_blocks.get(1).expect("cannot get block");
+        let alonzo_block = multi_era_blocks.get(2).expect("cannot get block");
+        let shelley_block = multi_era_blocks.get(3).expect("cannot get block");
+        let byron_block = multi_era_blocks.get(4).expect("cannot get block");
+
+        assert!(mary_block > allegra_block);
+        assert!(mary_block >= allegra_block);
+        assert!(mary_block != allegra_block);
+        assert!(mary_block > alonzo_block);
+        assert!(mary_block >= alonzo_block);
+        assert!(mary_block != alonzo_block);
+        assert!(mary_block > shelley_block);
+        assert!(mary_block >= shelley_block);
+        assert!(mary_block != shelley_block);
+        assert!(mary_block > byron_block);
+        assert!(mary_block >= byron_block);
+
+        assert!(allegra_block < mary_block);
+        assert!(allegra_block <= mary_block);
+        assert!(allegra_block != mary_block);
+        assert!(allegra_block == alonzo_block);
+        assert!(allegra_block >= alonzo_block);
+        assert!(allegra_block <= alonzo_block);
+        assert!(allegra_block > shelley_block);
+        assert!(allegra_block >= shelley_block);
+        assert!(allegra_block != shelley_block);
+        assert!(allegra_block > byron_block);
+        assert!(allegra_block >= byron_block);
+        assert!(allegra_block != byron_block);
+
+        assert!(alonzo_block < mary_block);
+        assert!(alonzo_block <= mary_block);
+        assert!(alonzo_block != mary_block);
+        assert!(alonzo_block == allegra_block);
+        assert!(alonzo_block >= allegra_block);
+        assert!(alonzo_block <= allegra_block);
+        assert!(alonzo_block > shelley_block);
+        assert!(alonzo_block >= shelley_block);
+        assert!(alonzo_block != shelley_block);
+        assert!(alonzo_block > byron_block);
+        assert!(alonzo_block >= byron_block);
+        assert!(alonzo_block != byron_block);
+
+        assert!(shelley_block < mary_block);
+        assert!(shelley_block <= mary_block);
+        assert!(shelley_block != mary_block);
+        assert!(shelley_block < allegra_block);
+        assert!(shelley_block <= allegra_block);
+        assert!(shelley_block != allegra_block);
+        assert!(shelley_block < alonzo_block);
+        assert!(shelley_block <= alonzo_block);
+        assert!(shelley_block != alonzo_block);
+        assert!(shelley_block > byron_block);
+        assert!(shelley_block >= byron_block);
+        assert!(shelley_block != byron_block);
+
+        assert!(byron_block < mary_block);
+        assert!(byron_block <= mary_block);
+        assert!(byron_block != mary_block);
+        assert!(byron_block < allegra_block);
+        assert!(byron_block <= allegra_block);
+        assert!(byron_block != allegra_block);
+        assert!(byron_block < alonzo_block);
+        assert!(byron_block <= alonzo_block);
+        assert!(byron_block != alonzo_block);
+        assert!(byron_block < shelley_block);
+        assert!(byron_block <= shelley_block);
+        assert!(byron_block != shelley_block);
+
+        Ok(())
+    }
+
+    /// Compares between blocks and points using comparison operators
+    #[test]
+    fn test_multi_era_block_point_compare_5() -> anyhow::Result<()> {
+        let points = mk_test_points();
+        let blocks = mk_test_blocks();
+
+        let mary_block = blocks.first().expect("cannot get block");
+        let allegra_block = blocks.get(1).expect("cannot get block");
+        let alonzo_block = blocks.get(2).expect("cannot get block");
+        let shelley_block = blocks.get(3).expect("cannot get block");
+        let byron_block = blocks.get(4).expect("cannot get block");
+
+        let mary_point = points.first().expect("cannot get point");
+        let allegra_point = points.get(1).expect("cannot get point");
+        let alonzo_point = points.get(2).expect("cannot get point");
+        let shelley_point = points.get(3).expect("cannot get point");
+        let byron_point = points.get(4).expect("cannot get point");
+
+        assert!(mary_block > allegra_point);
+        assert!(mary_block >= allegra_point);
+        assert!(mary_block != allegra_point);
+        assert!(mary_block > alonzo_point);
+        assert!(mary_block >= alonzo_point);
+        assert!(mary_block != alonzo_point);
+        assert!(mary_block > shelley_point);
+        assert!(mary_block >= shelley_point);
+        assert!(mary_block != shelley_point);
+        assert!(mary_block > byron_point);
+        assert!(mary_block >= byron_point);
+
+        assert!(allegra_block < mary_point);
+        assert!(allegra_block <= mary_point);
+        assert!(allegra_block != mary_point);
+        assert!(allegra_block == alonzo_point);
+        assert!(allegra_block >= alonzo_point);
+        assert!(allegra_block <= alonzo_point);
+        assert!(allegra_block > shelley_point);
+        assert!(allegra_block >= shelley_point);
+        assert!(allegra_block != shelley_point);
+        assert!(allegra_block > byron_point);
+        assert!(allegra_block >= byron_point);
+        assert!(allegra_block != byron_point);
+
+        assert!(alonzo_block < mary_point);
+        assert!(alonzo_block <= mary_point);
+        assert!(alonzo_block != mary_point);
+        assert!(alonzo_block == allegra_point);
+        assert!(alonzo_block >= allegra_point);
+        assert!(alonzo_block <= allegra_point);
+        assert!(alonzo_block > shelley_point);
+        assert!(alonzo_block >= shelley_point);
+        assert!(alonzo_block != shelley_point);
+        assert!(alonzo_block > byron_point);
+        assert!(alonzo_block >= byron_point);
+        assert!(alonzo_block != byron_point);
+
+        assert!(shelley_block < mary_point);
+        assert!(shelley_block <= mary_point);
+        assert!(shelley_block != mary_point);
+        assert!(shelley_block < allegra_point);
+        assert!(shelley_block <= allegra_point);
+        assert!(shelley_block != allegra_point);
+        assert!(shelley_block < alonzo_point);
+        assert!(shelley_block <= alonzo_point);
+        assert!(shelley_block != alonzo_point);
+        assert!(shelley_block > byron_point);
+        assert!(shelley_block >= byron_point);
+        assert!(shelley_block != byron_point);
+
+        assert!(byron_block < mary_point);
+        assert!(byron_block <= mary_point);
+        assert!(byron_block != mary_point);
+        assert!(byron_block < allegra_point);
+        assert!(byron_block <= allegra_point);
+        assert!(byron_block != allegra_point);
+        assert!(byron_block < alonzo_point);
+        assert!(byron_block <= alonzo_point);
+        assert!(byron_block != alonzo_point);
+        assert!(byron_block < shelley_point);
+        assert!(byron_block <= shelley_point);
+        assert!(byron_block != shelley_point);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_multi_era_block_with_origin_point() {
+        for test_block in test_blocks() {
+            let block = MultiEraBlock::new(
+                Network::Preprod,
+                test_block.raw.clone(),
+                &test_block.previous,
+                1.into(),
+            );
+
+            assert!(block.is_ok());
+        }
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/network.rs b/rust/cardano-blockchain-types/src/network.rs
new file mode 100644
index 000000000..95b9d47cb
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/network.rs
@@ -0,0 +1,404 @@
+//! Enum of possible Cardano networks.
+
+use std::{ffi::OsStr, path::PathBuf};
+
+use chrono::{DateTime, Utc};
+use pallas::{
+    ledger::traverse::wellknown::GenesisValues,
+    network::miniprotocols::{MAINNET_MAGIC, PREVIEW_MAGIC, PRE_PRODUCTION_MAGIC},
+};
+// use strum::IntoEnumIterator;
+// use strum_macros;
+use tracing::debug;
+
+use crate::{conversion::from_saturating, Slot};
+
+/// Default name of the executable if we can't derive it.
+pub(crate) const DEFAULT_EXE_NAME: &str = "cardano_chain_follower";
+/// ENV VAR name for the data path.
+pub(crate) const ENVVAR_MITHRIL_DATA_PATH: &str = "MITHRIL_DATA_PATH";
+/// ENV VAR name for the executable name.
+pub(crate) const ENVVAR_MITHRIL_EXE_NAME: &str = "MITHRIL_EXE_NAME";
+
+/// Enum of possible Cardano networks.
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    strum::EnumIter,
+    strum::VariantNames,
+    strum::EnumString,
+    strum::Display,
+)]
+#[strum(ascii_case_insensitive)]
+pub enum Network {
+    /// Cardano mainnet network.
+    Mainnet,
+    /// Cardano pre-production network.
+    Preprod,
+    /// Cardano preview network.
+    Preview,
+}
+
+// Mainnet Defaults.
+/// Mainnet Default Public Cardano Relay.
+const DEFAULT_MAINNET_RELAY: &str = "backbone.cardano.iog.io:3001";
+/// Main-net Mithril Signature genesis vkey.
+const DEFAULT_MAINNET_MITHRIL_GENESIS_KEY: &str = include_str!("data/mainnet-genesis.vkey");
+/// Default Mithril Aggregator to use.
+const DEFAULT_MAINNET_MITHRIL_AGGREGATOR: &str =
+    "https://aggregator.release-mainnet.api.mithril.network/aggregator";
+
+// Preprod Defaults
+/// Preprod Default Public Cardano Relay.
+const DEFAULT_PREPROD_RELAY: &str = "preprod-node.play.dev.cardano.org:3001";
+/// Preprod network Mithril Signature genesis vkey.
+const DEFAULT_PREPROD_MITHRIL_GENESIS_KEY: &str = include_str!("data/preprod-genesis.vkey");
+/// Default Mithril Aggregator to use.
+const DEFAULT_PREPROD_MITHRIL_AGGREGATOR: &str =
+    "https://aggregator.release-preprod.api.mithril.network/aggregator";
+
+// Preview Defaults
+/// Preview Default Public Cardano Relay.
+const DEFAULT_PREVIEW_RELAY: &str = "preview-node.play.dev.cardano.org:3001";
+/// Preview network Mithril Signature genesis vkey.
+const DEFAULT_PREVIEW_MITHRIL_GENESIS_KEY: &str = include_str!("data/preview-genesis.vkey");
+/// Default Mithril Aggregator to use.
+const DEFAULT_PREVIEW_MITHRIL_AGGREGATOR: &str =
+    "https://aggregator.pre-release-preview.api.mithril.network/aggregator";
+
+impl Network {
+    /// Get the default Relay for a blockchain network.
+    #[must_use]
+    pub fn default_relay(self) -> String {
+        match self {
+            Network::Mainnet => DEFAULT_MAINNET_RELAY.to_string(),
+            Network::Preprod => DEFAULT_PREPROD_RELAY.to_string(),
+            Network::Preview => DEFAULT_PREVIEW_RELAY.to_string(),
+        }
+    }
+
+    /// Get the default aggregator for a blockchain.
+    #[must_use]
+    pub fn default_mithril_aggregator(self) -> String {
+        match self {
+            Network::Mainnet => DEFAULT_MAINNET_MITHRIL_AGGREGATOR.to_string(),
+            Network::Preprod => DEFAULT_PREPROD_MITHRIL_AGGREGATOR.to_string(),
+            Network::Preview => DEFAULT_PREVIEW_MITHRIL_AGGREGATOR.to_string(),
+        }
+    }
+
+    /// Get the default Mithril Signature genesis key for a blockchain.
+    #[must_use]
+    pub fn default_mithril_genesis_key(self) -> String {
+        match self {
+            Network::Mainnet => DEFAULT_MAINNET_MITHRIL_GENESIS_KEY.to_string(),
+            Network::Preprod => DEFAULT_PREPROD_MITHRIL_GENESIS_KEY.to_string(),
+            Network::Preview => DEFAULT_PREVIEW_MITHRIL_GENESIS_KEY.to_string(),
+        }
+    }
+
+    /// Get the default storage location for mithril snapshots.
+    /// Defaults to: `<platform data_local_dir>/<exe name>/mithril/<network>`
+    pub fn default_mithril_path(self) -> PathBuf {
+        // Get the base path for storing Data.
+        // IF the ENV var is set, use that.
+        // Otherwise use the system default data path for an application.
+        // All else fails default to "/var/lib"
+        let mut base_path = std::env::var(ENVVAR_MITHRIL_DATA_PATH).map_or_else(
+            |_| dirs::data_local_dir().unwrap_or("/var/lib".into()),
+            PathBuf::from,
+        );
+
+        // Get the Executable name for the data path.
+        // IF the ENV var is set, use it, otherwise try and get it from the exe itself.
+        // Fallback to using a default exe name if all else fails.
+        let exe_name = std::env::var(ENVVAR_MITHRIL_EXE_NAME).unwrap_or(
+            std::env::current_exe()
+                .unwrap_or(DEFAULT_EXE_NAME.into())
+                .file_name()
+                .unwrap_or(OsStr::new(DEFAULT_EXE_NAME))
+                .to_string_lossy()
+                .to_string(),
+        );
+
+        // <base path>/<exe name>
+        base_path.push(exe_name);
+
+        // Put everything in a `mithril` sub directory.
+        base_path.push("mithril");
+
+        // <base path>/<exe name>/<network>
+        base_path.push(self.to_string());
+
+        debug!(
+            chain = self.to_string(),
+            path = base_path.to_string_lossy().to_string(),
+            "DEFAULT Mithril Data Path",
+        );
+
+        // Return the final path
+        base_path
+    }
+
+    /// Return genesis values for given network
+    #[must_use]
+    pub fn genesis_values(self) -> GenesisValues {
+        match self {
+            Network::Mainnet => GenesisValues::mainnet(),
+            Network::Preprod => GenesisValues::preprod(),
+            Network::Preview => GenesisValues::preview(),
+        }
+    }
+
+    /// Convert a given slot# to its Wall Time for a Blockchain network.
+    #[must_use]
+    pub fn slot_to_time(self, slot: Slot) -> DateTime<Utc> {
+        let genesis = self.genesis_values();
+        let wall_clock = genesis.slot_to_wallclock(slot.into());
+
+        let raw_time: i64 = wall_clock.try_into().unwrap_or(i64::MAX);
+        DateTime::from_timestamp(raw_time, 0).unwrap_or(DateTime::<Utc>::MAX_UTC)
+    }
+
+    /// Convert an arbitrary time to a slot.
+    ///
+    /// If the given time predates the blockchain, will return None.
+    ///
+    /// The Slot does not have to be a valid slot present in the blockchain.
+    #[must_use]
+    pub fn time_to_slot(self, time: DateTime<Utc>) -> Option<Slot> {
+        let genesis = self.genesis_values();
+
+        let byron_start_time =
+            DateTime::<Utc>::from_timestamp(from_saturating(genesis.byron_known_time), 0)?;
+        let shelley_start_time =
+            DateTime::<Utc>::from_timestamp(from_saturating(genesis.shelley_known_time), 0)?;
+
+        // determine if the given time is in Byron or Shelley era.
+        if time < byron_start_time {
+            return None;
+        }
+
+        let (elapsed_slots, era_known_slot) = if time < shelley_start_time {
+            // Byron era
+            let time_diff = time - byron_start_time;
+            (
+                time_diff.num_seconds() / i64::from(genesis.byron_slot_length),
+                genesis.byron_known_slot,
+            )
+        } else {
+            // Shelley era
+            let time_diff = time - shelley_start_time;
+            (
+                time_diff.num_seconds() / i64::from(genesis.shelley_slot_length),
+                genesis.shelley_known_slot,
+            )
+        };
+
+        let era_known_slot = i64::try_from(era_known_slot).ok()?;
+
+        Some(Slot::from_saturating(elapsed_slots + era_known_slot))
+    }
+}
+
+impl From<Network> for u64 {
+    fn from(network: Network) -> Self {
+        match network {
+            Network::Mainnet => MAINNET_MAGIC,
+            Network::Preprod => PRE_PRODUCTION_MAGIC,
+            Network::Preview => PREVIEW_MAGIC,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use anyhow::Ok;
+    use chrono::{TimeZone, Utc};
+
+    use super::*;
+
+    #[test]
+    fn test_from_str() -> anyhow::Result<()> {
+        let mainnet = Network::from_str("mainnet")?;
+        let preprod = Network::from_str("preprod")?;
+        let preview = Network::from_str("preview")?;
+
+        assert_eq!(mainnet, Network::Mainnet);
+        assert_eq!(preprod, Network::Preprod);
+        assert_eq!(preview, Network::Preview);
+
+        let mainnet = Network::from_str("Mainnet")?;
+        let preprod = Network::from_str("Preprod")?;
+        let preview = Network::from_str("Preview")?;
+
+        assert_eq!(mainnet, Network::Mainnet);
+        assert_eq!(preprod, Network::Preprod);
+        assert_eq!(preview, Network::Preview);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_time_to_slot_before_blockchain() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let before_blockchain = Utc
+            .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap() - 1, 0)
+            .unwrap();
+
+        assert_eq!(network.time_to_slot(before_blockchain), None);
+    }
+
+    #[test]
+    fn test_time_to_slot_byron_era() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let byron_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap(), 0)
+            .unwrap();
+        let byron_slot_length = i64::from(genesis.byron_slot_length);
+
+        // a time in the middle of the Byron era.
+        let time = byron_start_time + chrono::Duration::seconds(byron_slot_length * 100);
+        let expected_slot = Slot::from_saturating(genesis.byron_known_slot + 100);
+
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
+
+    #[test]
+    fn test_time_to_slot_transition_to_shelley() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let shelley_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.shelley_known_time).unwrap(), 0)
+            .unwrap();
+        let byron_slot_length = i64::from(genesis.byron_slot_length);
+
+        // a time just before Shelley era starts.
+        let time = shelley_start_time - chrono::Duration::seconds(1);
+        let elapsed_slots = (time
+            - Utc
+                .timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap(), 0)
+                .unwrap())
+        .num_seconds()
+            / byron_slot_length;
+        let expected_slot = Slot::from_saturating(
+            genesis.byron_known_slot + from_saturating::<u64, i64>(elapsed_slots),
+        );
+
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
+
+    #[test]
+    fn test_time_to_slot_shelley_era() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        let shelley_start_time = Utc
+            .timestamp_opt(i64::try_from(genesis.shelley_known_time).unwrap(), 0)
+            .unwrap();
+        let shelley_slot_length = i64::from(genesis.shelley_slot_length);
+
+        // a time in the middle of the Shelley era.
+        let time = shelley_start_time + chrono::Duration::seconds(shelley_slot_length * 200);
+        let expected_slot = Slot::from_saturating(genesis.shelley_known_slot + 200);
+
+        assert_eq!(network.time_to_slot(time), Some(expected_slot));
+    }
+
+    #[test]
+    fn test_slot_to_time_to_slot_consistency() {
+        let network = Network::Mainnet;
+
+        // a few arbitrary slots in different ranges.
+        let slots_to_test = vec![0, 10_000, 1_000_000, 50_000_000];
+
+        for slot in slots_to_test {
+            let time = network.slot_to_time(slot.into());
+            let calculated_slot = network.time_to_slot(time);
+
+            assert_eq!(
+                calculated_slot,
+                Some(Slot::from_saturating(slot)),
+                "Failed for slot: {slot}"
+            );
+        }
+    }
+
+    #[test]
+    #[allow(clippy::panic)]
+    fn test_time_to_slot_to_time_consistency() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        // Byron, Shelley, and Conway.
+        let times_to_test = vec![
+            Utc.timestamp_opt(i64::try_from(genesis.byron_known_time).unwrap() + 100, 0)
+                .unwrap(),
+            Utc.timestamp_opt(
+                i64::try_from(genesis.shelley_known_time).unwrap() + 1_000,
+                0,
+            )
+            .unwrap(),
+            Utc.timestamp_opt(
+                i64::try_from(genesis.shelley_known_time).unwrap() + 10_000_000,
+                0,
+            )
+            .unwrap(),
+        ];
+
+        for time in times_to_test {
+            if let Some(slot) = network.time_to_slot(time) {
+                let calculated_time = network.slot_to_time(slot);
+
+                assert_eq!(
+                    calculated_time.timestamp(),
+                    time.timestamp(),
+                    "Failed for time: {time}"
+                );
+            } else {
+                panic!("time_to_slot returned None for a valid time: {time}");
+            }
+        }
+    }
+
+    #[test]
+    fn test_conway_era_time_to_slot_and_back() {
+        let network = Network::Mainnet;
+        let genesis = network.genesis_values();
+
+        // a very late time, far in the Conway era.
+        let conway_time = Utc
+            .timestamp_opt(
+                i64::try_from(genesis.shelley_known_time).unwrap() + 20_000_000,
+                0,
+            )
+            .unwrap();
+
+        let slot = network.time_to_slot(conway_time);
+        assert!(
+            slot.is_some(),
+            "Failed to calculate slot for Conway era time"
+        );
+
+        let calculated_time = network.slot_to_time(slot.unwrap());
+
+        assert_eq!(
+            calculated_time.timestamp(),
+            conway_time.timestamp(),
+            "Inconsistency for Conway era time"
+        );
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/point.rs b/rust/cardano-blockchain-types/src/point.rs
new file mode 100644
index 000000000..d2d391459
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/point.rs
@@ -0,0 +1,580 @@
+//! A Cardano Point on the Blockchain.
+//!
+//! Wrapped version of the Pallas primitive.
+//! We only use this version unless talking to Pallas.
+
+use std::{
+    cmp::Ordering,
+    fmt::{Debug, Display, Formatter},
+};
+
+use pallas::crypto::hash::Hash;
+
+use crate::{hashes::Blake2b256Hash, Slot};
+
+/// A specific point in the blockchain. It can be used to
+/// identify a particular location within the blockchain, such as the tip (the
+/// most recent block) or any other block. It has special kinds of `Point`,
+/// available as constants: `TIP`, and `ORIGIN`.
+///
+/// # Attributes
+///
+/// * `Point` - The inner type is a `Point` from the `pallas::network::miniprotocols`
+///   module. This inner `Point` type encapsulates the specific details required to
+///   identify a point in the blockchain.
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Point(pallas::network::miniprotocols::Point);
+
+impl Point {
+    /// The origin of the blockchain. It is used when the
+    /// interest is in the very first point of the blockchain, regardless of its
+    /// specific details.
+    ///
+    /// # Usage
+    ///
+    /// `ORIGIN` can be used in scenarios where the starting point of the
+    /// blockchain is required. It signifies the genesis block or the initial state
+    /// of the blockchain.
+    ///
+    /// The inner `Point` is created with the `Origin` variant from
+    /// `pallas::network::miniprotocols::Point`, indicating that this is a marker
+    /// for the blockchain's origin.
+    pub const ORIGIN: Point = Point(pallas::network::miniprotocols::Point::Origin);
+    /// The tip of the blockchain at the current moment.
+    /// It is used when the specific point in the blockchain is not known, but the
+    /// interest is in the most recent block (the tip). The tip is the point where
+    /// new blocks are being added.
+    ///
+    /// # Usage
+    ///
+    /// `TIP` can be used in scenarios where the most up-to-date point in the
+    /// blockchain is required. It signifies that the exact point is not important
+    /// as long as it is the latest available point in the chain.
+    ///
+    /// The inner `Point` is created with `u64::MAX` and an empty `Vec<u8>`, indicating
+    /// that this is a special marker rather than a specific point in the blockchain.
+    pub const TIP: Point = Point(pallas::network::miniprotocols::Point::Specific(
+        u64::MAX,
+        Vec::new(),
+    ));
+    /// A truly unknown point in the blockchain. It is used
+    /// when the previous point is completely unknown and does not correspond to the
+    /// origin of the blockchain.
+    ///
+    /// # Usage
+    ///
+    /// `UNKNOWN` can be used in scenarios where the previous point in the
+    /// blockchain is not known and should not be assumed to be the origin. It serves
+    /// as a marker for an indeterminate or unspecified point.
+    ///
+    /// The inner `Point` is created with `u64::MIN` and an empty `Vec<u8>`, indicating
+    /// that this is a special marker for an unknown point, rather than a specific
+    /// point in the blockchain.
+    pub const UNKNOWN: Point = Point(pallas::network::miniprotocols::Point::Specific(
+        u64::MIN,
+        Vec::new(),
+    ));
+
+    /// Creates a new `Point` instance representing a specific
+    /// point in the blockchain, identified by a given slot and hash.
+    ///
+    /// # Parameters
+    ///
+    /// * `slot` - A `Slot` representing the slot number in the blockchain.
+    /// * `hash` - A `Blake2b256Hash`, block hash at the specified slot.
+    ///
+    /// # Returns
+    ///
+    /// A new `Point` instance encapsulating the given slot and hash.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let slot = 42;
+    /// let hash = [0; 32];
+    /// let point = Point::new(slot.into(), hash.into());
+    /// ```
+    #[must_use]
+    pub fn new(slot: Slot, hash: Blake2b256Hash) -> Self {
+        Self(pallas::network::miniprotocols::Point::Specific(
+            slot.into(),
+            hash.into(),
+        ))
+    }
+
+    /// Creates a new `Point` instance representing a specific
+    /// point in the blockchain, identified by a given slot, but with an
+    /// unknown hash. This can be useful in scenarios where the slot is known
+    /// but the hash is either unavailable or irrelevant.
+    ///
+    /// # Parameters
+    ///
+    /// * `slot` - A `Slot` representing the slot number in the blockchain.
+    ///
+    /// # Returns
+    ///
+    /// A new `Point` instance encapsulating the given slot with an empty hash.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let slot = 42;
+    /// let point = Point::fuzzy(slot.into());
+    /// ```
+    #[must_use]
+    pub fn fuzzy(slot: Slot) -> Self {
+        Self(pallas::network::miniprotocols::Point::Specific(
+            slot.into(),
+            Vec::new(),
+        ))
+    }
+
+    /// Creates a new Fuzzy `Point` from a concrete point.
+    ///
+    /// Will not alter either `TIP` or `ORIGIN` points.
+    #[must_use]
+    pub fn as_fuzzy(&self) -> Self {
+        if *self == Self::TIP {
+            Self::TIP
+        } else {
+            match self.0 {
+                pallas::network::miniprotocols::Point::Specific(slot, _) => {
+                    Self::fuzzy(slot.into())
+                },
+                pallas::network::miniprotocols::Point::Origin => Self::ORIGIN,
+            }
+        }
+    }
+
+    /// Check if a `Point` is Fuzzy.
+    ///
+    /// Even though we don't know the hash for TIP or Origin, neither of these points
+    /// are considered to be fuzzy.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let slot = 42;
+    /// let point = Point::fuzzy(slot.into());
+    ///
+    /// assert!(point.is_fuzzy());
+    /// ```
+    #[must_use]
+    pub fn is_fuzzy(&self) -> bool {
+        if *self == Self::TIP {
+            false
+        } else {
+            match self.0 {
+                pallas::network::miniprotocols::Point::Specific(_, ref hash) => hash.is_empty(),
+                pallas::network::miniprotocols::Point::Origin => false,
+            }
+        }
+    }
+
+    /// Check if a `Point` is the origin.
+    ///
+    /// Origin is the synthetic Origin point, and ALSO any point thats at slot zero with a
+    /// hash.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let slot = 42;
+    /// let point = Point::fuzzy(slot.into());
+    ///
+    /// assert!(!point.is_origin());
+    /// ```
+    #[must_use]
+    pub fn is_origin(&self) -> bool {
+        match self.0 {
+            pallas::network::miniprotocols::Point::Specific(slot, ref hash) => {
+                slot == 0 && !hash.is_empty()
+            },
+            pallas::network::miniprotocols::Point::Origin => true,
+        }
+    }
+
+    /// Check if a `Point` is actually unknown.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let point = Point::fuzzy(0.into());
+    ///
+    /// assert!(point.is_unknown());
+    /// ```
+    #[must_use]
+    pub fn is_unknown(&self) -> bool {
+        match self.0 {
+            pallas::network::miniprotocols::Point::Specific(slot, ref hash) => {
+                slot == 0 && hash.is_empty()
+            },
+            pallas::network::miniprotocols::Point::Origin => false,
+        }
+    }
+
+    /// Check if a Point is the tip.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let point = Point::fuzzy(0.into());
+    ///
+    /// assert!(!point.is_tip());
+    /// ```
+    #[must_use]
+    pub fn is_tip(&self) -> bool {
+        match self.0 {
+            pallas::network::miniprotocols::Point::Specific(slot, ref hash) => {
+                slot == u64::MAX && hash.is_empty()
+            },
+            pallas::network::miniprotocols::Point::Origin => false,
+        }
+    }
+
+    /// Retrieves the slot number from the `Point`. If the `Point`
+    /// is the origin, it returns a default slot number.
+    ///
+    /// # Returns
+    ///
+    /// A `u64` representing the slot number. If the `Point` is the origin,
+    /// it returns a default slot value, typically `0`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let specific_point = Point::new(42.into(), [0; 32].into());
+    /// assert_eq!(specific_point.slot_or_default(), 42.into());
+    ///
+    /// let origin_point = Point::ORIGIN;
+    /// assert_eq!(origin_point.slot_or_default(), 0.into()); // assuming 0 is the default
+    /// ```
+    #[must_use]
+    pub fn slot_or_default(&self) -> Slot {
+        self.0.slot_or_default().into()
+    }
+
+    /// Retrieves the hash from the `Point`. If the `Point` is
+    /// the origin, it returns `None`.
+    ///
+    /// # Returns
+    ///
+    /// A `Blake2b256Hash` representing the hash. If the `Point` is the `Origin`, it
+    /// returns `None`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::{hashes::Blake2b256Hash, Point};
+    ///
+    /// let specific_point = Point::new(42.into(), [0; 32].into());
+    /// assert_eq!(
+    ///     specific_point.hash_or_default(),
+    ///     Some::<Blake2b256Hash>([0; 32].into())
+    /// );
+    ///
+    /// let origin_point = Point::ORIGIN;
+    /// assert_eq!(origin_point.hash_or_default(), None);
+    /// ```
+    #[must_use]
+    pub fn hash_or_default(&self) -> Option<Blake2b256Hash> {
+        match &self.0 {
+            pallas::network::miniprotocols::Point::Specific(_, hash) => {
+                Blake2b256Hash::try_from(hash.clone()).ok()
+            },
+            // Origin has empty hash, so set it to None
+            pallas::network::miniprotocols::Point::Origin => None,
+        }
+    }
+
+    /// Checks if two `Point` instances are strictly equal.
+    /// Strict equality means both the slot number and hash must be identical.
+    ///
+    /// # Parameters
+    ///
+    /// * `b` - Another `Point` instance to compare against.
+    ///
+    /// # Returns
+    ///
+    /// A `bool` indicating whether the two `Point` instances are strictly equal.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use cardano_blockchain_types::Point;
+    ///
+    /// let point1 = Point::new(42.into(), [0; 32].into());
+    /// let point2 = Point::new(42.into(), [0; 32].into());
+    /// assert!(point1.strict_eq(&point2));
+    ///
+    /// let point3 = Point::new(42.into(), [0; 32].into());
+    /// let point4 = Point::new(43.into(), [0; 32].into());
+    /// assert!(!point3.strict_eq(&point4));
+    /// ```
+    #[must_use]
+    pub fn strict_eq(&self, b: &Self) -> bool {
+        self.0 == b.0
+    }
+}
+
+impl PartialEq<Option<Blake2b256Hash>> for Point {
+    /// Compares the hash stored in the `Point` with a `Blake2b256Hash`.
+    /// It returns `true` if the hashes match and `false` otherwise. If the
+    /// provided hash is `None`, the function checks if the `Point` has an
+    /// empty hash.
+    fn eq(&self, other: &Option<Blake2b256Hash>) -> bool {
+        match other {
+            Some(cmp_hash) => {
+                match self.0 {
+                    pallas::network::miniprotocols::Point::Specific(_, ref hash) => {
+                        // Compare vec to vec
+                        *hash == <Blake2b256Hash as Into<Vec<u8>>>::into(*cmp_hash)
+                    },
+                    pallas::network::miniprotocols::Point::Origin => false,
+                }
+            },
+            None => {
+                match self.0 {
+                    pallas::network::miniprotocols::Point::Specific(_, ref hash) => hash.is_empty(),
+                    pallas::network::miniprotocols::Point::Origin => true,
+                }
+            },
+        }
+    }
+}
+
+impl PartialEq<Option<Hash<32>>> for Point {
+    /// Compares the hash stored in the `Point` with a Pallas `Hash`.
+    /// It returns `true` if the hashes match and `false` otherwise. If the
+    /// provided hash is `None`, the function checks if the `Point` has an
+    /// empty hash.
+    fn eq(&self, other: &Option<Hash<32>>) -> bool {
+        *self == other.map(Blake2b256Hash::from)
+    }
+}
+
+impl Display for Point {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        if *self == Self::ORIGIN {
+            return write!(f, "Point @ Origin");
+        } else if *self == Self::TIP {
+            return write!(f, "Point @ Tip");
+        } else if *self == Self::UNKNOWN {
+            return write!(f, "Point @ Unknown");
+        }
+
+        let slot = self.slot_or_default();
+        let hash = self.hash_or_default();
+        match hash {
+            Some(hash) => {
+                write!(
+                    f,
+                    "Point @ {slot:?}:{}",
+                    hex::encode(<Blake2b256Hash as Into<Vec<u8>>>::into(hash))
+                )
+            },
+            None => write!(f, "Point @ {slot:?}"),
+        }
+    }
+}
+
+impl From<pallas::network::miniprotocols::Point> for Point {
+    fn from(point: pallas::network::miniprotocols::Point) -> Self {
+        Self(point)
+    }
+}
+
+impl From<Point> for pallas::network::miniprotocols::Point {
+    fn from(point: Point) -> pallas::network::miniprotocols::Point {
+        point.0
+    }
+}
+
+impl PartialOrd for Point {
+    /// Implements a partial ordering based on the slot number
+    /// of two `Point` instances. It only checks the slot number for ordering.
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Point {
+    /// Implements a total ordering based on the slot number
+    /// of two `Point` instances. It only checks the slot number for ordering.
+    fn cmp(&self, other: &Self) -> Ordering {
+        cmp_point(&self.0, &other.0)
+    }
+}
+
+impl PartialEq<u64> for Point {
+    fn eq(&self, other: &u64) -> bool {
+        self.0.slot_or_default() == *other
+    }
+}
+
+impl PartialOrd<u64> for Point {
+    /// Allows to compare a `Point` against a `u64`
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        self.0.slot_or_default().partial_cmp(other)
+    }
+}
+
+impl PartialEq<Option<Point>> for Point {
+    /// Allows for direct comparison between a `Point` and an `Option<Point>`,
+    /// returning `true` only if the `Option` contains a `Point` that is equal to the
+    /// `self` instance.
+    fn eq(&self, other: &Option<Point>) -> bool {
+        if let Some(other) = other {
+            *self == *other
+        } else {
+            false
+        }
+    }
+}
+
+impl PartialOrd<Option<Point>> for Point {
+    /// Allows comparing a `Point` with an `Option<Point>`, where a `Point` is always
+    /// considered greater than `None`.
+    fn partial_cmp(&self, other: &Option<Point>) -> Option<Ordering> {
+        if let Some(other) = other {
+            self.partial_cmp(other)
+        } else {
+            Some(Ordering::Greater)
+        }
+    }
+}
+
+impl Default for Point {
+    /// Returns the default value for `Point`, which is `UNKNOWN_POINT`.
+    fn default() -> Self {
+        Self::UNKNOWN
+    }
+}
+
+/// Compare Points, because Pallas does not impl `Ord` for `Point`.
+fn cmp_point(
+    a: &pallas::network::miniprotocols::Point, b: &pallas::network::miniprotocols::Point,
+) -> Ordering {
+    match a {
+        pallas::network::miniprotocols::Point::Origin => {
+            match b {
+                pallas::network::miniprotocols::Point::Origin => Ordering::Equal,
+                pallas::network::miniprotocols::Point::Specific(..) => Ordering::Less,
+            }
+        },
+        pallas::network::miniprotocols::Point::Specific(slot, _) => {
+            match b {
+                pallas::network::miniprotocols::Point::Origin => Ordering::Greater,
+                pallas::network::miniprotocols::Point::Specific(other_slot, _) => {
+                    slot.cmp(other_slot)
+                },
+            }
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{hashes::Blake2bHash, point::*};
+
+    #[test]
+    fn test_cmp_hash_simple() {
+        let origin1 = Point::ORIGIN;
+        let point1 = Point::new(100u64.into(), [8; 32].into());
+
+        assert!(origin1 != Some::<Blake2b256Hash>([0; 32].into()));
+        assert!(origin1 == None::<Blake2b256Hash>);
+        assert!(point1 == Some::<Blake2b256Hash>([8; 32].into()));
+        assert!(point1 != None::<Hash<32>>);
+    }
+
+    #[test]
+    fn test_get_hash_simple() {
+        let point1 = Point::new(100u64.into(), [8; 32].into());
+
+        assert_eq!(point1.hash_or_default(), Some([8; 32].into()));
+    }
+
+    #[test]
+    fn test_identical_compare() {
+        let point1 = Point::new(100u64.into(), [8; 32].into());
+        let point2 = Point::new(100u64.into(), [8; 32].into());
+        let point3 = Point::new(999u64.into(), [8; 32].into());
+
+        assert!(point1.strict_eq(&point2));
+        assert!(!point1.strict_eq(&point3));
+    }
+
+    #[test]
+    fn test_comparisons() {
+        let origin1 = Point::ORIGIN;
+        let origin2 = Point::ORIGIN;
+        let tip1 = Point::TIP;
+        let tip2 = Point::TIP;
+        let early_block = Point::new(100u64.into(), Blake2bHash::new(&[]));
+        let late_block1 = Point::new(5000u64.into(), Blake2bHash::new(&[]));
+        let late_block2 = Point::new(5000u64.into(), Blake2bHash::new(&[]));
+
+        assert!(origin1 == origin2);
+        assert!(origin1 < early_block);
+        assert!(origin1 <= early_block);
+        assert!(origin1 != early_block);
+        assert!(origin1 < late_block1);
+        assert!(origin1 <= late_block1);
+        assert!(origin1 != late_block1);
+        assert!(origin1 < tip1);
+        assert!(origin1 <= tip1);
+        assert!(origin1 != tip1);
+
+        assert!(tip1 > origin1);
+        assert!(tip1 >= origin1);
+        assert!(tip1 != origin1);
+        assert!(tip1 > early_block);
+        assert!(tip1 >= late_block1);
+        assert!(tip1 != late_block1);
+        assert!(tip1 == tip2);
+
+        assert!(early_block > origin1);
+        assert!(early_block >= origin1);
+        assert!(early_block != origin1);
+        assert!(early_block < late_block1);
+        assert!(early_block <= late_block1);
+        assert!(early_block != late_block1);
+        assert!(early_block < tip1);
+        assert!(early_block <= tip1);
+        assert!(early_block != tip1);
+
+        assert!(late_block1 == late_block2);
+        assert!(late_block1 > origin1);
+        assert!(late_block1 >= origin1);
+        assert!(late_block1 != origin1);
+        assert!(late_block1 > early_block);
+        assert!(late_block1 >= early_block);
+        assert!(late_block1 != early_block);
+        assert!(late_block1 < tip1);
+        assert!(late_block1 <= tip1);
+        assert!(late_block1 != tip1);
+    }
+
+    #[test]
+    fn test_create_point_and_fuzzy_not_equal() {
+        let point1 = Point::new(100u64.into(), Blake2bHash::new(&[]));
+        let fuzzy1 = Point::fuzzy(100u64.into());
+
+        assert!(point1 != fuzzy1);
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/slot.rs b/rust/cardano-blockchain-types/src/slot.rs
new file mode 100644
index 000000000..04225cf94
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/slot.rs
@@ -0,0 +1,35 @@
+//! Block Slot
+use crate::conversion::from_saturating;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+/// Slot on the blockchain, typically one slot equals one second.  However chain
+/// parameters can alter how long a slot is.
+pub struct Slot(u64);
+
+impl Slot {
+    /// Convert an `<T>` to Slot. (saturate if out of range.)
+    pub fn from_saturating<
+        T: Copy
+            + TryInto<u64>
+            + std::ops::Sub<Output = T>
+            + std::cmp::PartialOrd<T>
+            + num_traits::identities::Zero,
+    >(
+        value: T,
+    ) -> Self {
+        let value: u64 = from_saturating(value);
+        Self(value)
+    }
+}
+
+impl From<u64> for Slot {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Slot> for u64 {
+    fn from(val: Slot) -> Self {
+        val.0
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/txn_index.rs b/rust/cardano-blockchain-types/src/txn_index.rs
new file mode 100644
index 000000000..036bbf7e9
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/txn_index.rs
@@ -0,0 +1,23 @@
+//! Transaction Index
+use crate::conversion::from_saturating;
+
+/// Transaction index within a block
+/// See: <https://github.com/IntersectMBO/cardano-ledger/blob/78b32d585fd4a0340fb2b184959fb0d46f32c8d2/eras/conway/impl/cddl-files/conway.cddl#L20C1-L20C33>
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TxnIndex(u16);
+
+impl TxnIndex {
+    /// Convert an `<T>` to transaction index (saturate if out of range).
+    pub(crate) fn from_saturating<
+        T: Copy
+            + TryInto<u16>
+            + std::ops::Sub<Output = T>
+            + std::cmp::PartialOrd<T>
+            + num_traits::identities::Zero,
+    >(
+        value: T,
+    ) -> Self {
+        let value: u16 = from_saturating(value);
+        Self(value)
+    }
+}
diff --git a/rust/cardano-blockchain-types/src/txn_witness.rs b/rust/cardano-blockchain-types/src/txn_witness.rs
new file mode 100644
index 000000000..ade0cda61
--- /dev/null
+++ b/rust/cardano-blockchain-types/src/txn_witness.rs
@@ -0,0 +1,144 @@
+//! Transaction Witness
+use std::fmt::{Display, Formatter};
+
+use dashmap::{DashMap, DashSet};
+use ed25519_dalek::VerifyingKey;
+use pallas::ledger::traverse::MultiEraTx;
+
+use crate::{conversion::vkey_from_bytes, hashes::Blake2b224Hash, TxnIndex};
+
+/// Hash of a witness verifying public key
+pub type VKeyHash = Blake2b224Hash;
+
+/// `WitnessMap` type of `DashMap` with
+/// key as [u8; 28] = (`blake2b_244` hash of the public key)
+/// value as `(Bytes, Vec<u8>) = (public key, tx index within the block)`
+type WitnessMap = DashMap<VKeyHash, (VerifyingKey, DashSet<TxnIndex>)>;
+
+#[derive(Debug)]
+/// `TxnWitness` struct to store the witness data.
+pub struct TxnWitness(WitnessMap);
+
+impl TxnWitness {
+    /// Create a new `TxnWitness` from a list of `MultiEraTx`.
+    ///
+    /// # Errors
+    ///
+    /// If the witness map does not contain a valid ED25519 public key,
+    /// or unsupported transaction era.
+    pub fn new(txs: &[MultiEraTx]) -> anyhow::Result<Self> {
+        /// Update the temporary map with the witnesses.
+        fn update_map(
+            map: &WitnessMap,
+            vkey_witness_set: &Option<Vec<pallas::ledger::primitives::conway::VKeyWitness>>,
+            i: usize,
+        ) -> anyhow::Result<()> {
+            if let Some(vkey_witness_set) = vkey_witness_set.clone() {
+                for vkey_witness in vkey_witness_set {
+                    let vkey = vkey_from_bytes(&vkey_witness.vkey)?;
+                    let vkey_hash = VKeyHash::new(vkey.as_ref());
+                    let tx_num = TxnIndex::from_saturating(i);
+                    if let Some(entry) = map.get(&vkey_hash) {
+                        entry.1.insert(tx_num);
+                    } else {
+                        let new_set = DashSet::new();
+                        new_set.insert(tx_num);
+                        map.insert(vkey_hash, (vkey, new_set));
+                    }
+                }
+            };
+            Ok(())
+        }
+
+        let map: WitnessMap = DashMap::new();
+        for (i, tx) in txs.iter().enumerate() {
+            match tx {
+                MultiEraTx::AlonzoCompatible(tx, _) => {
+                    let witness_set = &tx.transaction_witness_set;
+                    update_map(&map, &witness_set.vkeywitness, i)?;
+                },
+                MultiEraTx::Babbage(tx) => {
+                    let witness_set = &tx.transaction_witness_set;
+                    update_map(&map, &witness_set.vkeywitness, i)?;
+                },
+                MultiEraTx::Conway(tx) => {
+                    let witness_set = &tx.transaction_witness_set;
+                    if let Some(non_empty_set) = witness_set.vkeywitness.clone() {
+                        update_map(&map, &Some(non_empty_set.to_vec()), i)?;
+                    }
+                },
+                _ => {
+                    return Err(anyhow::anyhow!("Unsupported transaction Era"));
+                },
+            };
+        }
+        Ok(Self(map))
+    }
+
+    /// Check whether the public key hash is in the given transaction number.
+    #[must_use]
+    pub fn check_witness_in_tx(&self, vkey_hash: &VKeyHash, tx_num: TxnIndex) -> bool {
+        self.0
+            .get(vkey_hash)
+            .map_or(false, |entry| entry.1.contains(&tx_num))
+    }
+
+    /// Get the actual verifying key from the given public key hash.
+    #[must_use]
+    pub fn get_witness_vkey(&self, vkey_hash: &VKeyHash) -> Option<VerifyingKey> {
+        self.0.get(vkey_hash).map(|entry| entry.0)
+    }
+}
+
+impl Display for TxnWitness {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        for data in &self.0 {
+            let vkey_hash = data.key();
+            let txn = &data.value().1;
+            let vkey = hex::encode(data.value().0.as_bytes());
+            writeln!(
+                f,
+                "Key Hash: 0x{vkey_hash}, PublicKey: 0x{vkey}, Tx: {txn:?}"
+            )?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::str::FromStr;
+
+    use super::*;
+    use crate::multi_era_block_data::tests::{alonzo_block, babbage_block};
+
+    #[test]
+    fn tx_witness() {
+        let alonzo = alonzo_block();
+        let alonzo_block = pallas::ledger::traverse::MultiEraBlock::decode(&alonzo)
+            .expect("Failed to decode MultiEraBlock");
+        let txs_alonzo = alonzo_block.txs();
+        let tx_witness_alonzo = TxnWitness::new(&txs_alonzo).expect("Failed to create TxnWitness");
+        let vkey1_hash =
+            VKeyHash::from_str("6082eb618d161a704207a0b3a9609e820111570d94d1e711b005386c")
+                .expect("Failed to decode vkey1_hash");
+        println!("{tx_witness_alonzo}");
+        assert!(tx_witness_alonzo.get_witness_vkey(&vkey1_hash).is_some());
+        assert!(tx_witness_alonzo.check_witness_in_tx(&vkey1_hash, TxnIndex::from_saturating(0)));
+
+        let babbage = babbage_block();
+        let babbage_block = pallas::ledger::traverse::MultiEraBlock::decode(&babbage)
+            .expect("Failed to decode MultiEraBlock");
+        let txs_babbage = babbage_block.txs();
+        let tx_witness_babbage =
+            TxnWitness::new(&txs_babbage).expect("Failed to create TxnWitness");
+        let vkey2_hash =
+            VKeyHash::from_str("ba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c66")
+                .expect("Failed to decode vkey2_hash");
+
+        println!("{tx_witness_babbage}");
+        assert!(tx_witness_babbage.get_witness_vkey(&vkey2_hash).is_some());
+        assert!(tx_witness_babbage.check_witness_in_tx(&vkey2_hash, TxnIndex::from_saturating(0)));
+    }
+}
diff --git a/rust/cardano-blockchain-types/test_data/allegra.block b/rust/cardano-blockchain-types/test_data/allegra.block
new file mode 100644
index 000000000..a276b1f3a
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/allegra.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/alonzo.block b/rust/cardano-blockchain-types/test_data/alonzo.block
new file mode 100644
index 000000000..bc6359292
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/alonzo.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/babbage.block b/rust/cardano-blockchain-types/test_data/babbage.block
new file mode 100644
index 000000000..aeb4df9c1
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/babbage.block
@@ -0,0 +1 @@
+820685828a1a002751831a0409c74758208f359d2ca9a3e513b574cc88c93346506e2520f9939eadfc2e02e6c251a94769582069b5785508a9898605833a7c346c9fa294eb9e6793e0887a0230a1e026ebd1fa5820e9fff58586a4a588f15f371b4d7bfc04344b6a281bce39a7ab81fe5b6751cbac825840df4ca9e1e98212e3bfa0356274e63890304710237e92973de89d8dfba015f3eb8e925557cadcb70031cd644fe84b043f260e81342bf865d811409ae2aefb528458509aab92e40a5c75252e190d6860fbe0274ee6f7de16d12256df1dbd1f08b0f835fc0f333395d8d94464e5181e72c3fd935573005f03656191e9e95855f8fbcfd3456a6c268df905c805c9e510dff0df0f190c505820e6aebff5e8b2049914014d88821ef94b873b219ea32b44a50161b7bd2442deb5845820356e1f77552adeab6d94c2383cb4f7a5fb1b644858a6639cf9f71da339ad1e17081901ff5840fc25623ba50cf9f2858463dca7a3b1c703b97bd49d54e965d2df9602424986bf26e29ab4dac9b82f185cb825cd4a0b6dbc90374defd9ca20206cd25f47dc01058209015901c07d47377a4d51a9ed20b203308e73c500db49947189f6c92e951ab0d24b131d20d0f157fdf10a90aad4c8c6173dcd8d16b834ff47f1914556ae14b8015d7edc0ea0c33c70c7867e06a2952efe9066ceae6e1b9b23c59c76148f01917099657153af53c0cb5bb0a601d6e7e504033c2522fe069dda3a488d189032fd4ff59273526b263cabf7966326054aa26bb3d3e24010aa1edec3a545c80a1e1e357b0bea164c6663240e865cff3e29d30862b99f1ce52ca042f5d7d065bc29cc7d4ccce45acce31cc0da588c4ddec1fd4e3444ace1bf583df247ba168e0375862090fa4f49fa95fd28df6ce88f72e303d1f9cd4353abdd2d1a4472164d15220142e922b03eb6657152f340cf460514bbe57e892b81fe633d395773c00b91025237ed84ef5c6541d6bccb5a56f736b294fc6500aaa9e958c7b41bd422200545efbf0e5eb0ff95fc2394ab22cb543854aab426f60ab5dc04fa9ca3d9cc71a2abcf00c1ef8287f9bd9f7508fc5cc6a4513faac33b05b06304883ec50acb9c1ee3033604ce4eebe75beba7e97a731f92c6e779ecf700c3220ec992752b49708cab9d9a079803a01832cb14da7c59d069c4538cadd38c90b6502ce3b311424eaba7676f3dbc720b84ab008382582022d427bf2262a44dc3a3a2c9555696a741d779eb89afecf624e91a1ebdf3335400825820533e9251fd0ed7ac8613fe3d05813ce3bde7d96a6e446019a93421a0c6b785a50282582090b06350ad57403e8dcdb49d4f9fad5de1b244668fd5a0c98cd08b78d5f343b3010183a300581d704e3b75eb68829ca9e63b541f3645f78afe8d119932a7a2528171e74901821a001e8480a1581c5cf48c225e057f8da0787eae1e2bc62a1cf1d2ee34c7e2a9498b19b5a1484e6f64654665656401028201d8185840d87a9fd8799f581cba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c66d8799fd8799f1b0000000da0e77c201b00000191449a86f5ffffffff82581d60ba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c661a0089544082581d60ba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c661a00ac398c021a00044c8c031a0409c766081a0409c6ee0b5820dbf505c29f869273f15ea579723e9ca9bcf31fdb8c4cb4e4085268f3714b99b90d818258206f8ebcf2a2b04f5cb5f977aa1e41001301634e64a532a8de1e98147cc84e6502010e81581cba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c661082581d60ba4ab50bdecca85162f3b8114739bc5ba3aaa6490e2b1d15ad0f9c661a00524801111a00370c3f1281825820efd8a48f69e5270cb73b438067e1b566d39758329a45e5d6d36755f2c732618400ab00838258201df5c710d3251bea8457e05813101bd7f8defaba978114939ffa38035d42672a02825820e04bce69a5659295c235502d5fdb62b29e43f773e698c97e533e394d92d9228001825820ec4b6e2455e84a8aaa365cdc4c41ee446314ea74c209e698f1785c94c9952910000183a300581d704e3b75eb68829ca9e63b541f3645f78afe8d119932a7a2528171e74901821a001e8480a1581c5cf48c225e057f8da0787eae1e2bc62a1cf1d2ee34c7e2a9498b19b5a1484e6f64654665656401028201d8185840d87a9fd8799f581c3f2728ec78ef8b0f356e91a5662ff3124add324a7b7f5aeed69362f4d8799fd8799f1b0000000da0cc2bf01b00000191449a8523ffffffff82581d603f2728ec78ef8b0f356e91a5662ff3124add324a7b7f5aeed69362f41a0089544082581d603f2728ec78ef8b0f356e91a5662ff3124add324a7b7f5aeed69362f41a00a1cf51021a0004529a031a0409c766081a0409c6ee0b5820ed60fdd0e4e9cc43b5fa9a601a3d013c6a8f26916ff80e9b5c5a41813493f04e0d8182582040d412944923070bbdeca4887e30983b497e455e62a150209d522c4f2eec82f5020e81581c3f2728ec78ef8b0f356e91a5662ff3124add324a7b7f5aeed69362f41082581d603f2728ec78ef8b0f356e91a5662ff3124add324a7b7f5aeed69362f41a00455948111a00370c3f1281825820efd8a48f69e5270cb73b438067e1b566d39758329a45e5d6d36755f2c732618400ab00838258203efd5491b62cec43b8421eeb9978d9544a451cf938b454278dabfe508a867175008258204d1deb722bdab493e69840eca2fbb2af5eed36a82d2cd196754ce4af2618ecb902825820f1883a3368b6baa87f5d051d3e7fedb0c571519333f38860b54ec7b4dec3253e010183a300581d704e3b75eb68829ca9e63b541f3645f78afe8d119932a7a2528171e74901821a001e8480a1581c5cf48c225e057f8da0787eae1e2bc62a1cf1d2ee34c7e2a9498b19b5a1484e6f64654665656401028201d8185840d87a9fd8799f581c17942ff3849b623d24e31ec709c1c94c53b9240311820a9601ad4af0d8799fd8799f1b0000000da0cc2bf01b00000191449a8522ffffffff82581d6017942ff3849b623d24e31ec709c1c94c53b9240311820a9601ad4af01a0089544082581d6017942ff3849b623d24e31ec709c1c94c53b9240311820a9601ad4af01a0073c968021a00044c8c031a0409c766081a0409c6ee0b5820dbf505c29f869273f15ea579723e9ca9bcf31fdb8c4cb4e4085268f3714b99b90d818258204c6d1cb7cba6122de41fb91be0f78b61316399096d6f54bd7e3f2f76dd63b92e020e81581c17942ff3849b623d24e31ec709c1c94c53b9240311820a9601ad4af01082581d6017942ff3849b623d24e31ec709c1c94c53b9240311820a9601ad4af01a004df567111a00370c3f1281825820efd8a48f69e5270cb73b438067e1b566d39758329a45e5d6d36755f2c732618400a50081825820aa7bbea2a5101b867d969ad7e6ff7d95d440199ef4ba6621751d25521566101400018182583900eb21979c03eed7207020b2a0b47565b5aafb1a2c3849b59a1fa8e6c5e075be10ec5c575caffb68b08c31470666d4fe1aeea07c16d64739031b00000002525569af021a00032471075820420e72fc38474ce192fc9ba39380a11ddf9e5ac96a814d3fdb68c24cbf81e4600f0084a200818258209a12ec259e59bd8fc60244062f294f11555539f5fd45e77d8a57f16b5987dc4458401944ed87d70eb6646aa840b9914c462b1e4e3513831d1f5ec817a6966d00c0b6f12bf24b0576ea9593ed4f9c9dac2f0d9e15473088e64f688f3dea4416dbe90d0581840000d87980821a0012a1311a15d0fa8ba20081825820499300f082db931c561f42b9ca7d5ea4b288ae74cf1969d1fbd7bf41e7b02e8e5840504c78c1fe246730ca7c2469ba6731cf7e0aff42bd027091283568fe25d2a9f35da1593fb89e5bfd2f7d2db58316ee86ed1c8380e8fb77d61362c78f64374a010581840002d87980821a0012eff61a1622a0d4a20081825820ae01a85ba5eb8e67830cf6b422cb819cac1eaf0c7f62dbc496f12d9735b170d7584004dd05c7ea8b1ab964f67bfe4515e18451b23ee7950c8224f9b355aa1005ba1c7051951e82883c9cb25be7ada388fe2b708eaa6d9f1590516f2782f8b5ff20050581840000d87980821a0012a1311a15d0fa8ba100818258208469288efa6f9cb49040b43dcff93f40969d72433f751afde50235012c01602058401d84bfa159ac070a11834e2a41b38f205ce1628ccdc693fe2000e21c680e6ead1a23a23043bb99ac1de8460fee2f5b40d3a736566b9434d1b551b115956b5004a103a11901fda50050ca7a1457ef9f4c7f9c747f8c4a4cfa6c0150152a368b96d95f61ae69513dd5f6e92a0258204d3f576f26db29139981a69443c2325daa812cc353a31b5a4db794a5bcbb06c20b8c58401b3d030866084fcb259de07496d3197e913a39fd628a3db0a4ed6839261a00c51cb0a5b9c16194064132ace375ea23c75c60659400cba304d0d689c00086195d5840ff28714da02c35e7295815ba58b77f227e576fa254c464e2f9c6f9dfa900a0208250033c054a468c38e08819601d073c034a4727a524ff39995477443c1fca235840839c927599b253887f50487c1caf757c0aaf79bc3fcacd42252b8f2ae1f1a8b282929ca22bb5c2885cc23a66005c0cc1ca20142b82310c3a137d44c1943e40995840a7a7ce5c3475b5887a3765ede2ff3b7bfea90f255e2edf37fd44e27f26b8e6cf408aef4b20bebf7257b3dabc7eda65fff4ed278b50219f0a52367ff5b80e46b758403875f55a394d17a5d9a6b1a1deff5b2206e9e9734e9fbefa6a1cdfeb7a104546dfb6e46c46feaeb65a7f4648c276e29e87b27bc053bffef79359300220d0c3875840f2a05cc4880317358e19c758fd9ab9917551ce3987af2e35d73b6958a0f5732784621b0c92f68a93537f16f48445424890f955d7a597c13c2eb54a82b39f0307584097507df5fef916fabb6dafdfb516fb9184783e2cb4e89d048a6c1e5c04818bdb76ffb5cbef1fbe452658d904cd152ee72a3bfc6efe1199fb3b51f1979629cd4e5840fdb7df511723d4cead3d2b2eb9c1f18cbbfcf9f5cc8eac46dc03cd55fcac3303c391437f50400923e65c02e981af5461b6867a47fb25ebe9b0fb4d9e41ec210e58404b9011000206414523c0990f9ee20b5d8a745393d3febaf6413a448b994f1567eb7945df7a0ab44afd55561e0190b376d411026c5d7a4a49a19e0bd3f5addd6c5840492fde46eee8d75b587286291dfeb6a78fdf59c1a6bfa2717b1f41dfa878756140ce7c77504b64b094b870ade78569566eec66369133af5aa8c8eab9f95e29df58409ec10be251547101b24c495c8ff4fa55378dbb4a5c6e89b18a12ac033343d61c3b7f5fba725b51536d92a5cbfaef9be6d24a3e5b3d75a1c0e29e42f523567fac4d0f8200811c822d2210b97f5708186358407b322d37df11460b98e13f6c3c4d5d4985ad984768d09f77516e8e0f61ed24e646c466a995c2bf2b547302b96d4582be9b65f8d52f9fbc4857e7bef79948860180
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/byron.block b/rust/cardano-blockchain-types/test_data/byron.block
new file mode 100644
index 000000000..2c26a9a3a
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/byron.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/conway_tx_rbac/Readme.md b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/Readme.md
new file mode 100644
index 000000000..1851d2b8f
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/Readme.md
@@ -0,0 +1,33 @@
+# Test data for CIP-0509 RBAC validation
+
+## Role Based Access Control (RBAC) validation
+
+The current validation includes
+
+1. Hashing the transaction input `0: transaction inputs` within the transaction should match the `1: txn-inputs-hash`.
+2. `?7: auxiliary_data_hash` should match the hash of the auxiliary data.
+  This also log the pre-hashed of the auxiliary data (auxiliary data with `99: validation signature` set to 0x00).
+3. Role 0 validation
+    1. Stake public key extracted from URI in X509 or C509 subject alternative name should match some of the
+        witness set within the transaction.
+    2. Reference `?3: payment-key`
+        1. Negative index reference - reference to transaction output in transaction: should match some of the
+            key within witness set.
+        2. Positive index reference - reference to transaction input in transaction: check only the index
+            exist within the transaction input.
+
+## Test Data
+
+* `conway_1.block`: Block number: `2761995`, Absolute slot number: `72605027`
+* `conway_2.block`: Block number: `2762138`, Absolute slot number: `72609251`
+* `conway_3.block`: Block number: `2762050`, Absolute slot number: `72606545`
+
+## References
+
+* [Conway CDDL](https://github.com/IntersectMBO/cardano-ledger/blob/ab8d57cf43be912a336e872b68d1a2526c93dc6a/eras/conway/impl/cddl-files/conway.cddl)
+
+* [CIP-0509 RBAC Registration](https://github.com/input-output-hk/catalyst-CIPs/tree/x509-rbac-signing-with-cip30/CIP-XXXX)
+* [CIP-0509 Metadata Envelope](https://github.com/input-output-hk/catalyst-CIPs/tree/x509-envelope-metadata/CIP-XXXX)
+* [CIP-0509 Role Registration](https://github.com/input-output-hk/catalyst-CIPs/tree/x509-role-registration-metadata/CIP-XXXX/)
+
+**Note: CIP-0509 is still in process and may be subject to change.**
diff --git a/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_1.block b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_1.block
new file mode 100644
index 000000000..ee2341dbf
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_1.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_2.block b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_2.block
new file mode 100644
index 000000000..d38c51b88
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_2.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_3.block b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_3.block
new file mode 100644
index 000000000..09dd13e19
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/conway_tx_rbac/conway_3.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/mary.block b/rust/cardano-blockchain-types/test_data/mary.block
new file mode 100644
index 000000000..7d71682e3
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/mary.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/shelley.block b/rust/cardano-blockchain-types/test_data/shelley.block
new file mode 100644
index 000000000..66da341e9
--- /dev/null
+++ b/rust/cardano-blockchain-types/test_data/shelley.block
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/rust/cardano-blockchain-types/test_data/test_snapshot_id/12345/immutable/12345.chunk b/rust/cardano-blockchain-types/test_data/test_snapshot_id/12345/immutable/12345.chunk
new file mode 100644
index 000000000..e69de29bb
diff --git a/rust/cardano-blockchain-types/test_data/test_snapshot_id/12346/immutable/12346.chunk b/rust/cardano-blockchain-types/test_data/test_snapshot_id/12346/immutable/12346.chunk
new file mode 100644
index 000000000..e69de29bb
diff --git a/rust/cardano-blockchain-types/test_data/test_snapshot_id/12347/immutable/12347.chunk b/rust/cardano-blockchain-types/test_data/test_snapshot_id/12347/immutable/12347.chunk
new file mode 100644
index 000000000..e69de29bb
diff --git a/rust/cardano-blockchain-types/test_data/test_snapshot_id/123abc/immutable/123abc.chunk b/rust/cardano-blockchain-types/test_data/test_snapshot_id/123abc/immutable/123abc.chunk
new file mode 100644
index 000000000..e69de29bb
diff --git a/rust/cbork/Earthfile b/rust/cbork/Earthfile
index e32f5fbb1..d3929ddb6 100644
--- a/rust/cbork/Earthfile
+++ b/rust/cbork/Earthfile
@@ -7,7 +7,7 @@ IMPORT .. AS rust-local
 
 # Run build using the most efficient host tooling
 # CI Automated Entry point.
-build:
+build-cbork:
     FROM rust-local+build
 
     SAVE ARTIFACT target/release/cbork cbork