fix: reimbursement and fee withdrawal

Author: eccentricexit

.vscode/launch.json

@@ -65,10 +65,11 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
     }
 
     struct Round {
-        uint[3] paidFees; // Tracks the fees paid for each Party in this round.
+        uint[3] amountPaid; // Tracks the sum for each Party in this round. Includes arbitration fees, fee stakes and deposits.
         bool[3] hasPaid; // True if the Party has fully paid its fee in this round.
         uint feeRewards; // Sum of reimbursable fees and stake rewards available to the parties that made contributions to the side that ultimately wins a dispute.
         mapping(address => uint[3]) contributions; // Maps contributors to their contributions for each side.
+        uint[3] paidArbitrationFees; // The arbitration or appeal fees paid for each party.
     }
 
     struct RequestID {
@@ -297,8 +298,9 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
             : removalChallengeBaseDeposit;
         uint totalCost = arbitrationCost.addCap(challengerBaseDeposit);
         contribute(round, Party.Challenger, msg.sender, msg.value, totalCost);
-        require(round.paidFees[uint(Party.Challenger)] >= totalCost, "You must fully fund your side.");
+        require(round.amountPaid[uint(Party.Challenger)] >= totalCost, "You must fully fund your side.");
         round.hasPaid[uint(Party.Challenger)] = true;
+        round.paidArbitrationFees[uint(Party.Challenger)] = arbitrationCost;
 
         // Raise a dispute.
         request.disputeID = request.arbitrator.createDispute.value(arbitrationCost)(RULING_OPTIONS, request.arbitratorExtraData);
@@ -364,6 +366,7 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         uint appealCost = request.arbitrator.appealCost(request.disputeID, request.arbitratorExtraData);
         uint totalCost = appealCost.addCap((appealCost.mulCap(multiplier)) / MULTIPLIER_DIVISOR);
         uint contribution = contribute(round, _side, msg.sender, msg.value, totalCost);
+        round.paidArbitrationFees[uint(_side)] += appealCost;
 
         emit AppealContribution(
             _itemID,
@@ -374,7 +377,7 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
             _side
         );
 
-        if (round.paidFees[uint(_side)] >= totalCost) {
+        if (round.amountPaid[uint(_side)] >= totalCost) {
             round.hasPaid[uint(_side)] = true;
             emit HasPaidAppealFee(_itemID, items[_itemID].requests.length - 1, request.rounds.length - 1, _side);
         }
@@ -403,20 +406,48 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         if (!round.hasPaid[uint(Party.Requester)] || !round.hasPaid[uint(Party.Challenger)]) {
             // Reimburse if not enough fees were raised to appeal the ruling.
             reward = round.contributions[_beneficiary][uint(Party.Requester)] + round.contributions[_beneficiary][uint(Party.Challenger)];
+        } else if (
+            request.ruling == Party.None &&
+            _round == 0
+        ) {
+            if (
+                _beneficiary != request.parties[uint(Party.Requester)] &&
+                _beneficiary != request.parties[uint(Party.Challenger)]
+            ) return;
+
+            uint side = _beneficiary == request.parties[uint(Party.Requester)] ? 1 : 2;
+            if (round.contributions[_beneficiary][side] == 0) return;
+
+            // The first round is special since it does not include crowdfunding fees,
+            // or stake multipliers. The only participants are the requester and challenger.
+            //
+            // Arbitration costs can rise or fall between when a request was made and when it was
+            // challenged. To keep things fair, we reimburse proportionally to the amount
+            // contributed.
+            reward = round.contributions[_beneficiary][side].subCap(round.paidArbitrationFees[side]); // Base deposit.
+            uint arbitrationFeesSide = round.paidArbitrationFees[side];
+            uint totalArbitrationFeesPaid = round.paidArbitrationFees[uint(Party.Requester)] + round.paidArbitrationFees[uint(Party.Requester)];
+
+            // Reimbursable fees are total amount paid minus the amount paid by the challenger
+            // because the amount paid by the challenger is the actual cost of the round.
+            uint reimbursableFeesAvailable = totalArbitrationFeesPaid - round.paidArbitrationFees[uint(Party.Challenger)];
+
+            reward += arbitrationFeesSide * reimbursableFeesAvailable / totalArbitrationFeesPaid;
+
         } else if (request.ruling == Party.None) {
             // Reimburse unspent fees proportionally if there is no winner or loser.
-            uint rewardRequester = round.paidFees[uint(Party.Requester)] > 0
-                ? (round.contributions[_beneficiary][uint(Party.Requester)] * round.feeRewards) / (round.paidFees[uint(Party.Challenger)] + round.paidFees[uint(Party.Requester)])
+            uint rewardRequester = round.amountPaid[uint(Party.Requester)] > 0
+                ? (round.contributions[_beneficiary][uint(Party.Requester)] * round.feeRewards) / (round.amountPaid[uint(Party.Challenger)] + round.amountPaid[uint(Party.Requester)])
                 : 0;
-            uint rewardChallenger = round.paidFees[uint(Party.Challenger)] > 0
-                ? (round.contributions[_beneficiary][uint(Party.Challenger)] * round.feeRewards) / (round.paidFees[uint(Party.Challenger)] + round.paidFees[uint(Party.Requester)])
+            uint rewardChallenger = round.amountPaid[uint(Party.Challenger)] > 0
+                ? (round.contributions[_beneficiary][uint(Party.Challenger)] * round.feeRewards) / (round.amountPaid[uint(Party.Challenger)] + round.amountPaid[uint(Party.Requester)])
                 : 0;
 
             reward = rewardRequester + rewardChallenger;
         } else {
             // Reward the winner.
-            reward = round.paidFees[uint(request.ruling)] > 0
-                ? (round.contributions[_beneficiary][uint(request.ruling)] * round.feeRewards) / round.paidFees[uint(request.ruling)]
+            reward = round.amountPaid[uint(request.ruling)] > 0
+                ? (round.contributions[_beneficiary][uint(request.ruling)] * round.feeRewards) / round.amountPaid[uint(request.ruling)]
                 : 0;
 
         }
@@ -624,8 +655,9 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         uint arbitrationCost = request.arbitrator.arbitrationCost(request.arbitratorExtraData);
         uint totalCost = arbitrationCost.addCap(_baseDeposit);
         contribute(round, Party.Requester, msg.sender, msg.value, totalCost);
-        require(round.paidFees[uint(Party.Requester)] >= totalCost, "You must fully fund your side.");
+        require(round.amountPaid[uint(Party.Requester)] >= totalCost, "You must fully fund your side.");
         round.hasPaid[uint(Party.Requester)] = true;
+        round.paidArbitrationFees[uint(Party.Requester)] = arbitrationCost;
 
         emit ItemStatusChange(itemID, item.requests.length - 1, request.rounds.length - 1, false, false);
         emit RequestSubmitted(itemID, item.requests.length - 1, item.status);
@@ -660,9 +692,9 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         // Take up to the amount necessary to fund the current round at the current costs.
         uint contribution; // Amount contributed.
         uint remainingETH; // Remaining ETH to send back.
-        (contribution, remainingETH) = calculateContribution(_amount, _totalRequired.subCap(_round.paidFees[uint(_side)]));
+        (contribution, remainingETH) = calculateContribution(_amount, _totalRequired.subCap(_round.amountPaid[uint(_side)]));
         _round.contributions[_contributor][uint(_side)] += contribution;
-        _round.paidFees[uint(_side)] += contribution;
+        _round.amountPaid[uint(_side)] += contribution;
         _round.feeRewards += contribution;
 
         // Reimburse leftover ETH.
@@ -699,7 +731,7 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
 
         emit ItemStatusChange(itemID, item.requests.length - 1, request.rounds.length - 1, true, true);
 
-        // Automatically withdraw.
+        // Automatically withdraw first deposits and reimbursements (first round only).
         if (winner == Party.None) {
             withdrawFeesAndRewards(request.parties[uint(Party.Requester)], itemID, item.requests.length - 1, 0);
             withdrawFeesAndRewards(request.parties[uint(Party.Challenger)], itemID, item.requests.length - 1, 0);
@@ -808,7 +840,7 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         view
         returns (
             bool appealed,
-            uint[3] memory paidFees,
+            uint[3] memory amountPaid,
             bool[3] memory hasPaid,
             uint feeRewards
         )
@@ -818,7 +850,7 @@ contract GeneralizedTCR is IArbitrable, IEvidence {
         Round storage round = request.rounds[_round];
         return (
             _round != (request.rounds.length - 1),
-            round.paidFees,
+            round.amountPaid,
             round.hasPaid,
             round.feeRewards
         );