refactor(prt-contracts): merge (non)rootTournament into Tournament

Author: stephenctw

prt/client-lua/player/reader.lua

@@ -360,13 +360,17 @@ function Reader:read_match(address, match_id_hash)
 end
 
 function Reader:inner_tournament_winner(address)
-    local sig = "innerTournamentWinner()(bool,bytes32,bytes32)"
+    -- innerTournamentWinner() returns (bool, Tree.Node, Tree.Node, Clock.State)
+    -- Clock.State is (uint64, uint64) for (allowance, startInstant)
+    local sig = "innerTournamentWinner()(bool,bytes32,bytes32,(uint64,uint64))"
     local ret = self:_call(address, sig, {})
+    assert(#ret >= 3, "innerTournamentWinner returned insufficient values")
 
     local winner = {
         has_winner = helper.str_to_bool(ret[1]),
-        commitment = Hash:from_digest_hex(ret[2]),
-        dangling = Hash:from_digest_hex(ret[3]),
+        parent_commitment = Hash:from_digest_hex(ret[2]),
+        dangling_commitment = Hash:from_digest_hex(ret[3]),
+        -- ret[4] contains Clock.State struct (allowance, startInstant) if needed
     }
 
     return winner

prt/client-rs/core/src/tournament/reader.rs

@@ -16,9 +16,7 @@ use crate::tournament::{
     TournamentWinner,
 };
 use cartesi_dave_merkle::Digest;
-use cartesi_prt_contracts::{
-    non_leaf_tournament, non_root_tournament, root_tournament, tournament,
-};
+use cartesi_prt_contracts::{non_leaf_tournament, tournament};
 
 #[derive(Clone)]
 pub struct StateReader {
@@ -202,8 +200,7 @@ impl StateReader {
         assert!(state.level < state.max_level, "level out of bounds");
 
         if state.level > 0 {
-            let tournament =
-                non_root_tournament::NonRootTournament::new(tournament_address, &self.client);
+            let tournament = tournament::Tournament::new(tournament_address, &self.client);
             state.can_be_eliminated = tournament.canBeEliminated().call().await?;
         }
 
@@ -276,8 +273,7 @@ impl StateReader {
         &self,
         root_tournament_address: Address,
     ) -> Result<Option<TournamentWinner>> {
-        let root_tournament =
-            root_tournament::RootTournament::new(root_tournament_address, &self.client);
+        let root_tournament = tournament::Tournament::new(root_tournament_address, &self.client);
         let arbitration_result_return = root_tournament.arbitrationResult().call().await?;
         let (finished, commitment, state) = (
             arbitration_result_return._0,
@@ -299,8 +295,7 @@ impl StateReader {
         &self,
         tournament_address: Address,
     ) -> Result<Option<TournamentWinner>> {
-        let tournament =
-            non_root_tournament::NonRootTournament::new(tournament_address, &self.client);
+        let tournament = tournament::Tournament::new(tournament_address, &self.client);
         let inner_tournament_winner_return = tournament.innerTournamentWinner().call().await?;
         let (finished, parent_commitment, dangling_commitment) = (
             inner_tournament_winner_return._0,

prt/contracts/justfile

@@ -1,7 +1,7 @@
 BINDINGS_DIR := "./bindings-rs/src/contract"
 DEPLOYMENTS_DIR := "./deployments"
 SRC_DIR := "."
-BINDINGS_FILTER := "^[^I].+TournamentFactory|LeafTournament|RootTournament|^Tournament$"
+BINDINGS_FILTER := "^[^I].+TournamentFactory|LeafTournament|^Tournament$"
 
 default: build
 

prt/contracts/src/ITournament.sol

@@ -41,6 +41,17 @@ interface ITournament {
         IDataProvider provider;
     }
 
+    /// @notice Arguments for non-root tournaments (level > 0)
+    /// @dev Non-root tournaments are inner tournaments created by parent tournaments.
+    ///      They need to track which two final states are being contested.
+    ///      Root tournaments (level == 0) don't need these arguments.
+    struct NonRootArguments {
+        Tree.Node contestedCommitmentOne;
+        Machine.Hash contestedFinalStateOne;
+        Tree.Node contestedCommitmentTwo;
+        Machine.Hash contestedFinalStateTwo;
+    }
+
     /// @notice Match deletion reason
     /// @param STEP The match was deleted because one of the
     /// commitments was proven wrong through an on-chain