provide additional commitment info in getCheckpointInfo call

accept optional param in getLatestCheckpointIndex to get latest finalized checkpoint index

bin/prover-client/src/rpc_server.rs

@@ -180,6 +180,8 @@ impl StrataProverClientApiServer for ProverClientRpc {
             l1_range,
             l2_range,
             l2_blockid: Default::default(),
+            l1_blockid: Default::default(),
+            commitment: None,
         };
 
         let task_id = self

bin/strata-client/src/rpc_server.rs

@@ -32,7 +32,6 @@ use strata_rpc_types::{
 };
 use strata_rpc_utils::to_jsonrpsee_error;
 use strata_state::{
-    batch::BatchCheckpoint,
     block::L2BlockBundle,
     bridge_duties::BridgeDuty,
     bridge_ops::WithdrawalIntent,
@@ -586,18 +585,29 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
             .get_checkpoint(idx)
             .await
             .map_err(|e| Error::Other(e.to_string()))?;
-        let batch_comm: Option<BatchCheckpoint> = entry.map(Into::into);
-        Ok(batch_comm.map(|bc| bc.batch_info().clone().into()))
-    }
-
-    async fn get_latest_checkpoint_index(&self) -> RpcResult<Option<u64>> {
-        let idx = self
-            .checkpoint_handle
-            .get_last_checkpoint_idx()
-            .await
-            .map_err(|e| Error::Other(e.to_string()))?;
 
-        return Ok(idx);
+        Ok(entry.map(Into::into))
+    }
+
+    async fn get_latest_checkpoint_index(&self, finalized: Option<bool>) -> RpcResult<Option<u64>> {
+        let finalized = finalized.unwrap_or(false);
+        if finalized {
+            // get last finalized checkpoint index from state
+            let (client_state, _) = self.get_cur_states().await?;
+            Ok(client_state
+                .l1_view()
+                .last_finalized_checkpoint()
+                .map(|checkpoint| checkpoint.batch_info.idx()))
+        } else {
+            // get latest checkpoint index from db
+            let idx = self
+                .checkpoint_handle
+                .get_last_checkpoint_idx()
+                .await
+                .map_err(|e| Error::Other(e.to_string()))?;
+
+            Ok(idx)
+        }
     }
 
     async fn get_l2_block_status(&self, block_height: u64) -> RpcResult<L2BlockStatus> {

crates/consensus-logic/src/client_transition.rs

@@ -9,7 +9,7 @@ use strata_db::traits::{
 };
 use strata_primitives::prelude::*;
 use strata_state::{
-    batch::{BatchCheckpoint, BatchInfo},
+    batch::{BatchCheckpoint, BatchCheckpointWithCommitment, BatchInfo, CommitmentInfo},
     block,
     client_state::*,
     header::L2Header,
@@ -165,11 +165,12 @@ pub fn process_event<D: Database>(
                 writes.push(ClientStateWrite::CheckpointsReceived(
                     checkpoints
                         .iter()
-                        .map(|x| {
+                        .map(|batchcheckpoint_with_commitment| {
+                            let batchcheckpoint = &batchcheckpoint_with_commitment.batch_checkpoint;
                             L1Checkpoint::new(
-                                x.batch_info().clone(),
-                                x.bootstrap_state().clone(),
-                                !x.proof().is_empty(),
+                                batchcheckpoint.batch_info().clone(),
+                                batchcheckpoint.bootstrap_state().clone(),
+                                !batchcheckpoint.proof().is_empty(),
                                 *height,
                             )
                         })
@@ -278,9 +279,9 @@ fn handle_maturable_height(
 /// A vector containing the valid sequence of `BatchCheckpoint`s, starting from the first valid one.
 pub fn filter_verified_checkpoints(
     state: &ClientState,
-    checkpoints: &[BatchCheckpoint],
+    checkpoints: &[BatchCheckpointWithCommitment],
     params: &RollupParams,
-) -> Vec<BatchCheckpoint> {
+) -> Vec<BatchCheckpointWithCommitment> {
     let l1_view = state.l1_view();
     let last_verified = l1_view.verified_checkpoints().last();
     let last_finalized = l1_view.last_finalized_checkpoint();
@@ -296,14 +297,14 @@ pub fn filter_verified_checkpoints(
     let mut result_checkpoints = Vec::new();
 
     for checkpoint in checkpoints {
-        let curr_idx = checkpoint.batch_info().idx;
+        let curr_idx = checkpoint.batch_checkpoint.batch_info().idx;
         if curr_idx != expected_idx {
             warn!(%expected_idx, %curr_idx, "Received invalid checkpoint idx, ignoring.");
             continue;
         }
-        if expected_idx == 0 && verify_proof(checkpoint, params).is_ok() {
+        if expected_idx == 0 && verify_proof(&checkpoint.batch_checkpoint, params).is_ok() {
             result_checkpoints.push(checkpoint.clone());
-            last_valid_checkpoint = Some(checkpoint.batch_info());
+            last_valid_checkpoint = Some(checkpoint.batch_checkpoint.batch_info());
         } else if expected_idx == 0 {
             warn!(%expected_idx, "Received invalid checkpoint proof, ignoring.");
         } else {
@@ -313,8 +314,8 @@ pub fn filter_verified_checkpoints(
             let last_l2_tsn = last_valid_checkpoint
                 .expect("There should be a last_valid_checkpoint")
                 .l2_transition;
-            let l1_tsn = checkpoint.batch_info().l1_transition;
-            let l2_tsn = checkpoint.batch_info().l2_transition;
+            let l1_tsn = checkpoint.batch_checkpoint.batch_info().l1_transition;
+            let l2_tsn = checkpoint.batch_checkpoint.batch_info().l2_transition;
 
             if l1_tsn.0 == last_l1_tsn.1 {
                 warn!(obtained = ?l1_tsn.0, expected = ?last_l1_tsn.1, "Received invalid checkpoint l1 transition, ignoring.");
@@ -324,9 +325,9 @@ pub fn filter_verified_checkpoints(
                 warn!(obtained = ?l2_tsn.0, expected = ?last_l2_tsn.1, "Received invalid checkpoint l2 transition, ignoring.");
                 continue;
             }
-            if verify_proof(checkpoint, params).is_ok() {
+            if verify_proof(&checkpoint.batch_checkpoint, params).is_ok() {
                 result_checkpoints.push(checkpoint.clone());
-                last_valid_checkpoint = Some(checkpoint.batch_info());
+                last_valid_checkpoint = Some(checkpoint.batch_checkpoint.batch_info());
             } else {
                 warn!(%expected_idx, "Received invalid checkpoint proof, ignoring.");
                 continue;

crates/consensus-logic/src/duty/extractor.rs

@@ -52,6 +52,13 @@ fn extract_batch_duties(
         return Ok(vec![]);
     };
 
+    // BlockHash of last L1 block covered by the checkpoint
+    let Some(tip_blockid) = state.l1_view().tip_blkid() else {
+        debug!("no blocks read from L1");
+        // Cannot create checkpoint without L1 blocks
+        return Ok(vec![]);
+    };
+
     match state.l1_view().last_finalized_checkpoint() {
         // Cool, we are producing first batch!
         None => {
@@ -102,6 +109,7 @@ fn extract_batch_duties(
                 l1_transition,
                 l2_transition,
                 tip_id,
+                *tip_blockid,
                 (0, current_l1_state.total_accumulated_pow),
                 rollup_params_commitment,
             );
@@ -137,6 +145,7 @@ fn extract_batch_duties(
                 l1_transition,
                 l2_transition,
                 tip_id,
+                *tip_blockid,
                 (
                     checkpoint.l1_pow_transition.1,
                     current_l1_state.total_accumulated_pow,

crates/consensus-logic/src/l1_handler.rs

@@ -18,7 +18,10 @@ use strata_primitives::{
 use strata_risc0_adapter::Risc0Verifier;
 use strata_sp1_adapter::SP1Verifier;
 use strata_state::{
-    batch::BatchCheckpoint, l1::L1Tx, sync_event::SyncEvent, tx::ProtocolOperation,
+    batch::{BatchCheckpoint, BatchCheckpointWithCommitment, CommitmentInfo},
+    l1::L1Tx,
+    sync_event::SyncEvent,
+    tx::ProtocolOperation,
 };
 use strata_tx_parser::messages::{BlockData, L1Event};
 use strata_zkvm::ZKVMVerifier;
@@ -130,7 +133,7 @@ where
 fn check_for_da_batch(
     blockdata: &BlockData,
     seq_pubkey: Option<XOnlyPublicKey>,
-) -> Vec<BatchCheckpoint> {
+) -> Vec<BatchCheckpointWithCommitment> {
     let protocol_ops_txs = blockdata.protocol_ops_txs();
 
     let signed_checkpts = protocol_ops_txs
@@ -155,7 +158,16 @@ fn check_for_da_batch(
             }
         }
         let checkpoint: BatchCheckpoint = signed_checkpoint.clone().into();
-        Some(checkpoint)
+
+        let blockhash = Buf32::from(*blockdata.block().block_hash().as_byte_array());
+        let txid = Buf32::from(*tx.compute_txid().as_byte_array());
+        let wtxid = Buf32::from(*tx.compute_wtxid().as_byte_array());
+        let commitment_info = CommitmentInfo::new(blockhash, txid, wtxid);
+
+        Some(BatchCheckpointWithCommitment::new(
+            checkpoint,
+            commitment_info,
+        ))
     });
     sig_verified_checkpoints.collect()
 }

crates/consensus-logic/src/worker.rs

@@ -213,6 +213,8 @@ fn handle_sync_event<D: Database, E: ExecEngineCtl>(
 
             SyncAction::WriteCheckpoints(_height, checkpoints) => {
                 for c in checkpoints.iter() {
+                    let commitment_info = &c.commitment;
+                    let c = &c.batch_checkpoint;
                     let idx = c.batch_info().idx();
                     let pstatus = CheckpointProvingStatus::ProofReady;
                     let cstatus = CheckpointConfStatus::Confirmed;
@@ -222,14 +224,18 @@ fn handle_sync_event<D: Database, E: ExecEngineCtl>(
                         c.proof().clone(),
                         pstatus,
                         cstatus,
+                        Some(commitment_info.clone().into()),
                     );
 
                     // Store
                     state.checkpoint_db().put_checkpoint_blocking(idx, entry)?;
                 }
             }
+            // FIXME: never called
             SyncAction::FinalizeCheckpoints(_height, checkpoints) => {
                 for c in checkpoints.iter() {
+                    let commitment_info = &c.commitment;
+                    let c = &c.batch_checkpoint;
                     let idx = c.batch_info().idx();
                     let pstatus = CheckpointProvingStatus::ProofReady;
                     let cstatus = CheckpointConfStatus::Finalized;
@@ -239,6 +245,7 @@ fn handle_sync_event<D: Database, E: ExecEngineCtl>(
                         c.proof().clone(),
                         pstatus,
                         cstatus,
+                        Some(commitment_info.clone().into()),
                     );
 
                     // Update

crates/db/src/types.rs

@@ -8,7 +8,7 @@ use bitcoin::{
 use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize};
 use strata_primitives::buf::Buf32;
-use strata_state::batch::{BatchCheckpoint, BatchInfo, BootstrapState};
+use strata_state::batch::{BatchCheckpoint, BatchInfo, BootstrapState, CommitmentInfo};
 use strata_zkvm::Proof;
 
 /// Represents data for a blob we're still planning to inscribe.
@@ -157,6 +157,9 @@ pub struct CheckpointEntry {
 
     /// Confirmation Status
     pub confirmation_status: CheckpointConfStatus,
+
+    /// checkpoint txn info
+    pub commitment: Option<CheckpointCommitment>,
 }
 
 impl CheckpointEntry {
@@ -166,13 +169,15 @@ impl CheckpointEntry {
         proof: Proof,
         proving_status: CheckpointProvingStatus,
         confirmation_status: CheckpointConfStatus,
+        commitment: Option<CheckpointCommitment>,
     ) -> Self {
         Self {
             batch_info,
             bootstrap,
             proof,
             proving_status,
             confirmation_status,
+            commitment,
         }
     }
 
@@ -188,6 +193,7 @@ impl CheckpointEntry {
             Proof::default(),
             CheckpointProvingStatus::PendingProof,
             CheckpointConfStatus::Pending,
+            None,
         )
     }
 
@@ -225,6 +231,23 @@ pub enum CheckpointConfStatus {
     Finalized,
 }
 
+#[derive(Debug, Clone, PartialEq, BorshSerialize, BorshDeserialize, Arbitrary)]
+pub struct CheckpointCommitment {
+    pub blockhash: Buf32,
+    pub txid: Buf32,
+    pub wtxid: Buf32,
+}
+
+impl From<CommitmentInfo> for CheckpointCommitment {
+    fn from(value: CommitmentInfo) -> Self {
+        Self {
+            blockhash: value.blockhash,
+            txid: value.txid,
+            wtxid: value.wtxid,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json;

crates/proof-impl/checkpoint/src/lib.rs

@@ -86,6 +86,7 @@ pub fn process_checkpoint_proof(
             l2_batch_output.final_snapshot.hash,
         ),
         l2_batch_output.final_snapshot.l2_blockid,
+        l1_batch_output.final_snapshot.hash.into(),
         (
             l1_batch_output.initial_snapshot.acc_pow,
             l1_batch_output.final_snapshot.acc_pow,

crates/rpc/api/src/lib.rs

@@ -98,7 +98,7 @@ pub trait StrataApi {
 
     /// Get latest checkpoint info
     #[method(name = "getLatestCheckpointIndex")]
-    async fn get_latest_checkpoint_index(&self) -> RpcResult<Option<u64>>;
+    async fn get_latest_checkpoint_index(&self, finalized: Option<bool>) -> RpcResult<Option<u64>>;
 
     /// Get nth checkpoint info if any
     #[method(name = "getCheckpointInfo")]

crates/rpc/types/src/types.rs

@@ -4,10 +4,12 @@
 //!  - implementation of RPC client
 //!  - crate for just data structures that represents the JSON responses from Bitcoin core RPC
 
-use bitcoin::{Network, Txid};
+use bitcoin::{hashes::Hash, Network, Txid, Wtxid};
 use serde::{Deserialize, Serialize};
+use strata_db::types::{CheckpointCommitment, CheckpointEntry};
 use strata_state::{
     batch::BatchInfo, bridge_duties::BridgeDuty, bridge_ops::WithdrawalIntent, id::L2BlockId,
+    l1::L1BlockId,
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -196,6 +198,27 @@ pub struct RawBlockWitness {
     pub raw_chain_state: Vec<u8>,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct RpcCheckpointCommitmentInfo {
+    /// block where checkpoint was posted
+    pub blockhash: L1BlockId,
+    /// txid of txn for this checkpoint
+    pub txid: Txid,
+    /// wtxid of txn for this checkpoint
+    pub wtxid: Wtxid,
+    // other info
+}
+
+impl From<CheckpointCommitment> for RpcCheckpointCommitmentInfo {
+    fn from(value: CheckpointCommitment) -> Self {
+        Self {
+            blockhash: value.blockhash.into(),
+            txid: Txid::from_byte_array(*value.txid.as_ref()),
+            wtxid: Wtxid::from_byte_array(*value.wtxid.as_ref()),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct RpcCheckpointInfo {
     /// The index of the checkpoint
@@ -206,6 +229,10 @@ pub struct RpcCheckpointInfo {
     pub l2_range: (u64, u64),
     /// L2 block that this checkpoint covers
     pub l2_blockid: L2BlockId,
+    /// Last L1 block covered by this checkpoint
+    pub l1_blockid: L1BlockId,
+    /// Info on txn where checkpoint is committed on chain
+    pub commitment: Option<RpcCheckpointCommitmentInfo>,
 }
 
 impl From<BatchInfo> for RpcCheckpointInfo {
@@ -215,10 +242,20 @@ impl From<BatchInfo> for RpcCheckpointInfo {
             l1_range: value.l1_range,
             l2_range: value.l2_range,
             l2_blockid: value.l2_blockid,
+            l1_blockid: value.l1_blockid,
+            commitment: None,
         }
     }
 }
 
+impl From<CheckpointEntry> for RpcCheckpointInfo {
+    fn from(value: CheckpointEntry) -> Self {
+        let mut item: Self = value.batch_info.into();
+        item.commitment = value.commitment.map(Into::into);
+        item
+    }
+}
+
 /// The duties assigned to an operator within a given range.
 ///
 /// # Note