diff --git a/crates/op-rbuilder/src/builders/flashblocks/best_txs.rs b/crates/op-rbuilder/src/builders/flashblocks/best_txs.rs
index ec2a45d19..b0b3396ee 100644
--- a/crates/op-rbuilder/src/builders/flashblocks/best_txs.rs
+++ b/crates/op-rbuilder/src/builders/flashblocks/best_txs.rs
@@ -63,18 +63,18 @@ where
                 continue;
             }
 
-            let flashblock_number_min = tx.flashblock_number_min();
-            let flashblock_number_max = tx.flashblock_number_max();
+            let min_flashblock_number = tx.min_flashblock_number();
+            let max_flashblock_number = tx.max_flashblock_number();
 
             // Check min flashblock requirement
-            if let Some(min) = flashblock_number_min
+            if let Some(min) = min_flashblock_number
                 && self.current_flashblock_number < min
             {
                 continue;
             }
 
             // Check max flashblock requirement
-            if let Some(max) = flashblock_number_max
+            if let Some(max) = max_flashblock_number
                 && self.current_flashblock_number > max
             {
                 debug!(
diff --git a/crates/op-rbuilder/src/mock_tx.rs b/crates/op-rbuilder/src/mock_tx.rs
index 3802fa9f8..04c5f9f85 100644
--- a/crates/op-rbuilder/src/mock_tx.rs
+++ b/crates/op-rbuilder/src/mock_tx.rs
@@ -66,8 +66,8 @@ impl MockFbTransactionFactory {
         self.validated(MockFbTransaction {
             inner: MockTransaction::legacy(),
             reverted_hashes: None,
-            flashblock_number_max: None,
-            flashblock_number_min: None,
+            max_flashblock_number: None,
+            min_flashblock_number: None,
         })
     }
 
@@ -76,8 +76,8 @@ impl MockFbTransactionFactory {
         self.validated(MockFbTransaction {
             inner: MockTransaction::legacy(),
             reverted_hashes: None,
-            flashblock_number_max: max,
-            flashblock_number_min: min,
+            max_flashblock_number: max,
+            min_flashblock_number: min,
         })
     }
 
@@ -86,8 +86,8 @@ impl MockFbTransactionFactory {
         self.validated(MockFbTransaction {
             inner: MockTransaction::eip1559(),
             reverted_hashes: None,
-            flashblock_number_max: None,
-            flashblock_number_min: None,
+            max_flashblock_number: None,
+            min_flashblock_number: None,
         })
     }
 
@@ -96,8 +96,8 @@ impl MockFbTransactionFactory {
         self.validated(MockFbTransaction {
             inner: MockTransaction::eip4844(),
             reverted_hashes: None,
-            flashblock_number_max: None,
-            flashblock_number_min: None,
+            max_flashblock_number: None,
+            min_flashblock_number: None,
         })
     }
 }
@@ -110,8 +110,8 @@ pub struct MockFbTransaction {
     /// transaction is not a bundle, this is `None`.
     pub reverted_hashes: Option<Vec<B256>>,
 
-    pub flashblock_number_min: Option<u64>,
-    pub flashblock_number_max: Option<u64>,
+    pub min_flashblock_number: Option<u64>,
+    pub max_flashblock_number: Option<u64>,
 }
 
 /// A validated transaction in the transaction pool, using [`MockTransaction`] as the transaction
@@ -135,8 +135,8 @@ impl PoolTransaction for MockFbTransaction {
         Self {
             inner: pooled.into(),
             reverted_hashes: None,
-            flashblock_number_min: None,
-            flashblock_number_max: None,
+            min_flashblock_number: None,
+            max_flashblock_number: None,
         }
     }
 
@@ -433,21 +433,21 @@ pub type PooledTransactionVariant =
     alloy_consensus::EthereumTxEnvelope<TxEip4844WithSidecar<BlobTransactionSidecarVariant>>;
 
 impl MaybeFlashblockFilter for MockFbTransaction {
-    fn with_flashblock_number_min(mut self, flashblock_number_min: Option<u64>) -> Self {
-        self.flashblock_number_min = flashblock_number_min;
+    fn with_min_flashblock_number(mut self, min_flashblock_number: Option<u64>) -> Self {
+        self.min_flashblock_number = min_flashblock_number;
         self
     }
 
-    fn with_flashblock_number_max(mut self, flashblock_number_max: Option<u64>) -> Self {
-        self.flashblock_number_max = flashblock_number_max;
+    fn with_max_flashblock_number(mut self, max_flashblock_number: Option<u64>) -> Self {
+        self.max_flashblock_number = max_flashblock_number;
         self
     }
 
-    fn flashblock_number_min(&self) -> Option<u64> {
-        self.flashblock_number_min
+    fn min_flashblock_number(&self) -> Option<u64> {
+        self.min_flashblock_number
     }
 
-    fn flashblock_number_max(&self) -> Option<u64> {
-        self.flashblock_number_max
+    fn max_flashblock_number(&self) -> Option<u64> {
+        self.max_flashblock_number
     }
 }
diff --git a/crates/op-rbuilder/src/primitives/bundle.rs b/crates/op-rbuilder/src/primitives/bundle.rs
index 6e4c471b2..38bc13a16 100644
--- a/crates/op-rbuilder/src/primitives/bundle.rs
+++ b/crates/op-rbuilder/src/primitives/bundle.rs
@@ -29,13 +29,13 @@ pub const MAX_BLOCK_RANGE_BLOCKS: u64 = 10;
 /// - There's only one transaction in the bundle
 /// - Flashblock number ranges are valid (min ≤ max)
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "camelCase")]
 pub struct Bundle {
     /// List of raw transaction data to be included in the bundle.
     ///
     /// Each transaction is represented as raw bytes that will be decoded and
     /// executed in the specified order when the bundle conditions are met.
-    #[serde(rename = "txs")]
-    pub transactions: Vec<Bytes>,
+    pub txs: Vec<Bytes>,
 
     /// Optional list of transaction hashes that are allowed to revert.
     ///
@@ -43,8 +43,7 @@ pub struct Bundle {
     /// considered invalid. This field allows specific transactions to revert
     /// without invalidating the bundle, enabling more sophisticated MEV
     /// strategies.
-    #[serde(rename = "revertingTxHashes")]
-    pub reverting_hashes: Option<Vec<B256>>,
+    pub reverting_tx_hashes: Option<Vec<B256>>,
 
     /// Minimum block number at which this bundle can be included.
     ///
@@ -53,11 +52,10 @@ pub struct Bundle {
     /// future execution.
     #[serde(
         default,
-        rename = "minBlockNumber",
         with = "alloy_serde::quantity::opt",
         skip_serializing_if = "Option::is_none"
     )]
-    pub block_number_min: Option<u64>,
+    pub min_block_number: Option<u64>,
 
     /// Maximum block number at which this bundle can be included.
     ///
@@ -66,11 +64,10 @@ pub struct Bundle {
     /// current block number plus `MAX_BLOCK_RANGE_BLOCKS`.
     #[serde(
         default,
-        rename = "maxBlockNumber",
         with = "alloy_serde::quantity::opt",
         skip_serializing_if = "Option::is_none"
     )]
-    pub block_number_max: Option<u64>,
+    pub max_block_number: Option<u64>,
 
     /// Minimum flashblock number at which this bundle can be included.
     ///
@@ -79,11 +76,10 @@ pub struct Bundle {
     /// for more precise execution.
     #[serde(
         default,
-        rename = "minFlashblockNumber",
         with = "alloy_serde::quantity::opt",
         skip_serializing_if = "Option::is_none"
     )]
-    pub flashblock_number_min: Option<u64>,
+    pub min_flashblock_number: Option<u64>,
 
     /// Maximum flashblock number at which this bundle can be included.
     ///
@@ -91,11 +87,10 @@ pub struct Bundle {
     /// flashblocks can include this bundle.
     #[serde(
         default,
-        rename = "maxFlashblockNumber",
         with = "alloy_serde::quantity::opt",
         skip_serializing_if = "Option::is_none"
     )]
-    pub flashblock_number_max: Option<u64>,
+    pub max_flashblock_number: Option<u64>,
 
     /// Minimum timestamp (Unix epoch seconds) for bundle inclusion.
     ///
@@ -103,11 +98,7 @@ pub struct Bundle {
     /// builder node's clock, which may not be perfectly synchronized with
     /// network time. Block number constraints are preferred for deterministic
     /// behavior.
-    #[serde(
-        default,
-        rename = "minTimestamp",
-        skip_serializing_if = "Option::is_none"
-    )]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub min_timestamp: Option<u64>,
 
     /// Maximum timestamp (Unix epoch seconds) for bundle inclusion.
@@ -116,11 +107,7 @@ pub struct Bundle {
     /// builder node's clock, which may not be perfectly synchronized with
     /// network time. Block number constraints are preferred for deterministic
     /// behavior.
-    #[serde(
-        default,
-        rename = "maxTimestamp",
-        skip_serializing_if = "Option::is_none"
-    )]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub max_timestamp: Option<u64>,
 }
 
@@ -132,15 +119,15 @@ impl From<BundleConditionalError> for EthApiError {
 
 #[derive(Debug, thiserror::Error)]
 pub enum BundleConditionalError {
-    #[error("block_number_min ({min}) is greater than block_number_max ({max})")]
+    #[error("min_block_number ({min}) is greater than max_block_number ({max})")]
     MinGreaterThanMax { min: u64, max: u64 },
-    #[error("block_number_max ({max}) is a past block (current: {current})")]
+    #[error("max_block_number ({max}) is a past block (current: {current})")]
     MaxBlockInPast { max: u64, current: u64 },
     /// To prevent resource exhaustion and ensure timely execution, bundles
     /// cannot be scheduled more than `MAX_BLOCK_RANGE_BLOCKS` blocks into the
     /// future.
     #[error(
-        "block_number_max ({max}) is too high (current: {current}, max allowed: {max_allowed})"
+        "max_block_number ({max}) is too high (current: {current}, max allowed: {max_allowed})"
     )]
     MaxBlockTooHigh {
         max: u64,
@@ -151,17 +138,17 @@ pub enum BundleConditionalError {
     /// `current_block + MAX_BLOCK_RANGE_BLOCKS` as the default maximum. This
     /// error occurs when the specified minimum exceeds this default maximum.
     #[error(
-        "block_number_min ({min}) is too high with default max range (max allowed: {max_allowed})"
+        "min_block_number ({min}) is too high with default max range (max allowed: {max_allowed})"
     )]
     MinTooHighForDefaultRange { min: u64, max_allowed: u64 },
-    #[error("flashblock_number_min ({min}) is greater than flashblock_number_max ({max})")]
+    #[error("min_flashblock_number ({min}) is greater than max_flashblock_number ({max})")]
     FlashblockMinGreaterThanMax { min: u64, max: u64 },
 }
 
 pub struct BundleConditional {
     pub transaction_conditional: TransactionConditional,
-    pub flashblock_number_min: Option<u64>,
-    pub flashblock_number_max: Option<u64>,
+    pub min_flashblock_number: Option<u64>,
+    pub max_flashblock_number: Option<u64>,
 }
 
 impl Bundle {
@@ -169,13 +156,13 @@ impl Bundle {
         &self,
         last_block_number: u64,
     ) -> Result<BundleConditional, BundleConditionalError> {
-        let mut block_number_max = self.block_number_max;
-        let block_number_min = self.block_number_min;
+        let mut max_block_number = self.max_block_number;
+        let min_block_number = self.min_block_number;
 
         // Validate block number ranges
-        if let Some(max) = block_number_max {
+        if let Some(max) = max_block_number {
             // Check if min > max
-            if let Some(min) = block_number_min
+            if let Some(min) = min_block_number
                 && min > max
             {
                 return Err(BundleConditionalError::MinGreaterThanMax { min, max });
@@ -201,10 +188,10 @@ impl Bundle {
         } else {
             // If no upper bound is set, use the maximum block range
             let default_max = last_block_number + MAX_BLOCK_RANGE_BLOCKS;
-            block_number_max = Some(default_max);
+            max_block_number = Some(default_max);
 
             // Ensure that the new max is not smaller than the min
-            if let Some(min) = block_number_min
+            if let Some(min) = min_block_number
                 && min > default_max
             {
                 return Err(BundleConditionalError::MinTooHighForDefaultRange {
@@ -215,8 +202,8 @@ impl Bundle {
         }
 
         // Validate flashblock number range
-        if let Some(min) = self.flashblock_number_min
-            && let Some(max) = self.flashblock_number_max
+        if let Some(min) = self.min_flashblock_number
+            && let Some(max) = self.max_flashblock_number
             && min > max
         {
             return Err(BundleConditionalError::FlashblockMinGreaterThanMax { min, max });
@@ -224,14 +211,14 @@ impl Bundle {
 
         Ok(BundleConditional {
             transaction_conditional: TransactionConditional {
-                block_number_min,
-                block_number_max,
+                block_number_min: min_block_number,
+                block_number_max: max_block_number,
                 known_accounts: Default::default(),
                 timestamp_max: self.max_timestamp,
                 timestamp_min: self.min_timestamp,
             },
-            flashblock_number_min: self.flashblock_number_min,
-            flashblock_number_max: self.flashblock_number_max,
+            min_flashblock_number: self.min_flashblock_number,
+            max_flashblock_number: self.max_flashblock_number,
         })
     }
 }
@@ -259,7 +246,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_no_bounds() {
         let bundle = Bundle {
-            transactions: vec![],
+            txs: vec![],
             ..Default::default()
         };
 
@@ -279,8 +266,8 @@ mod tests {
     #[test]
     fn test_bundle_conditional_with_valid_bounds() {
         let bundle = Bundle {
-            block_number_max: Some(1005),
-            block_number_min: Some(1002),
+            max_block_number: Some(1005),
+            min_block_number: Some(1002),
             ..Default::default()
         };
 
@@ -297,8 +284,8 @@ mod tests {
     #[test]
     fn test_bundle_conditional_min_greater_than_max() {
         let bundle = Bundle {
-            block_number_max: Some(1005),
-            block_number_min: Some(1010),
+            max_block_number: Some(1005),
+            min_block_number: Some(1010),
             ..Default::default()
         };
 
@@ -317,7 +304,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_max_in_past() {
         let bundle = Bundle {
-            block_number_max: Some(999),
+            max_block_number: Some(999),
             ..Default::default()
         };
 
@@ -336,7 +323,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_max_too_high() {
         let bundle = Bundle {
-            block_number_max: Some(1020),
+            max_block_number: Some(1020),
             ..Default::default()
         };
 
@@ -356,7 +343,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_min_too_high_for_default_range() {
         let bundle = Bundle {
-            block_number_min: Some(1015),
+            min_block_number: Some(1015),
             ..Default::default()
         };
 
@@ -375,7 +362,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_with_only_min() {
         let bundle = Bundle {
-            block_number_min: Some(1005),
+            min_block_number: Some(1005),
             ..Default::default()
         };
 
@@ -392,7 +379,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_with_only_max() {
         let bundle = Bundle {
-            block_number_max: Some(1008),
+            max_block_number: Some(1008),
             ..Default::default()
         };
 
@@ -409,7 +396,7 @@ mod tests {
     #[test]
     fn test_bundle_conditional_min_lower_than_last_block() {
         let bundle = Bundle {
-            block_number_min: Some(999),
+            min_block_number: Some(999),
             ..Default::default()
         };
 
@@ -426,8 +413,8 @@ mod tests {
     #[test]
     fn test_bundle_conditional_flashblock_min_greater_than_max() {
         let bundle = Bundle {
-            flashblock_number_min: Some(105),
-            flashblock_number_max: Some(100),
+            min_flashblock_number: Some(105),
+            max_flashblock_number: Some(100),
             ..Default::default()
         };
 
@@ -443,58 +430,58 @@ mod tests {
     #[test]
     fn test_bundle_conditional_with_valid_flashblock_range() {
         let bundle = Bundle {
-            flashblock_number_min: Some(100),
-            flashblock_number_max: Some(105),
+            min_flashblock_number: Some(100),
+            max_flashblock_number: Some(105),
             ..Default::default()
         };
 
         let last_block = 1000;
         let result = bundle.conditional(last_block).unwrap();
 
-        assert_eq!(result.flashblock_number_min, Some(100));
-        assert_eq!(result.flashblock_number_max, Some(105));
+        assert_eq!(result.min_flashblock_number, Some(100));
+        assert_eq!(result.max_flashblock_number, Some(105));
     }
 
     #[test]
     fn test_bundle_conditional_with_only_flashblock_min() {
         let bundle = Bundle {
-            flashblock_number_min: Some(100),
+            min_flashblock_number: Some(100),
             ..Default::default()
         };
 
         let last_block = 1000;
         let result = bundle.conditional(last_block).unwrap();
 
-        assert_eq!(result.flashblock_number_min, Some(100));
-        assert_eq!(result.flashblock_number_max, None);
+        assert_eq!(result.min_flashblock_number, Some(100));
+        assert_eq!(result.max_flashblock_number, None);
     }
 
     #[test]
     fn test_bundle_conditional_with_only_flashblock_max() {
         let bundle = Bundle {
-            flashblock_number_max: Some(105),
+            max_flashblock_number: Some(105),
             ..Default::default()
         };
 
         let last_block = 1000;
         let result = bundle.conditional(last_block).unwrap();
 
-        assert_eq!(result.flashblock_number_min, None);
-        assert_eq!(result.flashblock_number_max, Some(105));
+        assert_eq!(result.min_flashblock_number, None);
+        assert_eq!(result.max_flashblock_number, Some(105));
     }
 
     #[test]
     fn test_bundle_conditional_flashblock_equal_values() {
         let bundle = Bundle {
-            flashblock_number_min: Some(100),
-            flashblock_number_max: Some(100),
+            min_flashblock_number: Some(100),
+            max_flashblock_number: Some(100),
             ..Default::default()
         };
 
         let last_block = 1000;
         let result = bundle.conditional(last_block).unwrap();
 
-        assert_eq!(result.flashblock_number_min, Some(100));
-        assert_eq!(result.flashblock_number_max, Some(100));
+        assert_eq!(result.min_flashblock_number, Some(100));
+        assert_eq!(result.max_flashblock_number, Some(100));
     }
 }
diff --git a/crates/op-rbuilder/src/revert_protection.rs b/crates/op-rbuilder/src/revert_protection.rs
index f3fa8924e..93a95ad02 100644
--- a/crates/op-rbuilder/src/revert_protection.rs
+++ b/crates/op-rbuilder/src/revert_protection.rs
@@ -121,14 +121,14 @@ where
             .map_err(|_e| EthApiError::InternalEthError)?;
 
         // Only one transaction in the bundle is expected
-        let bundle_transaction = match bundle.transactions.len() {
+        let bundle_transaction = match bundle.txs.len() {
             0 => {
                 return Err(EthApiError::InvalidParams(
                     "bundle must contain at least one transaction".into(),
                 )
                 .into());
             }
-            1 => bundle.transactions[0].clone(),
+            1 => bundle.txs[0].clone(),
             _ => {
                 return Err(EthApiError::InvalidParams(
                     "bundle must contain exactly one transaction".into(),
@@ -144,9 +144,9 @@ where
         let recovered = recover_raw_transaction(&bundle_transaction)?;
         let pool_transaction =
             FBPooledTransaction::from(OpPooledTransaction::from_pooled(recovered))
-                .with_reverted_hashes(bundle.reverting_hashes.clone().unwrap_or_default())
-                .with_flashblock_number_min(conditional.flashblock_number_min)
-                .with_flashblock_number_max(conditional.flashblock_number_max)
+                .with_reverted_hashes(bundle.reverting_tx_hashes.clone().unwrap_or_default())
+                .with_min_flashblock_number(conditional.min_flashblock_number)
+                .with_max_flashblock_number(conditional.max_flashblock_number)
                 .with_conditional(conditional.transaction_conditional);
 
         let outcome = self
diff --git a/crates/op-rbuilder/src/tests/flashblocks.rs b/crates/op-rbuilder/src/tests/flashblocks.rs
index 684059e92..6eef4eb13 100644
--- a/crates/op-rbuilder/src/tests/flashblocks.rs
+++ b/crates/op-rbuilder/src/tests/flashblocks.rs
@@ -36,7 +36,7 @@ async fn test_flashblock_min_filtering(rbuilder: LocalInstance) -> eyre::Result<
     let tx1 = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(0))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(0))
         .with_max_priority_fee_per_gas(0)
         .send()
         .await?;
@@ -44,7 +44,7 @@ async fn test_flashblock_min_filtering(rbuilder: LocalInstance) -> eyre::Result<
     let tx2 = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(3))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(3))
         .with_max_priority_fee_per_gas(10)
         .send()
         .await?;
@@ -90,7 +90,7 @@ async fn test_flashblock_max_filtering(rbuilder: LocalInstance) -> eyre::Result<
 
     // Since we cannot directly trigger flashblock creation in tests, we
     // instead fill up the gas of flashblocks so that our tx with the
-    // flashblock_number_max parameter set is properly delayed, simulating
+    // max_flashblock_number parameter set is properly delayed, simulating
     // the scenario where we'd sent the tx after the flashblock max number
     // had passed.
     let call = driver
@@ -108,7 +108,7 @@ async fn test_flashblock_max_filtering(rbuilder: LocalInstance) -> eyre::Result<
     let tx1 = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_max(1))
+        .with_bundle(BundleOpts::default().with_max_flashblock_number(1))
         .send()
         .await?;
 
@@ -147,8 +147,8 @@ async fn test_flashblock_min_max_filtering(rbuilder: LocalInstance) -> eyre::Res
         .random_valid_transfer()
         .with_bundle(
             BundleOpts::default()
-                .with_flashblock_number_max(2)
-                .with_flashblock_number_min(2),
+                .with_max_flashblock_number(2)
+                .with_min_flashblock_number(2),
         )
         .send()
         .await?;
@@ -383,7 +383,7 @@ async fn create_flashblock_transactions(
         let tx = driver
             .create_transaction()
             .random_valid_transfer()
-            .with_bundle(BundleOpts::default().with_flashblock_number_min(i))
+            .with_bundle(BundleOpts::default().with_min_flashblock_number(i))
             .send()
             .await?;
         txs.push(*tx.tx_hash());
diff --git a/crates/op-rbuilder/src/tests/flashtestations.rs b/crates/op-rbuilder/src/tests/flashtestations.rs
index 002ce5cfc..6681d5913 100644
--- a/crates/op-rbuilder/src/tests/flashtestations.rs
+++ b/crates/op-rbuilder/src/tests/flashtestations.rs
@@ -150,7 +150,7 @@ async fn test_flashtestations_with_number_contract(rbuilder: LocalInstance) -> e
     let tx = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(4))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(4))
         .send()
         .await?;
     let block = driver.build_new_block_with_current_timestamp(None).await?;
@@ -307,7 +307,7 @@ async fn test_flashtestations_permit_with_flashblocks_number_contract(
     let tx = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(4))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(4))
         .send()
         .await?;
     let block = driver.build_new_block_with_current_timestamp(None).await?;
@@ -396,7 +396,7 @@ async fn test_flashtestations_permit_with_flashblocks_number_permit(
         .create_transaction()
         .add_authorized_builder(TEE_DEBUG_ADDRESS)
         .with_to(FLASHBLOCKS_NUMBER_ADDRESS)
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(4))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(4))
         .send()
         .await?;
     let block = driver.build_new_block_with_current_timestamp(None).await?;
@@ -432,7 +432,7 @@ async fn test_flashtestations_permit_with_flashblocks_number_permit(
     let tx = driver
         .create_transaction()
         .random_valid_transfer()
-        .with_bundle(BundleOpts::default().with_flashblock_number_min(4))
+        .with_bundle(BundleOpts::default().with_min_flashblock_number(4))
         .send()
         .await?;
     let block = driver.build_new_block_with_current_timestamp(None).await?;
diff --git a/crates/op-rbuilder/src/tests/framework/txs.rs b/crates/op-rbuilder/src/tests/framework/txs.rs
index 358727646..add7dd1ab 100644
--- a/crates/op-rbuilder/src/tests/framework/txs.rs
+++ b/crates/op-rbuilder/src/tests/framework/txs.rs
@@ -24,32 +24,32 @@ use alloy_eips::eip1559::MIN_PROTOCOL_BASE_FEE;
 
 #[derive(Clone, Copy, Default)]
 pub struct BundleOpts {
-    block_number_min: Option<u64>,
-    block_number_max: Option<u64>,
-    flashblock_number_min: Option<u64>,
-    flashblock_number_max: Option<u64>,
+    min_block_number: Option<u64>,
+    max_block_number: Option<u64>,
+    min_flashblock_number: Option<u64>,
+    max_flashblock_number: Option<u64>,
     min_timestamp: Option<u64>,
     max_timestamp: Option<u64>,
 }
 
 impl BundleOpts {
-    pub fn with_block_number_min(mut self, block_number_min: u64) -> Self {
-        self.block_number_min = Some(block_number_min);
+    pub fn with_min_block_number(mut self, min_block_number: u64) -> Self {
+        self.min_block_number = Some(min_block_number);
         self
     }
 
-    pub fn with_block_number_max(mut self, block_number_max: u64) -> Self {
-        self.block_number_max = Some(block_number_max);
+    pub fn with_max_block_number(mut self, max_block_number: u64) -> Self {
+        self.max_block_number = Some(max_block_number);
         self
     }
 
-    pub fn with_flashblock_number_min(mut self, flashblock_number_min: u64) -> Self {
-        self.flashblock_number_min = Some(flashblock_number_min);
+    pub fn with_min_flashblock_number(mut self, min_flashblock_number: u64) -> Self {
+        self.min_flashblock_number = Some(min_flashblock_number);
         self
     }
 
-    pub fn with_flashblock_number_max(mut self, flashblock_number_max: u64) -> Self {
-        self.flashblock_number_max = Some(flashblock_number_max);
+    pub fn with_max_flashblock_number(mut self, max_flashblock_number: u64) -> Self {
+        self.max_flashblock_number = Some(max_flashblock_number);
         self
     }
 
@@ -209,16 +209,16 @@ impl TransactionBuilder {
         if let Some(bundle_opts) = bundle_opts {
             // Send the transaction as a bundle with the bundle options
             let bundle = Bundle {
-                transactions: vec![transaction_encoded.into()],
-                reverting_hashes: if with_reverted_hash {
+                txs: vec![transaction_encoded.into()],
+                reverting_tx_hashes: if with_reverted_hash {
                     Some(vec![txn_hash])
                 } else {
                     None
                 },
-                block_number_min: bundle_opts.block_number_min,
-                block_number_max: bundle_opts.block_number_max,
-                flashblock_number_min: bundle_opts.flashblock_number_min,
-                flashblock_number_max: bundle_opts.flashblock_number_max,
+                min_block_number: bundle_opts.min_block_number,
+                max_block_number: bundle_opts.max_block_number,
+                min_flashblock_number: bundle_opts.min_flashblock_number,
+                max_flashblock_number: bundle_opts.max_flashblock_number,
                 min_timestamp: bundle_opts.min_timestamp,
                 max_timestamp: bundle_opts.max_timestamp,
             };
diff --git a/crates/op-rbuilder/src/tests/revert.rs b/crates/op-rbuilder/src/tests/revert.rs
index 8ed792c9d..4d0b4ac75 100644
--- a/crates/op-rbuilder/src/tests/revert.rs
+++ b/crates/op-rbuilder/src/tests/revert.rs
@@ -32,7 +32,7 @@ async fn monitor_transaction_gc(rbuilder: LocalInstance) -> eyre::Result<()> {
             .random_reverting_transaction()
             .with_signer(accounts[i].clone())
             .with_bundle(
-                BundleOpts::default().with_block_number_max(latest_block_number + i as u64 + 1),
+                BundleOpts::default().with_max_block_number(latest_block_number + i as u64 + 1),
             )
             .send()
             .await?;
@@ -151,7 +151,7 @@ async fn bundle(rbuilder: LocalInstance) -> eyre::Result<()> {
             .includes(valid_bundle.tx_hash())
     );
 
-    let bundle_opts = BundleOpts::default().with_block_number_max(4);
+    let bundle_opts = BundleOpts::default().with_max_block_number(4);
 
     let reverted_bundle = driver
         .create_transaction()
@@ -190,7 +190,7 @@ async fn bundle_min_block_number(rbuilder: LocalInstance) -> eyre::Result<()> {
         .create_transaction()
         .with_revert() // the transaction reverts but it is included in the block
         .with_reverted_hash()
-        .with_bundle(BundleOpts::default().with_block_number_min(2))
+        .with_bundle(BundleOpts::default().with_min_block_number(2))
         .send()
         .await?;
 
@@ -207,8 +207,8 @@ async fn bundle_min_block_number(rbuilder: LocalInstance) -> eyre::Result<()> {
         .with_reverted_hash()
         .with_bundle(
             BundleOpts::default()
-                .with_block_number_max(4)
-                .with_block_number_min(4),
+                .with_max_block_number(4)
+                .with_min_block_number(4),
         )
         .send()
         .await?;
@@ -269,7 +269,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
 
     // Max block cannot be a past block
     assert!(
-        send_bundle(&driver, BundleOpts::default().with_block_number_max(1))
+        send_bundle(&driver, BundleOpts::default().with_max_block_number(1))
             .await
             .is_err()
     );
@@ -280,7 +280,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
 
     for i in next_valid_block..next_valid_block + MAX_BLOCK_RANGE_BLOCKS {
         assert!(
-            send_bundle(&driver, BundleOpts::default().with_block_number_max(i))
+            send_bundle(&driver, BundleOpts::default().with_max_block_number(i))
                 .await
                 .is_ok()
         );
@@ -291,7 +291,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
         send_bundle(
             &driver,
             BundleOpts::default()
-                .with_block_number_max(next_valid_block + MAX_BLOCK_RANGE_BLOCKS + 1)
+                .with_max_block_number(next_valid_block + MAX_BLOCK_RANGE_BLOCKS + 1)
         )
         .await
         .is_err()
@@ -302,8 +302,8 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
         send_bundle(
             &driver,
             BundleOpts::default()
-                .with_block_number_max(1)
-                .with_block_number_min(2)
+                .with_max_block_number(1)
+                .with_min_block_number(2)
         )
         .await
         .is_err()
@@ -314,8 +314,8 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
         send_bundle(
             &driver,
             BundleOpts::default()
-                .with_block_number_max(next_valid_block)
-                .with_block_number_min(current_block)
+                .with_max_block_number(next_valid_block)
+                .with_min_block_number(current_block)
         )
         .await
         .is_ok()
@@ -323,7 +323,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
     assert!(
         send_bundle(
             &driver,
-            BundleOpts::default().with_block_number_max(next_valid_block)
+            BundleOpts::default().with_max_block_number(next_valid_block)
         )
         .await
         .is_ok()
@@ -334,8 +334,8 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
         send_bundle(
             &driver,
             BundleOpts::default()
-                .with_block_number_max(next_valid_block)
-                .with_block_number_min(next_valid_block)
+                .with_max_block_number(next_valid_block)
+                .with_min_block_number(next_valid_block)
         )
         .await
         .is_ok()
@@ -347,7 +347,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
     assert!(
         send_bundle(
             &driver,
-            BundleOpts::default().with_block_number_min(current_block)
+            BundleOpts::default().with_min_block_number(current_block)
         )
         .await
         .is_ok()
@@ -355,7 +355,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
     assert!(
         send_bundle(
             &driver,
-            BundleOpts::default().with_block_number_min(default_max - 1)
+            BundleOpts::default().with_min_block_number(default_max - 1)
         )
         .await
         .is_ok()
@@ -363,7 +363,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
     assert!(
         send_bundle(
             &driver,
-            BundleOpts::default().with_block_number_min(default_max)
+            BundleOpts::default().with_min_block_number(default_max)
         )
         .await
         .is_ok()
@@ -373,7 +373,7 @@ async fn bundle_range_limits(rbuilder: LocalInstance) -> eyre::Result<()> {
     assert!(
         send_bundle(
             &driver,
-            BundleOpts::default().with_block_number_min(default_max + 1)
+            BundleOpts::default().with_min_block_number(default_max + 1)
         )
         .await
         .is_err()
@@ -428,7 +428,7 @@ async fn check_transaction_receipt_status_message(rbuilder: LocalInstance) -> ey
     let reverting_tx = driver
         .create_transaction()
         .random_reverting_transaction()
-        .with_bundle(BundleOpts::default().with_block_number_max(3))
+        .with_bundle(BundleOpts::default().with_max_block_number(3))
         .send()
         .await?;
     let tx_hash = reverting_tx.tx_hash();
diff --git a/crates/op-rbuilder/src/tx.rs b/crates/op-rbuilder/src/tx.rs
index 64f7e43f5..8447698cf 100644
--- a/crates/op-rbuilder/src/tx.rs
+++ b/crates/op-rbuilder/src/tx.rs
@@ -27,8 +27,8 @@ pub struct FBPooledTransaction {
     /// transaction is not a bundle, this is `None`.
     pub reverted_hashes: Option<Vec<B256>>,
 
-    pub flashblock_number_min: Option<u64>,
-    pub flashblock_number_max: Option<u64>,
+    pub min_flashblock_number: Option<u64>,
+    pub max_flashblock_number: Option<u64>,
 }
 
 impl FBPoolTransaction for FBPooledTransaction {}
@@ -56,29 +56,29 @@ impl MaybeRevertingTransaction for FBPooledTransaction {
 }
 
 pub trait MaybeFlashblockFilter {
-    fn with_flashblock_number_min(self, flashblock_number_min: Option<u64>) -> Self;
-    fn with_flashblock_number_max(self, flashblock_number_max: Option<u64>) -> Self;
-    fn flashblock_number_min(&self) -> Option<u64>;
-    fn flashblock_number_max(&self) -> Option<u64>;
+    fn with_min_flashblock_number(self, min_flashblock_number: Option<u64>) -> Self;
+    fn with_max_flashblock_number(self, max_flashblock_number: Option<u64>) -> Self;
+    fn min_flashblock_number(&self) -> Option<u64>;
+    fn max_flashblock_number(&self) -> Option<u64>;
 }
 
 impl MaybeFlashblockFilter for FBPooledTransaction {
-    fn with_flashblock_number_min(mut self, flashblock_number_min: Option<u64>) -> Self {
-        self.flashblock_number_min = flashblock_number_min;
+    fn with_min_flashblock_number(mut self, min_flashblock_number: Option<u64>) -> Self {
+        self.min_flashblock_number = min_flashblock_number;
         self
     }
 
-    fn with_flashblock_number_max(mut self, flashblock_number_max: Option<u64>) -> Self {
-        self.flashblock_number_max = flashblock_number_max;
+    fn with_max_flashblock_number(mut self, max_flashblock_number: Option<u64>) -> Self {
+        self.max_flashblock_number = max_flashblock_number;
         self
     }
 
-    fn flashblock_number_min(&self) -> Option<u64> {
-        self.flashblock_number_min
+    fn min_flashblock_number(&self) -> Option<u64> {
+        self.min_flashblock_number
     }
 
-    fn flashblock_number_max(&self) -> Option<u64> {
-        self.flashblock_number_max
+    fn max_flashblock_number(&self) -> Option<u64> {
+        self.max_flashblock_number
     }
 }
 
@@ -107,8 +107,8 @@ impl PoolTransaction for FBPooledTransaction {
         Self {
             inner,
             reverted_hashes: None,
-            flashblock_number_min: None,
-            flashblock_number_max: None,
+            min_flashblock_number: None,
+            max_flashblock_number: None,
         }
     }
 
@@ -267,8 +267,8 @@ impl From<OpPooledTransaction> for FBPooledTransaction {
         Self {
             inner: tx,
             reverted_hashes: None,
-            flashblock_number_min: None,
-            flashblock_number_max: None,
+            min_flashblock_number: None,
+            max_flashblock_number: None,
         }
     }
 }
@@ -293,8 +293,8 @@ impl MaybeConditionalTransaction for FBPooledTransaction {
         FBPooledTransaction {
             inner: self.inner.with_conditional(conditional),
             reverted_hashes: self.reverted_hashes,
-            flashblock_number_min: self.flashblock_number_min,
-            flashblock_number_max: self.flashblock_number_max,
+            min_flashblock_number: self.min_flashblock_number,
+            max_flashblock_number: self.max_flashblock_number,
         }
     }
 }
diff --git a/docs/eth_sendBundle.md b/docs/eth_sendBundle.md
index 7dfa4daa1..2af834db8 100644
--- a/docs/eth_sendBundle.md
+++ b/docs/eth_sendBundle.md
@@ -27,16 +27,16 @@ The `eth_sendBundle` endpoint is only available when revert protection is enable
 
 ### Parameters
 
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `txs` | `string[]` | ✅ | Array of RLP-encoded transaction data (exactly one transaction) |
-| `revertingTxHashes` | `string[]` | ❌ | Transaction hashes allowed to revert without failing the bundle |
-| `minBlockNumber` | `number` | ❌ | Earliest block number for execution |
-| `maxBlockNumber` | `number` | ❌ | Latest block number for execution |
-| `minFlashblockNumber` | `number` | ❌ | Earliest flashblock iteration for execution |
-| `maxFlashblockNumber` | `number` | ❌ | Latest flashblock iteration for execution |
-| `minTimestamp` | `number` | ❌ | Earliest timestamp for execution (Unix epoch seconds) |
-| `maxTimestamp` | `number` | ❌ | Latest timestamp for execution (Unix epoch seconds) |
+| Field                 | Type       | Required | Description                                                     |
+| --------------------- | ---------- | -------- | --------------------------------------------------------------- |
+| `txs`                 | `string[]` | ✅        | Array of RLP-encoded transaction data (exactly one transaction) |
+| `revertingTxHashes`   | `string[]` | ❌        | Transaction hashes allowed to revert without failing the bundle |
+| `minBlockNumber`      | `number`   | ❌        | Earliest block number for execution                             |
+| `maxBlockNumber`      | `number`   | ❌        | Latest block number for execution                               |
+| `minFlashblockNumber` | `number`   | ❌        | Earliest flashblock iteration for execution                     |
+| `maxFlashblockNumber` | `number`   | ❌        | Latest flashblock iteration for execution                       |
+| `minTimestamp`        | `number`   | ❌        | Earliest timestamp for execution (Unix epoch seconds)           |
+| `maxTimestamp`        | `number`   | ❌        | Latest timestamp for execution (Unix epoch seconds)             |
 
 ## Response
 
@@ -81,13 +81,13 @@ Timestamp-based constraints depend on the builder node's clock and may not be pe
 
 ## Error Responses
 
-| Error | Description | Solution |
-|-------|-------------|----------|
-| `bundle must contain exactly one transaction` | Bundle has 0 or >1 transactions | Include exactly one transaction |
-| `block_number_max (X) is a past block` | Max block is ≤ current block | Use future block number |
-| `block_number_max (X) is too high` | Block range exceeds 10 blocks | Reduce block range |
-| `flashblock_number_min (X) is greater than flashblock_number_max (Y)` | Invalid flashblock range | Ensure min ≤ max |
-| `method not found` | Revert protection disabled | Enable revert protection |
+| Error                                                                 | Description                     | Solution                        |
+| --------------------------------------------------------------------- | ------------------------------- | ------------------------------- |
+| `bundle must contain exactly one transaction`                         | Bundle has 0 or >1 transactions | Include exactly one transaction |
+| `max_block_number (X) is a past block`                                | Max block is ≤ current block    | Use future block number         |
+| `max_block_number (X) is too high`                                    | Block range exceeds 10 blocks   | Reduce block range              |
+| `min_flashblock_number (X) is greater than max_flashblock_number (Y)` | Invalid flashblock range        | Ensure min ≤ max                |
+| `method not found`                                                    | Revert protection disabled      | Enable revert protection        |
 
 ## Usage Examples
 
@@ -156,4 +156,4 @@ curl -X POST http://localhost:8545 \
     "id": 1,
     "jsonrpc": "2.0"
   }'
-```
\ No newline at end of file
+```