feat: BlastYield contract

.github/workflows/checks.yaml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v3
         with:
-          node-version: 14.x
+          node-version: 16.x
       - name: Get yarn cache directory path
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"

.github/workflows/tests.yaml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v3
         with:
-          node-version: 14.x
+          node-version: 16.x
       - name: Get yarn cache directory path
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"

contracts/BlastYield.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IBlast, YieldMode as IBlast__YieldMode, GasMode as IBlast__GasMode} from "./interfaces/IBlast.sol";
+import {IBlastPoints} from "./interfaces/IBlastPoints.sol";
+import {IERC20Rebasing, YieldMode as IERC20Rebasing__YieldMode} from "./interfaces/IERC20Rebasing.sol";
+
+/**
+ * @title BlastYield
+ * @notice This contract is a base contract for future contracts that wish to claim Blast WETH or USDB yield to inherit from.
+ * @author LooksRare protocol team (👀,💎)
+ */
+contract BlastYield {
+    address public immutable WETH;
+    address public immutable USDB;
+
+    /**
+     * @param _blast Blast precompile
+     * @param _blastPoints Blast points
+     * @param _blastPointsOperator Blast points operator
+     * @param _owner Owner of the contract
+     * @param _usdb USDB address
+     * @param _weth WETH address
+     */
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _owner,
+        address _usdb,
+        address _weth
+    ) {
+        WETH = _weth;
+        USDB = _usdb;
+
+        IBlast(_blast).configure(IBlast__YieldMode.CLAIMABLE, IBlast__GasMode.CLAIMABLE, _owner);
+        IBlastPoints(_blastPoints).configurePointsOperator(_blastPointsOperator);
+        IERC20Rebasing(_weth).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
+        IERC20Rebasing(_usdb).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
+    }
+
+    /**
+     * @notice Claim Blast yield. Only callable by contract owner.
+     * @param wethReceiver The receiver of WETH.
+     * @param usdbReceiver The receiver of USDB.
+     */
+    function _claim(address wethReceiver, address usdbReceiver) internal virtual {
+        uint256 claimableWETH = IERC20Rebasing(WETH).getClaimableAmount(address(this));
+        if (claimableWETH != 0) {
+            IERC20Rebasing(WETH).claim(wethReceiver, claimableWETH);
+        }
+
+        uint256 claimableUSDB = IERC20Rebasing(USDB).getClaimableAmount(address(this));
+        if (claimableUSDB != 0) {
+            IERC20Rebasing(USDB).claim(usdbReceiver, claimableUSDB);
+        }
+    }
+}

contracts/interfaces/IBlast.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+enum YieldMode {
+    AUTOMATIC,
+    VOID,
+    CLAIMABLE
+}
+
+enum GasMode {
+    VOID,
+    CLAIMABLE
+}
+
+interface IBlast {
+    // configure
+    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;
+
+    function configure(YieldMode _yield, GasMode gasMode, address governor) external;
+
+    // base configuration options
+    function configureClaimableYield() external;
+
+    function configureClaimableYieldOnBehalf(address contractAddress) external;
+
+    function configureAutomaticYield() external;
+
+    function configureAutomaticYieldOnBehalf(address contractAddress) external;
+
+    function configureVoidYield() external;
+
+    function configureVoidYieldOnBehalf(address contractAddress) external;
+
+    function configureClaimableGas() external;
+
+    function configureClaimableGasOnBehalf(address contractAddress) external;
+
+    function configureVoidGas() external;
+
+    function configureVoidGasOnBehalf(address contractAddress) external;
+
+    function configureGovernor(address _governor) external;
+
+    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;
+
+    // claim yield
+    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
+
+    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);
+
+    // claim gas
+    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
+
+    function claimGasAtMinClaimRate(
+        address contractAddress,
+        address recipientOfGas,
+        uint256 minClaimRateBips
+    ) external returns (uint256);
+
+    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
+
+    function claimGas(
+        address contractAddress,
+        address recipientOfGas,
+        uint256 gasToClaim,
+        uint256 gasSecondsToConsume
+    ) external returns (uint256);
+
+    // read functions
+    function readClaimableYield(address contractAddress) external view returns (uint256);
+
+    function readYieldConfiguration(address contractAddress) external view returns (uint8);
+
+    function readGasParams(
+        address contractAddress
+    ) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
+}

contracts/interfaces/IBlastPoints.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IBlastPoints {
+    function configurePointsOperator(address operator) external;
+}

contracts/interfaces/IERC20Rebasing.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+enum YieldMode {
+    AUTOMATIC,
+    VOID,
+    CLAIMABLE
+}
+
+interface IERC20Rebasing {
+    // changes the yield mode of the caller and update the balance
+    // to reflect the configuration
+    function configure(YieldMode) external returns (uint256);
+
+    // "claimable" yield mode accounts can call this this claim their yield
+    // to another address
+    function claim(address recipient, uint256 amount) external returns (uint256);
+
+    // read the claimable amount for an account
+    function getClaimableAmount(address account) external view returns (uint256);
+}

hardhat.config.ts

@@ -33,7 +33,7 @@ const config: HardhatUserConfig = {
   solidity: {
     compilers: [
       {
-        version: "0.8.17",
+        version: "0.8.20",
         settings: { optimizer: { enabled: true, runs: 888888 } },
       },
       {

package.json

@@ -75,13 +75,16 @@
     "husky": "^7.0.4",
     "merkletreejs": "^0.2.31",
     "prettier": "^2.3.2",
-    "prettier-plugin-solidity": "^1.1.1",
+    "prettier-plugin-solidity": "^1.3.0",
     "release-it": "^15.0.0",
     "solhint": "^3.3.7",
     "solidity-coverage": "^0.7.21",
     "solmate": "^6.6.1",
     "ts-node": "^10.1.0",
     "typechain": "^5.1.2",
     "typescript": "^4.5.2"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.2"
   }
 }

test/foundry/BlastYield.t.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IOwnableTwoSteps} from "../../contracts/interfaces/IOwnableTwoSteps.sol";
+import {OwnableTwoSteps} from "../../contracts/OwnableTwoSteps.sol";
+import {BlastYield} from "../../contracts/BlastYield.sol";
+import {Test} from "../../lib/forge-std/src/Test.sol";
+import {YieldMode as IBlast__YieldMode, GasMode as IBlast__GasMode} from "../../contracts/interfaces/IBlast.sol";
+import {YieldMode as IERC20Rebasing__YieldMode} from "../../contracts/interfaces/IERC20Rebasing.sol";
+
+import {MockERC20} from "../mock/MockBlastERC20.sol";
+import {MockPoints} from "../mock/MockBlastPoints.sol";
+import {MockWETH} from "../mock/MockBlastWETH.sol";
+import {MockYield} from "../mock/MockBlastYield.sol";
+
+contract BlastYieldOwnableTwoSteps is BlastYield, OwnableTwoSteps {
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _owner,
+        address _usdb,
+        address _weth
+    ) BlastYield(_blast, _blastPoints, _blastPointsOperator, _owner, _usdb, _weth) OwnableTwoSteps(_owner) {}
+
+    function claim(address wethReceiver, address usdbReceiver) public onlyOwner {
+        _claim(wethReceiver, usdbReceiver);
+    }
+}
+
+contract BlastYieldOwnableTwoSteps_Test is Test {
+    MockWETH private weth;
+    MockERC20 private usdb;
+    MockYield private mockYield;
+    MockPoints private mockPoints;
+    BlastYieldOwnableTwoSteps private blastYieldOwnableTwoSteps;
+
+    address public owner = address(69);
+    address public operator = address(420);
+    address public user1 = address(1);
+    address private constant TREASURY = address(69420);
+    address internal constant BLAST_POINTS = 0x2536FE9ab3F511540F2f9e2eC2A805005C3Dd800;
+    bytes32 private constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
+
+    function setUp() public {
+        vm.etch(BLAST_POINTS, address(new MockPoints()).code);
+        weth = new MockWETH();
+        usdb = new MockERC20("USDB", "USDB");
+        mockYield = new MockYield();
+        blastYieldOwnableTwoSteps = new BlastYieldOwnableTwoSteps(
+            address(mockYield),
+            BLAST_POINTS,
+            operator,
+            owner,
+            address(usdb),
+            address(weth)
+        );
+    }
+
+    function test_setUpState() public {
+        assertEq(blastYieldOwnableTwoSteps.WETH(), address(weth));
+        assertEq(blastYieldOwnableTwoSteps.USDB(), address(usdb));
+
+        (IBlast__YieldMode yieldMode, IBlast__GasMode gasMode, address governor) = mockYield.config(
+            address(blastYieldOwnableTwoSteps)
+        );
+        assertEq(uint8(yieldMode), uint8(IBlast__YieldMode.CLAIMABLE));
+        assertEq(uint8(gasMode), uint8(IBlast__GasMode.CLAIMABLE));
+        assertEq(governor, owner);
+
+        IERC20Rebasing__YieldMode wethYieldMode = weth.yieldMode(address(blastYieldOwnableTwoSteps));
+        assertEq(uint8(wethYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
+
+        IERC20Rebasing__YieldMode usdbYieldMode = usdb.yieldMode(address(blastYieldOwnableTwoSteps));
+        assertEq(uint8(usdbYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
+    }
+
+    function test_claim() public asPrankedUser(owner) {
+        blastYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+
+        assertEq(weth.balanceOf(address(blastYieldOwnableTwoSteps)), 0);
+        assertEq(usdb.balanceOf(address(blastYieldOwnableTwoSteps)), 0);
+        assertEq(weth.balanceOf(TREASURY), 1 ether);
+        assertEq(usdb.balanceOf(TREASURY), 1 ether);
+    }
+
+    function test_claim_RevertIf_NotOwner() public asPrankedUser(user1) {
+        vm.expectRevert(IOwnableTwoSteps.NotOwner.selector);
+        blastYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+    }
+
+    modifier asPrankedUser(address user) {
+        vm.startPrank(user);
+        _;
+        vm.stopPrank();
+    }
+}

test/mock/MockBlastERC20.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+import {YieldMode} from "../../../contracts/interfaces/IERC20Rebasing.sol";
+
+contract MockERC20 is ERC20 {
+    mapping(address _contract => YieldMode) public yieldMode;
+
+    constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) {}
+
+    function mint(address to, uint256 amount) public {
+        _mint(to, amount);
+    }
+
+    function configure(YieldMode _yieldMode) external returns (uint256) {
+        yieldMode[msg.sender] = _yieldMode;
+        return uint256(_yieldMode);
+    }
+
+    function getClaimableAmount(address) external pure returns (uint256) {
+        return 1 ether;
+    }
+
+    function claim(address receiver, uint256 amount) external returns (uint256) {
+        _mint(receiver, amount);
+        return amount;
+    }
+}

test/mock/MockBlastPoints.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract MockPoints {
+    function configurePointsOperator(address operator) external {}
+}