Merge pull request #74 from base-org/jack/coverage

Improve test coverage

Author: jackchuma

contracts/src/libraries/SSZ.sol

@@ -38,8 +38,6 @@ library SSZ {
                     // Call sha256 precompile
                     let result := staticcall(gas(), SHA256, 0x00, 0x40, 0x00, 0x20)
 
-                    if eq(result, 0) { revert(0, 0) }
-
                     // Reuse `leaf` to store the hash to reduce stack operations.
                     leaf := mload(0x00)
                     offset := add(offset, 0x20)

contracts/src/libraries/StateValidator.sol

@@ -177,7 +177,7 @@ library StateValidator {
     /// @param encodedAccount An RLP-encoded account object
     ///
     /// @return _ The account's storage root
-    function _extractStorageRoot(bytes memory encodedAccount) private pure returns (bytes32) {
+    function _extractStorageRoot(bytes memory encodedAccount) internal pure returns (bytes32) {
         RLPReader.RLPItem[] memory accountFields = encodedAccount.readList();
 
         if (accountFields.length != 4) {

contracts/test/ArbitrumProver.t.sol

@@ -21,6 +21,7 @@ contract ArbitrumProverTest is BaseTest {
     using Strings for address;
 
     MockArbitrumProver prover;
+    string unconfirmedState;
 
     address private constant _INBOX_CONTRACT = 0xdac62f96404AB882F5a61CFCaFb0C470a19FC514;
 
@@ -35,11 +36,13 @@ contract ArbitrumProverTest is BaseTest {
             string.concat(rootPath, "/test/data/invalids/ArbitrumInvalidBlockHeaders.json");
         string memory invalidL2StoragePath =
             string.concat(rootPath, "/test/data/invalids/ArbitrumInvalidL2Storage.json");
+        string memory unconfirmedStatePath = string.concat(rootPath, "/test/data/invalids/ArbitrumUnconfirmed.json");
 
         validProof = vm.readFile(path);
         invalidL1State = vm.readFile(invalidPath);
         invalidBlockHeaders = vm.readFile(invalidBlockHeadersPath);
         invalidL2Storage = vm.readFile(invalidL2StoragePath);
+        unconfirmedState = vm.readFile(unconfirmedStatePath);
     }
 
     function test_reverts_ifFinalityDelaySecondsStillInProgress() external fundAlice(_REWARD_AMOUNT) {
@@ -69,6 +72,19 @@ contract ArbitrumProverTest is BaseTest {
         prover.validateProof(inboxStorageKey, _INBOX_CONTRACT, attributes, abi.encode(proof));
     }
 
+    function test_reverts_ifUnconfirmed() external fundAlice(_REWARD_AMOUNT) {
+        (string memory sourceChain, string memory sender, Message[] memory calls, bytes[] memory attributes) =
+            _initMessage(_REWARD_AMOUNT);
+        bytes32 messageId = _getMessageId(sourceChain, sender, calls, attributes);
+
+        ArbitrumProver.RIP7755Proof memory proof = _buildProof(unconfirmedState);
+        bytes memory inboxStorageKey = _deriveStorageKey(messageId);
+
+        vm.prank(FILLER);
+        vm.expectRevert(ArbitrumProver.NodeNotConfirmed.selector);
+        prover.validateProof(inboxStorageKey, _INBOX_CONTRACT, attributes, abi.encode(proof));
+    }
+
     function test_reverts_ifInvalidRLPHeaders() external fundAlice(_REWARD_AMOUNT) {
         (string memory sourceChain, string memory sender, Message[] memory calls, bytes[] memory attributes) =
             _initMessage(_REWARD_AMOUNT);

contracts/test/RIP7755Inbox.t.sol

@@ -111,6 +111,21 @@ contract RIP7755InboxTest is BaseTest {
         assertEq(ALICE.balance, amount);
     }
 
+    function test_executeMessages_doesntSendsEth(uint256 amount) external {
+        TestMessage memory m = _initMessage(false, false);
+
+        bytes[] memory attributes = new bytes[](1);
+        attributes[0] = abi.encodeWithSelector(_FULFILLER_ATTRIBUTE_SELECTOR, FILLER);
+
+        _appendMessage(m, Message({receiver: ALICE.toChecksumHexString(), payload: "", attributes: attributes}));
+
+        vm.deal(FILLER, amount);
+        vm.prank(FILLER);
+        inbox.executeMessages(m.sourceChain, m.sender, m.messages, m.attributes);
+
+        assertEq(ALICE.balance, 0);
+    }
+
     function test_executeMessages_reverts_ifTargetContractReverts() external {
         TestMessage memory m = _initMessage(false, false);
 

contracts/test/SSZ.t.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+
+import {SSZ} from "../src/libraries/SSZ.sol";
+
+contract SSZTest is Test {
+    bytes32[] proof;
+    bytes32 root;
+    bytes32 leaf;
+    uint256 index;
+
+    function setUp() public {
+        proof.push(0xd526ab81e92ee5f1cc067756a28fabace998cbcdc4dfc15be4e7a1e20556dd77);
+        proof.push(0x91fef64270acd9eaa77515c225e1ff733405ad5c9ef6af09348a81d494d91153);
+        proof.push(0xc29d2435ffdaae8e956a6ff850f93785e9088fc361df4b65fc4e5eda3dc48e5e);
+        proof.push(0xdf1fe9c339af0ab637e1657df29f04f6013844ffa492e4f48679f688d298c96b);
+        proof.push(0xd2ccf2d7b4fd6e881e9ef3eb79d21b67bf9541ad211e0a10568eedbec0a4c91c);
+        proof.push(0x869e40e6d2a1efca3d0d6b9d199c1ee48a0b4a232e05431f30372bacc620dec1);
+        proof.push(0xf17a619ac2d0dcc48af70c205dea3aba52c412df929f133f886ffbb6f52105b3);
+        proof.push(0xdb56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71);
+        proof.push(0x476ccb90633a03e07abffc0d8b9136e7428b938e1d99990dd57c8254869a2915);
+        proof.push(0x0000000000000000000000000000000000000000000000000000000000000000);
+        proof.push(0xf5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b);
+        proof.push(0x0398b3a4f9a61cdc13bcc5265c6860c6d6a13ce06d03d46663c0c54cf8bb4d01);
+        root = 0xd19bacd555eff238f7c814e0eca799246746322f663c1811564ef07bc2b68dda;
+        leaf = 0x4576ea3c05186e1df84e1c71036bf90bfc192f36063f6efed2a9c6fabe8de9db;
+        index = 6434;
+    }
+
+    function test_verifyProof_returnsTrue() public view {
+        assertEq(SSZ.verifyProof(proof, root, leaf, index), true);
+    }
+
+    function test_verifyProof_reverts_invalidIndex() public {
+        vm.expectRevert(0x5849603f);
+        SSZ.verifyProof(proof, root, leaf, 1);
+    }
+
+    function test_verifyProof_reverts_missingItem() public {
+        vm.expectRevert(0x1b6661c3);
+        SSZ.verifyProof(new bytes32[](0), root, leaf, 2);
+    }
+}

contracts/test/StateValidator.t.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+
+import {StateValidator} from "../src/libraries/StateValidator.sol";
+import {MockStateValidator} from "./mocks/MockStateValidator.sol";
+
+contract StateValidatorTest is Test {
+    MockStateValidator mockStateValidator;
+
+    function setUp() public {
+        mockStateValidator = new MockStateValidator();
+    }
+
+    function test_validateState_reverts_oracleCallFails() external {
+        deployCodeTo("MockStateValidator.sol", abi.encode(), 0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02);
+        vm.expectRevert(abi.encodeWithSelector(StateValidator.BeaconRootsOracleCallFailed.selector, abi.encode(1)));
+        mockStateValidator.validateState(
+            address(0),
+            StateValidator.StateProofParameters({
+                beaconRoot: bytes32(uint256(1)),
+                beaconOracleTimestamp: 1,
+                executionStateRoot: bytes32(uint256(1)),
+                stateRootProof: new bytes32[](0)
+            }),
+            StateValidator.AccountProofParameters({
+                storageKey: abi.encode(uint256(1)),
+                storageValue: abi.encode(uint256(1)),
+                accountProof: new bytes[](0),
+                storageProof: new bytes[](0)
+            })
+        );
+    }
+
+    function test_validateAccountStorage_reverts_ifInvalidAccountStructure() external {
+        bytes memory encodedAccount =
+            hex"f90224a0645c2c097705aef7a67aab8e7bebe9ccdef7277e1c4287e052d264444ed6118da01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794a4b000000000000000000073657175656e636572a04fce9af672aa9a624f43fcdecb7dc2f137220cf9e8a40f9555ac7df54bd82a42a0beec0b13d083ebbe53fe2ba98509acc5aa127e494e8b05dd1de851bcd675a5cea0b745fc54204ae8f5f8c600191da48237f2502c941dc4e8ec057d690651f96f8cb901000000002000000000000000020000a001400000000000000000800000000000000000280000000000000000000000000000000000000000000000000000200000000100000000000000080409000000008001000000000010000000800000010000000000020000000000000000000800008000000000004000000810000000400000000001000080000000000000280000040000000000001800000000200000020400400000800000000000000200000202000000000000000000000000000000008002000000200000000000000000000000000000000000000000000020000010000000240000000000000000004400100000480000000000020000100000018406fc59ae870400000000000083155208846792b144a00bf10cf6053bf44b0bf8e379d29072165857d5326142f5f2c7692d9bfbd1797fa0000000000000eedb0000000000734da000000000000000200000000000000000880000000000142f058405f5e100";
+        vm.expectRevert(StateValidator.InvalidAccountRLP.selector);
+        mockStateValidator.extractStorageRoot(encodedAccount);
+    }
+}