Merge pull request #21 from ironbeer/dev/mod-stakemanager

Updated StakeManager

contracts/IStakeManager.sol

@@ -14,12 +14,17 @@ interface IStakeManager {
      * Events *
      **********/
 
+    event AddedRewardBalance(uint256 amount);
+    event ValidatorJoined(address validator);
     event ValidatorActivated(address indexed validator, uint256[] epochs);
     event ValidatorDeactivated(address indexed validator, uint256[] epochs);
     event ValidatorSlashed(address indexed validator);
     event ValidatorJailed(address indexed validator, uint256 until);
+    event OperatorUpdated(address indexed validator, address oldOperator, address newOperator);
     event Staked(address indexed staker, address indexed validator, Token.Type token, uint256 amount);
     event Unstaked(address indexed staker, address indexed validator, Token.Type token, uint256 amount);
+    event ClaimedCommissions(address indexed validator, uint256 amount);
+    event ClaimedRewards(address indexed staker, address validator, uint256 amount);
 
     /***********
      * Structs *
@@ -64,6 +69,11 @@ interface IStakeManager {
         mapping(address => uint256) lastClaimReward;
     }
 
+    /**
+     * Add reward balance.
+     */
+    function addRewardBalance() external payable;
+
     /****************************
      * Functions for Validators *
      ****************************/

contracts/StakeManager.sol

@@ -130,6 +130,13 @@ contract StakeManager is IStakeManager, System {
         _;
     }
 
+    /**
+     * @inheritdoc IStakeManager
+     */
+    function addRewardBalance() external payable {
+        emit AddedRewardBalance(msg.value);
+    }
+
     /****************************
      * Functions for Validators *
      ****************************/
@@ -162,21 +169,31 @@ contract StakeManager is IStakeManager, System {
      * @inheritdoc IStakeManager
      */
     function joinValidator(address operator) external {
-        if (!allowlist.containsAddress(msg.sender)) {
+        address owner = msg.sender;
+        if (!allowlist.containsAddress(owner)) {
             revert UnauthorizedValidator();
         }
 
-        validators[msg.sender].join(operator);
-        validatorOwners.push(msg.sender);
-        operatorToOwner[operator] = msg.sender;
+        validators[owner].join(operator);
+        validatorOwners.push(owner);
+        operatorToOwner[operator] = owner;
+
+        emit ValidatorJoined(owner);
     }
 
     /**
      * @inheritdoc IStakeManager
      */
     function updateOperator(address operator) external validatorExists(msg.sender) {
-        validators[msg.sender].updateOperator(operator);
-        operatorToOwner[operator] = msg.sender;
+        address owner = msg.sender;
+
+        Validator storage validator = validators[owner];
+        address oldOperator = validator.operator;
+
+        validator.updateOperator(operator);
+        operatorToOwner[operator] = owner;
+
+        emit OperatorUpdated(owner, oldOperator, operator);
     }
 
     /**
@@ -209,7 +226,8 @@ contract StakeManager is IStakeManager, System {
      * @inheritdoc IStakeManager
      */
     function claimCommissions(address validator, uint256 epochs) external validatorExists(validator) {
-        validators[validator].claimCommissions(environment, epochs);
+        uint256 amount = validators[validator].claimCommissions(environment, epochs);
+        emit ClaimedCommissions(validator, amount);
     }
 
     /************************
@@ -269,7 +287,8 @@ contract StakeManager is IStakeManager, System {
         address validator,
         uint256 epochs
     ) external validatorExists(validator) stakerExists(staker) {
-        stakers[staker].claimRewards(environment, validators[validator], epochs);
+        uint256 amount = stakers[staker].claimRewards(environment, validators[validator], epochs);
+        emit ClaimedRewards(staker, validator, amount);
     }
 
     /******************

contracts/lib/Staker.sol

@@ -76,12 +76,13 @@ library Staker {
         IEnvironment environment,
         IStakeManager.Validator storage validator,
         uint256 epochs
-    ) internal {
+    ) internal returns (uint256) {
         (uint256 rewards, uint256 lastClaim) = getRewards(staker, environment, validator, epochs);
         staker.lastClaimReward[validator.owner] = lastClaim;
         if (rewards > 0) {
             Token.transfers(Token.Type.OAS, staker.signer, rewards);
         }
+        return rewards;
     }
 
     function claimUnstakes(IStakeManager.Staker storage staker, IEnvironment environment) internal {

contracts/lib/Validator.sol

@@ -86,12 +86,13 @@ library Validator {
         IStakeManager.Validator storage validator,
         IEnvironment environment,
         uint256 epochs
-    ) internal {
+    ) internal returns (uint256) {
         (uint256 commissions, uint256 lastClaim) = getCommissions(validator, environment, epochs);
         validator.lastClaimCommission = lastClaim;
         if (commissions > 0) {
             Token.transfers(Token.Type.OAS, validator.owner, commissions);
         }
+        return commissions;
     }
 
     function slash(

test/StakeManager.spec.ts

@@ -14,6 +14,7 @@ import {
   WOASAddress,
   SOASAddress,
   TestERC20Bytecode,
+  toBNWei,
 } from './helpers'
 
 const initialEnv: EnvironmentValue = {
@@ -213,6 +214,20 @@ describe('StakeManager', () => {
     await expect(initialize()).to.revertedWith('AlreadyInitialized()')
   })
 
+  it('addRewardBalance()', async () => {
+    const check = async (exp: string) => {
+      const actual = await stakeManager.provider.getBalance(stakeManager.address)
+      expect(fromWei(actual.toString())).to.equal(exp)
+    }
+
+    await check('0')
+
+    const tx = await stakeManager.addRewardBalance({ value: toWei('1') })
+    await check('1')
+
+    await expect(tx).to.emit(stakeManager, 'AddedRewardBalance').withArgs(toWei('1'))
+  })
+
   describe('validator owner or operator functions', () => {
     let validator: Validator
     let owner: Account
@@ -242,7 +257,9 @@ describe('StakeManager', () => {
       tx = validator.joinValidator(owner.address)
       await expect(tx).to.revertedWith('SameAsOwner()')
 
-      await validator.joinValidator()
+      await expect(await validator.joinValidator())
+        .to.emit(stakeManager, 'ValidatorJoined')
+        .withArgs(validator.owner.address)
 
       tx = validator.joinValidator()
       await expect(tx).to.revertedWith('AlreadyJoined()')
@@ -261,7 +278,9 @@ describe('StakeManager', () => {
       await expect(tx).to.revertedWith('SameAsOwner()')
 
       // from owner
-      await validator.updateOperator(newOperator.address)
+      await expect(await validator.updateOperator(newOperator.address))
+        .to.emit(stakeManager, 'OperatorUpdated')
+        .withArgs(validator.owner.address, validator.operator.address, newOperator.address)
       expect((await validator.getInfo()).operator).to.equal(newOperator.address)
 
       // from operator
@@ -400,7 +419,9 @@ describe('StakeManager', () => {
       await toNextEpoch()
 
       // from owner
-      await validator.claimCommissions(owner)
+      await expect(await validator.claimCommissions(owner))
+        .to.emit(stakeManager, 'ClaimedCommissions')
+        .withArgs(validator.owner.address, toBNWei('0.005707762557077625'))
       await expectBalance(stakeManager, '499.994292237442922375', '250', '250')
       await expectBalance(validator.owner, '10000.005707762557077625', '0', '0')
 
@@ -941,7 +962,9 @@ describe('StakeManager', () => {
       await staker2.expectRewards('0.17408675', validator1, 99)
       await validator1.expectCommissions('0.21347031', 99)
 
-      await staker1.claimRewards(validator1, 5)
+      await expect(await staker1.claimRewards(validator1, 5))
+        .to.emit(stakeManager, 'ClaimedRewards')
+        .withArgs(staker1.address, validator1.owner.address, toBNWei('0.069063926940639267'))
       await staker2.claimRewards(validator1, 5)
       await validator1.claimCommissions(undefined, 5)