contracts: make GovReward burn gas as required

Author: txhsl

contracts/solidity/GovReward.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.25;
 
 import {Errors} from "./libraries/Errors.sol";
+import {Bytes} from "./libraries/Bytes.sol";
 import {IGovReward} from "./interfaces/IGovReward.sol";
 import {IGovernance} from "./interfaces/IGovernance.sol";
 import {ERC1967Utils, GovProxyUpgradeable} from "./base/GovProxyUpgradeable.sol";
@@ -17,6 +18,17 @@ contract GovReward is IGovReward, GovProxyUpgradeable {
         if (msg.sig != bytes4(0xffffffff)) {
             revert Errors.InvalidSelector();
         }
+        // burn required gas amount internally
+        uint32 requiredSpace = Bytes.decodeUint32(msg.data[8:12]);
+        if (requiredSpace < 21000) {
+            revert Errors.InvalidGasLimit();
+        }
+        (bool success, bytes memory data) = address(this).staticcall{
+            gas: requiredSpace - 21000
+        }(abi.encodeWithSelector(this._wasteGas.selector));
+        if (success || data.length > 0) {
+            revert Errors.UnexpectedGasBurn();
+        }
     }
 
     modifier onlyGov() {
@@ -58,4 +70,8 @@ contract GovReward is IGovReward, GovProxyUpgradeable {
         (bool success, ) = to.call{value: value}(new bytes(0));
         if (!success) revert Errors.TransferFailed();
     }
+
+    function _wasteGas() external pure {
+        while (true) {}
+    }
 }

contracts/solidity/libraries/Bytes.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.25;
+
+library Bytes {
+    function toBytes4(
+        bytes memory data
+    ) internal pure returns (bytes4) {
+        bytes4 out;
+        for (uint256 i = 0; i < 4; i++) {
+            out |= bytes4(data[i] & 0xFF) >> (i * 8);
+        }
+        return out;
+    }
+
+    function decodeUint32(bytes memory data) internal pure returns (uint32) {
+        require(data.length == 4, "Bad data");
+        return uint32(toBytes4(data));
+    }
+}

contracts/solidity/libraries/Errors.sol

@@ -13,6 +13,8 @@ library Errors {
 
     // GovReward Errors
     error InvalidSelector();
+    error InvalidGasLimit();
+    error UnexpectedGasBurn();
 
     // Policy Errors
     error BlacklistExists();

contracts/solidity/test/MockFallback.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract MockFallback {
+    function call_fallback(address addr, bytes calldata data) public payable {
+        bool success;
+        assembly {
+            calldatacopy(0, data.offset, calldatasize())
+            success := call(
+                gas(),
+                addr,
+                0,
+                0,
+                calldatasize(),
+                0,
+                returndatasize()
+            )
+            switch success
+            case 0 {
+                invalid()
+            }
+        }
+    }
+}

contracts/test/GovReward.ts

@@ -0,0 +1,54 @@
+import { ethers } from "hardhat";
+import { expect } from "chai";
+
+const REWARD_PROXY = "0x1212000000000000000000000000000000000003";
+const REWARD_IMP = "0x1212100000000000000000000000000000000003";
+
+describe("GovReward", function () {
+    let Reward: any;
+    let signers: any;
+
+    beforeEach(async function () {
+        // Signers
+        signers = await ethers.getSigners();
+
+        // Reset blockchain state
+        await ethers.provider.send("hardhat_reset")
+
+        // Deploy contract
+        const reward_deploy = await ethers.deployContract("GovReward");
+
+        // Copy Bytecode to native address
+        const reward_code = await ethers.provider.send("eth_getCode", [reward_deploy.target]);
+        await ethers.provider.send("hardhat_setCode", [REWARD_PROXY, reward_code]);
+
+        const contract = require("../artifacts/solidity/GovReward.sol/GovReward.json");
+        Reward = new ethers.Contract(REWARD_PROXY, contract.abi, signers[0]);
+    });
+
+    describe("envelope call", function () {
+        let Mock: any;
+
+        beforeEach(async function () {
+            Mock = await ethers.deployContract("MockFallback");
+        });
+
+        it("Should revert if the selector is not 0xffffffff", async function () {
+            await expect(
+                Mock.call_fallback(REWARD_PROXY, "0xfffffffe")
+            ).to.be.reverted;
+        });
+
+        it("Should revert if the declared gaslimit is lower than 21000", async function () {
+            await expect(
+                Mock.call_fallback(REWARD_PROXY, "0xffffffff")
+            ).to.be.reverted;
+        });
+
+        it("Should consume gas as expected", async function () {
+            await expect(
+                Mock.call_fallback(REWARD_PROXY, "0xffffffff0000000000005208")
+            ).not.to.be.reverted;
+        });
+    });
+});