wip: add bridge type

PufferFinance · Jul 19, 2024 · 58c2f2e · 58c2f2e
1 parent d9efd52
commit 58c2f2e
Show file tree

Hide file tree

Showing 5 changed files with 123 additions and 63 deletions.
diff --git a/mainnet-contracts/script/DeployL2RewardManager.s.sol b/mainnet-contracts/script/DeployL2RewardManager.s.sol
@@ -6,6 +6,7 @@ import "forge-std/Script.sol";
 import { stdJson } from "forge-std/StdJson.sol";
 import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import { BaseScript } from "./BaseScript.s.sol";
+import { ROLE_ID_OPERATIONS_MULTISIG, PUBLIC_ROLE } from "../script/Roles.sol";
 import { AccessManager } from "@openzeppelin/contracts/access/manager/AccessManager.sol";
 import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 import { Timelock } from "../src/Timelock.sol";
@@ -45,11 +46,11 @@ contract DeployL2RewardManager is BaseScript {
         bridgeContractSelector[0] = L2RewardManager.xReceive.selector;
 
         // TODO - create new role for bridge contract
-        bytes memory cd = abi.encodeWithSelector(AccessManager.setTargetFunctionRole.selector, address(proxy), bridgeContractSelector, accessManager.BRIDGE_ROLE());
+        bytes memory cd = abi.encodeWithSelector(AccessManager.setTargetFunctionRole.selector, address(proxy), bridgeContractSelector, PUBLIC_ROLE);
 
         console.logBytes(cd);
         accessManager.execute(address(accessManager), cd);
 
-        accessManager.grantRole(accessManager.BRIDGE_ROLE(), _CONNEXT, 0);
+        accessManager.grantRole(PUBLIC_ROLE, _CONNEXT, 0);
     }
 }
diff --git a/mainnet-contracts/src/interface/IL2RewardManager.sol b/mainnet-contracts/src/interface/IL2RewardManager.sol
@@ -38,16 +38,24 @@ interface IL2RewardManager {
     ) external returns (bytes memory);
 
     /**
-     * @notice Posts the updated rewards root for a specific epoch range
-     * @param startEpoch The start epoch of the interval
-     * @param endEpoch The end epoch of the interval
-     * @param root The merkle root of the rewards
+     * @notice Sets the claimer for a specific account
+     * @param account The account to set the claimer for
+     * @param claimer The address of the claimer
      */
-    function postRewardsRoot(
-        uint64 startEpoch,
-        uint64 endEpoch,
-        bytes32 root
-    ) external;
+
+      function setClaimer(address account, address claimer) external;
+
+    // /**
+    //  * @notice Posts the updated rewards root for a specific epoch range
+    //  * @param startEpoch The start epoch of the interval
+    //  * @param endEpoch The end epoch of the interval
+    //  * @param root The merkle root of the rewards
+    //  */
+    // function postRewardsRoot(
+    //     uint64 startEpoch,
+    //     uint64 endEpoch,
+    //     bytes32 root
+    // ) external;
 
     /**
      * @notice Claims the rewards for a specific epoch range
@@ -56,26 +64,14 @@ interface IL2RewardManager {
     function claimRewards(ClaimOrder[] calldata claimOrders) external;
 
     /**
-     * @notice Event emitted when reward amount is received
-     * @param startEpoch The start epoch of the interval
-     * @param endEpoch The end epoch of the interval
-     * @param rewardsRoot The merkle root of the rewards
+     * @notice Event emitted when rewards root and rate are posted
      * @param rewardsAmount The total rewards amount
-     */
-    event RewardAmountReceived(
-        uint64 startEpoch,
-        uint64 endEpoch,
-        bytes32 rewardsRoot,
-        uint128 rewardsAmount
-    );
-
-    /**
-     * @notice Event emitted when rewards root is posted
+     * @param ethToPufETHRate The exchange rate from ETH to pufETH
      * @param startEpoch The start epoch of the interval
      * @param endEpoch The end epoch of the interval
      * @param root The merkle root of the rewards
      */
-    event RewardsRootPosted(uint64 startEpoch, uint64 endEpoch, bytes32 root);
+    event RewardRootAndRatePosted( uint128 rewardsAmount,  uint128 ethToPufETHRate, uint64 startEpoch, uint64 endEpoch, bytes32 root);
 
     /**
      * @notice Event emitted when rewards are claimed
@@ -110,4 +106,9 @@ interface IL2RewardManager {
      * @notice Custom error for invalid proof
      */
     error InvalidProof();
+
+    /**
+     * @notice Custom error for invalid bridging type
+     */
+    error InvalidBridgingType();
 }
diff --git a/mainnet-contracts/src/l2-contracts/L2RewardManager.sol b/mainnet-contracts/src/l2-contracts/L2RewardManager.sol
@@ -5,7 +5,7 @@ import {IL2RewardManager} from "../interface/IL2RewardManager.sol";
 import {IXReceiver} from "interfaces/core/IXReceiver.sol";
 import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
-import {BridgingParams, ClaimOrder} from "../struct/RewardManagerInfo.sol";
+import {BridgingParams, BridgingType, MintAndBridgeParams, SetClaimerParams, ClaimOrder} from "../struct/RewardManagerInfo.sol";
 import {AccessManagedUpgradeable} from "@openzeppelin-contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin-contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {RewardManagerStorage} from "../struct/RewardManagerStorage.sol";
@@ -62,38 +62,56 @@ contract L2RewardManager is
         restricted
         returns (bytes memory)
     {
-        // Check for the right token
-        if (_asset != address(XTOKEN)) {
-            revert InvalidAsset();
-        }
-
         // Decode the _callData to get the BridgingParams
-        BridgingParams memory params = abi.decode(_callData, (BridgingParams));
+        BridgingParams memory bridgingParams = abi.decode(
+            _callData,
+            (BridgingParams)
+        );
+        BridgingType bridgeType = bridgingParams.bridgingType;
+
+        if (bridgeType == BridgingType.MintAndBridge) {
+            MintAndBridgeParams memory params = abi.decode(
+                bridgingParams.data,
+                (MintAndBridgeParams)
+            );
+            // Check for the right token
+            if (_asset != address(XTOKEN)) {
+                revert InvalidAsset();
+            }
+
+            if (_amount < params.rewardsAmount) revert InvalidAmount();
 
-        if (_amount < params.rewardsAmount) {
-            revert InvalidAmount();
+            RewardManagerStorage storage $ = _getRewardManagerStorage();
+
+            $.rewardRoots[params.startEpoch][params.endEpoch] = params
+                .rewardsRoot;
+            $.ethToPufETHRates[params.startEpoch][params.endEpoch] = params
+                .ethToPufETHRate;
+
+            emit RewardRootAndRatePosted(
+                params.rewardsAmount,
+                params.ethToPufETHRate,
+                params.startEpoch,
+                params.endEpoch,
+                params.rewardsRoot
+            );
+        } else if (bridgeType == BridgingType.SetClaimer) {
+            // Set the claimer
+            SetClaimerParams memory claimerParams = abi.decode(
+                bridgingParams.data,
+                (SetClaimerParams)
+            );
+            setClaimer(claimerParams.account, claimerParams.claimer);
+        } else {
+            revert InvalidBridgingType();
         }
 
-        emit RewardAmountReceived(
-            params.startEpoch,
-            params.endEpoch,
-            params.rewardsRoot,
-            params.rewardsAmount
-        );
         //TODO: do something with calldata?
         return abi.encode(true);
     }
 
-    /// @inheritdoc IL2RewardManager
-    function postRewardsRoot(
-        uint64 startEpoch,
-        uint64 endEpoch,
-        bytes32 root
-    ) external restricted {
-        RewardManagerStorage storage $ = _getRewardManagerStorage();
-
-        $.rewardRoots[startEpoch][endEpoch] = root;
-        emit RewardsRootPosted(startEpoch, endEpoch, root);
+    function setClaimer(address account, address claimer) public restricted {
+        // TODO: implement
     }
 
     /// @inheritdoc IL2RewardManager
@@ -120,6 +138,9 @@ contract L2RewardManager is
             bytes32 rewardRoot = $.rewardRoots[claimOrder.startEpoch][
                 claimOrder.endEpoch
             ];
+            uint128 ethToPufETHRate = $.ethToPufETHRates[claimOrder.startEpoch][
+                claimOrder.endEpoch
+            ];
 
             // Node calculated using: keccak256(abi.encode(alice, startEpoch, endEpoch, total))
             bytes32 leaf = keccak256(
@@ -141,14 +162,15 @@ contract L2RewardManager is
             $.claimedRewards[claimOrder.startEpoch][claimOrder.endEpoch][
                     claimOrder.account
                 ] = true;
+            uint256 amountToTransfer = claimOrder.amount * ethToPufETHRate;
 
-            XTOKEN.safeTransfer(claimOrder.account, claimOrder.amount);
+            XTOKEN.safeTransfer(claimOrder.account, amountToTransfer);
 
             emit Claimed(
                 claimOrder.account,
                 claimOrder.startEpoch,
                 claimOrder.endEpoch,
-                claimOrder.amount
+                amountToTransfer
             );
         }
     }

diff --git a/mainnet-contracts/src/struct/RewardManagerInfo.sol b/mainnet-contracts/src/struct/RewardManagerInfo.sol
@@ -1,16 +1,48 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.8.0 <0.9.0;
 
-/**
- * @dev Parameters for bridging from PufferVaultV3 to L2RewardManager
- */
-struct BridgingParams {
-    uint128 rewardsAmount;
-    uint64 startEpoch;
-    uint64 endEpoch;
-    bytes32 rewardsRoot;
-    string rewardsURI;
-}
+    enum BridgingType {
+        MintAndBridge,
+        SetClaimer
+    }
+
+        /**
+     * @notice Parameters for bridging actions.
+     * @param bridgingType The type of bridging action.
+     * @param data The data associated with the bridging action.
+     */
+    struct BridgingParams {
+        BridgingType bridgingType;
+        bytes data;
+    }
+
+    /**
+     * @notice Parameters for setting a claimer.
+     * @param account The account setting the claimer.
+     * @param claimer The address of the new claimer.
+     */
+    struct SetClaimerParams {
+        address account;
+        address claimer;
+    }
+
+   /**
+     * @notice Parameters for minting and bridging rewards.
+     * @param rewardsAmount The amount of rewards to be bridged.
+     * @param ethToPufETHRate The exchange rate from ETH to pufETH.
+     * @param startEpoch The starting epoch for the rewards.
+     * @param endEpoch The ending epoch for the rewards.
+     * @param rewardsRoot The merkle root of the rewards.
+     * @param rewardsURI The URI for the rewards metadata.
+     */
+    struct MintAndBridgeParams {
+        uint128 rewardsAmount;
+        uint128 ethToPufETHRate;
+        uint64 startEpoch;
+        uint64 endEpoch;
+        bytes32 rewardsRoot;
+        string rewardsURI;
+    }
 
 /// @dev A record of a single order for claim function call.
 /// @param startEpoch The start epoch of the interval where the merkle root is generated from.

diff --git a/mainnet-contracts/src/struct/RewardManagerStorage.sol b/mainnet-contracts/src/struct/RewardManagerStorage.sol
@@ -10,6 +10,10 @@ pragma solidity >=0.8.0 <0.9.0;
  *      +-----------------------------------------------------------+
  */
 struct RewardManagerStorage {
+    /**
+     * @notice Mapping to track the exchange rate from ETH to pufETH for each unique epoch range
+     */
+    mapping(uint64 startEpoch => mapping(uint64 endEpoch => uint128 ethToPufETHRate)) ethToPufETHRates;
     /**
      * @notice Mapping to track reward roots for each unique epoch range
      */