@semaphore-protocol/cli-template-contracts-hardhat 3.6.0-1

package/.env.example

@@ -0,0 +1,4 @@
+INFURA_API_KEY=
+ETHEREUM_PRIVATE_KEY=
+REPORT_GAS=false
+COINMARKETCAP_API_KEY=

package/README.md

@@ -0,0 +1,54 @@
+# Semaphore Hardhat template
+
+This project demonstrates a basic Semaphore use case. It comes with a sample contract, a test for that contract and a sample task that deploys that contract.
+
+## Usage
+
+### Compile
+
+```bash
+yarn compile
+```
+
+### Testing
+
+```bash
+yarn test
+```
+
+You can also generate a test coverage report:
+
+```bash
+yarn test:coverage
+```
+
+Or a test gas report:
+
+```bash
+yarn test:report-gas
+```
+
+### Deploy
+
+1. Copy the `.env.example` file as `.env`.
+
+```bash
+cp .env.example .env
+```
+
+2. Add your environment variables.
+
+> **Note**  
+> You should at least set a valid Ethereum URL (e.g. Infura) and a private key with some ethers.
+
+3. And deploy your contract.
+
+```bash
+yarn deploy --semaphore <semaphore-address> --group <group-id> --network goerli
+```
+
+> **Note**  
+> Check the Semaphore contract addresses [here](https://semaphore.appliedzkp.org/docs/deployed-contracts#semaphore).
+
+> **Warning**  
+> The group id is a number!

package/contracts/Feedback.sol

@@ -0,0 +1,30 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+import "@semaphore-protocol/contracts/interfaces/ISemaphore.sol";
+
+contract Feedback {
+    ISemaphore public semaphore;
+
+    uint256 public groupId;
+
+    constructor(address semaphoreAddress, uint256 _groupId) {
+        semaphore = ISemaphore(semaphoreAddress);
+        groupId = _groupId;
+
+        semaphore.createGroup(groupId, 20, address(this));
+    }
+
+    function joinGroup(uint256 identityCommitment) external {
+        semaphore.addMember(groupId, identityCommitment);
+    }
+
+    function sendFeedback(
+        uint256 feedback,
+        uint256 merkleTreeRoot,
+        uint256 nullifierHash,
+        uint256[8] calldata proof
+    ) external {
+        semaphore.verifyProof(groupId, merkleTreeRoot, feedback, nullifierHash, groupId, proof);
+    }
+}

package/hardhat.config.ts

@@ -0,0 +1,77 @@
+import "@nomiclabs/hardhat-ethers"
+import "@nomicfoundation/hardhat-chai-matchers"
+import "@semaphore-protocol/hardhat"
+import "@typechain/hardhat"
+import { config as dotenvConfig } from "dotenv"
+import "hardhat-gas-reporter"
+import { HardhatUserConfig } from "hardhat/config"
+import { NetworksUserConfig } from "hardhat/types"
+import "solidity-coverage"
+import { config } from "./package.json"
+import "./tasks/deploy"
+
+dotenvConfig()
+
+function getNetworks(): NetworksUserConfig {
+    if (!process.env.INFURA_API_KEY || !process.env.ETHEREUM_PRIVATE_KEY) {
+        return {}
+    }
+
+    const accounts = [`0x${process.env.ETHEREUM_PRIVATE_KEY}`]
+    const infuraApiKey = process.env.INFURA_API_KEY
+
+    return {
+        goerli: {
+            url: `https://goerli.infura.io/v3/${infuraApiKey}`,
+            chainId: 5,
+            accounts
+        },
+        sepolia: {
+            url: `https://sepolia.infura.io/v3/${infuraApiKey}`,
+            chainId: 11155111,
+            accounts
+        },
+        mumbai: {
+            url: `https://polygon-mumbai.infura.io/v3/${infuraApiKey}`,
+            chainId: 80001,
+            accounts
+        },
+        "optimism-goerli": {
+            url: `https://optimism-goerli.infura.io/v3/${infuraApiKey}`,
+            chainId: 420,
+            accounts
+        },
+        arbitrum: {
+            url: `https://arbitrum-mainnet.infura.io/v3/${infuraApiKey}`,
+            chainId: 42161,
+            accounts
+        }
+    }
+}
+
+const hardhatConfig: HardhatUserConfig = {
+    solidity: config.solidity,
+    paths: {
+        sources: config.paths.contracts,
+        tests: config.paths.tests,
+        cache: config.paths.cache,
+        artifacts: config.paths.build.contracts
+    },
+    networks: {
+        hardhat: {
+            chainId: 1337
+        },
+        ...getNetworks()
+    },
+    gasReporter: {
+        currency: "USD",
+        enabled: process.env.REPORT_GAS === "true",
+        coinmarketcap: process.env.COINMARKETCAP_API_KEY
+    },
+    typechain: {
+        outDir: config.paths.build.typechain,
+        target: "ethers-v5"
+    }
+}
+
+export default hardhatConfig

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@semaphore-protocol/cli-template-contracts-hardhat",
+  "version": "3.6.0-1",
+  "description": "Semaphore Hardhat template.",
+  "license": "Unlicense",
+  "files": [
+    ".gitignore",
+    ".env.example",
+    "contracts/",
+    "scripts/",
+    "tasks/",
+    "test/",
+    "hardhat.config.ts",
+    "tsconfig.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "hardhat node & yarn compile && yarn deploy --network localhost",
+    "compile": "hardhat compile",
+    "download:snark-artifacts": "hardhat run scripts/download-snark-artifacts.ts",
+    "deploy": "yarn compile && hardhat deploy",
+    "test": "hardhat run scripts/download-snark-artifacts.ts && hardhat test",
+    "test:report-gas": "REPORT_GAS=true hardhat test",
+    "test:coverage": "hardhat coverage",
+    "typechain": "hardhat typechain"
+  },
+  "devDependencies": {
+    "@ethersproject/abi": "^5.4.7",
+    "@ethersproject/providers": "^5.4.7",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^2.0.0",
+    "@nomiclabs/hardhat-ethers": "^2.0.0",
+    "@nomiclabs/hardhat-etherscan": "^3.0.0",
+    "@semaphore-protocol/group": "3.6.0-1",
+    "@semaphore-protocol/hardhat": "3.6.0-1",
+    "@semaphore-protocol/identity": "3.6.0-1",
+    "@semaphore-protocol/proof": "3.6.0-1",
+    "@typechain/ethers-v5": "^10.1.0",
+    "@typechain/hardhat": "^6.1.2",
+    "@types/chai": "^4.2.0",
+    "@types/download": "^8.0.1",
+    "@types/mocha": "^9.1.0",
+    "@types/node": ">=12.0.0",
+    "chai": "^4.2.0",
+    "dotenv": "^16.0.3",
+    "download": "^8.0.0",
+    "ethers": "^5.4.7",
+    "hardhat": "^2.11.0",
+    "hardhat-gas-reporter": "^1.0.8",
+    "solidity-coverage": "^0.8.1",
+    "ts-node": ">=8.0.0",
+    "typechain": "^8.1.0",
+    "typescript": ">=4.5.0"
+  },
+  "dependencies": {
+    "@semaphore-protocol/contracts": "3.6.0-1"
+  },
+  "config": {
+    "solidity": {
+      "version": "0.8.4"
+    },
+    "paths": {
+      "contracts": "./contracts",
+      "tests": "./test",
+      "cache": "./cache",
+      "build": {
+        "snark-artifacts": "./build/snark-artifacts",
+        "contracts": "./build/contracts",
+        "typechain": "./build/typechain"
+      }
+    }
+  },
+  "stableVersion": "3.5.0"
+}

package/scripts/download-snark-artifacts.ts

@@ -0,0 +1,24 @@
+import download from "download"
+import fs from "fs"
+import { config } from "../package.json"
+
+async function main() {
+    const snarkArtifactsPath = config.paths.build["snark-artifacts"]
+    const url = `http://www.trusted-setup-pse.org/semaphore/${20}`
+
+    if (!fs.existsSync(snarkArtifactsPath)) {
+        fs.mkdirSync(snarkArtifactsPath, { recursive: true })
+    }
+
+    if (!fs.existsSync(`${snarkArtifactsPath}/semaphore.zkey`)) {
+        await download(`${url}/semaphore.wasm`, snarkArtifactsPath)
+        await download(`${url}/semaphore.zkey`, snarkArtifactsPath)
+    }
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error)
+        process.exit(1)
+    })

package/tasks/deploy.ts

@@ -0,0 +1,31 @@
+import { task, types } from "hardhat/config"
+
+task("deploy", "Deploy a Feedback contract")
+    .addOptionalParam("semaphore", "Semaphore contract address", undefined, types.string)
+    .addOptionalParam("group", "Group id", "42", types.string)
+    .addOptionalParam("logs", "Print the logs", true, types.boolean)
+    .setAction(async ({ logs, semaphore: semaphoreAddress, group: groupId }, { ethers, run }) => {
+        if (!semaphoreAddress) {
+            const { semaphore } = await run("deploy:semaphore", {
+                logs
+            })
+
+            semaphoreAddress = semaphore.address
+        }
+
+        if (!groupId) {
+            groupId = process.env.GROUP_ID
+        }
+
+        const FeedbackFactory = await ethers.getContractFactory("Feedback")
+
+        const feedbackContract = await FeedbackFactory.deploy(semaphoreAddress, groupId)
+
+        await feedbackContract.deployed()
+
+        if (logs) {
+            console.info(`Feedback contract has been deployed to: ${feedbackContract.address}`)
+        }
+
+        return feedbackContract
+    })

package/test/Feedback.ts

@@ -0,0 +1,69 @@
+import { Group } from "@semaphore-protocol/group"
+import { Identity } from "@semaphore-protocol/identity"
+import { generateProof } from "@semaphore-protocol/proof"
+import { expect } from "chai"
+import { formatBytes32String } from "ethers/lib/utils"
+import { run } from "hardhat"
+// @ts-ignore: typechain folder will be generated after contracts compilation
+import { Feedback } from "../build/typechain"
+import { config } from "../package.json"
+
+describe("Feedback", () => {
+    let feedbackContract: Feedback
+    let semaphoreContract: string
+
+    const groupId = "42"
+    const group = new Group(groupId)
+    const users: Identity[] = []
+
+    before(async () => {
+        const { semaphore } = await run("deploy:semaphore", {
+            logs: false
+        })
+
+        feedbackContract = await run("deploy", { logs: false, group: groupId, semaphore: semaphore.address })
+        semaphoreContract = semaphore
+
+        users.push(new Identity())
+        users.push(new Identity())
+    })
+
+    describe("# joinGroup", () => {
+        it("Should allow users to join the group", async () => {
+            for await (const [i, user] of users.entries()) {
+                const transaction = feedbackContract.joinGroup(user.commitment)
+
+                group.addMember(user.commitment)
+
+                await expect(transaction)
+                    .to.emit(semaphoreContract, "MemberAdded")
+                    .withArgs(groupId, i, user.commitment, group.root)
+            }
+        })
+    })
+
+    describe("# sendFeedback", () => {
+        const wasmFilePath = `${config.paths.build["snark-artifacts"]}/semaphore.wasm`
+        const zkeyFilePath = `${config.paths.build["snark-artifacts"]}/semaphore.zkey`
+
+        it("Should allow users to send feedback anonymously", async () => {
+            const feedback = formatBytes32String("Hello World")
+
+            const fullProof = await generateProof(users[1], group, groupId, feedback, {
+                wasmFilePath,
+                zkeyFilePath
+            })
+
+            const transaction = feedbackContract.sendFeedback(
+                feedback,
+                fullProof.merkleTreeRoot,
+                fullProof.nullifierHash,
+                fullProof.proof
+            )
+
+            await expect(transaction)
+                .to.emit(semaphoreContract, "ProofVerified")
+                .withArgs(groupId, fullProof.merkleTreeRoot, fullProof.nullifierHash, groupId, fullProof.signal)
+        })
+    })
+})

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "moduleResolution": "Node",
+        "noImplicitAny": true,
+        "resolveJsonModule": true,
+        "target": "ES2018",
+        "module": "CommonJS",
+        "strict": true,
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "typeRoots": ["node_modules/@types", "types"]
+    },
+    "include": ["scripts/**/*", "tasks/**/*", "test/**/*", "build/typechain/**/*", "types/**/*"],
+    "files": ["./hardhat.config.ts"]
+}