chore: address comments

Author: HrikB

src/Halo2Verifier.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.19;
 
-contract AxiomV2QueryVerifier {
+contract Halo2Verifier {
     fallback(bytes calldata) external returns (bytes memory) {
         // assembly ("memory-safe") {
         //     // Enforce that Solidity memory layout is respected

src/OpenVmHalo2Verifier.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity 0.8.19;
 
-import { AxiomV2QueryVerifier } from "./Halo2Verifier.sol";
+import { Halo2Verifier } from "./Halo2Verifier.sol";
 
 type MemoryPointer is uint256;
 
 /// @notice This contract provides a thin wrapper around the Halo2 verifier
 /// outputted by `snark-verifier`, exposing a more user-friendly interface.
-contract OpenVmHalo2Verifier is AxiomV2QueryVerifier {
+contract OpenVmHalo2Verifier is Halo2Verifier {
     /// @dev Invalid partial proof length
     error InvalidPartialProofLength();
 
@@ -26,6 +26,12 @@ contract OpenVmHalo2Verifier is AxiomV2QueryVerifier {
     /// @dev The length of the full proof, in bytes
     uint256 private constant FULL_PROOF_LENGTH = (12 + 2 + GUEST_PVS_LENGTH + 43) * 32;
 
+    /// @dev The leaf verifier commitment. This value is set by OpenVM.
+    bytes32 public constant LEAF_EXE_COMMIT =
+        bytes32(0x0000000000000000000000000000000000000000000000000000000000000000);
+
+    string public constant OPENVM_VERSION = "v1.0.0";
+
     /// @notice A wrapper that constructs the proof into the right format for
     /// use with the `snark-verifier` verification.
     ///
@@ -53,19 +59,18 @@ contract OpenVmHalo2Verifier is AxiomV2QueryVerifier {
     /// @param guestPvs The PVs revealed by the OpenVM guest program.
     /// @param appExeCommit The commitment to the RISC-V executable whose execution
     /// is being verified.
-    /// @param leafExeCommit The commitment to the leaf verifier.
-    function verifyProof(
-        bytes calldata guestPvs,
-        bytes calldata partialProof,
-        bytes32 appExeCommit,
-        bytes32 leafExeCommit
-    ) external view {
+    function verify(bytes calldata guestPvs, bytes calldata partialProof, bytes32 appExeCommit) external view {
+        if (guestPvs.length != GUEST_PVS_LENGTH) revert InvalidGuestPvsLength();
+        if (partialProof.length != PARTIAL_PROOF_LENGTH) revert InvalidPartialProofLength();
+
         // We will format the public values and construct the full proof payload
         // below.
 
-        MemoryPointer proofPtr = _constructProof(guestPvs, partialProof, appExeCommit, leafExeCommit);
+        MemoryPointer proofPtr = _constructProof(guestPvs, partialProof, appExeCommit);
 
         uint256 fullProofLength = FULL_PROOF_LENGTH;
+
+        /// @solidity memory-safe-assembly
         assembly {
             // Self-call using the proof as calldata
             if iszero(staticcall(gas(), address(), proofPtr, fullProofLength, 0, 0)) {
@@ -75,15 +80,11 @@ contract OpenVmHalo2Verifier is AxiomV2QueryVerifier {
         }
     }
 
-    function _constructProof(
-        bytes calldata guestPvs,
-        bytes calldata partialProof,
-        bytes32 appExeCommit,
-        bytes32 leafExeCommit
-    ) internal pure returns (MemoryPointer proofPtr) {
-        if (guestPvs.length != GUEST_PVS_LENGTH) revert InvalidGuestPvsLength();
-        if (partialProof.length != PARTIAL_PROOF_LENGTH) revert InvalidPartialProofLength();
-
+    function _constructProof(bytes calldata guestPvs, bytes calldata partialProof, bytes32 appExeCommit)
+        internal
+        pure
+        returns (MemoryPointer proofPtr)
+    {
         // The assembly code should perform the same function as the following
         // solidity code:
         //
@@ -96,6 +97,7 @@ contract OpenVmHalo2Verifier is AxiomV2QueryVerifier {
         // `guestPvs` separated into its own word.
 
         uint256 fullProofLength = FULL_PROOF_LENGTH;
+        bytes32 leafExeCommit = LEAF_EXE_COMMIT;
 
         /// @solidity memory-safe-assembly
         assembly {

test/OpenVmHalo2Verifier.t.sol

@@ -7,8 +7,7 @@ import { Test, console2, safeconsole as console } from "forge-std/Test.sol";
 contract OpenVmHalo2VerifierTest is Test, OpenVmHalo2Verifier {
     bytes partialProof;
     bytes32 appExeCommit = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-    bytes32 leafExeCommit = 0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE;
-    bytes32 guestPvsHash = 0xDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;
+    bytes32 guestPvsHash = 0xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE;
 
     uint256 private constant FULL_PROOF_WORDS = (12 + 2 + 32 + 43);
 
@@ -24,22 +23,16 @@ contract OpenVmHalo2VerifierTest is Test, OpenVmHalo2Verifier {
     }
 
     function test_verifyProof() public view {
-        this.verifyProof(abi.encodePacked(guestPvsHash), partialProof, appExeCommit, leafExeCommit);
+        this.verify(abi.encodePacked(guestPvsHash), partialProof, appExeCommit);
     }
 
     function test_proofFormat() public view {
-        this.constructAndCheckProof(abi.encodePacked(guestPvsHash), partialProof, appExeCommit, leafExeCommit);
+        this.constructAndCheckProof(abi.encodePacked(guestPvsHash), partialProof, appExeCommit);
     }
 
-    function testFuzz_proofFormat(
-        uint256 partialProofSeed,
-        bytes32 _guestPvsHash,
-        bytes32 _appExeCommit,
-        bytes32 _leafExeCommit
-    ) public {
+    function testFuzz_proofFormat(uint256 partialProofSeed, bytes32 _guestPvsHash, bytes32 _appExeCommit) public {
         vm.assume(_guestPvsHash != bytes32(0));
         vm.assume(_appExeCommit != bytes32(0));
-        vm.assume(_leafExeCommit != bytes32(0));
 
         bytes memory _partialProof = new bytes(55 * 32);
         for (uint256 i = 0; i < 55 * 32; ++i) {
@@ -50,18 +43,15 @@ contract OpenVmHalo2VerifierTest is Test, OpenVmHalo2Verifier {
         partialProof = _partialProof;
         guestPvsHash = _guestPvsHash;
         appExeCommit = _appExeCommit;
-        leafExeCommit = _leafExeCommit;
 
         test_proofFormat();
     }
 
-    function constructAndCheckProof(
-        bytes calldata _guestPvs,
-        bytes calldata _partialProof,
-        bytes32 _appExeCommit,
-        bytes32 _leafExeCommit
-    ) external view {
-        MemoryPointer proofPtr = _constructProof(_guestPvs, _partialProof, _appExeCommit, _leafExeCommit);
+    function constructAndCheckProof(bytes calldata _guestPvs, bytes calldata _partialProof, bytes32 _appExeCommit)
+        external
+        view
+    {
+        MemoryPointer proofPtr = _constructProof(_guestPvs, _partialProof, _appExeCommit);
 
         // _constructProof will return a pointer to memory that will hold the
         // proof data in a block of size FULL_PROOF_LENGTH. However, this won't
@@ -112,7 +102,7 @@ contract OpenVmHalo2VerifierTest is Test, OpenVmHalo2Verifier {
         bytes memory _leafExeCommit = proof[0x1a0:0x1c0];
 
         require(bytes32(_appExeCommit) == appExeCommit, "App exe commit mismatch");
-        require(bytes32(_leafExeCommit) == leafExeCommit, "Leaf exe commit mismatch");
+        require(bytes32(_leafExeCommit) == LEAF_EXE_COMMIT, "Leaf exe commit mismatch");
 
         bytes32 guestPvsHashExpected = guestPvsHash;
         bytes calldata _guestPvsHash = proof[0x1c0:0x5c0];
@@ -125,11 +115,11 @@ contract OpenVmHalo2VerifierTest is Test, OpenVmHalo2Verifier {
 
     function test_RevertWhen_InvalidPartialProofLength() public {
         vm.expectRevert(abi.encodeWithSelector(OpenVmHalo2Verifier.InvalidPartialProofLength.selector));
-        this.verifyProof(abi.encodePacked(guestPvsHash), hex"aa", appExeCommit, leafExeCommit);
+        this.verify(abi.encodePacked(guestPvsHash), hex"aa", appExeCommit);
     }
 
     function test_RevertWhen_InvalidGuestPvsLength() public {
         vm.expectRevert(abi.encodeWithSelector(OpenVmHalo2Verifier.InvalidGuestPvsLength.selector));
-        this.verifyProof(partialProof, hex"aa", appExeCommit, leafExeCommit);
+        this.verify(partialProof, hex"aa", appExeCommit);
     }
 }