Allow to simulate a rollback In integration tests with a specific SlotNumber and BlockNumber

Author: sfauvel

mithril-aggregator/tests/create_certificate.rs

@@ -33,10 +33,7 @@ async fn create_certificate() {
             epoch: Epoch(1),
             immutable_file_number: 1,
             chain_point: ChainPoint {
-                // TODO: It's probably not a good idea to have the same slot_number and block_number. Can we change this?
-                // Note: slot_number and block_number need to be equal
-                // to check the expected when we increase both with `increase_block_number_and_slot_number`
-                slot_number: SlotNumber(100),
+                slot_number: SlotNumber(10),
                 block_number: BlockNumber(100),
                 block_hash: "block_hash-100".to_string(),
             },
@@ -149,7 +146,7 @@ async fn create_certificate() {
         the state machine should be signing CardanoTransactions for block 179"
     );
     tester
-        .increase_block_number_and_slot_number(85, 185)
+        .increase_block_number_and_slot_number(85, SlotNumber(95), BlockNumber(185))
         .await
         .unwrap();
     cycle!(tester, "signing");
@@ -187,7 +184,7 @@ async fn create_certificate() {
         the state machine should be signing CardanoTransactions for block 120"
     );
     tester
-        .cardano_chain_send_rollback(SlotNumber(149))
+        .cardano_chain_send_rollback(SlotNumber(95), BlockNumber(149))
         .await
         .unwrap();
     cycle!(tester, "signing");

mithril-aggregator/tests/prove_transactions.rs

@@ -35,10 +35,7 @@ async fn prove_transactions() {
             epoch: Epoch(1),
             immutable_file_number: 1,
             chain_point: ChainPoint {
-                // TODO: It's probably not a good idea to have the same slot_number and block_number. Can we change this?
-                // Note: slot_number and block_number need to be equal
-                // to check the expected when we increase both with `increase_block_number_and_slot_number`
-                slot_number: SlotNumber(100),
+                slot_number: SlotNumber(10),
                 block_number: BlockNumber(100),
                 block_hash: "block_hash-100".to_string(),
             },
@@ -93,7 +90,7 @@ async fn prove_transactions() {
         the state machine should be signing CardanoTransactions up to block 179 included"
     );
     tester
-        .increase_block_number_and_slot_number(85, 185)
+        .increase_block_number_and_slot_number(85, SlotNumber(95), BlockNumber(185))
         .await
         .unwrap();
     cycle!(tester, "signing");

mithril-aggregator/tests/test_extensions/runtime_tester.rs

@@ -261,40 +261,42 @@ impl RuntimeTester {
     pub async fn increase_block_number_and_slot_number(
         &mut self,
         increment: u64,
-        expected: u64,
+        expected_slot_number: SlotNumber,
+        expected_block_number: BlockNumber,
     ) -> StdResult<()> {
-        let new_block_number = self
-            .chain_observer
-            .increase_block_number(increment)
-            .await
-            .ok_or_else(|| anyhow!("no block number returned".to_string()))?;
-
         let new_slot_number = self
             .chain_observer
             .increase_slot_number(increment)
             .await
             .ok_or_else(|| anyhow!("no slot number returned".to_string()))?;
 
+        let new_block_number = self
+            .chain_observer
+            .increase_block_number(increment)
+            .await
+            .ok_or_else(|| anyhow!("no block number returned".to_string()))?;
+
         anyhow::ensure!(
-            expected == new_block_number,
-            "expected to increase block number up to {expected}, got {new_block_number}",
+            expected_slot_number == new_slot_number,
+            format!("expected to increase slot number up to {expected_slot_number}, got {new_slot_number}"),
         );
 
         anyhow::ensure!(
-            expected == new_slot_number,
-            format!("expected to increase slot number up to {expected}, got {new_slot_number}"),
+            expected_block_number == new_block_number,
+            "expected to increase block number up to {expected_block_number}, got {new_block_number}",
         );
 
         // Make the block scanner return new blocks
-        let blocks_to_scan: Vec<ScannedBlock> = ((expected - increment + 1)..=expected)
-            .map(|block_number| {
+        let blocks_to_scan: Vec<ScannedBlock> = (1..=increment)
+            .map(|index_number| {
+                let block_number = expected_block_number - increment + index_number;
+                let slot_number = expected_slot_number - increment + index_number;
                 let block_hash = format!("block_hash-{block_number}");
-                let slot_number = block_number;
                 ScannedBlock::new(
                     block_hash,
-                    BlockNumber(block_number),
-                    SlotNumber(slot_number),
-                    vec![tx_hash(block_number, 1)],
+                    block_number,
+                    slot_number,
+                    vec![tx_hash(*block_number, 1)],
                 )
             })
             .collect();
@@ -306,38 +308,43 @@ impl RuntimeTester {
     pub async fn cardano_chain_send_rollback(
         &mut self,
         rollback_to_slot_number: SlotNumber,
+        rollback_to_block_number: BlockNumber,
     ) -> StdResult<()> {
-        let actual_slot_number = self
+        let chain_point = self
             .chain_observer
             .get_current_chain_point()
             .await?
-            .map(|c| c.slot_number)
-            .ok_or_else(|| anyhow!("no slot number returned".to_string()))?;
+            .ok_or_else(|| anyhow!("no chain point returned".to_string()))?;
+
+        let decrement_slot_number = chain_point.slot_number - rollback_to_slot_number;
+        let decrement_block_number = chain_point.block_number - rollback_to_block_number;
 
-        let decrement = actual_slot_number - rollback_to_slot_number;
         let new_slot_number = self
             .chain_observer
-            .decrease_slot_number(*decrement)
+            .decrease_slot_number(*decrement_slot_number)
             .await
             .ok_or_else(|| anyhow!("no slot number returned".to_string()))?;
 
-        // TODO: Needed for CardanoTransaction that use the block number. Is it normal ?
-        // Without this decrease_block_number, the create_certificate fail trying to sign a CardanoTransaction after a rollback.
-        let _new_block_number = self
+        let new_block_number = self
             .chain_observer
-            .decrease_block_number(*decrement)
+            .decrease_block_number(*decrement_block_number)
             .await
             .ok_or_else(|| anyhow!("no block number returned".to_string()))?;
 
         anyhow::ensure!(
             rollback_to_slot_number == new_slot_number,
-            "expected to increase slot number up to {rollback_to_slot_number}, got {new_slot_number}",
+            "expected to decrease slot number to {rollback_to_slot_number}, got {new_slot_number}",
+        );
+
+        anyhow::ensure!(
+            rollback_to_block_number == new_block_number,
+            "expected to decrease block number to {rollback_to_block_number}, got {new_block_number}",
         );
 
         let chain_point = ChainPoint {
             slot_number: rollback_to_slot_number,
-            block_number: BlockNumber(*rollback_to_slot_number),
-            block_hash: format!("block_hash-{rollback_to_slot_number}"),
+            block_number: rollback_to_block_number,
+            block_hash: format!("block_hash-{rollback_to_slot_number}-{rollback_to_block_number}"),
         };
         self.block_scanner.add_backward(chain_point);
 

mithril-signer/tests/create_cardano_transaction_single_signature.rs

@@ -23,7 +23,7 @@ async fn test_create_cardano_transaction_single_signature() {
         epoch: Epoch(1),
         immutable_file_number: 1,
         chain_point: ChainPoint {
-            slot_number: SlotNumber(100),
+            slot_number: SlotNumber(10),
             // Note: the starting block number must be greater than the cardano_transactions_signing_config.step
             // so first block range root computation is not on block 0.
             block_number: BlockNumber(100),
@@ -58,7 +58,7 @@ async fn test_create_cardano_transaction_single_signature() {
         .cycle_unregistered().await.unwrap()
 
         .comment("creating a new certificate pending with a cardano transaction signed entity → Registered")
-        .increase_block_number_and_slot_number(70, 170).await.unwrap()
+        .increase_block_number_and_slot_number(70, SlotNumber(80), BlockNumber(170)).await.unwrap()
         .cycle_registered().await.unwrap()
 
         .comment("signer can now create a single signature → Signed")
@@ -69,8 +69,8 @@ async fn test_create_cardano_transaction_single_signature() {
         .cycle_signed().await.unwrap()
 
         .comment("new blocks means a new signature with the same stake distribution → Signed")
-        .increase_block_number_and_slot_number(125, 295).await.unwrap()
-        .cardano_chain_send_rollback(SlotNumber(230)).await.unwrap()
+        .increase_block_number_and_slot_number(125, SlotNumber(205), BlockNumber(295)).await.unwrap()
+        .cardano_chain_send_rollback(SlotNumber(205), BlockNumber(230)).await.unwrap()
         .cycle_registered().await.unwrap()
         .cycle_signed().await.unwrap() 
 

mithril-signer/tests/test_extensions/state_machine_tester.rs

@@ -420,39 +420,41 @@ impl StateMachineTester {
     pub async fn increase_block_number_and_slot_number(
         &mut self,
         increment: u64,
-        expected: u64,
+        expected_slot_number: SlotNumber,
+        expected_block_number: BlockNumber,
     ) -> Result<&mut Self> {
-        let new_block_number = self
-            .chain_observer
-            .increase_block_number(increment)
-            .await
-            .ok_or_else(|| TestError::ValueError("no block number returned".to_string()))?;
-
         let new_slot_number = self
             .chain_observer
             .increase_slot_number(increment)
             .await
             .ok_or_else(|| TestError::ValueError("no slot number returned".to_string()))?;
 
+        let new_block_number = self
+            .chain_observer
+            .increase_block_number(increment)
+            .await
+            .ok_or_else(|| TestError::ValueError("no block number returned".to_string()))?;
+
         self.assert(
-            expected == new_block_number,
-            format!("expected to increase block number up to {expected}, got {new_block_number}"),
+            expected_slot_number == new_slot_number,
+            format!("expected to increase slot number up to {expected_slot_number}, got {new_slot_number}"),
         )?;
 
         self.assert(
-            expected == new_slot_number,
-            format!("expected to increase slot number up to {expected}, got {new_slot_number}"),
+            expected_block_number == new_block_number,
+            format!("expected to increase block number up to {expected_block_number}, got {new_block_number}"),
         )?;
 
         // Make the block scanner return new blocks
-        let blocks_to_scan: Vec<ScannedBlock> = ((expected - increment + 1)..=expected)
-            .map(|block_number| {
+        let blocks_to_scan: Vec<ScannedBlock> = (1..=increment)
+            .map(|index_number| {
+                let block_number = expected_block_number - increment + index_number;
+                let slot_number = expected_slot_number - increment + index_number;
                 let block_hash = format!("block_hash-{block_number}");
-                let slot_number = block_number;
                 ScannedBlock::new(
                     block_hash,
-                    BlockNumber(block_number),
-                    SlotNumber(slot_number),
+                    block_number,
+                    slot_number,
                     vec![format!("tx_hash-{block_number}-1")],
                 )
             })
@@ -465,31 +467,44 @@ impl StateMachineTester {
     pub async fn cardano_chain_send_rollback(
         &mut self,
         rollback_to_slot_number: SlotNumber,
+        rollback_to_block_number: BlockNumber,
     ) -> Result<&mut Self> {
-        let actual_slot_number = self
+        let chain_point = self
             .chain_observer
             .get_current_chain_point()
             .await
             .map_err(|err| TestError::SubsystemError(anyhow!(err)))?
-            .map(|c| c.slot_number)
-            .ok_or_else(|| TestError::ValueError("no slot number returned".to_string()))?;
+            .ok_or_else(|| anyhow!("no chain point returned".to_string()))?;
+
+        let decrement_slot_number = chain_point.slot_number - rollback_to_slot_number;
+        let decrement_block_number = chain_point.block_number - rollback_to_block_number;
 
-        let decrement = actual_slot_number - rollback_to_slot_number;
         let new_slot_number = self
             .chain_observer
-            .decrease_slot_number(*decrement)
+            .decrease_slot_number(*decrement_slot_number)
             .await
             .ok_or_else(|| TestError::ValueError("no slot number returned".to_string()))?;
 
+        let new_block_number = self
+            .chain_observer
+            .decrease_block_number(*decrement_block_number)
+            .await
+            .ok_or_else(|| TestError::ValueError("no block number returned".to_string()))?;
+
         self.assert(
             rollback_to_slot_number == new_slot_number,
-            format!("expected to increase slot number up to {rollback_to_slot_number}, got {new_slot_number}"),
+            format!("expected to decrease slot number to {rollback_to_slot_number}, got {new_slot_number}"),
+        )?;
+
+        self.assert(
+            rollback_to_block_number == new_block_number,
+            format!("expected to decrease block number to {rollback_to_block_number}, got {new_block_number}"),
         )?;
 
         let chain_point = ChainPoint {
             slot_number: rollback_to_slot_number,
-            block_number: BlockNumber(*rollback_to_slot_number),
-            block_hash: format!("block_hash-{rollback_to_slot_number}"),
+            block_number: rollback_to_block_number,
+            block_hash: format!("block_hash-{rollback_to_slot_number}-{rollback_to_block_number}"),
         };
         self.block_scanner.add_backward(chain_point);