fix: provide part of the keeper reward to L2 redeemer

contracts/l2/reservoir/L2Reservoir.sol

@@ -4,12 +4,22 @@ pragma solidity ^0.7.6;
 pragma abicoder v2;
 
 import "@openzeppelin/contracts/math/SafeMath.sol";
+import "arbos-precompiles/arbos/builtin/ArbRetryableTx.sol";
 
 import "../../reservoir/IReservoir.sol";
 import "../../reservoir/Reservoir.sol";
 import "./IL2Reservoir.sol";
 import "./L2ReservoirStorage.sol";
 
+interface IArbTxWithRedeemer {
+    /**
+     * @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.
@@ -19,8 +29,12 @@ import "./L2ReservoirStorage.sol";
 contract L2Reservoir is L2ReservoirV2Storage, Reservoir, IL2Reservoir {
     using SafeMath for uint256;
 
+    address public constant ARB_TX_ADDRESS = 0x000000000000000000000000000000000000006E;
+
     event DripReceived(uint256 _issuanceBase);
     event NextDripNonceUpdated(uint256 _nonce);
+    event L1ReservoirAddressUpdated(address _l1ReservoirAddress);
+    event L2KeeperRewardFractionUpdated(uint256 _l2KeeperRewardFraction);
 
     /**
      * @dev Checks that the sender is the L2GraphTokenGateway as configured on the Controller.
@@ -52,6 +66,29 @@ contract L2Reservoir is L2ReservoirV2Storage, 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 {
+        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:
@@ -115,14 +152,19 @@ contract L2Reservoir is L2ReservoirV2Storage, Reservoir, IL2Reservoir {
         }
         issuanceBase = _issuanceBase;
         IGraphToken grt = graphToken();
-        // We'd like to reward the keeper that redeemed the tx in L2
-        // but this won't work right now as tx.origin will actually be the L1 sender.
-        // uint256 _l2KeeperReward = _keeperReward.mul(l2KeeperRewardFraction).div(TOKEN_DECIMALS);
-        // // solhint-disable-next-line avoid-tx-origin
-        // grt.transfer(tx.origin, _l2KeeperReward);
-        // grt.transfer(_l1Keeper, _keeperReward.sub(_l2KeeperReward));
-        // So for now we just send all the rewards to teh L1 keeper:
-        grt.transfer(_l1Keeper, _keeperReward);
+
+        // 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 != 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 teh L1 keeper:
+            grt.transfer(_l1Keeper, _keeperReward);
+        }
+
         emit DripReceived(issuanceBase);
     }
 

contracts/l2/reservoir/L2ReservoirStorage.sol

@@ -13,4 +13,6 @@ contract L2ReservoirV1Storage {
 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;
 }

test/l2/l2Reservoir.test.ts

@@ -4,6 +4,7 @@ import { BigNumber, constants, ContractTransaction, utils } from 'ethers'
 import { L2FixtureContracts, NetworkFixture } from '../lib/fixtures'
 
 import { BigNumber as BN } from 'bignumber.js'
+import { FakeContract, smock } from '@defi-wonderland/smock'
 
 import {
   advanceBlocks,
@@ -30,11 +31,13 @@ const dripIssuanceRate = toBN('1000000023206889619')
 describe('L2Reservoir', () => {
   let governor: Account
   let testAccount1: Account
+  let testAccount2: Account
   let mockRouter: Account
   let mockL1GRT: Account
   let mockL1Gateway: Account
   let mockL1Reservoir: Account
   let fixture: NetworkFixture
+  let arbTxMock: FakeContract
 
   let grt: L2GraphToken
   let l2Reservoir: L2Reservoir
@@ -122,7 +125,7 @@ describe('L2Reservoir', () => {
   }
 
   before(async function () {
-    ;[governor, testAccount1, mockRouter, mockL1GRT, mockL1Gateway, mockL1Reservoir] =
+    ;[governor, testAccount1, mockRouter, mockL1GRT, mockL1Gateway, mockL1Reservoir, testAccount2] =
       await getAccounts()
 
     fixture = new NetworkFixture()
@@ -136,6 +139,11 @@ describe('L2Reservoir', () => {
       mockL1Gateway.address,
       mockL1Reservoir.address,
     )
+
+    arbTxMock = await smock.fake('IArbTxWithRedeemer', {
+      address: '0x000000000000000000000000000000000000006E',
+    })
+    arbTxMock.getCurrentRedeemer.returns(mockL1Reservoir.address)
   })
 
   beforeEach(async function () {
@@ -157,7 +165,42 @@ describe('L2Reservoir', () => {
       await expect(await l2Reservoir.nextDripNonce()).to.eq(toBN('10'))
     })
   })
+
+  describe('setL1ReservoirAddress', async function () {
+    it('rejects unauthorized calls', async function () {
+      const tx = l2Reservoir
+        .connect(testAccount1.signer)
+        .setL1ReservoirAddress(testAccount1.address)
+      await expect(tx).revertedWith('Caller must be Controller governor')
+    })
+    it('sets the L1Reservoir address', async function () {
+      const tx = l2Reservoir.connect(governor.signer).setL1ReservoirAddress(testAccount1.address)
+      await expect(tx).emit(l2Reservoir, 'L1ReservoirAddressUpdated').withArgs(testAccount1.address)
+      await expect(await l2Reservoir.l1ReservoirAddress()).to.eq(testAccount1.address)
+    })
+  })
+
+  describe('setL2KeeperRewardFraction', async function () {
+    it('rejects unauthorized calls', async function () {
+      const tx = l2Reservoir.connect(testAccount1.signer).setL2KeeperRewardFraction(toBN(1))
+      await expect(tx).revertedWith('Caller must be Controller governor')
+    })
+    it('rejects invalid values (> 1)', async function () {
+      const tx = l2Reservoir.connect(governor.signer).setL2KeeperRewardFraction(toGRT('1.000001'))
+      await expect(tx).revertedWith('INVALID_VALUE')
+    })
+    it('sets the L1Reservoir address', async function () {
+      const tx = l2Reservoir.connect(governor.signer).setL2KeeperRewardFraction(toGRT('0.999'))
+      await expect(tx).emit(l2Reservoir, 'L2KeeperRewardFractionUpdated').withArgs(toGRT('0.999'))
+      await expect(await l2Reservoir.l2KeeperRewardFraction()).to.eq(toGRT('0.999'))
+    })
+  })
+
   describe('receiveDrip', async function () {
+    beforeEach(async function () {
+      await l2Reservoir.connect(governor.signer).setL2KeeperRewardFraction(toGRT('0.2'))
+      await l2Reservoir.connect(governor.signer).setL1ReservoirAddress(mockL1Reservoir.address)
+    })
     it('rejects the call when not called by the gateway', async function () {
       const tx = l2Reservoir
         .connect(governor.signer)
@@ -224,14 +267,40 @@ describe('L2Reservoir', () => {
       )
       const tx = await validGatewayFinalizeTransfer(receiveDripTx.data, reward)
       dripBlock = await latestBlock()
-      await expect(await l2Reservoir.normalizedTokenSupplyCache()).to.eq(dripNormalizedSupply)
+      await expect(await l2Reservoir.issuanceBase()).to.eq(dripNormalizedSupply)
       await expect(await l2Reservoir.issuanceRate()).to.eq(dripIssuanceRate)
       await expect(tx).emit(l2Reservoir, 'DripReceived').withArgs(dripNormalizedSupply)
       await expect(tx)
         .emit(grt, 'Transfer')
         .withArgs(l2Reservoir.address, testAccount1.address, reward)
       await expect(await grt.balanceOf(testAccount1.address)).to.eq(reward)
     })
+    it('delivers part of the keeper reward to the L2 redeemer', async function () {
+      arbTxMock.getCurrentRedeemer.returns(testAccount2.address)
+      await l2Reservoir.connect(governor.signer).setL2KeeperRewardFraction(toGRT('0.25'))
+      normalizedSupply = dripNormalizedSupply
+      const reward = toGRT('16')
+      const receiveDripTx = await l2Reservoir.populateTransaction.receiveDrip(
+        dripNormalizedSupply,
+        dripIssuanceRate,
+        toBN('0'),
+        reward,
+        testAccount1.address,
+      )
+      const tx = await validGatewayFinalizeTransfer(receiveDripTx.data, reward)
+      dripBlock = await latestBlock()
+      await expect(await l2Reservoir.issuanceBase()).to.eq(dripNormalizedSupply)
+      await expect(await l2Reservoir.issuanceRate()).to.eq(dripIssuanceRate)
+      await expect(tx).emit(l2Reservoir, 'DripReceived').withArgs(dripNormalizedSupply)
+      await expect(tx)
+        .emit(grt, 'Transfer')
+        .withArgs(l2Reservoir.address, testAccount1.address, toGRT('12'))
+      await expect(tx)
+        .emit(grt, 'Transfer')
+        .withArgs(l2Reservoir.address, testAccount2.address, toGRT('4'))
+      await expect(await grt.balanceOf(testAccount1.address)).to.eq(toGRT('12'))
+      await expect(await grt.balanceOf(testAccount2.address)).to.eq(toGRT('4'))
+    })
     it('updates the normalized supply cache and issuance rate', async function () {
       normalizedSupply = dripNormalizedSupply
       let receiveDripTx = await l2Reservoir.populateTransaction.receiveDrip(