My own test

Author: jimmychu0807

packages/contracts/contracts/base/SemaphoreVerifier.sol

@@ -5,6 +5,7 @@ pragma solidity 0.8.23;
 
 import {MAX_DEPTH} from "./Constants.sol";
 import {SemaphoreVerifierKeyPts} from "./SemaphoreVerifierKeyPts.sol";
+import "hardhat/console.sol";
 
 contract SemaphoreVerifier {
     // Scalar field size
@@ -34,6 +35,87 @@ contract SemaphoreVerifier {
         SemaphoreVerifierKeyPts.checkInvariant(MAX_DEPTH);
     }
 
+    function test() external view returns(bytes32[3] memory) {
+        // --- 0x06 ecAdd ---
+        uint256[4] memory inputAdd = [
+            uint256(5090583730862410755830979584235210054631184460526892606022709842010236308675),
+            // invalid g1.x
+            // uint256(0),
+            uint256(4935746665478263580470501879719907639988899436008466660042851826337922233613),
+            uint256(5090583730862410755830979584235210054631184460526892606022709842010236308675),
+            uint256(4935746665478263580470501879719907639988899436008466660042851826337922233613)
+        ];
+        assembly {
+            // ref: https://www.evm.codes/precompiled on ecAdd
+            let success := staticcall(150, 0x06, inputAdd, 0x80, inputAdd, 0x40)
+
+            if iszero(success) {
+                mstore(0,0)
+                return(0, 0x60)
+            }
+        }
+
+        bytes32 addOut = abi.decode(abi.encode(inputAdd), (bytes32));
+        console.log("addOut: %i", uint256(addOut));
+
+        // --- 0x07 ecMul ---
+        uint256[3] memory inputMul = [
+            uint256(5090583730862410755830979584235210054631184460526892606022709842010236308675),
+            // invalid g1.x
+            // uint256(5090583730862410755830979584235210054631184460526892606022709842010236308674),
+            uint256(4935746665478263580470501879719907639988899436008466660042851826337922233613),
+            2
+            // infinity scalar
+            // 0
+        ];
+        assembly {
+            // ref: https://www.evm.codes/precompiled on ecMul
+            let success := staticcall(6000, 0x07, inputMul, 0x60, inputMul, 0x40)
+
+            if iszero(success) {
+                mstore(0,0)
+                return(0, 0x60)
+            }
+        }
+
+        bytes32 mulOut = abi.decode(abi.encode(inputMul), (bytes32));
+        console.log("mulOut: %i", uint256(mulOut));
+
+        // --- 0x08 ecPairing ---
+        // The input must always be a multiple of 6 32-byte values.
+        uint256[12] memory inputPairing = [
+            uint256(3010198690406615200373504922352659861758983907867017329644089018310584441462),
+            uint256(17861058253836152797273815394432013122766662423622084931972383889279925210507),
+            uint256(7273165102799931111715871471550377909735733521218303035754523677688038059653),
+            uint256(2725019753478801796453339367788033689375851816420509565303521482350756874229),
+            uint256(957874124722006818841961785324909313781880061366718538693995380805373202866),
+            uint256(2512659008974376214222774206987427162027254181373325676825515531566330959255),
+            uint256(4503322228978077916651710446042370109107355802721800704639343137502100212473),
+            uint256(6132642251294427119375180147349983541569387941788025780665104001559216576968),
+            uint256(14583779054894525174450323658765874724019480979794335525732096752006891875705),
+            uint256(18029695676650738226693292988307914797657423701064905010927197838374790804409),
+            uint256(11474861747383700316476719153975578001603231366361248090558603872215261634898),
+            uint256(2140229616977736810657479771656733941598412651537078903776637920509952744750)
+            // switched y2, y1 to be invalid
+            // uint256(2140229616977736810657479771656733941598412651537078903776637920509952744750),
+            // uint256(11474861747383700316476719153975578001603231366361248090558603872215261634898)
+        ];
+        assembly {
+            // ref: https://www.evm.codes/precompiled on ecPairing
+            // formula: 45000 + 34000 * (bytes/192)
+            let success := staticcall(113000, 0x08, inputPairing, 0x180, inputPairing, 0x20)
+
+            // Specified 0 gas cost to make it returning false
+            if iszero(success) {
+                mstore(inputPairing, 0)
+            }
+        }
+        bytes32 pairingOut = abi.decode(abi.encode(inputPairing), (bytes32));
+        console.log("pairingOut: %i", uint256(pairingOut));
+
+        return [addOut, mulOut, pairingOut];
+    }
+
     function verifyProof(
         uint[2] calldata _pA,
         uint[2][2] calldata _pB,

packages/contracts/test/SemaphoreVerifier.ts

@@ -0,0 +1,85 @@
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable jest/valid-expect */
+import { Group, Identity, SemaphoreProof, generateProof, proofHash } from "@semaphore-protocol/core"
+import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers"
+import { expect } from "chai"
+import { Signer, ZeroAddress } from "ethers"
+import { run } from "hardhat"
+// @ts-ignore
+import { Semaphore, SemaphoreVerifier } from "../typechain-types"
+
+describe("SemaphoreVerifier", () => {
+    async function deploySemaphoreFixture() {
+        const { semaphore, verifierAddress } = await run("deploy", {
+            logs: false
+        })
+
+        const semaphoreContract: Semaphore = semaphore
+        const semaphoreVerifierContract: SemaphoreVerifier = await ethers.getContractAt(
+            "SemaphoreVerifier", verifierAddress
+        ),
+
+        const accounts = await run("accounts", { logs: false })
+        const accountAddresses = await Promise.all(accounts.map((signer: Signer) => signer.getAddress()))
+
+        const groupId = 0
+
+        return {
+            semaphoreContract,
+            semaphoreVerifierContract,
+            accounts,
+            accountAddresses,
+            groupId
+        }
+    }
+
+    async function deployVerifyProofFixture() {
+        const {
+            semaphoreContract,
+            semaphoreVerifierContract,
+            accountAddresses,
+            groupId
+        } = await loadFixture(deploySemaphoreFixture)
+
+        const members = Array.from({ length: 3 }, (_, i) => new Identity(i.toString())).map(
+            ({ commitment }) => commitment
+        )
+
+        await semaphoreContract["createGroup(address)"](accountAddresses[0])
+        await semaphoreContract.addMembers(groupId, members)
+
+        const identity = new Identity("0")
+        const group = new Group()
+
+        group.addMembers(members)
+
+        const merkleTreeDepth = 12
+        const message = 2
+        const proof: SemaphoreProof = await generateProof(identity, group, message, group.root, merkleTreeDepth)
+
+        return {
+            semaphoreContract,
+            semaphoreVerifierContract,
+            accountAddresses,
+            groupId,
+            members,
+            proof
+        }
+    }
+
+    it("Should succeed", async () => {
+        const { semaphoreContract, semaphoreVerifierContract, proof } = await loadFixture(deployVerifyProofFixture)
+        // console.log("proof:", proof);
+        let result = await semaphoreVerifierContract.verifyProof(
+            [proof.points[0], proof.points[1]],
+            [[proof.points[2], proof.points[3]], [proof.points[4], proof.points[5]]],
+            [proof.points[6], proof.points[7]],
+            [proof.merkleTreeRoot, proof.nullifier, proofHash(proof.message), proofHash(proof.scope)],
+            proof.merkleTreeDepth
+        )
+        expect(result).to.be.true
+
+        result = await semaphoreVerifierContract.test();
+        console.log("result:", result);
+    })
+})

packages/proof/src/index.ts

@@ -1,6 +1,7 @@
 import { packGroth16Proof, unpackGroth16Proof } from "@zk-kit/utils/proof-packing"
+import hash from "./hash"
 import generateProof from "./generate-proof"
 import verifyProof from "./verify-proof"
 
 export * from "./types"
-export { generateProof, packGroth16Proof, unpackGroth16Proof, verifyProof }
+export { generateProof, packGroth16Proof, unpackGroth16Proof, verifyProof, hash as proofHash }