Update sample staking dapp

assets/bep-153/SampleStakingContract.sol

@@ -217,16 +217,18 @@ contract StakingDappExample {
   }
 
   // events
-  event Delegate(address indexed delegator, address indexed validator, uint256 amount);
-  event Undelegate(address indexed validator, uint256 amount);
-  event ClaimReward(address indexed delegator, uint256 amount);
-  event ClaimUndelegated(address indexed delegator, uint256 amount);
+  event Delegate(address indexed delegator, uint256 amount);
+  event DelegateSubmitted(address indexed validator, uint256 amount);
+  event Undelegate(address indexed delegator, uint256 amount);
+  event UndelegateSubmitted(address indexed validator, uint256 amount);
+  event RewardClaimed(address indexed delegator, uint256 amount);
+  event UndelegatedClaimed(address indexed delegator, uint256 amount);
   event RewardReceived(uint256 amount);
   event UndelegatedReceived(uint256 amount);
 
   receive() external payable {}
 
-  constructor() {
+  constructor() public {
     owner = msg.sender;
     operators[msg.sender] = true;
   }
@@ -259,6 +261,8 @@ contract StakingDappExample {
       totalStaked = totalStaked.add(amount);
       reserveUndelegated = reserveUndelegated.sub(amount);
     }
+
+    emit Delegate(msg.sender, amount);
   }
 
   // This function will not always submit delegation request to the staking system contract.
@@ -274,7 +278,7 @@ contract StakingDappExample {
     user.rewardDebt = user.amount.mul(poolInfo.rewardPerShare).sub(pendingReward);
 
     user.pendingUndelegated = user.pendingUndelegated.add(amount);
-    user.undelegateUnlockTime = block.timestamp.add(7*24*3600);
+    user.undelegateUnlockTime = block.timestamp.add(8*24*3600);
 
     amount = IStaking(STAKING_CONTRACT_ADDR).getMinDelegation();
     if (reserveUndelegated < amount) {
@@ -285,7 +289,11 @@ contract StakingDappExample {
     }
 
     totalReceived = totalReceived.sub(amount);
-    emit undelegateSubmitted(msg.sender, amount);
+    emit Undelegate(msg.sender, amount);
+  }
+
+  function getDelegated(address delegator) external view returns(uint256) {
+    return userInfo[delegator].amount;
   }
 
   function claimReward() external noReentrant {
@@ -297,9 +305,9 @@ contract StakingDappExample {
     if (reserveReward < pendingReward) {
       _claimReward();
     }
-    payable(msg.sender).transfer(pendingReward);
     user.rewardDebt = user.amount.mul(poolInfo.rewardPerShare);
-    emit rewardClaimed(msg.sender, pendingReward);
+    payable(msg.sender).transfer(pendingReward);
+    emit RewardClaimed(msg.sender, pendingReward);
   }
 
   function claimUndelegated() external noReentrant {
@@ -309,53 +317,55 @@ contract StakingDappExample {
     if (reserveUndelegated < user.pendingUndelegated) {
       _claimUndelegated();
     }
-    payable(msg.sender).transfer(user.pendingUndelegated);
     reserveUndelegated = reserveUndelegated.sub(user.pendingUndelegated);
     totalReceived = totalReceived.sub(user.pendingUndelegated);
     user.pendingUndelegated = 0;
-    emit undelegatedClaimed(msg.sender, user.pendingUndelegated);
+    payable(msg.sender).transfer(user.pendingUndelegated);
+    emit UndelegatedClaimed(msg.sender, user.pendingUndelegated);
   }
 
-  function getPendingReward() external view returns(uint256 pendingReward) {
-    UserInfo storage user = userInfo[msg.sender];
+  function getPendingReward(address delegator) external view returns(uint256 pendingReward) {
+    UserInfo memory user = userInfo[delegator];
     pendingReward = user.amount.mul(poolInfo.rewardPerShare).sub(user.rewardDebt);
   }
 
   /************************** Internal **************************/
-  function _getHighestYieldingValidator() internal pure returns(address highestYieldingValidator) {
+  function _getHighestYieldingValidator() internal pure returns(uint160 highestYieldingValidator) {
     // this function should return the desirable validator to delegate to
     // need to be implemented by the developer
-    highestYieldingValidator = address(0x1);
+    // use uint160 rather than address to prevent checksum error
+    highestYieldingValidator = uint160(0x001);
   }
 
-  function _getLowestYieldingValidator() internal pure returns(address lowestYieldingValidator) {
+  function _getLowestYieldingValidator() internal pure returns(uint160 lowestYieldingValidator) {
     // this function should return the desirable validator to undelegate from
     // need to be implemented by the developer
-    lowestYieldingValidator = address(0x2);
+    // use uint160 rather than address to prevent checksum error
+    lowestYieldingValidator = uint160(0x001);
   }
 
   function _delegate(uint256 amount, uint256 oracleRelayerFee) internal {
-    address validator = _getHighestYieldingValidator();
+    address validator = address(_getHighestYieldingValidator());
     IStaking(STAKING_CONTRACT_ADDR).delegate{value: amount.add(oracleRelayerFee)}(validator, amount);
-    emit delegateSubmitted(msg.sender, validator, amount);
+    emit DelegateSubmitted(validator, amount);
   }
 
   function _undelegate(uint256 amount, uint256 oracleRelayerFee) internal {
-    address validator = _getLowestYieldingValidator();
+    address validator = address(_getLowestYieldingValidator());
     IStaking(STAKING_CONTRACT_ADDR).undelegate{value: oracleRelayerFee}(validator, amount);
-    emit undelegateSubmitted(validator, amount);
+    emit UndelegateSubmitted(validator, amount);
   }
 
   function _claimReward() internal {
     uint256 amount = IStaking(STAKING_CONTRACT_ADDR).claimReward();
     totalReward = totalReward.add(amount);
     reserveReward = reserveReward.add(amount);
-    emit rewardReceived(amount);
+    emit RewardReceived(amount);
   }
 
   function _claimUndelegated() internal {
     uint256 amount = IStaking(STAKING_CONTRACT_ADDR).claimUndeldegated();
-    emit undelegatedReceived(amount);
+    emit UndelegatedReceived(amount);
   }
 
   function _updatePool() internal {