Add dynamic DA limit support via miner_setMaxDASize RPC

The priority fee estimator now respects dynamic DA limits set via the
miner_setMaxDASize RPC call. This allows operators to adjust DA limits
at runtime without restarting the node.

Key changes:
- PriorityFeeEstimator accepts optional OpDAConfig for dynamic DA limits
- When metering is enabled, the miner RPC module is automatically enabled
- Shared OpDAConfig is passed to both OpNode (for miner RPC) and estimator
- Add integration test that verifies setMaxDASize affects priority fee estimates

Author: niran

Cargo.lock

@@ -60,6 +60,7 @@ reth-rpc-eth-api = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3"
 reth-optimism-primitives = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-rpc-convert = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-optimism-rpc = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
+reth-optimism-payload-builder = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-optimism-evm = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-optimism-chainspec = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-provider = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
@@ -76,6 +77,7 @@ reth-db-common = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-rpc-layer = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-ipc = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 reth-node-core = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
+reth-rpc-server-types = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.3" }
 
 # revm
 revm = { version = "31.0.2", default-features = false }
@@ -143,6 +145,5 @@ arc-swap = "1.7.1"
 once_cell = "1.19"
 rand = "0.9.2"
 httpmock = "0.8.2"
-tracing-subscriber = "0.3"
 parking_lot = "0.12.3"
 indexmap = "2.7.0"

Cargo.toml

@@ -22,6 +22,7 @@ reth-primitives-traits.workspace = true
 reth-evm.workspace = true
 reth-optimism-evm.workspace = true
 reth-optimism-chainspec.workspace = true
+reth-optimism-payload-builder.workspace = true
 reth-optimism-primitives.workspace = true
 reth-transaction-pool.workspace = true
 reth-optimism-cli.workspace = true  # Enables serde & codec traits for OpReceipt/OpTxEnvelope
@@ -39,6 +40,7 @@ op-alloy-flz.workspace = true
 jsonrpsee.workspace = true
 
 # misc
+serde.workspace = true
 tracing.workspace = true
 eyre.workspace = true
 indexmap.workspace = true
@@ -57,6 +59,9 @@ reth-db = { workspace = true, features = ["test-utils"] }
 reth-db-common.workspace = true
 reth-e2e-test-utils.workspace = true
 reth-optimism-node.workspace = true
+reth-optimism-payload-builder.workspace = true
+reth-optimism-rpc.workspace = true
+reth-rpc-server-types.workspace = true
 reth-testing-utils.workspace = true
 reth-tracing.workspace = true
 reth-transaction-pool = { workspace = true, features = ["test-utils"] }

crates/metering/Cargo.toml

@@ -1,6 +1,7 @@
 use crate::{MeteredTransaction, MeteringCache};
 use alloy_primitives::U256;
 use parking_lot::RwLock;
+use reth_optimism_payload_builder::config::OpDAConfig;
 use std::sync::Arc;
 
 /// Errors that can occur during priority fee estimation.
@@ -232,6 +233,10 @@ pub struct PriorityFeeEstimator {
     percentile: f64,
     limits: ResourceLimits,
     default_priority_fee: U256,
+    /// Optional shared DA config from the miner RPC. When set, the estimator uses
+    /// `max_da_block_size` from this config instead of `limits.data_availability_bytes`.
+    /// This allows dynamic updates via `miner_setMaxDASize`.
+    da_config: Option<OpDAConfig>,
 }
 
 impl PriorityFeeEstimator {
@@ -243,17 +248,37 @@ impl PriorityFeeEstimator {
     ///   to use for the recommended fee.
     /// - `limits`: Configured resource capacity limits.
     /// - `default_priority_fee`: Fee to return when a resource is not congested.
+    /// - `da_config`: Optional shared DA config for dynamic DA limit updates.
     pub fn new(
         cache: Arc<RwLock<MeteringCache>>,
         percentile: f64,
         limits: ResourceLimits,
         default_priority_fee: U256,
+        da_config: Option<OpDAConfig>,
     ) -> Self {
         Self {
             cache,
             percentile,
             limits,
             default_priority_fee,
+            da_config,
+        }
+    }
+
+    /// Returns the current DA block size limit, preferring the dynamic `OpDAConfig` value
+    /// if available, otherwise falling back to the static limit.
+    pub fn max_da_block_size(&self) -> Option<u64> {
+        self.da_config
+            .as_ref()
+            .and_then(|c| c.max_da_block_size())
+            .or(self.limits.data_availability_bytes)
+    }
+
+    /// Returns the limit for the given resource kind, using dynamic config where available.
+    fn limit_for(&self, resource: ResourceKind) -> Option<u128> {
+        match resource {
+            ResourceKind::DataAvailability => self.max_da_block_size().map(|v| v as u128),
+            _ => self.limits.limit_for(resource),
         }
     }
 
@@ -321,7 +346,7 @@ impl PriorityFeeEstimator {
                 let Some(demand_value) = demand.demand_for(resource) else {
                     continue;
                 };
-                let Some(limit_value) = self.limits.limit_for(resource) else {
+                let Some(limit_value) = self.limit_for(resource) else {
                     continue;
                 };
 
@@ -807,7 +832,7 @@ mod tests {
         limits: ResourceLimits,
     ) -> (Arc<RwLock<MeteringCache>>, PriorityFeeEstimator) {
         let cache = Arc::new(RwLock::new(MeteringCache::new(4)));
-        let estimator = PriorityFeeEstimator::new(cache.clone(), 0.5, limits, DEFAULT_FEE);
+        let estimator = PriorityFeeEstimator::new(cache.clone(), 0.5, limits, DEFAULT_FEE, None);
         (cache, estimator)
     }
 

crates/metering/src/estimator.rs

@@ -18,6 +18,7 @@ pub use estimator::{
 };
 pub use kafka::{KafkaBundleConsumer, KafkaBundleConsumerConfig};
 pub use meter::meter_bundle;
+pub use reth_optimism_payload_builder::config::OpDAConfig;
 pub use rpc::{
     MeteredPriorityFeeResponse, MeteringApiImpl, MeteringApiServer, ResourceFeeEstimateResponse,
 };

crates/metering/src/lib.rs

@@ -149,9 +149,9 @@ where
             })?;
 
         let bundle_gas_price = if total_gas_used > 0 {
-            (total_gas_fees / U256::from(total_gas_used)).to_string()
+            total_gas_fees / U256::from(total_gas_used)
         } else {
-            "0".to_string()
+            U256::from(0)
         };
 
         info!(
@@ -165,9 +165,9 @@ where
         let response = MeterBundleResponse {
             bundle_gas_price,
             bundle_hash,
-            coinbase_diff: total_gas_fees.to_string(),
-            eth_sent_to_coinbase: "0".to_string(),
-            gas_fees: total_gas_fees.to_string(),
+            coinbase_diff: total_gas_fees,
+            eth_sent_to_coinbase: U256::from(0),
+            gas_fees: total_gas_fees,
             results,
             state_block_number: header.number,
             state_flashblock_index: None,

crates/metering/src/rpc.rs

@@ -3,7 +3,8 @@ mod tests {
     use std::{any::Any, net::SocketAddr, sync::Arc};
 
     use crate::{
-        MeteringApiImpl, MeteringApiServer, MeteringCache, PriorityFeeEstimator, ResourceLimits,
+        MeteredTransaction, MeteringApiImpl, MeteringApiServer, MeteringCache,
+        PriorityFeeEstimator, ResourceLimits,
     };
 
     const PRIORITY_FEE_PERCENTILE: f64 = 0.5;
@@ -27,14 +28,17 @@ mod tests {
     };
     use reth_optimism_chainspec::OpChainSpecBuilder;
     use reth_optimism_node::{OpNode, args::RollupArgs};
+    use reth_optimism_payload_builder::config::OpDAConfig;
     use reth_optimism_primitives::OpTransactionSigned;
+    use reth_rpc_server_types::{RethRpcModule, RpcModuleSelection};
     use reth_provider::providers::BlockchainProvider;
     use reth_transaction_pool::test_utils::TransactionBuilder;
     use serde_json;
     use tips_core::types::Bundle;
 
     pub struct NodeContext {
         http_api_addr: SocketAddr,
+        cache: Arc<RwLock<MeteringCache>>,
         _node_exit_future: NodeExitFuture,
         _node: Box<dyn Any + Sync + Send>,
     }
@@ -84,10 +88,19 @@ mod tests {
 
         let node_config = NodeConfig::new(chain_spec.clone())
             .with_network(network_config.clone())
-            .with_rpc(RpcServerArgs::default().with_unused_ports().with_http())
+            .with_rpc(
+                RpcServerArgs::default()
+                    .with_unused_ports()
+                    .with_http()
+                    .with_http_api(RpcModuleSelection::from([RethRpcModule::Miner])),
+            )
             .with_unused_ports();
 
-        let node = OpNode::new(RollupArgs::default());
+        // Create shared DA config that will be used by both the miner RPC and the estimator.
+        // When miner_setMaxDASize is called, the OpDAConfig is updated atomically and
+        // the estimator will see the new limits.
+        let da_config = OpDAConfig::default();
+        let node = OpNode::new(RollupArgs::default()).with_da_config(da_config.clone());
 
         let cache = Arc::new(RwLock::new(MeteringCache::new(12)));
         let limits = ResourceLimits {
@@ -101,6 +114,7 @@ mod tests {
             PRIORITY_FEE_PERCENTILE,
             limits,
             U256::from(UNCONGESTED_PRIORITY_FEE),
+            Some(da_config.clone()),
         ));
         let estimator_for_rpc = estimator.clone();
 
@@ -125,6 +139,7 @@ mod tests {
 
         Ok(NodeContext {
             http_api_addr,
+            cache,
             _node_exit_future: node_exit_future,
             _node: Box::new(node),
         })
@@ -470,4 +485,108 @@ mod tests {
 
         Ok(())
     }
+
+    /// Creates a test transaction with specified priority fee and DA bytes.
+    fn test_tx(priority_fee: u64, da_bytes: u64) -> MeteredTransaction {
+        let mut hash_bytes = [0u8; 32];
+        hash_bytes[24..].copy_from_slice(&priority_fee.to_be_bytes());
+        MeteredTransaction {
+            tx_hash: alloy_primitives::B256::new(hash_bytes),
+            priority_fee_per_gas: U256::from(priority_fee),
+            gas_used: 21_000,
+            execution_time_us: 100,
+            state_root_time_us: 0,
+            data_availability_bytes: da_bytes,
+        }
+    }
+
+    #[tokio::test]
+    async fn test_set_max_da_size_updates_priority_fee_estimates() -> eyre::Result<()> {
+        reth_tracing::init_test_tracing();
+        let node = setup_node().await?;
+        let client = node.rpc_client().await?;
+
+        // Create a transaction to include in the bundle for DA demand calculation.
+        // Use a funded account from genesis.json (Hardhat account #0).
+        let sender_secret =
+            b256!("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+
+        let tx = TransactionBuilder::default()
+            .signer(sender_secret)
+            .chain_id(84532)
+            .nonce(0)
+            .to(address!("0x1111111111111111111111111111111111111111"))
+            .value(1000)
+            .gas_limit(21_000)
+            .max_fee_per_gas(1_000_000_000)
+            .max_priority_fee_per_gas(1_000_000_000)
+            .into_eip1559();
+
+        let signed_tx =
+            OpTransactionSigned::Eip1559(tx.as_eip1559().expect("eip1559 transaction").clone());
+        let envelope: OpTxEnvelope = signed_tx.into();
+        let tx_bytes = Bytes::from(envelope.encoded_2718());
+
+        // Populate the cache with test transactions that have known DA bytes.
+        // We'll create a scenario where DA is the constraining resource:
+        //   - tx1: priority=100, DA=50 bytes
+        //   - tx2: priority=50, DA=50 bytes
+        //   - tx3: priority=10, DA=50 bytes
+        // Total DA used by existing transactions = 150 bytes
+        {
+            let mut cache = node.cache.write();
+            cache.upsert_transaction(1, 0, test_tx(100, 50));
+            cache.upsert_transaction(1, 0, test_tx(50, 50));
+            cache.upsert_transaction(1, 0, test_tx(10, 50));
+        }
+
+        // Bundle with our transaction - it will have some DA demand from the tx bytes.
+        let bundle = create_bundle(vec![tx_bytes], 0, None);
+
+        // With default DA limit (120KB = 120_000 bytes), there's plenty of room.
+        // All transactions fit (150 bytes used) plus our bundle's demand.
+        // This should return the uncongested default fee (1 wei).
+        //
+        // Note: We use serde_json::Value because alloy_rpc_client can't deserialize u128 fields
+        // when they're nested in flattened structs. The response contains totalExecutionTimeUs
+        // as u128 which causes deserialization issues.
+        let response: serde_json::Value = client
+            .request("base_meteredPriorityFeePerGas", (bundle.clone(),))
+            .await?;
+
+        let fee_before = response["recommendedPriorityFee"]
+            .as_str()
+            .expect("recommendedPriorityFee should be a string");
+        assert_eq!(
+            fee_before, "1",
+            "with large DA limit, resource should be uncongested"
+        );
+
+        // Now reduce the DA limit to 200 bytes via miner_setMaxDASize.
+        // With 200 byte limit and ~100 byte bundle demand, only ~100 bytes available for others.
+        // tx1 (50) + tx2 (50) = 100 bytes fits, but adding tx3 (50) = 150 bytes exceeds capacity.
+        // So tx3 gets displaced. Threshold fee = tx2's fee = 50.
+        let result: bool = client.request("miner_setMaxDASize", (1000, 200)).await?;
+        assert!(result, "miner_setMaxDASize should succeed");
+
+        // Request priority fee again - now DA should be congested.
+        let response: serde_json::Value = client
+            .request("base_meteredPriorityFeePerGas", (bundle,))
+            .await?;
+
+        // With the reduced limit, we should see a higher recommended fee.
+        // The exact value depends on the percentile calculation, but it should
+        // be significantly higher than the uncongested fee of 1.
+        let fee_after = response["recommendedPriorityFee"]
+            .as_str()
+            .expect("recommendedPriorityFee should be a string");
+        let fee: u64 = fee_after.parse().expect("valid u64");
+        assert!(
+            fee > 1,
+            "with reduced DA limit, recommended fee should be higher than uncongested fee (1), got {}",
+            fee
+        );
+
+        Ok(())
+    }
 }

crates/metering/src/tests/rpc.rs

@@ -22,6 +22,7 @@ base-reth-transaction-status.workspace = true
 reth.workspace = true
 reth-optimism-node.workspace = true
 reth-optimism-cli.workspace = true
+reth-rpc-server-types.workspace = true
 reth-cli-util.workspace = true
 
 # async
@@ -30,8 +31,16 @@ futures-util.workspace = true
 # reth-exex
 reth-exex.workspace = true
 
+# alloy
+alloy-primitives.workspace = true
+
+# tokio
+tokio.workspace = true
+
 # misc
 clap.workspace = true
+eyre.workspace = true
+metrics.workspace = true
 tracing.workspace = true
 url.workspace = true
 once_cell.workspace = true