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

refactor: update terminology in contract

Browse Source 
Closes #87
This commit is contained in:
r4bbit
2025-01-23 10:32:05 +01:00
parent 1294b76fbd
commit 44deb52c58
10 changed files with 374 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
.gas-report
View File

@@ -1,9 +1,9 @@
| script/DeployRewardsStreamerMP.s.sol:DeployRewardsStreamerMPScript contract | | | | | |
|-----------------------------------------------------------------------------|-----------------|---------|---------|---------|---------|
| Deployment Cost | Deployment Size | | | | |
| 6307818 | 30199 | | | | |
| 6351315 | 30400 | | | | |
| Function Name | min | avg | median | max | # calls |
| run | 5401845 | 5401845 | 5401845 | 5401845 | 63 |
| run | 5443041 | 5443041 | 5443041 | 5443041 | 63 |
| script/DeploymentConfig.s.sol:DeploymentConfig contract | | | | | |
@@ -27,39 +27,39 @@
| Deployment Cost | Deployment Size | | | | |
| 2632986 | 12135 | | | | |
| Function Name | min | avg | median | max | # calls |
| MAX_LOCKUP_PERIOD | 349 | 349 | 349 | 349 | 6 |
| MAX_MULTIPLIER | 251 | 251 | 251 | 251 | 33 |
| MIN_LOCKUP_PERIOD | 297 | 297 | 297 | 297 | 15 |
| MAX_LOCKUP_PERIOD | 371 | 371 | 371 | 371 | 6 |
| MAX_MULTIPLIER | 295 | 295 | 295 | 295 | 33 |
| MIN_LOCKUP_PERIOD | 252 | 252 | 252 | 252 | 15 |
| MP_RATE_PER_YEAR | 253 | 253 | 253 | 253 | 9 |
| STAKING_TOKEN | 428 | 2036 | 2428 | 2428 | 322 |
| emergencyModeEnabled | 2420 | 2420 | 2420 | 2420 | 7 |
| enableEmergencyMode | 2485 | 19392 | 24677 | 24677 | 8 |
| getAccount | 1661 | 1661 | 1661 | 1661 | 72 |
| emergencyModeEnabled | 2398 | 2398 | 2398 | 2398 | 7 |
| enableEmergencyMode | 2507 | 19414 | 24699 | 24699 | 8 |
| getAccountTotalMaxMP | 3122 | 3122 | 3122 | 3122 | 1 |
| getAccountTotalStakedBalance | 15119 | 15119 | 15119 | 15119 | 1 |
| getAccountVaults | 5202 | 5202 | 5202 | 5202 | 4 |
| getStakedBalance | 2629 | 2629 | 2629 | 2629 | 1 |
| getUserTotalMaxMP | 3123 | 3123 | 3123 | 3123 | 1 |
| getUserTotalStakedBalance | 15162 | 15162 | 15162 | 15162 | 1 |
| getUserVaults | 5201 | 5201 | 5201 | 5201 | 4 |
| getVault | 1643 | 1643 | 1643 | 1643 | 72 |
| initialize | 115611 | 115611 | 115611 | 115611 | 65 |
| lastRewardTime | 395 | 1395 | 1395 | 2395 | 2 |
| leave | 59939 | 59939 | 59939 | 59939 | 1 |
| lock | 12063 | 35404 | 16480 | 77670 | 3 |
| mpBalanceOfUser | 9185 | 9185 | 9185 | 9185 | 1 |
| lastRewardTime | 373 | 1373 | 1373 | 2373 | 2 |
| leave | 59961 | 59961 | 59961 | 59961 | 1 |
| lock | 12041 | 35382 | 16458 | 77648 | 3 |
| mpBalanceOfAccount | 9228 | 9228 | 9228 | 9228 | 1 |
| proxiableUUID | 353 | 353 | 353 | 353 | 3 |
| registerVault | 55866 | 72766 | 72966 | 72966 | 257 |
| registerVault | 55888 | 72788 | 72988 | 72988 | 257 |
| rewardEndTime | 373 | 1373 | 1373 | 2373 | 2 |
| rewardStartTime | 352 | 1352 | 1352 | 2352 | 2 |
| rewardsBalanceOf | 3231 | 6627 | 7074 | 7341 | 8 |
| setReward | 2583 | 58371 | 86341 | 105731 | 7 |
| setReward | 2561 | 58349 | 86319 | 105709 | 7 |
| setTrustedCodehash | 24243 | 24304 | 24243 | 26243 | 65 |
| stake | 134841 | 172420 | 179234 | 199567 | 66 |
| totalMPAccrued | 395 | 395 | 395 | 395 | 81 |
| totalMaxMP | 350 | 350 | 350 | 350 | 81 |
| totalRewardsAccrued | 351 | 351 | 351 | 351 | 3 |
| stake | 134819 | 172398 | 179212 | 199545 | 66 |
| totalMPAccrued | 351 | 351 | 351 | 351 | 81 |
| totalMaxMP | 373 | 373 | 373 | 373 | 81 |
| totalRewardsAccrued | 373 | 373 | 373 | 373 | 3 |
| totalRewardsSupply | 1025 | 1984 | 1806 | 6765 | 30 |
| totalStaked | 374 | 374 | 374 | 374 | 82 |
| unstake | 64077 | 64613 | 64077 | 67567 | 13 |
| updateAccountMP | 12217 | 17332 | 17934 | 17934 | 19 |
| updateGlobalState | 14317 | 26623 | 28594 | 28594 | 19 |
| updateGlobalState | 14339 | 26645 | 28616 | 28616 | 19 |
| updateVaultMP | 12238 | 17353 | 17955 | 17955 | 19 |
| upgradeToAndCall | 3225 | 7901 | 8448 | 10936 | 5 |
@@ -68,33 +68,33 @@
| Deployment Cost | Deployment Size | | | | |
| 256467 | 1263 | | | | |
| Function Name | min | avg | median | max | # calls |
| MAX_LOCKUP_PERIOD | 776 | 3776 | 5276 | 5276 | 6 |
| MAX_MULTIPLIER | 678 | 1905 | 678 | 5178 | 33 |
| MIN_LOCKUP_PERIOD | 724 | 3424 | 5224 | 5224 | 15 |
| MAX_LOCKUP_PERIOD | 798 | 3798 | 5298 | 5298 | 6 |
| MAX_MULTIPLIER | 722 | 1949 | 722 | 5222 | 33 |
| MIN_LOCKUP_PERIOD | 679 | 3379 | 5179 | 5179 | 15 |
| MP_RATE_PER_YEAR | 680 | 1180 | 680 | 5180 | 9 |
| STAKING_TOKEN | 855 | 6083 | 7355 | 7355 | 322 |
| emergencyModeEnabled | 7347 | 7347 | 7347 | 7347 | 7 |
| enableEmergencyMode | 28480 | 45381 | 50665 | 50665 | 8 |
| getAccount | 2115 | 2115 | 2115 | 2115 | 72 |
| emergencyModeEnabled | 7325 | 7325 | 7325 | 7325 | 7 |
| enableEmergencyMode | 28502 | 45403 | 50687 | 50687 | 8 |
| getAccountTotalMaxMP | 3552 | 3552 | 3552 | 3552 | 1 |
| getAccountTotalStakedBalance | 15549 | 15549 | 15549 | 15549 | 1 |
| getAccountVaults | 5638 | 6763 | 5638 | 10138 | 4 |
| getStakedBalance | 7559 | 7559 | 7559 | 7559 | 1 |
| getUserTotalMaxMP | 3553 | 3553 | 3553 | 3553 | 1 |
| getUserTotalStakedBalance | 15592 | 15592 | 15592 | 15592 | 1 |
| getUserVaults | 5637 | 6762 | 5637 | 10137 | 4 |
| getVault | 2097 | 2097 | 2097 | 2097 | 72 |
| implementation | 343 | 775 | 343 | 2343 | 412 |
| lastRewardTime | 822 | 1822 | 1822 | 2822 | 2 |
| mpBalanceOfUser | 9615 | 9615 | 9615 | 9615 | 1 |
| lastRewardTime | 800 | 1800 | 1800 | 2800 | 2 |
| mpBalanceOfAccount | 9658 | 9658 | 9658 | 9658 | 1 |
| rewardEndTime | 800 | 1800 | 1800 | 2800 | 2 |
| rewardStartTime | 779 | 4029 | 4029 | 7279 | 2 |
| rewardsBalanceOf | 3661 | 7057 | 7504 | 7771 | 8 |
| setReward | 28863 | 84685 | 112699 | 132089 | 7 |
| setReward | 28841 | 84663 | 112677 | 132067 | 7 |
| setTrustedCodehash | 52889 | 52889 | 52889 | 52889 | 2 |
| totalMPAccrued | 822 | 822 | 822 | 822 | 81 |
| totalMaxMP | 777 | 777 | 777 | 777 | 81 |
| totalRewardsAccrued | 778 | 778 | 778 | 778 | 3 |
| totalMPAccrued | 778 | 778 | 778 | 778 | 81 |
| totalMaxMP | 800 | 800 | 800 | 800 | 81 |
| totalRewardsAccrued | 800 | 800 | 800 | 800 | 3 |
| totalRewardsSupply | 1452 | 2561 | 2233 | 11692 | 30 |
| totalStaked | 801 | 801 | 801 | 801 | 82 |
| updateAccountMP | 38576 | 43691 | 44293 | 44293 | 19 |
| updateGlobalState | 40305 | 52611 | 54582 | 54582 | 19 |
| updateGlobalState | 40327 | 52633 | 54604 | 54604 | 19 |
| updateVaultMP | 38597 | 43712 | 44314 | 44314 | 19 |
| upgradeToAndCall | 29868 | 33720 | 33720 | 37572 | 2 |
@@ -104,12 +104,12 @@
| 1420425 | 6695 | | | | |
| Function Name | min | avg | median | max | # calls |
| STAKING_TOKEN | 216 | 216 | 216 | 216 | 1 |
| emergencyExit | 36375 | 48879 | 48113 | 65213 | 7 |
| leave | 33507 | 132178 | 62113 | 370978 | 4 |
| lock | 33245 | 61600 | 50845 | 111467 | 4 |
| emergencyExit | 36353 | 48857 | 48091 | 65191 | 7 |
| leave | 33507 | 132182 | 62122 | 370978 | 4 |
| lock | 33245 | 61584 | 50823 | 111445 | 4 |
| owner | 2339 | 2339 | 2339 | 2339 | 257 |
| register | 87015 | 103915 | 104115 | 104115 | 257 |
| stake | 33411 | 243748 | 253738 | 274119 | 67 |
| register | 87037 | 103937 | 104137 | 104137 | 257 |
| stake | 33411 | 243726 | 253716 | 274097 | 67 |
| stakeManager | 368 | 368 | 368 | 368 | 257 |
| trustStakeManager | 28953 | 28953 | 28953 | 28953 | 1 |
| unstake | 33282 | 99955 | 105755 | 113604 | 14 |
@@ -142,7 +142,7 @@
| addRewardProvider | 23967 | 57628 | 51089 | 68189 | 44 |
| allowance | 530 | 530 | 530 | 530 | 2 |
| approve | 410 | 410 | 410 | 410 | 2 |
| balanceOf | 3647 | 11313 | 9647 | 20647 | 6 |
| balanceOf | 3601 | 11267 | 9601 | 20601 | 6 |
| getRewardProviders | 1051 | 3304 | 3304 | 5557 | 4 |
| mint | 24199 | 75906 | 91068 | 91080 | 14 |
| mintAllowance | 5714 | 5751 | 5751 | 5788 | 2 |
@@ -206,9 +206,9 @@
| test/mocks/XPProviderMock.sol:XPProviderMock contract | | | | | |
|-------------------------------------------------------|-----------------|-------|--------|-------|---------|
| Deployment Cost | Deployment Size | | | | |
| 177753 | 606 | | | | |
| 177729 | 606 | | | | |
| Function Name | min | avg | median | max | # calls |
| rewardsBalanceOfUser | 524 | 1857 | 2524 | 2524 | 12 |
| rewardsBalanceOfAccount | 501 | 1834 | 2501 | 2501 | 12 |
| setTotalXPShares | 43652 | 43652 | 43652 | 43652 | 20 |
| setUserXPShare | 44125 | 44125 | 44125 | 44125 | 4 |
| totalRewardsSupply | 323 | 989 | 323 | 2323 | 72 |

130
.gas-snapshot
View File

@@ -1,74 +1,74 @@
EmergencyExitTest:test_CannotEnableEmergencyModeTwice() (gas: 92690)
EmergencyExitTest:test_CannotLeaveBeforeEmergencyMode() (gas: 299030)
EmergencyExitTest:test_EmergencyExitBasic() (gas: 385790)
EmergencyExitTest:test_EmergencyExitMultipleUsers() (gas: 664369)
EmergencyExitTest:test_EmergencyExitToAlternateAddress() (gas: 393709)
EmergencyExitTest:test_EmergencyExitWithLock() (gas: 393097)
EmergencyExitTest:test_EmergencyExitWithRewards() (gas: 378651)
EmergencyExitTest:test_OnlyOwnerCanEnableEmergencyMode() (gas: 39426)
IntegrationTest:testStakeFoo() (gas: 1212612)
LeaveTest:test_LeaveShouldProperlyUpdateAccounting() (gas: 5836926)
EmergencyExitTest:test_CannotEnableEmergencyModeTwice() (gas: 92734)
EmergencyExitTest:test_CannotLeaveBeforeEmergencyMode() (gas: 299008)
EmergencyExitTest:test_EmergencyExitBasic() (gas: 385662)
EmergencyExitTest:test_EmergencyExitMultipleUsers() (gas: 664160)
EmergencyExitTest:test_EmergencyExitToAlternateAddress() (gas: 393691)
EmergencyExitTest:test_EmergencyExitWithLock() (gas: 393030)
EmergencyExitTest:test_EmergencyExitWithRewards() (gas: 378630)
EmergencyExitTest:test_OnlyOwnerCanEnableEmergencyMode() (gas: 39470)
IntegrationTest:testStakeFoo() (gas: 1212157)
LeaveTest:test_LeaveShouldProperlyUpdateAccounting() (gas: 5836880)
LeaveTest:test_RevertWhenStakeManagerIsTrusted() (gas: 296161)
LeaveTest:test_TrustNewStakeManager() (gas: 5907344)
LockTest:test_LockFailsWithInvalidPeriod() (gas: 311246)
LockTest:test_LockFailsWithNoStake() (gas: 63730)
LockTest:test_LockWithoutPriorLock() (gas: 390945)
MaliciousUpgradeTest:test_UpgradeStackOverflowStakeManager() (gas: 1746668)
MathTest:test_CalcAbsoluteMaxTotalMP() (gas: 18908)
MathTest:test_CalcAccrueMP() (gas: 22207)
MathTest:test_CalcBonusMP() (gas: 17713)
MathTest:test_CalcInitialMP() (gas: 5395)
MathTest:test_CalcMaxAccruedMP() (gas: 15586)
MathTest:test_CalcMaxTotalMP() (gas: 23298)
MultipleVaultsStakeTest:test_StakeMultipleVaults() (gas: 725628)
LeaveTest:test_TrustNewStakeManager() (gas: 5907277)
LockTest:test_LockFailsWithInvalidPeriod() (gas: 311224)
LockTest:test_LockFailsWithNoStake() (gas: 63663)
LockTest:test_LockWithoutPriorLock() (gas: 390931)
MaliciousUpgradeTest:test_UpgradeStackOverflowStakeManager() (gas: 1746581)
MathTest:test_CalcAbsoluteMaxTotalMP() (gas: 18995)
MathTest:test_CalcAccrueMP() (gas: 22229)
MathTest:test_CalcBonusMP() (gas: 17645)
MathTest:test_CalcInitialMP() (gas: 5330)
MathTest:test_CalcMaxAccruedMP() (gas: 15696)
MathTest:test_CalcMaxTotalMP() (gas: 23339)
MultipleVaultsStakeTest:test_StakeMultipleVaults() (gas: 725540)
NFTMetadataGeneratorSVGTest:testGenerateMetadata() (gas: 85934)
NFTMetadataGeneratorSVGTest:testSetImageStrings() (gas: 58332)
NFTMetadataGeneratorSVGTest:testSetImageStringsRevert() (gas: 35804)
NFTMetadataGeneratorURLTest:testGenerateMetadata() (gas: 102512)
NFTMetadataGeneratorURLTest:testSetBaseURL() (gas: 49555)
NFTMetadataGeneratorURLTest:testSetBaseURLRevert() (gas: 35979)
RewardsStreamerMP_RewardsTest:testRewardsBalanceOf() (gas: 486296)
RewardsStreamerMP_RewardsTest:testSetRewards() (gas: 160703)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadAmount() (gas: 39404)
RewardsStreamerMP_RewardsTest:testRewardsBalanceOf() (gas: 486274)
RewardsStreamerMP_RewardsTest:testSetRewards() (gas: 160637)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadAmount() (gas: 39317)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsBadDuration() (gas: 39340)
RewardsStreamerMP_RewardsTest:testSetRewards_RevertsNotAuthorized() (gas: 39375)
RewardsStreamerMP_RewardsTest:testTotalRewardsSupply() (gas: 618531)
StakeTest:test_StakeMultipleAccounts() (gas: 499536)
StakeTest:test_StakeMultipleAccountsAndRewards() (gas: 505474)
StakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 842540)
StakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 515936)
StakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 537979)
StakeTest:test_StakeOneAccount() (gas: 278268)
StakeTest:test_StakeOneAccountAndRewards() (gas: 284215)
StakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 507661)
StakeTest:test_StakeOneAccountReachingMPLimit() (gas: 499052)
StakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 298123)
StakeTest:test_StakeOneAccountWithMinLockUp() (gas: 299812)
StakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 299879)
RewardsStreamerMP_RewardsTest:testTotalRewardsSupply() (gas: 618553)
StakeTest:test_StakeMultipleAccounts() (gas: 499457)
StakeTest:test_StakeMultipleAccountsAndRewards() (gas: 505374)
StakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 842563)
StakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 515891)
StakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 538001)
StakeTest:test_StakeOneAccount() (gas: 278207)
StakeTest:test_StakeOneAccountAndRewards() (gas: 284155)
StakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 507692)
StakeTest:test_StakeOneAccountReachingMPLimit() (gas: 499083)
StakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 298124)
StakeTest:test_StakeOneAccountWithMinLockUp() (gas: 299768)
StakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 299857)
StakingTokenTest:testStakeToken() (gas: 10422)
UnstakeTest:test_StakeMultipleAccounts() (gas: 499558)
UnstakeTest:test_StakeMultipleAccountsAndRewards() (gas: 505496)
UnstakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 842562)
UnstakeTest:test_StakeMultipleAccounts() (gas: 499479)
UnstakeTest:test_StakeMultipleAccountsAndRewards() (gas: 505396)
UnstakeTest:test_StakeMultipleAccountsMPIncreasesMaxMPDoesNotChange() (gas: 842585)
UnstakeTest:test_StakeMultipleAccountsWithMinLockUp() (gas: 515935)
UnstakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 538001)
UnstakeTest:test_StakeOneAccount() (gas: 278291)
UnstakeTest:test_StakeOneAccountAndRewards() (gas: 284259)
UnstakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 507705)
UnstakeTest:test_StakeOneAccountReachingMPLimit() (gas: 499054)
UnstakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 298123)
UnstakeTest:test_StakeOneAccountWithMinLockUp() (gas: 299812)
UnstakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 299878)
UnstakeTest:test_UnstakeBonusMPAndAccuredMP() (gas: 546326)
UnstakeTest:test_UnstakeMultipleAccounts() (gas: 705083)
UnstakeTest:test_UnstakeMultipleAccountsAndRewards() (gas: 800935)
UnstakeTest:test_UnstakeOneAccount() (gas: 480104)
UnstakeTest:test_UnstakeOneAccountAndAccruedMP() (gas: 502976)
UnstakeTest:test_UnstakeOneAccountAndRewards() (gas: 409152)
UnstakeTest:test_UnstakeOneAccountWithLockUpAndAccruedMP() (gas: 531453)
UnstakeTest:test_StakeMultipleAccountsWithRandomLockUp() (gas: 537957)
UnstakeTest:test_StakeOneAccount() (gas: 278230)
UnstakeTest:test_StakeOneAccountAndRewards() (gas: 284133)
UnstakeTest:test_StakeOneAccountMPIncreasesMaxMPDoesNotChange() (gas: 507736)
UnstakeTest:test_StakeOneAccountReachingMPLimit() (gas: 499040)
UnstakeTest:test_StakeOneAccountWithMaxLockUp() (gas: 298124)
UnstakeTest:test_StakeOneAccountWithMinLockUp() (gas: 299768)
UnstakeTest:test_StakeOneAccountWithRandomLockUp() (gas: 299856)
UnstakeTest:test_UnstakeBonusMPAndAccuredMP() (gas: 546251)
UnstakeTest:test_UnstakeMultipleAccounts() (gas: 704925)
UnstakeTest:test_UnstakeMultipleAccountsAndRewards() (gas: 800718)
UnstakeTest:test_UnstakeOneAccount() (gas: 479941)
UnstakeTest:test_UnstakeOneAccountAndAccruedMP() (gas: 502893)
UnstakeTest:test_UnstakeOneAccountAndRewards() (gas: 409031)
UnstakeTest:test_UnstakeOneAccountWithLockUpAndAccruedMP() (gas: 531430)
UpgradeTest:test_RevertWhenNotOwner() (gas: 2709437)
UpgradeTest:test_UpgradeStakeManager() (gas: 5749483)
VaultRegistrationTest:test_VaultRegistration() (gas: 62013)
WithdrawTest:test_CannotWithdrawStakedFunds() (gas: 311863)
UpgradeTest:test_UpgradeStakeManager() (gas: 5749376)
VaultRegistrationTest:test_VaultRegistration() (gas: 62017)
WithdrawTest:test_CannotWithdrawStakedFunds() (gas: 311841)
XPNFTTokenTest:testApproveNotAllowed() (gas: 10500)
XPNFTTokenTest:testGetApproved() (gas: 10523)
XPNFTTokenTest:testIsApprovedForAll() (gas: 10698)
@@ -79,9 +79,9 @@ XPNFTTokenTest:testSetMetadataGenerator() (gas: 969770)
XPNFTTokenTest:testSetMetadataGeneratorRevert() (gas: 966301)
XPNFTTokenTest:testTokenURI() (gas: 103894)
XPNFTTokenTest:testTransferNotAllowed() (gas: 10715)
XPTokenMintAllowanceTest:testAddXPProviderOnlyOwner() (gas: 311380)
XPTokenMintAllowanceTest:testBalanceOf() (gas: 294627)
XPTokenMintAllowanceTest:testBalanceOfWithNoSystemTotalXP() (gas: 43477)
XPTokenMintAllowanceTest:testAddXPProviderOnlyOwner() (gas: 311356)
XPTokenMintAllowanceTest:testBalanceOf() (gas: 294581)
XPTokenMintAllowanceTest:testBalanceOfWithNoSystemTotalXP() (gas: 43385)
XPTokenMintAllowanceTest:testMintAllowance_Available() (gas: 205305)
XPTokenMintAllowanceTest:testMintAllowance_NotAvailable() (gas: 205241)
XPTokenMintAllowanceTest:testMintOnlyOwner() (gas: 242059)
@@ -93,9 +93,9 @@ XPTokenMintAllowanceTest:testTotalSupply() (gas: 202556)
XPTokenMintAllowanceTest:testTransfersNotAllowed() (gas: 20653)
XPTokenOwnershipTest:testInitialOwner() (gas: 12612)
XPTokenOwnershipTest:testOwnershipTransfer() (gas: 87164)
XPTokenTest:testAddXPProviderOnlyOwner() (gas: 311412)
XPTokenTest:testBalanceOf() (gas: 294631)
XPTokenTest:testBalanceOfWithNoSystemTotalXP() (gas: 43454)
XPTokenTest:testAddXPProviderOnlyOwner() (gas: 311388)
XPTokenTest:testBalanceOf() (gas: 294585)
XPTokenTest:testBalanceOfWithNoSystemTotalXP() (gas: 43362)
XPTokenTest:testMintOnlyOwner() (gas: 242035)
XPTokenTest:testRemoveXPProviderIndexOutOfBounds() (gas: 36267)
XPTokenTest:testRemoveXPProviderOnlyOwner() (gas: 72129)

14
certora/specs/EmergencyMode.spec
View File

@@ -19,12 +19,12 @@ definition isViewFunction(method f) returns bool = (
f.selector == sig:streamer.totalStaked().selector ||
f.selector == sig:streamer.totalMaxMP().selector ||
f.selector == sig:streamer.totalMPAccrued().selector ||
f.selector == sig:streamer.accounts(address).selector ||
f.selector == sig:streamer.vaultData(address).selector ||
f.selector == sig:streamer.emergencyModeEnabled().selector ||
f.selector == sig:streamer.getStakedBalance(address).selector ||
f.selector == sig:streamer.getAccount(address).selector ||
f.selector == sig:streamer.getVault(address).selector ||
f.selector == sig:streamer.rewardsBalanceOf(address).selector ||
f.selector == sig:streamer.rewardsBalanceOfUser(address).selector ||
f.selector == sig:streamer.rewardsBalanceOfAccount(address).selector ||
f.selector == sig:streamer.pendingRewardIndex().selector ||
f.selector == sig:streamer.totalRewardsSupply().selector ||
f.selector == sig:streamer.lastRewardTime().selector ||
@@ -33,13 +33,13 @@ definition isViewFunction(method f) returns bool = (
f.selector == sig:streamer.rewardStartTime().selector ||
f.selector == sig:streamer.rewardEndTime().selector ||
f.selector == sig:streamer.mpBalanceOf(address).selector ||
f.selector == sig:streamer.mpBalanceOfUser(address).selector ||
f.selector == sig:streamer.getUserTotalMaxMP(address).selector ||
f.selector == sig:streamer.getUserTotalStakedBalance(address).selector ||
f.selector == sig:streamer.mpBalanceOfAccount(address).selector ||
f.selector == sig:streamer.getAccountTotalMaxMP(address).selector ||
f.selector == sig:streamer.getAccountTotalStakedBalance(address).selector ||
f.selector == sig:streamer.vaults(address,uint256).selector ||
f.selector == sig:streamer.vaultOwners(address).selector ||
f.selector == sig:streamer.registerVault().selector ||
f.selector == sig:streamer.getUserVaults(address).selector
f.selector == sig:streamer.getAccountVaults(address).selector
);
definition isOwnableFunction(method f) returns bool = (

44
certora/specs/RewardsStreamerMP.spec
View File

@@ -7,10 +7,10 @@ methods {
function ERC20A.allowance(address, address) external returns(uint256) envfree;
function ERC20A.totalSupply() external returns(uint256) envfree;
function totalStaked() external returns (uint256) envfree;
function accounts(address) external returns (uint256, uint256, uint256, uint256, uint256, uint256) envfree;
function vaultData(address) external returns (uint256, uint256, uint256, uint256, uint256, uint256) envfree;
function lastMPUpdatedTime() external returns (uint256) envfree;
function updateGlobalState() external;
function updateAccountMP(address accountAddress) external;
function updateVaultMP(address vaultAddress) external;
function emergencyModeEnabled() external returns (bool) envfree;
function leave() external;
function Math.mulDiv(uint256 a, uint256 b, uint256 c) internal returns uint256 => mulDivSummary(a,b,c);
@@ -25,25 +25,25 @@ ghost mathint sumOfBalances {
init_state axiom sumOfBalances == 0;
}
hook Sstore accounts[KEY address account].stakedBalance uint256 newValue (uint256 oldValue) {
hook Sstore vaultData[KEY address vault].stakedBalance uint256 newValue (uint256 oldValue) {
sumOfBalances = sumOfBalances - oldValue + newValue;
}
function getAccountMaxMP(address account) returns uint256 {
function getVaultMaxMP(address vault) returns uint256 {
uint256 maxMP;
_, _, _, maxMP, _, _ = streamer.accounts(account);
_, _, _, maxMP, _, _ = streamer.vaultData(vault);
return maxMP;
}
function getAccountMP(address account) returns uint256 {
uint256 accountMP;
_, _, accountMP, _, _, _ = streamer.accounts(account);
return accountMP;
function getVaultMPAccrued(address vault) returns uint256 {
uint256 vaultMPAccrued;
_, _, vaultMPAccrued, _, _, _ = streamer.vaultData(vault);
return vaultMPAccrued;
}
function getAccountLockUntil(address account) returns uint256 {
function getVaultLockUntil(address vault) returns uint256 {
uint256 lockUntil;
_, _, _, _, _, lockUntil = streamer.accounts(account);
_, _, _, _, _, lockUntil = streamer.vaultData(vault);
return lockUntil;
}
@@ -53,14 +53,14 @@ invariant sumOfBalancesIsTotalStaked()
f -> f.selector != sig:upgradeToAndCall(address,bytes).selector
}
invariant accountMPLessEqualAccountMaxMP(address account)
to_mathint(getAccountMP(account)) <= to_mathint(getAccountMaxMP(account))
invariant vaultMPLessEqualVaultMaxMP(address vault)
to_mathint(getVaultMPAccrued(vault)) <= to_mathint(getVaultMaxMP(vault))
filtered {
f -> f.selector != sig:upgradeToAndCall(address,bytes).selector
}
invariant accountMPGreaterEqualAccountStakedBalance(address account)
to_mathint(getAccountMP(account)) >= to_mathint(getAccountStakedBalance(account))
invariant vaultMPGreaterEqualVaultStakedBalance(address vault)
to_mathint(getVaultMPAccrued(vault)) >= to_mathint(getVaultStakedBalance(vault))
filtered {
f -> f.selector != sig:upgradeToAndCall(address,bytes).selector
}
@@ -73,15 +73,15 @@ rule stakingMintsMultiplierPoints1To1Ratio {
uint256 multiplierPointsBefore;
uint256 multiplierPointsAfter;
requireInvariant accountMPGreaterEqualAccountStakedBalance(e.msg.sender);
requireInvariant vaultMPGreaterEqualVaultStakedBalance(e.msg.sender);
require getAccountLockUntil(e.msg.sender) <= e.block.timestamp;
require getVaultLockUntil(e.msg.sender) <= e.block.timestamp;
updateGlobalState(e);
updateAccountMP(e, e.msg.sender);
updateVaultMP(e, e.msg.sender);
uint256 t = lastMPUpdatedTime();
multiplierPointsBefore = getAccountMP(e.msg.sender);
multiplierPointsBefore = getVaultMPAccrued(e.msg.sender);
stake(e, amount, lockupTime);
@@ -89,7 +89,7 @@ rule stakingMintsMultiplierPoints1To1Ratio {
// which makes it harder to proof this rule
require lastMPUpdatedTime() == t;
multiplierPointsAfter = getAccountMP(e.msg.sender);
multiplierPointsAfter = getVaultMPAccrued(e.msg.sender);
assert lockupTime == 0 => to_mathint(multiplierPointsAfter) == multiplierPointsBefore + amount;
assert to_mathint(multiplierPointsAfter) >= multiplierPointsBefore + amount;
@@ -107,10 +107,10 @@ rule stakingGreaterLockupTimeMeansGreaterMPs {
storage initalStorage = lastStorage;
stake(e, amount, lockupTime1);
multiplierPointsAfter1 = getAccountMP(e.msg.sender);
multiplierPointsAfter1 = getVaultMPAccrued(e.msg.sender);
stake(e, amount, lockupTime2) at initalStorage;
multiplierPointsAfter2 = getAccountMP(e.msg.sender);
multiplierPointsAfter2 = getVaultMPAccrued(e.msg.sender);
assert lockupTime1 >= lockupTime2 => to_mathint(multiplierPointsAfter1) >= to_mathint(multiplierPointsAfter2);
satisfy to_mathint(multiplierPointsAfter1) > to_mathint(multiplierPointsAfter2);

4
certora/specs/shared.spec
View File

@@ -1,8 +1,8 @@
using RewardsStreamerMP as streamer;
function getAccountStakedBalance(address account) returns uint256 {
function getVaultStakedBalance(address vault) returns uint256 {
uint256 stakedBalance;
stakedBalance, _, _, _, _, _ = streamer.accounts(account);
stakedBalance, _, _, _, _, _ = streamer.vaultData(vault);
return stakedBalance;
}

202
src/RewardsStreamerMP.sol
View File

@@ -56,16 +56,16 @@ contract RewardsStreamerMP is
uint256 public rewardStartTime;
uint256 public rewardEndTime;
struct Account {
struct VaultData {
uint256 stakedBalance;
uint256 accountRewardIndex;
uint256 rewardIndex;
uint256 mpAccrued;
uint256 maxMP;
uint256 lastMPUpdateTime;
uint256 lockUntil;
}
mapping(address vault => Account data) public accounts;
mapping(address vault => VaultData data) public vaultData;
mapping(address owner => address[] vault) public vaults;
mapping(address vault => address owner) public vaultOwners;
@@ -123,60 +123,60 @@ contract RewardsStreamerMP is
/**
* @notice Get the vaults owned by a user
* @param user The address of the user
* @param account The address of the user
* @return The vaults owned by the user
*/
function getUserVaults(address user) external view returns (address[] memory) {
return vaults[user];
function getAccountVaults(address account) external view returns (address[] memory) {
return vaults[account];
}
/**
* @notice Get the total multiplier points for a user
* @dev Iterates over all vaults owned by the user and sums the multiplier points
* @param user The address of the user
* @param account The address of the user
* @return The total multiplier points for the user
*/
function mpBalanceOfUser(address user) external view returns (uint256) {
address[] memory userVaults = vaults[user];
uint256 userTotalMP = 0;
function mpBalanceOfAccount(address account) external view returns (uint256) {
address[] memory accountVaults = vaults[account];
uint256 accountTotalMP = 0;
for (uint256 i = 0; i < userVaults.length; i++) {
Account storage account = accounts[userVaults[i]];
userTotalMP += account.mpAccrued + _getAccountPendingdMP(account);
for (uint256 i = 0; i < accountVaults.length; i++) {
VaultData storage vault = vaultData[accountVaults[i]];
accountTotalMP += vault.mpAccrued + _getVaultPendingMP(vault);
}
return userTotalMP;
return accountTotalMP;
}
/**
* @notice Get the total maximum multiplier points for a user
* @dev Iterates over all vaults owned by the user and sums the maximum multiplier points
* @param user The address of the user
* @param account The address of the user
* @return The total maximum multiplier points for the user
*/
function getUserTotalMaxMP(address user) external view returns (uint256) {
address[] memory userVaults = vaults[user];
uint256 userTotalMaxMP = 0;
function getAccountTotalMaxMP(address account) external view returns (uint256) {
address[] memory accountVaults = vaults[account];
uint256 accountTotalMaxMP = 0;
for (uint256 i = 0; i < userVaults.length; i++) {
userTotalMaxMP += accounts[userVaults[i]].maxMP;
for (uint256 i = 0; i < accountVaults.length; i++) {
accountTotalMaxMP += vaultData[accountVaults[i]].maxMP;
}
return userTotalMaxMP;
return accountTotalMaxMP;
}
/**
* @notice Get the total staked balance for a user
* @dev Iterates over all vaults owned by the user and sums the staked balances
* @param user The address of the user
* @param account The address of the user
* @return The total staked balance for the user
*/
function getUserTotalStakedBalance(address user) external view returns (uint256) {
address[] memory userVaults = vaults[user];
uint256 userTotalStake = 0;
function getAccountTotalStakedBalance(address account) external view returns (uint256) {
address[] memory accountVaults = vaults[account];
uint256 accountTotalStake = 0;
for (uint256 i = 0; i < userVaults.length; i++) {
userTotalStake += accounts[userVaults[i]].stakedBalance;
for (uint256 i = 0; i < accountVaults.length; i++) {
accountTotalStake += vaultData[accountVaults[i]].stakedBalance;
}
return userTotalStake;
return accountTotalStake;
}
function stake(
@@ -198,14 +198,14 @@ contract RewardsStreamerMP is
}
_updateGlobalState();
_updateAccountMP(msg.sender, true);
_updateVaultMP(msg.sender, true);
Account storage account = accounts[msg.sender];
if (account.lockUntil != 0 && account.lockUntil > block.timestamp) {
VaultData storage vault = vaultData[msg.sender];
if (vault.lockUntil != 0 && vault.lockUntil > block.timestamp) {
revert StakingManager__CannotRestakeWithLockedFunds();
}
account.stakedBalance += amount;
vault.stakedBalance += amount;
totalStaked += amount;
uint256 initialMP = amount;
@@ -214,21 +214,21 @@ contract RewardsStreamerMP is
if (lockPeriod != 0) {
bonusMP = _calculateBonusMP(amount, lockPeriod);
account.lockUntil = block.timestamp + lockPeriod;
vault.lockUntil = block.timestamp + lockPeriod;
} else {
account.lockUntil = 0;
vault.lockUntil = 0;
}
uint256 accountMaxMP = initialMP + bonusMP + potentialMP;
uint256 accountMP = initialMP + bonusMP;
uint256 vaultMaxMP = initialMP + bonusMP + potentialMP;
uint256 vaultMP = initialMP + bonusMP;
account.mpAccrued += accountMP;
totalMPAccrued += accountMP;
vault.mpAccrued += vaultMP;
totalMPAccrued += vaultMP;
account.maxMP += accountMaxMP;
totalMaxMP += accountMaxMP;
vault.maxMP += vaultMaxMP;
totalMaxMP += vaultMaxMP;
account.accountRewardIndex = rewardIndex;
vault.rewardIndex = rewardIndex;
}
function lock(uint256 lockPeriod)
@@ -242,31 +242,31 @@ contract RewardsStreamerMP is
revert StakingManager__InvalidLockingPeriod();
}
Account storage account = accounts[msg.sender];
VaultData storage vault = vaultData[msg.sender];
if (account.lockUntil > 0) {
if (vault.lockUntil > 0) {
revert StakingManager__AlreadyLocked();
}
if (account.stakedBalance == 0) {
if (vault.stakedBalance == 0) {
revert StakingManager__InsufficientBalance();
}
_updateGlobalState();
_updateAccountMP(msg.sender, true);
_updateVaultMP(msg.sender, true);
uint256 additionalBonusMP = _calculateBonusMP(account.stakedBalance, lockPeriod);
uint256 additionalBonusMP = _calculateBonusMP(vault.stakedBalance, lockPeriod);
// Update account state
account.lockUntil = block.timestamp + lockPeriod;
account.mpAccrued += additionalBonusMP;
account.maxMP += additionalBonusMP;
// Update vault state
vault.lockUntil = block.timestamp + lockPeriod;
vault.mpAccrued += additionalBonusMP;
vault.maxMP += additionalBonusMP;
// Update global state
totalMPAccrued += additionalBonusMP;
totalMaxMP += additionalBonusMP;
account.accountRewardIndex = rewardIndex;
vault.rewardIndex = rewardIndex;
}
function unstake(uint256 amount)
@@ -276,31 +276,31 @@ contract RewardsStreamerMP is
onlyRegisteredVault
nonReentrant
{
Account storage account = accounts[msg.sender];
if (amount > account.stakedBalance) {
VaultData storage vault = vaultData[msg.sender];
if (amount > vault.stakedBalance) {
revert StakingManager__InsufficientBalance();
}
if (block.timestamp < account.lockUntil) {
if (block.timestamp < vault.lockUntil) {
revert StakingManager__TokensAreLocked();
}
_unstake(amount, account, msg.sender);
_unstake(amount, vault, msg.sender);
}
function _unstake(uint256 amount, Account storage account, address accountAddress) internal {
function _unstake(uint256 amount, VaultData storage vault, address vaultAddress) internal {
_updateGlobalState();
_updateAccountMP(accountAddress, true);
_updateVaultMP(vaultAddress, true);
uint256 previousStakedBalance = account.stakedBalance;
uint256 previousStakedBalance = vault.stakedBalance;
// solhint-disable-next-line
uint256 mpToReduce = Math.mulDiv(account.mpAccrued, amount, previousStakedBalance);
uint256 maxMPToReduce = Math.mulDiv(account.maxMP, amount, previousStakedBalance);
uint256 mpToReduce = Math.mulDiv(vault.mpAccrued, amount, previousStakedBalance);
uint256 maxMPToReduce = Math.mulDiv(vault.maxMP, amount, previousStakedBalance);
account.stakedBalance -= amount;
account.mpAccrued -= mpToReduce;
account.maxMP -= maxMPToReduce;
account.accountRewardIndex = rewardIndex;
vault.stakedBalance -= amount;
vault.mpAccrued -= mpToReduce;
vault.maxMP -= maxMPToReduce;
vault.rewardIndex = rewardIndex;
totalMPAccrued -= mpToReduce;
totalMaxMP -= maxMPToReduce;
totalStaked -= amount;
@@ -312,15 +312,15 @@ contract RewardsStreamerMP is
// This ensures `StakeVault`s will call this function only if they don't
// trust the `StakeManager` (e.g. in case of an upgrade).
function leave() external onlyTrustedCodehash nonReentrant {
Account storage account = accounts[msg.sender];
VaultData storage vault = vaultData[msg.sender];
if (account.stakedBalance > 0) {
if (vault.stakedBalance > 0) {
// calling `_unstake` to update accounting accordingly
_unstake(account.stakedBalance, account, msg.sender);
_unstake(vault.stakedBalance, vault, msg.sender);
// further cleanup that isn't done in `_unstake`
account.accountRewardIndex = 0;
account.lockUntil = 0;
vault.rewardIndex = 0;
vault.lockUntil = 0;
}
}
@@ -469,35 +469,35 @@ contract RewardsStreamerMP is
return Math.mulDiv(amount, lockPeriod, YEAR);
}
function _getAccountPendingdMP(Account storage account) internal view returns (uint256) {
if (account.maxMP == 0 || account.stakedBalance == 0) {
function _getVaultPendingMP(VaultData storage vault) internal view returns (uint256) {
if (vault.maxMP == 0 || vault.stakedBalance == 0) {
return 0;
}
uint256 timeDiff = block.timestamp - account.lastMPUpdateTime;
uint256 timeDiff = block.timestamp - vault.lastMPUpdateTime;
if (timeDiff == 0) {
return 0;
}
uint256 accruedMP = Math.mulDiv(timeDiff * account.stakedBalance, MP_RATE_PER_YEAR, YEAR);
uint256 accruedMP = Math.mulDiv(timeDiff * vault.stakedBalance, MP_RATE_PER_YEAR, YEAR);
if (account.mpAccrued + accruedMP > account.maxMP) {
accruedMP = account.maxMP - account.mpAccrued;
if (vault.mpAccrued + accruedMP > vault.maxMP) {
accruedMP = vault.maxMP - vault.mpAccrued;
}
return accruedMP;
}
function _updateAccountMP(address accountAddress, bool forceMPUpdate) internal {
Account storage account = accounts[accountAddress];
uint256 accruedMP = _getAccountPendingdMP(account);
function _updateVaultMP(address vaultAddress, bool forceMPUpdate) internal {
VaultData storage vault = vaultData[vaultAddress];
uint256 accruedMP = _getVaultPendingMP(vault);
if (accruedMP > 0 || forceMPUpdate) {
account.mpAccrued += accruedMP;
account.lastMPUpdateTime = block.timestamp;
vault.mpAccrued += accruedMP;
vault.lastMPUpdateTime = block.timestamp;
}
}
function updateAccountMP(address accountAddress) external onlyNotEmergencyMode {
_updateAccountMP(accountAddress, false);
function updateVaultMP(address vaultAddress) external onlyNotEmergencyMode {
_updateVaultMP(vaultAddress, false);
}
function enableEmergencyMode() external onlyOwner {
@@ -507,47 +507,47 @@ contract RewardsStreamerMP is
emergencyModeEnabled = true;
}
function getStakedBalance(address accountAddress) public view returns (uint256) {
return accounts[accountAddress].stakedBalance;
function getStakedBalance(address vaultAddress) public view returns (uint256) {
return vaultData[vaultAddress].stakedBalance;
}
function getAccount(address accountAddress) external view returns (Account memory) {
return accounts[accountAddress];
function getVault(address vaultAddress) external view returns (VaultData memory) {
return vaultData[vaultAddress];
}
function totalRewardsSupply() public view returns (uint256) {
return totalRewardsAccrued + _calculatePendingRewards();
}
function rewardsBalanceOf(address accountAddress) public view returns (uint256) {
function rewardsBalanceOf(address vaultAddress) public view returns (uint256) {
uint256 newRewardIndex;
(, newRewardIndex) = _pendingRewardIndex();
Account storage account = accounts[accountAddress];
VaultData storage vault = vaultData[vaultAddress];
uint256 accountWeight = account.stakedBalance + _mpBalanceOf(accountAddress);
uint256 deltaRewardIndex = newRewardIndex - account.accountRewardIndex;
uint256 accountWeight = vault.stakedBalance + _mpBalanceOf(vaultAddress);
uint256 deltaRewardIndex = newRewardIndex - vault.rewardIndex;
return (accountWeight * deltaRewardIndex) / SCALE_FACTOR;
}
function rewardsBalanceOfUser(address user) external view returns (uint256) {
address[] memory userVaults = vaults[user];
uint256 userTotalRewards = 0;
function rewardsBalanceOfAccount(address account) external view returns (uint256) {
address[] memory accountVaults = vaults[account];
uint256 accountTotalRewards = 0;
for (uint256 i = 0; i < userVaults.length; i++) {
userTotalRewards += rewardsBalanceOf(userVaults[i]);
for (uint256 i = 0; i < accountVaults.length; i++) {
accountTotalRewards += rewardsBalanceOf(accountVaults[i]);
}
return userTotalRewards;
return accountTotalRewards;
}
function _mpBalanceOf(address accountAddress) internal view returns (uint256) {
Account storage account = accounts[accountAddress];
return account.mpAccrued + _getAccountPendingdMP(account);
function _mpBalanceOf(address vaultAddress) internal view returns (uint256) {
VaultData storage vault = vaultData[vaultAddress];
return vault.mpAccrued + _getVaultPendingMP(vault);
}
function mpBalanceOf(address accountAddress) external view returns (uint256) {
return _mpBalanceOf(accountAddress);
function mpBalanceOf(address vaultAddress) external view returns (uint256) {
return _mpBalanceOf(vaultAddress);
}
}

2
src/XPToken.sol
View File

@@ -80,7 +80,7 @@ contract XPToken is ERC20, Ownable2Step {
for (uint256 i = 0; i < rewardProviders.length; i++) {
IRewardProvider provider = rewardProviders[i];
externalBalance += provider.rewardsBalanceOfUser(account);
externalBalance += provider.rewardsBalanceOfAccount(account);
}
return super.balanceOf(account) + externalBalance;

2
src/interfaces/IRewardProvider.sol
View File

@@ -4,5 +4,5 @@ pragma solidity ^0.8.26;
interface IRewardProvider {
function totalRewardsSupply() external view returns (uint256);
function rewardsBalanceOf(address account) external view returns (uint256);
function rewardsBalanceOfUser(address user) external view returns (uint256);
function rewardsBalanceOfAccount(address user) external view returns (uint256);
}

252
test/RewardsStreamerMP.t.sol
View File

@@ -68,7 +68,7 @@ contract RewardsStreamerMPTest is Test {
// assertEq(streamer.rewardIndex(), p.rewardIndex, "wrong reward index");
}
struct CheckAccountParams {
struct CheckVaultParams {
address account;
uint256 rewardBalance;
uint256 stakedBalance;
@@ -78,16 +78,16 @@ contract RewardsStreamerMPTest is Test {
uint256 maxMP;
}
function checkAccount(CheckAccountParams memory p) public view {
function checkVault(CheckVaultParams memory p) public view {
// assertEq(rewardToken.balanceOf(p.account), p.rewardBalance, "wrong account reward balance");
RewardsStreamerMP.Account memory accountInfo = streamer.getAccount(p.account);
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(p.account);
assertEq(accountInfo.stakedBalance, p.stakedBalance, "wrong account staked balance");
assertEq(vaultData.stakedBalance, p.stakedBalance, "wrong account staked balance");
assertEq(stakingToken.balanceOf(p.account), p.vaultBalance, "wrong vault balance");
// assertEq(accountInfo.accountRewardIndex, p.rewardIndex, "wrong account reward index");
assertEq(accountInfo.mpAccrued, p.mpAccrued, "wrong account MP");
assertEq(accountInfo.maxMP, p.maxMP, "wrong account max MP");
// assertEq(vaultData.accountRewardIndex, p.rewardIndex, "wrong account reward index");
assertEq(vaultData.mpAccrued, p.mpAccrued, "wrong account MP");
assertEq(vaultData.maxMP, p.maxMP, "wrong account max MP");
}
struct CheckUserTotalsParams {
@@ -98,9 +98,9 @@ contract RewardsStreamerMPTest is Test {
}
function checkUserTotals(CheckUserTotalsParams memory p) public view {
assertEq(streamer.getUserTotalStakedBalance(p.user), p.totalStakedBalance, "wrong user total stake balance");
assertEq(streamer.mpBalanceOfUser(p.user), p.totalMPAccrued, "wrong user total MP");
assertEq(streamer.getUserTotalMaxMP(p.user), p.totalMaxMP, "wrong user total MP");
assertEq(streamer.getAccountTotalStakedBalance(p.user), p.totalStakedBalance, "wrong user total stake balance");
assertEq(streamer.mpBalanceOfAccount(p.user), p.totalMPAccrued, "wrong user total MP");
assertEq(streamer.getAccountTotalMaxMP(p.user), p.totalMaxMP, "wrong user total MP");
}
function _createTestVault(address owner) internal returns (StakeVault vault) {
@@ -239,7 +239,7 @@ contract VaultRegistrationTest is RewardsStreamerMPTest {
function test_VaultRegistration() public view {
address[4] memory accounts = [alice, bob, charlie, dave];
for (uint256 i = 0; i < accounts.length; i++) {
address[] memory userVaults = streamer.getUserVaults(accounts[i]);
address[] memory userVaults = streamer.getAccountVaults(accounts[i]);
assertEq(userVaults.length, 1, "wrong number of vaults");
assertEq(userVaults[0], vaults[accounts[i]], "wrong vault address");
}
@@ -281,8 +281,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -307,8 +307,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -319,8 +319,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -346,8 +346,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -358,8 +358,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -402,8 +402,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 250e18,
stakedBalance: 0e18,
@@ -414,8 +414,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -440,8 +440,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 250e18,
stakedBalance: 0e18,
@@ -452,8 +452,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -464,8 +464,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[charlie],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -491,8 +491,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 250e18,
stakedBalance: 0e18,
@@ -503,8 +503,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -515,8 +515,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[charlie],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -542,8 +542,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 250e18,
stakedBalance: 0e18,
@@ -554,8 +554,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
// bob had 30 staked + 30 initial MP + 15 MP accrued in 6 months
// so in the second bucket we have 1000 rewards with
@@ -573,8 +573,8 @@ contract IntegrationTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[charlie],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -606,8 +606,8 @@ contract StakeTest is RewardsStreamerMPTest {
rewardIndex: 0
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -633,8 +633,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -741,7 +741,7 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + (365 days));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
uint256 expectedMPIncrease = stakeAmount; // 1 year passed, 1 MP accrued per token staked
totalMPAccrued = totalMPAccrued + expectedMPIncrease;
@@ -757,8 +757,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -773,7 +773,7 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + (365 days / 2));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
expectedMPIncrease = stakeAmount / 2; // 1/2 year passed, 1/2 MP accrued per token staked
totalMPAccrued = totalMPAccrued + expectedMPIncrease;
@@ -789,8 +789,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -820,8 +820,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -837,7 +837,7 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + timeToMaxMP);
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
checkStreamer(
CheckStreamerParams({
@@ -850,8 +850,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -868,7 +868,7 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + 14 days);
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
checkStreamer(
CheckStreamerParams({
@@ -900,8 +900,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -912,8 +912,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -943,8 +943,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -955,8 +955,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -1069,8 +1069,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: aliceStakeAmount,
@@ -1080,8 +1080,8 @@ contract StakeTest is RewardsStreamerMPTest {
maxMP: aliceMaxMP
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: bobStakeAmount,
@@ -1096,8 +1096,8 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + (365 days));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateAccountMP(vaults[bob]);
streamer.updateVaultMP(vaults[alice]);
streamer.updateVaultMP(vaults[bob]);
uint256 aliceExpectedMPIncrease = aliceStakeAmount; // 1 year passed, 1 MP accrued per token staked
uint256 bobExpectedMPIncrease = bobStakeAmount; // 1 year passed, 1 MP accrued per token staked
@@ -1118,8 +1118,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: aliceStakeAmount,
@@ -1129,8 +1129,8 @@ contract StakeTest is RewardsStreamerMPTest {
maxMP: aliceMaxMP
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: bobStakeAmount,
@@ -1145,8 +1145,8 @@ contract StakeTest is RewardsStreamerMPTest {
vm.warp(currentTime + (365 days / 2));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateAccountMP(vaults[bob]);
streamer.updateVaultMP(vaults[alice]);
streamer.updateVaultMP(vaults[bob]);
aliceExpectedMPIncrease = aliceStakeAmount / 2;
bobExpectedMPIncrease = bobStakeAmount / 2;
@@ -1167,8 +1167,8 @@ contract StakeTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: aliceStakeAmount,
@@ -1178,8 +1178,8 @@ contract StakeTest is RewardsStreamerMPTest {
maxMP: aliceMaxMP
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: bobStakeAmount,
@@ -1213,8 +1213,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 2e18,
@@ -1247,7 +1247,7 @@ contract UnstakeTest is StakeTest {
vm.warp(currentTime + (365 days));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
checkStreamer(
CheckStreamerParams({
@@ -1290,7 +1290,7 @@ contract UnstakeTest is StakeTest {
vm.warp(currentTime + (warpLength));
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
checkStreamer(
CheckStreamerParams({
@@ -1337,8 +1337,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 1000e18,
stakedBalance: 2e18,
@@ -1408,10 +1408,10 @@ contract UnstakeTest is StakeTest {
{
_stake(alice, amountStaked, secondsLocked);
{
RewardsStreamerMP.Account memory accountInfo = streamer.getAccount(vaults[alice]);
assertEq(accountInfo.stakedBalance, totalStaked[stage], "stage 1: wrong account staked balance");
assertEq(accountInfo.mpAccrued, predictedTotalMP[stage], "stage 1: wrong account MP");
assertEq(accountInfo.maxMP, predictedTotalMaxMP[stage], "stage 1: wrong account max MP");
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(vaults[alice]);
assertEq(vaultData.stakedBalance, totalStaked[stage], "stage 1: wrong account staked balance");
assertEq(vaultData.mpAccrued, predictedTotalMP[stage], "stage 1: wrong account MP");
assertEq(vaultData.maxMP, predictedTotalMaxMP[stage], "stage 1: wrong account max MP");
assertEq(streamer.totalStaked(), totalStaked[stage], "stage 1: wrong total staked");
assertEq(streamer.totalMPAccrued(), predictedTotalMP[stage], "stage 1: wrong total MP");
@@ -1422,12 +1422,12 @@ contract UnstakeTest is StakeTest {
stage++; // second stage: progress in time
vm.warp(timestamp[stage]);
streamer.updateGlobalState();
streamer.updateAccountMP(vaults[alice]);
streamer.updateVaultMP(vaults[alice]);
{
RewardsStreamerMP.Account memory accountInfo = streamer.getAccount(vaults[alice]);
assertEq(accountInfo.stakedBalance, totalStaked[stage], "stage 2: wrong account staked balance");
assertEq(accountInfo.mpAccrued, predictedTotalMP[stage], "stage 2: wrong account MP");
assertEq(accountInfo.maxMP, predictedTotalMaxMP[stage], "stage 2: wrong account max MP");
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(vaults[alice]);
assertEq(vaultData.stakedBalance, totalStaked[stage], "stage 2: wrong account staked balance");
assertEq(vaultData.mpAccrued, predictedTotalMP[stage], "stage 2: wrong account MP");
assertEq(vaultData.maxMP, predictedTotalMaxMP[stage], "stage 2: wrong account max MP");
assertEq(streamer.totalStaked(), totalStaked[stage], "stage 2: wrong total staked");
assertEq(streamer.totalMPAccrued(), predictedTotalMP[stage], "stage 2: wrong total MP");
@@ -1437,10 +1437,10 @@ contract UnstakeTest is StakeTest {
stage++; // third stage: reduced stake
_unstake(alice, reducedStake);
{
RewardsStreamerMP.Account memory accountInfo = streamer.getAccount(vaults[alice]);
assertEq(accountInfo.stakedBalance, totalStaked[stage], "stage 3: wrong account staked balance");
assertEq(accountInfo.mpAccrued, predictedTotalMP[stage], "stage 3: wrong account MP");
assertEq(accountInfo.maxMP, predictedTotalMaxMP[stage], "stage 3: wrong account max MP");
RewardsStreamerMP.VaultData memory vaultData = streamer.getVault(vaults[alice]);
assertEq(vaultData.stakedBalance, totalStaked[stage], "stage 3: wrong account staked balance");
assertEq(vaultData.mpAccrued, predictedTotalMP[stage], "stage 3: wrong account MP");
assertEq(vaultData.maxMP, predictedTotalMaxMP[stage], "stage 3: wrong account max MP");
assertEq(streamer.totalStaked(), totalStaked[stage], "stage 3: wrong total staked");
assertEq(streamer.totalMPAccrued(), predictedTotalMP[stage], "stage 3: wrong total MP");
@@ -1465,8 +1465,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 0,
@@ -1477,8 +1477,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 20e18,
@@ -1507,8 +1507,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 250e18,
stakedBalance: 0,
@@ -1532,8 +1532,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 750e18,
stakedBalance: 20e18,
@@ -1557,8 +1557,8 @@ contract UnstakeTest is StakeTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 750e18,
stakedBalance: 0,
@@ -1591,8 +1591,8 @@ contract LockTest is RewardsStreamerMPTest {
uint256 initialMaxMP = stakeAmount * streamer.MAX_MULTIPLIER() + stakeAmount; // 50e18
// Verify initial state
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -1610,8 +1610,8 @@ contract LockTest is RewardsStreamerMPTest {
_lock(alice, lockPeriod);
// Check updated state
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: stakeAmount,
@@ -1685,8 +1685,8 @@ contract EmergencyExitTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -1783,8 +1783,8 @@ contract EmergencyExitTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -1795,8 +1795,8 @@ contract EmergencyExitTest is RewardsStreamerMPTest {
})
);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[bob],
rewardBalance: 0,
stakedBalance: 30e18,
@@ -1828,8 +1828,8 @@ contract EmergencyExitTest is RewardsStreamerMPTest {
StakeVault aliceVault = StakeVault(vaults[alice]);
aliceVault.emergencyExit(alternateAddress);
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 10e18,
@@ -1940,8 +1940,8 @@ contract LeaveTest is RewardsStreamerMPTest {
);
// vault should be empty as funds have been moved out
checkAccount(
CheckAccountParams({
checkVault(
CheckVaultParams({
account: vaults[alice],
rewardBalance: 0,
stakedBalance: 0,

2
test/mocks/XPProviderMock.sol
View File

@@ -20,7 +20,7 @@ contract XPProviderMock is IRewardProvider {
revert("Not implemented");
}
function rewardsBalanceOfUser(address account) external view override returns (uint256) {
function rewardsBalanceOfAccount(address account) external view override returns (uint256) {
return userXPShare[account];
}