Merge pull request #1449 from keep-network/check-for-operator-stake-when-seizing

Check for operator stake when seizing

We to cover a scenario, when a seize amount is greater than 
the operator balance. In this case, we are zeroing balance and 
the balance become our new amount to be seized.

Author: pdyraga

contracts/solidity/contracts/StakeDelegatable.sol

@@ -1,5 +1,4 @@
 pragma solidity ^0.5.4;
-pragma solidity ^0.5.4;
 
 import "openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol";
 import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";

contracts/solidity/contracts/TokenStaking.sol

@@ -205,31 +205,42 @@ contract TokenStaking is StakeDelegatable {
      * @dev Seize provided token amount from every member in the misbehaved
      * operators array. The tattletale is rewarded with 5% of the total seized
      * amount scaled by the reward adjustment parameter and the rest 95% is burned.
-     * @param amount Token amount to seize from every misbehaved operator.
+     * @param amountToSeize Token amount to seize from every misbehaved operator.
      * @param rewardMultiplier Reward adjustment in percentage. Min 1% and 100% max.
      * @param tattletale Address to receive the 5% reward.
      * @param misbehavedOperators Array of addresses to seize the tokens from.
      */
     function seize(
-        uint256 amount,
+        uint256 amountToSeize,
         uint256 rewardMultiplier,
         address tattletale,
         address[] memory misbehavedOperators
     ) public onlyApprovedOperatorContract(msg.sender) {
+        uint256 totalAmountToBurn = 0;
         for (uint i = 0; i < misbehavedOperators.length; i++) {
             address operator = misbehavedOperators[i];
             require(authorizations[msg.sender][operator], "Not authorized");
+
             uint256 operatorParams = operators[operator].packedParams;
-            uint256 oldAmount = operatorParams.getAmount();
-            uint256 newAmount = oldAmount.sub(amount);
-            operators[operator].packedParams = operatorParams.setAmount(newAmount);
+            uint256 currentAmount = operatorParams.getAmount();
+
+            if (currentAmount < amountToSeize) {
+                totalAmountToBurn = totalAmountToBurn.add(currentAmount);
+
+                uint256 newAmount = 0;
+                operators[operator].packedParams = operatorParams.setAmount(newAmount);
+            } else {
+                totalAmountToBurn = totalAmountToBurn.add(amountToSeize);
+
+                uint256 newAmount = currentAmount.sub(amountToSeize);
+                operators[operator].packedParams = operatorParams.setAmount(newAmount);
+            }
         }
 
-        uint256 total = misbehavedOperators.length.mul(amount);
-        uint256 tattletaleReward = (total.mul(5).div(100)).mul(rewardMultiplier).div(100);
+        uint256 tattletaleReward = (totalAmountToBurn.mul(5).div(100)).mul(rewardMultiplier).div(100);
 
         token.safeTransfer(tattletale, tattletaleReward);
-        token.burn(total.sub(tattletaleReward));
+        token.burn(totalAmountToBurn.sub(tattletaleReward));
     }
 
     /**

contracts/solidity/test/TestKeepRandomBeaconOperatorSlashing.js

@@ -47,6 +47,10 @@ contract('KeepRandomBeaconOperator', function(accounts) {
 
     entryFeeEstimate = await serviceContract.entryFeeEstimate(0)
     await serviceContract.methods['requestRelayEntry()']({value: entryFeeEstimate})
+  
+    await registry.setRegistryKeeper(registryKeeper)
+    await registry.approveOperatorContract(anotherOperatorContract, {from: registryKeeper})
+    await stakingContract.authorizeOperatorContract(operator1, anotherOperatorContract, {from: authorizer})
   })
 
   beforeEach(async () => {
@@ -58,29 +62,67 @@ contract('KeepRandomBeaconOperator', function(accounts) {
   })
 
   it("should slash token amount", async () => {
-    await registry.setRegistryKeeper(registryKeeper)
-    await registry.approveOperatorContract(anotherOperatorContract, {from: registryKeeper})
-    await stakingContract.authorizeOperatorContract(operator1, anotherOperatorContract, {from: authorizer})
-
     let amountToSlash = web3.utils.toBN(42000000);
     let balanceBeforeSlashing = await stakingContract.balanceOf(operator1)
-    await stakingContract.slash(web3.utils.toBN(amountToSlash), [operator1], {from: anotherOperatorContract})
+    await stakingContract.slash(amountToSlash, [operator1], {from: anotherOperatorContract})
     let balanceAfterSlashing = await stakingContract.balanceOf(operator1)
 
     assert.isTrue((balanceBeforeSlashing.sub(amountToSlash)).eq(balanceAfterSlashing), "Unexpected balance after token slasing")
   })
 
   it("should slash no more than available operator's amount", async () => {
-    await registry.setRegistryKeeper(registryKeeper)
-    await registry.approveOperatorContract(anotherOperatorContract, {from: registryKeeper})
-    await stakingContract.authorizeOperatorContract(operator1, anotherOperatorContract, {from: authorizer})
-
     let amountToSlash = largeStake.add(web3.utils.toBN(100));
-    await stakingContract.slash(web3.utils.toBN(amountToSlash), [operator1], {from: anotherOperatorContract})
+    await stakingContract.slash(amountToSlash, [operator1], {from: anotherOperatorContract})
 
     assert.isTrue((await stakingContract.balanceOf(operator1)).isZero(), "Unexpected balance after token slasing")
   })
 
+  it("should seize token amount", async () => {
+    let operatorBalanceBeforeSeizing = await stakingContract.balanceOf(operator1)
+    let tattletaleBalanceBeforeSeizing = await token.balanceOf(tattletale)
+    
+    let amountToSeize = web3.utils.toBN(42000000);
+    let rewardMultiplier = web3.utils.toBN(25)
+    await stakingContract.seize(amountToSeize, rewardMultiplier, tattletale, [operator1], {from: anotherOperatorContract})
+    
+    let operatorBalanceAfterSeizing = await stakingContract.balanceOf(operator1)
+    let tattletaleBalanceAfterSeizing = await token.balanceOf(tattletale)
+    
+    assert.isTrue(
+      (operatorBalanceBeforeSeizing.sub(amountToSeize)).eq(operatorBalanceAfterSeizing), 
+      "Unexpected balance for operator after token seizing"
+    )
+
+    // 525000 = (42000000 * 5 / 100) * 25 / 100
+    let expectedTattletaleReward = web3.utils.toBN(525000)
+    assert.isTrue(
+      (tattletaleBalanceBeforeSeizing.add(expectedTattletaleReward)).eq(tattletaleBalanceAfterSeizing), 
+      "Unexpected balance for tattletale after token seizing"
+    )
+  })
+
+  it("should seize no more than available operator's amount", async () => {
+    let tattletaleBalanceBeforeSeizing = await token.balanceOf(tattletale)
+    
+    let amountToSeize = largeStake.add(web3.utils.toBN(100)); // 400000000000000000000100
+    let rewardMultiplier = web3.utils.toBN(10)
+    await stakingContract.seize(amountToSeize, rewardMultiplier, tattletale, [operator1], {from: anotherOperatorContract})
+    
+    let tattletaleBalanceAfterSeizing = await token.balanceOf(tattletale)
+      
+    assert.isTrue(
+      (await stakingContract.balanceOf(operator1)).isZero(), 
+      "Unexpected balance for operator after token seizing"
+    )
+    
+    // 2000000000000000000000 = (400000000000000000000100 * 5 / 100) * 10 / 100
+    let expectedTattletaleReward = web3.utils.toBN("2000000000000000000000")
+    assert.isTrue(
+      (tattletaleBalanceBeforeSeizing.add(expectedTattletaleReward)).eq(tattletaleBalanceAfterSeizing), 
+      "Unexpected balance for tattletale after token seizing"
+    )
+  })
+
   it("should be able to report unauthorized signing", async () => {
     await operatorContract.reportUnauthorizedSigning(
       groupIndex,