feat!: extract ITask from ITournament and add the Safety Gate

Introduce a minimal task abstraction (ITask/ITaskSpawner) that decouples
DaveConsensus from the proof system:

- ITournament now extends ITask; result() projects arbitrationResult
  without the winner commitment, and cleanup() recovers bonds.
- ITournamentFactory is replaced by ITaskSpawner.
- DaveConsensus spawns tasks and settles on result(); canSettle reports
  the final machine state instead of the winner commitment.

Add the Safety Gate, a delay-only middleware task:

- SafetyGateTask gates an inner task behind unanimous sentry votes, with
  a permissionless fallback timer for liveness.
- SafetyGateTaskSpawner wraps an inner spawner; the security council can
  rotate the sentry set, effective from the next spawned task.
- Deployment scripts wire DaveAppFactory through the gate spawner.

Tasks implement ERC-165; the ISafetyGateTask interface id is pinned by a
guard test for offchain gate detection.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: GCdePaula

cartesi-rollups/contracts/script/Deployment.s.sol

@@ -14,13 +14,13 @@ contract DeploymentScript is BaseDeploymentScript {
 
         address inputBox = _loadDeployment(".", "InputBox");
         address appFactory = _loadDeployment(".", "ApplicationFactory");
-        address tournamentFactory = _loadDeployment(".", "MultiLevelTournamentFactory");
+        address taskSpawner = _loadDeployment(".", "SafetyGateTaskSpawner");
 
         vmSafe.startBroadcast();
 
         _storeDeployment(
             type(DaveAppFactory).name,
-            _create2(type(DaveAppFactory).creationCode, abi.encode(inputBox, appFactory, tournamentFactory))
+            _create2(type(DaveAppFactory).creationCode, abi.encode(inputBox, appFactory, taskSpawner))
         );
 
         vmSafe.stopBroadcast();

cartesi-rollups/contracts/src/DaveAppFactory.sol

@@ -14,7 +14,7 @@ import {IApplication} from "cartesi-rollups-contracts-3.0.0/src/dapp/IApplicatio
 import {IApplicationFactory} from "cartesi-rollups-contracts-3.0.0/src/dapp/IApplicationFactory.sol";
 import {IInputBox} from "cartesi-rollups-contracts-3.0.0/src/inputs/IInputBox.sol";
 
-import {ITournamentFactory} from "prt-contracts/ITournamentFactory.sol";
+import {ITaskSpawner} from "prt-contracts/ITaskSpawner.sol";
 import {Machine} from "prt-contracts/types/Machine.sol";
 
 import {DaveConsensus} from "./DaveConsensus.sol";
@@ -24,14 +24,14 @@ import {IDaveConsensus} from "./IDaveConsensus.sol";
 contract DaveAppFactory is IDaveAppFactory {
     IInputBox immutable INPUT_BOX;
     IApplicationFactory immutable APP_FACTORY;
-    ITournamentFactory immutable TOURNAMENT_FACTORY;
+    ITaskSpawner immutable TASK_SPAWNER;
 
     IOutputsMerkleRootValidator constant NO_VALIDATOR = IOutputsMerkleRootValidator(address(0));
 
-    constructor(IInputBox inputBox, IApplicationFactory appFactory, ITournamentFactory tournamentFactory) {
+    constructor(IInputBox inputBox, IApplicationFactory appFactory, ITaskSpawner taskSpawner) {
         INPUT_BOX = inputBox;
         APP_FACTORY = appFactory;
-        TOURNAMENT_FACTORY = tournamentFactory;
+        TASK_SPAWNER = taskSpawner;
     }
 
     function newDaveApp(bytes32 templateHash, WithdrawalConfig calldata withdrawalConfig, bytes32 salt)
@@ -81,7 +81,7 @@ contract DaveAppFactory is IDaveAppFactory {
         returns (DaveConsensus)
     {
         Machine.Hash initialMachineStateHash = Machine.Hash.wrap(templateHash);
-        return new DaveConsensus{salt: salt}(INPUT_BOX, appContract, TOURNAMENT_FACTORY, initialMachineStateHash);
+        return new DaveConsensus{salt: salt}(INPUT_BOX, appContract, TASK_SPAWNER, initialMachineStateHash);
     }
 
     /// @notice Calculates the address of an application contract.
@@ -106,8 +106,7 @@ contract DaveAppFactory is IDaveAppFactory {
             salt,
             keccak256(
                 abi.encodePacked(
-                    type(DaveConsensus).creationCode,
-                    abi.encode(INPUT_BOX, appContract, TOURNAMENT_FACTORY, templateHash)
+                    type(DaveConsensus).creationCode, abi.encode(INPUT_BOX, appContract, TASK_SPAWNER, templateHash)
                 )
             )
         );

cartesi-rollups/contracts/src/DaveConsensus.sol

@@ -16,18 +16,17 @@ import {LibKeccak256} from "cartesi-rollups-contracts-3.0.0/src/library/LibKecca
 import {LibMath} from "cartesi-rollups-contracts-3.0.0/src/library/LibMath.sol";
 
 import {IDataProvider} from "prt-contracts/IDataProvider.sol";
-import {ITournament} from "prt-contracts/ITournament.sol";
-import {ITournamentFactory} from "prt-contracts/ITournamentFactory.sol";
+import {ITask} from "prt-contracts/ITask.sol";
+import {ITaskSpawner} from "prt-contracts/ITaskSpawner.sol";
 
 import {Machine} from "prt-contracts/types/Machine.sol";
-import {Tree} from "prt-contracts/types/Tree.sol";
 
 import {EmulatorConstants} from "step/src/EmulatorConstants.sol";
 import {Memory} from "step/src/Memory.sol";
 
 import {IDaveConsensus} from "./IDaveConsensus.sol";
 
-/// @notice Consensus contract with Dave tournaments.
+/// @notice Consensus contract with Dave tasks.
 ///
 /// @notice This contract validates only one application,
 /// which read inputs from the InputBox contract.
@@ -60,8 +59,8 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
     /// @notice The application contract
     address immutable _APP_CONTRACT;
 
-    /// @notice The contract used to instantiate tournaments
-    ITournamentFactory immutable _TOURNAMENT_FACTORY;
+    /// @notice The contract used to instantiate tasks
+    ITaskSpawner immutable _TASK_SPAWNER;
 
     /// @notice Deployment block number
     uint256 immutable _DEPLOYMENT_BLOCK_NUMBER = block.number;
@@ -75,8 +74,8 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
     /// @notice Input index (exclusive) upper bound of the current sealed epoch
     uint256 _inputIndexUpperBound;
 
-    /// @notice Current sealed epoch tournament
-    ITournament _tournament;
+    /// @notice Current sealed epoch task
+    ITask _task;
 
     /// @notice Settled output trees' merkle root hash
     mapping(bytes32 => bool) _outputsMerkleRoots;
@@ -87,30 +86,30 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
     constructor(
         IInputBox inputBox,
         address appContract,
-        ITournamentFactory tournamentFactory,
+        ITaskSpawner taskSpawner,
         Machine.Hash initialMachineStateHash
     ) {
         // Initialize immutable variables
         _INPUT_BOX = inputBox;
         _APP_CONTRACT = appContract;
-        _TOURNAMENT_FACTORY = tournamentFactory;
-        emit ConsensusCreation(inputBox, appContract, tournamentFactory);
+        _TASK_SPAWNER = taskSpawner;
+        emit ConsensusCreation(inputBox, appContract, taskSpawner);
 
         // Initialize first sealed epoch
         uint256 inputIndexUpperBound = inputBox.getNumberOfInputs(appContract);
         _inputIndexUpperBound = inputIndexUpperBound;
-        ITournament tournament = tournamentFactory.instantiate(initialMachineStateHash, this);
-        _tournament = tournament;
-        emit EpochSealed(0, 0, inputIndexUpperBound, initialMachineStateHash, bytes32(0), tournament);
+        ITask task = taskSpawner.spawn(initialMachineStateHash, this);
+        _task = task;
+        emit EpochSealed(0, 0, inputIndexUpperBound, initialMachineStateHash, bytes32(0), task);
     }
 
     function canSettle()
         external
         view
         override
-        returns (bool isFinished, uint256 epochNumber, Tree.Node winnerCommitment)
+        returns (bool isFinished, uint256 epochNumber, Machine.Hash finalState)
     {
-        (isFinished, winnerCommitment,) = _tournament.arbitrationResult();
+        (isFinished, finalState) = _task.result();
         epochNumber = _epochNumber;
     }
 
@@ -119,14 +118,14 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
         override
         notForeclosed(_APP_CONTRACT)
     {
-        // Check tournament settlement
+        // Check task settlement
         require(epochNumber == _epochNumber, IncorrectEpochNumber(epochNumber, _epochNumber));
 
-        // Check tournament finished
-        (bool isFinished,, Machine.Hash finalMachineStateHash) = _tournament.arbitrationResult();
+        // Check task finished
+        (bool isFinished, Machine.Hash finalMachineStateHash) = _task.result();
         require(isFinished, TournamentNotFinishedYet());
-        ITournament oldTournament = _tournament;
-        _tournament = ITournament(address(0));
+        ITask oldTask = _task;
+        _task = ITask(address(0));
 
         // Check outputs Merkle root
         _validateOutputTree(finalMachineStateHash, outputsMerkleRoot, proof);
@@ -138,36 +137,26 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
         _outputsMerkleRoots[outputsMerkleRoot] = true;
         _lastFinalizedMachineStateHash = finalMachineStateHash;
 
-        // Start new tournament
-        _tournament = _TOURNAMENT_FACTORY.instantiate(finalMachineStateHash, this);
+        // Start new task
+        _task = _TASK_SPAWNER.spawn(finalMachineStateHash, this);
 
         emit EpochSealed(
-            _epochNumber,
-            _inputIndexLowerBound,
-            _inputIndexUpperBound,
-            finalMachineStateHash,
-            outputsMerkleRoot,
-            _tournament
+            _epochNumber, _inputIndexLowerBound, _inputIndexUpperBound, finalMachineStateHash, outputsMerkleRoot, _task
         );
 
-        oldTournament.tryRecoveringBond();
+        _tryCleanup(oldTask);
     }
 
     function getCurrentSealedEpoch()
         external
         view
         override
-        returns (
-            uint256 epochNumber,
-            uint256 inputIndexLowerBound,
-            uint256 inputIndexUpperBound,
-            ITournament tournament
-        )
+        returns (uint256 epochNumber, uint256 inputIndexLowerBound, uint256 inputIndexUpperBound, ITask task)
     {
         epochNumber = _epochNumber;
         inputIndexLowerBound = _inputIndexLowerBound;
         inputIndexUpperBound = _inputIndexUpperBound;
-        tournament = _tournament;
+        task = _task;
     }
 
     function getInputBox() external view override returns (IInputBox) {
@@ -178,8 +167,8 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
         return _APP_CONTRACT;
     }
 
-    function getTournamentFactory() external view override returns (ITournamentFactory) {
-        return _TOURNAMENT_FACTORY;
+    function getTaskSpawner() external view override returns (ITaskSpawner) {
+        return _TASK_SPAWNER;
     }
 
     function provideMerkleRootOfInput(uint256 inputIndexWithinEpoch, bytes calldata input)
@@ -250,6 +239,12 @@ contract DaveConsensus is IDaveConsensus, ERC165, ApplicationChecker {
         require(machineStateHash == allegedStateHash, InvalidOutputsMerkleRootProof(finalMachineStateHash));
     }
 
+    /// @dev Best-effort: settlement must never be blocked by a task whose
+    /// cleanup reverts.
+    function _tryCleanup(ITask task) internal {
+        try task.cleanup() returns (bool) {} catch {}
+    }
+
     modifier onlyValidAppContract(address appContract) {
         _ensureAppContractIsValid(appContract);
         _;

cartesi-rollups/contracts/src/IDaveConsensus.sol

@@ -11,13 +11,12 @@ import {IApplicationChecker} from "cartesi-rollups-contracts-3.0.0/src/dapp/IApp
 import {IInputBox} from "cartesi-rollups-contracts-3.0.0/src/inputs/IInputBox.sol";
 
 import {IDataProvider} from "prt-contracts/IDataProvider.sol";
-import {ITournament} from "prt-contracts/ITournament.sol";
-import {ITournamentFactory} from "prt-contracts/ITournamentFactory.sol";
+import {ITask} from "prt-contracts/ITask.sol";
+import {ITaskSpawner} from "prt-contracts/ITaskSpawner.sol";
 
 import {Machine} from "prt-contracts/types/Machine.sol";
-import {Tree} from "prt-contracts/types/Tree.sol";
 
-/// @notice Consensus contract with Dave tournaments.
+/// @notice Consensus contract with Dave tasks.
 ///
 /// @notice This contract validates only one application,
 /// which read inputs from the InputBox contract.
@@ -43,31 +42,33 @@ interface IDaveConsensus is IDataProvider, IOutputsMerkleRootValidator, IApplica
     /// @notice Consensus contract was created
     /// @param inputBox the input box contract
     /// @param appContract the application contract
-    /// @param tournamentFactory the tournament factory contract
-    event ConsensusCreation(IInputBox inputBox, address appContract, ITournamentFactory tournamentFactory);
+    /// @param taskSpawner the task spawner contract
+    event ConsensusCreation(IInputBox inputBox, address appContract, ITaskSpawner taskSpawner);
 
     /// @notice An epoch was sealed
     /// @param epochNumber the sealed epoch number
     /// @param inputIndexLowerBound the input index (inclusive) lower bound in the sealed epoch
     /// @param inputIndexUpperBound the input index (exclusive) upper bound in the sealed epoch
     /// @param initialMachineStateHash the initial machine state hash
     /// @param outputsMerkleRoot the Merkle root hash of the outputs tree
-    /// @param tournament the sealed epoch tournament contract
+    /// @param task the sealed epoch task contract
     event EpochSealed(
         uint256 epochNumber,
         uint256 inputIndexLowerBound,
         uint256 inputIndexUpperBound,
         Machine.Hash initialMachineStateHash,
         bytes32 outputsMerkleRoot,
-        ITournament tournament
+        ITask task
     );
 
     /// @notice Received epoch number is different from actual
     /// @param received The epoch number received as argument
     /// @param actual The actual epoch number in storage
     error IncorrectEpochNumber(uint256 received, uint256 actual);
 
-    /// @notice Tournament is not finished yet
+    /// @notice Task is not finished yet
+    /// @dev Kept under its historical name: downstream nodes classify
+    /// settle reverts by error name.
     error TournamentNotFinishedYet();
 
     /// @notice Hash of received input blob is different from stored on-chain
@@ -97,29 +98,24 @@ interface IDaveConsensus is IDataProvider, IOutputsMerkleRootValidator, IApplica
     /// @notice Get the address of the application contract.
     function getApplicationContract() external view returns (address);
 
-    /// @notice Get the tournament factory contract used to instantiate root tournaments.
-    function getTournamentFactory() external view returns (ITournamentFactory);
+    /// @notice Get the task spawner contract used to instantiate root tasks.
+    function getTaskSpawner() external view returns (ITaskSpawner);
 
-    /// @notice Get the current sealed epoch number, boundaries, and tournament.
+    /// @notice Get the current sealed epoch number, boundaries, and task.
     /// @param epochNumber The epoch number
     /// @param inputIndexLowerBound The epoch input index (inclusive) lower bound
     /// @param inputIndexUpperBound The epoch input index (exclusive) upper bound
-    /// @param tournament The tournament that will decide the post-epoch state
+    /// @param task The task that will decide the post-epoch state
     function getCurrentSealedEpoch()
         external
         view
-        returns (
-            uint256 epochNumber,
-            uint256 inputIndexLowerBound,
-            uint256 inputIndexUpperBound,
-            ITournament tournament
-        );
+        returns (uint256 epochNumber, uint256 inputIndexLowerBound, uint256 inputIndexUpperBound, ITask task);
 
     /// @notice Check whether the current sealed epoch can be settled.
-    /// @return isFinished Whether the current sealed epoch tournament has finished yet
+    /// @return isFinished Whether the current sealed epoch task has finished yet
     /// @return epochNumber The current sealed epoch number
-    /// @return winnerCommitment If the tournament has finished, the winning commitment
-    function canSettle() external view returns (bool isFinished, uint256 epochNumber, Tree.Node winnerCommitment);
+    /// @return finalState If the task has finished, the final machine state
+    function canSettle() external view returns (bool isFinished, uint256 epochNumber, Machine.Hash finalState);
 
     /// @notice Settle the current sealed epoch.
     /// @param epochNumber The current sealed epoch number (used to avoid race conditions)