use transcoder -> rewardCaller mapping direction to prevent frontruns

SidestreamSweatyPumpkin · SidestreamSweatyPumpkin · commit 884a9a297edb · 2025-09-03T15:22:30.000+02:00
diff --git a/contracts/bonding/BondingManager.sol b/contracts/bonding/BondingManager.sol
@@ -102,8 +102,8 @@ contract BondingManager is ManagerProxyTarget, IBondingManager {
     // If the balance of the treasury in LPT is above this value, automatic treasury contributions will halt.
     uint256 public treasuryBalanceCeiling;
 
-    // Allow reward() calls by pre-defined set of addresses
-    mapping(address => address) private rewardCallerToTranscoder;
+    // Allow reward() calls from one pre-defined address per transcoder
+    mapping(address => address) private transcoderToRewardCaller;
 
     // Check if sender is TicketBroker
     modifier onlyTicketBroker() {
@@ -194,23 +194,13 @@ contract BondingManager is ManagerProxyTarget, IBondingManager {
     /**
      * @notice Set a reward caller for a transcoder
      * @param _rewardCaller Address of the new reward caller
+     * @dev By providing address(0) the reward caller can be unset
      */
     function setRewardCaller(address _rewardCaller) external whenSystemNotPaused {
-        require(rewardCallerToTranscoder[_rewardCaller] == address(0), "reward caller is already set");
-        rewardCallerToTranscoder[_rewardCaller] = msg.sender;
+        transcoderToRewardCaller[msg.sender] = _rewardCaller;
         emit RewardCallerSet(msg.sender, _rewardCaller);
     }
 
-    /**
-     * @notice Unset a reward caller for a transcoder
-     * @param _rewardCaller Address of the existing reward caller
-     */
-    function unsetRewardCaller(address _rewardCaller) external whenSystemNotPaused {
-        require(rewardCallerToTranscoder[_rewardCaller] == msg.sender, "only relevant transcoder can unset");
-        rewardCallerToTranscoder[_rewardCaller] = address(0);
-        emit RewardCallerUnset(msg.sender, _rewardCaller);
-    }
-
     /**
      * @notice Sets commission rates as a transcoder and if the caller is not in the transcoder pool tries to add it
      * @dev Percentages are represented as numerators of fractions over MathUtils.PERC_DIVISOR
@@ -317,6 +307,15 @@ contract BondingManager is ManagerProxyTarget, IBondingManager {
         rewardWithHint(address(0), address(0));
     }
 
+    /**
+     * @notice Mint token rewards for an active transcoder and its delegators
+     * @param _transcoder Address of the transcoder on behalf of which the reward is called
+     * @dev Only callable by trusted rewardCaller
+     */
+    function rewardForTranscoder(address _transcoder) external {
+        rewardForTranscoderWithHint(_transcoder, address(0), address(0));
+    }
+
     /**
      * @notice Update transcoder's fee pool. Only callable by the TicketBroker
      * @param _transcoder Transcoder address
@@ -884,25 +883,53 @@ contract BondingManager is ManagerProxyTarget, IBondingManager {
      * @param _newPosPrev Address of previous transcoder in pool if the caller is in the pool
      * @param _newPosNext Address of next transcoder in pool if the caller is in the pool
      */
-    function rewardWithHint(address _newPosPrev, address _newPosNext)
-        public
-        whenSystemNotPaused
-        currentRoundInitialized
-        autoCheckpoint(msg.sender)
-    {
+    function rewardWithHint(address _newPosPrev, address _newPosNext) public {
+        _rewardWithHint(msg.sender, _newPosPrev, _newPosNext);
+    }
+
+    /**
+     * @notice Mint token rewards for an active transcoder and its delegators and update the transcoder pool using an optional list hint if needed
+     * @dev If the caller is in the transcoder pool, the caller can provide an optional hint for its insertion position in the
+     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
+     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
+     * @dev Only callable by trusted rewardCaller
+     * @param _transcoder Address of the transcoder on behalf of which the reward is called
+     * @param _newPosPrev Address of previous transcoder in pool if the caller is in the pool
+     * @param _newPosNext Address of next transcoder in pool if the caller is in the pool
+     */
+    function rewardForTranscoderWithHint(
+        address _transcoder,
+        address _newPosPrev,
+        address _newPosNext
+    ) public {
+        address rewardCaller = transcoderToRewardCaller[_transcoder];
+        require(rewardCaller == msg.sender, "caller must be a reward caller set by the transcoder");
+        _rewardWithHint(_transcoder, _newPosPrev, _newPosNext);
+    }
+
+    /**
+     * @notice Mint token rewards for an active transcoder and its delegators and update the transcoder pool using an optional list hint if needed
+     * @dev If the caller is in the transcoder pool, the caller can provide an optional hint for its insertion position in the
+     * pool via the `_newPosPrev` and `_newPosNext` params. A linear search will be executed starting at the hint to find the correct position.
+     * In the best case, the hint is the correct position so no search is executed. See SortedDoublyLL.sol for details on list hints
+     * @param _transcoder Address of the transcoder on behalf of which the reward is called
+     * @param _newPosPrev Address of previous transcoder in pool if the caller is in the pool
+     * @param _newPosNext Address of next transcoder in pool if the caller is in the pool
+     */
+    function _rewardWithHint(
+        address _transcoder,
+        address _newPosPrev,
+        address _newPosNext
+    ) private whenSystemNotPaused currentRoundInitialized autoCheckpoint(_transcoder) {
         uint256 currentRound = roundsManager().currentRound();
 
-        address transcoderAddress = msg.sender;
-        if (!isActiveTranscoder(transcoderAddress)) {
-            transcoderAddress = rewardCallerToTranscoder[msg.sender];
-            require(isActiveTranscoder(transcoderAddress), "caller must be an active transcoder or rewardCaller");
-        }
+        require(isActiveTranscoder(_transcoder), "transcoder must be an active");
         require(
-            transcoders[transcoderAddress].lastRewardRound != currentRound,
+            transcoders[_transcoder].lastRewardRound != currentRound,
             "caller has already called reward for the current round"
         );
 
-        Transcoder storage t = transcoders[transcoderAddress];
+        Transcoder storage t = transcoders[_transcoder];
         EarningsPool.Data storage earningsPool = t.earningsPoolPerRound[currentRound];
 
         // Set last round that transcoder called reward
@@ -935,17 +962,17 @@ contract BondingManager is ManagerProxyTarget, IBondingManager {
 
             mtr.trustedTransferTokens(trsry, treasuryRewards);
 
-            emit TreasuryReward(transcoderAddress, trsry, treasuryRewards);
+            emit TreasuryReward(_transcoder, trsry, treasuryRewards);
         }
 
         uint256 transcoderRewards = totalRewardTokens.sub(treasuryRewards);
 
-        updateTranscoderWithRewards(transcoderAddress, transcoderRewards, currentRound, _newPosPrev, _newPosNext);
+        updateTranscoderWithRewards(_transcoder, transcoderRewards, currentRound, _newPosPrev, _newPosNext);
 
         // Set last round that transcoder called reward
         t.lastRewardRound = currentRound;
 
-        emit Reward(transcoderAddress, transcoderRewards);
+        emit Reward(_transcoder, transcoderRewards);
     }
 
     /**
diff --git a/contracts/bonding/IBondingManager.sol b/contracts/bonding/IBondingManager.sol
@@ -45,7 +45,6 @@ interface IBondingManager {
         uint256 endRound
     );
     event RewardCallerSet(address indexed transcoder, address indexed rewardCaller);
-    event RewardCallerUnset(address indexed transcoder, address indexed rewardCaller);
 
     // Deprecated events
     // These event signatures can be used to construct the appropriate topic hashes to filter for past logs corresponding
diff --git a/test/unit/BondingManager.js b/test/unit/BondingManager.js
@@ -5474,9 +5474,7 @@ describe("BondingManager", () => {
         it("should fail if caller is not a transcoder", async () => {
             await expect(
                 bondingManager.connect(nonTranscoder).reward()
-            ).to.be.revertedWith(
-                "caller must be an active transcoder or rewardCaller"
-            )
+            ).to.be.revertedWith("transcoder must be an active")
         })
 
         it("should fail if caller is registered but not an active transcoder yet in the current round", async () => {
@@ -5486,9 +5484,7 @@ describe("BondingManager", () => {
             )
             await expect(
                 bondingManager.connect(transcoder).reward()
-            ).to.be.revertedWith(
-                "caller must be an active transcoder or rewardCaller"
-            )
+            ).to.be.revertedWith("transcoder must be an active")
         })
 
         it("should fail if caller already called reward during the current round", async () => {
@@ -6128,10 +6124,10 @@ describe("BondingManager", () => {
 
                 const unsetRewardCallerTx = bondingManager
                     .connect(transcoder)
-                    .unsetRewardCaller(nonTranscoder.address)
+                    .setRewardCaller(ZERO_ADDRESS)
                 await expect(unsetRewardCallerTx)
-                    .to.emit(bondingManager, "RewardCallerUnset")
-                    .withArgs(transcoder.address, nonTranscoder.address)
+                    .to.emit(bondingManager, "RewardCallerSet")
+                    .withArgs(transcoder.address, ZERO_ADDRESS)
 
                 const rewardTx2 = bondingManager.connect(transcoder).reward()
                 await expect(rewardTx2)
@@ -6147,7 +6143,9 @@ describe("BondingManager", () => {
                     .to.emit(bondingManager, "RewardCallerSet")
                     .withArgs(transcoder.address, nonTranscoder.address)
 
-                const rewardTx = bondingManager.connect(nonTranscoder).reward()
+                const rewardTx = bondingManager
+                    .connect(nonTranscoder)
+                    .rewardForTranscoder(transcoder.address)
                 await expect(rewardTx)
                     .to.emit(bondingManager, "Reward")
                     .withArgs(transcoder.address, transcoderRewards)
@@ -6159,46 +6157,16 @@ describe("BondingManager", () => {
 
                 const unsetRewardCallerTx = bondingManager
                     .connect(transcoder)
-                    .unsetRewardCaller(nonTranscoder.address)
+                    .setRewardCaller(ZERO_ADDRESS)
                 await expect(unsetRewardCallerTx)
-                    .to.emit(bondingManager, "RewardCallerUnset")
-                    .withArgs(transcoder.address, nonTranscoder.address)
-
-                const rewardTx2 = bondingManager.connect(nonTranscoder).reward()
-                await expect(rewardTx2).to.be.revertedWith(
-                    "caller must be an active transcoder or rewardCaller"
-                )
-            })
-
-            it("impossible to set the same RewardCaller twice", async () => {
-                const setRewardCallerTx = bondingManager
-                    .connect(transcoder)
-                    .setRewardCaller(nonTranscoder.address)
-                await expect(setRewardCallerTx)
-                    .to.emit(bondingManager, "RewardCallerSet")
-                    .withArgs(transcoder.address, nonTranscoder.address)
-
-                const setRewardCallerTx2 = bondingManager
-                    .connect(transcoder)
-                    .setRewardCaller(nonTranscoder.address)
-                await expect(setRewardCallerTx2).to.be.revertedWith(
-                    "reward caller is already set"
-                )
-            })
-
-            it("impossible to unset the RewardCaller for another transcoder", async () => {
-                const setRewardCallerTx = bondingManager
-                    .connect(transcoder)
-                    .setRewardCaller(nonTranscoder.address)
-                await expect(setRewardCallerTx)
                     .to.emit(bondingManager, "RewardCallerSet")
-                    .withArgs(transcoder.address, nonTranscoder.address)
+                    .withArgs(transcoder.address, ZERO_ADDRESS)
 
-                const unsetRewardCallerTx = bondingManager
+                const rewardTx2 = bondingManager
                     .connect(nonTranscoder)
-                    .unsetRewardCaller(nonTranscoder.address)
-                await expect(unsetRewardCallerTx).to.be.revertedWith(
-                    "only relevant transcoder can unset"
+                    .rewardForTranscoder(transcoder.address)
+                await expect(rewardTx2).to.be.revertedWith(
+                    "caller must be a reward caller set by the transcoder"
                 )
             })
         })
