feat(rust/cardano-blockchain-types): add cardano-blockchain-types crate

.config/dictionaries/project.dic

@@ -10,6 +10,7 @@ Arissara
 asyncio
 Attributes
 auditability
+auxdata
 babystep
 backpressure
 bech

rust/Cargo.toml

@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "c509-certificate",
+    "cardano-blockchain-types",
     "cardano-chain-follower",
     "hermes-ipfs",
     "cbork",

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=vote-tx-v1 --libs=vote-tx-v2" \
         --args4="--bins=cbork/cbork --libs=rbac-registration --libs=signed_doc" \

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 <[email protected]>"
+]
+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"

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`.

rust/cardano-blockchain-types/deps.tmp

@@ -0,0 +1,62 @@
+
+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" }

rust/cardano-blockchain-types/src/auxdata/aux_data.rs

@@ -0,0 +1,170 @@
+//! 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) => {
+                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(
+                    "Multiple Alonzo+ Script entries of type {script_type} found. Invalid.",
+                ));
+            }
+        }
+
+        Ok(Self {
+            metadata,
+            scripts: scripts.into(),
+        })
+    }
+}

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())))
+    }
+}