feat: keeper reward for reservoir drip through token issuance

contracts/l2/reservoir/IL2Reservoir.sol

@@ -2,7 +2,7 @@
 
 pragma solidity ^0.7.6;
 
-import "../../reservoir/IReservoir.sol";
+import { IReservoir } from "../../reservoir/IReservoir.sol";
 
 /**
  * @title Interface for the L2 Rewards Reservoir
@@ -18,13 +18,23 @@ interface IL2Reservoir is IReservoir {
      * updates the issuanceBase and issuanceRate,
      * and snapshots the accumulated rewards. If issuanceRate changes,
      * it also triggers a snapshot of rewards per signal on the RewardsManager.
+     * Note that the transaction might revert if it's received out-of-order,
+     * because it checks an incrementing nonce. If that is the case, the retryable ticket can be redeemed
+     * again once the ticket for previous drip has been redeemed.
+     * A keeper reward will be sent to the keeper that dripped on L1, and part of it
+     * to whoever redeemed the current retryable ticket (as reported by ArbRetryableTx.getCurrentRedeemer) if
+     * the ticket is not auto-redeemed.
      * @param _issuanceBase Base value for token issuance (approximation for token supply times L2 rewards fraction)
      * @param _issuanceRate Rewards issuance rate, using fixed point at 1e18, and including a +1
      * @param _nonce Incrementing nonce to ensure messages are received in order
+     * @param _keeperReward Keeper reward to distribute between keeper that called drip and keeper that redeemed the retryable tx
+     * @param _l1Keeper Address of the keeper that called drip in L1
      */
     function receiveDrip(
         uint256 _issuanceBase,
         uint256 _issuanceRate,
-        uint256 _nonce
+        uint256 _nonce,
+        uint256 _keeperReward,
+        address _l1Keeper
     ) external;
 }

contracts/l2/reservoir/L2Reservoir.sol

@@ -3,24 +3,51 @@
 pragma solidity ^0.7.6;
 pragma abicoder v2;
 
-import "@openzeppelin/contracts/math/SafeMath.sol";
+import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
+import { ArbRetryableTx } from "arbos-precompiles/arbos/builtin/ArbRetryableTx.sol";
 
-import "../../reservoir/IReservoir.sol";
-import "../../reservoir/Reservoir.sol";
-import "./IL2Reservoir.sol";
-import "./L2ReservoirStorage.sol";
+import { Managed } from "../../governance/Managed.sol";
+import { IGraphToken } from "../../token/IGraphToken.sol";
+import { AddressAliasHelper } from "../../arbitrum/AddressAliasHelper.sol";
+import { IReservoir } from "../../reservoir/IReservoir.sol";
+import { Reservoir } from "../../reservoir/Reservoir.sol";
+import { IL2Reservoir } from "./IL2Reservoir.sol";
+import { L2ReservoirV2Storage } from "./L2ReservoirStorage.sol";
+
+/**
+ * @dev ArbRetryableTx with additional interface to query the current redeemer.
+ * This is being added by the Arbitrum team but hasn't made it into the arbos-precompiles
+ * package yet.
+ */
+interface IArbTxWithRedeemer is ArbRetryableTx {
+    /**
+     * @notice Gets the redeemer of the current retryable redeem attempt.
+     * Returns the zero address if the current transaction is not a retryable redeem attempt.
+     * If this is an auto-redeem, returns the fee refund address of the retryable.
+     */
+    function getCurrentRedeemer() external view returns (address);
+}
 
 /**
  * @title L2 Rewards Reservoir
  * @dev This contract acts as a reservoir/vault for the rewards to be distributed on Layer 2.
  * It receives tokens for rewards from L1, and provides functions to compute accumulated and new
  * total rewards at a particular block number.
  */
-contract L2Reservoir is L2ReservoirV1Storage, Reservoir, IL2Reservoir {
+contract L2Reservoir is L2ReservoirV2Storage, Reservoir, IL2Reservoir {
     using SafeMath for uint256;
 
-    event DripReceived(uint256 _issuanceBase);
-    event NextDripNonceUpdated(uint256 _nonce);
+    // Address for the ArbRetryableTx interface provided by Arbitrum
+    address public constant ARB_TX_ADDRESS = 0x000000000000000000000000000000000000006E;
+
+    // Emitted when a rewards drip is received from L1
+    event DripReceived(uint256 issuanceBase);
+    // Emitted when the next drip nonce is manually updated by governance
+    event NextDripNonceUpdated(uint256 nonce);
+    // Emitted when the L1Reservoir's address is updated
+    event L1ReservoirAddressUpdated(address l1ReservoirAddress);
+    // Emitted when the L2 keeper reward fraction is updated
+    event L2KeeperRewardFractionUpdated(uint256 l2KeeperRewardFraction);
 
     /**
      * @dev Checks that the sender is the L2GraphTokenGateway as configured on the Controller.
@@ -36,6 +63,10 @@ contract L2Reservoir is L2ReservoirV1Storage, Reservoir, IL2Reservoir {
      * are not set here because they are set from L1 through the drip function.
      * The RewardsManager's address might also not be available in the controller at initialization
      * time, so approveRewardsManager() must be called separately.
+     * The l1ReservoirAddress must also be set separately through setL1ReservoirAddress
+     * for the same reason.
+     * In the same vein, the l2KeeperRewardFraction is assumed to be zero at initialization,
+     * so it must be set through setL2KeeperRewardFraction.
      * @param _controller Address of the Controller that manages this contract
      */
     function initialize(address _controller) external onlyImpl {
@@ -52,6 +83,30 @@ contract L2Reservoir is L2ReservoirV1Storage, Reservoir, IL2Reservoir {
         emit NextDripNonceUpdated(_nonce);
     }
 
+    /**
+     * @dev Sets the L1 Reservoir address
+     * This is the address on L1 that will appear as redeemer when a ticket
+     * was auto-redeemed.
+     * @param _l1ReservoirAddress New address for the L1Reservoir on L1
+     */
+    function setL1ReservoirAddress(address _l1ReservoirAddress) external onlyGovernor {
+        require(_l1ReservoirAddress != address(0), "INVALID_L1_RESERVOIR");
+        l1ReservoirAddress = _l1ReservoirAddress;
+        emit L1ReservoirAddressUpdated(_l1ReservoirAddress);
+    }
+
+    /**
+     * @dev Sets the L2 keeper reward fraction
+     * This is the fraction of the keeper reward that will be sent to the redeemer on L2
+     * if the retryable ticket is not auto-redeemed
+     * @param _l2KeeperRewardFraction New value for the fraction, with fixed point at 1e18
+     */
+    function setL2KeeperRewardFraction(uint256 _l2KeeperRewardFraction) external onlyGovernor {
+        require(_l2KeeperRewardFraction <= FIXED_POINT_SCALING_FACTOR, "INVALID_VALUE");
+        l2KeeperRewardFraction = _l2KeeperRewardFraction;
+        emit L2KeeperRewardFractionUpdated(_l2KeeperRewardFraction);
+    }
+
     /**
      * @dev Get new total rewards accumulated since the last drip.
      * This is deltaR = p * r ^ (blocknum - t0) - p, where:
@@ -88,14 +143,21 @@ contract L2Reservoir is L2ReservoirV1Storage, Reservoir, IL2Reservoir {
      * Note that the transaction might revert if it's received out-of-order,
      * because it checks an incrementing nonce. If that is the case, the retryable ticket can be redeemed
      * again once the ticket for previous drip has been redeemed.
+     * A keeper reward will be sent to the keeper that dripped on L1, and part of it
+     * to whoever redeemed the current retryable ticket (as reported by ArbRetryableTx.getCurrentRedeemer) if
+     * the ticket is not auto-redeemed.
      * @param _issuanceBase Base value for token issuance (approximation for token supply times L2 rewards fraction)
      * @param _issuanceRate Rewards issuance rate, using fixed point at 1e18, and including a +1
      * @param _nonce Incrementing nonce to ensure messages are received in order
+     * @param _keeperReward Keeper reward to distribute between keeper that called drip and keeper that redeemed the retryable tx
+     * @param _l1Keeper Address of the keeper that called drip in L1
      */
     function receiveDrip(
         uint256 _issuanceBase,
         uint256 _issuanceRate,
-        uint256 _nonce
+        uint256 _nonce,
+        uint256 _keeperReward,
+        address _l1Keeper
     ) external override onlyL2Gateway {
         require(_nonce == nextDripNonce, "INVALID_NONCE");
         nextDripNonce = nextDripNonce.add(1);
@@ -108,6 +170,22 @@ contract L2Reservoir is L2ReservoirV1Storage, Reservoir, IL2Reservoir {
             snapshotAccumulatedRewards();
         }
         issuanceBase = _issuanceBase;
+        IGraphToken grt = graphToken();
+
+        // Part of the reward always goes to whoever redeemed the  ticket in L2,
+        // unless this was an autoredeem, in which case the "redeemer" is the sender, i.e. L1Reservoir
+        address redeemer = IArbTxWithRedeemer(ARB_TX_ADDRESS).getCurrentRedeemer();
+        if (redeemer != AddressAliasHelper.applyL1ToL2Alias(l1ReservoirAddress)) {
+            uint256 _l2KeeperReward = _keeperReward.mul(l2KeeperRewardFraction).div(
+                FIXED_POINT_SCALING_FACTOR
+            );
+            grt.transfer(redeemer, _l2KeeperReward);
+            grt.transfer(_l1Keeper, _keeperReward.sub(_l2KeeperReward));
+        } else {
+            // In an auto-redeem, we just send all the rewards to the L1 keeper:
+            grt.transfer(_l1Keeper, _keeperReward);
+        }
+
         emit DripReceived(issuanceBase);
     }
 

contracts/l2/reservoir/L2ReservoirStorage.sol

@@ -3,9 +3,20 @@
 pragma solidity ^0.7.6;
 
 /**
- * @dev Storage variables for the L2Reservoir
+ * @dev Storage variables for the L2Reservoir, version 1
  */
 contract L2ReservoirV1Storage {
     // Expected nonce value for the next drip hook
     uint256 public nextDripNonce;
 }
+
+/**
+ * @dev Storage variables for the L2Reservoir, version 2
+ * This version adds some variables needed when introducing the keeper reward.
+ */
+contract L2ReservoirV2Storage is L2ReservoirV1Storage {
+    // Fraction of the keeper reward to send to the retryable tx redeemer in L2 (fixed point 1e18)
+    uint256 public l2KeeperRewardFraction;
+    // Address of the L1Reservoir on L1, used to check if a ticket was auto-redeemed
+    address public l1ReservoirAddress;
+}