vacp2p/staking-reward-streamer
1
0
Fork 0
mirror of https://github.com/vacp2p/staking-reward-streamer.git synced 2026-01-08 04:33:52 -05:00
Code Issues Packages Projects Releases Wiki Activity

# This is a combination of 6 commits.

Browse Source 
# This is the 1st commit message:

feat(RewardsStreamerMP.t): improve fuzz tests to test revert cases

fix(StakeMath): prevent uint256 overflow error
fix(StakeMath): prevent unstaking zero

# This is the commit message #2:

fix(StakeMath): prevent unstaking zero

# This is the commit message #3:

refactor(fuzz-tests): enhance readibility + test for unstake

# This is the commit message #4:

chore(tests): add compoud fuzz test

# This is the commit message #5:

chore(tests): Add Compound Fuzz Test

# This is the commit message #6:

chore (tests): fix fuzz test Unstake to always call compound function before unstake.
This commit is contained in:
Ricardo Guilherme Schmidt
2025-03-10 12:24:32 -03:00
committed by r4bbit
parent 14eaf35091
commit 400923aed0
4 changed files with 567 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
.gas-report
View File

@@ -10,7 +10,7 @@
|-------------------------------------------------------------------------------------------+-----------------+--------+--------+--------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|-------------------------------------------------------------------------------------------+-----------------+--------+--------+--------+---------|
| fallback | 746 | 132207 | 190939 | 190987 | 517 |
| fallback | 746 | 132057 | 189609 | 190987 | 518 |
╰-------------------------------------------------------------------------------------------+-----------------+--------+--------+--------+---------╯
╭-----------------------------------------------------+-----------------+---------+---------+---------+---------╮
@@ -18,13 +18,13 @@
+===============================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|-----------------------------------------------------+-----------------+---------+---------+---------+---------|
| 4821705 | 23344 | | | | |
| 4816329 | 23319 | | | | |
|-----------------------------------------------------+-----------------+---------+---------+---------+---------|
| | | | | | |
|-----------------------------------------------------+-----------------+---------+---------+---------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|-----------------------------------------------------+-----------------+---------+---------+---------+---------|
| run | 4020680 | 4020680 | 4020680 | 4020680 | 119 |
| run | 4015668 | 4015668 | 4015668 | 4015668 | 120 |
╰-----------------------------------------------------+-----------------+---------+---------+---------+---------╯
╭-----------------------------------------------------------+-----------------+---------+---------+---------+---------╮
@@ -46,13 +46,13 @@
+=======================================================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|-----------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| 8500228 | 40524 | | | | |
| 8542904 | 40726 | | | | |
|-----------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| | | | | | |
|-----------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|-----------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| run | 7413708 | 7413708 | 7413708 | 7413708 | 94 |
| run | 7454205 | 7454205 | 7454205 | 7454205 | 95 |
╰-----------------------------------------------------------------------------+-----------------+---------+---------+---------+---------╯
╭---------------------------------------------------------+-----------------+-----+--------+-----+---------╮
@@ -66,7 +66,7 @@
|---------------------------------------------------------+-----------------+-----+--------+-----+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|---------------------------------------------------------+-----------------+-----+--------+-----+---------|
| activeNetworkConfig | 597 | 597 | 597 | 597 | 347 |
| activeNetworkConfig | 597 | 597 | 597 | 597 | 350 |
╰---------------------------------------------------------+-----------------+-----+--------+-----+---------╯
╭-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------╮
@@ -74,13 +74,13 @@
+=========================================================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| 5950692 | 28615 | | | | |
| 5993348 | 28817 | | | | |
|-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| | | | | | |
|-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------|
| runWithAdminAndProxy | 3376570 | 3376570 | 3376570 | 3376570 | 3 |
| runWithAdminAndProxy | 3417066 | 3417066 | 3417066 | 3417066 | 3 |
╰-------------------------------------------------------------------------------+-----------------+---------+---------+---------+---------╯
╭------------------------------+-----------------+--------+--------+--------+---------╮
@@ -88,29 +88,29 @@
+=====================================================================================+
| Deployment Cost | Deployment Size | | | | |
|------------------------------+-----------------+--------+--------+--------+---------|
| 0 | 10047 | | | | |
| 0 | 10022 | | | | |
|------------------------------+-----------------+--------+--------+--------+---------|
| | | | | | |
|------------------------------+-----------------+--------+--------+--------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|------------------------------+-----------------+--------+--------+--------+---------|
| acceptOwnership | 12020 | 12020 | 12020 | 12020 | 1 |
| acceptOwnership | 12042 | 12042 | 12042 | 12042 | 1 |
|------------------------------+-----------------+--------+--------+--------+---------|
| addRewardDistributor | 2589 | 65629 | 70586 | 70586 | 155 |
| addRewardDistributor | 2589 | 65661 | 70586 | 70586 | 156 |
|------------------------------+-----------------+--------+--------+--------+---------|
| allowance | 482 | 482 | 482 | 482 | 3 |
|------------------------------+-----------------+--------+--------+--------+---------|
| approve | 419 | 419 | 419 | 419 | 3 |
|------------------------------+-----------------+--------+--------+--------+---------|
| balanceOf | 4019 | 11685 | 10019 | 21019 | 9 |
| balanceOf | 4041 | 11707 | 10041 | 21041 | 9 |
|------------------------------+-----------------+--------+--------+--------+---------|
| getRewardDistributors | 1140 | 3384 | 3384 | 5628 | 6 |
| getRewardDistributors | 1162 | 3406 | 3406 | 5650 | 6 |
|------------------------------+-----------------+--------+--------+--------+---------|
| initialize | 95872 | 95872 | 95872 | 95872 | 119 |
| initialize | 95872 | 95872 | 95872 | 95872 | 120 |
|------------------------------+-----------------+--------+--------+--------+---------|
| mint | 2654 | 58515 | 74916 | 74916 | 18 |
| mint | 2654 | 56378 | 72352 | 72352 | 18 |
|------------------------------+-----------------+--------+--------+--------+---------|
| mintAllowance | 7286 | 7322 | 7322 | 7359 | 2 |
| mintAllowance | 6722 | 6758 | 6758 | 6795 | 2 |
|------------------------------+-----------------+--------+--------+--------+---------|
| owner | 363 | 1029 | 363 | 2363 | 3 |
|------------------------------+-----------------+--------+--------+--------+---------|
@@ -118,7 +118,7 @@
|------------------------------+-----------------+--------+--------+--------+---------|
| setReward | 22065 | 152079 | 164263 | 164263 | 290 |
|------------------------------+-----------------+--------+--------+--------+---------|
| totalSupply | 3827 | 6008 | 3827 | 11827 | 11 |
| totalSupply | 3545 | 5726 | 3545 | 11545 | 11 |
|------------------------------+-----------------+--------+--------+--------+---------|
| transfer | 417 | 417 | 417 | 417 | 3 |
|------------------------------+-----------------+--------+--------+--------+---------|
@@ -164,7 +164,7 @@
+=============================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| 3587693 | 16621 | | | | |
| 3630341 | 16823 | | | | |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| | | | | | |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
@@ -176,7 +176,7 @@
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| MIN_LOCKUP_PERIOD | 309 | 309 | 309 | 309 | 15 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| compound | 37694 | 76876 | 76876 | 116059 | 2 |
| compound | 32664 | 33959 | 32664 | 116059 | 514 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| compoundAccount | 369662 | 369662 | 369662 | 369662 | 1 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
@@ -192,15 +192,15 @@
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| getStakedBalance | 2643 | 2643 | 2643 | 2643 | 1 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| getVault | 2139 | 2785 | 2139 | 4139 | 2130 |
| getVault | 2139 | 7731 | 2139 | 20139 | 4665 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| initialize | 92753 | 92753 | 92753 | 92753 | 94 |
| initialize | 92753 | 92753 | 92753 | 92753 | 95 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| lastRewardTime | 429 | 1429 | 1429 | 2429 | 2 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| leave | 95083 | 95083 | 95083 | 95083 | 1 |
| leave | 95106 | 95106 | 95106 | 95106 | 1 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| lock | 7062 | 74444 | 76770 | 110983 | 1034 |
| lock | 7062 | 38789 | 59606 | 110806 | 1034 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| migrateToVault | 13505 | 73541 | 15712 | 191406 | 3 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
@@ -212,45 +212,45 @@
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| proxiableUUID | 342 | 342 | 342 | 342 | 3 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| registerVault | 2539 | 74404 | 74970 | 74970 | 370 |
| registerVault | 2539 | 74410 | 74970 | 74970 | 374 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| rewardEndTime | 385 | 1385 | 1385 | 2385 | 2 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| rewardStartTime | 430 | 1430 | 1430 | 2430 | 2 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| rewardsBalanceOf | 2340 | 3556 | 3953 | 6340 | 268 |
| rewardsBalanceOf | 2340 | 3562 | 3953 | 6340 | 268 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| rewardsBalanceOfAccount | 10242 | 10242 | 10242 | 10242 | 1 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| setReward | 2530 | 105587 | 107098 | 107098 | 265 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| setRewardsSupplier | 26831 | 26831 | 26831 | 26831 | 89 |
| setRewardsSupplier | 26831 | 26831 | 26831 | 26831 | 90 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| setTrustedCodehash | 24194 | 24194 | 24194 | 24194 | 94 |
| setTrustedCodehash | 24194 | 24194 | 24194 | 24194 | 95 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| stake | 2639 | 243651 | 225022 | 268415 | 2411 |
| stake | 2639 | 151049 | 82444 | 268529 | 2667 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalMP | 805 | 1257 | 1257 | 1710 | 6 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalMPAccrued | 385 | 385 | 385 | 385 | 2136 |
| totalMPAccrued | 385 | 982 | 385 | 2385 | 4671 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalMPStaked | 429 | 429 | 429 | 429 | 2139 |
| totalMPStaked | 429 | 1025 | 429 | 2429 | 4674 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalMaxMP | 407 | 407 | 407 | 407 | 2136 |
| totalMaxMP | 407 | 1004 | 407 | 2407 | 4671 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalRewardsAccrued | 429 | 429 | 429 | 429 | 3 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalRewardsSupply | 1020 | 1651 | 1814 | 6759 | 290 |
| totalRewardsSupply | 1020 | 1654 | 1814 | 6759 | 290 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalShares | 662 | 662 | 662 | 662 | 6 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| totalStaked | 430 | 430 | 430 | 430 | 2143 |
| totalStaked | 430 | 1026 | 430 | 2430 | 4678 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| unstake | 50738 | 76053 | 76059 | 83049 | 269 |
| unstake | 39196 | 42270 | 39222 | 80792 | 269 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| updateGlobalState | 15820 | 27758 | 29230 | 29521 | 277 |
| updateGlobalState | 15820 | 17253 | 15820 | 29516 | 1020 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| updateVaultMP | 25083 | 34565 | 36494 | 36785 | 277 |
| updateVaultMP | 22753 | 24225 | 22753 | 36507 | 1020 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
| upgradeTo | 10235 | 10857 | 10235 | 12723 | 4 |
|------------------------------------------------------+-----------------+--------+--------+--------+---------|
@@ -274,25 +274,25 @@
|----------------------------------------+-----------------+--------+--------+--------+---------|
| emergencyExit | 15045 | 31485 | 31483 | 48583 | 263 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| initialize | 97660 | 97660 | 97660 | 97660 | 370 |
| initialize | 97660 | 97660 | 97660 | 97660 | 374 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| leave | 12161 | 128071 | 69640 | 360844 | 4 |
| leave | 12161 | 128077 | 69651 | 360844 | 4 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| lock | 12091 | 89833 | 92233 | 126446 | 1035 |
| lock | 12091 | 54214 | 75072 | 126269 | 1035 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| migrateToVault | 28993 | 100223 | 31200 | 240476 | 3 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| owner | 379 | 410 | 379 | 2379 | 378 |
| owner | 379 | 410 | 379 | 2379 | 382 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| register | 12674 | 78052 | 78600 | 78600 | 370 |
| register | 12674 | 78057 | 78600 | 78600 | 374 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| stake | 12071 | 298851 | 280590 | 323983 | 2412 |
| stake | 12071 | 185366 | 97937 | 324097 | 2668 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| stakeManager | 369 | 369 | 369 | 369 | 369 |
| stakeManager | 369 | 369 | 369 | 369 | 373 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| trustStakeManager | 7580 | 7580 | 7580 | 7580 | 1 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| unstake | 12048 | 106515 | 107081 | 114071 | 270 |
| unstake | 12048 | 58640 | 54665 | 111814 | 270 |
|----------------------------------------+-----------------+--------+--------+--------+---------|
| withdraw | 20754 | 20754 | 20754 | 20754 | 1 |
╰----------------------------------------+-----------------+--------+--------+--------+---------╯
@@ -308,9 +308,9 @@
|----------------------------------------------------+-----------------+------+--------+--------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|----------------------------------------------------+-----------------+------+--------+--------+---------|
| fallback | 708 | 5505 | 874 | 396039 | 12533 |
| fallback | 708 | 8135 | 2629 | 396039 | 27207 |
|----------------------------------------------------+-----------------+------+--------+--------+---------|
| implementation | 346 | 2345 | 2346 | 2346 | 4095 |
| implementation | 346 | 2345 | 2346 | 2346 | 4355 |
╰----------------------------------------------------+-----------------+------+--------+--------+---------╯
╭--------------------------------------------+-----------------+--------+--------+--------+---------╮
@@ -324,7 +324,7 @@
|--------------------------------------------+-----------------+--------+--------+--------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|--------------------------------------------+-----------------+--------+--------+--------+---------|
| createVault | 230924 | 247653 | 248024 | 248024 | 369 |
| createVault | 230924 | 247657 | 248024 | 248024 | 373 |
╰--------------------------------------------+-----------------+--------+--------+--------+---------╯
╭------------------------------------------------------------------------------------------+-----------------+-------+--------+-------+---------╮
@@ -332,7 +332,7 @@
+===============================================================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|------------------------------------------------------------------------------------------+-----------------+-------+--------+-------+---------|
| 1204853 | 6207 | | | | |
| 1204853 | 6015 | | | | |
|------------------------------------------------------------------------------------------+-----------------+-------+--------+-------+---------|
| | | | | | |
|------------------------------------------------------------------------------------------+-----------------+-------+--------+-------+---------|
@@ -406,17 +406,17 @@
+==================================================================================================+
| Deployment Cost | Deployment Size | | | | |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| 770741 | 3987 | | | | |
| 770657 | 3987 | | | | |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| | | | | | |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| Function Name | Min | Avg | Median | Max | # Calls |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| approve | 29075 | 31829 | 29255 | 46259 | 2416 |
| approve | 29075 | 31548 | 29183 | 46259 | 2676 |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| balanceOf | 561 | 924 | 561 | 2561 | 2930 |
| balanceOf | 561 | 1266 | 561 | 2561 | 5465 |
|---------------------------------------------+-----------------+-------+--------+-------+---------|
| mint | 33964 | 37547 | 34144 | 68248 | 2425 |
| mint | 33964 | 37193 | 34072 | 68248 | 2685 |
╰---------------------------------------------+-----------------+-------+--------+-------+---------╯
╭-----------------------------------------------------------------------------+-----------------+--------+--------+--------+---------╮

219
.gas-snapshot
View File

@@ -1,33 +1,34 @@
CompoundTest:test_CompoundForAccount() (gas: 2493082)
CompoundTest:test_RevertWhenInsufficientMPBalance() (gas: 381970)
CompoundTest:test_CompoundForAccount() (gas: 2493561)
CompoundTest:test_RevertWhenInsufficientMPBalance() (gas: 382040)
EmergencyExitTest:test_CannotEnableEmergencyModeTwice() (gas: 93420)
EmergencyExitTest:test_CannotLeaveBeforeEmergencyMode() (gas: 355289)
EmergencyExitTest:test_EmergencyExitBasic() (gas: 450164)
EmergencyExitTest:test_EmergencyExitMultipleUsers() (gas: 775832)
EmergencyExitTest:test_EmergencyExitToAlternateAddress() (gas: 455671)
EmergencyExitTest:test_EmergencyExitWithLock() (gas: 472989)
EmergencyExitTest:test_EmergencyExitWithRewards() (gas: 438441)
EmergencyExitTest:test_OnlyOwnerCanEnableEmergencyMode() (gas: 39066)
FuzzTests:testFuzz_AccrueMP(uint256,uint256,uint16) (runs: 1000, μ: 535810, ~: 520588)
FuzzTests:testFuzz_AccrueMP_Relock(uint256,uint256,uint16) (runs: 1001, μ: 575695, ~: 577717)
FuzzTests:testFuzz_EmergencyExit(uint256,uint256) (runs: 1000, μ: 526140, ~: 507220)
FuzzTests:testFuzz_Lock(uint256,uint256) (runs: 1000, μ: 548513, ~: 548525)
FuzzTests:testFuzz_Relock(uint256,uint256,uint256) (runs: 1002, μ: 575384, ~: 581656)
FuzzTests:testFuzz_Rewards(uint256,uint256,uint256,uint16,uint16) (runs: 1000, μ: 634123, ~: 635975)
FuzzTests:testFuzz_Stake(uint256,uint256) (runs: 1000, μ: 419495, ~: 400575)
FuzzTests:testFuzz_Unstake(uint256,uint256,uint16,uint256) (runs: 1000, μ: 535947, ~: 535404)
IntegrationTest:testStakeFoo() (gas: 1438069)
KarmaMintAllowanceTest:testAddKarmaDistributorOnlyOwner() (gas: 364780)
KarmaMintAllowanceTest:testBalanceOf() (gas: 444028)
KarmaMintAllowanceTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49501)
KarmaMintAllowanceTest:testMintAllowance_Available() (gas: 355738)
KarmaMintAllowanceTest:testMintAllowance_NotAvailable() (gas: 355743)
KarmaMintAllowanceTest:testMintOnlyOwner() (gas: 397985)
KarmaMintAllowanceTest:testMint_Ok() (gas: 425651)
KarmaMintAllowanceTest:testMint_RevertWithAllowanceExceeded() (gas: 405708)
KarmaMintAllowanceTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88855)
EmergencyExitTest:test_CannotLeaveBeforeEmergencyMode() (gas: 355381)
EmergencyExitTest:test_EmergencyExitBasic() (gas: 450301)
EmergencyExitTest:test_EmergencyExitMultipleUsers() (gas: 776038)
EmergencyExitTest:test_EmergencyExitToAlternateAddress() (gas: 455763)
EmergencyExitTest:test_EmergencyExitWithLock() (gas: 473147)
EmergencyExitTest:test_EmergencyExitWithRewards() (gas: 438555)
EmergencyExitTest:test_OnlyOwnerCanEnableEmergencyMode() (gas: 39109)
FuzzTests:testFuzz_AccrueMP(uint128,uint64,uint64) (runs: 1023, μ: 433295, ~: 407385)
FuzzTests:testFuzz_AccrueMP_Relock(uint128,uint64,uint64,uint64) (runs: 1023, μ: 535458, ~: 509184)
FuzzTests:testFuzz_Compound(uint128,uint64,uint64) (runs: 1023, μ: 521411, ~: 494881)
FuzzTests:testFuzz_EmergencyExit(uint256,uint256) (runs: 1007, μ: 525759, ~: 507538)
FuzzTests:testFuzz_Lock(uint256,uint64) (runs: 1023, μ: 772579, ~: 793973)
FuzzTests:testFuzz_Relock(uint256,uint64,uint64) (runs: 1023, μ: 410341, ~: 392608)
FuzzTests:testFuzz_Rewards(uint256,uint256,uint256,uint16,uint16) (runs: 1000, μ: 634354, ~: 636257)
FuzzTests:testFuzz_Stake(uint256,uint64) (runs: 1023, μ: 312467, ~: 290859)
FuzzTests:testFuzz_Unstake(uint128,uint64,uint16,uint128) (runs: 1023, μ: 620437, ~: 599309)
IntegrationTest:testStakeFoo() (gas: 1441361)
KarmaMintAllowanceTest:testAddKarmaDistributorOnlyOwner() (gas: 364802)
KarmaMintAllowanceTest:testBalanceOf() (gas: 441486)
KarmaMintAllowanceTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49545)
KarmaMintAllowanceTest:testMintAllowance_Available() (gas: 352610)
KarmaMintAllowanceTest:testMintAllowance_NotAvailable() (gas: 352615)
KarmaMintAllowanceTest:testMintOnlyOwner() (gas: 394857)
KarmaMintAllowanceTest:testMint_Ok() (gas: 419959)
KarmaMintAllowanceTest:testMint_RevertWithAllowanceExceeded() (gas: 400580)
KarmaMintAllowanceTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88877)
KarmaMintAllowanceTest:testRemoveUnknownKarmaDistributor() (gas: 41416)
KarmaMintAllowanceTest:testTotalSupply() (gas: 352205)
KarmaMintAllowanceTest:testTotalSupply() (gas: 349359)
KarmaMintAllowanceTest:testTransfersNotAllowed() (gas: 40219)
KarmaNFTTest:testApproveNotAllowed() (gas: 10507)
KarmaNFTTest:testGetApproved() (gas: 10531)
@@ -39,102 +40,102 @@ KarmaNFTTest:testSetMetadataGenerator() (gas: 1010377)
KarmaNFTTest:testSetMetadataGeneratorRevert() (gas: 1006937)
KarmaNFTTest:testTokenURI() (gas: 1105935)
KarmaNFTTest:testTransferNotAllowed() (gas: 10701)
KarmaOwnershipTest:testAddKarmaDistributorOnlyOwner() (gas: 364768)
KarmaOwnershipTest:testBalanceOf() (gas: 443998)
KarmaOwnershipTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49479)
KarmaOwnershipTest:testAddKarmaDistributorOnlyOwner() (gas: 364790)
KarmaOwnershipTest:testBalanceOf() (gas: 441456)
KarmaOwnershipTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49523)
KarmaOwnershipTest:testInitialOwner() (gas: 17601)
KarmaOwnershipTest:testMintOnlyOwner() (gas: 397949)
KarmaOwnershipTest:testOwnershipTransfer() (gas: 98047)
KarmaOwnershipTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88820)
KarmaOwnershipTest:testMintOnlyOwner() (gas: 394821)
KarmaOwnershipTest:testOwnershipTransfer() (gas: 98069)
KarmaOwnershipTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88842)
KarmaOwnershipTest:testRemoveUnknownKarmaDistributor() (gas: 41398)
KarmaOwnershipTest:testTotalSupply() (gas: 352175)
KarmaOwnershipTest:testTotalSupply() (gas: 349329)
KarmaOwnershipTest:testTransfersNotAllowed() (gas: 40196)
KarmaTest:testAddKarmaDistributorOnlyOwner() (gas: 364768)
KarmaTest:testBalanceOf() (gas: 443998)
KarmaTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49545)
KarmaTest:testMintOnlyOwner() (gas: 397949)
KarmaTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88798)
KarmaTest:testAddKarmaDistributorOnlyOwner() (gas: 364790)
KarmaTest:testBalanceOf() (gas: 441456)
KarmaTest:testBalanceOfWithNoSystemTotalKarma() (gas: 49589)
KarmaTest:testMintOnlyOwner() (gas: 394821)
KarmaTest:testRemoveKarmaDistributorOnlyOwner() (gas: 88820)
KarmaTest:testRemoveUnknownKarmaDistributor() (gas: 41398)
KarmaTest:testTotalSupply() (gas: 352175)
KarmaTest:testTotalSupply() (gas: 349329)
KarmaTest:testTransfersNotAllowed() (gas: 40241)
LeaveTest:test_LeaveShouldProperlyUpdateAccounting() (gas: 9815533)
LeaveTest:test_RevertWhenStakeManagerIsTrusted() (gas: 352361)
LeaveTest:test_TrustNewStakeManager() (gas: 9866614)
LockTest:test_LockFailsWithInvalidPeriod(uint256) (runs: 1002, μ: 388817, ~: 366513)
LeaveTest:test_LeaveShouldProperlyUpdateAccounting() (gas: 9899202)
LeaveTest:test_RevertWhenStakeManagerIsTrusted() (gas: 352518)
LeaveTest:test_TrustNewStakeManager() (gas: 9949960)
LockTest:test_LockFailsWithInvalidPeriod(uint256) (runs: 1024, μ: 387855, ~: 366605)
LockTest:test_LockFailsWithNoStake() (gas: 109665)
LockTest:test_LockFailsWithZero() (gas: 362510)
LockTest:test_LockMultipleTimesExceedMaxLock() (gas: 673773)
LockTest:test_LockWithPriorLock() (gas: 620559)
LockTest:test_LockWithoutPriorLock() (gas: 493252)
LockTest:test_LockFailsWithZero() (gas: 362624)
LockTest:test_LockMultipleTimesExceedMaxLock() (gas: 674397)
LockTest:test_LockWithPriorLock() (gas: 621342)
LockTest:test_LockWithoutPriorLock() (gas: 493744)
LockTest:test_RevertWhenVaultToLockIsEmpty() (gas: 109623)
MaliciousUpgradeTest:test_UpgradeStackOverflowStakeManager() (gas: 2018645)
MathTest:test_CalcAbsoluteMaxTotalMP() (gas: 5196)
MathTest:test_CalcAccrueMP() (gas: 8511)
MathTest:test_CalcBonusMP() (gas: 19112)
MathTest:test_CalcInitialMP() (gas: 5728)
MathTest:test_CalcMaxAccruedMP() (gas: 4842)
MathTest:test_CalcMaxTotalMP() (gas: 19852)
MultipleVaultsStakeTest:test_StakeMultipleVaults() (gas: 859619)
MaliciousUpgradeTest:test_UpgradeStackOverflowStakeManager() (gas: 2018869)
MathTest:test_CalcAbsoluteMaxTotalMP() (gas: 5218)
MathTest:test_CalcAccrueMP() (gas: 8599)
MathTest:test_CalcBonusMP() (gas: 19178)
MathTest:test_CalcInitialMP() (gas: 5836)
MathTest:test_CalcMaxAccruedMP() (gas: 4929)
MathTest:test_CalcMaxTotalMP() (gas: 19940)
MultipleVaultsStakeTest:test_StakeMultipleVaults() (gas: 860071)
NFTMetadataGeneratorSVGTest:testGenerateMetadata() (gas: 92580)
NFTMetadataGeneratorSVGTest:testSetImageStrings() (gas: 60081)
NFTMetadataGeneratorSVGTest:testSetImageStringsRevert() (gas: 35891)
NFTMetadataGeneratorURLTest:testGenerateMetadata() (gas: 108341)
NFTMetadataGeneratorURLTest:testSetBaseURL() (gas: 50631)
NFTMetadataGeneratorURLTest:testSetBaseURLRevert() (gas: 36066)
RewardsStreamerMP_RewardsTest:testRewardsBalanceOf() (gas: 1326082)
RewardsStreamerMP_RewardsTest:testRewardsBalanceOf() (gas: 1326353)
RewardsStreamerMP_RewardsTest:testSetRewards() (gas: 224746)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadAmount() (gas: 61304)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadDuration() (gas: 101081)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsNotAuthorized() (gas: 39366)
RewardsStreamerMP_RewardsTest:testTotalRewardsSupply() (gas: 761240)
StakeTest:test_RevertWhenStakeMultipleTimesExceedsMaxLockUpTime() (gas: 774186)
StakeTest:test_RevertWhenStakeMultipleTimesWithGapsExceedsMaxLockUpTime() (gas: 826327)
StakeTest:test_StakeMultipleAccounts() (gas: 601232)
StakeTest:test_StakeMultipleAccountsAndRewards() (gas: 609747)
StakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 1038600)
StakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 629966)
StakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 674582)
StakeTest:test_StakeMultipleTimesWithLockIncreaseAtSameBlock() (gas: 623011)
StakeTest:test_StakeMultipleTimesWithLockZeroAfterMaxLock() (gas: 739026)
StakeTest:test_StakeOneAccount() (gas: 338822)
StakeTest:test_StakeOneAccountAndRewards() (gas: 347334)
StakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 614453)
StakeTest:test_StakeOneAccountReachingMPLimit() (gas: 602606)
StakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 377247)
StakeTest:test_StakeOneAccountWithMinLockUp() (gas: 377843)
StakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 377910)
StakeVaultMigrationTest:testMigrateToVault() (gas: 957982)
StakeVaultMigrationTest:test_RevertWhenMigrationVaultNotEmpty() (gas: 648407)
StakeVaultMigrationTest:test_RevertWhenNotOwnerOfMigrationVault() (gas: 68066)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadAmount() (gas: 61324)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadDuration() (gas: 101082)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsNotAuthorized() (gas: 39344)
RewardsStreamerMP_RewardsTest:testTotalRewardsSupply() (gas: 761342)
StakeTest:test_RevertWhenStakeMultipleTimesExceedsMaxLockUpTime() (gas: 774528)
StakeTest:test_RevertWhenStakeMultipleTimesWithGapsExceedsMaxLockUpTime() (gas: 826669)
StakeTest:test_StakeMultipleAccounts() (gas: 601877)
StakeTest:test_StakeMultipleAccountsAndRewards() (gas: 610415)
StakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 1039884)
StakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 630238)
StakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 674876)
StakeTest:test_StakeMultipleTimesWithLockIncreaseAtSameBlock() (gas: 623415)
StakeTest:test_StakeMultipleTimesWithLockZeroAfterMaxLock() (gas: 739368)
StakeTest:test_StakeOneAccount() (gas: 339156)
StakeTest:test_StakeOneAccountAndRewards() (gas: 347734)
StakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 615073)
StakeTest:test_StakeOneAccountReachingMPLimit() (gas: 603204)
StakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 377449)
StakeTest:test_StakeOneAccountWithMinLockUp() (gas: 378045)
StakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 378090)
StakeVaultMigrationTest:testMigrateToVault() (gas: 958888)
StakeVaultMigrationTest:test_RevertWhenMigrationVaultNotEmpty() (gas: 648499)
StakeVaultMigrationTest:test_RevertWhenNotOwnerOfMigrationVault() (gas: 68044)
StakeVaultTest:testOwner() (gas: 15262)
StakingTokenTest:testOwner() (gas: 15262)
StakingTokenTest:testStakeToken() (gas: 13144)
TrustedCodehashAccessTest:test_RevertWhenProxyCloneCodehashNotTrusted() (gas: 2023401)
UnstakeTest:test_RevertWhenStakeMultipleTimesExceedsMaxLockUpTime() (gas: 774208)
UnstakeTest:test_RevertWhenStakeMultipleTimesWithGapsExceedsMaxLockUpTime() (gas: 826371)
UnstakeTest:test_StakeMultipleAccounts() (gas: 601276)
UnstakeTest:test_StakeMultipleAccountsAndRewards() (gas: 609702)
UnstakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 1038577)
UnstakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 629921)
UnstakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 674559)
UnstakeTest:test_StakeMultipleTimesWithLockIncreaseAtSameBlock() (gas: 623033)
UnstakeTest:test_StakeMultipleTimesWithLockZeroAfterMaxLock() (gas: 739026)
UnstakeTest:test_StakeOneAccount() (gas: 338822)
UnstakeTest:test_StakeOneAccountAndRewards() (gas: 347311)
UnstakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 614430)
UnstakeTest:test_StakeOneAccountReachingMPLimit() (gas: 602564)
UnstakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 377269)
UnstakeTest:test_StakeOneAccountWithMinLockUp() (gas: 377843)
UnstakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 377888)
UnstakeTest:test_UnstakeBonusMPAndAccuredMP() (gas: 655491)
UnstakeTest:test_UnstakeMultipleAccounts() (gas: 843259)
UnstakeTest:test_UnstakeMultipleAccountsAndRewards() (gas: 958200)
UnstakeTest:test_UnstakeOneAccount() (gas: 575186)
UnstakeTest:test_UnstakeOneAccountAndAccruedMP() (gas: 599567)
UnstakeTest:test_UnstakeOneAccountAndRewards() (gas: 495454)
UnstakeTest:test_UnstakeOneAccountWithLockUpAndAccruedMP() (gas: 642464)
UpgradeTest:test_RevertWhenNotOwner() (gas: 3664151)
UpgradeTest:test_UpgradeStakeManager() (gas: 9702629)
VaultRegistrationTest:test_VaultRegistration() (gas: 63050)
TrustedCodehashAccessTest:test_RevertWhenProxyCloneCodehashNotTrusted() (gas: 2023424)
UnstakeTest:test_RevertWhenStakeMultipleTimesExceedsMaxLockUpTime() (gas: 774550)
UnstakeTest:test_RevertWhenStakeMultipleTimesWithGapsExceedsMaxLockUpTime() (gas: 826713)
UnstakeTest:test_StakeMultipleAccounts() (gas: 601834)
UnstakeTest:test_StakeMultipleAccountsAndRewards() (gas: 610370)
UnstakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 1039928)
UnstakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 630304)
UnstakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 674920)
UnstakeTest:test_StakeMultipleTimesWithLockIncreaseAtSameBlock() (gas: 623437)
UnstakeTest:test_StakeMultipleTimesWithLockZeroAfterMaxLock() (gas: 739368)
UnstakeTest:test_StakeOneAccount() (gas: 339156)
UnstakeTest:test_StakeOneAccountAndRewards() (gas: 347733)
UnstakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 615072)
UnstakeTest:test_StakeOneAccountReachingMPLimit() (gas: 603184)
UnstakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 377471)
UnstakeTest:test_StakeOneAccountWithMinLockUp() (gas: 378045)
UnstakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 378156)
UnstakeTest:test_UnstakeBonusMPAndAccuredMP() (gas: 655966)
UnstakeTest:test_UnstakeMultipleAccounts() (gas: 844237)
UnstakeTest:test_UnstakeMultipleAccountsAndRewards() (gas: 959589)
UnstakeTest:test_UnstakeOneAccount() (gas: 575842)
UnstakeTest:test_UnstakeOneAccountAndAccruedMP() (gas: 600078)
UnstakeTest:test_UnstakeOneAccountAndRewards() (gas: 496119)
UnstakeTest:test_UnstakeOneAccountWithLockUpAndAccruedMP() (gas: 642865)
UpgradeTest:test_RevertWhenNotOwner() (gas: 3706859)
UpgradeTest:test_UpgradeStakeManager() (gas: 9786172)
VaultRegistrationTest:test_VaultRegistration() (gas: 63226)
WithdrawTest:testOwner() (gas: 15296)
WithdrawTest:test_CannotWithdrawStakedFunds() (gas: 368095)
WithdrawTest:test_CannotWithdrawStakedFunds() (gas: 368209)

10
src/math/StakeMath.sol
View File

@@ -12,6 +12,7 @@ import { MultiplierPointMath } from "./MultiplierPointMath.sol";
abstract contract StakeMath is MultiplierPointMath {
error StakeMath__FundsLocked();
error StakeMath__InvalidLockingPeriod();
error StakeMath__InvalidAmount();
error StakeMath__InsufficientBalance();
error StakeMath__AbsoluteMaxMPOverflow();
@@ -48,6 +49,9 @@ abstract contract StakeMath is MultiplierPointMath {
returns (uint256 _deltaMpTotal, uint256 _deltaMpMax, uint256 _newLockEnd)
{
uint256 newBalance = _balance + _increasedAmount;
if (_increasedLockSeconds > MAX_LOCKUP_PERIOD) {
revert StakeMath__InvalidLockingPeriod();
}
_newLockEnd = Math.max(_currentLockEndTime, _processTime) + _increasedLockSeconds;
// solhint-disable-next-line
uint256 dtLock = _newLockEnd - _processTime;
@@ -97,6 +101,9 @@ abstract contract StakeMath is MultiplierPointMath {
revert StakeMath__InsufficientBalance();
}
if (_increasedLockSeconds > MAX_LOCKUP_PERIOD) {
revert StakeMath__InvalidLockingPeriod();
}
_newLockEnd = Math.max(_currentLockEndTime, _processTime) + _increasedLockSeconds;
// solhint-disable-next-line
uint256 dt_lock = _newLockEnd - _processTime;
@@ -133,6 +140,9 @@ abstract contract StakeMath is MultiplierPointMath {
pure
returns (uint256 _deltaMpTotal, uint256 _deltaMpMax)
{
if (_reducedAmount == 0) {
revert StakeMath__InvalidAmount();
}
if (_reducedAmount > _balance) {
revert StakeMath__InsufficientBalance();
}

668
test/RewardsStreamerMP.t.sol
View File

@@ -87,6 +87,15 @@ contract RewardsStreamerMPTest is StakeMath, Test {
// assertEq(streamer.rewardIndex(), p.rewardIndex, "wrong reward index");
}
function checkStreamer(string memory text, CheckStreamerParams memory p) public view {
assertEq(streamer.totalStaked(), p.totalStaked, string(abi.encodePacked(text, "wrong total staked")));
assertEq(streamer.totalMPStaked(), p.totalMPStaked, string(abi.encodePacked(text, "wrong total staked MP")));
assertEq(streamer.totalMPAccrued(), p.totalMPAccrued, string(abi.encodePacked(text, "wrong total accrued MP")));
assertEq(streamer.totalMaxMP(), p.totalMaxMP, string(abi.encodePacked(text, "wrong totalMaxMP MP")));
// assertEq(rewardToken.balanceOf(address(streamer)), p.rewardBalance, "wrong reward balance");
// assertEq(streamer.rewardIndex(), p.rewardIndex, "wrong reward index");
}
struct CheckVaultParams {
address account;
uint256 rewardBalance;
@@ -110,6 +119,26 @@ contract RewardsStreamerMPTest is StakeMath, Test {
assertEq(vaultData.rewardsAccrued, p.rewardsAccrued, "wrong account rewards accrued");
}
function checkVault(string memory text, CheckVaultParams memory p) public view {
// assertEq(rewardToken.balanceOf(p.account), p.rewardBalance, "wrong account reward balance");
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(p.account);
assertEq(
vaultData.stakedBalance, p.stakedBalance, string(abi.encodePacked(text, "wrong account staked balance"))
);
assertEq(
stakingToken.balanceOf(p.account), p.vaultBalance, string(abi.encodePacked(text, "wrong vault balance"))
);
// assertEq(vaultData.accountRewardIndex, p.rewardIndex, "wrong account reward index");
assertEq(vaultData.mpStaked, p.mpStaked, string(abi.encodePacked(text, "wrong account MP staked")));
assertEq(vaultData.mpAccrued, p.mpAccrued, string(abi.encodePacked(text, "wrong account MP accrued")));
assertEq(vaultData.maxMP, p.maxMP, string(abi.encodePacked(text, "wrong account max MP")));
assertEq(
vaultData.rewardsAccrued, p.rewardsAccrued, string(abi.encodePacked(text, "wrong account rewards accrued"))
);
}
struct CheckUserTotalsParams {
address user;
uint256 totalStakedBalance;
@@ -134,6 +163,15 @@ contract RewardsStreamerMPTest is StakeMath, Test {
vault.stake(amount, lockupTime);
}
function _stake(address account, uint256 amount, uint256 lockupTime, bytes4 _expectedRevert) public virtual {
StakeVault vault = StakeVault(vaults[account]);
vm.prank(account);
if (_expectedRevert != bytes4(0)) {
vm.expectRevert(_expectedRevert);
}
vault.stake(amount, lockupTime);
}
function _compound(address account) public {
StakeVault vault = StakeVault(vaults[account]);
streamer.compound(address(vault));
@@ -2915,6 +2953,79 @@ contract CompoundTest is RewardsStreamerMPTest {
}
contract FuzzTests is RewardsStreamerMPTest {
struct CheckVaultLockParams {
uint256 lockEnd;
uint256 totalLockUp;
}
bytes4 constant NO_REVERT = 0x00000000;
error FuzzTests__UndefinedError();
bytes4 expectedRevert = FuzzTests__UndefinedError.selector;
CheckStreamerParams expectedSystemState = CheckStreamerParams({
totalStaked: 0,
totalMPStaked: 0,
totalMPAccrued: 0,
totalMaxMP: 0,
stakingBalance: 0,
rewardBalance: 0,
rewardIndex: 0
});
mapping(address userAddress => CheckVaultParams params) public expectedAccountState;
mapping(address vaultAddress => CheckVaultLockParams params) public expectedVaultLockState;
function check(string memory test) internal view {
check(test, expectedSystemState);
}
function check(string memory test, address vaultOwner) internal view {
check(test, expectedAccountState[vaultOwner]);
check(test, expectedSystemState);
}
function check(string memory text, CheckStreamerParams storage p) internal view {
assertEq(streamer.totalStaked(), p.totalStaked, string(abi.encodePacked(text, "wrong total staked")));
assertEq(streamer.totalMPStaked(), p.totalMPStaked, string(abi.encodePacked(text, "wrong total staked MP")));
assertEq(streamer.totalMPAccrued(), p.totalMPAccrued, string(abi.encodePacked(text, "wrong total accrued MP")));
assertEq(streamer.totalMaxMP(), p.totalMaxMP, string(abi.encodePacked(text, "wrong totalMaxMP MP")));
// assertEq(rewardToken.balanceOf(address(streamer)), p.rewardBalance, "wrong reward balance");
// assertEq(streamer.rewardIndex(), p.rewardIndex, "wrong reward index");
}
function check(string memory text, CheckVaultParams storage p) internal view {
// assertEq(rewardToken.balanceOf(p.account), p.rewardBalance, "wrong account reward balance");
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(p.account);
assertEq(
vaultData.stakedBalance, p.stakedBalance, string(abi.encodePacked(text, "wrong account staked balance"))
);
assertEq(
stakingToken.balanceOf(p.account), p.vaultBalance, string(abi.encodePacked(text, "wrong vault balance"))
);
// assertEq(vaultData.accountRewardIndex, p.rewardIndex, "wrong account reward index");
assertEq(vaultData.mpStaked, p.mpStaked, string(abi.encodePacked(text, "wrong account MP staked")));
assertEq(vaultData.mpAccrued, p.mpAccrued, string(abi.encodePacked(text, "wrong account MP accrued")));
assertEq(vaultData.maxMP, p.maxMP, string(abi.encodePacked(text, "wrong account max MP")));
assertEq(
vaultData.rewardsAccrued, p.rewardsAccrued, string(abi.encodePacked(text, "wrong account rewards accrued"))
);
assertEq(
vaultData.lockUntil,
expectedVaultLockState[p.account].lockEnd,
string(abi.encodePacked(text, "wrong account lock end"))
);
}
function _stake(address account, uint256 amount, uint256 lockPeriod, bytes4 _expectedRevert) public override {
stakingToken.mint(account, amount);
vm.prank(account);
stakingToken.approve(vaults[account], amount);
super._stake(account, amount, lockPeriod, _expectedRevert);
expectedRevert = FuzzTests__UndefinedError.selector;
}
function _stake(address account, uint256 amount, uint256 lockPeriod) public override {
stakingToken.mint(account, amount);
vm.prank(account);
@@ -2922,294 +3033,305 @@ contract FuzzTests is RewardsStreamerMPTest {
super._stake(account, amount, lockPeriod);
}
function testFuzz_Stake(uint256 stakeAmount, uint256 lockUpPeriod) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
vm.assume(lockUpPeriod == 0 || (lockUpPeriod >= MIN_LOCKUP_PERIOD && lockUpPeriod <= MAX_LOCKUP_PERIOD));
uint256 expectedBonusMP = _bonusMP(stakeAmount, lockUpPeriod);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: stakeAmount + expectedBonusMP,
totalMPAccrued: stakeAmount + expectedBonusMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: stakeAmount + expectedBonusMP,
mpAccrued: stakeAmount + expectedBonusMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
}
function testFuzz_Lock(uint256 stakeAmount, uint256 lockUpPeriod) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
vm.assume(lockUpPeriod >= MIN_LOCKUP_PERIOD && lockUpPeriod <= MAX_LOCKUP_PERIOD);
uint256 expectedBonusMP = _bonusMP(stakeAmount, lockUpPeriod);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, 0);
_lock(alice, lockUpPeriod);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: stakeAmount + expectedBonusMP,
totalMPAccrued: stakeAmount + expectedBonusMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: stakeAmount + expectedBonusMP,
mpAccrued: stakeAmount + expectedBonusMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
}
function testFuzz_Relock(uint256 stakeAmount, uint256 lockUpPeriod, uint256 lockUpPeriod2) public {
stakeAmount = bound(stakeAmount, 1, MAX_BALANCE);
lockUpPeriod = lockUpPeriod == 0 ? 0 : bound(lockUpPeriod, MIN_LOCKUP_PERIOD, MAX_LOCKUP_PERIOD);
vm.assume(
lockUpPeriod2 > 0 && lockUpPeriod2 <= MAX_LOCKUP_PERIOD && lockUpPeriod + lockUpPeriod2 >= MIN_LOCKUP_PERIOD
&& lockUpPeriod + lockUpPeriod2 <= MAX_LOCKUP_PERIOD
);
uint256 expectedBonusMP = _bonusMP(stakeAmount, lockUpPeriod);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: stakeAmount + expectedBonusMP,
totalMPAccrued: stakeAmount + expectedBonusMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: stakeAmount + expectedBonusMP,
mpAccrued: stakeAmount + expectedBonusMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
_lock(alice, lockUpPeriod2);
expectedBonusMP += _bonusMP(stakeAmount, lockUpPeriod2);
expectedMaxTotalMP += _bonusMP(stakeAmount, lockUpPeriod2);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: stakeAmount + expectedBonusMP,
totalMPAccrued: stakeAmount + expectedBonusMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: stakeAmount + expectedBonusMP,
mpAccrued: stakeAmount + expectedBonusMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
}
function testFuzz_AccrueMP(uint256 stakeAmount, uint256 lockUpPeriod, uint16 accruedTime) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
vm.assume(lockUpPeriod == 0 || (lockUpPeriod >= MIN_LOCKUP_PERIOD && lockUpPeriod <= MAX_LOCKUP_PERIOD));
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
uint256 expectedStakedMP = _initialMP(stakeAmount) + _bonusMP(stakeAmount, lockUpPeriod);
uint256 rawTotalMP = expectedStakedMP + _accrueMP(stakeAmount, accruedTime);
uint256 expectedTotalMP = Math.min(rawTotalMP, expectedMaxTotalMP);
_stake(alice, stakeAmount, lockUpPeriod);
uint256 currentTime = vm.getBlockTimestamp();
vm.warp(currentTime + accruedTime);
streamer.updateGlobalState();
streamer.updateVaultMP(vaults[alice]);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: expectedStakedMP,
totalMPAccrued: expectedTotalMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: expectedStakedMP,
mpAccrued: expectedTotalMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
}
function testFuzz_AccrueMP_Relock(uint256 stakeAmount, uint256 lockUpPeriod2, uint16 accruedTime) public {
uint256 lockUpPeriod = MIN_LOCKUP_PERIOD;
vm.assume(lockUpPeriod2 <= MAX_LOCKUP_PERIOD);
if (accruedTime <= lockUpPeriod) {
vm.assume(
lockUpPeriod2 > 0 && lockUpPeriod + lockUpPeriod2 - accruedTime >= MIN_LOCKUP_PERIOD
&& lockUpPeriod + lockUpPeriod2 - accruedTime <= MAX_LOCKUP_PERIOD
);
} else {
vm.assume(lockUpPeriod2 >= MIN_LOCKUP_PERIOD);
function _lock(address account, uint256 lockPeriod, bytes4 _expectedRevert) internal {
StakeVault vault = StakeVault(vaults[account]);
vm.prank(account);
if (_expectedRevert != NO_REVERT) {
vm.expectRevert(_expectedRevert);
}
stakeAmount = bound(stakeAmount, MIN_BALANCE, MAX_BALANCE);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
uint256 expectedStakedMP = _initialMP(stakeAmount) + _bonusMP(stakeAmount, lockUpPeriod);
uint256 rawTotalMP = expectedStakedMP + _accrueMP(stakeAmount, accruedTime);
uint256 expectedTotalMP = Math.min(rawTotalMP, expectedMaxTotalMP);
_stake(alice, stakeAmount, lockUpPeriod);
uint256 currentTime = vm.getBlockTimestamp();
vm.warp(currentTime + accruedTime);
_lock(alice, lockUpPeriod2);
expectedTotalMP += _bonusMP(stakeAmount, lockUpPeriod2);
expectedStakedMP += _bonusMP(stakeAmount, lockUpPeriod2);
expectedMaxTotalMP += _bonusMP(stakeAmount, lockUpPeriod2);
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount,
totalMPStaked: expectedStakedMP,
totalMPAccrued: expectedTotalMP,
totalMaxMP: expectedMaxTotalMP,
stakingBalance: stakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
vaultBalance: stakeAmount,
rewardIndex: 0,
mpStaked: expectedStakedMP,
mpAccrued: expectedTotalMP,
maxMP: expectedMaxTotalMP,
rewardsAccrued: 0
})
);
vault.lock(lockPeriod);
expectedRevert = FuzzTests__UndefinedError.selector;
}
function testFuzz_Unstake(
uint256 stakeAmount,
uint256 lockUpPeriod,
uint16 accruedTime,
uint256 unstakeAmount
function _compound(address account, bytes4 _expectedRevert) internal {
StakeVault vault = StakeVault(vaults[account]);
if (_expectedRevert != NO_REVERT) {
vm.expectRevert(_expectedRevert);
}
streamer.compound(address(vault));
}
function _accrue(address account, uint256 accruedTime) internal {
if (accruedTime > 0) {
vm.warp(vm.getBlockTimestamp() + accruedTime);
}
streamer.updateGlobalState();
streamer.updateVaultMP(vaults[account]);
}
function _unstake(address account, uint256 amount, bytes4 _expectedRevert) internal {
StakeVault vault = StakeVault(vaults[account]);
vm.prank(account);
if (_expectedRevert != NO_REVERT) {
vm.expectRevert(_expectedRevert);
}
vault.unstake(amount);
expectedRevert = FuzzTests__UndefinedError.selector;
}
function _expectCompound(address account) internal {
CheckVaultParams storage expectedAccountParams = expectedAccountState[account];
uint256 mpCompounded = expectedAccountParams.mpAccrued - expectedAccountParams.mpStaked;
if (mpCompounded == 0) {
expectedRevert = IStakeManager.StakingManager__InsufficientBalance.selector;
} else {
expectedRevert = NO_REVERT;
}
expectedAccountParams.mpStaked += mpCompounded;
expectedSystemState.totalMPStaked += mpCompounded;
}
function _expectUnstake(address account, uint256 amount) internal {
if (amount == 0) {
expectedRevert = StakeMath.StakeMath__InvalidAmount.selector;
return;
}
CheckVaultParams storage expectedAccountParams = expectedAccountState[account];
if (amount > expectedAccountParams.stakedBalance) {
expectedRevert = StakeMath.StakeMath__InsufficientBalance.selector;
console.log("no balance");
return;
}
if (expectedVaultLockState[expectedAccountParams.account].lockEnd >= vm.getBlockTimestamp()) {
expectedRevert = StakeMath.StakeMath__FundsLocked.selector;
console.log("locked");
return;
}
expectedRevert = NO_REVERT;
uint256 expectedReducedMP =
_reduceMP(expectedAccountParams.stakedBalance, expectedAccountParams.mpAccrued, amount);
uint256 expectedReducedMaxMP =
_reduceMP(expectedAccountParams.stakedBalance, expectedAccountParams.maxMP, amount);
expectedAccountParams.stakedBalance -= amount;
expectedAccountParams.vaultBalance -= amount;
expectedSystemState.stakingBalance -= amount;
expectedSystemState.totalStaked -= amount;
expectedAccountParams.mpStaked -= expectedReducedMP;
expectedSystemState.totalMPStaked -= expectedReducedMP;
expectedAccountParams.mpAccrued -= expectedReducedMP;
expectedSystemState.totalMPAccrued -= expectedReducedMP;
expectedAccountParams.maxMP -= expectedReducedMaxMP;
expectedSystemState.totalMaxMP -= expectedReducedMaxMP;
}
function _expectAccrue(address account, uint256 accruedTime) internal {
CheckVaultParams storage expectedAccountParams = expectedAccountState[account];
if (expectedAccountParams.vaultBalance > 0) {
uint256 rawAccruedMP = _accrueMP(expectedAccountParams.vaultBalance, accruedTime);
expectedAccountParams.mpAccrued =
Math.min(expectedAccountParams.mpAccrued + rawAccruedMP, expectedAccountParams.maxMP);
expectedSystemState.totalMPAccrued =
Math.min(expectedSystemState.totalMPAccrued + rawAccruedMP, expectedSystemState.totalMaxMP);
}
}
function _expectStake(address account, uint256 stakeAmount, uint256 lockUpPeriod) internal {
CheckVaultParams storage expectedAccountParams = expectedAccountState[account];
uint256 calcLockEnd = Math.max(
expectedVaultLockState[expectedAccountParams.account].lockEnd, vm.getBlockTimestamp()
) + lockUpPeriod;
uint256 calcLockUpPeriod = calcLockEnd - vm.getBlockTimestamp(); //increased lock + remaining current lock
if (lockUpPeriod == 0 || (lockUpPeriod >= MIN_LOCKUP_PERIOD && lockUpPeriod <= MAX_LOCKUP_PERIOD)) {
//valid raw input
if (expectedVaultLockState[expectedAccountParams.account].totalLockUp + lockUpPeriod > MAX_LOCKUP_PERIOD) {
// but total lock time surpassed the maximum allowed
expectedRevert = StakeMath.StakeMath__AbsoluteMaxMPOverflow.selector;
} else {
expectedRevert = NO_REVERT;
expectedAccountParams.account = vaults[account];
uint256 expectedBonusMP = _bonusMP(stakeAmount, calcLockUpPeriod);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, calcLockUpPeriod);
if (expectedVaultLockState[expectedAccountParams.account].lockEnd > vm.getBlockTimestamp()) {
// in case stake increased for a locked vault
// increases MP for the previous balance
expectedBonusMP += _bonusMP(expectedAccountParams.stakedBalance, lockUpPeriod);
expectedMaxTotalMP += _maxTotalMP(expectedAccountParams.stakedBalance, lockUpPeriod);
}
if (lockUpPeriod > 0) {
//update lockup end
expectedVaultLockState[expectedAccountParams.account].totalLockUp += lockUpPeriod;
expectedVaultLockState[expectedAccountParams.account].lockEnd = calcLockEnd;
}
expectedAccountParams.stakedBalance = stakeAmount;
expectedAccountParams.vaultBalance = stakeAmount;
expectedSystemState.stakingBalance += stakeAmount;
expectedSystemState.totalStaked += stakeAmount;
expectedAccountParams.mpStaked = stakeAmount + expectedBonusMP;
expectedSystemState.totalMPStaked += stakeAmount + expectedBonusMP;
expectedAccountParams.mpAccrued = stakeAmount + expectedBonusMP;
expectedSystemState.totalMPAccrued += stakeAmount + expectedBonusMP;
expectedAccountParams.maxMP = expectedMaxTotalMP;
expectedSystemState.totalMaxMP += expectedMaxTotalMP;
}
} else {
if (lockUpPeriod > MAX_LOCKUP_PERIOD) {
expectedRevert = IStakeManager.StakingManager__InvalidLockPeriod.selector;
} else {
expectedRevert = StakeMath.StakeMath__InvalidLockingPeriod.selector;
}
return;
}
}
function _expectLock(address account, uint256 lockUpPeriod) internal {
if (lockUpPeriod == 0) {
expectedRevert = IStakeManager.StakingManager__DurationCannotBeZero.selector;
return;
}
if (lockUpPeriod > MAX_LOCKUP_PERIOD) {
expectedRevert = IStakeManager.StakingManager__InvalidLockPeriod.selector;
return;
}
CheckVaultParams storage expectedAccountParams = expectedAccountState[account];
if (expectedAccountParams.vaultBalance == 0) {
expectedRevert = StakeMath.StakeMath__InsufficientBalance.selector;
return;
}
uint256 calcLockEnd = Math.max(
expectedVaultLockState[expectedAccountParams.account].lockEnd, vm.getBlockTimestamp()
) + lockUpPeriod;
uint256 calcLockUpPeriod = calcLockEnd - vm.getBlockTimestamp();
if (!(calcLockUpPeriod >= MIN_LOCKUP_PERIOD && calcLockUpPeriod <= MAX_LOCKUP_PERIOD)) {
if (calcLockUpPeriod > MAX_LOCKUP_PERIOD) {
expectedRevert = IStakeManager.StakingManager__InvalidLockPeriod.selector;
} else {
expectedRevert = StakeMath.StakeMath__InvalidLockingPeriod.selector;
}
return;
}
if (expectedVaultLockState[expectedAccountParams.account].totalLockUp + lockUpPeriod > MAX_LOCKUP_PERIOD) {
// total lock time surpassed the maximum allowed
//expectedRevert = StakeMath.StakeMath__AbsoluteMaxMPOverflow.selector;
expectedRevert = IStakeManager.StakingManager__InvalidLockPeriod.selector;
} else {
expectedRevert = NO_REVERT;
uint256 additionalBonusMP = _bonusMP(expectedAccountParams.vaultBalance, lockUpPeriod);
expectedVaultLockState[expectedAccountParams.account].totalLockUp += lockUpPeriod;
expectedVaultLockState[expectedAccountParams.account].lockEnd = calcLockEnd;
expectedSystemState.totalMPStaked += additionalBonusMP;
expectedSystemState.totalMPAccrued += additionalBonusMP;
expectedSystemState.totalMaxMP += additionalBonusMP;
expectedAccountParams.mpStaked += additionalBonusMP;
expectedAccountParams.mpAccrued += additionalBonusMP;
expectedAccountParams.maxMP += additionalBonusMP;
}
}
function testFuzz_Stake(uint256 stakeAmount, uint64 lockUpPeriod) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
}
function testFuzz_Lock(uint256 stakeAmount, uint64 lockUpPeriod) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
_expectStake(alice, stakeAmount, 0);
_stake(alice, stakeAmount, 0, expectedRevert);
check("Stake:", alice);
_expectLock(alice, lockUpPeriod);
_lock(alice, lockUpPeriod, expectedRevert);
check("Lock: ", alice);
}
function testFuzz_Relock(uint256 stakeAmount, uint64 lockUpPeriod, uint64 lockUpPeriod2) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
_expectLock(alice, lockUpPeriod2);
_lock(alice, lockUpPeriod2, expectedRevert);
check("Lock: ", alice);
}
function testFuzz_AccrueMP(uint128 stakeAmount, uint64 lockUpPeriod, uint64 accruedTime) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
//vm.assume(lockUpPeriod < vm.getBlockTimestamp() - (MAX_LOCKUP_PERIOD*10));
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
_expectAccrue(alice, accruedTime);
_accrue(alice, accruedTime);
check("Accrue: ", alice);
}
function testFuzz_Compound(uint128 stakeAmount, uint64 lockUpPeriod, uint64 accruedTime) public {
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
_expectAccrue(alice, accruedTime);
_accrue(alice, accruedTime);
check("Accrue: ", alice);
_expectCompound(alice);
_compound(alice, expectedRevert);
check("Compound", alice);
}
/**
* uint256 public constant MIN_LOCKUP_PERIOD = 90 days; //7776000 seconds
* uint256 public constant MAX_LOCKUP_PERIOD = MAX_MULTIPLIER * YEAR; // 126230400 seconds
*/
function testFuzz_AccrueMP_Relock(
uint128 stakeAmount,
uint64 lockUpPeriod,
uint64 lockUpPeriod2,
uint64 accruedTime
)
public
{
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
vm.assume(lockUpPeriod == 0 || (lockUpPeriod >= MIN_LOCKUP_PERIOD && lockUpPeriod <= MAX_LOCKUP_PERIOD));
vm.assume(unstakeAmount <= stakeAmount);
vm.assume(accruedTime >= lockUpPeriod);
uint256 expectedMaxTotalMP = _maxTotalMP(stakeAmount, lockUpPeriod);
uint256 expectedStakedMP = _initialMP(stakeAmount) + _bonusMP(stakeAmount, lockUpPeriod);
uint256 rawTotalMP = expectedStakedMP + _accrueMP(stakeAmount, accruedTime);
uint256 expectedTotalMP = Math.min(rawTotalMP, expectedMaxTotalMP);
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
_stake(alice, stakeAmount, lockUpPeriod);
_expectAccrue(alice, accruedTime);
_accrue(alice, accruedTime);
check("Accrue: ", alice);
uint256 currentTime = vm.getBlockTimestamp();
vm.warp(currentTime + accruedTime);
_expectLock(alice, lockUpPeriod2);
_lock(alice, lockUpPeriod2, expectedRevert);
check("Lock: ", alice);
}
_unstake(alice, unstakeAmount);
function testFuzz_Unstake(
uint128 stakeAmount,
uint64 lockUpPeriod,
uint16 accruedTime,
uint128 unstakeAmount
)
public
{
vm.assume(stakeAmount > 0 && stakeAmount <= MAX_BALANCE);
uint256 totalMPAccrued = expectedTotalMP - _reduceMP(stakeAmount, expectedTotalMP, unstakeAmount);
if (totalMPAccrued < expectedStakedMP) {
expectedStakedMP = totalMPAccrued;
_expectStake(alice, stakeAmount, lockUpPeriod);
_stake(alice, stakeAmount, lockUpPeriod, expectedRevert);
check("Stake: ", alice);
if (accruedTime > 0) {
_expectAccrue(alice, accruedTime);
_accrue(alice, accruedTime);
check("Accrue: ", alice);
}
checkStreamer(
CheckStreamerParams({
totalStaked: stakeAmount - unstakeAmount,
totalMPStaked: expectedStakedMP,
totalMPAccrued: totalMPAccrued,
totalMaxMP: expectedMaxTotalMP - _reduceMP(stakeAmount, expectedMaxTotalMP, unstakeAmount),
stakingBalance: stakeAmount - unstakeAmount,
rewardBalance: 0,
rewardIndex: 0
})
);
_expectCompound(alice);
_compound(alice, expectedRevert);
check("Compound", alice);
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount - unstakeAmount,
vaultBalance: stakeAmount - unstakeAmount,
rewardIndex: 0,
mpStaked: expectedStakedMP,
mpAccrued: expectedTotalMP - _reduceMP(stakeAmount, expectedTotalMP, unstakeAmount),
maxMP: expectedMaxTotalMP - _reduceMP(stakeAmount, expectedMaxTotalMP, unstakeAmount),
rewardsAccrued: 0
})
);
_expectUnstake(alice, unstakeAmount);
_unstake(alice, unstakeAmount, expectedRevert);
check("Unstake: ", alice);
}
function testFuzz_Rewards(