fix: tied choices coherence M-07

Author: unknownunknown1

contracts/src/arbitration/dispute-kits/DisputeKitClassicBase.sol

@@ -44,7 +44,9 @@ abstract contract DisputeKitClassicBase is IDisputeKit, Initializable, UUPSProxi
         uint256 feeRewards; // Sum of reimbursable appeal fees available to the parties that made contributions to the ruling that ultimately wins a dispute.
         uint256[] fundedChoices; // Stores the choices that are fully funded.
         mapping(address drawnAddress => bool) alreadyDrawn; // True if the address has already been drawn, false by default.
-        uint256[10] __gap; // Reserved slots for future upgrades.
+        uint256 winningChoiceCount; // Number of votes for the winning choice.
+        uint256 numberOfWinningChoices; // Number of choices that are currently top voted.
+        uint256[8] __gap; // Reserved slots for future upgrades.
     }
 
     struct Vote {
@@ -378,15 +380,20 @@ abstract contract DisputeKitClassicBase is IDisputeKit, Initializable, UUPSProxi
         round.counts[_choice] += _voteIDs.length;
         if (_choice == round.winningChoice) {
             if (round.tied) round.tied = false;
+            round.winningChoiceCount = round.counts[_choice];
+            round.numberOfWinningChoices = 1;
         } else {
             // Voted for another choice.
             if (round.counts[_choice] == round.counts[round.winningChoice]) {
                 // Tie.
                 if (!round.tied) round.tied = true;
+                round.numberOfWinningChoices++;
             } else if (round.counts[_choice] > round.counts[round.winningChoice]) {
                 // New winner.
                 round.winningChoice = _choice;
                 round.tied = false;
+                round.winningChoiceCount = round.counts[_choice];
+                round.numberOfWinningChoices = 1;
             }
         }
         emit VoteCast(_coreDisputeID, _juror, _voteIDs, _choice, _justification);
@@ -588,10 +595,13 @@ abstract contract DisputeKitClassicBase is IDisputeKit, Initializable, UUPSProxi
     ) internal view returns (uint256 coherence) {
         // In this contract this degree can be either 0 or 1, but in other dispute kits this value can be something in between.
         Dispute storage dispute = disputes[coreDisputeIDToLocal[_coreDisputeID]];
-        Vote storage vote = dispute.rounds[dispute.coreRoundIDToLocal[_coreRoundID]].votes[_voteID];
-        (uint256 winningChoice, bool tied, ) = core.currentRuling(_coreDisputeID);
+        uint256 currentRoundID = dispute.coreRoundIDToLocal[_coreRoundID];
+        Round storage currentRound = dispute.rounds[currentRoundID];
+        Vote storage vote = dispute.rounds[currentRoundID].votes[_voteID];
+        (uint256 winningChoice, , ) = core.currentRuling(_coreDisputeID);
 
-        if (vote.voted && (vote.choice == winningChoice || tied)) {
+        if (vote.voted && (currentRound.counts[vote.choice] == currentRound.winningChoiceCount)) {
+            // If several choices match the winning choice count they all become coherent.
             return ONE_BASIS_POINT;
         } else {
             return 0;
@@ -607,7 +617,8 @@ abstract contract DisputeKitClassicBase is IDisputeKit, Initializable, UUPSProxi
         if (currentRound.totalVoted == 0 || (!tied && currentRound.counts[winningChoice] == 0)) {
             return 0;
         } else if (tied) {
-            return currentRound.totalVoted;
+            // All votes casted for top choices are considered coherent
+            return currentRound.numberOfWinningChoices * currentRound.winningChoiceCount;
         } else {
             return currentRound.counts[winningChoice];
         }

contracts/test/foundry/KlerosCore_Execution.t.sol

@@ -153,6 +153,73 @@ contract KlerosCore_ExecutionTest is KlerosCore_TestBase {
         assertEq(pinakion.balanceOf(staker2), 999999999999980000, "Wrong token balance of staker2");
     }
 
+    function test_execute_multipleWinners() public {
+        uint256 disputeID = 0;
+        uint256 numberOfOptions = 5; // 5 choices, 2 will be winners, the rest - losers
+
+        arbitrable.changeNumberOfRulingOptions(numberOfOptions);
+
+        vm.prank(staker1);
+        core.setStake(GENERAL_COURT, 10000);
+        vm.prank(disputer);
+        arbitrable.createDispute{value: feeForJuror * 5}("Action"); // 5 jurors, with future votes distribution 2-2-1-0-0
+        vm.warp(block.timestamp + minStakingTime);
+        sortitionModule.passPhase(); // Generating
+        vm.warp(block.timestamp + rngLookahead);
+        sortitionModule.passPhase(); // Drawing phase
+
+        core.draw(disputeID, 5);
+
+        vm.warp(block.timestamp + timesPerPeriod[0]);
+        core.passPeriod(disputeID); // Vote
+
+        uint256[] memory voteIDs = new uint256[](2);
+        voteIDs[0] = 0;
+        voteIDs[1] = 1;
+        vm.prank(staker1);
+        disputeKit.castVote(disputeID, voteIDs, 1, 0, "XYZ"); // Cast first 2 votes for 1st choice
+
+        voteIDs = new uint256[](2);
+        voteIDs[0] = 2;
+        voteIDs[1] = 3;
+        vm.prank(staker1);
+        disputeKit.castVote(disputeID, voteIDs, 2, 0, "XYZ"); // Cast next 2 votes for 2nd choice
+
+        voteIDs = new uint256[](1);
+        voteIDs[0] = 4;
+        vm.prank(staker1);
+        disputeKit.castVote(disputeID, voteIDs, 3, 0, "XYZ"); // Cast the last vote for 3rd choice.
+        core.passPeriod(disputeID); // Appeal
+
+        vm.warp(block.timestamp + timesPerPeriod[3]);
+        core.passPeriod(disputeID); // Execution
+
+        assertEq(disputeKit.getCoherentCount(disputeID, 0), 4, "Wrong coherent count"); // Votes casted for first 2 choices are coherent
+
+        uint256 pnkCoherence;
+        uint256 feeCoherence;
+        // dispute, round, voteID, feeForJuror (not used in classic DK), pnkPerJuror (not used in classic DK)
+        (pnkCoherence, feeCoherence) = disputeKit.getDegreeOfCoherenceReward(disputeID, 0, 0, 0, 0);
+        assertEq(pnkCoherence, 10000, "Wrong reward pnk coherence 0 vote ID");
+        assertEq(feeCoherence, 10000, "Wrong reward fee coherence 0 vote ID");
+
+        (pnkCoherence, feeCoherence) = disputeKit.getDegreeOfCoherenceReward(disputeID, 0, 1, 0, 0);
+        assertEq(pnkCoherence, 10000, "Wrong reward pnk coherence 1 vote ID");
+        assertEq(feeCoherence, 10000, "Wrong reward fee coherence 1 vote ID");
+
+        (pnkCoherence, feeCoherence) = disputeKit.getDegreeOfCoherenceReward(disputeID, 0, 2, 0, 0);
+        assertEq(pnkCoherence, 10000, "Wrong reward pnk coherence 2 vote ID");
+        assertEq(feeCoherence, 10000, "Wrong reward fee coherence 2 vote ID");
+
+        (pnkCoherence, feeCoherence) = disputeKit.getDegreeOfCoherenceReward(disputeID, 0, 3, 0, 0);
+        assertEq(pnkCoherence, 10000, "Wrong reward pnk coherence 3 vote ID");
+        assertEq(feeCoherence, 10000, "Wrong reward fee coherence 3 vote ID");
+
+        (pnkCoherence, feeCoherence) = disputeKit.getDegreeOfCoherenceReward(disputeID, 0, 4, 0, 0);
+        assertEq(pnkCoherence, 0, "Wrong reward pnk coherence 4 vote ID");
+        assertEq(feeCoherence, 0, "Wrong reward fee coherence 4 vote ID");
+    }
+
     function test_execute_maxStakeCheck() public {
         uint256 disputeID = 0;