feat: BlastYield contract

contracts/BlastYield.sol → contracts/BlastERC20RebasingYield.sol

@@ -2,16 +2,15 @@
 
 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 {BlastNativeYield} from "./BlastNativeYield.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.
+ * @title BlastERC20RebasingYield
+ * @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 {
+contract BlastERC20RebasingYield is BlastNativeYield {
     address public immutable WETH;
     address public immutable USDB;
 
@@ -30,12 +29,10 @@ contract BlastYield {
         address _governor,
         address _usdb,
         address _weth
-    ) {
+    ) BlastNativeYield(_blast, _blastPoints, _blastPointsOperator, _governor) {
         WETH = _weth;
         USDB = _usdb;
 
-        IBlast(_blast).configure(IBlast__YieldMode.CLAIMABLE, IBlast__GasMode.CLAIMABLE, _governor);
-        IBlastPoints(_blastPoints).configurePointsOperator(_blastPointsOperator);
         IERC20Rebasing(_weth).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
         IERC20Rebasing(_usdb).configure(IERC20Rebasing__YieldMode.CLAIMABLE);
     }

contracts/BlastNativeYield.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IBlast, YieldMode as IBlast__YieldMode, GasMode as IBlast__GasMode} from "./interfaces/IBlast.sol";
+import {BlastPoints} from "./BlastPoints.sol";
+/**
+ * @title BlastNativeYield
+ * @notice This contract is a base contract for future contracts that wish to claim native yield and Blast points to inherit from
+ * @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(IBlast__YieldMode.CLAIMABLE, IBlast__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 contract for future contracts that wish to claim 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);
+    }
+}

test/foundry/BlastYield.t.sol → test/foundry/BlastERC20RebasingYield.t.sol

@@ -4,8 +4,7 @@ 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 {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";
@@ -15,27 +14,30 @@ import {MockBlastPoints} from "../mock/MockBlastPoints.sol";
 import {MockBlastWETH} from "../mock/MockBlastWETH.sol";
 import {MockBlastYield} from "../mock/MockBlastYield.sol";
 
-contract BlastYieldOwnableTwoSteps is BlastYield, OwnableTwoSteps {
+contract BlastERC20RebasingYieldOwnableTwoSteps is BlastERC20RebasingYield, OwnableTwoSteps {
     constructor(
         address _blast,
         address _blastPoints,
         address _blastPointsOperator,
         address _owner,
         address _usdb,
         address _weth
-    ) BlastYield(_blast, _blastPoints, _blastPointsOperator, _owner, _usdb, _weth) OwnableTwoSteps(_owner) {}
+    )
+        BlastERC20RebasingYield(_blast, _blastPoints, _blastPointsOperator, _owner, _usdb, _weth)
+        OwnableTwoSteps(_owner)
+    {}
 
     function claim(address wethReceiver, address usdbReceiver) public onlyOwner {
         _claim(wethReceiver, usdbReceiver);
     }
 }
 
-contract BlastYieldOwnableTwoSteps_Test is TestHelpers {
+contract BlastERC20RebasingYieldOwnableTwoStepsOwnableTwoSteps_Test is TestHelpers {
     MockBlastWETH private weth;
     MockBlastERC20 private usdb;
     MockBlastYield private mockBlastYield;
     MockBlastPoints private mockBlastPoints;
-    BlastYieldOwnableTwoSteps private blastYieldOwnableTwoSteps;
+    BlastERC20RebasingYieldOwnableTwoSteps private blastERC20RebasingYieldOwnableTwoSteps;
 
     address public owner = address(69);
     address public operator = address(420);
@@ -47,7 +49,7 @@ contract BlastYieldOwnableTwoSteps_Test is TestHelpers {
         usdb = new MockBlastERC20("USDB", "USDB");
         mockBlastYield = new MockBlastYield();
         mockBlastPoints = new MockBlastPoints();
-        blastYieldOwnableTwoSteps = new BlastYieldOwnableTwoSteps(
+        blastERC20RebasingYieldOwnableTwoSteps = new BlastERC20RebasingYieldOwnableTwoSteps(
             address(mockBlastYield),
             address(mockBlastPoints),
             operator,
@@ -58,34 +60,27 @@ contract BlastYieldOwnableTwoSteps_Test is TestHelpers {
     }
 
     function test_setUpState() public {
-        assertEq(blastYieldOwnableTwoSteps.WETH(), address(weth));
-        assertEq(blastYieldOwnableTwoSteps.USDB(), address(usdb));
+        assertEq(blastERC20RebasingYieldOwnableTwoSteps.WETH(), address(weth));
+        assertEq(blastERC20RebasingYieldOwnableTwoSteps.USDB(), address(usdb));
 
-        (IBlast__YieldMode yieldMode, IBlast__GasMode gasMode, address governor) = mockBlastYield.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));
+        IERC20Rebasing__YieldMode wethYieldMode = weth.yieldMode(address(blastERC20RebasingYieldOwnableTwoSteps));
         assertEq(uint8(wethYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
 
-        IERC20Rebasing__YieldMode usdbYieldMode = usdb.yieldMode(address(blastYieldOwnableTwoSteps));
+        IERC20Rebasing__YieldMode usdbYieldMode = usdb.yieldMode(address(blastERC20RebasingYieldOwnableTwoSteps));
         assertEq(uint8(usdbYieldMode), uint8(IERC20Rebasing__YieldMode.CLAIMABLE));
     }
 
     function test_claim() public asPrankedUser(owner) {
-        blastYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+        blastERC20RebasingYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
 
-        assertEq(weth.balanceOf(address(blastYieldOwnableTwoSteps)), 0);
-        assertEq(usdb.balanceOf(address(blastYieldOwnableTwoSteps)), 0);
+        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);
-        blastYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
+        blastERC20RebasingYieldOwnableTwoSteps.claim(TREASURY, TREASURY);
     }
 }

test/foundry/BlastNativeYield.t.sol

@@ -0,0 +1,51 @@
+// 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 as IBlast__YieldMode, GasMode as IBlast__GasMode} from "../../contracts/interfaces/IBlast.sol";
+
+import {MockBlastPoints} from "../mock/MockBlastPoints.sol";
+import {MockBlastYield} from "../mock/MockBlastYield.sol";
+
+contract BlastNativeYieldOwnableTwoSteps is BlastNativeYield, OwnableTwoSteps {
+    constructor(
+        address _blast,
+        address _blastPoints,
+        address _blastPointsOperator,
+        address _owner
+    ) BlastNativeYield(_blast, _blastPoints, _blastPointsOperator, _owner) OwnableTwoSteps(_owner) {}
+}
+
+contract BlastNativeYieldOwnableTwoSteps_Test is TestHelpers {
+    MockBlastYield private mockBlastYield;
+    MockBlastPoints private mockBlastPoints;
+    BlastNativeYieldOwnableTwoSteps private blastNativeYieldOwnableTwoSteps;
+
+    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();
+        blastNativeYieldOwnableTwoSteps = new BlastNativeYieldOwnableTwoSteps(
+            address(mockBlastYield),
+            address(mockBlastPoints),
+            operator,
+            owner
+        );
+    }
+
+    function test_setUpState() public {
+        (IBlast__YieldMode yieldMode, IBlast__GasMode gasMode, address governor) = mockBlastYield.config(
+            address(blastNativeYieldOwnableTwoSteps)
+        );
+        assertEq(uint8(yieldMode), uint8(IBlast__YieldMode.CLAIMABLE));
+        assertEq(uint8(gasMode), uint8(IBlast__GasMode.CLAIMABLE));
+        assertEq(governor, owner);
+    }
+}

test/foundry/BlastPoints.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {OwnableTwoSteps} from "../../contracts/OwnableTwoSteps.sol";
+import {BlastPoints} from "../../contracts/BlastPoints.sol";
+import {TestHelpers} from "./utils/TestHelpers.sol";
+
+import {MockBlastPoints} from "../mock/MockBlastPoints.sol";
+
+contract BlastPointsOwnableTwoSteps is BlastPoints, OwnableTwoSteps {
+    constructor(
+        address _blastPoints,
+        address _blastPointsOperator
+    ) BlastPoints(_blastPoints, _blastPointsOperator) OwnableTwoSteps(_blastPointsOperator) {}
+}
+
+contract BlastPointsOwnableTwoSteps_Test is TestHelpers {
+    MockBlastPoints private mockBlastPoints;
+    BlastPointsOwnableTwoSteps private blastPointsOwnableTwoSteps;
+
+    address public operator = address(420);
+    address private constant TREASURY = address(69420);
+
+    function setUp() public {
+        mockBlastPoints = new MockBlastPoints();
+        blastPointsOwnableTwoSteps = new BlastPointsOwnableTwoSteps(address(mockBlastPoints), operator);
+    }
+
+    function test_setUpState() public {
+        assertEq(mockBlastPoints.contractOperators(address(blastPointsOwnableTwoSteps)), operator);
+    }
+}

test/mock/MockBlastPoints.sol

@@ -2,5 +2,10 @@
 pragma solidity ^0.8.0;
 
 contract MockBlastPoints {
-    function configurePointsOperator(address operator) external {}
+    mapping(address _contract => address operator) public contractOperators;
+    event LogAddress(address);
+
+    function configurePointsOperator(address operator) external {
+        contractOperators[msg.sender] = operator;
+    }
 }