@semaphore-protocol/hardhat 0.1.0 → 3.0.0-beta.6

package/dist/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/hardhat
- * @version 0.1.0
+ * @version 3.0.0-beta.6
  * @file A Semaphore Hardhat plugin to deploy verifiers and Semaphore contract.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -75,92 +75,114 @@ function __spreadArray(to, from, pack) {
 }
 
 task("deploy:semaphore", "Deploy a Semaphore contract")
-    .addParam("verifiers", "Tree depths and verifier addresses", [], types.json)
+    .addOptionalParam("pairing", "Pairing library address", undefined, types.string)
+    .addOptionalParam("semaphoreVerifier", "SemaphoreVerifier contract address", undefined, types.string)
+    .addOptionalParam("poseidon", "Poseidon library address", undefined, types.string)
+    .addOptionalParam("incrementalBinaryTree", "IncrementalBinaryTree library address", undefined, types.string)
     .addOptionalParam("logs", "Print the logs", true, types.boolean)
     .setAction(function (_a, _b) {
-    var logs = _a.logs, verifiers = _a.verifiers;
+    var logs = _a.logs, pairingAddress = _a.pairing, semaphoreVerifierAddress = _a.semaphoreVerifier, poseidonAddress = _a.poseidon, incrementalBinaryTreeAddress = _a.incrementalBinaryTree;
     var ethers = _b.ethers;
     return __awaiter(void 0, void 0, void 0, function () {
-        var poseidonABI, poseidonBytecode, signer, PoseidonLibFactory, poseidonLib, IncrementalBinaryTreeLibFactory, incrementalBinaryTreeLib, SemaphoreContractFactory, semaphoreContract;
+        var PairingFactory, pairing, SemaphoreVerifierFactory, semaphoreVerifier, poseidonABI, poseidonBytecode, signer, PoseidonFactory, poseidon, IncrementalBinaryTreeFactory, incrementalBinaryTree, SemaphoreFactory, semaphore;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
-                    poseidonABI = poseidon_gencontract.generateABI(2);
-                    poseidonBytecode = poseidon_gencontract.createCode(2);
-                    return [4 /*yield*/, ethers.getSigners()];
+                    if (!!semaphoreVerifierAddress) return [3 /*break*/, 8];
+                    if (!!pairingAddress) return [3 /*break*/, 4];
+                    return [4 /*yield*/, ethers.getContractFactory("Pairing")];
                 case 1:
-                    signer = (_c.sent())[0];
-                    PoseidonLibFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer);
-                    return [4 /*yield*/, PoseidonLibFactory.deploy()];
+                    PairingFactory = _c.sent();
+                    return [4 /*yield*/, PairingFactory.deploy()];
                 case 2:
-                    poseidonLib = _c.sent();
-                    return [4 /*yield*/, poseidonLib.deployed()];
+                    pairing = _c.sent();
+                    return [4 /*yield*/, pairing.deployed()];
                 case 3:
                     _c.sent();
                     if (logs) {
-                        console.info("Poseidon library has been deployed to: ".concat(poseidonLib.address));
+                        console.info("Pairing library has been deployed to: ".concat(pairing.address));
                     }
-                    return [4 /*yield*/, ethers.getContractFactory("IncrementalBinaryTree", {
-                            libraries: {
-                                PoseidonT3: poseidonLib.address
-                            }
-                        })];
-                case 4:
-                    IncrementalBinaryTreeLibFactory = _c.sent();
-                    return [4 /*yield*/, IncrementalBinaryTreeLibFactory.deploy()];
+                    pairingAddress = pairing.address;
+                    _c.label = 4;
+                case 4: return [4 /*yield*/, ethers.getContractFactory("SemaphoreVerifier", {
+                        libraries: {
+                            Pairing: pairingAddress
+                        }
+                    })];
                 case 5:
-                    incrementalBinaryTreeLib = _c.sent();
-                    return [4 /*yield*/, incrementalBinaryTreeLib.deployed()];
+                    SemaphoreVerifierFactory = _c.sent();
+                    return [4 /*yield*/, SemaphoreVerifierFactory.deploy()];
                 case 6:
+                    semaphoreVerifier = _c.sent();
+                    return [4 /*yield*/, semaphoreVerifier.deployed()];
+                case 7:
                     _c.sent();
                     if (logs) {
-                        console.info("IncrementalBinaryTree library has been deployed to: ".concat(incrementalBinaryTreeLib.address));
+                        console.info("SemaphoreVerifier contract has been deployed to: ".concat(semaphoreVerifier.address));
                     }
-                    return [4 /*yield*/, ethers.getContractFactory("Semaphore", {
-                            libraries: {
-                                IncrementalBinaryTree: incrementalBinaryTreeLib.address
-                            }
-                        })];
-                case 7:
-                    SemaphoreContractFactory = _c.sent();
-                    return [4 /*yield*/, SemaphoreContractFactory.deploy(verifiers)];
+                    semaphoreVerifierAddress = semaphoreVerifier.address;
+                    _c.label = 8;
                 case 8:
-                    semaphoreContract = _c.sent();
-                    return [4 /*yield*/, semaphoreContract.deployed()];
+                    if (!!incrementalBinaryTreeAddress) return [3 /*break*/, 16];
+                    if (!!poseidonAddress) return [3 /*break*/, 12];
+                    poseidonABI = poseidon_gencontract.generateABI(2);
+                    poseidonBytecode = poseidon_gencontract.createCode(2);
+                    return [4 /*yield*/, ethers.getSigners()];
                 case 9:
+                    signer = (_c.sent())[0];
+                    PoseidonFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer);
+                    return [4 /*yield*/, PoseidonFactory.deploy()];
+                case 10:
+                    poseidon = _c.sent();
+                    return [4 /*yield*/, poseidon.deployed()];
+                case 11:
                     _c.sent();
                     if (logs) {
-                        console.info("Semaphore contract has been deployed to: ".concat(semaphoreContract.address));
+                        console.info("Poseidon library has been deployed to: ".concat(poseidon.address));
                     }
-                    return [2 /*return*/, semaphoreContract];
-            }
-        });
-    });
-});
-
-task("deploy:verifier", "Deploy a Verifier contract")
-    .addParam("merkleTreeDepth", "Merkle tree depth", undefined, types.int)
-    .addOptionalParam("logs", "Print the logs", true, types.boolean)
-    .setAction(function (_a, _b) {
-    var merkleTreeDepth = _a.merkleTreeDepth, logs = _a.logs;
-    var ethers = _b.ethers;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var VerifierContractFactory, verifierContract;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, ethers.getContractFactory("Verifier".concat(merkleTreeDepth))];
-                case 1:
-                    VerifierContractFactory = _c.sent();
-                    return [4 /*yield*/, VerifierContractFactory.deploy()];
-                case 2:
-                    verifierContract = _c.sent();
-                    return [4 /*yield*/, verifierContract.deployed()];
-                case 3:
+                    poseidonAddress = poseidon.address;
+                    _c.label = 12;
+                case 12: return [4 /*yield*/, ethers.getContractFactory("IncrementalBinaryTree", {
+                        libraries: {
+                            PoseidonT3: poseidonAddress
+                        }
+                    })];
+                case 13:
+                    IncrementalBinaryTreeFactory = _c.sent();
+                    return [4 /*yield*/, IncrementalBinaryTreeFactory.deploy()];
+                case 14:
+                    incrementalBinaryTree = _c.sent();
+                    return [4 /*yield*/, incrementalBinaryTree.deployed()];
+                case 15:
+                    _c.sent();
+                    if (logs) {
+                        console.info("IncrementalBinaryTree library has been deployed to: ".concat(incrementalBinaryTree.address));
+                    }
+                    incrementalBinaryTreeAddress = incrementalBinaryTree.address;
+                    _c.label = 16;
+                case 16: return [4 /*yield*/, ethers.getContractFactory("Semaphore", {
+                        libraries: {
+                            IncrementalBinaryTree: incrementalBinaryTreeAddress
+                        }
+                    })];
+                case 17:
+                    SemaphoreFactory = _c.sent();
+                    return [4 /*yield*/, SemaphoreFactory.deploy(semaphoreVerifierAddress)];
+                case 18:
+                    semaphore = _c.sent();
+                    return [4 /*yield*/, semaphore.deployed()];
+                case 19:
                     _c.sent();
                     if (logs) {
-                        console.info("Verifier".concat(merkleTreeDepth, " contract has been deployed to: ").concat(verifierContract.address));
+                        console.info("Semaphore contract has been deployed to: ".concat(semaphore.address));
                     }
-                    return [2 /*return*/, verifierContract];
+                    return [2 /*return*/, {
+                            semaphore: semaphore,
+                            pairingAddress: pairingAddress,
+                            semaphoreVerifierAddress: semaphoreVerifierAddress,
+                            poseidonAddress: poseidonAddress,
+                            incrementalBinaryTreeAddress: incrementalBinaryTreeAddress
+                        }];
             }
         });
     });
@@ -169,23 +191,8 @@ task("deploy:verifier", "Deploy a Verifier contract")
 extendConfig(function (config, userConfig) {
     var _a;
     config.dependencyCompiler.paths = [
-        "@semaphore-protocol/contracts/verifiers/Verifier16.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier17.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier18.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier19.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier20.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier21.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier22.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier23.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier24.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier25.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier26.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier27.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier28.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier29.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier30.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier31.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier32.sol",
+        "@semaphore-protocol/contracts/base/Pairing.sol",
+        "@semaphore-protocol/contracts/base/SemaphoreVerifier.sol",
         "@semaphore-protocol/contracts/Semaphore.sol"
     ];
     if ((_a = userConfig.dependencyCompiler) === null || _a === void 0 ? void 0 : _a.paths) {

package/dist/index.node.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/hardhat
- * @version 0.1.0
+ * @version 3.0.0-beta.6
  * @file A Semaphore Hardhat plugin to deploy verifiers and Semaphore contract.
  * @copyright Ethereum Foundation 2022
  * @license MIT
@@ -77,92 +77,114 @@ function __spreadArray(to, from, pack) {
 }
 
 config.task("deploy:semaphore", "Deploy a Semaphore contract")
-    .addParam("verifiers", "Tree depths and verifier addresses", [], config.types.json)
+    .addOptionalParam("pairing", "Pairing library address", undefined, config.types.string)
+    .addOptionalParam("semaphoreVerifier", "SemaphoreVerifier contract address", undefined, config.types.string)
+    .addOptionalParam("poseidon", "Poseidon library address", undefined, config.types.string)
+    .addOptionalParam("incrementalBinaryTree", "IncrementalBinaryTree library address", undefined, config.types.string)
     .addOptionalParam("logs", "Print the logs", true, config.types.boolean)
     .setAction(function (_a, _b) {
-    var logs = _a.logs, verifiers = _a.verifiers;
+    var logs = _a.logs, pairingAddress = _a.pairing, semaphoreVerifierAddress = _a.semaphoreVerifier, poseidonAddress = _a.poseidon, incrementalBinaryTreeAddress = _a.incrementalBinaryTree;
     var ethers = _b.ethers;
     return __awaiter(void 0, void 0, void 0, function () {
-        var poseidonABI, poseidonBytecode, signer, PoseidonLibFactory, poseidonLib, IncrementalBinaryTreeLibFactory, incrementalBinaryTreeLib, SemaphoreContractFactory, semaphoreContract;
+        var PairingFactory, pairing, SemaphoreVerifierFactory, semaphoreVerifier, poseidonABI, poseidonBytecode, signer, PoseidonFactory, poseidon, IncrementalBinaryTreeFactory, incrementalBinaryTree, SemaphoreFactory, semaphore;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
-                    poseidonABI = circomlibjs.poseidon_gencontract.generateABI(2);
-                    poseidonBytecode = circomlibjs.poseidon_gencontract.createCode(2);
-                    return [4 /*yield*/, ethers.getSigners()];
+                    if (!!semaphoreVerifierAddress) return [3 /*break*/, 8];
+                    if (!!pairingAddress) return [3 /*break*/, 4];
+                    return [4 /*yield*/, ethers.getContractFactory("Pairing")];
                 case 1:
-                    signer = (_c.sent())[0];
-                    PoseidonLibFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer);
-                    return [4 /*yield*/, PoseidonLibFactory.deploy()];
+                    PairingFactory = _c.sent();
+                    return [4 /*yield*/, PairingFactory.deploy()];
                 case 2:
-                    poseidonLib = _c.sent();
-                    return [4 /*yield*/, poseidonLib.deployed()];
+                    pairing = _c.sent();
+                    return [4 /*yield*/, pairing.deployed()];
                 case 3:
                     _c.sent();
                     if (logs) {
-                        console.info("Poseidon library has been deployed to: ".concat(poseidonLib.address));
+                        console.info("Pairing library has been deployed to: ".concat(pairing.address));
                     }
-                    return [4 /*yield*/, ethers.getContractFactory("IncrementalBinaryTree", {
-                            libraries: {
-                                PoseidonT3: poseidonLib.address
-                            }
-                        })];
-                case 4:
-                    IncrementalBinaryTreeLibFactory = _c.sent();
-                    return [4 /*yield*/, IncrementalBinaryTreeLibFactory.deploy()];
+                    pairingAddress = pairing.address;
+                    _c.label = 4;
+                case 4: return [4 /*yield*/, ethers.getContractFactory("SemaphoreVerifier", {
+                        libraries: {
+                            Pairing: pairingAddress
+                        }
+                    })];
                 case 5:
-                    incrementalBinaryTreeLib = _c.sent();
-                    return [4 /*yield*/, incrementalBinaryTreeLib.deployed()];
+                    SemaphoreVerifierFactory = _c.sent();
+                    return [4 /*yield*/, SemaphoreVerifierFactory.deploy()];
                 case 6:
+                    semaphoreVerifier = _c.sent();
+                    return [4 /*yield*/, semaphoreVerifier.deployed()];
+                case 7:
                     _c.sent();
                     if (logs) {
-                        console.info("IncrementalBinaryTree library has been deployed to: ".concat(incrementalBinaryTreeLib.address));
+                        console.info("SemaphoreVerifier contract has been deployed to: ".concat(semaphoreVerifier.address));
                     }
-                    return [4 /*yield*/, ethers.getContractFactory("Semaphore", {
-                            libraries: {
-                                IncrementalBinaryTree: incrementalBinaryTreeLib.address
-                            }
-                        })];
-                case 7:
-                    SemaphoreContractFactory = _c.sent();
-                    return [4 /*yield*/, SemaphoreContractFactory.deploy(verifiers)];
+                    semaphoreVerifierAddress = semaphoreVerifier.address;
+                    _c.label = 8;
                 case 8:
-                    semaphoreContract = _c.sent();
-                    return [4 /*yield*/, semaphoreContract.deployed()];
+                    if (!!incrementalBinaryTreeAddress) return [3 /*break*/, 16];
+                    if (!!poseidonAddress) return [3 /*break*/, 12];
+                    poseidonABI = circomlibjs.poseidon_gencontract.generateABI(2);
+                    poseidonBytecode = circomlibjs.poseidon_gencontract.createCode(2);
+                    return [4 /*yield*/, ethers.getSigners()];
                 case 9:
+                    signer = (_c.sent())[0];
+                    PoseidonFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer);
+                    return [4 /*yield*/, PoseidonFactory.deploy()];
+                case 10:
+                    poseidon = _c.sent();
+                    return [4 /*yield*/, poseidon.deployed()];
+                case 11:
                     _c.sent();
                     if (logs) {
-                        console.info("Semaphore contract has been deployed to: ".concat(semaphoreContract.address));
+                        console.info("Poseidon library has been deployed to: ".concat(poseidon.address));
                     }
-                    return [2 /*return*/, semaphoreContract];
-            }
-        });
-    });
-});
-
-config.task("deploy:verifier", "Deploy a Verifier contract")
-    .addParam("merkleTreeDepth", "Merkle tree depth", undefined, config.types.int)
-    .addOptionalParam("logs", "Print the logs", true, config.types.boolean)
-    .setAction(function (_a, _b) {
-    var merkleTreeDepth = _a.merkleTreeDepth, logs = _a.logs;
-    var ethers = _b.ethers;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var VerifierContractFactory, verifierContract;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, ethers.getContractFactory("Verifier".concat(merkleTreeDepth))];
-                case 1:
-                    VerifierContractFactory = _c.sent();
-                    return [4 /*yield*/, VerifierContractFactory.deploy()];
-                case 2:
-                    verifierContract = _c.sent();
-                    return [4 /*yield*/, verifierContract.deployed()];
-                case 3:
+                    poseidonAddress = poseidon.address;
+                    _c.label = 12;
+                case 12: return [4 /*yield*/, ethers.getContractFactory("IncrementalBinaryTree", {
+                        libraries: {
+                            PoseidonT3: poseidonAddress
+                        }
+                    })];
+                case 13:
+                    IncrementalBinaryTreeFactory = _c.sent();
+                    return [4 /*yield*/, IncrementalBinaryTreeFactory.deploy()];
+                case 14:
+                    incrementalBinaryTree = _c.sent();
+                    return [4 /*yield*/, incrementalBinaryTree.deployed()];
+                case 15:
+                    _c.sent();
+                    if (logs) {
+                        console.info("IncrementalBinaryTree library has been deployed to: ".concat(incrementalBinaryTree.address));
+                    }
+                    incrementalBinaryTreeAddress = incrementalBinaryTree.address;
+                    _c.label = 16;
+                case 16: return [4 /*yield*/, ethers.getContractFactory("Semaphore", {
+                        libraries: {
+                            IncrementalBinaryTree: incrementalBinaryTreeAddress
+                        }
+                    })];
+                case 17:
+                    SemaphoreFactory = _c.sent();
+                    return [4 /*yield*/, SemaphoreFactory.deploy(semaphoreVerifierAddress)];
+                case 18:
+                    semaphore = _c.sent();
+                    return [4 /*yield*/, semaphore.deployed()];
+                case 19:
                     _c.sent();
                     if (logs) {
-                        console.info("Verifier".concat(merkleTreeDepth, " contract has been deployed to: ").concat(verifierContract.address));
+                        console.info("Semaphore contract has been deployed to: ".concat(semaphore.address));
                     }
-                    return [2 /*return*/, verifierContract];
+                    return [2 /*return*/, {
+                            semaphore: semaphore,
+                            pairingAddress: pairingAddress,
+                            semaphoreVerifierAddress: semaphoreVerifierAddress,
+                            poseidonAddress: poseidonAddress,
+                            incrementalBinaryTreeAddress: incrementalBinaryTreeAddress
+                        }];
             }
         });
     });
@@ -171,23 +193,8 @@ config.task("deploy:verifier", "Deploy a Verifier contract")
 config.extendConfig(function (config, userConfig) {
     var _a;
     config.dependencyCompiler.paths = [
-        "@semaphore-protocol/contracts/verifiers/Verifier16.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier17.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier18.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier19.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier20.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier21.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier22.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier23.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier24.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier25.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier26.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier27.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier28.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier29.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier30.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier31.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier32.sol",
+        "@semaphore-protocol/contracts/base/Pairing.sol",
+        "@semaphore-protocol/contracts/base/SemaphoreVerifier.sol",
         "@semaphore-protocol/contracts/Semaphore.sol"
     ];
     if ((_a = userConfig.dependencyCompiler) === null || _a === void 0 ? void 0 : _a.paths) {

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
 import "hardhat-dependency-compiler";
 import "@nomiclabs/hardhat-ethers";
 import "./tasks/deploy-semaphore";
-import "./tasks/deploy-verifier";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/hardhat",
-    "version": "0.1.0",
+    "version": "3.0.0-beta.6",
     "description": "A Semaphore Hardhat plugin to deploy verifiers and Semaphore contract.",
     "license": "MIT",
     "main": "dist/index.node.js",
@@ -38,7 +38,7 @@
     },
     "dependencies": {
         "@nomiclabs/hardhat-ethers": "^2.1.1",
-        "@semaphore-protocol/contracts": "^2.5.0",
+        "@semaphore-protocol/contracts": "3.0.0-beta.6",
         "circomlibjs": "^0.0.8",
         "ethers": "^5.7.1",
         "hardhat-dependency-compiler": "^1.1.3"

package/src/index.ts

@@ -4,27 +4,11 @@ import { HardhatConfig, HardhatUserConfig } from "hardhat/types"
 import "hardhat-dependency-compiler"
 import "@nomiclabs/hardhat-ethers"
 import "./tasks/deploy-semaphore"
-import "./tasks/deploy-verifier"
 
 extendConfig((config: HardhatConfig, userConfig: Readonly<HardhatUserConfig>) => {
     config.dependencyCompiler.paths = [
-        "@semaphore-protocol/contracts/verifiers/Verifier16.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier17.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier18.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier19.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier20.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier21.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier22.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier23.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier24.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier25.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier26.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier27.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier28.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier29.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier30.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier31.sol",
-        "@semaphore-protocol/contracts/verifiers/Verifier32.sol",
+        "@semaphore-protocol/contracts/base/Pairing.sol",
+        "@semaphore-protocol/contracts/base/SemaphoreVerifier.sol",
         "@semaphore-protocol/contracts/Semaphore.sol"
     ]
 

package/src/tasks/deploy-semaphore.ts

@@ -1,51 +1,114 @@
 import { poseidon_gencontract as poseidonContract } from "circomlibjs"
-import { Contract } from "ethers"
 import { task, types } from "hardhat/config"
 
 task("deploy:semaphore", "Deploy a Semaphore contract")
-    .addParam("verifiers", "Tree depths and verifier addresses", [], types.json)
+    .addOptionalParam<boolean>("pairing", "Pairing library address", undefined, types.string)
+    .addOptionalParam<boolean>("semaphoreVerifier", "SemaphoreVerifier contract address", undefined, types.string)
+    .addOptionalParam<boolean>("poseidon", "Poseidon library address", undefined, types.string)
+    .addOptionalParam<boolean>(
+        "incrementalBinaryTree",
+        "IncrementalBinaryTree library address",
+        undefined,
+        types.string
+    )
     .addOptionalParam<boolean>("logs", "Print the logs", true, types.boolean)
-    .setAction(async ({ logs, verifiers }, { ethers }): Promise<Contract> => {
-        const poseidonABI = poseidonContract.generateABI(2)
-        const poseidonBytecode = poseidonContract.createCode(2)
+    .setAction(
+        async (
+            {
+                logs,
+                pairing: pairingAddress,
+                semaphoreVerifier: semaphoreVerifierAddress,
+                poseidon: poseidonAddress,
+                incrementalBinaryTree: incrementalBinaryTreeAddress
+            },
+            { ethers }
+        ): Promise<any> => {
+            if (!semaphoreVerifierAddress) {
+                if (!pairingAddress) {
+                    const PairingFactory = await ethers.getContractFactory("Pairing")
+                    const pairing = await PairingFactory.deploy()
 
-        const [signer] = await ethers.getSigners()
+                    await pairing.deployed()
 
-        const PoseidonLibFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer)
-        const poseidonLib = await PoseidonLibFactory.deploy()
+                    if (logs) {
+                        console.info(`Pairing library has been deployed to: ${pairing.address}`)
+                    }
 
-        await poseidonLib.deployed()
+                    pairingAddress = pairing.address
+                }
 
-        if (logs) {
-            console.info(`Poseidon library has been deployed to: ${poseidonLib.address}`)
-        }
+                const SemaphoreVerifierFactory = await ethers.getContractFactory("SemaphoreVerifier", {
+                    libraries: {
+                        Pairing: pairingAddress
+                    }
+                })
+
+                const semaphoreVerifier = await SemaphoreVerifierFactory.deploy()
+
+                await semaphoreVerifier.deployed()
 
-        const IncrementalBinaryTreeLibFactory = await ethers.getContractFactory("IncrementalBinaryTree", {
-            libraries: {
-                PoseidonT3: poseidonLib.address
+                if (logs) {
+                    console.info(`SemaphoreVerifier contract has been deployed to: ${semaphoreVerifier.address}`)
+                }
+
+                semaphoreVerifierAddress = semaphoreVerifier.address
             }
-        })
-        const incrementalBinaryTreeLib = await IncrementalBinaryTreeLibFactory.deploy()
 
-        await incrementalBinaryTreeLib.deployed()
+            if (!incrementalBinaryTreeAddress) {
+                if (!poseidonAddress) {
+                    const poseidonABI = poseidonContract.generateABI(2)
+                    const poseidonBytecode = poseidonContract.createCode(2)
 
-        if (logs) {
-            console.info(`IncrementalBinaryTree library has been deployed to: ${incrementalBinaryTreeLib.address}`)
-        }
+                    const [signer] = await ethers.getSigners()
+
+                    const PoseidonFactory = new ethers.ContractFactory(poseidonABI, poseidonBytecode, signer)
+                    const poseidon = await PoseidonFactory.deploy()
+
+                    await poseidon.deployed()
+
+                    if (logs) {
+                        console.info(`Poseidon library has been deployed to: ${poseidon.address}`)
+                    }
+
+                    poseidonAddress = poseidon.address
+                }
 
-        const SemaphoreContractFactory = await ethers.getContractFactory("Semaphore", {
-            libraries: {
-                IncrementalBinaryTree: incrementalBinaryTreeLib.address
+                const IncrementalBinaryTreeFactory = await ethers.getContractFactory("IncrementalBinaryTree", {
+                    libraries: {
+                        PoseidonT3: poseidonAddress
+                    }
+                })
+                const incrementalBinaryTree = await IncrementalBinaryTreeFactory.deploy()
+
+                await incrementalBinaryTree.deployed()
+
+                if (logs) {
+                    console.info(`IncrementalBinaryTree library has been deployed to: ${incrementalBinaryTree.address}`)
+                }
+
+                incrementalBinaryTreeAddress = incrementalBinaryTree.address
             }
-        })
 
-        const semaphoreContract = await SemaphoreContractFactory.deploy(verifiers)
+            const SemaphoreFactory = await ethers.getContractFactory("Semaphore", {
+                libraries: {
+                    IncrementalBinaryTree: incrementalBinaryTreeAddress
+                }
+            })
 
-        await semaphoreContract.deployed()
+            const semaphore = await SemaphoreFactory.deploy(semaphoreVerifierAddress)
 
-        if (logs) {
-            console.info(`Semaphore contract has been deployed to: ${semaphoreContract.address}`)
-        }
+            await semaphore.deployed()
 
-        return semaphoreContract
-    })
+            if (logs) {
+                console.info(`Semaphore contract has been deployed to: ${semaphore.address}`)
+            }
+
+            return {
+                semaphore,
+                pairingAddress,
+                semaphoreVerifierAddress,
+                poseidonAddress,
+                incrementalBinaryTreeAddress
+            }
+        }
+    )

package/dist/types/tasks/deploy-verifier.d.ts

@@ -1 +0,0 @@
-export {};

package/src/tasks/deploy-verifier.ts

@@ -1,19 +0,0 @@
-import { Contract } from "ethers"
-import { task, types } from "hardhat/config"
-
-task("deploy:verifier", "Deploy a Verifier contract")
-    .addParam<number>("merkleTreeDepth", "Merkle tree depth", undefined, types.int)
-    .addOptionalParam<boolean>("logs", "Print the logs", true, types.boolean)
-    .setAction(async ({ merkleTreeDepth, logs }, { ethers }): Promise<Contract> => {
-        const VerifierContractFactory = await ethers.getContractFactory(`Verifier${merkleTreeDepth}`)
-
-        const verifierContract = await VerifierContractFactory.deploy()
-
-        await verifierContract.deployed()
-
-        if (logs) {
-            console.info(`Verifier${merkleTreeDepth} contract has been deployed to: ${verifierContract.address}`)
-        }
-
-        return verifierContract
-    })