feat: enforce min max fee

Author: MarcosNicolau

crates/batcher/src/lib.rs

@@ -97,6 +97,7 @@ pub struct Batcher {
     disabled_verifiers: Mutex<U256>,
     aggregator_fee_percentage_multiplier: u128,
     aggregator_gas_cost: u128,
+    latest_block_gas_price: RwLock<U256>,
     pub metrics: metrics::BatcherMetrics,
     pub telemetry: TelemetrySender,
 }
@@ -276,6 +277,7 @@ impl Batcher {
             posting_batch: Mutex::new(false),
             batch_state: Mutex::new(batch_state),
             disabled_verifiers: Mutex::new(disabled_verifiers),
+            latest_block_gas_price: RwLock::new(U256::zero()),
             metrics,
             telemetry,
         }
@@ -767,6 +769,22 @@ impl Batcher {
         let mut batch_state_lock = self.batch_state.lock().await;
 
         let msg_max_fee = nonced_verification_data.max_fee;
+
+        // Verify that the max fee is enough to cover a batch of 32 proofs at least
+        // TODO move number to config file
+        let gas_price = *self.latest_block_gas_price.read().await;
+        let min_max_fee_per_proof =
+            aligned_sdk::verification_layer::compute_fee_per_proof_formula(32, gas_price);
+        if msg_max_fee < min_max_fee_per_proof {
+            std::mem::drop(batch_state_lock);
+            send_message(
+                ws_conn_sink.clone(),
+                SubmitProofResponseMessage::UnderpricedProof,
+            )
+            .await;
+            return Ok(());
+        }
+
         let Some(user_last_max_fee_limit) =
             batch_state_lock.get_user_last_max_fee_limit(&addr).await
         else {
@@ -1502,6 +1520,9 @@ impl Batcher {
         let gas_price = gas_price.map_err(|_| BatcherError::GasPriceError)?;
 
         {
+            let mut latest_block_gas_price = self.latest_block_gas_price.write().await;
+            *latest_block_gas_price = gas_price;
+
             let new_disable_verifiers = disable_verifiers
                 .map_err(|e| BatcherError::DisabledVerifiersError(e.to_string()))?;
             let mut disabled_verifiers_lock = self.disabled_verifiers.lock().await;

crates/sdk/src/verification_layer/mod.rs

@@ -171,20 +171,43 @@ pub async fn calculate_fee_per_proof_for_batch_of_size(
         })?;
     let gas_price = fetch_gas_price(&eth_rpc_provider).await?;
 
-    // Cost for estimate `num_proofs_per_batch` proofs
+    let fee_per_proof = compute_fee_per_proof_formula(num_proofs_in_batch, gas_price);
+    Ok(fee_per_proof)
+}
+
+/// Estimates the fee per proof based on the given batch size and gas price.
+///
+/// This function models the cost of submitting a batch of proofs to the network
+/// by computing an estimated gas cost per proof. The total gas cost is composed of:
+/// - a constant base gas cost for any batch submission (`DEFAULT_CONSTANT_GAS_COST`)
+/// - an additional gas cost that scales linearly with the number of proofs in the batch
+///   (`ADDITIONAL_SUBMISSION_GAS_COST_PER_PROOF * num_proofs_in_batch`)
+///
+/// The final fee per proof is calculated by:
+///     (estimated_gas_per_proof * gas_price * GAS_PRICE_PERCENTAGE_MULTIPLIER) / PERCENTAGE_DIVIDER
+///
+///
+/// # Arguments
+/// * `num_proofs_in_batch` - Number of proofs in the batch (must be > 0).
+/// * `gas_price` - Current gas price (in wei).
+///
+/// # Returns
+/// * Estimated fee per individual proof (in wei).
+///
+/// # Panics
+/// This function panics if `num_proofs_in_batch` is 0 due to division by zero.
+pub fn compute_fee_per_proof_formula(num_proofs_in_batch: usize, gas_price: U256) -> U256 {
+    // Gas cost for `num_proofs_per_batch` proofs
     let estimated_gas_per_proof = (DEFAULT_CONSTANT_GAS_COST
         + ADDITIONAL_SUBMISSION_GAS_COST_PER_PROOF * num_proofs_in_batch as u128)
         / num_proofs_in_batch as u128;
 
-    // Price of 1 proof in a batch of size `num_proofs_in_batch` i.e. (1 / `num_proofs_in_batch`).
-    // The computed price is adjusted with respect to the percentage multiplier from:
-    // https://github.com/yetanotherco/aligned_layer/blob/staging/crates/batcher/src/lib.rs#L1401
     let fee_per_proof = (U256::from(estimated_gas_per_proof)
         * gas_price
         * U256::from(GAS_PRICE_PERCENTAGE_MULTIPLIER))
         / U256::from(PERCENTAGE_DIVIDER);
 
-    Ok(fee_per_proof)
+    fee_per_proof
 }
 
 async fn fetch_gas_price(