Merge branch 'main' into feat/split-kes-period-functions

Author: falcucci

.github/workflows/ci.yml

@@ -266,13 +266,13 @@ jobs:
       matrix:
         mode: [ "std" ]
         era: ${{ fromJSON(needs.build-ubuntu-X64.outputs.eras) }}
-        cardano_node_version: [ "8.7.3" ]
+        cardano_node_version: [ "8.7.3", "8.8.1-pre", "8.9.0" ]
         hard_fork_latest_era_at_epoch: [ 0,10,100 ]
-        run_id: [ "#1","#2" ]
+        run_id: [ "#1" ]
         extra_args: [ "" ]
 
         include:
-          # Include a hard fork test for `8.1.2` which is not concerned
+          # Include a test for `8.1.2` which is not concerned by the hard fork 
           - mode: "std"
             era: ${{ fromJSON(needs.build-ubuntu-X64.outputs.eras)[0] }}
             cardano_node_version: "8.1.2"
@@ -527,7 +527,7 @@ jobs:
           version-name: unstable-${{ steps.slug.outputs.sha8 }}
           download-url-base: ${{ github.server_url }}/${{ github.repository }}/releases/download/unstable
           gpg-secret-key: ${{ secrets.GPG_SECRET_KEY }}
-          compatibility-table: '{ "release-mainnet": "⛔", "release-preprod": "⛔", "pre-release-preview": "⛔", "testing-preview": "✔" }'
+          compatibility-table: '{ "release-mainnet": "⛔", "release-preprod": "⛔", "pre-release-preview": "⛔", "testing-preview": "✔", "testing-sanchonet": "✔" }'
 
       - name: Update unstable release
         uses: marvinpinto/action-automatic-releases@latest

.github/workflows/pre-release.yml

@@ -64,7 +64,7 @@ jobs:
           version-name: ${{ github.ref_name }}
           download-url-base: ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ github.ref_name }}
           gpg-secret-key: ${{ secrets.GPG_SECRET_KEY }}
-          compatibility-table: '{ "release-mainnet": "⛔", "release-preprod": "⛔", "pre-release-preview": "✔", "testing-preview": "✔" }'
+          compatibility-table: '{ "release-mainnet": "⛔", "release-preprod": "⛔", "pre-release-preview": "✔", "testing-preview": "✔", "testing-sanchonet": "✔" }'
 
       - name: Create pre-release ${{ github.ref_name }}
         uses: marvinpinto/action-automatic-releases@latest

Cargo.lock

@@ -32,7 +32,7 @@ RUN /app/target/release/mithril-aggregator --version
 FROM debian:11-slim
 
 # Args
-ARG CARDANO_NODE_VERSION=8.7.3
+ARG CARDANO_NODE_VERSION=8.9.0
 ARG CARDANO_BIN_URL=https://github.com/input-output-hk/cardano-node/releases/download/$CARDANO_NODE_VERSION/cardano-node-$CARDANO_NODE_VERSION-linux.tar.gz
 
 # Upgrade
@@ -47,16 +47,16 @@ COPY --from=rustbuilder /app/target/release/mithril-aggregator /app/bin/mithril-
 # Copy the config files
 COPY --from=rustbuilder /app/mithril-aggregator/config /app/config
 
-#Workdir
-WORKDIR /app/
-RUN chown -R appuser /app/
-
 # Install cardano-cli
 RUN wget -nv -O cardano-bin.tar.gz $CARDANO_BIN_URL
-RUN tar xzf cardano-bin.tar.gz ./cardano-cli && mv cardano-cli /app/bin
+RUN (tar xzf cardano-bin.tar.gz ./bin/cardano-cli && mv /bin/cardano-cli /app/bin) || (tar xzf cardano-bin.tar.gz ./cardano-cli && mv cardano-cli /app/bin)
 RUN /app/bin/cardano-cli --version
 RUN rm -f cardano-bin.tar.gz
 
+#Workdir
+WORKDIR /app/
+RUN chown -R appuser /app/
+
 # Use an unprivileged user
 USER appuser
 

mithril-aggregator/Dockerfile

@@ -14,10 +14,10 @@ RUN mkdir -p /app/bin
 RUN apt-get update -y && apt-get install -y libssl-dev ca-certificates wget && apt-get clean && rm -rf /var/lib/apt/lists/*
 
 # Install cardano-cli
-ARG CARDANO_NODE_VERSION=8.7.3
+ARG CARDANO_NODE_VERSION=8.9.0
 ARG CARDANO_BIN_URL=https://github.com/input-output-hk/cardano-node/releases/download/$CARDANO_NODE_VERSION/cardano-node-$CARDANO_NODE_VERSION-linux.tar.gz
 RUN wget -nv -O cardano-bin.tar.gz $CARDANO_BIN_URL \
-    && tar xzf cardano-bin.tar.gz ./cardano-cli && mv cardano-cli /app/bin \
+    && (tar xzf cardano-bin.tar.gz ./bin/cardano-cli && mv /bin/cardano-cli /app/bin) || (tar xzf cardano-bin.tar.gz ./cardano-cli && mv cardano-cli /app/bin) \ 
     && /app/bin/cardano-cli --version \
     && rm -f cardano-bin.tar.gz
 

mithril-aggregator/Dockerfile.ci

@@ -37,6 +37,11 @@ fn proof_cardano_transaction(
 }
 
 mod handlers {
+    use mithril_common::{
+        entities::{CardanoTransactionsSnapshot, SignedEntity},
+        messages::CardanoTransactionsProofsMessage,
+        StdResult,
+    };
     use reqwest::StatusCode;
     use slog_scope::{debug, warn};
     use std::{convert::Infallible, sync::Arc};
@@ -72,23 +77,9 @@ mod handlers {
             "proof_cardano_transaction::error"
         ) {
             Some(signed_entity) => {
-                let transactions_set_proofs = unwrap_to_internal_server_error!(
-                    prover_service
-                        .compute_transactions_proofs(
-                            &signed_entity.artifact.beacon,
-                            transaction_hashes.as_slice(),
-                        )
-                        .await,
-                    "proof_cardano_transaction::error"
-                );
-
                 let message = unwrap_to_internal_server_error!(
-                    ToCardanoTransactionsProofsMessageAdapter::try_adapt(
-                        &signed_entity.certificate_id,
-                        transactions_set_proofs,
-                        transaction_hashes,
-                    ),
-                    "proof_cardano_transaction::error"
+                    build_response_message(prover_service, signed_entity, transaction_hashes).await,
+                    "proof_cardano_transaction"
                 );
                 Ok(reply::json(&message, StatusCode::OK))
             }
@@ -98,14 +89,34 @@ mod handlers {
             }
         }
     }
+
+    pub async fn build_response_message(
+        prover_service: Arc<dyn ProverService>,
+        signed_entity: SignedEntity<CardanoTransactionsSnapshot>,
+        transaction_hashes: Vec<String>,
+    ) -> StdResult<CardanoTransactionsProofsMessage> {
+        let transactions_set_proofs = prover_service
+            .compute_transactions_proofs(
+                &signed_entity.artifact.beacon,
+                transaction_hashes.as_slice(),
+            )
+            .await?;
+        let message = ToCardanoTransactionsProofsMessageAdapter::try_adapt(
+            signed_entity,
+            transactions_set_proofs,
+            transaction_hashes,
+        )?;
+
+        Ok(message)
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use std::vec;
 
-    use mithril_common::test_utils::apispec::APISpec;
+    use mithril_common::{entities::Beacon, test_utils::apispec::APISpec};
 
     use anyhow::anyhow;
     use mithril_common::entities::{
@@ -136,6 +147,42 @@ mod tests {
             .and(routes(dependency_manager).with(cors))
     }
 
+    #[tokio::test]
+    async fn build_response_message_return_immutable_file_number_from_artifact_beacon() {
+        // Arrange
+        let mut mock_prover_service = MockProverService::new();
+        mock_prover_service
+            .expect_compute_transactions_proofs()
+            .returning(|_, _| Ok(vec![CardanoTransactionsSetProof::dummy()]));
+
+        let cardano_transactions_snapshot = {
+            let merkle_root = String::new();
+            let beacon = Beacon {
+                immutable_file_number: 2309,
+                ..Beacon::default()
+            };
+            CardanoTransactionsSnapshot::new(merkle_root, beacon)
+        };
+
+        let signed_entity = SignedEntity::<CardanoTransactionsSnapshot> {
+            artifact: cardano_transactions_snapshot,
+            ..SignedEntity::<CardanoTransactionsSnapshot>::dummy()
+        };
+
+        // Action
+        let transaction_hashes = vec![];
+        let message = handlers::build_response_message(
+            Arc::new(mock_prover_service),
+            signed_entity,
+            transaction_hashes,
+        )
+        .await
+        .unwrap();
+
+        // Assert
+        assert_eq!(message.latest_immutable_file_number, 2309)
+    }
+
     #[tokio::test]
     async fn proof_cardano_transaction_ok() {
         let config = Configuration::new_sample();

mithril-aggregator/src/http_server/routes/proof_routes.rs

@@ -1,3 +1,4 @@
+use mithril_common::entities::{CardanoTransactionsSnapshot, SignedEntity};
 use mithril_common::messages::CardanoTransactionsSetProofMessagePart;
 use mithril_common::{
     entities::{CardanoTransactionsSetProof, TransactionHash},
@@ -11,7 +12,7 @@ pub struct ToCardanoTransactionsProofsMessageAdapter;
 impl ToCardanoTransactionsProofsMessageAdapter {
     /// Turn an entity instance into message.
     pub fn try_adapt(
-        certificate_hash: &str,
+        signed_entity: SignedEntity<CardanoTransactionsSnapshot>,
         transactions_set_proofs: Vec<CardanoTransactionsSetProof>,
         transaction_hashes_to_certify: Vec<TransactionHash>,
     ) -> StdResult<CardanoTransactionsProofsMessage> {
@@ -21,9 +22,10 @@ impl ToCardanoTransactionsProofsMessageAdapter {
         );
 
         Ok(CardanoTransactionsProofsMessage::new(
-            certificate_hash,
+            &signed_entity.certificate_id,
             try_adapt_set_proof_message(transactions_set_proofs)?,
             transactions_hashes_not_certified,
+            signed_entity.artifact.beacon.immutable_file_number,
         ))
     }
 }
@@ -76,30 +78,33 @@ mod tests {
         let transactions_hashes_certified = &transaction_hashes[0..5];
         let transactions_hashes_non_certified = &transaction_hashes[5..];
 
-        let mut transactions_set_proofs = Vec::new();
-        for transaction_hashes_in_chunk in transactions_hashes_certified.chunks(2) {
-            let mk_proof = MKProof::from_leaves(transaction_hashes_in_chunk).unwrap();
-            transactions_set_proofs.push(CardanoTransactionsSetProof::new(
-                transaction_hashes_in_chunk.to_vec(),
-                mk_proof,
-            ))
-        }
+        let transactions_set_proofs = transactions_hashes_certified
+            .chunks(2)
+            .map(|transaction_hashes_in_chunk| {
+                let mk_proof = MKProof::from_leaves(transaction_hashes_in_chunk).unwrap();
+                CardanoTransactionsSetProof::new(transaction_hashes_in_chunk.to_vec(), mk_proof)
+            })
+            .collect::<Vec<_>>();
+
+        let signed_entity = SignedEntity::<CardanoTransactionsSnapshot>::dummy();
 
-        let certificate_hash = "certificate_hash";
         let message = ToCardanoTransactionsProofsMessageAdapter::try_adapt(
-            certificate_hash,
+            signed_entity.clone(),
             transactions_set_proofs.clone(),
             transaction_hashes.to_vec(),
         )
         .unwrap();
-        let transactions_set_proofs = transactions_set_proofs
+
+        let transactions_set_proof_message_part = transactions_set_proofs
             .into_iter()
             .map(|p| p.try_into().unwrap())
             .collect();
+
         let expected_message = CardanoTransactionsProofsMessage::new(
-            certificate_hash,
-            transactions_set_proofs,
+            &signed_entity.certificate_id,
+            transactions_set_proof_message_part,
             transactions_hashes_non_certified.to_vec(),
+            signed_entity.artifact.beacon.immutable_file_number,
         );
         assert_eq!(expected_message, message);
     }

mithril-aggregator/src/message_adapters/to_cardano_transactions_proof_message.rs

@@ -239,8 +239,12 @@ mod tests {
         let mut aggregator_client = MockAggregatorHTTPClient::new();
         let certificate_hash = "cert-hash-123".to_string();
         let set_proof = CardanoTransactionsSetProof::dummy();
-        let transactions_proofs =
-            CardanoTransactionsProofs::new(&certificate_hash, vec![set_proof.clone()], vec![]);
+        let transactions_proofs = CardanoTransactionsProofs::new(
+            &certificate_hash,
+            vec![set_proof.clone()],
+            vec![],
+            99999,
+        );
         let expected_transactions_proofs = transactions_proofs.clone();
         aggregator_client
             .expect_get_content()

mithril-client/src/cardano_transaction_client.rs

@@ -163,6 +163,7 @@ mod proof {
                     proof: ProtocolMkProof::new(proof.clone()).to_json_hex().unwrap(),
                 }],
                 non_certified_transactions: vec![],
+                latest_immutable_file_number: 9999,
             })
             .unwrap();
 
@@ -175,6 +176,10 @@ mod proof {
                     ProtocolMessagePartKey::CardanoTransactionsMerkleRoot,
                     proof.root().to_hex(),
                 );
+                cert.protocol_message.set_message_part(
+                    ProtocolMessagePartKey::LatestImmutableFileNumber,
+                    9999.to_string(),
+                );
                 cert.signed_message = cert.protocol_message.compute_hash();
                 cert
             };