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/BlastERC20RebasingYield.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {BlastNativeYield} from "./BlastNativeYield.sol";
+import {IERC20Rebasing, YieldMode as IERC20Rebasing__YieldMode} from "./interfaces/IERC20Rebasing.sol";
+
+/**
+ * @title BlastERC20RebasingYield
+ * @notice This contract is a base contract for inheriting functions to claim Blast WETH or USDB yield
+ * @author LooksRare protocol team (👀,💎)
+ */
+contract BlastERC20RebasingYield is BlastNativeYield {
+    address public immutable WETH;
+    address public immutable USDB;
+
+    /**
+     * @param _blast Blast precompile
+     * @param _blastPoints Blast points
+     * @param _blastPointsOperator Blast points operator
+     * @param _governor The address that’s allowed to claim the contract’s yield and gas
+     * @param _usdb USDB address
+     * @param _weth WETH address
+     */
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _governor,
+        address _usdb,
+        address _weth
+    ) BlastNativeYield(_blast, _blastPoints, _blastPointsOperator, _governor) {
+        WETH = _weth;
+        USDB = _usdb;
+
+        IERC20Rebasing(_weth).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
+        IERC20Rebasing(_usdb).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
+    }
+
+    /**
+     * @notice Claim Blast yield. Guarding of the function is dependent on the inherited contract.
+     * @param wethReceiver The receiver of WETH.
+     * @param usdbReceiver The receiver of USDB.
+     */
+    function _claim(address wethReceiver, address usdbReceiver) internal {
+        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/BlastNativeYield.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IBlast, YieldMode, GasMode} from "./interfaces/IBlast.sol";
+import {BlastPoints} from "./BlastPoints.sol";
+
+/**
+ * @title BlastNativeYield
+ * @notice This contract is a base contract for inheriting functions to claim native yield and for those that wish to recieve Blast points
+ * @author LooksRare protocol team (👀,💎)
+ */
+contract BlastNativeYield is BlastPoints {
+    /**
+     * @param _blast Blast precompile
+     * @param _blastPoints Blast points
+     * @param _blastPointsOperator Blast points operator
+     * @param _governor The address that’s allowed to claim the contract’s yield and gas
+     */
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _governor
+    ) BlastPoints(_blastPoints, _blastPointsOperator) {
+        IBlast(_blast).configure(YieldMode.CLAIMABLE, GasMode.CLAIMABLE, _governor);
+    }
+}

contracts/BlastPoints.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IBlastPoints} from "./interfaces/IBlastPoints.sol";
+
+/**
+ * @title BlastPoints
+ * @notice This contract is a base for future contracts that wish to be recipients of Blast points to inherit from
+ * @author LooksRare protocol team (👀,💎)
+ */
+contract BlastPoints {
+    /**
+     * @param _blastPoints Blast points
+     * @param _blastPointsOperator Blast points operator
+     */
+    constructor(address _blastPoints, address _blastPointsOperator) {
+        IBlastPoints(_blastPoints).configurePointsOperator(_blastPointsOperator);
+    }
+}

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

@@ -74,12 +74,12 @@
     "hardhat-gas-reporter": "^1.0.8",
     "husky": "^7.0.4",
     "merkletreejs": "^0.2.31",
+    "@openzeppelin/contracts": "^5.0.2",
     "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"

test/foundry/BlastERC20RebasingYield.t.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IOwnableTwoSteps} from "../../contracts/interfaces/IOwnableTwoSteps.sol";
+import {OwnableTwoSteps} from "../../contracts/OwnableTwoSteps.sol";
+import {BlastERC20RebasingYield} from "../../contracts/BlastERC20RebasingYield.sol";
+import {TestHelpers} from "./utils/TestHelpers.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 {MockBlastERC20} from "../mock/MockBlastERC20.sol";
+import {MockBlastPoints} from "../mock/MockBlastPoints.sol";
+import {MockBlastWETH} from "../mock/MockBlastWETH.sol";
+import {MockBlastYield} from "../mock/MockBlastYield.sol";
+
+contract BlastERC20RebasingYieldOwnableTwoSteps is BlastERC20RebasingYield, OwnableTwoSteps {
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _owner,
+        address _usdb,
+        address _weth
+    )
+        BlastERC20RebasingYield(_blast, _blastPoints, _blastPointsOperator, _owner, _usdb, _weth)
+        OwnableTwoSteps(_owner)
+    {}
+
+    function claim(address wethReceiver, address usdbReceiver) public onlyOwner {
+        _claim(wethReceiver, usdbReceiver);
+    }
+}
+
+contract BlastERC20RebasingYield_Test is TestHelpers {
+    MockBlastWETH private weth;
+    MockBlastERC20 private usdb;
+    MockBlastYield private mockBlastYield;
+    MockBlastPoints private mockBlastPoints;
+    BlastERC20RebasingYieldOwnableTwoSteps private blastERC20RebasingYieldOwnableTwoSteps;
+
+    address public owner = address(69);
+    address public operator = address(420);
+    address public user1 = address(1);
+    address private constant TREASURY = address(69420);
+
+    function setUp() public {
+        weth = new MockBlastWETH();
+        usdb = new MockBlastERC20("USDB", "USDB");
+        mockBlastYield = new MockBlastYield();
+        mockBlastPoints = new MockBlastPoints();
+        blastERC20RebasingYieldOwnableTwoSteps = new BlastERC20RebasingYieldOwnableTwoSteps(
+            address(mockBlastYield),
+            address(mockBlastPoints),
+            operator,
+            owner,
+            address(usdb),
+            address(weth)
+        );
+    }
+
+    function test_setUpState() public {
+        assertEq(blastERC20RebasingYieldOwnableTwoSteps.WETH(), address(weth));
+        assertEq(blastERC20RebasingYieldOwnableTwoSteps.USDB(), address(usdb));
+
+        IERC20Rebasing__YieldMode wethYieldMode = weth.yieldMode(address(blastERC20RebasingYieldOwnableTwoSteps));
+        assertEq(uint8(wethYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
+
+        IERC20Rebasing__YieldMode usdbYieldMode = usdb.yieldMode(address(blastERC20RebasingYieldOwnableTwoSteps));
+        assertEq(uint8(usdbYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
+    }
+
+    function test_claim() public asPrankedUser(owner) {
+        blastERC20RebasingYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+
+        assertEq(weth.balanceOf(address(blastERC20RebasingYieldOwnableTwoSteps)), 0);
+        assertEq(usdb.balanceOf(address(blastERC20RebasingYieldOwnableTwoSteps)), 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);
+        blastERC20RebasingYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+    }
+}

test/foundry/BlastNativeYield.t.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IOwnableTwoSteps} from "../../contracts/interfaces/IOwnableTwoSteps.sol";
+import {OwnableTwoSteps} from "../../contracts/OwnableTwoSteps.sol";
+import {BlastNativeYield} from "../../contracts/BlastNativeYield.sol";
+import {TestHelpers} from "./utils/TestHelpers.sol";
+import {YieldMode, GasMode} from "../../contracts/interfaces/IBlast.sol";
+
+import {MockBlastPoints} from "../mock/MockBlastPoints.sol";
+import {MockBlastYield} from "../mock/MockBlastYield.sol";
+
+contract BlastNativeYield_Test is TestHelpers {
+    MockBlastYield private mockBlastYield;
+    MockBlastPoints private mockBlastPoints;
+    BlastNativeYield private blastNativeYield;
+
+    address public owner = address(69);
+    address public operator = address(420);
+    address private constant TREASURY = address(69420);
+
+    function setUp() public {
+        mockBlastPoints = new MockBlastPoints();
+        mockBlastYield = new MockBlastYield();
+        blastNativeYield = new BlastNativeYield(address(mockBlastYield), address(mockBlastPoints), operator, owner);
+    }
+
+    function test_setUpState() public {
+        (YieldMode yieldMode, GasMode gasMode, address governor) = mockBlastYield.config(address(blastNativeYield));
+        assertEq(uint8(yieldMode), uint8(YieldMode.CLAIMABLE));
+        assertEq(uint8(gasMode), uint8(GasMode.CLAIMABLE));
+        assertEq(governor, owner);
+    }
+}