fix: accounting of round.drawIterations

Author: jaybuidl

contracts/src/arbitration/KlerosCore.sol

@@ -610,9 +610,10 @@ contract KlerosCore is IArbitratorV2 {
 
         IDisputeKit disputeKit = disputeKitNodes[round.disputeKitID].disputeKit;
 
-        uint256 startIndex = round.drawIterations;
-        for (uint256 i = startIndex; i < startIndex + _iterations && round.drawnJurors.length < round.nbVotes; i++) {
-            address drawnAddress = disputeKit.draw(_disputeID, i);
+        uint256 startIndex = round.drawIterations; // for gas: less storage reads
+        uint256 i;
+        while (i < _iterations && round.drawnJurors.length < round.nbVotes) {
+            address drawnAddress = disputeKit.draw(_disputeID, startIndex + i++);
             if (drawnAddress == address(0)) {
                 continue;
             }
@@ -623,7 +624,7 @@ contract KlerosCore is IArbitratorV2 {
                 sortitionModule.postDrawHook(_disputeID, currentRound);
             }
         }
-        round.drawIterations += _iterations;
+        round.drawIterations += i;
     }
 
     /// @dev Appeals the ruling of a specified dispute.
@@ -972,38 +973,8 @@ contract KlerosCore is IArbitratorV2 {
         (ruling, tied, overridden) = disputeKit.currentRuling(_disputeID);
     }
 
-    function getRoundInfo(
-        uint256 _disputeID,
-        uint256 _round
-    )
-        external
-        view
-        returns (
-            uint256 disputeKitID,
-            uint256 pnkAtStakePerJuror,
-            uint256 totalFeesForJurors,
-            uint256 nbVotes,
-            uint256 repartitions,
-            uint256 pnkPenalties,
-            address[] memory drawnJurors,
-            uint256 sumFeeRewardPaid,
-            uint256 sumPnkRewardPaid,
-            IERC20 feeToken
-        )
-    {
-        Round storage round = disputes[_disputeID].rounds[_round];
-        return (
-            round.disputeKitID,
-            round.pnkAtStakePerJuror,
-            round.totalFeesForJurors,
-            round.nbVotes,
-            round.repartitions,
-            round.pnkPenalties,
-            round.drawnJurors,
-            round.sumFeeRewardPaid,
-            round.sumPnkRewardPaid,
-            round.feeToken
-        );
+    function getRoundInfo(uint256 _disputeID, uint256 _round) external view returns (Round memory) {
+        return disputes[_disputeID].rounds[_round];
     }
 
     function getNumberOfRounds(uint256 _disputeID) external view returns (uint256) {

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

@@ -562,10 +562,9 @@ contract DisputeKitClassic is BaseDisputeKit, IEvidence {
     /// @inheritdoc BaseDisputeKit
     function _postDrawCheck(uint256 _coreDisputeID, address _juror) internal view override returns (bool) {
         (uint96 courtID, , , , ) = core.disputes(_coreDisputeID);
-        (, uint256 lockedAmountPerJuror, , , , , , , , ) = core.getRoundInfo(
-            _coreDisputeID,
-            core.getNumberOfRounds(_coreDisputeID) - 1
-        );
+        uint256 lockedAmountPerJuror = core
+            .getRoundInfo(_coreDisputeID, core.getNumberOfRounds(_coreDisputeID) - 1)
+            .pnkAtStakePerJuror;
         (uint256 totalStaked, uint256 totalLocked, , ) = core.getJurorBalance(_juror, courtID);
         return totalStaked >= totalLocked + lockedAmountPerJuror;
     }

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

@@ -585,10 +585,9 @@ contract DisputeKitSybilResistant is BaseDisputeKit, IEvidence {
     /// @return Whether the address can be drawn or not.
     function _postDrawCheck(uint256 _coreDisputeID, address _juror) internal view override returns (bool) {
         (uint96 courtID, , , , ) = core.disputes(_coreDisputeID);
-        (, uint256 lockedAmountPerJuror, , , , , , , , ) = core.getRoundInfo(
-            _coreDisputeID,
-            core.getNumberOfRounds(_coreDisputeID) - 1
-        );
+        uint256 lockedAmountPerJuror = core
+            .getRoundInfo(_coreDisputeID, core.getNumberOfRounds(_coreDisputeID) - 1)
+            .pnkAtStakePerJuror;
         (uint256 totalStaked, uint256 totalLocked, , ) = core.getJurorBalance(_juror, courtID);
         if (totalStaked < totalLocked + lockedAmountPerJuror) {
             return false;

contracts/test/arbitration/draw.ts

@@ -203,6 +203,8 @@ describe("Draw Benchmark", async () => {
     };
     let countedDraws: CountedDraws;
     const expectFromDraw = async (drawTx: Promise<ContractTransaction>) => {
+      expect(await core.getRoundInfo(0, 0).then((round) => round.drawIterations)).to.equal(3);
+
       const tx = await (await drawTx).wait();
       expect(tx)
         .to.emit(core, "Draw")
@@ -261,7 +263,8 @@ describe("Draw Benchmark", async () => {
     };
 
     const expectFromDraw = async (drawTx: Promise<ContractTransaction>) => {
-      await expect(drawTx).to.not.emit(core, "Draw");
+      expect(await core.getRoundInfo(0, 0).then((round) => round.drawIterations)).to.equal(20);
+      expect(await drawTx).to.not.emit(core, "Draw");
     };
 
     const unstake = async (wallet: Wallet) => {
@@ -295,6 +298,8 @@ describe("Draw Benchmark", async () => {
     };
     let countedDraws: CountedDraws;
     const expectFromDraw = async (drawTx: Promise<ContractTransaction>) => {
+      expect(await core.getRoundInfo(0, 0).then((round) => round.drawIterations)).to.equal(3);
+
       const tx = await (await drawTx).wait();
       expect(tx)
         .to.emit(core, "Draw")
@@ -353,6 +358,8 @@ describe("Draw Benchmark", async () => {
     };
     let countedDraws: CountedDraws;
     const expectFromDraw = async (drawTx: Promise<ContractTransaction>) => {
+      expect(await core.getRoundInfo(0, 0).then((round) => round.drawIterations)).to.equal(3);
+
       const tx = await (await drawTx).wait();
       expect(tx)
         .to.emit(core, "Draw")