feat: implement nicer batch limit and fees

fix bach too large

Author: GCdePaula

sequencer-core/src/batch.rs

@@ -8,6 +8,23 @@ use ssz_derive::{Decode, Encode};
 /// L1/app must post such inputs as `0x00 || body`. Only these are stored (body only) and executed.
 pub const INPUT_TAG_DIRECT_INPUT: u8 = 0x00;
 
+// ---------------------------------------------------------------------------
+// Gas-economics-derived batch sizing
+//
+// The InputBox contract charges roughly:
+//   total_gas ≈ base_gas + delta × payload_bytes
+//
+// We charge each user-op a DA fee of (1 + α) × δ per byte, where α amortizes
+// the base cost across the batch:
+//
+//   α × δ × n = base_gas   ⟹   n = base_gas / (α × δ)
+//
+// Choosing α (the overhead fraction) determines the batch size n in bytes.
+// All parameters live in the `batch_policy` SQLite singleton table so they
+// can be hot-swapped at runtime (see 0001_schema.sql). A CHECK constraint
+// on that table ensures batch_size_target < const_max_batch_bytes.
+// ---------------------------------------------------------------------------
+
 /// Batch submissions are sent as raw `ssz(Batch)` with no tag; classification at L1 is by
 /// attempting SSZ decode, and at the rollup by msg_sender.
 

sequencer/src/inclusion_lane/config.rs

@@ -4,13 +4,10 @@
 use std::time::Duration;
 
 use alloy_primitives::Address;
-use sequencer_core::application::Application;
-use sequencer_core::user_op::SignedUserOp;
 
-const DEFAULT_MAX_USER_OPS_PER_CHUNK: usize = 1024;
+const DEFAULT_MAX_USER_OPS_PER_CHUNK: usize = 64;
 const DEFAULT_SAFE_INPUT_BUFFER_CAPACITY: usize = 2048;
 const DEFAULT_MAX_BATCH_OPEN: Duration = Duration::from_secs(2 * 60 * 60);
-const DEFAULT_MAX_BATCH_USER_OP_BYTES: usize = 1_048_576; // 1 MiB
 const DEFAULT_IDLE_POLL_INTERVAL: Duration = Duration::from_millis(2);
 
 #[derive(Debug, Clone, Copy)]
@@ -19,28 +16,16 @@ pub struct InclusionLaneConfig {
     pub max_user_ops_per_chunk: usize,
     pub safe_input_buffer_capacity: usize,
     pub max_batch_open: Duration,
-
-    // Soft threshold for batch rotation.
-    //
-    // We intentionally check this between chunks (not per user-op) to keep the hot path
-    // simple and low-latency. This means batches can overshoot the threshold by at most
-    // one processed chunk. API ingress bounds each user-op size, so this overshoot is
-    // bounded by:
-    //   max_user_ops_per_chunk * (SignedUserOp::max_batch_metadata() + A::MAX_METHOD_PAYLOAD_BYTES)
-    pub max_batch_user_op_bytes: usize,
-
     pub idle_poll_interval: Duration,
 }
 
 impl InclusionLaneConfig {
-    pub fn for_app<A: Application>(batch_submitter_address: Address) -> Self {
+    pub fn new(batch_submitter_address: Address) -> Self {
         Self {
             batch_submitter_address,
             max_user_ops_per_chunk: DEFAULT_MAX_USER_OPS_PER_CHUNK,
             safe_input_buffer_capacity: DEFAULT_SAFE_INPUT_BUFFER_CAPACITY,
             max_batch_open: DEFAULT_MAX_BATCH_OPEN,
-            max_batch_user_op_bytes: DEFAULT_MAX_BATCH_USER_OP_BYTES
-                .max(SignedUserOp::max_batch_metadata() + A::MAX_METHOD_PAYLOAD_BYTES),
             idle_poll_interval: DEFAULT_IDLE_POLL_INTERVAL,
         }
     }

sequencer/src/inclusion_lane/lane.rs

@@ -297,7 +297,7 @@ impl<A: Application + 'static> InclusionLane<A> {
 }
 
 fn should_close_batch<A: Application>(head: &WriteHead, config: &InclusionLaneConfig) -> bool {
-    should_close_batch_by_time(head, config) || should_close_batch_by_size::<A>(head, config)
+    should_close_batch_by_time(head, config) || should_close_batch_by_size::<A>(head)
 }
 
 fn should_close_batch_by_time(head: &WriteHead, config: &InclusionLaneConfig) -> bool {
@@ -307,11 +307,8 @@ fn should_close_batch_by_time(head: &WriteHead, config: &InclusionLaneConfig) ->
     age >= config.max_batch_open
 }
 
-fn should_close_batch_by_size<A: Application>(
-    head: &WriteHead,
-    config: &InclusionLaneConfig,
-) -> bool {
-    user_op_count_to_bytes::<A>(head.batch_user_op_count) >= config.max_batch_user_op_bytes as u64
+fn should_close_batch_by_size<A: Application>(head: &WriteHead) -> bool {
+    user_op_count_to_bytes::<A>(head.batch_user_op_count) >= head.max_batch_user_op_bytes
 }
 
 fn execute_user_op(

sequencer/src/inclusion_lane/tests.rs

@@ -200,7 +200,6 @@ fn default_test_config() -> InclusionLaneConfig {
         max_user_ops_per_chunk: 16,
         safe_input_buffer_capacity: 16,
         max_batch_open: Duration::MAX,
-        max_batch_user_op_bytes: 1_000_000_000,
         idle_poll_interval: Duration::from_millis(2),
     }
 }
@@ -634,9 +633,13 @@ async fn empty_batches_close_when_max_open_time_is_reached() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn batch_closes_when_max_user_op_bytes_is_reached() {
     let db = temp_db("batch-close-size");
-    let mut config = default_test_config();
-    config.max_batch_user_op_bytes =
-        SignedUserOp::max_batch_metadata() + <TestApp as Application>::MAX_METHOD_PAYLOAD_BYTES;
+    // Set alpha high enough that batch_size_target ≤ one user op (126 bytes).
+    // 55000*1000/(17000*26) = 124 bytes < 126.
+    {
+        let mut storage = Storage::open(db.path.as_str(), "NORMAL").expect("open storage");
+        storage.set_alpha(17000, 1000).expect("set alpha");
+    }
+    let config = default_test_config();
     let (tx, shutdown, lane_handle) = start_lane(db.path.as_str(), config).await;
     let (pending, recv) = make_pending_user_op(0x33);
 

sequencer/src/runtime.rs

@@ -147,7 +147,7 @@ where
         shutdown.clone(),
         app,
         storage,
-        InclusionLaneConfig::for_app::<A>(l1_config.batch_submitter_address),
+        InclusionLaneConfig::new(l1_config.batch_submitter_address),
     );
     let mut input_reader_handle = input_reader.start()?;
 

sequencer/src/storage/db.rs

@@ -9,17 +9,18 @@ use super::sql::{
     sql_count_user_ops_for_frame, sql_insert_open_batch, sql_insert_open_batch_with_index,
     sql_insert_open_frame, sql_insert_safe_inputs_batch,
     sql_insert_sequenced_direct_inputs_for_frame, sql_insert_user_ops_and_sequenced_batch,
-    sql_select_frames_for_batch, sql_select_latest_batch_index,
+    sql_select_batch_policy, sql_select_frames_for_batch, sql_select_latest_batch_index,
     sql_select_latest_batch_with_user_op_count, sql_select_latest_frame_in_batch_for_batch,
     sql_select_max_safe_input_index, sql_select_ordered_l2_tx_count,
     sql_select_ordered_l2_txs_for_batch, sql_select_ordered_l2_txs_from_offset,
-    sql_select_ordered_l2_txs_page_from_offset, sql_select_recommended_fee, sql_select_safe_block,
+    sql_select_ordered_l2_txs_page_from_offset, sql_select_safe_block,
     sql_select_safe_input_payloads_for_sender, sql_select_safe_inputs_range,
     sql_select_total_drained_direct_inputs, sql_select_user_ops_for_frame,
-    sql_update_recommended_fee, sql_update_safe_block,
+    sql_update_batch_policy_alpha, sql_update_batch_policy_gas_price, sql_update_safe_block,
 };
 use super::{
-    FrameHeader, SafeFrontier, SafeInputRange, StorageOpenError, StoredSafeInput, WriteHead,
+    BatchPolicy, FrameHeader, SafeFrontier, SafeInputRange, StorageOpenError, StoredSafeInput,
+    WriteHead,
 };
 use crate::inclusion_lane::PendingUserOp;
 use alloy_primitives::Address;
@@ -247,30 +248,44 @@ impl Storage {
         );
 
         let now_ms = now_unix_ms();
-        let frame_fee = query_recommended_fee(&tx)?;
+        let policy = query_batch_policy(&tx)?;
         insert_open_batch_with_index(&tx, 0, now_ms)?;
-        insert_open_frame(&tx, 0, 0, now_ms, frame_fee, safe_block)?;
+        insert_open_frame(&tx, 0, 0, now_ms, policy.recommended_fee, safe_block)?;
         persist_frame_direct_sequence(&tx, 0, 0, leading_direct_range)?;
         tx.commit()?;
 
         Ok(WriteHead {
             batch_index: 0,
             batch_created_at: from_unix_ms(now_ms),
-            frame_fee,
+            frame_fee: policy.recommended_fee,
             safe_block,
             batch_user_op_count: 0,
             open_frame_user_op_count: 0,
             frame_in_batch: 0,
+            max_batch_user_op_bytes: policy.batch_size_target,
         })
     }
 
-    pub fn recommended_fee(&mut self) -> Result<u64> {
-        let value = sql_select_recommended_fee(&self.conn)?;
-        Ok(i64_to_u64(value))
+    pub fn batch_policy(&mut self) -> Result<BatchPolicy> {
+        let (fee, target) = sql_select_batch_policy(&self.conn)?;
+        Ok(BatchPolicy {
+            recommended_fee: i64_to_u64(fee),
+            batch_size_target: i64_to_u64(target),
+        })
+    }
+
+    pub fn set_gas_price(&mut self, gas_price: u64) -> Result<()> {
+        let changed_rows =
+            sql_update_batch_policy_gas_price(&self.conn, u64_to_i64(gas_price))?;
+        if changed_rows != 1 {
+            return Err(rusqlite::Error::StatementChangedRows(changed_rows));
+        }
+        Ok(())
     }
 
-    pub fn set_recommended_fee(&mut self, fee: u64) -> Result<()> {
-        let changed_rows = sql_update_recommended_fee(&self.conn, u64_to_i64(fee))?;
+    pub fn set_alpha(&mut self, num: u64, denom: u64) -> Result<()> {
+        let changed_rows =
+            sql_update_batch_policy_alpha(&self.conn, u64_to_i64(num), u64_to_i64(denom))?;
         if changed_rows != 1 {
             return Err(rusqlite::Error::StatementChangedRows(changed_rows));
         }
@@ -317,14 +332,14 @@ impl Storage {
             .transaction_with_behavior(TransactionBehavior::Immediate)?;
         assert_write_head_matches_open_state(&tx, head)?;
         let now_ms = now_unix_ms();
-        let next_frame_fee = query_recommended_fee(&tx)?;
+        let policy = query_batch_policy(&tx)?;
         let next_frame_in_batch = head.frame_in_batch.saturating_add(1);
         insert_open_frame(
             &tx,
             head.batch_index,
             next_frame_in_batch,
             now_ms,
-            next_frame_fee,
+            policy.recommended_fee,
             next_safe_block,
         )?;
         persist_frame_direct_sequence(
@@ -334,7 +349,7 @@ impl Storage {
             leading_direct_range,
         )?;
         tx.commit()?;
-        head.advance_frame(next_frame_fee, next_safe_block);
+        head.advance_frame(policy, next_safe_block);
         Ok(())
     }
 
@@ -348,23 +363,23 @@ impl Storage {
             .transaction_with_behavior(TransactionBehavior::Immediate)?;
         assert_write_head_matches_open_state(&tx, head)?;
         let now_ms = now_unix_ms();
-        // Frame fee is committed here: we sample the current recommendation once and
-        // assign it to the newly opened frame.
-        let next_frame_fee = query_recommended_fee(&tx)?;
+        // Batch policy is sampled here: the derived fee is committed to the newly
+        // opened frame, and the batch size target is stored on the write head.
+        let policy = query_batch_policy(&tx)?;
         let next_batch_index = insert_open_batch(&tx, now_ms)?;
         insert_open_frame(
             &tx,
             next_batch_index,
             0,
             now_ms,
-            next_frame_fee,
+            policy.recommended_fee,
             next_safe_block,
         )?;
         tx.commit()?;
         head.move_to_next_batch(
             next_batch_index,
             from_unix_ms(now_ms),
-            next_frame_fee,
+            policy,
             next_safe_block,
         );
         Ok(())
@@ -516,6 +531,7 @@ fn load_current_write_head(tx: &Transaction<'_>) -> Result<Option<WriteHead>> {
     };
     let (frame_in_batch, frame_fee, safe_block) = query_latest_frame_in_batch(tx, batch_index)?;
     let open_frame_user_op_count = query_frame_user_op_count(tx, batch_index, frame_in_batch)?;
+    let policy = query_batch_policy(tx)?;
     Ok(Some(WriteHead {
         batch_index,
         batch_created_at,
@@ -524,6 +540,7 @@ fn load_current_write_head(tx: &Transaction<'_>) -> Result<Option<WriteHead>> {
         batch_user_op_count,
         open_frame_user_op_count,
         frame_in_batch,
+        max_batch_user_op_bytes: policy.batch_size_target,
     }))
 }
 
@@ -606,9 +623,12 @@ fn query_current_safe_block(tx: &Connection) -> Result<u64> {
     Ok(i64_to_u64(value))
 }
 
-fn query_recommended_fee(tx: &Transaction<'_>) -> Result<u64> {
-    let value = sql_select_recommended_fee(tx)?;
-    Ok(i64_to_u64(value))
+fn query_batch_policy(tx: &Transaction<'_>) -> Result<BatchPolicy> {
+    let (fee, target) = sql_select_batch_policy(tx)?;
+    Ok(BatchPolicy {
+        recommended_fee: i64_to_u64(fee),
+        batch_size_target: i64_to_u64(target),
+    })
 }
 
 fn persist_frame_direct_sequence(
@@ -761,12 +781,13 @@ mod tests {
     }
 
     #[test]
-    fn next_frame_fee_comes_from_recommended_fee_singleton() {
-        let db = temp_db("recommended-fee");
+    fn next_frame_fee_comes_from_batch_policy() {
+        let db = temp_db("batch-policy-fee");
         let mut storage = Storage::open(db.path.as_str(), "NORMAL").expect("open storage");
-        assert_eq!(storage.recommended_fee().expect("default recommended"), 0);
+        let policy = storage.batch_policy().expect("default policy");
+        assert_eq!(policy.recommended_fee, 0);
 
-        storage.set_recommended_fee(7).expect("set recommended fee");
+        storage.set_gas_price(100).expect("set gas price");
 
         let mut head = storage
             .initialize_open_state(0, SafeInputRange::empty_at(0))
@@ -776,8 +797,10 @@ mod tests {
             .close_frame_and_batch(&mut head, next_safe_block)
             .expect("rotate batch");
 
-        assert_eq!(head.frame_fee, 7);
-        assert_eq!(storage.recommended_fee().expect("read recommended"), 7);
+        let policy = storage.batch_policy().expect("read policy");
+        assert!(head.frame_fee > 0, "frame fee should be derived from gas_price");
+        assert_eq!(head.frame_fee, policy.recommended_fee);
+        assert!(head.max_batch_user_op_bytes > 0, "batch size target should be set");
     }
 
     #[test]

sequencer/src/storage/migrations/0001_schema.sql

@@ -81,11 +81,68 @@ CREATE TABLE IF NOT EXISTS l1_safe_head (
 INSERT OR IGNORE INTO l1_safe_head (singleton_id, block_number)
 VALUES (0, 0);
 
-CREATE TABLE IF NOT EXISTS recommended_fees (
-    singleton_id INTEGER PRIMARY KEY CHECK (singleton_id = 0),
-    -- Mutable recommendation consumed when opening the next frame.
-    fee          INTEGER NOT NULL CHECK (fee >= 0)
+-- ---------------------------------------------------------------------------
+-- Batch policy singleton
+--
+-- Contains operator-tunable knobs (alpha, gas_price) and on-chain constants
+-- (delta, base_gas, etc.). A view derives `batch_size_target` and
+-- `recommended_fee` from these columns, and a CHECK constraint prevents
+-- updates that would violate the batch size limit.
+--
+-- Gas economics:
+--   batch_size_target = const_base_gas * alpha_denom / (alpha_num * const_delta)
+--   recommended_fee   = gas_price * (alpha_num + alpha_denom)
+--                        * const_delta * const_user_op_bytes / alpha_denom
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS batch_policy (
+    singleton_id             INTEGER PRIMARY KEY CHECK (singleton_id = 0),
+
+    -- Knobs (operator-tunable via sqlite3 CLI):
+    alpha_num                INTEGER NOT NULL CHECK (alpha_num > 0),
+    alpha_denom              INTEGER NOT NULL CHECK (alpha_denom > 0),
+    gas_price                INTEGER NOT NULL CHECK (gas_price >= 0),
+
+    -- Constants (in DB so the CHECK can reference them):
+    const_delta              INTEGER NOT NULL CHECK (const_delta > 0),
+    const_base_gas           INTEGER NOT NULL CHECK (const_base_gas > 0),
+    const_user_op_bytes      INTEGER NOT NULL CHECK (const_user_op_bytes > 0),
+    -- Effective max batch payload. Already includes slack for chunk overshoot
+    -- and SSZ framing, so the CHECK is simply batch_size_target < this value.
+    const_max_batch_bytes    INTEGER NOT NULL CHECK (const_max_batch_bytes > 0),
+
+    -- Safety: batch_size_target < const_max_batch_bytes.
+    CHECK (
+        const_base_gas * alpha_denom / (alpha_num * const_delta)
+        < const_max_batch_bytes
+    )
 );
 
-INSERT OR IGNORE INTO recommended_fees (singleton_id, fee)
-VALUES (0, 0);
+INSERT OR IGNORE INTO batch_policy(
+    singleton_id,
+
+    alpha_num, alpha_denom, gas_price,
+
+    const_delta, const_base_gas,
+    const_user_op_bytes, const_max_batch_bytes
+)
+VALUES (
+    -- Fixed id
+    0,
+
+    -- Knobs
+    168, 1000, 0,
+
+    -- Constants
+    26, 55000,
+    126, 32000
+);
+
+-- Derived view for reads.
+CREATE VIEW IF NOT EXISTS batch_policy_derived AS
+SELECT *,
+    const_base_gas * alpha_denom / (alpha_num * const_delta)
+        AS batch_size_target,
+
+    gas_price * (alpha_num + alpha_denom) * const_delta * const_user_op_bytes / alpha_denom
+        AS recommended_fee
+FROM batch_policy;