logos-co
/
staking
mirror of https://github.com/logos-co/staking.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
staking/.gas-report

127 lines
11 KiB
Plaintext
Raw Permalink Normal View History

refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| contracts/StakeManager.sol:StakeManager contract | | | | | |
|--------------------------------------------------|-----------------|--------|--------|--------|---------|
| Deployment Cost | Deployment Size | | | | |
| 2465702 | 13041 | | | | |
| Function Name | min | avg | median | max | # calls |
| EPOCH_SIZE | 307 | 307 | 307 | 307 | 1498 |
| MAX_BOOST | 285 | 285 | 285 | 285 | 637 |
| MAX_LOCKUP_PERIOD | 361 | 361 | 361 | 361 | 4 |
| MIN_LOCKUP_PERIOD | 264 | 264 | 264 | 264 | 12 |
| YEAR | 263 | 263 | 263 | 263 | 637 |
| accounts | 1597 | 1597 | 1597 | 1597 | 144273 |
| calculateMPToMint | 740 | 740 | 740 | 740 | 1276 |
| currentEpoch | 384 | 1050 | 384 | 2384 | 54 |
| epochEnd | 627 | 627 | 627 | 2627 | 23675 |
| epochReward | 1425 | 2925 | 1425 | 5925 | 3 |
| executeAccount(address) | 151152 | 151152 | 151152 | 151152 | 2 |
| executeAccount(address,uint256) | 26562 | 72616 | 74122 | 217879 | 141860 |
| executeEpoch() | 23458 | 120800 | 121956 | 938985 | 23564 |
| executeEpoch(uint256) | 23861 | 24497 | 23861 | 26090 | 7 |
| isVault | 540 | 948 | 540 | 2540 | 680 |
| lock | 23862 | 23862 | 23862 | 23862 | 1 |
| migrateTo | 23891 | 23897 | 23897 | 23903 | 2 |
| migration | 395 | 1395 | 1395 | 2395 | 4 |
| migrationInitialize | 24602 | 24602 | 24602 | 24602 | 1 |
| newEpoch | 441 | 441 | 441 | 441 | 5 |
| owner | 2432 | 2432 | 2432 | 2432 | 13 |
| pendingMPToBeMinted | 364 | 364 | 364 | 364 | 46432 |
| pendingReward | 386 | 1420 | 2386 | 2386 | 29 |
| previousManager | 275 | 275 | 275 | 275 | 13 |
| setVault | 46239 | 46239 | 46239 | 46239 | 139 |
| stake | 23983 | 23983 | 23983 | 23983 | 1 |
| stakeRewardEstimate | 436 | 2345 | 2436 | 2436 | 22 |
| stakedToken | 295 | 295 | 295 | 295 | 696 |
| startMigration | 103580 | 103588 | 103592 | 103592 | 3 |
| startTime | 306 | 306 | 306 | 306 | 21 |
| totalSupply | 762 | 1943 | 2762 | 2762 | 22 |
| totalSupplyBalance | 407 | 1807 | 2407 | 2407 | 20 |
| totalSupplyMP | 362 | 362 | 362 | 2362 | 46453 |
| unstake | 23819 | 23819 | 23819 | 23819 | 1 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| contracts/StakeManager.sol:StakeRewardEstimate contract | | | | | |
|---------------------------------------------------------|-----------------|-------|--------|-------|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| getExpiredMP | 2427 | 2427 | 2427 | 2427 | 23725 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| transferOwnership | 28533 | 28533 | 28533 | 28533 | 1 |
| contracts/StakeVault.sol:StakeVault contract | | | | | |
|----------------------------------------------|-----------------|--------|--------|--------|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): optimize epoch finalization and execution of accounts and epochs This commit refactors the StakeManager contract to optimize the finalization and execution of epochs. It updates the function finalizeEpoch() to new function finalizeEpoch(uint256 _limitEpoch) that releases rewards for the current epoch and increases the epoch up to the specified limit. This allows for more efficient processing of epochs. The changes also include updates to the executeEpoch() and executeAccount() functions to utilize the new finalizeEpoch() function. Additionally, a new function newEpoch() is introduced to calculate the last epoch that can be processed based on the current time. Now the executeAccount(account,limit) will also process epochs up to the specified limit. Added a overload of the executeAccount to process the account up to the newEpoch() Added a overload of the executeEpoch to allow the process of epochs up to a certain limit. All methods now that finalizeEpoch will process the epochs up to the newEpoch(). These changes improve the overall performance, user expirience and reliability of the StakeManager contract. chore(StakeManagerStartMigration.spec): add new function executeEpoch(uint256) to blockedWhenMigrating fix(StakeManager.sol): Replace the check for pending migration in migrationInitialize with noPendingMigration modifier to avoid code duplication
2024-09-25 15:53:59 +00:00
| acceptMigration | 35280 | 35280 | 35280 | 35280 | 2 |
| leave | 35266 | 35266 | 35266 | 35266 | 1 |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| lock | 43329 | 96146 | 64421 | 204745 | 7 |
refactor(StakeManager): optimize epoch finalization and execution of accounts and epochs This commit refactors the StakeManager contract to optimize the finalization and execution of epochs. It updates the function finalizeEpoch() to new function finalizeEpoch(uint256 _limitEpoch) that releases rewards for the current epoch and increases the epoch up to the specified limit. This allows for more efficient processing of epochs. The changes also include updates to the executeEpoch() and executeAccount() functions to utilize the new finalizeEpoch() function. Additionally, a new function newEpoch() is introduced to calculate the last epoch that can be processed based on the current time. Now the executeAccount(account,limit) will also process epochs up to the specified limit. Added a overload of the executeAccount to process the account up to the newEpoch() Added a overload of the executeEpoch to allow the process of epochs up to a certain limit. All methods now that finalizeEpoch will process the epochs up to the newEpoch(). These changes improve the overall performance, user expirience and reliability of the StakeManager contract. chore(StakeManagerStartMigration.spec): add new function executeEpoch(uint256) to blockedWhenMigrating fix(StakeManager.sol): Replace the check for pending migration in migrationInitialize with noPendingMigration modifier to avoid code duplication
2024-09-25 15:53:59 +00:00
| owner | 362 | 362 | 362 | 362 | 679 |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| stake | 27265 | 282079 | 265719 | 351866 | 684 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| stakedToken | 212 | 212 | 212 | 212 | 2 |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| unstake | 40167 | 95818 | 78688 | 233549 | 11 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| contracts/VaultFactory.sol:VaultFactory contract | | | | | |
|--------------------------------------------------|-----------------|--------|--------|--------|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): optimize epoch finalization and execution of accounts and epochs This commit refactors the StakeManager contract to optimize the finalization and execution of epochs. It updates the function finalizeEpoch() to new function finalizeEpoch(uint256 _limitEpoch) that releases rewards for the current epoch and increases the epoch up to the specified limit. This allows for more efficient processing of epochs. The changes also include updates to the executeEpoch() and executeAccount() functions to utilize the new finalizeEpoch() function. Additionally, a new function newEpoch() is introduced to calculate the last epoch that can be processed based on the current time. Now the executeAccount(account,limit) will also process epochs up to the specified limit. Added a overload of the executeAccount to process the account up to the newEpoch() Added a overload of the executeEpoch to allow the process of epochs up to a certain limit. All methods now that finalizeEpoch will process the epochs up to the newEpoch(). These changes improve the overall performance, user expirience and reliability of the StakeManager contract. chore(StakeManagerStartMigration.spec): add new function executeEpoch(uint256) to blockedWhenMigrating fix(StakeManager.sol): Replace the check for pending migration in migrationInitialize with noPendingMigration modifier to avoid code duplication
2024-09-25 15:53:59 +00:00
| createVault | 696553 | 696553 | 696553 | 696553 | 683 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| setStakeManager | 23710 | 26669 | 26076 | 30222 | 3 |
| stakeManager | 368 | 1868 | 2368 | 2368 | 4 |
| lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol:ERC20 contract | | | | | |
|---------------------------------------------------------------------------|-----------------|-------|--------|-------|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| approve | 46175 | 46239 | 46199 | 46367 | 679 |
| balanceOf | 561 | 2107 | 2561 | 2561 | 30744 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| script/Deploy.s.sol:Deploy contract | | | | | |
|-------------------------------------|-----------------|---------|---------|---------|---------|
| Deployment Cost | Deployment Size | | | | |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| 6118940 | 29538 | | | | |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| run | 5316305 | 5316305 | 5316305 | 5316305 | 66 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| script/DeployMigrationStakeManager.s.sol:DeployMigrationStakeManager contract | | | | | |
|-------------------------------------------------------------------------------|-----------------|---------|---------|---------|---------|
| Deployment Cost | Deployment Size | | | | |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| 3282471 | 16306 | | | | |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| run | 2302633 | 2302633 | 2302633 | 2302633 | 19 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| script/DeploymentConfig.s.sol:DeploymentConfig contract | | | | | |
|---------------------------------------------------------|-----------------|-----|--------|-----|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): optimize epoch finalization and execution of accounts and epochs This commit refactors the StakeManager contract to optimize the finalization and execution of epochs. It updates the function finalizeEpoch() to new function finalizeEpoch(uint256 _limitEpoch) that releases rewards for the current epoch and increases the epoch up to the specified limit. This allows for more efficient processing of epochs. The changes also include updates to the executeEpoch() and executeAccount() functions to utilize the new finalizeEpoch() function. Additionally, a new function newEpoch() is introduced to calculate the last epoch that can be processed based on the current time. Now the executeAccount(account,limit) will also process epochs up to the specified limit. Added a overload of the executeAccount to process the account up to the newEpoch() Added a overload of the executeEpoch to allow the process of epochs up to a certain limit. All methods now that finalizeEpoch will process the epochs up to the newEpoch(). These changes improve the overall performance, user expirience and reliability of the StakeManager contract. chore(StakeManagerStartMigration.spec): add new function executeEpoch(uint256) to blockedWhenMigrating fix(StakeManager.sol): Replace the check for pending migration in migrationInitialize with noPendingMigration modifier to avoid code duplication
2024-09-25 15:53:59 +00:00
| activeNetworkConfig | 455 | 455 | 455 | 455 | 132 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| test/mocks/BrokenERC20.s.sol:BrokenERC20 contract | | | | | |
|---------------------------------------------------|-----------------|-------|--------|-------|---------|
| Deployment Cost | Deployment Size | | | | |
| 0 | 0 | | | | |
| Function Name | min | avg | median | max | # calls |
| approve | 46175 | 46175 | 46175 | 46175 | 1 |
| balanceOf | 561 | 1227 | 561 | 2561 | 3 |
| test/script/DeployBroken.s.sol:DeployBroken contract | | | | | |
|------------------------------------------------------|-----------------|---------|---------|---------|---------|
| Deployment Cost | Deployment Size | | | | |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| 4803693 | 23336 | | | | |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00
| Function Name | min | avg | median | max | # calls |
refactor(StakeManager): replace epoch.startTime with a global startTime As now all epochEnd() are multiples of EPOCH_SIZE, we can drop the startTime from the struct Epoch, and avoid storing an information that can be cheaply calculated on the fly. - Refactored the StakeManager contract to optimize the finalization of epochs and execution of accounts and epochs. - Replaced the Epoch.startTime with a new global variable startTime to keep track of the start time of the contract. - Modified the finalizeEpoch function to use a temporary variable for the current epoch and calculate the epoch reward only for the current epoch. - Updated the migrationInitialize function to set the start time using the new startTime variable. - Modified the epochEnd function to calculate the end time of the current epoch using the startTime variable. - Modified the newEpoch function to calculate the number of the next epoch based on the startTime variable. refactor(StakeManager): set startTime as immutable, load startTime from previousManager at constructor, verify startTime is correct on initializeMigration
2024-09-25 15:55:53 +00:00
| run | 4156127 | 4156127 | 4156127 | 4156127 | 1 |
fix(StakeManager): use while loop instead of hacky for loop in process account chore: lint again with foundry updated
2024-09-11 12:05:18 +00:00