feat(aggregation): have constant costs proof sending

aggregation_mode/Cargo.toml

@@ -27,6 +27,7 @@ sp1_aggregation_program = { path = "./aggregation_programs/sp1" }
 risc0-zkvm = { version = "3.0.3" }
 risc0_aggregation_program = { path = "./aggregation_programs/risc0" }
 risc0-ethereum-contracts = { git = "https://github.com/risc0/risc0-ethereum/", tag = "v3.0.0" }
+ethers = { version = "2.0", features = ["ws", "rustls"] }
 
 [build-dependencies]
 sp1-build = { version = "5.0.0" }

aggregation_mode/src/backend/config.rs

@@ -23,6 +23,7 @@ pub struct Config {
     pub ecdsa: ECDSAConfig,
     pub proofs_per_chunk: u16,
     pub total_proofs_limit: u16,
+    pub monthly_budget_eth: f64,
 }
 
 impl Config {

aggregation_mode/src/backend/fetcher.rs

@@ -24,6 +24,7 @@ use tracing::{error, info};
 pub enum ProofsFetcherError {
     GetLogs(String),
     GetBlockNumber(String),
+    GasPriceError(String),
 }
 
 pub struct ProofsFetcher {
@@ -188,4 +189,15 @@ impl ProofsFetcher {
     pub fn get_last_aggregated_block(&self) -> u64 {
         self.last_aggregated_block
     }
+
+    /// Try to obtain a sensible gas price from two providers.
+    /// Tries `primary` first, falls back to `fallback` if the first fails.
+    pub async fn get_gas_price(&self) -> Result<u128, ProofsFetcherError> {
+        match self.rpc_provider.get_gas_price().await {
+            Ok(price) => Ok(price),
+            Err(e1) => Err(ProofsFetcherError::GasPriceError(format!(
+                "gas price error: {e1}"
+            ))),
+        }
+    }
 }

aggregation_mode/src/backend/mod.rs

@@ -5,6 +5,8 @@ mod retry;
 mod s3;
 mod types;
 
+use crate::backend::AggregatedProofSubmissionError::FetchingProofs;
+
 use crate::aggregators::{AlignedProof, ProofAggregationError, ZKVMEngine};
 
 use alloy::{
@@ -18,10 +20,13 @@ use alloy::{
     signers::local::LocalSigner,
 };
 use config::Config;
+use ethers::types::U256;
 use fetcher::{ProofsFetcher, ProofsFetcherError};
 use merkle_tree::compute_proofs_merkle_root;
 use risc0_ethereum_contracts::encode_seal;
-use std::str::FromStr;
+use std::thread::sleep;
+use std::{str::FromStr, time::Duration};
+use tokio::time::Instant;
 use tracing::{error, info, warn};
 use types::{AlignedProofAggregationService, AlignedProofAggregationServiceContract};
 
@@ -136,23 +141,88 @@ impl ProofAggregator {
             hex::encode(blob_versioned_hash)
         );
 
-        info!("Sending proof to ProofAggregationService contract...");
-        let receipt = self
-            .send_proof_to_verify_on_chain(blob, blob_versioned_hash, aggregated_proof)
-            .await?;
-        info!(
-            "Proof sent and verified, tx hash {:?}",
-            receipt.transaction_hash
-        );
+        // Iterate until we can send the proof on-chain
+        let start_time = Instant::now();
+
+        let mut sent_proof = false;
+        while !sent_proof {
+            // We add 24 hours because the proof aggregator runs once a day, so the time elapsed
+            // should be considered over a 24h period.
+            let time_elapsed: Duration =
+                Instant::now().duration_since(start_time) + Duration::from_secs(24 * 3600);
+
+            let gas_price = self.fetcher.get_gas_price().await.map_err(FetchingProofs)?;
+
+            if self.should_send_proof_to_verify_on_chain(
+                time_elapsed,
+                self.config.monthly_budget_eth,
+                gas_price.into(),
+            ) {
+                info!("Sending proof to ProofAggregationService contract...");
+                let receipt = self
+                    .send_proof_to_verify_on_chain(&blob, blob_versioned_hash, &aggregated_proof)
+                    .await?;
+                info!(
+                    "Proof sent and verified, tx hash {:?}",
+                    receipt.transaction_hash
+                );
+
+                sent_proof = true;
+            } else {
+                info!("Skipping sending proof to ProofAggregationService contract due to budget/time constraints.");
+            }
+
+            // Sleep for 5 minutes before re-evaluating
+            sleep(Duration::from_secs(300));
+        }
 
         Ok(())
     }
 
+    fn floating_eth_to_wei(eth: f64) -> U256 {
+        let wei_in_eth = 1_000_000_000_000_000_000f64;
+        let wei = eth * wei_in_eth;
+        U256::from(wei as u64)
+    }
+
+    fn max_to_spend_in_wei(time_elapsed: Duration, monthly_eth_budget: f64) -> U256 {
+        const SECONDS_PER_MONTH: u64 = 30 * 24 * 60 * 60;
+
+        let monthly_budget_in_wei = Self::floating_eth_to_wei(monthly_eth_budget);
+
+        let elapsed_seconds = U256::from(time_elapsed.as_secs());
+
+        let budget_available_per_second_in_wei = monthly_budget_in_wei / SECONDS_PER_MONTH;
+
+        budget_available_per_second_in_wei * elapsed_seconds
+    }
+
+    /// Decides whether to send the aggregated proof to be verified on-chain based on
+    /// time elapsed since last submission and monthly ETH budget.
+    /// We make a linear function with the eth to spend this month and the time elapsed since last submission.
+    /// If eth to spend / elapsed time is over the linear function, we skip the submission.
+    fn should_send_proof_to_verify_on_chain(
+        &self,
+        time_elapsed: Duration,
+        monthly_eth_budget: f64,
+        gas_price_in_wei: U256,
+    ) -> bool {
+        // We assume a fixed gas cost of 300,000 for each of the 2 transactions
+        const ON_CHAIN_COST_IN_GAS_UNITS: u64 = 600_000u64;
+
+        let on_chain_cost_in_gas: U256 = U256::from(ON_CHAIN_COST_IN_GAS_UNITS);
+        let max_to_spend_in_wei = Self::max_to_spend_in_wei(time_elapsed, monthly_eth_budget);
+
+        let expected_cost_in_wei = gas_price_in_wei * on_chain_cost_in_gas;
+
+        expected_cost_in_wei <= max_to_spend_in_wei
+    }
+
     async fn send_proof_to_verify_on_chain(
         &self,
-        blob: BlobTransactionSidecar,
+        blob: &BlobTransactionSidecar,
         blob_versioned_hash: [u8; 32],
-        aggregated_proof: AlignedProof,
+        aggregated_proof: &AlignedProof,
     ) -> Result<TransactionReceipt, AggregatedProofSubmissionError> {
         let tx_req = match aggregated_proof {
             AlignedProof::SP1(proof) => self
@@ -162,7 +232,7 @@ impl ProofAggregator {
                     proof.proof_with_pub_values.public_values.to_vec().into(),
                     proof.proof_with_pub_values.bytes().into(),
                 )
-                .sidecar(blob)
+                .sidecar(blob.clone())
                 .into_transaction_request(),
             AlignedProof::Risc0(proof) => {
                 let encoded_seal = encode_seal(&proof.receipt).map_err(|e| {
@@ -172,9 +242,9 @@ impl ProofAggregator {
                     .verifyRisc0(
                         blob_versioned_hash.into(),
                         encoded_seal.into(),
-                        proof.receipt.journal.bytes.into(),
+                        proof.receipt.journal.bytes.clone().into(),
                     )
-                    .sidecar(blob)
+                    .sidecar(blob.clone())
                     .into_transaction_request()
             }
         };
@@ -284,3 +354,113 @@ impl ProofAggregator {
         Ok((blob, blob_versioned_hash))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use super::config::Config;
+
+    fn make_aggregator() -> ProofAggregator {
+        // Set the AGGREGATOR env variable to "sp1" or "risc0" as it's needed by ProofAggregator::new
+        std::env::set_var("AGGREGATOR", "sp1");
+
+        let current_dir = env!("CARGO_MANIFEST_DIR");
+
+        // These config values are taken from config-files/config-proof-aggregator.yaml
+        let config = Config {
+            eth_rpc_url: "http://localhost:8545".to_string(),
+            eth_ws_url: "ws://localhost:8545".to_string(),
+            max_proofs_in_queue: 1000,
+            proof_aggregation_service_address: "0xcbEAF3BDe82155F56486Fb5a1072cb8baAf547cc"
+                .to_string(),
+            aligned_service_manager_address: "0x851356ae760d987E095750cCeb3bC6014560891C"
+                .to_string(),
+            // Use a path relative to the crate so tests work both locally and in CI
+            last_aggregated_block_filepath: format!(
+                "{current_dir}/../config-files/proof-aggregator.last_aggregated_block.json"
+            ),
+            ecdsa: config::ECDSAConfig {
+                private_key_store_path: format!(
+                    "{current_dir}/../config-files/anvil.proof-aggregator.ecdsa.key.json"
+                ),
+                private_key_store_password: "".to_string(),
+            },
+            proofs_per_chunk: 512,
+            total_proofs_limit: 3968,
+            monthly_budget_eth: 15.0,
+        };
+
+        ProofAggregator::new(config)
+    }
+
+    #[test]
+    fn test_should_send_proof_to_verify_on_chain_updated_cases() {
+        let aggregator = make_aggregator();
+
+        let gas_price_20gwei: U256 = U256::from(20_000_000_000u64);
+
+        // With 0 seconds elapsed and 1 ETH budget, we cannot send the proof
+        assert!(!aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(0),
+            1.0,
+            gas_price_20gwei,
+        ));
+
+        // After 24 hours and 1 ETH monthly budget, we can send the proof
+        assert!(aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(24 * 3600),
+            1.0,
+            gas_price_20gwei,
+        ));
+
+        // After 24 hours and a very low budget, we cannot send the proof
+        assert!(!aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(24 * 3600),
+            0.00325,
+            U256::from(0_200_000_000u64),
+        ));
+
+        // After 27 hours with the same budget as before, we can send the proof
+        assert!(aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(27 * 3600),
+            0.00325,
+            U256::from(0_200_000_000u64),
+        ));
+
+        // After 30 days but with a very low budget, we cannot send the proof
+        assert!(!aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(30 * 24 * 3600),
+            0.001,
+            gas_price_20gwei,
+        ));
+
+        // After 15 days, a moderate budget and a high gas price, we can still send the proof
+        assert!(aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(15 * 24 * 3600),
+            10.0,
+            U256::from(2_000_000_000_000u64),
+        ));
+
+        // After 30 days and a medium budget, we cannot send the proof
+        assert!(!aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(30 * 24 * 3600),
+            0.012,
+            gas_price_20gwei,
+        ));
+
+        // After 2 days and a reasonable budget, we can send the proof
+        assert!(aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(2 * 24 * 3600),
+            5.0,
+            gas_price_20gwei,
+        ));
+
+        // After 10 days and a medium budget with a very high gas price, we cannot send the proof
+        assert!(!aggregator.should_send_proof_to_verify_on_chain(
+            Duration::from_secs(10 * 24 * 3600),
+            2.0,
+            U256::from(100_000_000_000_000u64),
+        ));
+    }
+}

config-files/config-proof-aggregator-ethereum-package.yaml

@@ -12,6 +12,8 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # Since each proof commitments takes 32 bytes hash
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
+# Monthly ETH budget for on-chain proof verification
+monthly_budget_eth: 15.0
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator-mock-ethereum-package.yaml

@@ -12,7 +12,8 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # Since each proof commitments takes 32 bytes hash
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
-
+# Monthly ETH budget for on-chain proof verification
+monthly_budget_eth: 15.0
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator-mock.yaml

@@ -12,7 +12,8 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # Since each proof commitments takes 32 bytes hash
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
-
+# Monthly ETH budget for on-chain proof verification
+monthly_budget_eth: 15.0
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"

config-files/config-proof-aggregator.yaml

@@ -12,7 +12,8 @@ proofs_per_chunk: 512 # Amount of proofs to process per chunk
 # Since each proof commitments takes 32 bytes hash
 # We can aggregate as much proofs as 126.976 / 32 = 3968 per blob
 total_proofs_limit: 3968
-
+# Monthly ETH budget for on-chain proof verification
+monthly_budget_eth: 15.0
 
 ecdsa:
   private_key_store_path: "config-files/anvil.proof-aggregator.ecdsa.key.json"