feat(node): add output merkle and proof for settle

Author: stephenctw

cartesi-rollups/node/epoch-manager/src/lib.rs

@@ -1,11 +1,15 @@
-use alloy::{hex::ToHexExt, primitives::Address, providers::DynProvider};
+use alloy::{
+    hex::ToHexExt,
+    primitives::{Address, B256},
+    providers::DynProvider,
+};
 use anyhow::Result;
 use log::{error, info, trace};
 use num_traits::cast::ToPrimitive;
 use std::{sync::Arc, time::Duration};
 
 use cartesi_dave_contracts::daveconsensus;
-use rollups_state_manager::StateManager;
+use rollups_state_manager::{Proof, StateManager};
 
 pub struct EpochManager<SM: StateManager> {
     client: DynProvider,
@@ -38,13 +42,13 @@ where
             let can_settle = dave_consensus.canSettle().call().await?;
 
             if can_settle.isFinished {
-                match self.state_manager.computation_hash(
+                match self.state_manager.settlement_info(
                     can_settle
                         .epochNumber
                         .to_u64()
                         .expect("fail to convert epoch number to u64"),
                 )? {
-                    Some(computation_hash) => {
+                    Some((computation_hash, output_merkle, output_proof)) => {
                         assert_eq!(
                             computation_hash,
                             can_settle.winnerCommitment.to_vec(),
@@ -55,7 +59,15 @@ where
                             can_settle.epochNumber,
                             computation_hash.encode_hex()
                         );
-                        match dave_consensus.settle(can_settle.epochNumber).send().await {
+                        match dave_consensus
+                            .settle(
+                                can_settle.epochNumber,
+                                Self::vec_u8_to_bytes_32(output_merkle),
+                                Self::to_bytes_32_vec(output_proof),
+                            )
+                            .send()
+                            .await
+                        {
                             Ok(tx_builder) => {
                                 let _ = tx_builder.watch().await.inspect_err(|e| error!("{}", e));
                             }
@@ -73,4 +85,14 @@ where
             tokio::time::sleep(self.sleep_duration).await;
         }
     }
+
+    fn to_bytes_32_vec(proof: Proof) -> Vec<B256> {
+        proof.inner().iter().map(|hash| B256::from(hash)).collect()
+    }
+
+    fn vec_u8_to_bytes_32(vec: Vec<u8>) -> B256 {
+        let mut array = [0u8; 32];
+        array.copy_from_slice(&vec[..32]);
+        B256::from(array)
+    }
 }

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

@@ -14,14 +14,14 @@ use std::{
 use cartesi_dave_merkle::{Digest, DigestError, MerkleBuilder};
 use cartesi_machine::{
     config::runtime::RuntimeConfig,
-    constants::break_reason,
+    constants::{break_reason, pma::TX_START},
     machine::Machine,
     types::{cmio::CmioResponseReason, Hash},
 };
 use cartesi_prt_core::machine::constants::{
     LOG2_BARCH_SPAN_TO_INPUT, LOG2_INPUT_SPAN_TO_EPOCH, LOG2_UARCH_SPAN_TO_BARCH,
 };
-use rollups_state_manager::{InputId, StateManager};
+use rollups_state_manager::{InputId, Proof, StateManager};
 
 // gap of each leaf in the commitment tree, should use the same value as CanonicalConstants.sol:log2step(0)
 const LOG2_STRIDE: u64 = 44;
@@ -101,7 +101,9 @@ where
                 assert!(self.epoch_number < latest_epoch);
 
                 let commitment = self.build_commitment()?;
-                self.save_commitment(&commitment)?;
+                let (output_merkle, output_proof) = self.get_output_merkle_and_proof()?;
+
+                self.save_settlement_info(&commitment, &output_merkle, &output_proof)?;
 
                 // end of current epoch
                 self.epoch_number += 1;
@@ -159,9 +161,27 @@ where
         Ok(computation_hash)
     }
 
-    fn save_commitment(&self, computation_hash: &[u8]) -> Result<(), SM> {
+    /// get output merkle and output proof
+    fn get_output_merkle_and_proof(&mut self) -> Result<(Vec<u8>, Proof), SM> {
+        let proof = self.machine.proof(TX_START, 5)?;
+        let output_merkle = self.machine.read_memory(TX_START, 32)?;
+
+        Ok((output_merkle, Proof::new(proof.sibling_hashes)))
+    }
+
+    fn save_settlement_info(
+        &self,
+        computation_hash: &[u8],
+        output_merkle: &[u8],
+        output_proof: &Proof,
+    ) -> Result<(), SM> {
         self.state_manager
-            .add_computation_hash(computation_hash, self.epoch_number)
+            .add_settlement_info(
+                computation_hash,
+                output_merkle,
+                output_proof,
+                self.epoch_number,
+            )
             .map_err(|e| MachineRunnerError::StateManagerError(e))?;
 
         Ok(())

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

@@ -45,7 +45,7 @@ where
             if let Some(last_sealed_epoch) = self.state_manager.last_sealed_epoch()? {
                 match self
                     .state_manager
-                    .computation_hash(last_sealed_epoch.epoch_number)?
+                    .settlement_info(last_sealed_epoch.epoch_number)?
                 {
                     Some(_) => {
                         if let Some(snapshot) = self

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

@@ -6,9 +6,48 @@ pub mod persistent_state_access;
 pub(crate) mod sql;
 
 use std::error::Error;
-
 pub type Blob = Vec<u8>;
 
+#[derive(Debug, PartialEq)]
+pub struct Proof(Vec<[u8; 32]>);
+impl From<Vec<u8>> for Proof {
+    fn from(input: Vec<u8>) -> Self {
+        // Ensure the length is a multiple of 32
+        assert!(
+            input.len() % 32 == 0,
+            "Input length must be a multiple of 32"
+        );
+
+        let mut result = Vec::new();
+
+        for chunk in input.chunks(32) {
+            let mut array = [0u8; 32];
+            array.copy_from_slice(chunk);
+            result.push(array);
+        }
+
+        Proof(result)
+    }
+}
+
+impl Proof {
+    pub fn new(siblings: Vec<[u8; 32]>) -> Self {
+        Self(siblings)
+    }
+
+    pub fn inner(&self) -> Vec<[u8; 32]> {
+        self.0.clone()
+    }
+
+    fn flatten(&self) -> Vec<u8> {
+        self.0
+            .iter()
+            .flat_map(|array| array.iter())
+            .copied()
+            .collect()
+    }
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct InputId {
     pub epoch_number: u64,
@@ -104,10 +143,15 @@ pub trait StateManager {
         state_hash_index_in_epoch: u64,
     ) -> Result<(Vec<u8>, u64), Self::Error>;
     fn machine_state_hashes(&self, epoch_number: u64) -> Result<Vec<(Vec<u8>, u64)>, Self::Error>;
-    fn computation_hash(&self, epoch_number: u64) -> Result<Option<Vec<u8>>, Self::Error>;
-    fn add_computation_hash(
+    fn settlement_info(
+        &self,
+        epoch_number: u64,
+    ) -> Result<Option<(Vec<u8>, Vec<u8>, Proof)>, Self::Error>;
+    fn add_settlement_info(
         &self,
         computation_hash: &[u8],
+        output_merkle: &[u8],
+        output_proof: &Proof,
         epoch_number: u64,
     ) -> Result<(), Self::Error>;
     fn add_snapshot(

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 (see LICENSE)
 
 use crate::sql::{consensus_data, error::*, migrations};
-use crate::{Epoch, Input, InputId, StateManager};
+use crate::{Epoch, Input, InputId, Proof, StateManager};
 
 use rusqlite::{Connection, OptionalExtension};
 use std::sync::Mutex;
@@ -179,25 +179,35 @@ impl StateManager for PersistentStateAccess {
         Ok(())
     }
 
-    fn computation_hash(&self, epoch_number: u64) -> Result<Option<Vec<u8>>> {
+    fn settlement_info(&self, epoch_number: u64) -> Result<Option<(Vec<u8>, Vec<u8>, Proof)>> {
         let conn = self.connection.lock().unwrap();
         let mut stmt = conn.prepare(
             "\
-            SELECT computation_hash FROM computation_hashes
+            SELECT computation_hash, output_merkle, output_proof FROM settlement_info
             WHERE epoch_number = ?1
             ",
         )?;
 
         Ok(stmt
-            .query_row([epoch_number], |row| Ok(row.get(0)?))
+            .query_row([epoch_number], |row| {
+                Ok((row.get(0)?, row.get(1)?, row.get::<_, Vec<u8>>(2)?.into()))
+            })
             .optional()?)
     }
 
-    fn add_computation_hash(&self, computation_hash: &[u8], epoch_number: u64) -> Result<()> {
-        match self.computation_hash(epoch_number)? {
-            Some(c) => {
-                // previous row with same key found, all values should match
+    fn add_settlement_info(
+        &self,
+        computation_hash: &[u8],
+        output_merkle: &[u8],
+        output_proof: &Proof,
+        epoch_number: u64,
+    ) -> Result<()> {
+        match self.settlement_info(epoch_number)? {
+            Some((c, o_m, o_p)) => {
+                // a row with same key found, all values should match
                 assert!(c == computation_hash.to_vec());
+                assert!(o_m == output_merkle.to_vec());
+                assert!(o_p == *output_proof);
 
                 return Ok(());
             }
@@ -206,10 +216,16 @@ impl StateManager for PersistentStateAccess {
 
         let conn = self.connection.lock().unwrap();
         let mut sttm = conn.prepare(
-            "INSERT INTO computation_hashes (epoch_number, computation_hash) VALUES (?1, ?2)",
+            "INSERT INTO settlement_info (epoch_number, computation_hash, output_merkle, output_proof) VALUES (?1, ?2, ?3, ?4)",
         )?;
 
-        if sttm.execute((epoch_number, computation_hash))? != 1 {
+        if sttm.execute((
+            epoch_number,
+            computation_hash,
+            output_merkle,
+            output_proof.flatten(),
+        ))? != 1
+        {
             return Err(PersistentStateAccessError::InsertionFailed {
                 description: "machine computation_hash insertion failed".to_owned(),
             });
@@ -577,17 +593,23 @@ mod tests {
         );
 
         assert!(
-            access.computation_hash(0)?.is_none(),
+            access.settlement_info(0)?.is_none(),
             "computation_hash shouldn't exist"
         );
 
         let computation_hash_1 = vec![1, 2, 3, 4, 5];
-        access.add_computation_hash(&computation_hash_1, 0)?;
+        let output_merkle_1 = vec![1, 2, 3, 4, 4];
+        let output_proof_1: Proof = vec![
+            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+            25, 26, 27, 28, 29, 30, 31, 32,
+        ]
+        .into();
+        access.add_settlement_info(&computation_hash_1, &output_merkle_1, &output_proof_1, 0)?;
 
         assert_eq!(
-            access.computation_hash(0)?,
-            Some(computation_hash_1),
-            "computation_hash 1 should match"
+            access.settlement_info(0)?,
+            Some((computation_hash_1, output_merkle_1, output_proof_1)),
+            "settlement info of epoch 0 should match"
         );
 
         Ok(())

cartesi-rollups/node/state-manager/src/sql/migrations.sql

@@ -1,6 +1,8 @@
-CREATE TABLE computation_hashes (
+CREATE TABLE settlement_info (
     epoch_number INTEGER NOT NULL PRIMARY KEY,
-    computation_hash BLOB NOT NULL
+    computation_hash BLOB NOT NULL,
+    output_merkle BLOB NOT NULL,
+    output_proof BLOB NOT NULL
 );
 
 CREATE TABLE epochs (