Merge branch 'feat/aggregation-mode' into feat/aggregation-mode-explorer

Author: MarcosNicolau

Makefile

@@ -155,7 +155,6 @@ start_proof_aggregator_local:
 	cargo run --manifest-path ./aggregation-mode/Cargo.toml --release -- config-files/config-proof-aggregator.yaml
 
 start_proof_aggregator_local_with_proving:
-	cd aggregation-mode && \
 	cargo run --manifest-path ./aggregation-mode/Cargo.toml --release --features prove -- config-files/config-proof-aggregator.yaml
 
 _AGGREGATOR_:

aggregation-mode/abi/AlignedProofAggregationService.json

@@ -4,59 +4,54 @@
 ## How to run it locally
 
 1. Deploy aligned contracts on anvil:
+
 ```shell
 make deploy_aligned_contracts
 ```
 
 2. Start anvil:
+
 ```shell
 make anvil_start_with_block_time
 ```
 
 3. Start batcher
+
 ```shell
 make start_batcher_local
 ```
 
 4. Send SP1 proofs:
+
 ```shell
 make batcher_send_sp1_burst
 ```
 
 5. Start proof aggregator:
-```shell 
+
+```shell
 # This will not run a real prover but a mocked one see below to run a real prover
 make start_proof_aggregator_local
 ```
-Note: it might take a while to compile as it uses more aggressive optimization levels.
-
-You should it will fetch the new batch logs from the BatcherService and aggregate the compressed SP1 proofs from them.
 
-### Run it with proving
+or
 
-By default, on dev environments, the proving is mocked and the ProofAggregationService contract skips verification as proves are mocked. To run the service with proving you need to run change the commands on step `1.` and `4.`:
-
-1. Start anvil with verification activated:
-```shell
-make anvil_start_with_verification
-```
-
-4. Start proof aggregator with proving:
 ```shell
 make start_proof_aggregator_local_with_proving
 ```
 
-Note: Unless you constraint yourself to a few proofs, this requires a powerful machine with GPU.
-
+Note: Proving can be quite slow without GPUs
 
 ### Check the logs
 
 1. Get latest aggregated proof:
+
 ```shell
 cast call 0xcbEAF3BDe82155F56486Fb5a1072cb8baAf547cc "currentAggregatedProofNumber()" --rpc-url http://localhost:8545
 ```
 
 2. Get aggregated proof info:
+
 ```shell
 cast call 0xcbEAF3BDe82155F56486Fb5a1072cb8baAf547cc "getAggregatedProof(uint64)(uint8,bytes32,bytes32)" <AGG_PROOF_NUMBER>  --rpc-url http://localhost:8545
 ```

aggregation-mode/readme.md

@@ -13,10 +13,10 @@ use alloy::{
     consensus::{Blob, BlobTransactionSidecar},
     eips::eip4844::BYTES_PER_BLOB,
     hex,
-    network::{EthereumWallet, TransactionBuilder4844},
+    network::EthereumWallet,
     primitives::{Address, FixedBytes},
-    providers::{PendingTransactionError, Provider, ProviderBuilder, WalletProvider},
-    rpc::types::{TransactionReceipt, TransactionRequest},
+    providers::{PendingTransactionError, ProviderBuilder},
+    rpc::types::TransactionReceipt,
     signers::local::LocalSigner,
 };
 use config::Config;
@@ -25,22 +25,21 @@ use merkle_tree::compute_proofs_merkle_root;
 use sp1_sdk::HashableKey;
 use std::str::FromStr;
 use tracing::{error, info, warn};
-use types::{
-    AlignedProofAggregationService, AlignedProofAggregationServiceContract, RPCProviderWithSigner,
-};
+use types::{AlignedProofAggregationService, AlignedProofAggregationServiceContract};
 
 #[derive(Debug)]
 pub enum AggregatedProofSubmissionError {
     Aggregation(ProofAggregationError),
-    SendBlobTransaction,
+    BuildingBlobCommitment,
+    BuildingBlobProof,
+    BuildingBlobVersionedHash,
     SendVerifyAggregatedProofTransaction(alloy::contract::Error),
     ReceiptError(PendingTransactionError),
     FetchingProofs(ProofsFetcherError),
 }
 
 pub struct ProofAggregator {
     engine: ZKVMEngine,
-    rpc_provider: RPCProviderWithSigner,
     proof_aggregation_service: AlignedProofAggregationServiceContract,
     fetcher: ProofsFetcher,
 }
@@ -58,15 +57,14 @@ impl ProofAggregator {
         let proof_aggregation_service: AlignedProofAggregationService::AlignedProofAggregationServiceInstance<(), alloy::providers::fillers::FillProvider<alloy::providers::fillers::JoinFill<alloy::providers::fillers::JoinFill<alloy::providers::Identity, alloy::providers::fillers::JoinFill<alloy::providers::fillers::GasFiller, alloy::providers::fillers::JoinFill<alloy::providers::fillers::BlobGasFiller, alloy::providers::fillers::JoinFill<alloy::providers::fillers::NonceFiller, alloy::providers::fillers::ChainIdFiller>>>>, alloy::providers::fillers::WalletFiller<EthereumWallet>>, alloy::providers::RootProvider>> = AlignedProofAggregationService::new(
             Address::from_str(&config.proof_aggregation_service_address)
                 .expect("Address to be correct"),
-            rpc_provider.clone(),
+            rpc_provider,
         );
         let fetcher = ProofsFetcher::new(config);
 
         Self {
             engine: ZKVMEngine::SP1,
             proof_aggregation_service,
             fetcher,
-            rpc_provider,
         }
     }
 
@@ -131,16 +129,16 @@ impl ProofAggregator {
         };
         info!("Proof aggregation program finished");
 
-        info!("Sending blob transaction...");
-        let blob_receipt = self.send_blob_transaction(leaves).await?;
+        info!("Constructing blob...");
+        let (blob, blob_versioned_hash) = self.construct_blob(leaves).await?;
         info!(
-            "Blob transaction sent, hash: {:?}",
-            blob_receipt.transaction_hash
+            "Blob constructed, versioned hash: {}",
+            hex::encode(blob_versioned_hash)
         );
 
         info!("Sending proof to ProofAggregationService contract...");
         let receipt = self
-            .send_proof_to_verify_on_chain(&blob_receipt.transaction_hash, output.proof)
+            .send_proof_to_verify_on_chain(blob, blob_versioned_hash, output.proof)
             .await?;
         info!(
             "Proof sent and verified, tx hash {:?}",
@@ -152,19 +150,21 @@ impl ProofAggregator {
 
     async fn send_proof_to_verify_on_chain(
         &self,
-        blob_tx_hash: &[u8; 32],
+        blob: BlobTransactionSidecar,
+        blob_versioned_hash: [u8; 32],
         aggregated_proof: AggregatedProof,
     ) -> Result<TransactionReceipt, AggregatedProofSubmissionError> {
         match aggregated_proof {
             AggregatedProof::SP1(proof) => {
                 let res = self
                     .proof_aggregation_service
                     .verify(
-                        blob_tx_hash.into(),
+                        blob_versioned_hash.into(),
                         proof.vk().bytes32_raw().into(),
                         proof.proof.public_values.to_vec().into(),
                         proof.proof.bytes().into(),
                     )
+                    .sidecar(blob)
                     .send()
                     .await
                     .map_err(
@@ -178,10 +178,10 @@ impl ProofAggregator {
         }
     }
 
-    async fn send_blob_transaction(
+    async fn construct_blob(
         &self,
         leaves: Vec<[u8; 32]>,
-    ) -> Result<TransactionReceipt, AggregatedProofSubmissionError> {
+    ) -> Result<(BlobTransactionSidecar, [u8; 32]), AggregatedProofSubmissionError> {
         let data: Vec<u8> = leaves.iter().flat_map(|arr| arr.iter().copied()).collect();
         let mut blob_data: [u8; BYTES_PER_BLOB] = [0u8; BYTES_PER_BLOB];
 
@@ -193,32 +193,23 @@ impl ProofAggregator {
         let settings = c_kzg::ethereum_kzg_settings();
         let blob = c_kzg::Blob::new(blob_data);
         let commitment = c_kzg::KzgCommitment::blob_to_kzg_commitment(&blob, settings)
-            .map_err(|_| AggregatedProofSubmissionError::SendBlobTransaction)?;
+            .map_err(|_| AggregatedProofSubmissionError::BuildingBlobCommitment)?;
         let proof =
             c_kzg::KzgProof::compute_blob_kzg_proof(&blob, &commitment.to_bytes(), settings)
-                .map_err(|_| AggregatedProofSubmissionError::SendBlobTransaction)?;
+                .map_err(|_| AggregatedProofSubmissionError::BuildingBlobProof)?;
 
         // convert to alloy types
         let blob = Blob::from_slice(&blob_data);
         let commitment: FixedBytes<48> = FixedBytes::from_slice(commitment.to_bytes().as_slice());
         let proof: FixedBytes<48> = FixedBytes::from_slice(proof.to_bytes().as_slice());
 
-        let blob_sidecar = BlobTransactionSidecar::new(vec![blob], vec![commitment], vec![proof]);
-        // send transaction to itself
-        let to = self.rpc_provider.signer_addresses().collect::<Vec<_>>()[0];
-        let tx = TransactionRequest::default()
-            .to(to)
-            .with_blob_sidecar(blob_sidecar);
-
-        let res = self
-            .rpc_provider
-            .send_transaction(tx)
-            .await
-            .map_err(|_| AggregatedProofSubmissionError::SendBlobTransaction)?;
+        let blob = BlobTransactionSidecar::new(vec![blob], vec![commitment], vec![proof]);
+        let blob_versioned_hash = blob
+            .versioned_hash_for_blob(0)
+            .ok_or(AggregatedProofSubmissionError::BuildingBlobVersionedHash)?
+            .0;
 
-        res.get_receipt()
-            .await
-            .map_err(AggregatedProofSubmissionError::ReceiptError)
+        Ok((blob, blob_versioned_hash))
     }
 
     async fn set_aggregated_proof_as_missed(

aggregation-mode/src/backend/mod.rs

@@ -65,23 +65,3 @@ pub type RPCProvider = alloy::providers::fillers::FillProvider<
     >,
     alloy::providers::RootProvider,
 >;
-
-pub type RPCProviderWithSigner = alloy::providers::fillers::FillProvider<
-    alloy::providers::fillers::JoinFill<
-        alloy::providers::fillers::JoinFill<
-            alloy::providers::Identity,
-            alloy::providers::fillers::JoinFill<
-                alloy::providers::fillers::GasFiller,
-                alloy::providers::fillers::JoinFill<
-                    alloy::providers::fillers::BlobGasFiller,
-                    alloy::providers::fillers::JoinFill<
-                        alloy::providers::fillers::NonceFiller,
-                        alloy::providers::fillers::ChainIdFiller,
-                    >,
-                >,
-            >,
-        >,
-        alloy::providers::fillers::WalletFiller<EthereumWallet>,
-    >,
-    alloy::providers::RootProvider,
->;

aggregation-mode/src/backend/types.rs

@@ -46,32 +46,33 @@ contract AlignedProofAggregationService is
     }
 
     function verify(
-        bytes32 blobTransactionHash,
+        bytes32 blobVersionedHash,
         bytes32 sp1ProgramVKey,
         bytes calldata sp1PublicValues,
         bytes calldata sp1ProofBytes
     ) public onlyAlignedAggregator {
         // In dev mode, poofs are mocked, so we skip the verification part
         if (sp1VerifierAddress == VERIFIER_MOCK_ADDRESS) {
             (bytes32 merkleRoot) = abi.decode(sp1PublicValues, (bytes32));
-            _newAggregatedProof(merkleRoot, blobTransactionHash);
+            _newAggregatedProof(merkleRoot, blobVersionedHash);
             return;
         }
 
         try ISP1Verifier(sp1VerifierAddress).verifyProof(sp1ProgramVKey, sp1PublicValues, sp1ProofBytes) {
             (bytes32 merkleRoot) = abi.decode(sp1PublicValues, (bytes32));
-            _newAggregatedProof(merkleRoot, blobTransactionHash);
+            _newAggregatedProof(merkleRoot, blobVersionedHash);
         } catch {
             AggregatedProof storage proof = aggregatedProofs[currentAggregatedProofNumber];
             proof.status = AggregatedProofStatus.Failed;
-            emit AggregatedProofFailed(currentAggregatedProofNumber);
+            emit NewAggregatedProof(currentAggregatedProofNumber, AggregatedProofStatus.Failed, 0x0, 0x0);
+            currentAggregatedProofNumber += 1;
         }
     }
 
     function markCurrentAggregatedProofAsMissed() public onlyAlignedAggregator {
         AggregatedProof storage proof = aggregatedProofs[currentAggregatedProofNumber];
         proof.status = AggregatedProofStatus.Missed;
-        emit AggregatedProofMissed(currentAggregatedProofNumber);
+        emit NewAggregatedProof(currentAggregatedProofNumber, AggregatedProofStatus.Missed, 0x0, 0x0);
         currentAggregatedProofNumber += 1;
     }
 
@@ -80,7 +81,7 @@ contract AlignedProofAggregationService is
         proof.merkleRoot = merkleRoot;
         proof.blobHash = blobHash;
         proof.status = AggregatedProofStatus.Verified;
-        emit NewAggregatedProofVerified(currentAggregatedProofNumber, merkleRoot, blobHash);
+        emit NewAggregatedProof(currentAggregatedProofNumber, AggregatedProofStatus.Verified, merkleRoot, blobHash);
         currentAggregatedProofNumber += 1;
     }
 

contracts/scripts/anvil/state/alignedlayer-deployed-anvil-state.json

@@ -24,12 +24,12 @@ interface IAlignedProofAggregationService {
     /// @notice Method to verify an aggregated proof from aligned
     /// @dev This function is called by the aligned proof aggregator after collecting the proofs and aggregating them
     /// to be verified on-chain. We expect the blobTransactionHash to be called before
-    /// @param blobTransactionHash the hash of the blob transaction that contains the leaves that compose the merkle root.
+    /// @param blobVersionedHash the versioned hash of the blob transaction that contains the leaves that compose the merkle root.
     /// @param sp1ProgramVKey Public verifying key
     /// @param sp1PublicValues Values used to perform the execution
     /// @param sp1ProofBytes Groth16 proof
     function verify(
-        bytes32 blobTransactionHash,
+        bytes32 blobVersionedHash,
         bytes32 sp1ProgramVKey,
         bytes calldata sp1PublicValues,
         bytes calldata sp1ProofBytes
@@ -43,11 +43,9 @@ interface IAlignedProofAggregationService {
     function markCurrentAggregatedProofAsMissed() external;
 
     /// @notice event that gets emitted after a successful aggregated proof verification
-    event NewAggregatedProofVerified(uint64 indexed proofNumber, bytes32 merkleRoot, bytes32 blobTransactionHash);
-    /// @notice event that gets emitted after a successful aggregated proof verification
-    event AggregatedProofMissed(uint64 indexed proofNumber);
-    /// @notice event that gets emitted after a successful aggregated proof verification
-    event AggregatedProofFailed(uint64 indexed proofNumber);
+    event NewAggregatedProof(
+        uint64 indexed proofNumber, AggregatedProofStatus status, bytes32 merkleRoot, bytes32 blobVersionedHash
+    );
 
     error OnlyAlignedAggregator(address sender);
 }