feat: handle revert in machine-runner

Author: stephenctw

cartesi-rollups/node/machine-runner/src/lib.rs

@@ -6,8 +6,8 @@ pub mod error;
 use error::Result;
 use std::{ops::ControlFlow, time::Duration};
 
+use cartesi_machine::types::cmio::ManualReason;
 use rollups_state_manager::{InputId, StateManager, rollups_machine::RollupsMachine, sync::Watch};
-
 pub struct MachineRunner<SM: StateManager> {
     state_manager: SM,
     sleep_duration: Duration,
@@ -66,9 +66,18 @@ impl<SM: StateManager + std::fmt::Debug> MachineRunner<SM> {
             match next {
                 Some(input) => {
                     log::info!("processing input {}", input.id.input_index_in_epoch);
-                    let state_hashes = rollups_machine.process_input(&input.data)?;
-                    self.state_manager
-                        .advance_accepted(rollups_machine, &state_hashes)?;
+                    let (state_hashes, reason) = rollups_machine.process_input(&input.data)?;
+
+                    match reason {
+                        ManualReason::RxAccepted { .. } => {
+                            self.state_manager
+                                .advance_accepted(rollups_machine, &state_hashes)?;
+                        }
+                        _ => {
+                            self.state_manager
+                                .advance_reverted(rollups_machine, &state_hashes)?;
+                        }
+                    }
                 }
                 None => break Ok(rollups_machine),
             }

cartesi-rollups/node/state-manager/src/persistent_state_access.rs

@@ -134,12 +134,34 @@ impl StateManager for PersistentStateAccess {
         Ok(machine)
     }
 
-    fn finish_reverted_advance(
+    fn advance_reverted(
         &mut self,
-        _machine: RollupsMachine,
-        _leafs: &[CommitmentLeaf],
+        mut machine: RollupsMachine,
+        leafs: &[CommitmentLeaf],
     ) -> Result<RollupsMachine> {
-        todo!()
+        assert!(!leafs.is_empty());
+        let epoch = machine.epoch();
+        let input = machine.input_index_in_epoch();
+
+        rollup_data::insert_state_hashes_for_input(&self.connection, epoch, input, &leafs)?;
+
+        let (snapshot_path, snapshot_epoch, snapshot_input) =
+            rollup_data::latest_snapshot_path(&self.connection)?;
+        assert_eq!(snapshot_input + 1, input);
+        assert_eq!(snapshot_epoch, epoch);
+
+        // load rollups machine from previous successful (ACCEPT) snapshot
+        machine = RollupsMachine::new(&snapshot_path, epoch, input)?;
+
+        rollup_data::insert_snapshot(
+            &self.connection,
+            epoch,
+            input,
+            &machine.state_hash()?,
+            &snapshot_path,
+        )?;
+
+        Ok(machine)
     }
 
     fn epoch_state_hashes(&mut self, epoch_number: u64) -> Result<Vec<CommitmentLeaf>> {
@@ -423,7 +445,7 @@ mod tests {
         };
 
         initial_snapshot =
-            access.finish_accepted_advance(initial_snapshot, &[commitment_leaf_1.clone()])?;
+            access.advance_accepted(initial_snapshot, &[commitment_leaf_1.clone()])?;
 
         assert_eq!(
             access.epoch_state_hashes(0)?[0],
@@ -441,7 +463,7 @@ mod tests {
 
         initial_snapshot.increment_input();
         initial_snapshot =
-            access.finish_accepted_advance(initial_snapshot, &[commitment_leaf_2.clone()])?;
+            access.advance_reverted(initial_snapshot, &[commitment_leaf_2.clone()])?;
 
         assert_eq!(
             access.epoch_state_hashes(0)?.len(),

cartesi-rollups/node/state-manager/src/rollups_machine.rs

@@ -13,7 +13,10 @@ use cartesi_machine::{
     constants::{break_reason, pma::TX_START},
     error::{MachineError, MachineResult},
     machine::Machine,
-    types::{Hash, cmio::CmioResponseReason},
+    types::{
+        Hash,
+        cmio::{CmioRequest, CmioResponseReason, ManualReason},
+    },
 };
 
 use thiserror::Error;
@@ -91,7 +94,10 @@ impl RollupsMachine {
         self.machine.root_hash()
     }
 
-    pub fn process_input(&mut self, data: &[u8]) -> MachineResult<Vec<CommitmentLeaf>> {
+    pub fn process_input(
+        &mut self,
+        data: &[u8],
+    ) -> MachineResult<(Vec<CommitmentLeaf>, ManualReason)> {
         let mut state_hashes = Vec::with_capacity(1 << 20);
 
         self.feed_input(data)?;
@@ -114,9 +120,14 @@ impl RollupsMachine {
             hash,
             repetitions: STRIDE_COUNT_IN_INPUT - i,
         });
-
         self.input_index_in_epoch += 1;
-        Ok(state_hashes)
+
+        match self.machine.receive_cmio_request()? {
+            CmioRequest::Manual(reason) => Ok((state_hashes, reason)),
+            _ => {
+                panic!("This branch should not be reached");
+            }
+        }
     }
 
     fn feed_input(&mut self, input: &[u8]) -> MachineResult<()> {

cartesi-rollups/node/state-manager/src/state_manager.rs

@@ -36,7 +36,7 @@ pub trait StateManager {
         leafs: &[CommitmentLeaf],
     ) -> Result<RollupsMachine>;
 
-    fn finish_reverted_advance(
+    fn advance_reverted(
         &mut self,
         machine: RollupsMachine,
         leafs: &[CommitmentLeaf],