Rename ProtocolOpsTxRef -> ProtocolTxEntry

crates/consensus-logic/src/l1_handler.rs

@@ -131,7 +131,7 @@ fn check_for_da_batch(
     blockdata: &BlockData,
     seq_pubkey: Option<XOnlyPublicKey>,
 ) -> Vec<BatchCheckpointWithCommitment> {
-    let protocol_ops_txs = blockdata.protocol_ops_txs();
+    let protocol_ops_txs = blockdata.protocol_txs();
 
     let signed_checkpts = protocol_ops_txs.iter().flat_map(|txref| {
         txref.proto_ops().iter().filter_map(|op| match op {
@@ -240,7 +240,7 @@ fn generate_block_manifest(block: &Block, epoch: u64) -> L1BlockManifest {
 
 fn generate_l1txs(blockdata: &BlockData) -> Vec<L1Tx> {
     blockdata
-        .protocol_ops_txs()
+        .protocol_txs()
         .iter()
         .map(|ops_txs| {
             generate_l1_tx(

crates/l1tx/src/filter/mod.rs

@@ -12,7 +12,7 @@ pub mod visitor;
 pub use types::TxFilterConfig;
 use visitor::OpsVisitor;
 
-use super::messages::ProtocolOpsTxRef;
+use super::messages::ProtocolTxEntry;
 use crate::{
     deposit::{deposit_request::extract_deposit_request_info, deposit_tx::extract_deposit_info},
     envelope::parser::parse_envelope_payloads,
@@ -25,14 +25,14 @@ pub fn filter_protocol_op_tx_refs<V: OpsVisitor>(
     params: &RollupParams,
     filter_config: &TxFilterConfig,
     ops_visitor: &V,
-) -> Vec<ProtocolOpsTxRef> {
+) -> Vec<ProtocolTxEntry> {
     block
         .txdata
         .iter()
         .enumerate()
         .map(|(i, tx)| {
             let protocol_ops = extract_protocol_ops(tx, params, filter_config, ops_visitor);
-            ProtocolOpsTxRef::new(i as u32, protocol_ops)
+            ProtocolTxEntry::new(i as u32, protocol_ops)
         })
         // Filter out tx refs which do not contain protocol ops
         .filter(|txref| !txref.proto_ops().is_empty())

crates/l1tx/src/messages.rs

@@ -21,15 +21,15 @@ pub enum L1Event {
 /// Core protocol specific bitcoin transaction reference. A bitcoin transaction can have multiple
 /// operations relevant to protocol. This is used in the context of [`BlockData`].
 #[derive(Clone, Debug, BorshSerialize, BorshDeserialize)]
-pub struct ProtocolOpsTxRef {
+pub struct ProtocolTxEntry {
     /// Index of the transaction in the block
     index: u32,
     /// The operation that is to be applied on data
     proto_ops: Vec<ProtocolOperation>,
 }
 
-impl ProtocolOpsTxRef {
-    /// Creates a new [`ProtocolOpsTxRef`]
+impl ProtocolTxEntry {
+    /// Creates a new [`ProtocolTxEntry`]
     pub fn new(index: u32, proto_ops: Vec<ProtocolOperation>) -> Self {
         Self { index, proto_ops }
     }
@@ -50,29 +50,29 @@ impl ProtocolOpsTxRef {
 pub struct BlockData {
     block_num: u64,
     block: Block,
-    /// Transactions in the block that are relevant to rollup
-    protocol_ops_txs: Vec<ProtocolOpsTxRef>,
+    /// Transactions in the block that contain protocol operations
+    protocol_txs: Vec<ProtocolTxEntry>,
 }
 
 impl BlockData {
-    pub fn new(block_num: u64, block: Block, protocol_ops_txs: Vec<ProtocolOpsTxRef>) -> Self {
+    pub fn new(block_num: u64, block: Block, protocol_txs: Vec<ProtocolTxEntry>) -> Self {
         Self {
             block_num,
             block,
-            protocol_ops_txs,
+            protocol_txs,
         }
     }
 
     pub fn block(&self) -> &Block {
         &self.block
     }
 
-    pub fn protocol_ops_tx_idxs(&self) -> impl Iterator<Item = u32> + '_ {
-        self.protocol_ops_txs.iter().map(|v| v.index)
+    pub fn protocol_tx_idxs(&self) -> impl Iterator<Item = u32> + '_ {
+        self.protocol_txs.iter().map(|v| v.index)
     }
 
-    pub fn protocol_ops_txs(&self) -> &[ProtocolOpsTxRef] {
-        &self.protocol_ops_txs
+    pub fn protocol_txs(&self) -> &[ProtocolTxEntry] {
+        &self.protocol_txs
     }
 
     pub fn block_num(&self) -> u64 {