feat: add --builder.enforce-resource-metering flag

When false (default), transactions that exceed execution time limits
are logged and metrics recorded, but not rejected. Only the first
transaction to exceed the limit triggers logging/metrics.

When true, transactions exceeding limits are marked invalid and
excluded from the block.

Author: niran

crates/op-rbuilder/src/args/op.rs

@@ -51,7 +51,10 @@ pub struct OpRbuilderArgs {
     /// Whether to enable TIPS Resource Metering
     #[arg(long = "builder.enable-resource-metering", default_value = "false")]
     pub enable_resource_metering: bool,
-    /// Whether to enable TIPS Resource Metering
+    /// Whether to enforce resource metering limits (reject transactions that exceed limits)
+    #[arg(long = "builder.enforce-resource-metering", default_value = "false")]
+    pub enforce_resource_metering: bool,
+    /// Buffer size for resource metering data
     #[arg(
         long = "builder.resource-metering-buffer-size",
         default_value = "10000"

crates/op-rbuilder/src/base/context.rs

@@ -8,15 +8,18 @@ use super::metrics::BaseMetrics;
 pub struct BaseBuilderCtx {
     /// Block execution time limit in microseconds
     pub block_execution_time_limit_us: u128,
+    /// Whether to enforce resource metering limits
+    pub enforce_limits: bool,
     /// Base-specific metrics
     pub metrics: BaseMetrics,
 }
 
 impl BaseBuilderCtx {
     /// Create a new BaseBuilderCtx with the given execution time limit.
-    pub fn new(block_execution_time_limit_us: u128) -> Self {
+    pub fn new(block_execution_time_limit_us: u128, enforce_limits: bool) -> Self {
         Self {
             block_execution_time_limit_us,
+            enforce_limits,
             metrics: Default::default(),
         }
     }

crates/op-rbuilder/src/base/execution.rs

@@ -38,7 +38,19 @@ pub enum BaseLimitExceeded {
 }
 
 impl BaseLimitExceeded {
+    /// Returns the tx usage that caused the limit to be exceeded.
+    pub fn usage(&self) -> BaseTxUsage {
+        match self {
+            Self::ExecutionTime { tx_us, .. } => BaseTxUsage {
+                execution_time_us: *tx_us,
+            },
+        }
+    }
+
     /// Log and record metrics for this limit exceeded event.
+    ///
+    /// Only logs/records if this is the first tx to exceed the limit
+    /// (i.e., cumulative was within the limit before this tx).
     pub fn log_and_record(&self, metrics: &BaseMetrics) {
         match self {
             Self::ExecutionTime {
@@ -49,6 +61,11 @@ impl BaseLimitExceeded {
                 tx_gas,
                 remaining_gas,
             } => {
+                // Only log/record for the first tx that exceeds the limit
+                if *cumulative_us > *limit_us {
+                    return;
+                }
+
                 let remaining_us = limit_us.saturating_sub(*cumulative_us);
                 let exceeded_by_us = tx_us.saturating_sub(remaining_us);
                 warn!(
@@ -97,6 +114,7 @@ impl BaseExecutionState {
         let total = self
             .cumulative_execution_time_us
             .saturating_add(usage.execution_time_us);
+
         if total > execution_time_limit_us {
             let remaining_gas = block_gas_limit.saturating_sub(cumulative_gas_used);
             return Err(BaseLimitExceeded::ExecutionTime {

crates/op-rbuilder/src/base/flashblocks.rs

@@ -10,19 +10,22 @@ pub struct BaseFlashblocksCtx {
     pub target_execution_time_us: u128,
     /// Execution time (us) limit per flashblock batch
     pub execution_time_per_batch_us: u128,
+    /// Whether to enforce resource metering limits
+    pub enforce_limits: bool,
 }
 
 impl BaseFlashblocksCtx {
     /// Create a new BaseFlashblocksCtx with the given execution time limit per batch.
-    pub fn new(execution_time_per_batch_us: u128) -> Self {
+    pub fn new(execution_time_per_batch_us: u128, enforce_limits: bool) -> Self {
         Self {
             target_execution_time_us: execution_time_per_batch_us,
             execution_time_per_batch_us,
+            enforce_limits,
         }
     }
 
     /// Advance to the next batch, updating the target execution time.
-    /// 
+    ///
     /// Unlike gas and DA, execution time does not carry over to the next batch.
     pub fn next(self, cumulative_execution_time_us: u128) -> Self {
         Self {
@@ -34,6 +37,6 @@ impl BaseFlashblocksCtx {
 
 impl From<&BaseFlashblocksCtx> for BaseBuilderCtx {
     fn from(ctx: &BaseFlashblocksCtx) -> Self {
-        BaseBuilderCtx::new(ctx.target_execution_time_us)
+        BaseBuilderCtx::new(ctx.target_execution_time_us, ctx.enforce_limits)
     }
 }

crates/op-rbuilder/src/builders/context.rs

@@ -500,8 +500,11 @@ impl<ExtraCtx: Debug + Default> OpPayloadBuilderCtx<ExtraCtx> {
                 Ok(usage) => usage,
                 Err(exceeded) => {
                     exceeded.log_and_record(&self.base_ctx.metrics);
-                    best_txs.mark_invalid(tx.signer(), tx.nonce());
-                    continue;
+                    if self.base_ctx.enforce_limits {
+                        best_txs.mark_invalid(tx.signer(), tx.nonce());
+                        continue;
+                    }
+                    exceeded.usage()
                 }
             };
 

crates/op-rbuilder/src/builders/flashblocks/ctx.rs

@@ -55,7 +55,10 @@ impl OpPayloadSyncerCtx {
             max_gas_per_txn: builder_config.max_gas_per_txn,
             metrics,
             resource_metering: builder_config.resource_metering,
-            base_ctx: BaseBuilderCtx::new(builder_config.block_time.as_micros()),
+            base_ctx: BaseBuilderCtx::new(
+                builder_config.block_time.as_micros(),
+                builder_config.enforce_resource_metering,
+            ),
         })
     }
 

crates/op-rbuilder/src/builders/flashblocks/payload.rs

@@ -288,7 +288,10 @@ where
             max_gas_per_txn: self.config.max_gas_per_txn,
             address_gas_limiter: self.address_gas_limiter.clone(),
             resource_metering: self.config.resource_metering.clone(),
-            base_ctx: BaseBuilderCtx::new(self.config.block_time.as_micros()),
+            base_ctx: BaseBuilderCtx::new(
+                self.config.block_time.as_micros(),
+                self.config.enforce_resource_metering,
+            ),
         })
     }
 
@@ -471,7 +474,10 @@ where
             da_footprint_per_batch,
             disable_state_root,
             target_da_footprint_for_batch: da_footprint_per_batch,
-            base_ctx: BaseFlashblocksCtx::new(self.config.specific.interval.as_micros()),
+            base_ctx: BaseFlashblocksCtx::new(
+                self.config.specific.interval.as_micros(),
+                self.config.enforce_resource_metering,
+            ),
         };
 
         let mut fb_cancel = block_cancel.child_token();

crates/op-rbuilder/src/builders/mod.rs

@@ -130,6 +130,9 @@ pub struct BuilderConfig<Specific: Clone> {
 
     /// Resource metering context
     pub resource_metering: ResourceMetering,
+
+    /// Whether to enforce resource metering limits
+    pub enforce_resource_metering: bool,
 }
 
 impl<S: Debug + Clone> core::fmt::Debug for BuilderConfig<S> {
@@ -171,6 +174,7 @@ impl<S: Default + Clone> Default for BuilderConfig<S> {
             max_gas_per_txn: None,
             gas_limiter_config: GasLimiterArgs::default(),
             resource_metering: ResourceMetering::default(),
+            enforce_resource_metering: false,
         }
     }
 }
@@ -197,6 +201,7 @@ where
                 args.enable_resource_metering,
                 args.resource_metering_buffer_size,
             ),
+            enforce_resource_metering: args.enforce_resource_metering,
             specific: S::try_from(args)?,
         })
     }

crates/op-rbuilder/src/builders/standard/payload.rs

@@ -253,7 +253,10 @@ where
             max_gas_per_txn: self.config.max_gas_per_txn,
             address_gas_limiter: self.address_gas_limiter.clone(),
             resource_metering: self.config.resource_metering.clone(),
-            base_ctx: BaseBuilderCtx::new(self.config.block_time.as_micros()),
+            base_ctx: BaseBuilderCtx::new(
+                self.config.block_time.as_micros(),
+                self.config.enforce_resource_metering,
+            ),
         };
 
         let builder = OpBuilder::new(best);