feat: proof aggregation service contract

Author: MarcosNicolau

.gitmodules

@@ -31,3 +31,6 @@
 [submodule "claim_contracts/lib/openzeppelin-contracts"]
 	path = claim_contracts/lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
+[submodule "contracts/lib/sp1-contracts"]
+	path = contracts/lib/sp1-contracts
+	url = https://github.com/succinctlabs/sp1-contracts

contracts/remappings.txt

@@ -5,3 +5,4 @@ eigenlayer-scripts/=lib/eigenlayer-middleware/lib/eigenlayer-contracts/script/
 forge-std/=lib/forge-std/src/
 @openzeppelin/contracts/=lib/eigenlayer-middleware/lib/openzeppelin-contracts/contracts/
 @openzeppelin-upgrades/contracts/=lib/eigenlayer-middleware/lib/openzeppelin-contracts-upgradeable/contracts/
+@sp1-contracts/=lib/sp1-contracts/contracts/src/ 

contracts/src/core/AlignedProofAggregationService.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.12;
+
+import {Initializable} from "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol";
+import {OwnableUpgradeable} from "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol";
+import {UUPSUpgradeable} from "@openzeppelin-upgrades/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {IAlignedProofAggregationService} from "./IAlignedProofAggregationService.sol";
+import {ISP1Verifier} from "@sp1-contracts/ISP1Verifier.sol";
+
+contract AlignedProofAggregationService is
+    IAlignedProofAggregationService,
+    Initializable,
+    OwnableUpgradeable,
+    UUPSUpgradeable
+{
+    /// @notice Maps the aggregated verification merkle root with the blob transaction hash that contains the leaves
+    uint64 public currentAggregatedProofNumber;
+    mapping(uint64 => AggregatedProof) public aggregatedProofs;
+
+    /// @notice The address of the SP1 verifier contract.
+    /// @dev This can either be a specific SP1Verifier for a specific version, or the
+    ///      SP1VerifierGateway which can be used to verify proofs for any version of SP1.
+    ///      For the list of supported verifiers on each chain, see:
+    ///      https://docs.succinct.xyz/onchain-verification/contract-addresses
+    address public sp1VerifierAddress;
+
+    address public alignedAggregatorAddress;
+
+    /// @notice whether we are in dev mode or not
+    /// if the sp1 verifier address is set to this address, then we skip verification
+    address public constant VERIFIER_MOCK_ADDRESS = address(0xFF);
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address newOwner, address _alignedAggregatorAddress, address _sp1VerifierAddress)
+        public
+        initializer
+    {
+        __Ownable_init();
+        __UUPSUpgradeable_init();
+        _transferOwnership(newOwner);
+        alignedAggregatorAddress = _alignedAggregatorAddress;
+        sp1VerifierAddress = _sp1VerifierAddress;
+    }
+
+    function verify(
+        bytes32 blobTransactionHash,
+        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);
+            return;
+        }
+
+        try ISP1Verifier(sp1VerifierAddress).verifyProof(sp1ProgramVKey, sp1PublicValues, sp1ProofBytes) {
+            (bytes32 merkleRoot) = abi.decode(sp1PublicValues, (bytes32));
+            _newAggregatedProof(merkleRoot, blobTransactionHash);
+        } catch {
+            emit AggregatedProofFailed(currentAggregatedProofNumber);
+        }
+    }
+
+    function markCurrentAggregatedProofAsMissed() public onlyAlignedAggregator {
+        emit AggregatedProofMissed(currentAggregatedProofNumber);
+        currentAggregatedProofNumber += 1;
+    }
+
+    function _newAggregatedProof(bytes32 merkleRoot, bytes32 blobHash) internal {
+        AggregatedProof storage proof = aggregatedProofs[currentAggregatedProofNumber];
+        proof.merkleRoot = merkleRoot;
+        proof.blobHash = blobHash;
+        proof.status = AggregatedProofStatus.Verified;
+        emit NewAggregatedProofVerified(currentAggregatedProofNumber, merkleRoot, blobHash);
+        currentAggregatedProofNumber += 1;
+    }
+
+    function _authorizeUpgrade(address newImplementation)
+        internal
+        override
+        onlyOwner // solhint-disable-next-line no-empty-blocks
+    {}
+
+    modifier onlyAlignedAggregator() {
+        if (msg.sender != alignedAggregatorAddress) {
+            revert OnlyAlignedAggregator(msg.sender);
+        }
+        _;
+    }
+}

contracts/src/core/IAlignedProofAggregationService.sol

@@ -0,0 +1,48 @@
+pragma solidity ^0.8.12;
+
+interface IAlignedProofAggregationService {
+    /// @notice aggregated proof status
+    /// Verified -> Verification was successful
+    /// Failed -> Verification failed
+    /// Missed -> Internal error in the aligned service could not send the aggregated proof to verify
+    enum AggregatedProofStatus {
+        Verified,
+        Failed,
+        Missed
+    }
+
+    /// @notice aggregated proof
+    /// Status -> proof status
+    /// blobHash -> the hash of the blob transaction containing the hashes of all the proofs that have been aggregated
+    /// merkleRoot -> the committed merkle root in the aggregated
+    struct AggregatedProof {
+        AggregatedProofStatus status;
+        bytes32 blobHash;
+        bytes32 merkleRoot;
+    }
+
+    /// @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 sp1ProgramVKey Public verifying key
+    /// @param sp1PublicValues Values used to perform the execution
+    /// @param sp1ProofBytes Groth16 proof
+    function verify(
+        bytes32 blobTransactionHash,
+        bytes32 sp1ProgramVKey,
+        bytes calldata sp1PublicValues,
+        bytes calldata sp1ProofBytes
+    ) external;
+
+    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);
+
+    error OnlyAlignedAggregator(address sender);
+}