feat: add operator receiver functionality for base BGT rewards

ZERGUCCI · ZERGUCCI · commit f80b363cb092 · 2025-01-29T12:47:38.000-08:00
- Add operatorReceivers public mapping to route base BGT rewards

- Add setOperatorReceiver function for operators to set reward receiver

- Add BaseMinted event for tracking base BGT mints

- Update BlockRewardController to respect operator receiver settings

- Add comprehensive tests for operator receiver functionality
diff --git a/src/pol/BeaconDeposit.sol b/src/pol/BeaconDeposit.sol
@@ -62,6 +62,9 @@ contract BeaconDeposit is IBeaconDeposit, ERC165 {
     /// @dev The mapping of public keys to operator change requests.
     mapping(bytes => QueuedOperator) public queuedOperator;
 
+    /// @dev The mapping of operators to their receiver addresses.
+    mapping(address => address) public operatorReceivers;
+    
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                            VIEWS                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -181,6 +184,21 @@ contract BeaconDeposit is IBeaconDeposit, ERC165 {
         emit OperatorUpdated(pubkey, newOperator, oldOperator);
     }
 
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        OPERATOR RECEIVERS                  */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Sets or updates the receiver address for an operator's base bgt rewards
+     * @dev Only the operator can set their receiver
+     * @param receiver The address that will receive base bgt rewards. Set to address(0) to receive rewards directly to operator
+     */
+    function setOperatorReceiver(address receiver) external {
+        address oldReceiver = operatorReceivers[msg.sender];
+        operatorReceivers[msg.sender] = receiver;
+        emit OperatorReceiverUpdated(msg.sender, oldReceiver, receiver);
+    }
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                            INTERNAL                         */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
diff --git a/src/pol/interfaces/IBeaconDeposit.sol b/src/pol/interfaces/IBeaconDeposit.sol
@@ -45,6 +45,22 @@ interface IBeaconDeposit is IPOLErrors {
      */
     event OperatorUpdated(bytes indexed pubkey, address newOperator, address previousOperator);
 
+    /// @notice Emitted when an operator sets or changes their receiver address
+    /// @param operator The operator address that changed their receiver
+    /// @param oldReceiver The previous receiver address (zero if first time setting)
+    /// @param newReceiver The new receiver address (zero if clearing receiver)
+    event OperatorReceiverUpdated(address indexed operator, address indexed oldReceiver, address indexed newReceiver);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            STORAGE                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /**
+     * @notice Mapping of operators to their receiver addresses for base rewards
+     * @dev Returns address(0) if no receiver is set
+     */
+    function operatorReceivers(address) external view returns (address);
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                            VIEWS                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -102,4 +118,11 @@ interface IBeaconDeposit is IPOLErrors {
      * @param pubkey The pubkey of the validator.
      */
     function acceptOperatorChange(bytes calldata pubkey) external;
+
+    /**
+     * @notice Sets or updates the receiver address for an operator's base rewards
+     * @dev Only the operator can set their receiver
+     * @param receiver The address that will receive base rewards. Set to address(0) to receive rewards directly
+     */
+    function setOperatorReceiver(address receiver) external;
 }
diff --git a/src/pol/interfaces/IBlockRewardController.sol b/src/pol/interfaces/IBlockRewardController.sol
@@ -53,6 +53,12 @@ interface IBlockRewardController is IPOLErrors {
     /// @param rewardRate The amount of BGT minted to the distributor.
     event BlockRewardProcessed(bytes indexed pubkey, uint64 nextTimestamp, uint256 baseRate, uint256 rewardRate);
 
+    /// @notice Emitted when base BGT is minted to either the operator or their receiver
+    /// @param operator The operator address that earned the base rewards
+    /// @param receiver The address that received the base rewards (operator or their set receiver)
+    /// @param amount The amount of base BGT minted
+    event BaseMinted(address indexed operator, address indexed receiver, uint256 indexed amount);
+
     /// @notice Returns the constant base rate for BGT.
     /// @return The constant base amount of BGT to be minted in the current block.
     function baseRate() external view returns (uint256);
diff --git a/src/pol/rewards/BlockRewardController.sol b/src/pol/rewards/BlockRewardController.sol
@@ -235,8 +235,16 @@ contract BlockRewardController is IBlockRewardController, OwnableUpgradeable, UU
         // Use the beaconDepositContract to fetch the operator, Its gauranteed to return a valid address.
         // Beacon Deposit contract will enforce validators to set an operator.
         address operator = beaconDepositContract.getOperator(pubkey);
-        if (base > 0) bgt.mint(operator, base);
-
+        
+        // Check if the operator has set a receiver for their base rewards
+        address receiver = beaconDepositContract.operatorReceivers(operator);
+        // If no receiver is set (address(0)), mint to operator directly
+        if (base > 0) {
+            address mintTo = receiver == address(0) ? operator : receiver;
+            bgt.mint(mintTo, base);
+            emit BaseMinted(operator, mintTo, base);
+        }
+        
         // Mint the scaled rewards BGT for validator reward allocation to the distributor.
         if (reward > 0) bgt.mint(distributor, reward);
 
diff --git a/test/mock/pol/BeaconDepositMock.sol b/test/mock/pol/BeaconDepositMock.sol
@@ -3,6 +3,7 @@ pragma solidity 0.8.26;
 
 contract BeaconDepositMock {
     mapping(bytes => address) public pubkeyToOperator;
+    mapping(address => address) public operatorReceivers;
 
     function setOperator(bytes memory pubkey, address operator) public {
         pubkeyToOperator[pubkey] = operator;
@@ -11,4 +12,8 @@ contract BeaconDepositMock {
     function getOperator(bytes memory pubkey) public view returns (address) {
         return pubkeyToOperator[pubkey];
     }
+
+    function setOperatorReceiver(address receiver) external {
+        operatorReceivers[msg.sender] = receiver;
+    }
 }
diff --git a/test/pol/BeaconDeposit.t.sol b/test/pol/BeaconDeposit.t.sol
@@ -224,6 +224,87 @@ contract BeaconDepositTest is Test {
         depositContract.acceptOperatorChange(VALIDATOR_PUBKEY);
     }
 
+    function test_SetOperatorReceiver() public {
+        test_Deposit();
+        address receiver = makeAddr("receiver");
+        
+        vm.prank(operator);
+        vm.expectEmit(true, true, true, true);
+        emit IBeaconDeposit.OperatorReceiverUpdated(operator, address(0), receiver);
+        depositContract.setOperatorReceiver(receiver);
+        
+        // Verify receiver is set correctly
+        assertEq(depositContract.operatorReceivers(operator), receiver);
+    }
+
+    function test_SetOperatorReceiver_Update() public {
+        test_Deposit();
+        address receiver1 = makeAddr("receiver1");
+        address receiver2 = makeAddr("receiver2");
+        
+        // Set initial receiver
+        vm.prank(operator);
+        depositContract.setOperatorReceiver(receiver1);
+        
+        // Update to new receiver
+        vm.prank(operator);
+        vm.expectEmit(true, true, true, true);
+        emit IBeaconDeposit.OperatorReceiverUpdated(operator, receiver1, receiver2);
+        depositContract.setOperatorReceiver(receiver2);
+        
+        assertEq(depositContract.operatorReceivers(operator), receiver2);
+    }
+
+    function test_SetOperatorReceiver_Clear() public {
+        test_Deposit();
+        address receiver = makeAddr("receiver");
+        
+        // Set receiver
+        vm.prank(operator);
+        depositContract.setOperatorReceiver(receiver);
+        
+        // Verify receiver is set correctly
+        assertEq(depositContract.operatorReceivers(operator), receiver);
+        
+        // Clear receiver by setting to address(0)
+        vm.prank(operator);
+        vm.expectEmit(true, true, true, true);
+        emit IBeaconDeposit.OperatorReceiverUpdated(operator, receiver, address(0));
+        depositContract.setOperatorReceiver(address(0));
+        
+        // Verify receiver is cleared
+        assertEq(depositContract.operatorReceivers(operator), address(0));
+    }
+
+    function test_GetOperatorReceiver_NonExistent() public {
+        address nonExistentOperator = makeAddr("nonExistentOperator");
+        
+        // Should return address(0) for non-existent operator
+        assertEq(depositContract.operatorReceivers(nonExistentOperator), address(0));
+    }
+
+    function test_SetOperatorReceiver_MultipleOperators() public {
+        test_Deposit();
+        
+        // Setup second operator and validator using a different pubkey
+        bytes memory pubkey2 = abi.encodePacked(bytes32("33"), bytes16("17")); // Different value from _create48Byte()
+        address operator2 = makeAddr("operator2");
+        vm.deal(operator2, 10_000 ether);
+        
+        vm.prank(operator2);
+        depositContract.deposit{ value: 10_000 ether }(pubkey2, _credential(operator2), _create96Byte(), operator2);
+        
+        // Set different receivers for first operator but not second operator
+        address receiver1 = makeAddr("receiver1");
+        
+        vm.prank(operator);
+        depositContract.setOperatorReceiver(receiver1);
+        
+        // Verify receivers are set correctly
+        assertEq(depositContract.operatorReceivers(operator), receiver1);
+        assertEq(depositContract.operatorReceivers(operator2), address(0));
+    }
+
     function testFuzz_AcceptOperatorChange_FailsIfNotEnoughTime(uint256 timeElapsed) public {
         timeElapsed = _bound(timeElapsed, 0, 1 days - 1);
         testFuzz_RequestOperatorChange(newOperator);
diff --git a/test/pol/BlockRewardController.t.sol b/test/pol/BlockRewardController.t.sol
@@ -258,6 +258,102 @@ contract BlockRewardControllerTest is POLTest {
         assertApproxEqAbs(reward, expected, maxDelta);
     }
 
+    /// @dev Should process rewards with operator receiver set
+    function test_ProcessRewardsWithReceiver() public {
+        test_SetDistributor();
+        test_SetBaseRate();
+        
+        address receiver = makeAddr("receiver");
+        // Set receiver for operator
+        vm.prank(operator);
+        BeaconDepositMock(beaconDepositContract).setOperatorReceiver(receiver);
+        
+        // Verify receiver is set correctly
+        assertEq(BeaconDepositMock(beaconDepositContract).operatorReceivers(operator), receiver);
+
+        // Process rewards - should mint base rewards to receiver instead of operator
+        vm.prank(address(distributor));
+        vm.expectEmit(true, true, true, true);
+        emit IBlockRewardController.BlockRewardProcessed(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, 1 ether, 0);
+
+        // expect call to mint BGT to the receiver instead of operator
+        vm.expectCall(address(bgt), abi.encodeCall(IBGT.mint, (receiver, 1.0 ether)));
+        blockRewardController.processRewards(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, true);
+    }
+
+    /// @dev Should process rewards with operator receiver cleared
+    function test_ProcessRewardsWithReceiverCleared() public {
+        test_SetDistributor();
+        test_SetBaseRate();
+        
+        address receiver = makeAddr("receiver");
+        // First set a receiver
+        vm.prank(operator);
+        BeaconDepositMock(beaconDepositContract).setOperatorReceiver(receiver);
+        
+        // Then clear it by setting to address(0)
+        vm.prank(operator);
+        BeaconDepositMock(beaconDepositContract).setOperatorReceiver(address(0));
+        
+        // Verify receiver is cleared
+        assertEq(BeaconDepositMock(beaconDepositContract).operatorReceivers(operator), address(0));
+
+        // Process rewards - should mint base rewards to operator since receiver is cleared
+        vm.prank(address(distributor));
+        vm.expectEmit(true, true, true, true);
+        emit IBlockRewardController.BlockRewardProcessed(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, 1 ether, 0);
+
+        // expect call to mint BGT to the operator since receiver is cleared
+        vm.expectCall(address(bgt), abi.encodeCall(IBGT.mint, (operator, 1.0 ether)));
+        blockRewardController.processRewards(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, true);
+    }
+
+    /// @dev Should process rewards with no receiver set (default case)
+    function test_ProcessRewardsWithNoReceiver() public {
+        test_SetDistributor();
+        test_SetBaseRate();
+        
+        // Verify no receiver is set
+        assertEq(BeaconDepositMock(beaconDepositContract).operatorReceivers(operator), address(0));
+
+        // Process rewards - should mint base rewards to operator since no receiver set
+        vm.prank(address(distributor));
+        vm.expectEmit(true, true, true, true);
+        emit IBlockRewardController.BlockRewardProcessed(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, 1 ether, 0);
+
+        // expect call to mint BGT to the operator since no receiver set
+        vm.expectCall(address(bgt), abi.encodeCall(IBGT.mint, (operator, 1.0 ether)));
+        blockRewardController.processRewards(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, true);
+    }
+
+    /// @dev Should process rewards correctly when multiple operators have different receiver settings
+    function test_ProcessRewardsMultipleOperators() public {
+        test_SetDistributor();
+        test_SetBaseRate();
+        
+        // Setup second operator and validator
+        address operator2 = makeAddr("operator2");
+        bytes memory pubkey2 = bytes("validator2");
+        BeaconDepositMock(beaconDepositContract).setOperator(pubkey2, operator2);
+        
+        // Setup receivers
+        address receiver1 = makeAddr("receiver1");
+        vm.prank(operator);
+        BeaconDepositMock(beaconDepositContract).setOperatorReceiver(receiver1);
+        
+        // Don't set receiver for operator2
+        
+        // Process rewards for first operator - should go to receiver1
+        vm.prank(address(distributor));
+        vm.expectCall(address(bgt), abi.encodeCall(IBGT.mint, (receiver1, 1.0 ether)));
+        blockRewardController.processRewards(valData.pubkey, DISTRIBUTE_FOR_TIMESTAMP, true);
+        
+        // Process rewards for second operator - should go to operator2
+        vm.prank(address(distributor));
+        vm.expectCall(address(bgt), abi.encodeCall(IBGT.mint, (operator2, 1.0 ether)));
+        blockRewardController.processRewards(pubkey2, DISTRIBUTE_FOR_TIMESTAMP, true);
+    }
+
     /// @dev Should bound compute rewards correctly to its theoretical limits
     function testFuzz_ComputeRewards(
         uint256 boostPower,

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ pragma solidity 0.8.26;`
`3`	`3`
`4`	`4`	`contract BeaconDepositMock {`
`5`	`5`	`mapping(bytes => address) public pubkeyToOperator;`
	`6`	`+ mapping(address => address) public operatorReceivers;`
`6`	`7`
`7`	`8`	`function setOperator(bytes memory pubkey, address operator) public {`
`8`	`9`	`pubkeyToOperator[pubkey] = operator;`
`@@ -11,4 +12,8 @@ contract BeaconDepositMock {`
`11`	`12`	`function getOperator(bytes memory pubkey) public view returns (address) {`
`12`	`13`	`return pubkeyToOperator[pubkey];`
`13`	`14`	`}`
	`15`	`+`
	`16`	`+ function setOperatorReceiver(address receiver) external {`
	`17`	`+ operatorReceivers[msg.sender] = receiver;`
	`18`	`+ }`
`14`	`19`	`}`