chore: cleanup and fmt

Author: stephenctw

cartesi-rollups/contracts/src/DaveConsensus.sol

@@ -167,7 +167,7 @@ contract DaveConsensus is IDataProvider, IOutputsMerkleRootValidator, ERC165 {
         require(proof.length == Memory.LOG2_MAX_SIZE, OutputTreeProofWrongSize(proof.length));
         bytes32 machineStateHash = Machine.Hash.unwrap(finalMachineStateHash);
         bytes32 allegedStateHash = proof.merkleRootAfterReplacement(
-          EmulatorConstants.PMA_CMIO_TX_BUFFER_START >> 5, keccak256(abi.encode(outputTreeHash))
+            EmulatorConstants.PMA_CMIO_TX_BUFFER_START >> 5, keccak256(abi.encode(outputTreeHash))
         );
         require(machineStateHash == allegedStateHash, OutputTreeInvalidProof(finalMachineStateHash));
         _outputsMerkleRoots[outputTreeHash] = true;

cartesi-rollups/node/blockchain-reader/src/lib.rs

@@ -69,12 +69,12 @@ where
         provider_url: &str,
         sleep_duration: u64,
     ) -> Result<Self, SM> {
-        let partition_provider = PartitionProvider::new(provider_url)
-            .map_err(|e| BlockchainReaderError::ParseError(e))?;
+        let partition_provider =
+            PartitionProvider::new(provider_url).map_err(BlockchainReaderError::ParseError)?;
         // read from DB the block of the most recent processed
         let prev_block = state_manager
             .latest_processed_block()
-            .map_err(|e| BlockchainReaderError::StateManagerError(e))?;
+            .map_err(BlockchainReaderError::StateManagerError)?;
 
         Ok(Self {
             state_manager,
@@ -108,7 +108,7 @@ where
                 inputs.iter().collect::<Vec<&Input>>().into_iter(),
                 epochs.iter().collect::<Vec<&Epoch>>().into_iter(),
             )
-            .map_err(|e| BlockchainReaderError::StateManagerError(e))?;
+            .map_err(BlockchainReaderError::StateManagerError)?;
 
         Ok(())
     }
@@ -126,7 +126,7 @@ where
         let last_sealed_epoch_opt = self
             .state_manager
             .last_sealed_epoch()
-            .map_err(|e| BlockchainReaderError::StateManagerError(e))?;
+            .map_err(BlockchainReaderError::StateManagerError)?;
         let mut merged_sealed_epochs = Vec::new();
         if let Some(last_sealed_epoch) = last_sealed_epoch_opt {
             merged_sealed_epochs.push(last_sealed_epoch);
@@ -203,7 +203,7 @@ where
         let last_input = self
             .state_manager
             .last_input()
-            .map_err(|e| BlockchainReaderError::StateManagerError(e))?;
+            .map_err(BlockchainReaderError::StateManagerError)?;
 
         let (mut next_input_index_in_epoch, mut last_input_epoch_number) = {
             match last_input {

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

@@ -55,7 +55,7 @@ where
     ) -> Result<Self, SM> {
         let (snapshot, epoch_number, next_input_index_in_epoch) = match state_manager
             .latest_snapshot()
-            .map_err(|e| MachineRunnerError::StateManagerError(e))?
+            .map_err(MachineRunnerError::StateManagerError)?
         {
             Some(r) => (r.0, r.1, r.2 + 1),
             None => (initial_machine.to_string(), 0, 0),
@@ -95,13 +95,14 @@ where
             let latest_epoch = self
                 .state_manager
                 .epoch_count()
-                .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+                .map_err(MachineRunnerError::StateManagerError)?;
 
             if self.epoch_number == latest_epoch {
                 // all inputs processed in current epoch
                 // epoch may still be open, come back later
                 break Ok(());
             } else {
+                // epoch has advanced, fill in the rest of machine state hashes of self.epoch_number
                 assert!(self.epoch_number < latest_epoch);
 
                 // Add remaining strides
@@ -135,7 +136,7 @@ where
                     epoch_number: self.epoch_number,
                     input_index_in_epoch: self.next_input_index_in_epoch,
                 })
-                .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+                .map_err(MachineRunnerError::StateManagerError)?;
 
             match next {
                 Some(input) => {
@@ -151,7 +152,7 @@ where
         let state_hashes = self
             .state_manager
             .machine_state_hashes(self.epoch_number)
-            .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+            .map_err(MachineRunnerError::StateManagerError)?;
 
         let computation_hash = build_commitment_from_hashes(&state_hashes)?;
 
@@ -169,7 +170,7 @@ where
                 &siblings,
                 self.epoch_number,
             )
-            .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+            .map_err(MachineRunnerError::StateManagerError)?;
 
         Ok(())
     }
@@ -224,7 +225,7 @@ where
                 self.state_hash_index_in_epoch,
                 repetitions,
             )
-            .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+            .map_err(MachineRunnerError::StateManagerError)?;
         self.state_hash_index_in_epoch += 1;
 
         Ok(machine_state_hash)
@@ -254,7 +255,7 @@ where
                     self.epoch_number,
                     self.next_input_index_in_epoch,
                 )
-                .map_err(|e| MachineRunnerError::StateManagerError(e))?;
+                .map_err(MachineRunnerError::StateManagerError)?;
             self.machine.store(&snapshot_path)?;
         }