Merge pull request #86 from uprendis/feature/fix-tests-2.0.1-rc3

fix tests 2.0.1 rc3

Author: quan8

README.md

@@ -35,43 +35,51 @@ Using network 'test'.
 
 Compiling your contracts...
 ===========================
-> Compiling ./contracts/SafeMath.sol
-> Compiling ./contracts/Staker.sol
+> Compiling ./contracts/ownership/Ownable.sol
+> Compiling ./contracts/sfc/Migrations.sol
+> Compiling ./contracts/sfc/SafeMath.sol
+> Compiling ./contracts/sfc/Staker.sol
+> Compiling ./contracts/sfc/StakerConstants.sol
+> Compiling ./contracts/test/LegacyStaker.sol
+> Compiling ./contracts/test/UnitTestStakers.sol
+> Compiling ./contracts/upgradeability/Address.sol
+> Compiling ./contracts/upgradeability/BaseUpgradeabilityProxy.sol
+> Compiling ./contracts/upgradeability/Proxy.sol
+> Compiling ./contracts/upgradeability/UpgradeabilityProxy.sol
+> Compiling ./contracts/version/Version.sol
 
 
 
   Contract: SFC
-    Delegation migration tests
-        gas used for sfc deploying: 4915131
-      ✓ should auto migrate legacy deposition to new model (1699ms)
-      ✓ should manually migrate legacy deposition to new model (272ms)
-      ✓ should not call calcDelegationRewards while delegation is in the legacy model (404ms)
+    Locking stake tests
+      ✓ should start "locked stake" feature (736ms)
+      ✓ should calc raw ValidatorEpochReward correctly after locked up started (1076ms)
+      ✓ should lock stake (1208ms)
+      ✓ should lock stake with right duration (513ms)
+      ✓ should not call prepareToWithdrawStake, until locked time is pass (455ms)
+      ✓ should not call prepareToWithdrawStakePartial, until locked time is pass (477ms)
+      ✓ should lock delegation (1427ms)
+      ✓ should lock delegation with right duration (758ms)
+      ✓ should subtract penalty if prepareToWithdrawDelegation will call earlier than locked time is pass (842ms)
+      ✓ should subtract penalty if prepareToWithdrawDelegationPartial will call earlier than locked time is pass (886ms)
 
   Contract: SFC
     Methods tests
-      ✓ checking Staker parameters (127ms)
-      ✓ checking createStake function (521ms)
-      ✓ checking increaseStake function (316ms)
-      ✓ checking createDelegation function (473ms)
-      ✓ checking createDelegation function to several stakers (581ms)
-      ✓ checking calcRawValidatorEpochReward function (385ms)
-      ✓ checking epoch snapshot logic (148ms)
-      ✓ checking calcValidatorEpochReward function (484ms)
-      ✓ checking calcDelegationEpochReward function (462ms)
-      ✓ checking claimDelegationRewards function (703ms)
+      ✓ checking Staker parameters (165ms)
+      ✓ checking createStake function (525ms)
+      ✓ checking increaseStake function (249ms)
+      ✓ checking createDelegation function (436ms)
+      ✓ checking calcRawValidatorEpochReward function (363ms)
+      ✓ checking epoch snapshot logic (163ms)
+      ✓ checking calcValidatorEpochReward function (453ms)
+      ✓ checking calcDelegationEpochReward function (418ms)
+      ✓ checking claimDelegationRewards function (647ms)
       ✓ checking bonded ratio (107ms)
-      ✓ checking claimValidatorRewards function (419ms)
-      ✓ checking prepareToWithdrawStake function (272ms)
-      ✓ checking withdrawStake function (903ms)
-      ✓ checking prepareToWithdrawDelegation function (364ms)
-      ✓ checking withdrawDelegation function (1498ms)
-    Locked stake tests
-      ✓ should start "locked stake" feature (352ms)
-      ✓ should calc raw ValidatorEpochReward correctly after locked up started (980ms)
-      ✓ should lock stake (2200ms)
-      ✓ should lock stake with right duration (505ms)
-      ✓ should not call prepareToWithdrawStake, until locked time is pass (441ms)
-      ✓ should not call prepareToWithdrawStakePartial, until locked time is pass (447ms)
+      ✓ checking claimValidatorRewards function (388ms)
+      ✓ checking prepareToWithdrawStake function (198ms)
+      ✓ checking withdrawStake function (922ms)
+      ✓ checking prepareToWithdrawDelegation function (330ms)
+      ✓ checking withdrawDelegation function (1497ms)
 
 
   25 passing (18s)

contracts/test/UnitTestStakers.sol

@@ -141,7 +141,7 @@ contract UnitTestStakers is Stakers {
         return rewards.unlockedReward + rewards.lockupBaseReward + rewards.lockupExtraReward;
     }
 
-    function calcDelegationEpochReward(address delegator, uint256 stakerID, uint256 epoch, uint256 delegationAmount, uint256 commission) external view returns (uint256) {
+    function calcDelegationEpochReward(address delegator, uint256 stakerID, uint256 epoch, uint256, uint256 commission) external view returns (uint256) {
         _RewardsSet memory rewards = _calcDelegationEpochReward(delegator, stakerID, epoch, commission);
         return rewards.unlockedReward + rewards.lockupBaseReward + rewards.lockupExtraReward;
     }
@@ -156,7 +156,7 @@ contract UnitTestStakers is Stakers {
         stakers[stakerID].paidUntilEpoch = currentSealedEpoch;
     }
 
-    function discardDelegationRewards(uint256 stakerID) public {
+    function discardDelegationRewards(uint256) public {
         if (delegations[msg.sender].amount != 0) {
             delegations[msg.sender].paidUntilEpoch = currentSealedEpoch;
         }/* else if (delegations_v2[msg.sender][stakerID].amount != 0) {

test/StakeLocking.js

@@ -8,7 +8,8 @@ const {
 const {expect} = require('chai');
 
 const UnitTestStakers = artifacts.require('UnitTestStakers');
-const getDeposition = async (depositor, to) => this.stakers.delegations_v2.call(depositor, to);
+//const getDeposition = async (depositor, to) => this.stakers.delegations_v2.call(depositor, to);
+const getDeposition = async (depositor, to) => this.stakers.delegations.call(depositor);
 const getStaker = async (stakerID) => this.stakers.stakers.call(stakerID);
 
 contract('SFC', async ([firstStaker, secondStaker, thirdStaker, firstDepositor, secondDepositor, thirdDepositor]) => {
@@ -453,18 +454,29 @@ contract('SFC', async ([firstStaker, secondStaker, thirdStaker, firstDepositor,
       await this.stakers.lockUpDelegation(duration, firstStakerID, { from: firstDepositor });
       await this.stakers.lockUpDelegation(duration, firstStakerID, { from: secondDepositor });
       await this.stakers.makeEpochSnapshots(10000, false); // epoch #3
-      await this.stakers.discardDelegationRewards(firstStakerID, {from: firstDepositor});
-      await this.stakers.discardDelegationRewards(firstStakerID, {from: secondDepositor});
-      /*time.increase(86400 * 14 - 2);
+
+      await this.stakers.claimDelegationRewards(2, {from: firstDepositor});
+      const penaltyNonLocked = await this.stakers.calcDelegationPenalty(firstDepositor, firstStakerID, ether('1.0'));
+      expect(penaltyNonLocked).to.be.bignumber.equal(ether('0.0')); // penalty must be zero for non-lockup epochs
+
+      const reward = await this.stakers.calcDelegationRewards(firstDepositor, 0, 1);
+      expect(reward[0]).to.be.bignumber.equal(ether('0.000000070833333333'));
+      await this.stakers.claimDelegationRewards(100, {from: firstDepositor});
+      await this.stakers.claimDelegationRewards(100, {from: secondDepositor});
       const penalty = await this.stakers.calcDelegationPenalty(firstDepositor, firstStakerID, ether('1.0'));
-      expect(penalty).to.be.bignumber.equal(ether('0.000000068958333333'));
-      await this.stakers.prepareToWithdrawDelegation(firstStakerID, { from: firstDepositor });
+      expect(penalty).to.be.bignumber.equal(ether('0.000000060208333333')); // (50% of base reward + 100% of extra reward) * 1.0 FTM / 1.0 FTM
+
+      time.increase(86400 * 14 - 2); // not unlocked yet
+
+      await this.stakers.prepareToWithdrawDelegation({ from: firstDepositor });
       const firstDeposition = await getDeposition(firstDepositor, firstStakerID);
       expect(firstDeposition.amount).to.be.bignumber.equal(ether('1.0').sub(penalty));
-      time.increase(3);
-      await this.stakers.prepareToWithdrawDelegation(firstStakerID, { from: secondDepositor });
+
+      time.increase(3); // after lockup
+
+      await this.stakers.prepareToWithdrawDelegation({ from: secondDepositor });
       const secondDeposition = await getDeposition(secondDepositor, firstStakerID);
-      expect(secondDeposition.amount).to.be.bignumber.equal(ether('1.0'));*/
+      expect(secondDeposition.amount).to.be.bignumber.equal(ether('1.0'));
     });
 
     it('should subtract penalty if prepareToWithdrawDelegationPartial will call earlier than locked time is pass', async () => {
@@ -486,19 +498,35 @@ contract('SFC', async ([firstStaker, secondStaker, thirdStaker, firstDepositor,
       await this.stakers.lockUpDelegation(duration, firstStakerID, { from: firstDepositor });
       await this.stakers.lockUpDelegation(duration, firstStakerID, { from: secondDepositor });
       await this.stakers.makeEpochSnapshots(10000, false); // epoch #3
-      await this.stakers.discardDelegationRewards(firstStakerID, {from: firstDepositor});
-      await this.stakers.discardDelegationRewards(firstStakerID, {from: secondDepositor});
-      /*time.increase(86400 * 14 - 2);
+
+      await this.stakers.claimDelegationRewards(2, {from: firstDepositor});
+      const penaltyNonLocked = await this.stakers.calcDelegationPenalty(firstDepositor, firstStakerID, ether('1.0'));
+      expect(penaltyNonLocked).to.be.bignumber.equal(ether('0.0')); // penalty must be zero for non-lockup epochs
+
+      const reward = await this.stakers.calcDelegationRewards(firstDepositor, 0, 1);
+      expect(reward[0]).to.be.bignumber.equal(ether('0.000000070833333333'));
+      await this.stakers.claimDelegationRewards(100, {from: firstDepositor});
+      await this.stakers.claimDelegationRewards(100, {from: secondDepositor});
       const penalty = await this.stakers.calcDelegationPenalty(firstDepositor, firstStakerID, ether('1.0'));
-      expect(penalty).to.be.bignumber.equal(ether('0.000000034479166666')); // 50% for reward
-      const wrID = new BN('1');
-      await this.stakers.prepareToWithdrawDelegationPartial(wrID, firstStakerID, ether('1.0'), { from: firstDepositor });
+      expect(penalty).to.be.bignumber.equal(ether('0.000000030104166666')); // (50% of base reward + 100% of extra reward) * 1.0 FTM / 2.0 FTM
+
+      time.increase(86400 * 14 - 2); // not unlocked yet
+
+      const wrID1 = new BN('1');
+      await this.stakers.prepareToWithdrawDelegationPartial(wrID1, ether('1.0'), { from: firstDepositor });
       const firstDeposition = await getDeposition(firstDepositor, firstStakerID);
-      expect(firstDeposition.amount).to.be.bignumber.equal(ether('1.0').sub(penalty));
-      time.increase(3);
-      await this.stakers.prepareToWithdrawDelegationPartial(wrID.add(new BN('1')), firstStakerID, ether('1.0'), { from: secondDepositor });
+      const firstRequest = await this.stakers.withdrawalRequests(firstDepositor, wrID1);
+      expect(firstDeposition.amount).to.be.bignumber.equal(ether('1.0'));
+      expect(firstRequest.amount).to.be.bignumber.equal(ether('1.0').sub(penalty));
+
+      time.increase(3); // after lockup
+
+      const wrID2 = new BN('2');
+      await this.stakers.prepareToWithdrawDelegationPartial(wrID2, ether('1.0'), { from: secondDepositor });
       const secondDeposition = await getDeposition(secondDepositor, firstStakerID);
-      expect(secondDeposition.amount).to.be.bignumber.equal(ether('1.0'));*/
+      const secondRequest = await this.stakers.withdrawalRequests(secondDepositor, wrID2);
+      expect(secondDeposition.amount).to.be.bignumber.equal(ether('1.0'));
+      expect(secondRequest.amount).to.be.bignumber.equal(ether('1.0'));
     });
   });
 });