feat: wip logic in batcher

Author: uri-99

batcher/aligned-batcher/src/eth/utils.rs

@@ -8,11 +8,11 @@ use crate::{
         retry_function,
     },
 };
-use aligned_sdk::core::constants::{
+use aligned_sdk::core::{constants::{
     ETHEREUM_CALL_BACKOFF_FACTOR, ETHEREUM_CALL_MAX_RETRIES, ETHEREUM_CALL_MAX_RETRY_DELAY,
     ETHEREUM_CALL_MIN_RETRY_DELAY, GAS_PRICE_INCREMENT_PERCENTAGE_PER_ITERATION,
     OVERRIDE_GAS_PRICE_PERCENTAGE_MULTIPLIER, PERCENTAGE_DIVIDER,
-};
+}, errors::BumpError, types::BumpUnit};
 use ethers::prelude::*;
 use ethers::providers::{Http, Provider};
 use log::error;
@@ -103,6 +103,40 @@ pub async fn get_gas_price(
         e.inner()
     })
 }
+
+pub async fn calculate_bumped_proof_cost(
+    current_gas_price: U256,
+    bump_unit: BumpUnit,
+    amount: U256,
+) -> Result<U256, BumpError> {
+    let new_max_fee = match bump_unit {
+        BumpUnit::NewMaxFee => {
+            amount
+        }
+        BumpUnit::Wei => {
+            current_gas_price + amount
+        }
+        BumpUnit::Gwei => {
+            current_gas_price + (amount * U256::from(1_000_000_000))
+        }
+        BumpUnit::Eth => {
+            current_gas_price + (amount * U256::from(1_000_000_000_000_000_000))
+        }
+        BumpUnit::Percentage => {
+            current_gas_price + (current_gas_price * amount / U256::from(PERCENTAGE_DIVIDER))
+        }
+        // TODO once Pats pr is done:
+        // BumpUnit::BatchSize => {
+
+        // }
+        _ => {
+            warn!("Invalid bump unit: {bump_unit:?}");
+            return Err(BumpError::InvalidBumpUnit);
+        }
+    };
+    Ok(new_max_fee)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

batcher/aligned-batcher/src/lib.rs

@@ -31,9 +31,7 @@ use aligned_sdk::core::constants::{
     RESPOND_TO_TASK_FEE_LIMIT_PERCENTAGE_MULTIPLIER,
 };
 use aligned_sdk::core::types::{
-    ClientMessage, GetNonceResponseMessage, NoncedVerificationData, ProofInvalidReason,
-    ProvingSystemId, SubmitProofMessage, SubmitProofResponseMessage, VerificationCommitmentBatch,
-    VerificationData, VerificationDataCommitment,
+    BumpFeeResponseMessage, BumpUnit, ClientMessage, GetNonceResponseMessage, NoncedVerificationData, ProofInvalidReason, ProvingSystemId, SubmitProofMessage, SubmitProofResponseMessage, VerificationCommitmentBatch, VerificationData, VerificationDataCommitment
 };
 
 use aws_sdk_s3::client::Client as S3Client;
@@ -473,6 +471,11 @@ impl Batcher {
                     .handle_submit_proof_msg(msg, ws_conn_sink)
                     .await
             }
+            ClientMessage::BumpFee(bump_unit, amout, proof_qty) => {
+                self.clone()
+                    .handle_bump_fee_msg(bump_unit, amout, proof_qty, ws_conn_sink)
+                    .await
+            }
         }
     }
 
@@ -783,6 +786,9 @@ impl Batcher {
 
         // In this case, the message might be a replacement one. If it is valid,
         // we replace the old entry with the new from the replacement message.
+
+        // TODO DISABLE THIS FUNCTIONALITY
+        // IT IS BEING REPLACED WITH BumpFee()
         if expected_nonce > msg_nonce {
             info!("Possible replacement message received: Expected nonce {expected_nonce:?} - message nonce: {msg_nonce:?}");
             self.handle_replacement_message(
@@ -833,6 +839,84 @@ impl Batcher {
         Ok(())
     }
 
+
+    // TODO add signature
+    async fn handle_bump_fee_msg(
+        bump_unit: BumpUnit,
+        amount: U256,
+        proof_qty: usize,
+        signature: Signature, //TODO add this
+        signature_content: Vec<u8>, //TODO add this
+        ws_conn_sink: WsMessageSink,
+    ) -> Result<(), Error> {
+
+    //         /// The signature of the message is verified, and when it correct, the
+    // /// recovered address from the signature is returned.
+    // pub fn verify_signature(&self) -> Result<Address, VerifySignatureError> {
+    //     // Recovers the address from the signed data
+    //     let recovered = self.signature.recover_typed_data(&self.verification_data)?;
+
+    //     let hashed_data = self.verification_data.encode_eip712()?;
+
+    //     self.signature.verify(hashed_data, recovered)?;
+    //     Ok(recovered)
+    // }
+
+        info!("Verifying Bump Fee signature...");
+        let Ok(addr) = verify_bump_signature(signature, signature_content) else {
+            error!("Signature verification error");
+            send_message(
+                ws_conn_sink.clone(),
+                BumpFeeResponseMessage::InvalidSignature,
+            )
+            .await;
+            self.metrics.user_error(&["invalid_bump_fee_signature", ""]);
+            return Ok(());
+        };
+        info!("Bump Fee signature verified");
+
+
+        let from_proof_nonce = self.get_first_proof();
+        let to_proof_nonce = from_proof_nonce + proof_qty; // exclusive
+
+        let batch_state_lock = self.batch_state.lock().await;
+        let batch_queue_copy = batch_state_lock.batch_queue.clone();
+    
+        // TODO check if user has enough funds
+        while let Some((entry, _)) = batch_state_lock.batch_queue.peek() {
+            let entry_nonce = entry.nonced_verification_data.nonce;
+            if entry_nonce >= from_proof_nonce && entry_nonce < to_proof_nonce {
+                if let Err(bumped_fee) = calculate_bumped_proof_cost(entry.nonced_verification_data.max_fee, bump_unit, amount) {
+                    send_message(
+                        ws_conn_sink.clone(),
+                        BumpFeeResponseMessage::InvalidBumpUnit,
+                    )
+                    .await;
+                    self.metrics.user_error(&["invalid_bump_fee_unit", ""]);
+                    return Ok(());
+                }
+                let new_entry = entry.clone();
+                new_entry.nonced_verification_data.max_fee = bumped_fee;
+
+                batch_state_lock.update_user_total_fees_in_queue_of_replacement_message(sender_address, entry_nonce.clone(), bumped_fee).await?;
+                batch_state_lock.replace_entry(entry, new_entry);
+            }
+        };
+        return;
+
+    }
+
+    fn verify_bump_signature(
+        &self,
+        signature: Signature,
+        bump_unit: BumpUnit,
+        amount: U256,
+        proof_qty: usize,
+    ) -> bool {
+        // TODO
+        true
+    }
+
     async fn is_verifier_disabled(&self, verifier: ProvingSystemId) -> bool {
         let disabled_verifiers = self.disabled_verifiers.lock().await;
         zk_utils::is_verifier_disabled(*disabled_verifiers, verifier)

batcher/aligned-sdk/src/core/types.rs

@@ -2,6 +2,7 @@ use std::fmt;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::str::FromStr;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use ethers::core::k256::ecdsa::SigningKey;
 use ethers::signers::Signer;
@@ -231,7 +232,8 @@ pub enum ClientMessage {
     // Needs to be wrapped in box as the message is 3x bigger than the others
     // see https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
     SubmitProof(Box<SubmitProofMessage>),
-    BumpFee(BumpUnit, U256, usize), // BumpUnit, value, proof_qty
+    // BumpFee(BumpUnit, U256, usize), // BumpUnit, value, proof_qty
+    BumpFee(BumpFeeMessage), // BumpUnit, value, proof_qty
 }
 
 impl Display for ClientMessage {
@@ -398,11 +400,74 @@ pub enum GetNonceResponseMessage {
     InvalidRequest(String),
 }
 
+pub struct BumpFeeMessage {
+    pub conent: BumpFeeMessageContent,
+    pub signature: Signature,
+}
+
+pub struct BumpFeeMessageContent {
+    pub bump_unit: BumpUnit,
+    pub value: U256,
+    pub proof_qty: usize,
+    pub timestamp: u64,
+}
+
+impl EIP712 for BumpFeeMessageContent {
+    type Error = Eip712Error;
+    fn domain(&self) -> Result<EIP712Domain, Self::Error> {
+        Ok(EIP712Domain {
+            name: Some("Aligned".into()),
+            version: Some("1".into()),
+            chain_id: Some(self.chain_id),
+            verifying_contract: Some("0x00"),
+            salt: None,
+        })
+    }
+    fn type_hash() -> Result<[u8; 32], Self::Error> {
+        let mut hasher = Keccak256::new();
+        hasher.update(NONCED_VERIFICATION_DATA_TYPE);
+        Ok(hasher.finalize().into())
+    }
+
+    pub fn new(bump_unit: BumpUnit, value: U256, proof_qty: usize) -> Self {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time went backwards");
+        let timestamp = now.as_secs(); // Seconds since UNIX_EPOCH
+
+        Self {
+            bump_unit,
+            value,
+            proof_qty,
+            timestamp,
+        }
+    }
+}
+
+impl BumpFeeMessage {
+    pub fn new(
+        bump_unit: BumpUnit,
+        value: U256,
+        proof_qty: usize,
+        wallet: Wallet<SigningKey>
+    ) -> Self {
+        let signature = wallet.sign_typed_data(&BumpFeeMessageContent::new(bump_unit, value, proof_qty)).unwrap();
+
+        Self {
+            bump_unit,
+            value,
+            proof_qty,
+            timestamp,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum BumpFeeResponseMessage {
     Ok(),
     EthRpcError(String),
     InvalidRequest(String),
+    InvalidBumpUnit,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]