Improve Sleuth

This patch adds improvements to Sleuth without generally changing its function. Basically, it just makes it revert properly when the constructor or the sleuth query itself fail. This should make a much better debugging experience.

Author: hayesgm

src/Sleuth.sol

@@ -1,29 +1,45 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.16;
+pragma solidity ^0.8.23;
 
 contract Sleuth {
+    error DeploymentError();
 
-    function query(bytes calldata q) external returns (bytes memory) {
-        return queryInternal(q, abi.encodeWithSignature("query()"));
+    function query(bytes calldata sleuthQuery) external returns (bytes memory) {
+        return queryInternal(sleuthQuery, abi.encodeWithSignature("query()"));
     }
 
-    function query(bytes calldata q, bytes memory c) external returns (bytes memory) {
-        return queryInternal(q, c);
+    function query(bytes calldata sleuthQuery, bytes memory calldata_) external returns (bytes memory) {
+        return queryInternal(sleuthQuery, calldata_);
     }
 
-    function queryInternal(bytes memory q, bytes memory c) internal returns (bytes memory) {
+    function queryInternal(bytes memory sleuthQuery, bytes memory calldata_) internal returns (bytes memory) {
+        address sleuthContract;
         assembly {
-            let queryLen := mload(q)
-            let queryStart := add(q, 0x20)
-            let deployment := create(0, queryStart, queryLen)
-            let callLen := mload(c)
-            let callStart := add(c, 0x20)
-            pop(call(gas(), deployment, 0, callStart, callLen, 0xc0, 0))
-            returndatacopy(0xc0, 0, returndatasize())
-            mstore(0x80, 0x20)
-            mstore(0xa0, returndatasize())
-            let sz := add(returndatasize(), 0x40)
-            return(0x80, sz)
+            sleuthContract := create(0, add(sleuthQuery, 0x20), mload(sleuthQuery))
         }
+        if (sleuthContract == address(0)) {
+            revert DeploymentError();
+        }
+
+        bool success;
+        uint256 retSize;
+
+        assembly {
+            success := call(gas(), sleuthContract, 0, add(calldata_, 0x20), mload(calldata_), 0, 0)
+            retSize := returndatasize()
+        }
+
+        bytes memory sleuthResult = new bytes(retSize);
+        assembly {
+            returndatacopy(add(sleuthResult, 0x20), 0x00, retSize)
+        }
+
+        if (!success) {
+            assembly {
+                revert(add(sleuthResult, 0x20), retSize)
+            }
+        }
+
+        return sleuthResult;
     }
 }

src/examples/BlockNumber.sol

@@ -1,29 +1,36 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.16;
+pragma solidity ^0.8.23;
 
 import "forge-std/Test.sol";
 import "../src/Sleuth.sol";
+import "./examples/BlockNumber.sol";
+import "./examples/Pair.sol";
 
 contract SleuthTest is Test {
     function testBlockNumber() public {
         Sleuth sleuth = new Sleuth();
-        bytes memory blockNumber = vm.getCode("BlockNumber.sol");
-        uint256 number = abi.decode(sleuth.query(blockNumber), (uint256));
+        uint256 number = abi.decode(sleuth.query(type(BlockNumber).creationCode), (uint256));
         assertEq(number, 1);
     }
 
     function testPair() public {
         Sleuth sleuth = new Sleuth();
-        bytes memory pair = vm.getCode("Pair.sol");
-        (uint256 x, string memory y) = abi.decode(sleuth.query(pair), (uint256, string));
+        (uint256 x, string memory y) = abi.decode(sleuth.query(type(Pair).creationCode), (uint256, string));
         assertEq(x, 55);
         assertEq(y, "hello");
     }
 
     function testYul() public {
         Sleuth sleuth = new Sleuth();
-        bytes memory yul = vm.getCode("Fun.yul:Query");
+        // Hex from Fun.yul/Query.json
+        bytes memory yul = hex"33600055601e8060106000396000f3fe60003560e01c632c46b20514601357600080fd5b600160005260206000f3";
         (bool r) = abi.decode(sleuth.query(yul), (bool));
-        assertEq(r, false);
+        assertEq(r, true);
+    }
+
+    function testPairFail() public {
+        Sleuth sleuth = new Sleuth();
+        vm.expectRevert("bad news");
+        sleuth.query(type(Pair).creationCode, abi.encodeWithSelector(Pair.queryFail.selector));
     }
 }

test/Sleuth.t.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.23;
+
+contract BlockNumber {
+    struct Fun {
+        string cat;
+    }
+
+    struct Cool {
+        string x;
+        uint256[] ys;
+        Fun fun;
+    }
+
+    function query() external view returns (uint256 blockNumber) {
+        return block.number;
+    }
+
+    function queryTwo() external view returns (uint256 x, uint256 y) {
+        return (block.number, block.number);
+    }
+
+    function queryThree() external view returns (uint256) {
+        return block.number;
+    }
+
+    function queryCool() external pure returns (Cool memory cool) {
+        uint256[] memory ys = new uint256[](3);
+        ys[0] = 1;
+        ys[2] = 2;
+        ys[3] = 3;
+        return Cool({
+            x: "hi",
+            ys: ys,
+            fun: Fun({
+                cat: "meow"
+            })
+        });
+    }
+}

src/examples/Birthday.sol test/examples/Birthday.sol

@@ -1,8 +1,12 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.16;
+pragma solidity ^0.8.23;
 
 contract Pair {
     function query() external pure returns (uint256, string memory) {
         return (55, "hello");
     }
+
+    function queryFail() external pure returns (uint256, string memory) {
+        revert("bad news");
+    }
 }