mithril_common/signable_builder/
cardano_transactions.rs

1use std::sync::Arc;
2
3use anyhow::Context;
4use async_trait::async_trait;
5
6use crate::{
7    StdResult,
8    crypto_helper::{MKMap, MKMapNode, MKTreeNode, MKTreeStorer},
9    entities::{BlockNumber, BlockRange, ProtocolMessage, ProtocolMessagePartKey},
10    signable_builder::SignableBuilder,
11};
12
13#[cfg(test)]
14use mockall::automock;
15
16/// Cardano transactions importer
17#[cfg_attr(test, automock)]
18#[async_trait]
19pub trait TransactionsImporter: Send + Sync {
20    /// Import all transactions up to the given beacon into the system
21    async fn import(&self, up_to_beacon: BlockNumber) -> StdResult<()>;
22}
23
24/// Block Range Merkle roots retriever
25#[cfg_attr(test, automock)]
26#[async_trait]
27pub trait BlockRangeRootRetriever<S: MKTreeStorer>: Send + Sync {
28    /// Returns a Merkle map of the block ranges roots up to a given beacon
29    async fn retrieve_block_range_roots<'a>(
30        &'a self,
31        up_to_beacon: BlockNumber,
32    ) -> StdResult<Box<dyn Iterator<Item = (BlockRange, MKTreeNode)> + 'a>>;
33
34    /// Returns a Merkle map of the block ranges roots up to a given beacon
35    async fn compute_merkle_map_from_block_range_roots(
36        &self,
37        up_to_beacon: BlockNumber,
38    ) -> StdResult<MKMap<BlockRange, MKMapNode<BlockRange, S>, S>> {
39        let block_range_roots_iterator = self
40            .retrieve_block_range_roots(up_to_beacon)
41            .await?
42            .map(|(block_range, root)| (block_range, root.into()));
43        let mk_hash_map = MKMap::new_from_iter(block_range_roots_iterator)
44        .with_context(|| "BlockRangeRootRetriever failed to compute the merkelized structure that proves ownership of the transaction")?;
45
46        Ok(mk_hash_map)
47    }
48}
49
50/// A [CardanoTransactionsSignableBuilder] builder
51pub struct CardanoTransactionsSignableBuilder<S: MKTreeStorer> {
52    transaction_importer: Arc<dyn TransactionsImporter>,
53    block_range_root_retriever: Arc<dyn BlockRangeRootRetriever<S>>,
54}
55
56impl<S: MKTreeStorer> CardanoTransactionsSignableBuilder<S> {
57    /// Constructor
58    pub fn new(
59        transaction_importer: Arc<dyn TransactionsImporter>,
60        block_range_root_retriever: Arc<dyn BlockRangeRootRetriever<S>>,
61    ) -> Self {
62        Self {
63            transaction_importer,
64            block_range_root_retriever,
65        }
66    }
67}
68
69#[async_trait]
70impl<S: MKTreeStorer> SignableBuilder<BlockNumber> for CardanoTransactionsSignableBuilder<S> {
71    async fn compute_protocol_message(&self, beacon: BlockNumber) -> StdResult<ProtocolMessage> {
72        self.transaction_importer.import(beacon).await?;
73
74        let mk_root = self
75            .block_range_root_retriever
76            .compute_merkle_map_from_block_range_roots(beacon)
77            .await?
78            .compute_root()?;
79
80        let mut protocol_message = ProtocolMessage::new();
81        protocol_message.set_message_part(
82            ProtocolMessagePartKey::CardanoTransactionsMerkleRoot,
83            mk_root.to_hex(),
84        );
85        protocol_message.set_message_part(
86            ProtocolMessagePartKey::LatestBlockNumber,
87            beacon.to_string(),
88        );
89
90        Ok(protocol_message)
91    }
92}
93
94#[cfg(test)]
95mod tests {
96
97    use crate::{
98        crypto_helper::MKTreeStoreInMemory, entities::CardanoTransaction,
99        test_utils::CardanoTransactionsBuilder,
100    };
101
102    use super::*;
103
104    fn compute_mk_map_from_transactions(
105        transactions: Vec<CardanoTransaction>,
106    ) -> MKMap<BlockRange, MKMapNode<BlockRange, MKTreeStoreInMemory>, MKTreeStoreInMemory> {
107        MKMap::new_from_iter(transactions.iter().map(|tx| {
108            (
109                BlockRange::from_block_number(tx.block_number),
110                MKMapNode::TreeNode(tx.transaction_hash.clone().into()),
111            )
112        }))
113        .unwrap()
114    }
115
116    #[tokio::test]
117    async fn test_compute_signable() {
118        // Arrange
119        let block_number = BlockNumber(1453);
120        let transactions = CardanoTransactionsBuilder::new().build_transactions(3);
121        let mk_map = compute_mk_map_from_transactions(transactions.clone());
122        let mut transaction_importer = MockTransactionsImporter::new();
123        transaction_importer.expect_import().return_once(move |_| Ok(()));
124        let retrieved_transactions = transactions.clone();
125        let mut block_range_root_retriever = MockBlockRangeRootRetriever::new();
126        block_range_root_retriever
127            .expect_compute_merkle_map_from_block_range_roots()
128            .return_once(move |_| Ok(compute_mk_map_from_transactions(retrieved_transactions)));
129
130        let cardano_transactions_signable_builder = CardanoTransactionsSignableBuilder::new(
131            Arc::new(transaction_importer),
132            Arc::new(block_range_root_retriever),
133        );
134
135        // Action
136        let signable = cardano_transactions_signable_builder
137            .compute_protocol_message(block_number)
138            .await
139            .unwrap();
140
141        // Assert
142        let mut signable_expected = ProtocolMessage::new();
143        signable_expected.set_message_part(
144            ProtocolMessagePartKey::CardanoTransactionsMerkleRoot,
145            mk_map.compute_root().unwrap().to_hex(),
146        );
147        signable_expected.set_message_part(
148            ProtocolMessagePartKey::LatestBlockNumber,
149            format!("{block_number}"),
150        );
151        assert_eq!(signable_expected, signable);
152    }
153
154    #[tokio::test]
155    async fn test_compute_signable_with_no_block_range_root_return_error() {
156        let block_number = BlockNumber(50);
157        let mut transaction_importer = MockTransactionsImporter::new();
158        transaction_importer.expect_import().return_once(|_| Ok(()));
159        let mut block_range_root_retriever = MockBlockRangeRootRetriever::new();
160        block_range_root_retriever
161            .expect_compute_merkle_map_from_block_range_roots()
162            .return_once(move |_| Ok(compute_mk_map_from_transactions(vec![])));
163        let cardano_transactions_signable_builder = CardanoTransactionsSignableBuilder::new(
164            Arc::new(transaction_importer),
165            Arc::new(block_range_root_retriever),
166        );
167
168        let result = cardano_transactions_signable_builder
169            .compute_protocol_message(block_number)
170            .await;
171
172        assert!(result.is_err());
173    }
174}
mithril_common/signable_builder/cardano_transactions.rs

mithril_common/signable_builder/
cardano_transactions.rs
