@maci-protocol/cli 0.0.0-ci.185b643

package/build/ts/index.js

@@ -0,0 +1,912 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const extra_typings_1 = require("@commander-js/extra-typings");
+const domainobjs_1 = require("@maci-protocol/domainobjs");
+const sdk_1 = require("@maci-protocol/sdk");
+const ethers_1 = require("ethers");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+require("./cliInit");
+const utils_1 = require("./utils");
+const defaults_1 = require("./utils/defaults");
+// set the description version and name of the cli tool
+const { description, version, name } = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, "..", "package.json"), "utf8"));
+const program = new extra_typings_1.Command();
+program.name(name).description(description).version(version);
+const getSigner = async () => Promise.resolve().then(() => __importStar(require("@maci-protocol/sdk"))).then((m) => m.getDefaultSigner());
+// add the commands
+program
+    .command("create")
+    .description("deploy the contracts")
+    .option("--poseidonT3Address <poseidonT3Address>", "PoseidonT3 contract address")
+    .option("--poseidonT4Address <poseidonT4Address>", "PoseidonT4 contract address")
+    .option("--poseidonT5Address <poseidonT5Address>", "PoseidonT5 contract address")
+    .option("--poseidonT6Address <poseidonT6Address>", "PoseidonT6 contract address")
+    .option("-g, --signupPolicyAddress <signupPolicyAddress>", "the signup policy contract address")
+    .option("--freeForAllCheckerFactoryAddress <freeForAllCheckerFactoryAddress>", "the free for all checker factory address (optional, using for deployment optimization)")
+    .option("--freeForAllPolicyFactoryAddress <freeForAllPolicyFactoryAddress>", "the free for all policy factory address (optional, using for deployment optimization)")
+    .requiredOption("--signupPolicyContractName <signupPolicyContractName>", "the signup policy contract name")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .requiredOption("-s, --stateTreeDepth <stateTreeDepth>", "the state tree depth", parseInt)
+    .action(async (cmdOptions) => {
+    try {
+        const signer = await getSigner();
+        (0, utils_1.banner)(cmdOptions.quiet);
+        const network = await signer.provider?.getNetwork();
+        const [poseidonT3, poseidonT4, poseidonT5, poseidonT6] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.PoseidonT3, sdk_1.EContracts.PoseidonT4, sdk_1.EContracts.PoseidonT5, sdk_1.EContracts.PoseidonT6],
+            network: network?.name,
+        });
+        let [signupPolicyContractAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [cmdOptions.signupPolicyContractName.toString()],
+            network: network?.name,
+        });
+        if (!signupPolicyContractAddress) {
+            const checkerFactory = cmdOptions.freeForAllCheckerFactoryAddress
+                ? sdk_1.FreeForAllCheckerFactory__factory.connect(cmdOptions.freeForAllCheckerFactoryAddress, signer)
+                : undefined;
+            const policyFactory = cmdOptions.freeForAllPolicyFactoryAddress
+                ? sdk_1.FreeForAllPolicyFactory__factory.connect(cmdOptions.freeForAllPolicyFactoryAddress, signer)
+                : undefined;
+            const [contract] = await (0, sdk_1.deployFreeForAllSignUpPolicy)({ checker: checkerFactory, policy: policyFactory }, signer, true);
+            signupPolicyContractAddress = await contract.getAddress();
+        }
+        // deploy a verifier contract
+        const verifierContract = await (0, sdk_1.deployVerifier)(signer, true);
+        const verifierContractAddress = await verifierContract.getAddress();
+        // deploy MACI, PollFactory and poseidon
+        const { maciContractAddress, pollFactoryContractAddress, tallyFactoryContractAddress, messageProcessorFactoryContractAddress, poseidonAddresses, } = await (0, sdk_1.deployMaci)({
+            signupPolicyAddress: signupPolicyContractAddress,
+            poseidonAddresses: {
+                poseidonT3,
+                poseidonT4,
+                poseidonT5,
+                poseidonT6,
+            },
+            signer,
+            stateTreeDepth: cmdOptions.stateTreeDepth,
+        });
+        const emptyBallotRoots = (0, sdk_1.genEmptyBallotRoots)(cmdOptions.stateTreeDepth);
+        // save to the JSON File
+        await (0, utils_1.storeContractAddresses)({
+            data: {
+                [cmdOptions.signupPolicyContractName]: { address: signupPolicyContractAddress, args: [] },
+                [sdk_1.EContracts.Verifier]: { address: verifierContractAddress, args: [] },
+                [sdk_1.EContracts.MACI]: {
+                    address: maciContractAddress,
+                    args: [
+                        pollFactoryContractAddress,
+                        messageProcessorFactoryContractAddress,
+                        tallyFactoryContractAddress,
+                        signupPolicyContractAddress,
+                        cmdOptions.stateTreeDepth,
+                        emptyBallotRoots.map((root) => root.toString()),
+                    ],
+                },
+                [sdk_1.EContracts.MessageProcessorFactory]: { address: messageProcessorFactoryContractAddress, args: [] },
+                [sdk_1.EContracts.TallyFactory]: { address: tallyFactoryContractAddress, args: [] },
+                [sdk_1.EContracts.PollFactory]: { address: pollFactoryContractAddress, args: [] },
+                [sdk_1.EContracts.PoseidonT3]: { address: poseidonAddresses.poseidonT3, args: [] },
+                [sdk_1.EContracts.PoseidonT4]: { address: poseidonAddresses.poseidonT4, args: [] },
+                [sdk_1.EContracts.PoseidonT5]: { address: poseidonAddresses.poseidonT5, args: [] },
+                [sdk_1.EContracts.PoseidonT6]: { address: poseidonAddresses.poseidonT6, args: [] },
+            },
+            signer,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdOptions.quiet, text: (0, sdk_1.success)(`MACI deployed at:  ${maciContractAddress}`) });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("checkVerifyingKeys")
+    .description("check that the verifying keys in the contract match the local ones")
+    .option("-u, --use-quadratic-voting <useQuadraticVoting>", "whether to use quadratic voting", (value) => value === "true", true)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .option("-k, --vk-contract <vkContract>", "the VkRegistry contract address")
+    .requiredOption("-s, --state-tree-depth <stateTreeDepth>", "the state tree depth", parseInt)
+    .requiredOption("-i, --int-state-tree-depth <intStateTreeDepth>", "the intermediate state tree depth", parseInt)
+    .requiredOption("-v, --vote-option-tree-depth <voteOptionTreeDepth>", "the vote option tree depth", parseInt)
+    .requiredOption("-b, --msg-batch-size <messageBatchSize>", "the message batch size", parseInt)
+    .requiredOption("-p, --process-messages-zkey <processMessagesZkeyPath>", "the process messages zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("-t, --tally-votes-zkey <tallyVotesZkeyPath>", "the tally votes zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--poll-joining-zkey <pollJoiningZkey>", "the poll joining zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--poll-joined-zkey <pollJoinedZkey>", "the poll joined zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .action(async (cmdOptions) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [vkContractAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.VkRegistry],
+            network: network?.name,
+            defaultAddresses: [cmdOptions.vkContract],
+        });
+        (0, sdk_1.logYellow)({ quiet: cmdOptions.quiet, text: (0, sdk_1.info)("Retrieving verifying keys from the contract...") });
+        await (0, sdk_1.checkVerifyingKeys)({
+            stateTreeDepth: cmdOptions.stateTreeDepth,
+            intStateTreeDepth: cmdOptions.intStateTreeDepth,
+            voteOptionTreeDepth: cmdOptions.voteOptionTreeDepth,
+            messageBatchSize: cmdOptions.msgBatchSize,
+            processMessagesZkeyPath: cmdOptions.processMessagesZkey,
+            tallyVotesZkeyPath: cmdOptions.tallyVotesZkey,
+            pollJoiningZkeyPath: cmdOptions.pollJoiningZkey,
+            pollJoinedZkeyPath: cmdOptions.pollJoinedZkey,
+            vkRegistry: vkContractAddress,
+            useQuadraticVoting: cmdOptions.useQuadraticVoting,
+            signer,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdOptions.quiet, text: (0, sdk_1.success)("Verifying keys match") });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("genMaciPubKey")
+    .description("generate a new MACI public key")
+    .requiredOption("-k, --privkey <privkey>", "the private key")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action((cmdObj) => {
+    const publicKey = (0, sdk_1.generateMaciPublicKey)(cmdObj.privkey);
+    (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Public key: ${publicKey}`) });
+});
+program
+    .command("genMaciKeyPair")
+    .description("generate a new MACI key pair")
+    .option("-s, --seed <seed>", "seed value for keypair", (value) => (value ? BigInt(value) : undefined), undefined)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .action((cmdObj) => {
+    const { publicKey, privateKey } = (0, sdk_1.generateKeypair)({ seed: cmdObj.seed });
+    (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Public key: ${publicKey}`) });
+    (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Private key: ${privateKey}`) });
+});
+program
+    .command("deployVkRegistry")
+    .description("deploy a new verification key registry contract")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        (0, utils_1.banner)(cmdObj.quiet);
+        const signer = await getSigner();
+        // assume that the vkRegistry contract is the first one to be deployed
+        const isContractAddressesStoreExists = fs_1.default.existsSync(utils_1.contractAddressesStorePath);
+        if (isContractAddressesStoreExists) {
+            const network = await signer.provider?.getNetwork();
+            (0, utils_1.resetContractAddresses)(network?.name);
+        }
+        // deploy and store the address
+        const vkRegistryAddress = await (0, sdk_1.deployVkRegistryContract)({ signer });
+        await (0, utils_1.storeContractAddresses)({
+            data: { [sdk_1.EContracts.VkRegistry]: { address: vkRegistryAddress, args: [] } },
+            signer,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`VkRegistry deployed at: ${vkRegistryAddress}`) });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("show")
+    .description("show the deployed contract addresses")
+    .action(async () => {
+    try {
+        (0, utils_1.banner)(false);
+        if (!fs_1.default.existsSync(utils_1.contractAddressesStorePath)) {
+            throw new Error("No contracts have been deployed yet");
+        }
+        const signer = await getSigner();
+        const [address, network] = await Promise.all([signer.getAddress(), signer.provider?.getNetwork()]);
+        const contractStorage = sdk_1.ContractStorage.getInstance();
+        contractStorage.printContracts(address, network?.name ?? "hardhat");
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("deployPoll")
+    .description("deploy a new poll")
+    .option("-k, --vkRegistryAddress <vkRegistryAddress>", "the vk registry contract address")
+    .requiredOption("-s, --start <pollStartDate>", "the poll start date", parseInt)
+    .requiredOption("-e, --end <pollEndDate>", "the poll end date", parseInt)
+    .requiredOption("-i, --int-state-tree-depth <intStateTreeDepth>", "the int state tree depth", parseInt)
+    .requiredOption("-b, --msg-batch-size <messageBatchSize>", "the message batch size", parseInt)
+    .requiredOption("-s, --state-tree-depth <stateTreeDepth>", "the state tree depth", parseInt)
+    .requiredOption("-v, --vote-option-tree-depth <voteOptionTreeDepth>", "the vote option tree depth", parseInt)
+    .requiredOption("-p, --pubkey <coordinatorPubkey>", "the coordinator public key")
+    .option("-u, --use-quadratic-voting <useQuadraticVoting>", "whether to use quadratic voting", (value) => value === "true", true)
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-m, --relayers <relayers>", "the relayer addresses", (value) => value.split(",").map((item) => item.trim()))
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .option("-o, --vote-options <voteOptions>", "the number of vote options", parseInt)
+    .option("--initial-voice-credits <initialVoiceCredits>", "the initial voice credits", parseInt)
+    .option("--initial-voice-credits-proxy <initialVoiceCreditsProxy>", "the initial voice credits proxy address")
+    .option("--signup-policy <signupPolicy>", "the signup policy contract address")
+    .action(async (cmdObj) => {
+    try {
+        (0, utils_1.banner)(cmdObj.quiet);
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [vkRegistryAddress, maciAddress, initialVoiceCreditProxyAddress, verifierContractAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [
+                sdk_1.EContracts.VkRegistry,
+                sdk_1.EContracts.MACI,
+                sdk_1.EContracts.ConstantInitialVoiceCreditProxy,
+                sdk_1.EContracts.Verifier,
+            ],
+            network: network?.name,
+            defaultAddresses: [cmdObj.vkRegistryAddress, cmdObj.maciAddress, cmdObj.initialVoiceCreditsProxy],
+        });
+        const maciContract = sdk_1.MACI__factory.connect(maciAddress, signer);
+        const nextPollId = await maciContract.nextPollId();
+        const policyTrait = await (0, sdk_1.getPolicyTrait)({ maciAddress, signer });
+        const policyContractName = (0, sdk_1.getPolicyContractNamesByTrait)(policyTrait);
+        const [signupPolicyContractAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [policyContractName.toString()],
+            keys: [nextPollId.toString()],
+            network: network?.name,
+            defaultAddresses: [cmdObj.signupPolicy],
+        });
+        const { pollId, pollContractAddress, tallyContractAddress, messageProcessorContractAddress, initialVoiceCreditProxyContractAddress, policyContractAddress, } = await (0, sdk_1.deployPoll)({
+            initialVoiceCredits: cmdObj.initialVoiceCredits || defaults_1.DEFAULT_INITIAL_VOICE_CREDITS,
+            pollStartTimestamp: cmdObj.start,
+            pollEndTimestamp: cmdObj.end,
+            intStateTreeDepth: cmdObj.intStateTreeDepth,
+            messageBatchSize: cmdObj.msgBatchSize,
+            stateTreeDepth: cmdObj.stateTreeDepth,
+            voteOptionTreeDepth: cmdObj.voteOptionTreeDepth,
+            coordinatorPubKey: domainobjs_1.PubKey.deserialize(cmdObj.pubkey),
+            maciAddress,
+            vkRegistryContractAddress: vkRegistryAddress,
+            relayers: cmdObj.relayers ?? [ethers_1.ZeroAddress],
+            mode: cmdObj.useQuadraticVoting ? sdk_1.EMode.QV : sdk_1.EMode.NON_QV,
+            signer,
+            voteOptions: cmdObj.voteOptions ?? defaults_1.DEFAULT_VOTE_OPTIONS,
+            verifierContractAddress,
+            policyContractAddress: signupPolicyContractAddress,
+            initialVoiceCreditProxyContractAddress: initialVoiceCreditProxyAddress,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Poll ID: ${pollId}`) });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Poll contract address: ${pollContractAddress}`) });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Tally contract address: ${tallyContractAddress}`) });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`Message processor contract address: ${messageProcessorContractAddress}`),
+        });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`Initial voice credit proxy contract address: ${initialVoiceCreditProxyContractAddress}`),
+        });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`Signup policy contract address: ${policyContractAddress}`),
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("joinPoll")
+    .description("join the poll")
+    .requiredOption("-k, --priv-key <privKey>", "the private key")
+    .option("-i, --state-index <stateIndex>", "the user's state index", BigInt)
+    .option("-s, --sg-data <sgData>", "the signup policy data")
+    .option("-v, --ivcp-data <ivcpData>", "the initial voice credit proxy data")
+    .option("-n, --new-voice-credit-balance <newVoiceCreditBalance>", "the voice credit balance of the user for the poll", BigInt)
+    .requiredOption("-p, --poll-id <pollId>", "the id of the poll", BigInt)
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("--state-file <stateFile>", "the path to the state file containing the serialized maci state")
+    .option("--start-block <startBlock>", "the block number to start looking for events from", parseInt)
+    .option("--end-block <endBlock>", "the block number to end looking for events from", parseInt)
+    .option("--blocks-per-batch <blockPerBatch>", "the number of blocks to process per batch", parseInt)
+    .option("--transaction-hash <transactionHash>", "transaction hash of MACI contract creation")
+    .option("--poll-wasm <pollWasm>", "the path to the poll witness generation wasm binary")
+    .requiredOption("--poll-joining-zkey <pollZkeyPath>", "the poll join zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("-w, --wasm", "whether to use the wasm binaries")
+    .option("-r, --rapidsnark <rapidsnark>", "the path to the rapidsnark binary")
+    .option("-g, --poll-witnessgen <pollWitnessgen>", "the path to the poll witness generation binary")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const privateKey = cmdObj.privKey || (await (0, utils_1.promptSensitiveValue)("Insert your MACI private key"));
+        const data = await (0, sdk_1.joinPoll)({
+            maciAddress,
+            privateKey,
+            stateIndex: cmdObj.stateIndex,
+            stateFile: cmdObj.stateFile,
+            pollId: cmdObj.pollId,
+            signer,
+            startBlock: cmdObj.startBlock,
+            endBlock: cmdObj.endBlock,
+            blocksPerBatch: cmdObj.blocksPerBatch,
+            pollJoiningZkey: cmdObj.pollJoiningZkey,
+            pollWasm: cmdObj.pollWasm,
+            useWasm: cmdObj.wasm,
+            rapidsnark: cmdObj.rapidsnark,
+            pollWitgen: cmdObj.pollWitnessgen,
+            sgDataArg: cmdObj.sgData ?? utils_1.DEFAULT_SG_DATA,
+            ivcpDataArg: cmdObj.ivcpData ?? utils_1.DEFAULT_IVCP_DATA,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.info)(`User joined poll with nullifier: ${data.nullifier}`) });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.info)(`User joined poll with state index: ${data.pollStateIndex}`) });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.info)(`User joined poll with ${data.voiceCredits} voice credits`) });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("setVerifyingKeys")
+    .description("set the verifying keys")
+    .requiredOption("-s, --state-tree-depth <stateTreeDepth>", "the state tree depth", parseInt)
+    .requiredOption("-i, --int-state-tree-depth <intStateTreeDepth>", "the intermediate state tree depth", parseInt)
+    .requiredOption("-v, --vote-option-tree-depth <voteOptionTreeDepth>", "the vote option tree depth", parseInt)
+    .requiredOption("-b, --msg-batch-size <messageBatchSize>", "the message batch size", parseInt)
+    .option("--poll-state-tree-depth <pollStateTreeDepth>", "the poll state tree depth", parseInt)
+    .option("--poll-joining-zkey <pollJoiningZkeyPath>", "the poll joining zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("--poll-joined-zkey <pollJoinedZkeyPath>", "the poll joined zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("--process-messages-zkey-qv <processMessagesZkeyPathQv>", "the process messages qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("--tally-votes-zkey-qv <tallyVotesZkeyPathQv>", "the tally votes qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("--process-messages-zkey-non-qv <processMessagesZkeyPathNonQv>", "the process messages non-qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("--tally-votes-zkey-non-qv <tallyVotesZkeyPathNonQv>", "the tally votes non-qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .option("-u, --use-quadratic-voting <useQuadraticVoting>", "whether to use quadratic voting", (value) => value === "true", true)
+    .option("-k, --vk-registry <vkRegistry>", "the vk registry contract address")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [vkRegistryAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.VkRegistry],
+            network: network?.name,
+            defaultAddresses: [cmdObj.vkRegistry],
+        });
+        const { pollJoiningVk, pollJoinedVk, processVk, tallyVk } = await (0, sdk_1.extractAllVks)({
+            pollJoiningZkeyPath: cmdObj.pollJoiningZkey,
+            pollJoinedZkeyPath: cmdObj.pollJoinedZkey,
+            processMessagesZkeyPath: cmdObj.useQuadraticVoting
+                ? cmdObj.processMessagesZkeyQv
+                : cmdObj.processMessagesZkeyNonQv,
+            tallyVotesZkeyPath: cmdObj.useQuadraticVoting ? cmdObj.tallyVotesZkeyQv : cmdObj.tallyVotesZkeyQv,
+        });
+        await (0, sdk_1.setVerifyingKeys)({
+            stateTreeDepth: cmdObj.stateTreeDepth,
+            intStateTreeDepth: cmdObj.intStateTreeDepth,
+            voteOptionTreeDepth: cmdObj.voteOptionTreeDepth,
+            messageBatchSize: cmdObj.msgBatchSize,
+            pollStateTreeDepth: cmdObj.pollStateTreeDepth || cmdObj.stateTreeDepth,
+            pollJoiningVk: pollJoiningVk,
+            pollJoinedVk: pollJoinedVk,
+            processMessagesVk: processVk,
+            tallyVotesVk: tallyVk,
+            vkRegistryAddress,
+            mode: cmdObj.useQuadraticVoting ? sdk_1.EMode.QV : sdk_1.EMode.NON_QV,
+            signer,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("publish")
+    .description("publish a new message to a MACI Poll contract")
+    .requiredOption("-p, --pubkey <pubkey>", "the MACI public key which should replace the user's public key in the state tree")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-k, --privkey <privkey>", "your serialized MACI private key")
+    .requiredOption("-i, --state-index <stateIndex>", "the user's state index", BigInt)
+    .requiredOption("-v, --vote-option-index <voteOptionIndex>", "the vote option index", BigInt)
+    .requiredOption("-n, --nonce <nonce>", "the message nonce", BigInt)
+    .option("-s, --salt <salt>", "the message salt", BigInt)
+    .requiredOption("-o, --poll-id <pollId>", "the poll id", BigInt)
+    .requiredOption("-w, --new-vote-weight <newVoteWeight>", "the new vote weight", BigInt)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const privateKey = cmdObj.privkey || (await (0, utils_1.promptSensitiveValue)("Insert your MACI private key"));
+        await (0, sdk_1.publish)({
+            pubkey: cmdObj.pubkey,
+            stateIndex: cmdObj.stateIndex,
+            voteOptionIndex: cmdObj.voteOptionIndex,
+            nonce: cmdObj.nonce,
+            pollId: cmdObj.pollId,
+            newVoteWeight: cmdObj.newVoteWeight,
+            maciAddress,
+            salt: cmdObj.salt,
+            privateKey,
+            signer,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("mergeSignups")
+    .description("merge the signups accumulator queue")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .requiredOption("-p, --poll-id <pollId>", "the poll id", BigInt)
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const receipt = await (0, sdk_1.mergeSignups)({
+            pollId: cmdObj.pollId,
+            maciAddress,
+            signer,
+        });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.info)(`Transaction hash: ${receipt.hash}`) });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`Executed mergeSignups(); gas used: ${receipt.gasUsed.toString()}`),
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("timeTravel")
+    .description("fast-forward the time (only works for local hardhat testing")
+    .requiredOption("-s, --seconds <seconds>", "the number of seconds to fast-forward", parseInt)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        (0, utils_1.banner)(cmdObj.quiet);
+        const signer = await getSigner();
+        await (0, sdk_1.timeTravel)({ seconds: cmdObj.seconds, signer });
+        (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`Fast-forwarded ${cmdObj.seconds} seconds`) });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("extractVkToFile")
+    .description("extract vkey to json file")
+    .requiredOption("--poll-joining-zkey <pollJoiningZkey>", "the poll joining zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--poll-joined-zkey <pollJoinedZkey>", "the poll joined zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--process-messages-zkey-qv <processMessagesZkeyPathQv>", "the process messages qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--tally-votes-zkey-qv <tallyVotesZkeyPathQv>", "the tally votes qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--process-messages-zkey-non-qv <processMessagesZkeyPathNonQv>", "the process messages non-qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("--tally-votes-zkey-non-qv <tallyVotesZkeyPathNonQv>", "the tally votes non-qv zkey path (see different options for zkey files to use specific circuits https://maci.pse.dev/docs/trusted-setup, https://maci.pse.dev/docs/testing/#pre-compiled-artifacts-for-testing)")
+    .requiredOption("-o, --output-file <outputFile>", "the output file path of extracted vkeys")
+    .action(async (cmdObj) => {
+    try {
+        await (0, sdk_1.extractVkToFile)({
+            processMessagesZkeyPathQv: cmdObj.processMessagesZkeyQv,
+            tallyVotesZkeyPathQv: cmdObj.tallyVotesZkeyQv,
+            processMessagesZkeyPathNonQv: cmdObj.processMessagesZkeyNonQv,
+            tallyVotesZkeyPathNonQv: cmdObj.tallyVotesZkeyNonQv,
+            pollJoiningZkeyPath: cmdObj.pollJoiningZkey,
+            pollJoinedZkeyPath: cmdObj.pollJoinedZkey,
+            outputFilePath: cmdObj.outputFile,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("signup")
+    .description("Sign up to a MACI contract")
+    .requiredOption("-p, --pubkey <maciPubKey>", "the MACI public key")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-s, --sg-data <sgData>", "the signup gateway data")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const data = await (0, sdk_1.signup)({
+            maciPubKey: cmdObj.pubkey,
+            maciAddress,
+            sgData: cmdObj.sgData ?? utils_1.DEFAULT_SG_DATA,
+            signer,
+        });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`State index: ${data.stateIndex.toString()}\n Transaction hash: ${data.transactionHash}`),
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("isRegisteredUser")
+    .description("Checks if user is registered with their public key and get their data")
+    .requiredOption("-p, --pubkey <maciPubKey>", "the MACI public key")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const data = await (0, sdk_1.getSignedupUserData)({
+            maciPubKey: cmdObj.pubkey,
+            maciAddress,
+            signer,
+        });
+        if (data.isRegistered) {
+            (0, sdk_1.logGreen)({ quiet: cmdObj.quiet, text: (0, sdk_1.success)(`State index: ${data.stateIndex?.toString()}`) });
+        }
+        else {
+            (0, sdk_1.logRed)({ quiet: cmdObj.quiet, text: "User is not registered" });
+        }
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("isJoinedUser")
+    .description("Checks if user is joined to the poll with public key")
+    .requiredOption("-p, --pubkey <pubkey>", "the MACI public key")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .requiredOption("-o, --poll-id <pollId>", "the poll id", BigInt)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("--start-block <startBlock>", "the block number to start looking for events from", parseInt)
+    .option("--end-block <endBlock>", "the block number to end looking for events from", parseInt)
+    .option("--blocks-per-batch <blockPerBatch>", "the number of blocks to process per batch", parseInt)
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const data = await (0, sdk_1.getJoinedUserData)({
+            pollPubKey: cmdObj.pubkey,
+            startBlock: cmdObj.startBlock,
+            maciAddress,
+            pollId: cmdObj.pollId,
+            signer,
+        });
+        if (data.isJoined) {
+            (0, sdk_1.logGreen)({
+                quiet: cmdObj.quiet,
+                text: (0, sdk_1.success)([
+                    `Poll state index: ${data.pollStateIndex?.toString()}, registered: ${data.isJoined}`,
+                    `Voice credits: ${data.voiceCredits?.toString()}`,
+                ].join("\n")),
+            });
+        }
+        else {
+            (0, sdk_1.logRed)({ quiet: cmdObj.quiet, text: "User has not joined the poll" });
+        }
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("getPoll")
+    .description("Get deployed poll from MACI contract")
+    .option("-p, --poll <poll>", "the poll id")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const details = await (0, sdk_1.getPoll)({
+            pollId: cmdObj.poll,
+            maciAddress,
+            signer,
+        });
+        (0, sdk_1.logGreen)({
+            quiet: true,
+            text: (0, sdk_1.success)([
+                `ID: ${details.id}`,
+                `Start time: ${new Date(Number(details.startDate) * 1000).toString()}`,
+                `End time: ${new Date(Number(details.endDate) * 1000).toString()}`,
+                `Number of signups ${details.numSignups}`,
+                `State tree merged: ${details.isMerged}`,
+                `Mode: ${details.mode === 0n ? "Quadratic Voting" : "Non-Quadratic Voting"}`,
+            ].join("\n")),
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("fundWallet")
+    .description("Fund a wallet with Ether")
+    .requiredOption("-a, --amount <amount>", "the amount of Ether", parseInt)
+    .requiredOption("-w, --address <address>", "the address to fund")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        (0, utils_1.banner)(cmdObj.quiet);
+        const signer = await getSigner();
+        const hash = await (0, sdk_1.fundWallet)({ amount: cmdObj.amount, address: cmdObj.address, signer });
+        (0, sdk_1.logYellow)({ quiet: cmdObj.quiet, text: (0, sdk_1.info)(`Transaction hash: ${hash}`) });
+        (0, sdk_1.logGreen)({
+            quiet: cmdObj.quiet,
+            text: (0, sdk_1.success)(`Successfully funded ${cmdObj.address} with ${cmdObj.amount} wei`),
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("verify")
+    .description("verify the results of a poll")
+    .requiredOption("-o, --poll-id <pollId>", "the poll id", BigInt)
+    .requiredOption("-t, --tally-file <tallyFile>", "the tally file with results, per vote option spent credits, spent voice credits total")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .action(async (cmdObj) => {
+    try {
+        (0, utils_1.banner)(cmdObj.quiet);
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        // read the tally file
+        const isTallyFileExists = fs_1.default.existsSync(cmdObj.tallyFile);
+        if (!cmdObj.tallyFile || !isTallyFileExists) {
+            throw new Error(`Unable to open ${cmdObj.tallyFile}`);
+        }
+        const tallyData = await (0, utils_1.readJSONFile)(cmdObj.tallyFile);
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const pollParams = await (0, sdk_1.getPollParams)({ pollId: cmdObj.pollId, maciContractAddress: maciAddress, signer });
+        const tallyCommitments = (0, sdk_1.generateTallyCommitments)({
+            tallyData,
+            voteOptionTreeDepth: pollParams.voteOptionTreeDepth,
+        });
+        await (0, sdk_1.verify)({
+            tallyData,
+            pollId: cmdObj.pollId,
+            maciAddress,
+            signer,
+            tallyCommitments,
+            numVoteOptions: pollParams.numVoteOptions,
+            voteOptionTreeDepth: pollParams.voteOptionTreeDepth,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("genProofs")
+    .description("generate the proofs for a poll")
+    .option("-k, --privkey <privkey>", "your serialized MACI private key")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .requiredOption("-o, --poll-id <pollId>", "the poll id", BigInt)
+    .requiredOption("-t, --tally-file <tallyFile>", "the tally file with results, per vote option spent credits, spent voice credits total")
+    .option("-r, --rapidsnark <rapidsnark>", "the path to the rapidsnark binary")
+    .option("-g, --process-witnessgen <processWitnessgen>", "the path to the process witness generation binary")
+    .option("--process-witnessdat <processWitnessdat>", "the path to the process witness dat file")
+    .option("--tally-witnessgen <tallyWitnessgen>", "the path to the tally witness generation binary")
+    .option("--tally-witnessdat <tallyWitnessdat>", "the path to the tally witness dat file")
+    .requiredOption("--poll-joining-zkey <processJoinZkey>", "the path to the poll join zkey")
+    .requiredOption("--process-zkey <processZkey>", "the path to the process zkey")
+    .requiredOption("--tally-zkey <tallyZkey>", "the path to the tally zkey")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-p, --rpc-provider <provider>", "the rpc provider URL")
+    .requiredOption("-f, --output <outputDir>", "the output directory for proofs")
+    .option("--transaction-hash <transactionHash>", "transaction hash of MACI contract creation")
+    .option("-w, --wasm", "whether to use the wasm binaries")
+    .option("--process-wasm <processWasm>", "the path to the process witness generation wasm binary")
+    .option("--tally-wasm <tallyWasm>", "the path to the tally witness generation wasm binary")
+    .option("--state-file <stateFile>", "the path to the state file containing the serialized maci state")
+    .option("--start-block <startBlock>", "the block number to start looking for events from", parseInt)
+    .option("--end-block <endBlock>", "the block number to end looking for events from", parseInt)
+    .option("--blocks-per-batch <blockPerBatch>", "the number of blocks to process per batch", parseInt)
+    .option("-u, --use-quadratic-voting <useQuadraticVoting>", "whether to use quadratic voting", (value) => value === "true", true)
+    .option("-b, --ipfs-message-backup-files <ipfsMessageBackupFiles>", "Backup files for ipfs messages (name format: ipfsHash1.json, ipfsHash2.json, ..., ipfsHashN.json)", (value) => value?.split(/\s*,\s*/))
+    .action(async ({ quiet, maciAddress, pollId, ipfsMessageBackupFiles, stateFile, startBlock, endBlock, blocksPerBatch, privkey, transactionHash, output, tallyFile, tallyZkey, tallyWitnessgen, tallyWasm, processZkey, processWitnessgen, processWasm, useQuadraticVoting, tallyWitnessdat, processWitnessdat, wasm, rapidsnark, }) => {
+    try {
+        (0, utils_1.banner)(quiet);
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciContractAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [maciAddress],
+        });
+        const coordinatorPrivateKey = privkey || (await (0, utils_1.promptSensitiveValue)("Insert your MACI private key"));
+        await (0, sdk_1.generateProofs)({
+            maciAddress: maciContractAddress,
+            coordinatorPrivateKey,
+            pollId: Number(pollId),
+            ipfsMessageBackupFiles,
+            stateFile: stateFile || "",
+            transactionHash: transactionHash || "",
+            startBlock,
+            endBlock,
+            blocksPerBatch,
+            signer,
+            outputDir: output,
+            tallyFile,
+            tallyZkey,
+            tallyWitgen: tallyWitnessgen,
+            tallyWasm,
+            processZkey,
+            processWitgen: processWitnessgen,
+            processWasm,
+            useQuadraticVoting,
+            tallyDatFile: tallyWitnessdat,
+            processDatFile: processWitnessdat,
+            useWasm: wasm,
+            rapidsnark,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("genLocalState")
+    .description("generate a local MACI state from the smart contracts events")
+    .requiredOption("-o, --output <outputPath>", "the path where to write the state")
+    .requiredOption("-p, --poll-id <pollId>", "the id of the poll", BigInt)
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .option("-k, --privkey <privkey>", "your serialized MACI private key")
+    .option("--start-block <startBlock>", "the start block number", parseInt)
+    .option("--end-block <endBlock>", "the end block number", parseInt)
+    .option("--blocks-per-batch <blockPerBatch>", "the blocks per batch", parseInt)
+    .option("--transaction-hash <transactionHash>", "the transaction hash")
+    .option("-s, --sleep <sleep>", "the sleep time between batches", parseInt)
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .option("-b, --ipfs-message-backup-files <ipfsMessageBackupFiles>", "Backup files for ipfs messages (name format: ipfsHash1.json, ipfsHash2.json, ..., ipfsHashN.json)", (value) => value?.split(/\s*,\s*/))
+    .option("-l, --logs-output <logsOutputPath>", "the path where to save the logs for debugging and auditing purposes")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        const coordinatorPrivateKey = cmdObj.privkey || (await (0, utils_1.promptSensitiveValue)("Insert your MACI private key"));
+        await (0, sdk_1.generateMaciState)({
+            outputPath: cmdObj.output.toString(),
+            pollId: cmdObj.pollId,
+            maciAddress,
+            coordinatorPrivateKey,
+            provider: cmdObj.rpcProvider,
+            endBlock: cmdObj.endBlock,
+            startBlock: cmdObj.startBlock,
+            blockPerBatch: cmdObj.blocksPerBatch,
+            transactionHash: cmdObj.transactionHash,
+            ipfsMessageBackupFiles: cmdObj.ipfsMessageBackupFiles,
+            sleep: cmdObj.sleep,
+            signer,
+            logsOutputPath: cmdObj.logsOutput,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+program
+    .command("proveOnChain")
+    .description("prove the results of a poll on chain")
+    .requiredOption("-o, --poll-id <pollId>", "the poll id", BigInt)
+    .option("-t, --tally-file <tallyFile>", "the tally file with results, per vote option spent credits, spent voice credits total")
+    .option("-q, --quiet <quiet>", "whether to print values to the console", (value) => value === "true", false)
+    .option("-r, --rpc-provider <provider>", "the rpc provider URL")
+    .option("-x, --maci-address <maciAddress>", "the MACI contract address")
+    .requiredOption("-f, --proof-dir <proofDir>", "the proof output directory from the genProofs subcommand")
+    .action(async (cmdObj) => {
+    try {
+        const signer = await getSigner();
+        const network = await signer.provider?.getNetwork();
+        const [maciAddress] = (0, utils_1.readContractAddresses)({
+            contractNames: [sdk_1.EContracts.MACI],
+            network: network?.name,
+            defaultAddresses: [cmdObj.maciAddress],
+        });
+        await (0, sdk_1.proveOnChain)({
+            pollId: cmdObj.pollId,
+            tallyFile: cmdObj.tallyFile,
+            proofDir: cmdObj.proofDir,
+            maciAddress,
+            signer,
+        });
+    }
+    catch (error) {
+        program.error(error.message, { exitCode: 1 });
+    }
+});
+if (require.main === module) {
+    program.parseAsync(process.argv);
+}
+//# sourceMappingURL=index.js.map