feat: add a transaction api

Signed-off-by: Eric Torreborre <etorreborre@yahoo.com>

Author: etorreborre

Cargo.lock

@@ -23,6 +23,7 @@ acto = { version = "0.8.0", features = ["tokio"] }
 anyhow = "1.0.100"
 async-compression = { version = "0.4.32", features = ["tokio", "gzip"] }
 async-trait = "0.1.83"
+axum = "0.8"
 assert-json-diff = "2.0.2"
 bech32 = "0.11.0"
 binrw = "0.15.0"

Cargo.toml

@@ -50,6 +50,8 @@ pub struct Block {
 }
 
 impl Block {
+    pub const CBOR_FIELD_COUNT: u64 = 5;
+
     /// Get the size in bytes of the serialised block.
     pub fn body_len(&self) -> u64 {
         self.original_body_size
@@ -103,7 +105,7 @@ impl IntoIterator for Block {
 impl<'b, C> cbor::Decode<'b, C> for Block {
     fn decode(d: &mut cbor::Decoder<'b>, ctx: &mut C) -> Result<Self, cbor::decode::Error> {
         cbor::heterogeneous_array(d, |d, assert_len| {
-            assert_len(5)?;
+            assert_len(Block::CBOR_FIELD_COUNT)?;
 
             let (header, header_bytes) = cbor::tee(d, |d| d.decode_with(ctx))?;
 

crates/amaru-kernel/src/cardano/block.rs

@@ -51,6 +51,10 @@ impl NetworkBlock {
         RawBlock::from(to_cbor(self).as_slice())
     }
 
+    pub fn encoded_block(&self) -> &[u8] {
+        &self.encoded_block
+    }
+
     /// Decode the inner block from its raw CBOR representation.
     pub fn decode_block(&self) -> Result<Block, minicbor::decode::Error> {
         minicbor::decode(&self.encoded_block)

crates/amaru-kernel/src/cardano/network_block.rs

@@ -12,11 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{fmt, ops::Deref, sync::Arc};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fmt,
+    ops::Deref,
+    sync::Arc,
+};
 
 use minicbor::decode;
 
-use crate::{Block, cardano::network_block::NetworkBlock, utils::debug_bytes};
+use crate::{Block, cardano::network_block::NetworkBlock, cbor, utils::debug_bytes};
 
 /// Cheaply cloneable block bytes
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
@@ -57,16 +62,111 @@ impl RawBlock {
         let network_block: NetworkBlock = minicbor::decode(&self.0)?;
         network_block.decode_block()
     }
+
+    /// Return an iterator over standalone CBOR-encoded transactions extracted from the block.
+    pub fn transactions(&self) -> Result<RawBlockTransactions, decode::Error> {
+        let network_block = NetworkBlock::try_from(self.clone())?;
+        let mut decoder = cbor::Decoder::new(network_block.encoded_block());
+
+        let len = decoder.array()?;
+        if len != Some(Block::CBOR_FIELD_COUNT) {
+            return Err(decode::Error::message(format!(
+                "invalid Block array length. Expected {}, got {len:?}",
+                Block::CBOR_FIELD_COUNT
+            )));
+        }
+
+        decoder.skip()?;
+        let bodies = cbor::collect_array_item_bytes(&mut decoder)?;
+        let witnesses = cbor::collect_array_item_bytes(&mut decoder)?;
+        let auxiliary_data = cbor::collect_map_value_bytes(&mut decoder, |d| d.u32())?;
+        let invalid_transactions: Option<BTreeSet<u32>> = decoder.decode()?;
+
+        if bodies.len() != witnesses.len() {
+            return Err(decode::Error::message(format!(
+                "inconsistent block: {} transaction bodies but {} witness sets",
+                bodies.len(),
+                witnesses.len()
+            )));
+        }
+
+        Ok(RawBlockTransactions {
+            bodies: bodies.into_iter(),
+            witnesses: witnesses.into_iter(),
+            auxiliary_data,
+            invalid_transactions,
+            index: 0,
+        })
+    }
+}
+
+/// This struct supports the iteration over serialized transactions contained in a block
+pub struct RawBlockTransactions {
+    bodies: std::vec::IntoIter<Vec<u8>>,
+    witnesses: std::vec::IntoIter<Vec<u8>>,
+    auxiliary_data: BTreeMap<u32, Vec<u8>>,
+    invalid_transactions: Option<BTreeSet<u32>>,
+    index: u32,
+}
+
+impl Iterator for RawBlockTransactions {
+    type Item = Vec<u8>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let body = self.bodies.next()?;
+        let witnesses = self.witnesses.next()?;
+        let tx_index = self.index;
+        self.index += 1;
+
+        Some(Self::serialize_transaction_from_components(
+            &body,
+            &witnesses,
+            !self.invalid_transactions.as_ref().is_some_and(|set| set.contains(&tx_index)),
+            self.auxiliary_data.get(&tx_index).map(Vec::as_slice),
+        ))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.bodies.size_hint()
+    }
+}
+
+impl ExactSizeIterator for RawBlockTransactions {
+    fn len(&self) -> usize {
+        self.bodies.len()
+    }
+}
+
+impl RawBlockTransactions {
+    fn serialize_transaction_from_components(
+        body: &[u8],
+        witnesses: &[u8],
+        is_expected_valid: bool,
+        auxiliary_data: Option<&[u8]>,
+    ) -> Vec<u8> {
+        let mut tx_bytes = Vec::with_capacity(body.len() + witnesses.len() + auxiliary_data.map_or(1, |x| x.len()) + 3);
+
+        tx_bytes.push(0x84);
+        tx_bytes.extend_from_slice(body);
+        tx_bytes.extend_from_slice(witnesses);
+        tx_bytes.push(if is_expected_valid { 0xf5 } else { 0xf4 });
+        match auxiliary_data {
+            Some(aux) => tx_bytes.extend_from_slice(aux),
+            None => tx_bytes.push(0xf6),
+        }
+
+        tx_bytes
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use amaru_minicbor_extra::{from_cbor, to_cbor};
 
     use crate::{
-        BlockHeader, TESTNET_ERA_HISTORY,
+        Block, BlockHeader, TESTNET_ERA_HISTORY, Transaction,
         cardano::network_block::{NetworkBlock, make_block_with_header},
-        make_header,
+        include_cbor, make_header,
     };
 
     #[test]
@@ -90,4 +190,21 @@ mod tests {
         let decoded_block = raw_block.decode().expect("raw block should decode");
         assert_eq!(decoded_block, block);
     }
+
+    #[test]
+    fn iterate_over_serialized_transactions() {
+        let (_era, block): (crate::EraName, Block) = include_cbor!(
+            "cbor.decode/block/b9bef52dd8dedf992837d20c18399a284d80fde0ae9435f2a33649aaee7c5698/sample.cbor"
+        );
+        let raw_block = NetworkBlock::new(&crate::PREPROD_ERA_HISTORY, &block).expect("make network block").raw_block();
+        let mut txs = raw_block.transactions().expect("extract transactions");
+
+        assert_eq!(txs.len(), 1);
+
+        let tx_bytes = txs.next().expect("the first transaction");
+        let tx: Transaction = minicbor::decode(&tx_bytes).expect("decode extracted transaction");
+
+        assert!(!tx_bytes.is_empty());
+        assert_eq!(tx.body.id().to_string(), "3741dc1d8f14f938904388bb257a05b361ac1e9f447db11032bb2577ff0cbd38");
+    }
 }

crates/amaru-kernel/src/cardano/raw_block.rs

@@ -177,9 +177,10 @@ pub use cardano::{
 
 pub mod cbor {
     pub use amaru_minicbor_extra::{
-        TAG_MAP_259, TAG_SET_258, allow_tag, check_tagged_array_length, decode_break, expect_tag, from_cbor,
-        from_cbor_no_leftovers, from_cbor_no_leftovers_with, heterogeneous_array, heterogeneous_map, lazy,
-        missing_field, tee, to_cbor, unexpected_field,
+        TAG_MAP_259, TAG_SET_258, allow_tag, check_tagged_array_length, collect_array_item_bytes,
+        collect_map_value_bytes, decode_break, expect_tag, from_cbor, from_cbor_no_leftovers,
+        from_cbor_no_leftovers_with, heterogeneous_array, heterogeneous_map, lazy, missing_field, tee, to_cbor,
+        unexpected_field,
     };
     pub use minicbor::{
         CborLen, Decode, Decoder, Encode, Encoder, bytes,