feat: increase coverage, add more merkle tests with fixed large tree

Author: QEDK

foundry.toml

@@ -10,4 +10,7 @@ via_ir = true
 runs = 10000
 max_test_rejects = 999999
 
+[rpc_endpoints]
+sepolia = "https://rpc.ankr.com/eth_sepolia"
+
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

slither.config.json

@@ -1,4 +1,4 @@
 {
     "detectors_to_exclude": "solc-version",
-    "filter_paths": "(lib/)"
+    "filter_paths": "(lib/|test/|script/|src/mocks/)"
 }

test/AvailBridgeTest.t.sol

@@ -40,6 +40,27 @@ contract AvailBridgeTest is Test, MurkyBase {
         assertEq(address(bridge.vectorx()), address(newVectorx));
     }
 
+    function testRevertArrayLengthMismatch_updateTokens(uint8 len1, uint8 len2) external {
+        // using len > uint8 slows tests by a *lot*
+        vm.assume(len1 != len2);
+        bytes32[] memory assetIds = new bytes32[](len1);
+        address[] memory addresses = new address[](len2);
+        vm.prank(owner);
+        vm.expectRevert(AvailBridge.ArrayLengthMismatch.selector);
+        bridge.updateTokens(assetIds, addresses);
+    }
+
+    function testRevertInvalidMessage_receiveMessage(bytes1 prefix) external {
+        vm.assume(prefix != 0x01);
+        AvailBridge.Message memory message =
+            AvailBridge.Message(prefix, bytes32(0), bytes32(0), 1, 2, "", 0);
+        AvailBridge.MerkleProofInput memory input = AvailBridge.MerkleProofInput(
+            new bytes32[](0), new bytes32[](0), bytes32(0), 0, bytes32(0), bytes32(0), bytes32(0), 0
+        );
+        vm.expectRevert(AvailBridge.InvalidMessage.selector);
+        bridge.receiveMessage(message, input);
+    }
+
     function test_receiveMessage(bytes32 rangeHash, bytes calldata data, bytes32 from, uint64 messageId) external {
         MessageReceiverMock messageReceiver = new MessageReceiverMock();
         messageReceiver.initialize(address(bridge));
@@ -59,6 +80,17 @@ contract AvailBridgeTest is Test, MurkyBase {
         bridge.receiveMessage(message, input);
     }
 
+    function testRevertInvalidAssetId_receiveAvail(bytes32 assetId) external {
+        vm.assume(assetId != 0x0);
+        AvailBridge.Message memory message =
+            AvailBridge.Message(0x02, bytes32(0), bytes32(0), 1, 2, abi.encode(assetId, 0), 0);
+        AvailBridge.MerkleProofInput memory input = AvailBridge.MerkleProofInput(
+            new bytes32[](0), new bytes32[](0), bytes32(0), 0, bytes32(0), bytes32(0), bytes32(0), 0
+        );
+        vm.expectRevert(AvailBridge.InvalidAssetId.selector);
+        bridge.receiveAVL(message, input);
+    }
+
     function test_receiveAVL(bytes32 rangeHash, bytes32 from, uint256 amount, uint64 messageId) external {
         vm.assume(amount != 0);
         address to = makeAddr("to");

test/MerkleTest.t.sol

@@ -13,12 +13,12 @@ contract MerkleTest is Test, MurkyBase {
     }
 
     /// @notice Hashing function for Murky
-    function hashLeafPairs(bytes32 left, bytes32 right) public pure override returns (bytes32 _hash) {
-        _hash = keccak256(abi.encode(left, right));
+    function hashLeafPairs(bytes32 left, bytes32 right) public pure override returns (bytes32) {
+        return keccak256(abi.encode(left, right));
     }
 
-    function testCheckMembershipSingleLeaf(bytes32 leaf, uint256 index) external {
-        vm.assume(index != 0);
+    function test_checkMembershipSingleLeaf(bytes32 leaf, bytes32 wrongRoot, uint256 index) external {
+        vm.assume(index != 0 && wrongRoot != leaf);
         bytes32 randomDataHash = keccak256(abi.encode(leaf));
         bytes32[] memory proof = new bytes32[](0);
 
@@ -32,9 +32,11 @@ contract MerkleTest is Test, MurkyBase {
         assertFalse(merkleUser.checkMembership(leaf, index, leaf, proof));
         // check with wrong leaf and wrong index
         assertFalse(merkleUser.checkMembership(randomDataHash, index, leaf, proof));
+        // check with wrong index, wrong leaf and wrong root
+        assertFalse(merkleUser.checkMembership(randomDataHash, index, wrongRoot, proof));
     }
 
-    function testCheckMembership(bytes32[] memory leaves, uint256 index, uint256 wrongIndex, bytes32 wrongRoot)
+    function test_checkMembership(bytes32[] memory leaves, uint256 index, uint256 wrongIndex, bytes32 wrongRoot)
         external
     {
         vm.assume(leaves.length > 1 && index < leaves.length && wrongIndex != index);
@@ -58,10 +60,41 @@ contract MerkleTest is Test, MurkyBase {
         assertFalse(merkleUser.checkMembership(randomDataHash, wrongIndex, wrongRoot, proof));
     }
 
-    function testCheckMembershipLargeTree(bytes32[] memory leaves, uint256 index, uint256 wrongIndex, bytes32 wrongRoot)
+    function test_checkMembershipLargeTree(bytes32[] memory leaves, uint256 index, uint256 wrongIndex, bytes32 wrongRoot)
         external
     {
-        vm.assume(leaves.length > 1 && index < leaves.length && wrongIndex != index);
+        vm.assume(leaves.length >= 128 && index < leaves.length && wrongIndex != index);
+        bytes32 root = getRoot(leaves);
+        vm.assume(wrongRoot != root);
+        bytes32[] memory proof = getProof(leaves, index);
+        bytes32 leaf = leaves[index];
+        bytes32 randomDataHash = keccak256(abi.encode(leaf));
+
+        // should return true for leaf and false for random hash
+        assertTrue(merkleUser.checkMembership(leaf, index, root, proof));
+        // check with wrong leaf
+        assertFalse(merkleUser.checkMembership(randomDataHash, index, root, proof));
+        // check with fixed wrong index
+        assertFalse(merkleUser.checkMembership(leaf, leaves.length, root, proof));
+        // check with wrong index
+        assertFalse(merkleUser.checkMembership(leaf, wrongIndex, root, proof));
+        // check with wrong index and wrong leaf
+        assertFalse(merkleUser.checkMembership(randomDataHash, wrongIndex, root, proof));
+        // check with wrong index, wrong leaf and wrong root
+        assertFalse(merkleUser.checkMembership(randomDataHash, wrongIndex, wrongRoot, proof));
+    }
+
+    function test_checkMembershipLargeTree2(bytes32[256] memory c_leaves, uint256 index, uint256 wrongIndex, bytes32 wrongRoot)
+        external
+    {
+        vm.assume(index < c_leaves.length && wrongIndex != index);
+        bytes32[] memory leaves = new bytes32[](c_leaves.length);
+        for (uint256 i = 0; i < c_leaves.length; ) {
+            leaves[i] = c_leaves[i];
+            unchecked {
+                ++i;
+            }
+        }
         bytes32 root = getRoot(leaves);
         vm.assume(wrongRoot != root);
         bytes32[] memory proof = getProof(leaves, index);
@@ -93,7 +126,6 @@ contract MerkleUser {
         pure
         returns (bool)
     {
-        bool r = Merkle.verify(proof, rootHash, index, leaf);
-        return r;
+        return Merkle.verify(proof, rootHash, index, leaf);
     }
 }