Cleanup

bewakes · bewakes · commit a0157a6d17f8 · 2025-09-17T10:21:03.000+05:45
diff --git a/bin/stf-runner-demo/README.md b/bin/stf-runner-demo/README.md
@@ -34,14 +34,7 @@ The STF Runner Demo provides a hands-on way to understand how the Orchestration
 From the project root:
 
 ```bash
-cargo run --bin stf-runner-demo
-```
-
-Or from the demo directory:
-
-```bash
-cd bin/stf-runner-demo
-cargo run
+cargo run -p stf-runner-demo
 ```
 
 ## Usage
diff --git a/bin/stf-runner-demo/main.rs b/bin/stf-runner-demo/main.rs
@@ -112,7 +112,7 @@ impl StateAccessor<OLState> for SimpleStateAccessor {
 
 fn create_minimal_params() -> RollupParams {
     RollupParams {
-        magic_bytes: "demo".as_bytes().try_into().unwrap_or([0u8; 4]).into(),
+        magic_bytes: "demo".as_bytes().try_into().unwrap_or([0u8; 4]),
         block_time: 1000,
         da_tag: "demo-da".to_string(),
         checkpoint_tag: "demo-ckpt".to_string(),
@@ -353,18 +353,18 @@ fn main() -> anyhow::Result<()> {
     println!("  Bridge Account: {} for withdrawals", bridge_hex);
 
     // Update state accessor with the correct accounts root after creating accounts
-    let accounts_root = ledger.root().expect("Failed to compute accounts root");
+    let accounts_root = ledger
+        .accounts_root()
+        .expect("Failed to compute accounts root");
     state_accessor.set_accounts_root(accounts_root);
 
     // Process genesis block automatically on startup
     println!("\nProcessing genesis block...");
     let genesis_block = create_genesis_block();
     let genesis_prev_header =
         OLBlockHeader::new(0, 0, 0, Buf32::zero(), Buf32::zero(), Buf32::zero());
-    let state_clone = state_accessor.get_toplevel_state().clone();
 
     match process_block(
-        &state_clone,
         &genesis_prev_header,
         &genesis_block,
         &params,
@@ -432,9 +432,7 @@ fn main() -> anyhow::Result<()> {
 
                             // Create a clone of the state for the first parameter (it's unused
                             // according to comments)
-                            let state_clone = state_accessor.get_toplevel_state().clone();
                             match process_block(
-                                &state_clone,
                                 &last_header,
                                 &block,
                                 &params,
@@ -479,9 +477,7 @@ fn main() -> anyhow::Result<()> {
 
                             // Create a clone of the state for the first parameter (it's unused
                             // according to comments)
-                            let state_clone = state_accessor.get_toplevel_state().clone();
                             match process_block(
-                                &state_clone,
                                 &last_header,
                                 &block,
                                 &params,
@@ -519,9 +515,7 @@ fn main() -> anyhow::Result<()> {
 
                 // Create a clone of the state for the first parameter (it's unused according to
                 // comments)
-                let state_clone = state_accessor.get_toplevel_state().clone();
                 match process_block(
-                    &state_clone,
                     &last_header,
                     &block,
                     &params,
@@ -549,9 +543,7 @@ fn main() -> anyhow::Result<()> {
 
                 // Create a clone of the state for the first parameter (it's unused according to
                 // comments)
-                let state_clone = state_accessor.get_toplevel_state().clone();
                 match process_block(
-                    &state_clone,
                     &last_header,
                     &block,
                     &params,
@@ -613,7 +605,7 @@ fn show_accounts(ledger: &InMemoryVectorLedger) {
     for i in 0..2 {
         let account_id = Buf32::from([i as u8; 32]);
         let account_hex = hex::encode(account_id.as_bytes());
-        match ledger.account_state(&account_id) {
+        match ledger.get_account_state(&account_id) {
             Ok(Some(account)) => {
                 println!(
                     "  Account {}: {} balance = {} sats",
diff --git a/crates/chain-worker/src/state.rs b/crates/chain-worker/src/state.rs
@@ -80,4 +80,12 @@ impl StateAccessor for WbStateAccessorImpl {
     fn set_epoch_finishing_flag(&mut self, flag: bool) {
         self.toplevel_chs_cache.set_epoch_finishing_flag(flag);
     }
+
+    fn get_toplevel_state(&mut self) -> &Chainstate {
+        self.toplevel_chs_cache.state()
+    }
+
+    fn set_accounts_root(&mut self, _root: Buf32) {
+        todo!()
+    }
 }
diff --git a/crates/services/stf-runner/src/block.rs b/crates/services/stf-runner/src/block.rs
@@ -95,7 +95,6 @@ pub struct AsmManifest {
 #[derive(Debug, Clone)]
 pub struct OLLog {
     account_serial: u32,
-    account_id: AccountId,
     payload: Vec<u8>, // TODO: make this typed, serialization can be done at the edges
 }
 
@@ -122,17 +121,19 @@ impl OLBlock {
     ) -> Result<(), String> {
         let current_header = self.signed_header.header();
 
-        if current_header.slot() > 0 && current_header.slot() != prev_header.slot() + 1 {
-            return Err(format!("Invalid block slot {}", current_header.slot()));
-        }
-        if current_header.slot() > 0
-            && *current_header.parent_blockid() != prev_header.compute_header_root()
-        {
-            return Err("Invalid parent block ID".to_string());
+        if current_header.slot() > 0 {
+            if current_header.slot() != prev_header.slot() + 1 {
+                return Err(format!("Invalid block slot {}", current_header.slot()));
+            }
+            if *current_header.parent_blockid() != prev_header.compute_header_root() {
+                return Err("Invalid parent block ID".to_string());
+            }
         }
 
-        // Check epoch progression - epoch should not decrease
-        if current_header.epoch() != 0 && current_header.epoch() < prev_header.epoch() {
+        // Check epoch progression - epoch should not decrease and increase only by 1 at max
+        let same_epoch = current_header.epoch() == prev_header.epoch();
+        let valid_increment = current_header.epoch() == prev_header.epoch() + 1;
+        if current_header.epoch() != 0 && (same_epoch || valid_increment) {
             return Err(format!(
                 "Epoch regression: current {} < previous {}",
                 current_header.epoch, prev_header.epoch
@@ -276,7 +277,8 @@ impl Transaction {
         &self.extra
     }
 
-    /// The account id this transaction belongs to. Maybe we should also store sequencer pubkey
+    /// The account id this transaction is on behalf of. `target` is confusing.
+    /// Maybe we could also store sequencer pubkey
     /// along with vk? and then we can have transactions to update the pubkey if sequencer needs to
     /// rotate. Just a thought.
     pub fn account_id(&self) -> AccountId {
@@ -339,10 +341,9 @@ impl AsmManifest {
 }
 
 impl OLLog {
-    pub fn new(account_serial: u32, account_id: AccountId, payload: Vec<u8>) -> Self {
+    pub fn new(account_serial: u32, payload: Vec<u8>) -> Self {
         Self {
             account_serial,
-            account_id,
             payload,
         }
     }
@@ -351,10 +352,6 @@ impl OLLog {
         self.account_serial
     }
 
-    pub fn account_id(&self) -> &AccountId {
-        &self.account_id
-    }
-
     pub fn payload(&self) -> &[u8] {
         &self.payload
     }
diff --git a/crates/services/stf-runner/src/ledger.rs b/crates/services/stf-runner/src/ledger.rs
@@ -4,7 +4,9 @@ use sha2::{Digest, Sha256};
 use strata_primitives::buf::Buf32;
 use thiserror::Error;
 
-use crate::account::{AccountId, AccountSerial, AccountState, SnarkAccountMessageEntry};
+use crate::account::{
+    AccountId, AccountInnerState, AccountSerial, AccountState, SnarkAccountMessageEntry,
+};
 
 #[derive(Debug, Error)]
 pub enum LedgerError {}
@@ -14,18 +16,21 @@ pub type LedgerResult<T> = Result<T, LedgerError>;
 /// Interface for accessing and modifying accounts ledger
 pub trait LedgerProvider {
     /// Root of the current accounts ledger. For example root of the accounts trie.
-    fn root(&self) -> LedgerResult<Buf32>;
+    fn accounts_root(&self) -> LedgerResult<Buf32>;
 
     /// Get account id from serial
-    fn account_id(&self, serial: AccountSerial) -> LedgerResult<Option<AccountId>>;
+    fn get_account_id(&self, serial: AccountSerial) -> LedgerResult<Option<AccountId>>;
 
     /// Get an account state
-    fn account_state(&self, acct_id: &AccountId) -> LedgerResult<Option<AccountState>>;
+    fn get_account_state(&self, acct_id: &AccountId) -> LedgerResult<Option<AccountState>>;
 
     /// Convenient method for accessing state via serial.
-    fn account_serial_state(&self, serial: AccountSerial) -> LedgerResult<Option<AccountState>> {
-        if let Some(acct_id) = self.account_id(serial)? {
-            self.account_state(&acct_id)
+    fn get_account_state_by_serial(
+        &self,
+        serial: AccountSerial,
+    ) -> LedgerResult<Option<AccountState>> {
+        if let Some(acct_id) = self.get_account_id(serial)? {
+            self.get_account_state(&acct_id)
         } else {
             Ok(None)
         }
@@ -42,23 +47,14 @@ pub trait LedgerProvider {
     // TODO: message can be a bit generic instead of snark message?
     fn insert_message(
         &mut self,
-        acct_id: AccountId,
+        acct_id: &AccountId,
         message: SnarkAccountMessageEntry,
     ) -> LedgerResult<()>;
-
-    /// Consume input messages. Most likely updates some input index in state
-    fn consume_messages(
-        &mut self,
-        acct_id: AccountId,
-        from_idx: u64,
-        to_idx: u64,
-    ) -> LedgerResult<()>;
 }
 
 /// Simplest in-memory ledger. All it has is an in-memory map of acct id to list of messages.
 #[derive(Debug, Clone)]
 pub struct InMemoryVectorLedger {
-    pub acct_msgs: HashMap<AccountId, Vec<SnarkAccountMessageEntry>>,
     pub serial_to_id: HashMap<AccountSerial, AccountId>,
     pub account_states: HashMap<AccountId, AccountState>,
     pub root_cache: Option<Buf32>,
@@ -67,7 +63,6 @@ pub struct InMemoryVectorLedger {
 impl InMemoryVectorLedger {
     pub fn new() -> Self {
         Self {
-            acct_msgs: HashMap::new(),
             serial_to_id: HashMap::new(),
             account_states: HashMap::new(),
             root_cache: None,
@@ -77,7 +72,6 @@ impl InMemoryVectorLedger {
     pub fn create_account(&mut self, serial: AccountSerial, id: AccountId, state: AccountState) {
         self.serial_to_id.insert(serial, id);
         self.account_states.insert(id, state);
-        self.acct_msgs.insert(id, Vec::new());
         self.invalidate_root_cache();
     }
 
@@ -90,7 +84,6 @@ impl InMemoryVectorLedger {
             return Ok(*cached);
         }
 
-        use sha2::{Digest, Sha256};
         let mut hasher = Sha256::new();
 
         // Sort account IDs for deterministic ordering
@@ -100,9 +93,9 @@ impl InMemoryVectorLedger {
         for account_id in sorted_accounts {
             hasher.update(account_id.as_ref());
             if let Some(state) = self.account_states.get(account_id) {
-                hasher.update(&state.serial.to_be_bytes());
-                hasher.update(&state.ty.to_be_bytes());
-                hasher.update(&state.balance.to_be_bytes());
+                hasher.update(state.serial.to_be_bytes());
+                hasher.update(state.ty.to_be_bytes());
+                hasher.update(state.balance.to_be_bytes());
             }
         }
 
@@ -119,7 +112,7 @@ impl Default for InMemoryVectorLedger {
 }
 
 impl LedgerProvider for InMemoryVectorLedger {
-    fn root(&self) -> LedgerResult<Buf32> {
+    fn accounts_root(&self) -> LedgerResult<Buf32> {
         // Need mutable access to compute/cache root, but trait requires &self
         // For now, recompute every time (inefficient but correct)
         let mut hasher = Sha256::new();
@@ -130,53 +123,33 @@ impl LedgerProvider for InMemoryVectorLedger {
         for account_id in sorted_accounts {
             hasher.update(account_id.as_ref());
             if let Some(state) = self.account_states.get(account_id) {
-                hasher.update(&state.serial.to_be_bytes());
-                hasher.update(&state.ty.to_be_bytes());
-                hasher.update(&state.balance.to_be_bytes());
+                hasher.update(state.serial.to_be_bytes());
+                hasher.update(state.ty.to_be_bytes());
+                hasher.update(state.balance.to_be_bytes());
             }
         }
 
         Ok(Buf32::new(hasher.finalize().into()))
     }
 
-    fn account_id(&self, serial: AccountSerial) -> LedgerResult<Option<AccountId>> {
+    fn get_account_id(&self, serial: AccountSerial) -> LedgerResult<Option<AccountId>> {
         Ok(self.serial_to_id.get(&serial).copied())
     }
 
-    fn account_state(&self, acct_id: &AccountId) -> LedgerResult<Option<AccountState>> {
+    fn get_account_state(&self, acct_id: &AccountId) -> LedgerResult<Option<AccountState>> {
         Ok(self.account_states.get(acct_id).cloned())
     }
 
     fn insert_message(
         &mut self,
-        acct_id: AccountId,
+        acct_id: &AccountId,
         message: SnarkAccountMessageEntry,
     ) -> LedgerResult<()> {
-        self.acct_msgs
-            .entry(acct_id)
-            .or_insert_with(Vec::new)
-            .push(message);
-        self.invalidate_root_cache();
-        Ok(())
-    }
-
-    fn consume_messages(
-        &mut self,
-        acct_id: AccountId,
-        from_idx: u64,
-        to_idx: u64,
-    ) -> LedgerResult<()> {
-        if let Some(messages) = self.acct_msgs.get_mut(&acct_id) {
-            let from_idx = from_idx as usize;
-            let to_idx = to_idx as usize;
-
-            // Validate indices
-            if from_idx > to_idx || to_idx > messages.len() {
-                return Ok(()); // Invalid range, do nothing
-            }
-
-            // Remove consumed messages by draining the range
-            messages.drain(from_idx..to_idx);
+        if let Some(AccountInnerState::Snark(mut acct)) =
+            self.get_account_state(acct_id)?.map(|a| a.inner_state)
+        {
+            // TODO: Will this actually update the hashmap?
+            acct.input.push(message);
             self.invalidate_root_cache();
         }
         Ok(())
diff --git a/crates/services/stf-runner/src/state.rs b/crates/services/stf-runner/src/state.rs
@@ -9,7 +9,7 @@ pub struct OLState {
     cur_epoch: u64,
 }
 
-/// Represents the view of Layer 1 blockchain from the perspective of the OL
+/// Represents the view of the layer 1 blockchain from the perspective of the OL
 #[derive(Debug, Clone, Default)]
 pub struct L1View {
     block_hash: Buf32,
@@ -58,6 +58,7 @@ impl OLState {
         self.cur_epoch = cur_epoch;
     }
 
+    // NOTE: will be redundant with SSZ
     pub fn compute_root(&self) -> Buf32 {
         use sha2::{Digest, Sha256};
         let mut hasher = Sha256::new();
@@ -67,11 +68,11 @@ impl OLState {
 
         // Hash L1 view components
         hasher.update(self.l1_view.block_hash.as_ref());
-        hasher.update(&self.l1_view.block_height.to_be_bytes());
+        hasher.update(self.l1_view.block_height.to_be_bytes());
 
         // Hash current slot and epoch
-        hasher.update(&self.cur_slot.to_be_bytes());
-        hasher.update(&self.cur_epoch.to_be_bytes());
+        hasher.update(self.cur_slot.to_be_bytes());
+        hasher.update(self.cur_epoch.to_be_bytes());
 
         Buf32::new(hasher.finalize().into())
     }
diff --git a/crates/services/stf-runner/src/stf.rs b/crates/services/stf-runner/src/stf.rs
diff --git a/crates/services/stf-runner/src/tx_exec.rs b/crates/services/stf-runner/src/tx_exec.rs

Original file line number	Diff line number	Diff line change
`@@ -80,4 +80,12 @@ impl StateAccessor for WbStateAccessorImpl {`
`80`	`80`	`fn set_epoch_finishing_flag(&mut self, flag: bool) {`
`81`	`81`	`self.toplevel_chs_cache.set_epoch_finishing_flag(flag);`
`82`	`82`	`}`
	`83`	`+`
	`84`	`+ fn get_toplevel_state(&mut self) -> &Chainstate {`
	`85`	`+ self.toplevel_chs_cache.state()`
	`86`	`+ }`
	`87`	`+`
	`88`	`+ fn set_accounts_root(&mut self, _root: Buf32) {`
	`89`	`+ todo!()`
	`90`	`+ }`
`83`	`91`	`}`