Ahead of time auction for prover incentives

documentation/Overall Design.md

@@ -75,6 +75,7 @@ These properties seem like they should be useful for composability. However:
 
 - we have not yet designed any features that rely on them.
 - the shared feed undermines the ability to recognise when a publication is no longer required, so  <span style="color: orange;">it prevents the use of a ring buffer</span>.
+- we cannot compute the number of relevant publications between two publication ids, so we need to pass this as a separate parameter to the proof.
 
 If we do not implement any composability features, we should restore the different publication feeds per rollup so the implementation can be optimised.
 

src/protocol/CheckpointTracker.sol

@@ -6,49 +6,67 @@ import {IPublicationFeed} from "./IPublicationFeed.sol";
 import {IVerifier} from "./IVerifier.sol";
 
 contract CheckpointTracker is ICheckpointTracker {
-    /// @notice The hash of the current proven checkpoint representing the latest verified state of the rollup
+    /// @notice The current proven checkpoint representing the latest verified state of the rollup
     /// @dev Previous checkpoints are not stored here but are synchronized to the `SignalService`
     /// @dev A checkpoint commitment is any value (typically a state root) that uniquely identifies
     /// the state of the rollup at a specific point in time
-    bytes32 public provenHash;
+    /// @dev We store the actual checkpoint(not the hash) to avoid race conditions when closing a period or evicting a
+    /// prover(https://github.com/OpenZeppelin/minimal-rollup/pull/77#discussion_r2002192018)
+    Checkpoint private _provenCheckpoint;
 
     IPublicationFeed public immutable publicationFeed;
-
-    // This would usually be retrieved dynamically as in the current Taiko implementation, but for simplicity we are
-    // just setting it in the constructor
     IVerifier public immutable verifier;
+    address public proverManager;
 
     /// @param _genesis the checkpoint commitment describing the initial state of the rollup
     /// @param _publicationFeed the input data source that updates the state of this rollup
     /// @param _verifier a contract that can verify the validity of a transition from one checkpoint to another
-    constructor(bytes32 _genesis, address _publicationFeed, address _verifier) {
+    /// @param _proverManager contract responsible for managing the prover auction
+    constructor(bytes32 _genesis, address _publicationFeed, address _verifier, address _proverManager) {
         // set the genesis checkpoint commitment of the rollup - genesis is trusted to be correct
         require(_genesis != 0, "genesis checkpoint commitment cannot be 0");
 
         publicationFeed = IPublicationFeed(_publicationFeed);
         verifier = IVerifier(_verifier);
-
+        proverManager = _proverManager;
         Checkpoint memory genesisCheckpoint = Checkpoint({publicationId: 0, commitment: _genesis});
-        provenHash = keccak256(abi.encode(genesisCheckpoint));
-        emit CheckpointUpdated(provenHash);
+        _provenCheckpoint = genesisCheckpoint;
+        emit CheckpointUpdated(genesisCheckpoint);
     }
 
     /// @inheritdoc ICheckpointTracker
-    function proveTransition(Checkpoint calldata start, Checkpoint calldata end, bytes calldata proof) external {
+    function proveTransition(
+        Checkpoint calldata start,
+        Checkpoint calldata end,
+        uint256 numPublications,
+        bytes calldata proof
+    ) external {
+        require(
+            proverManager == address(0) || msg.sender == proverManager, "Only the prover manager can call this function"
+        );
+
         require(end.commitment != 0, "Checkpoint commitment cannot be 0");
 
-        bytes32 startCheckpointHash = keccak256(abi.encode(start));
-        require(startCheckpointHash == provenHash, "Start checkpoint must be the latest proven checkpoint");
+        require(
+            start.publicationId == _provenCheckpoint.publicationId && start.commitment == _provenCheckpoint.commitment,
+            "Start checkpoint must be the latest proven checkpoint"
+        );
 
         require(start.publicationId < end.publicationId, "End publication must be after the last proven publication");
 
         bytes32 startPublicationHash = publicationFeed.getPublicationHash(start.publicationId);
         bytes32 endPublicationHash = publicationFeed.getPublicationHash(end.publicationId);
         require(endPublicationHash != 0, "End publication does not exist");
 
-        verifier.verifyProof(startPublicationHash, endPublicationHash, start.commitment, end.commitment, proof);
+        verifier.verifyProof(
+            startPublicationHash, endPublicationHash, start.commitment, end.commitment, numPublications, proof
+        );
+
+        _provenCheckpoint = end;
+        emit CheckpointUpdated(end);
+    }
 
-        provenHash = keccak256(abi.encode(end));
-        emit TransitionProven(start, end);
+    function getProvenCheckpoint() external view returns (Checkpoint memory) {
+        return _provenCheckpoint;
     }
 }

src/protocol/ICheckpointTracker.sol

@@ -8,17 +8,23 @@ interface ICheckpointTracker {
     }
 
     /// @notice Emitted when the proven checkpoint is updated
-    /// @param checkpointHash the hash of the last proven checkpoint
-    event CheckpointUpdated(bytes32 indexed checkpointHash);
+    /// @param latestCheckpoint the latest proven checkpoint
+    event CheckpointUpdated(Checkpoint latestCheckpoint);
 
-    /// @notice Emitted when a transition is proven
-    /// @param start the checkpoint before the transition
-    /// @param end the checkpoint after the transition
-    event TransitionProven(Checkpoint start, Checkpoint end);
+    /// @return _ The last proven checkpoint
+    function getProvenCheckpoint() external view returns (Checkpoint memory);
 
     /// @notice Verifies a transition between two checkpoints. Update the latest `provenCheckpoint` if possible
     /// @param start The initial checkpoint before the transition
     /// @param end The final checkpoint after the transition
+    /// @param numPublications The number of publications that need to be processed between the two checkpoints.
+    /// Note that this is not necessarily (end.publicationId - start.publicationId) because there could be irrelevant
+    /// publications.
     /// @param proof Arbitrary data passed to the `verifier` contract to confirm the transition validity
-    function proveTransition(Checkpoint calldata start, Checkpoint calldata end, bytes calldata proof) external;
+    function proveTransition(
+        Checkpoint calldata start,
+        Checkpoint calldata end,
+        uint256 numPublications,
+        bytes calldata proof
+    ) external;
 }

src/protocol/IInbox.sol

@@ -2,5 +2,5 @@
 pragma solidity ^0.8.28;
 
 interface IInbox {
-    function publish(uint256 nBlobs, uint64 anchorBlockId) external;
+    function publish(uint256 nBlobs, uint64 anchorBlockId) external payable;
 }

src/protocol/IProposerFees.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IProposerFees {
+    /// @notice Proposers have to pay a fee for each publication they want to get proven. This should be called only by
+    /// the Inbox contract.
+    /// @param proposer The address of the proposer
+    /// @param isDelayed Whether the publication is a delayed publication
+    function payPublicationFee(address proposer, bool isDelayed) external payable;
+
+    /// @notice Returns the current fees for a period
+    /// @return fee The fee for a regular publication
+    /// @return delayedFee The fee for a delayed publication
+    function getCurrentFees() external view returns (uint256 fee, uint256 delayedFee);
+}

src/protocol/IProverManager.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {ICheckpointTracker} from "./ICheckpointTracker.sol";
+import {IPublicationFeed} from "./IPublicationFeed.sol";
+
+interface IProverManager {
+    /// @notice Bid to become the prover for the next period
+    /// @param offeredFee The fee you are willing to charge for proving each publication
+    function bid(uint256 offeredFee) external;
+
+    /// @notice The current prover can signal exit to eventually pull out their liveness bond.
+    function exit() external;
+
+    /// @notice If there is no active prover, start a new period and become the new prover in the next block
+    /// @param fee The per-publication fee for the new period
+    /// @dev Consider the scenario:
+    ///   - a prover has exited or been evicted
+    ///   - no prover has bid on the next period
+    ///   - a publication is made, creating a new period with no prover and no fee
+    /// At this point it is impossible to outbid the prover because the fee is zero
+    /// This function allows anyone to start a new period with a new fee. Note that the new prover will still need to
+    // ensure the previous publications are proven before proving their own. Nevertheless, we start a new period so
+    // they cannot be evicted based on publications that occurred before they agreed to prove
+    function claimProvingVacancy(uint256 fee) external;
+
+    /// @notice Evicts a prover that has been inactive, marking the prover for slashing
+    /// @param publicationHeader The publication header that the caller is claiming is too old and hasn't been proven
+    function evictProver(IPublicationFeed.PublicationHeader calldata publicationHeader) external;
+
+    /// @notice Submits a proof.
+    /// @dev If called after the period is closed( the proof deadline has passed), the caller becomes the prover for the
+    /// period and some of the original prover's stake is burned
+    /// @dev In either case the (possibly new) prover gets the fee for all proven publications
+    /// @param start The initial checkpoint before the transition
+    /// @param end The final checkpoint after the transition
+    /// @param firstPub The first publication header in the transition. Note that since checkpoints refer to the
+    /// publication they follow, this should have an id `start.publicationId + 1`
+    /// @param lastPub The last publication header in the transition
+    /// @param numPublications The number of publications to process. This is not implied by the start/end publication
+    /// ids because the `PublicationFeed` is shared and may contain publications not relevant for this rollup
+    /// @param proof Arbitrary data passed to the `verifier` contract to confirm the transition validity
+    /// @param periodId The id of the period for which the proof is submitted
+    function prove(
+        ICheckpointTracker.Checkpoint calldata start,
+        ICheckpointTracker.Checkpoint calldata end,
+        IPublicationFeed.PublicationHeader calldata firstPub,
+        IPublicationFeed.PublicationHeader calldata lastPub,
+        uint256 numPublications,
+        bytes calldata proof,
+        uint256 periodId
+    ) external;
+
+    /// @notice Returns the stake for a past period to the prover
+    /// @param periodId The id of the period to finalize
+    /// @param provenPublication A publication that the caller is claiming has been proven and is after the period end
+    /// @dev If there is a proven publication after the period, it implies the whole period has been proven.
+    /// @dev We assume there will always be a suitable proven publication.
+    function finalizePastPeriod(uint256 periodId, IPublicationFeed.PublicationHeader calldata provenPublication)
+        external;
+}

src/protocol/IPublicationFeed.sol

@@ -32,4 +32,9 @@ interface IPublicationFeed {
     /// @notice Returns the next publication's ID.
     /// @return _ The next publication ID.
     function getNextPublicationId() external view returns (uint256);
+
+    /// @notice Validate a publication header against the hash stored in the feed
+    /// @param header The header to validate
+    /// @return _ True if the header is valid, false otherwise
+    function validateHeader(PublicationHeader calldata header) external view returns (bool);
 }

src/protocol/IVerifier.sol

@@ -8,6 +8,7 @@ interface IVerifier {
         bytes32 endPublicationHash,
         bytes32 startCheckPoint,
         bytes32 endCheckPoint,
+        uint256 numPublications,
         bytes calldata proof
     ) external;
 }

src/protocol/PublicationFeed.sol

@@ -45,4 +45,9 @@ contract PublicationFeed is IPublicationFeed {
     function getNextPublicationId() external view returns (uint256) {
         return publicationHashes.length;
     }
+
+    /// @inheritdoc IPublicationFeed
+    function validateHeader(PublicationHeader calldata header) external view returns (bool) {
+        return keccak256(abi.encode(header)) == publicationHashes[header.id];
+    }
 }