Feature/reward distributor #152

alexkeating · 2025-06-24T10:28:47Z

No description provided.

github-actions · 2025-06-24T10:29:50Z

Coverage after merging feature/reward-distributor into main will be

72.83%

Coverage Report

File	Stmts	Branches	Funcs	Lines	Uncovered Lines
src
DelegationSurrogate.sol	100%	100%	100%	100%
DelegationSurrogateVotes.sol	100%	100%	100%	100%
RewardDistributor.sol	0%	0%	0%	0%	173–175, 179–181, 187–189, 196–199, 205–207, 214–215, 223–224, 226–227, 241–242, 252–255, 262–264, 264–265, 267, 278, 283, 283, 285, 287–288, 290, 292, 295, 295–296, 299, 299–300, 304–305, 305–306, 309, 314, 316, 319, 322–323, 327, 333, 339–342, 346–349, 354–356, 361, 363, 365, 365, 367, 374, 380, 385–387, 391–393, 395, 399, 401–402, 406–408, 417–419, 427, 432, 439, 444–445, 447, 449–450, 453, 456–457, 459, 461, 463, 466, 468–469, 469–470, 474, 479–480, 480, 486–487, 487, 494, 499, 499, 517–518, 518, 522, 524, 524, 524–525, 527–528, 531–532, 534, 534, 542–543, 543, 545, 551–553
RewardDistributorDelegateInitializer.sol	0%	0%	0%	0%	10–11, 13–14, 16, 16, 18–19
Staker.sol	100%	100%	100%	100%
src/calculators
BinaryEligibilityOracleEarningPowerCalculator.sol	100%	100%	100%	100%
BinaryVotingPowerEarningPowerCalculator.sol	0%	0%	0%	0%	13, 32–34, 37, 44–46, 48–49, 52, 58–60, 64, 66, 66–69, 72, 76–78, 81–82, 86–87
IdentityEarningPowerCalculator.sol	100%	100%	100%	100%
src/extensions
StakerCapDeposits.sol	100%	100%	100%	100%
StakerDelegateSurrogateVotes.sol	100%	100%	100%	100%
StakerOnBehalf.sol	100%	100%	100%	100%
StakerPermitAndStake.sol	100%	100%	100%	100%
src/notifiers
MintRewardNotifier.sol	100%	100%	100%	100%
RewardTokenNotifierBase.sol	100%	100%	100%	100%
TransferFromRewardNotifier.sol	100%	100%	100%	100%
TransferRewardNotifier.sol	100%	100%	100%	100%

src/RewardDistributor.sol

+  /// @notice The maximum value to which the claim fee can be set.
+  /// @dev For anything other than a zero value, this immutable parameter should be set in the
+  /// constructor of a concrete implementation inheriting from Staker.
+  uint256 public immutable MAX_CLAIM_FEE;


src/RewardDistributor.sol

+  function lastTimeRewardDistributed() public view virtual returns (uint256) {
+    if (rewardEndTime <= block.timestamp) return rewardEndTime;
+    else return block.timestamp;
+  }


src/RewardDistributor.sol

+  function _claimReward(
+    DepositIdentifier _depositId,
+    DelegateReward storage deposit,
+    address _claimer
+  ) internal virtual returns (uint256) {
+    _checkpointGlobalReward();
+    _checkpointReward(deposit);
+
+    uint256 _reward = deposit.scaledUnclaimedRewardCheckpoint / SCALE_FACTOR;
+    // Intentionally reverts due to overflow if unclaimed rewards are less than fee.
+    uint256 _payout = _reward - claimFeeParameters.feeAmount;
+    if (_payout == 0) return 0;
+
+    // retain sub-wei dust that would be left due to the precision loss
+    deposit.scaledUnclaimedRewardCheckpoint =
+      deposit.scaledUnclaimedRewardCheckpoint - (_reward * SCALE_FACTOR);
+
+    uint256 _newEarningPower =
+      earningPowerCalculator.getEarningPower(0, deposit.owner, deposit.owner);
+
+    emit RewardClaimed(_depositId, _claimer, _payout, _newEarningPower);
+
+    totalEarningPower =
+      _calculateTotalEarningPower(deposit.earningPower, _newEarningPower, totalEarningPower);
+    depositorTotalEarningPower[deposit.owner] = _calculateTotalEarningPower(
+      deposit.earningPower, _newEarningPower, depositorTotalEarningPower[deposit.owner]
+    );
+    deposit.earningPower = _newEarningPower.toUint96();
+
+    SafeERC20.safeTransfer(REWARD_TOKEN, _claimer, _payout);
+    if (claimFeeParameters.feeAmount > 0) {
+      SafeERC20.safeTransfer(
+        REWARD_TOKEN, claimFeeParameters.feeCollector, claimFeeParameters.feeAmount
+      );
+    }
+    return _payout;
+  }


src/RewardDistributor.sol

+  function notifyRewardAmount(uint256 _amount) external virtual {
+    if (!isRewardNotifier[msg.sender]) revert Staker__Unauthorized("not notifier", msg.sender);
+
+    // We checkpoint the accumulator without updating the timestamp at which it was updated,
+    // because that second operation will be done after updating the reward rate.
+    rewardPerTokenAccumulatedCheckpoint = rewardPerTokenAccumulated();
+
+    if (block.timestamp >= rewardEndTime) {
+      scaledRewardRate = (_amount * SCALE_FACTOR) / REWARD_DURATION;
+    } else {
+      uint256 _remainingReward = scaledRewardRate * (rewardEndTime - block.timestamp);
+      scaledRewardRate = (_remainingReward + _amount * SCALE_FACTOR) / REWARD_DURATION;
+    }
+
+    rewardEndTime = block.timestamp + REWARD_DURATION;
+    lastCheckpointTime = block.timestamp;
+
+    if ((scaledRewardRate / SCALE_FACTOR) == 0) revert Staker__InvalidRewardRate();
+
+    // This check cannot _guarantee_ sufficient rewards have been transferred to the contract,
+    // because it cannot isolate the unclaimed rewards owed to stakers left in the balance. While
+    // this check is useful for preventing degenerate cases, it is not sufficient. Therefore, it is
+    // critical that only safe reward notifier contracts are approved to call this method by the
+    // admin.
+    if (
+      (scaledRewardRate * REWARD_DURATION) > (REWARD_TOKEN.balanceOf(address(this)) * SCALE_FACTOR)
+    ) revert Staker__InsufficientRewardBalance();
+
+    emit RewardNotified(_amount, msg.sender);
+  }


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  function getEarningPower(uint256, /* _amountStaked */ address, /* _staker */ address _delegatee)
+    external
+    view
+    virtual
+    override
+    returns (uint256)
+  {
+    uint48 _votingPowerTimepoint = _getVotingPowerTimepoint();
+    uint256 _votingPower =
+      IVotes(VOTING_POWER_TOKEN).getPastVotes(_delegatee, _votingPowerTimepoint);
+
+    if (_isOracleStale() || isOraclePaused) return _votingPower;
+    return _isDelegateeEligible(_delegatee) ? _votingPower : 0;
+  }


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  function getNewEarningPower(
+    uint256, /* _amountStaked */
+    address, /* _staker */
+    address _delegatee,
+    uint256 /* _oldEarningPower */
+  ) external view virtual override returns (uint256, bool) {
+    uint48 _votingPowerTimepoint = _getVotingPowerTimepoint();
+    uint256 _votingPower =
+      IVotes(VOTING_POWER_TOKEN).getPastVotes(_delegatee, _votingPowerTimepoint);
+
+    // TODO: Do we want the same fallback behavior.
+    // Should we instead accept the stale values if paused?
+    if (_isOracleStale() || isOraclePaused) return (_votingPower, true);
+
+    if (!_isDelegateeEligible(_delegatee)) {
+      bool _isUpdateDelayElapsed =
+        (timeOfIneligibility[_delegatee] + updateEligibilityDelay) <= block.timestamp;
+      return (0, _isUpdateDelayElapsed);
+    }
+
+    return (_votingPower, true);
+  }


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

alexkeating · 2025-06-24T13:30:08Z

src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+    uint256 _votingPower =
+      IVotes(VOTING_POWER_TOKEN).getPastVotes(_delegatee, _votingPowerTimepoint);
+
+    if (_isOracleStale() || isOraclePaused) return _votingPower;


Keep this but read other epc, from staker

I think the address we'd need to look at, the address which represents the delegate in this case, is the one passed as the _staker to the EPC, i.e. the owner of the "deposit" in the DelegateCompensationStaker, right?

This is a good question. I updated the owner and delegate to be the same address for both spikes so it shouldn't matter, but it may matter for future implementations. Which would be better? Happy to choose either.

Let's make the EPC methods public on BinaryEligibilityEPC, add to existing pr, add tests for new public methods

src/DelegateCompensationStaker.sol

+  function _fetchOrDeploySurrogate(address) internal pure override returns (DelegationSurrogate) {
+    revert();
+  }


apbendi · 2025-06-27T14:13:05Z

src/DelegateCompensationStaker.sol

+    depositorTotalEarningPower[_delegate] += _earningPower;
+    deposits[_depositId] = Deposit({
+      balance: 0,
+      delegatee: address(0),


I think delegating to address(0) would revert in Staker. The easiest way to handle it is probably just to pick a non-zero, non "real" address to set as the delegate for every "deposit"

I don't think this will revert unless we have to create surrogates.

Now, I think it is probably better to make this the provided delegate address to avoid issues in the earning power calculator

apbendi · 2025-06-27T14:14:11Z

src/DelegateCompensationStaker.sol

+    return _depositId;
+  }
+
+  function _fetchOrDeploySurrogate(address) internal pure override returns (DelegationSurrogate) {


Would we want this to revert? Wouldn't we need to do this once for whatever the fake "delegatee" is for every deposti?

Maybe I am missing something, do we still have the concept of a delegatee for deposit? I was under the impression delegates were simply accumulating rewards and not delegating them. I think we can revert if my understanding is correct as this is only used in _stake and _alterDelegatee which we no longer use.

src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  uint48 public votingPowerUpdateFrequency;
+  uint48 public immutable UPDATE_START_TIME;
+  address public immutable VOTING_POWER_TOKEN;
+  BinaryEligibilityOracleEarningPowerCalculator public eligibilityModule;


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  BinaryEligibilityOracleEarningPowerCalculator public eligibilityModule;
+
+  constructor(
+    address _owner,


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  constructor(
+    address _owner,
+    address _eligibilityAddress,
+    address _votingPowerToken,


src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+  function _isOracleStale() internal view returns (bool) {
+    return block.timestamp - eligibilityModule.lastOracleUpdateTime()
+      > eligibilityModule.STALE_ORACLE_WINDOW();
+  }


alexkeating · 2025-06-30T15:48:03Z

src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+    VOTING_POWER_TOKEN = _votingPowerToken;
+  }
+
+  function getEarningPower(uint256, /* _amountStaked */ address, /* _staker */ address _delegatee)


Let's switch to use _staker

alexkeating · 2025-06-30T15:50:51Z

src/calculators/BinaryVotingPowerEarningPowerCalculator.sol

+    returns (uint256)
+  {
+    uint48 _votingPowerTimepoint = _getVotingPowerTimepoint();
+    uint256 _votingPower =


Switch to square root calculation

alexkeating · 2025-06-30T16:01:29Z

src/DelegateCompensationStaker.sol

+import {DelegationSurrogate} from "./DelegationSurrogate.sol";
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+abstract contract DelegateCompensationStaker is Staker {


Testing strategy

Use fakes for other EPC, and token

Add some integration post phase 1

Staker

Simple smoke stakes, and other methods revert. Where there is smoke there is fire testing.

Minimum, tests that demonstrate the functionality is left still works and interacts properly with the new changes i.e. reward distribution and claiming.

At least one test for every public methods to make sure the happy is working.

alexkeating added 4 commits June 12, 2025 09:45

WIP

3203080

WIP first pair

ac8e210

Compiling example

94b386b

WIP Cleanup

6355869

github-advanced-security bot found potential problems Jun 24, 2025

View reviewed changes

alexkeating added 2 commits June 24, 2025 07:01

WIP

630f5d1

Minor changes

d8a84de

alexkeating commented Jun 24, 2025

View reviewed changes

alexkeating added 3 commits June 25, 2025 13:25

Working test

a826807

Working example

7eb737f

Add override spike

8ab81c1

github-advanced-security bot found potential problems Jun 27, 2025

View reviewed changes

apbendi reviewed Jun 27, 2025

View reviewed changes

alexkeating added 2 commits June 27, 2025 11:34

Maybe delegate to themself

18afd65

Cleanup a little more

ec89eed

github-advanced-security bot found potential problems Jun 29, 2025

View reviewed changes

alexkeating commented Jun 30, 2025

View reviewed changes

alexkeating closed this Aug 4, 2025

Feature/reward distributor #152

Feature/reward distributor #152

Uh oh!

Conversation

alexkeating commented Jun 24, 2025

Uh oh!

github-actions bot commented Jun 24, 2025

Uh oh!

Uh oh!

Check failure

Check notice

Check warning

Check warning

Uh oh!

Uh oh!

Check notice

Check notice

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Check warning

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Check warning

Check notice

Check notice

Check notice

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

alexkeating Jun 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

alexkeating Jun 30, 2025 •

edited

Loading