STR-929 Core STF refactors

bin/prover-client/src/rpc_server.rs

@@ -159,9 +159,9 @@ impl StrataProverClientApiServer for ProverClientRpc {
 
     async fn prove_checkpoint_raw(
         &self,
-        _checkpoint_idx: u64,
-        _l1_range: (u64, u64),
-        _l2_range: (u64, u64),
+        checkpoint_idx: u64,
+        l1_range: (u64, u64),
+        l2_range: (u64, u64),
     ) -> RpcResult<Vec<ProofKey>> {
         unimplemented!()
     }

bin/strata-client/src/main.rs

@@ -256,7 +256,7 @@ fn do_startup_checks(
 
     // Check that we can connect to bitcoin client and block we believe to be matured in L1 is
     // actually present
-    let safe_l1blockid = last_chain_state.l1_view().safe_block().blkid();
+    let safe_l1blockid = last_chain_state.epoch_state().safe_l1_blkid();
     let block_hash = BlockHash::from_slice(safe_l1blockid.as_ref())?;
 
     match handle.block_on(bitcoin_client.get_block(&block_hash)) {

bin/strata-client/src/rpc_server.rs

@@ -155,7 +155,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     }
 
     async fn get_l1_status(&self) -> RpcResult<RpcL1Status> {
-        let l1s = self.status_channel.l1_status();
+        let l1s = self.status_channel.get_l1_reader_status();
         Ok(RpcL1Status::from_l1_status(
             l1s,
             self.sync_manager.params().rollup().network,
@@ -182,45 +182,50 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     }
 
     async fn get_client_status(&self) -> RpcResult<RpcClientStatus> {
-        let sync_state = self.status_channel.sync_state();
-        let l1_view = self.status_channel.l1_view();
+        let sync_state = self.status_channel.get_sync_state();
+        let l1_view = self.status_channel.get_l1_view();
 
-        let last_l1 = l1_view.tip_blkid().cloned().unwrap_or_else(|| {
-            // TODO figure out a better way to do this
-            warn!("last L1 block not set in client state, returning zero");
-            L1BlockId::from(Buf32::zero())
-        });
+        let tip_l1_blkid = l1_view.tip_l1_blkid();
 
         // Copy these out of the sync state, if they're there.
-        let (chain_tip, finalized_blkid) = sync_state
-            .map(|ss| (*ss.chain_tip_blkid(), *ss.finalized_blkid()))
+        let (chain_tip, finalized_blkid, finalized_epoch) = sync_state
+            .map(|ss| {
+                (
+                    *ss.chain_tip_blkid(),
+                    *ss.finalized_blkid(),
+                    ss.finalized_epoch(),
+                )
+            })
             .unwrap_or_default();
 
-        // FIXME make this load from cache, and put the data we actually want
-        // here in the client state
-        // FIXME error handling
-        let db = self.database.clone();
-        let slot: u64 = wait_blocking("load_cur_block", move || {
-            let l2_db = db.l2_db();
-            l2_db
-                .get_block_data(chain_tip)
-                .map(|b| b.map(|b| b.header().blockidx()).unwrap_or(u64::MAX))
-                .map_err(Error::from)
-        })
-        .await?;
+        let Some(block) = self
+            .l2_block_manager
+            .get_block_data_async(&chain_tip)
+            .map_err(Error::from)
+            .await?
+        else {
+            // We should never encounter this.
+            return Err(Error::MissingL2Block(chain_tip).into());
+        };
+
+        let slot: u64 = block.block().header().blockidx();
+        let epoch = self.status_channel.get_cur_l2_epoch().unwrap_or(0);
 
         Ok(RpcClientStatus {
             chain_tip: *chain_tip.as_ref(),
             chain_tip_slot: slot,
+            cur_epoch: epoch,
             finalized_blkid: *finalized_blkid.as_ref(),
-            last_l1_block: *last_l1.as_ref(),
-            buried_l1_height: l1_view.buried_l1_height(),
+            finalized_epoch,
+            last_l1_block: *tip_l1_blkid.as_ref(),
+            // FIXME make this coherent when we re-add this construct
+            buried_l1_height: 0,
         })
     }
 
     async fn get_recent_block_headers(&self, count: u64) -> RpcResult<Vec<RpcBlockHeader>> {
         // FIXME: sync state should have a block number
-        let sync_state = self.status_channel.sync_state();
+        let sync_state = self.status_channel.get_sync_state();
         let tip_blkid = *sync_state.ok_or(Error::ClientNotStarted)?.chain_tip_blkid();
         let db = self.database.clone();
 
@@ -251,7 +256,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     }
 
     async fn get_headers_at_idx(&self, idx: u64) -> RpcResult<Option<Vec<RpcBlockHeader>>> {
-        let sync_state = self.status_channel.sync_state();
+        let sync_state = self.status_channel.get_sync_state();
         let tip_blkid = *sync_state.ok_or(Error::ClientNotStarted)?.chain_tip_blkid();
         let db = self.database.clone();
 
@@ -370,7 +375,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     async fn get_current_deposits(&self) -> RpcResult<Vec<u32>> {
         let deps = self
             .status_channel
-            .deposits_table()
+            .get_cur_deposits_table()
             .ok_or(Error::BeforeGenesis)?;
 
         Ok(deps.get_all_deposits_idxs_iters_iter().collect())
@@ -379,7 +384,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     async fn get_current_deposit_by_id(&self, deposit_id: u32) -> RpcResult<RpcDepositEntry> {
         let deps = self
             .status_channel
-            .deposits_table()
+            .get_cur_deposits_table()
             .ok_or(Error::BeforeGenesis)?;
         Ok(deps
             .get_deposit(deposit_id)
@@ -388,12 +393,21 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     }
 
     async fn sync_status(&self) -> RpcResult<RpcSyncStatus> {
-        let sync_state = self.status_channel.sync_state();
+        let sync_state = self.status_channel.get_sync_state();
+        let (cur_epoch, cur_slot, cur_tip_blkid) =
+            self.status_channel.get_cur_l2_tip().unwrap_or_else(|| {
+                warn!("cur tip unset, using default 0");
+                (0, 0, L2BlockId::from(Buf32::zero()))
+            });
         Ok(sync_state
             .map(|sync| RpcSyncStatus {
-                tip_height: sync.chain_tip_height(),
-                tip_block_id: *sync.chain_tip_blkid(),
+                cur_epoch,
+                tip_slot: cur_slot,
+                tip_blkid: cur_tip_blkid,
+                csm_tip_height: sync.tip_height(),
+                csm_tip_block_id: *sync.chain_tip_blkid(),
                 finalized_block_id: *sync.finalized_blkid(),
+                finalized_epoch: sync.finalized_epoch(),
             })
             .ok_or(Error::ClientNotStarted)?)
     }
@@ -492,16 +506,12 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
 
         let deposit_duties = deposit_duties.map(BridgeDuty::from);
 
-        // withdrawal duties should only be generated from finalized checkpoint states
-        let withdrawal_duties = self
-            .get_last_checkpoint_chainstate()
-            .await
-            .map(|chainstate| {
-                extract_withdrawal_infos(chainstate.deposits_table())
-                    .map(BridgeDuty::from)
-                    .collect::<Vec<_>>()
-            })
-            .unwrap_or_default();
+        let deps_table = self
+            .status_channel
+            .get_cur_deposits_table()
+            .ok_or(Error::BeforeGenesis)?;
+
+        let withdrawal_duties = extract_withdrawal_infos(&deps_table).map(BridgeDuty::from);
 
         let mut duties = vec![];
         duties.extend(deposit_duties);
@@ -518,7 +528,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     async fn get_active_operator_chain_pubkey_set(&self) -> RpcResult<PublickeyTable> {
         let operator_table = self
             .status_channel
-            .operator_table()
+            .get_cur_operator_table()
             .ok_or(Error::BeforeGenesis)?;
         let operator_map: BTreeMap<OperatorIdx, PublicKey> = operator_table
             .operators()
@@ -555,7 +565,7 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
             Ok(client_state
                 .l1_view()
                 .last_finalized_checkpoint()
-                .map(|checkpoint| checkpoint.batch_info.idx()))
+                .map(|checkpoint| checkpoint.batch_info.epoch()))
         } else {
             // get latest checkpoint index from db
             let idx = self
@@ -569,20 +579,20 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     }
 
     async fn get_l2_block_status(&self, block_height: u64) -> RpcResult<L2BlockStatus> {
-        let sync_state = self.status_channel.sync_state();
-        let l1_view = self.status_channel.l1_view();
+        let sync_state = self.status_channel.get_sync_state();
+        let l1_view = self.status_channel.get_l1_view();
         if let Some(last_checkpoint) = l1_view.last_finalized_checkpoint() {
             if last_checkpoint.batch_info.includes_l2_block(block_height) {
                 return Ok(L2BlockStatus::Finalized(last_checkpoint.height));
             }
         }
         if let Some(l1_height) = l1_view.get_verified_l1_height(block_height) {
-            return Ok(L2BlockStatus::Verified(l1_height));
+            return Ok(L2BlockStatus::Committed(l1_height));
         }
 
         if let Some(sync_status) = sync_state {
-            if block_height < sync_status.chain_tip_height() {
-                return Ok(L2BlockStatus::Confirmed);
+            if block_height < sync_status.tip_height() {
+                return Ok(L2BlockStatus::Accepted);
             }
         }
 
@@ -618,17 +628,11 @@ impl<D: Database + Send + Sync + 'static> StrataApiServer for StrataRpcImpl<D> {
     async fn get_client_update_output(&self, idx: u64) -> RpcResult<Option<ClientUpdateOutput>> {
         let db = self.database.clone();
 
+        // TODO convert to use manager interface
         let res = wait_blocking("fetch_client_update_output", move || {
             let client_state_db = db.client_state_db();
-
-            let writes = client_state_db.get_client_state_writes(idx)?;
-            let actions = client_state_db.get_client_update_actions(idx)?;
-
-            match (writes, actions) {
-                (Some(w), Some(a)) => Ok(Some(ClientUpdateOutput::new(w, a))),
-                // normally this is just that they're both missing
-                _ => Ok(None),
-            }
+            let output = client_state_db.get_client_update(idx)?;
+            Ok(output)
         })
         .await?;
 
@@ -746,37 +750,38 @@ impl StrataSequencerApiServer for SequencerServerImpl {
 
     async fn submit_checkpoint_proof(
         &self,
-        idx: u64,
+        checkpoint_idx: u64,
         proof_receipt: ProofReceipt,
     ) -> RpcResult<()> {
-        debug!(%idx, "received checkpoint proof request");
+        debug!(%checkpoint_idx, "received checkpoint proof request");
         let mut entry = self
             .checkpoint_handle
-            .get_checkpoint(idx)
+            .get_checkpoint(checkpoint_idx)
             .await
             .map_err(|e| Error::Other(e.to_string()))?
-            .ok_or(Error::MissingCheckpointInDb(idx))?;
-        debug!(%idx, "found checkpoint in db");
+            .ok_or(Error::MissingCheckpointInDb(checkpoint_idx))?;
 
         // If proof is not pending error out
         if entry.proving_status != CheckpointProvingStatus::PendingProof {
-            return Err(Error::ProofAlreadyCreated(idx))?;
+            warn!(%checkpoint_idx, "checkpoint proof submitted but we already had one?");
+            return Err(Error::ProofAlreadyCreated(checkpoint_idx))?;
         }
 
         let checkpoint = entry.clone().into_batch_checkpoint();
         verify_proof(&checkpoint, &proof_receipt, self.params.rollup())
-            .map_err(|e| Error::InvalidProof(idx, e.to_string()))?;
+            .map_err(|e| Error::InvalidProof(checkpoint_idx, e.to_string()))?;
 
         entry.proof = proof_receipt;
         entry.proving_status = CheckpointProvingStatus::ProofReady;
 
-        debug!(%idx, "Proof is pending, setting proof reaedy");
+        debug!(%checkpoint_idx, "Proof is pending, setting proof reaedy");
+        let checkpoint = entry.clone().into_batch_checkpoint();
 
         self.checkpoint_handle
-            .put_checkpoint_and_notify(idx, entry)
+            .put_checkpoint_and_notify(checkpoint_idx, entry)
             .await
             .map_err(|e| Error::Other(e.to_string()))?;
-        debug!(%idx, "Success");
+        trace!(%checkpoint_idx, "found checkpoint and notified");
 
         Ok(())
     }
@@ -818,6 +823,7 @@ impl<D: Database + Sync + Send + 'static> StrataDebugApiServer for StrataDebugRp
             .map(|b| b.block().clone());
         Ok(l2_block)
     }
+
     async fn get_chainstate_at_idx(&self, idx: u64) -> RpcResult<Option<RpcChainState>> {
         let db = self.database.clone();
         let chain_state = wait_blocking("chain_state_at_idx", move || {
@@ -830,7 +836,7 @@ impl<D: Database + Sync + Send + 'static> StrataDebugApiServer for StrataDebugRp
             Some(cs) => Ok(Some(RpcChainState {
                 tip_blkid: cs.chain_tip_blockid(),
                 tip_slot: cs.chain_tip_slot(),
-                cur_epoch: cs.epoch(),
+                cur_epoch: cs.cur_epoch(),
             })),
             None => Ok(None),
         }

crates/bridge-relay/src/relayer.rs

@@ -84,7 +84,7 @@ impl RelayerState {
             // Otherwise it's better for network health to relay them
             // unconditionally.
             // TODO make it configurable if we relay or not without chainstate?
-            if let Some(op_table) = self.status_channel.operator_table() {
+            if let Some(op_table) = self.status_channel.get_cur_operator_table() {
                 let sig_res =
                     strata_primitives::relay::util::verify_bridge_msg_sig(&message, &op_table);
 

crates/btcio/src/reader/query.rs

@@ -490,7 +490,7 @@ mod test {
         let (event_tx, _event_rx) = mpsc::channel::<L1Event>(10);
         let mut chstate: Chainstate = ArbitraryGenerator::new().generate();
         let clstate: ClientState = ArbitraryGenerator::new().generate();
-        let curr_epoch = chstate.epoch();
+        let curr_epoch = chstate.cur_epoch();
 
         let ctx = get_reader_ctx(event_tx, chstate.clone(), clstate);
         let mut state = get_reader_state(&ctx);

crates/btcio/src/status.rs

@@ -12,8 +12,11 @@ pub enum L1StatusUpdate {
     IncrementInscriptionCount,
 }
 
+#[deprecated(note = "TODO: refactor this to just directly update the fields")]
 pub async fn apply_status_updates(st_updates: &[L1StatusUpdate], st_chan: &StatusChannel) {
-    let mut l1_status = st_chan.l1_status();
+    // FIXME this should be maintaining the authoritative state internally, updating it, and writing
+    // it, *not* just reading what we previously wrote from the channel and modifying that
+    let mut l1_status = st_chan.get_l1_reader_status();
     for event in st_updates {
         match event {
             L1StatusUpdate::CurHeight(height) => l1_status.cur_height = *height,

crates/chaintsn/src/clock.rs

@@ -0,0 +1,26 @@
+//! Utils for reasoning about chain slots.
+
+use strata_primitives::params::RollupParams;
+
+pub fn get_slot_expected_epoch(slot: u64, params: &RollupParams) -> u64 {
+    slot / params.target_l2_batch_size as u64
+}
+
+pub fn get_epoch_initial_slot(epoch: u64, params: &RollupParams) -> u64 {
+    epoch * params.target_l2_batch_size
+}
+
+pub fn get_epoch_final_slot(epoch: u64, params: &RollupParams) -> u64 {
+    let epoch_init_slot = get_epoch_initial_slot(epoch, params);
+    epoch_init_slot + (params.target_l2_batch_size - 1)
+}
+
+pub fn is_epoch_init_slot(slot: u64, params: &RollupParams) -> bool {
+    let epoch = get_slot_expected_epoch(slot, params);
+    slot == get_epoch_initial_slot(epoch, params)
+}
+
+pub fn is_epoch_final_slot(slot: u64, params: &RollupParams) -> bool {
+    let epoch = get_slot_expected_epoch(slot, params);
+    slot == get_epoch_final_slot(epoch, params)
+}