@maci-protocol/core 0.0.0-ci.84b0e62 → 0.0.0-ci.85a90db

package/build/ts/Poll.js

@@ -7,6 +7,7 @@ exports.Poll = void 0;
 const crypto_1 = require("@maci-protocol/crypto");
 const domainobjs_1 = require("@maci-protocol/domainobjs");
 const lean_imt_1 = require("@zk-kit/lean-imt");
+const omit_1 = __importDefault(require("lodash/omit"));
 const assert_1 = __importDefault(require("assert"));
 const constants_1 = require("./utils/constants");
 const errors_1 = require("./utils/errors");
@@ -23,22 +24,23 @@ class Poll {
      * @param maciStateRef - The reference to the MACI state.
      * @param pollId - The poll id
      */
-    constructor(pollEndTimestamp, coordinatorKeypair, treeDepths, batchSizes, maciStateRef, voteOptions) {
+    constructor(pollEndTimestamp, coordinatorKeypair, treeDepths, batchSizes, maciStateRef, voteOptions, mode) {
         this.ballots = [];
+        this.voteCounts = [];
         this.messages = [];
         this.commands = [];
-        this.encPubKeys = [];
+        this.encryptionPublicKeys = [];
         this.stateCopied = false;
-        this.pubKeys = [domainobjs_1.padKey];
+        this.publicKeys = [domainobjs_1.padKey];
         // For message processing
-        this.numBatchesProcessed = 0;
+        this.totalBatchesProcessed = 0;
         this.sbSalts = {};
         this.resultRootSalts = {};
-        this.preVOSpentVoiceCreditsRootSalts = {};
+        this.perVoteOptionSpentVoiceCreditsRootSalts = {};
         this.spentVoiceCreditSubtotalSalts = {};
         // For vote tallying
         this.tallyResult = [];
-        this.perVOSpentVoiceCredits = [];
+        this.perVoteOptionSpentVoiceCredits = [];
         this.numBatchesTallied = 0;
         this.totalSpentVoiceCredits = 0n;
         // message chain hash
@@ -48,7 +50,7 @@ class Poll {
         // Poll state tree leaves
         this.pollStateLeaves = [domainobjs_1.blankStateLeaf];
         // how many users signed up
-        this.numSignups = 0n;
+        this.totalSignups = 0n;
         /**
          * Check if user has already joined the poll by checking if the nullifier is registered
          */
@@ -56,13 +58,12 @@ class Poll {
         /**
          * Join the anonymous user to the Poll (to the tree)
          * @param nullifier - Hashed private key used as nullifier
-         * @param pubKey - The poll public key.
+         * @param publicKey - The poll public key.
          * @param newVoiceCreditBalance - New voice credit balance of the user.
-         * @param timestamp - The timestamp of the sign-up.
          * @returns The index of added state leaf
          */
-        this.joinPoll = (nullifier, pubKey, newVoiceCreditBalance, timestamp) => {
-            const stateLeaf = new domainobjs_1.StateLeaf(pubKey, newVoiceCreditBalance, timestamp);
+        this.joinPoll = (nullifier, publicKey, newVoiceCreditBalance) => {
+            const stateLeaf = new domainobjs_1.StateLeaf(publicKey, newVoiceCreditBalance);
             if (this.hasJoined(nullifier)) {
                 throw new Error("UserAlreadyJoined");
             }
@@ -75,11 +76,11 @@ class Poll {
          * Update a Poll with data from MaciState.
          * This is the step where we copy the state from the MaciState instance,
          * and set the number of signups we have so far.
-         * @note It should be called to generate the state for poll joining with numSignups set as
-         * the number of signups in the MaciState. For message processing, you should set numSignups as
+         * @note It should be called to generate the state for poll joining with totalSignups set as
+         * the number of signups in the MaciState. For message processing, you should set totalSignups as
          * the number of users who joined the poll.
          */
-        this.updatePoll = (numSignups) => {
+        this.updatePoll = (totalSignups) => {
             // there might be occasions where we fetch logs after new signups have been made
             // logs are fetched (and MaciState/Poll created locally).
             // If someone signs up after that and we fetch that record
@@ -87,15 +88,15 @@ class Poll {
             // not match. For this, we must only copy up to the number of signups
             // Copy the state tree, ballot tree, state leaves, and ballot leaves
             // start by setting the number of signups
-            this.setNumSignups(numSignups);
-            // copy up to numSignups state leaves
-            this.pubKeys = this.maciStateRef.pubKeys.slice(0, Number(this.numSignups)).map((x) => x.copy());
+            this.setTotalSignups(totalSignups);
+            // copy up to totalSignups state leaves
+            this.publicKeys = this.maciStateRef.publicKeys.slice(0, Number(this.totalSignups)).map((x) => x.copy());
             // ensure we have the correct actual state tree depth value
-            this.actualStateTreeDepth = Math.max(1, Math.ceil(Math.log2(Number(this.numSignups))));
+            this.actualStateTreeDepth = Math.max(1, Math.ceil(Math.log2(Number(this.totalSignups))));
             this.stateTree = new lean_imt_1.LeanIMT(crypto_1.hashLeanIMT);
             // add all leaves
-            this.pubKeys.forEach((pubKey) => {
-                this.stateTree?.insert(pubKey.hash());
+            this.publicKeys.forEach((publicKey) => {
+                this.stateTree?.insert(publicKey.hash());
             });
             // create a poll state tree
             this.pollStateTree = new crypto_1.IncrementalQuinTree(this.actualStateTreeDepth, domainobjs_1.blankStateLeafHash, constants_1.STATE_TREE_ARITY, crypto_1.hash2);
@@ -103,27 +104,33 @@ class Poll {
                 this.pollStateTree?.insert(stateLeaf.hash());
             });
             // Create as many ballots as state leaves
-            this.emptyBallotHash = this.emptyBallot.hash();
-            this.ballotTree = new crypto_1.IncrementalQuinTree(this.stateTreeDepth, this.emptyBallotHash, constants_1.STATE_TREE_ARITY, crypto_1.hash2);
+            this.ballotTree = new crypto_1.IncrementalQuinTree(Number(this.treeDepths.stateTreeDepth), this.emptyBallotHash, constants_1.STATE_TREE_ARITY, crypto_1.hash2);
             this.ballotTree.insert(this.emptyBallotHash);
             // we fill the ballotTree with empty ballots hashes to match the number of signups in the tree
-            while (this.ballots.length < this.pubKeys.length) {
+            while (this.ballots.length < this.publicKeys.length) {
                 this.ballotTree.insert(this.emptyBallotHash);
                 this.ballots.push(this.emptyBallot);
             }
+            this.voteCountsTree = new crypto_1.IncrementalQuinTree(Number(this.treeDepths.stateTreeDepth), this.emptyVoteCountsHash, constants_1.STATE_TREE_ARITY, crypto_1.hash2);
+            this.voteCountsTree.insert(this.emptyVoteCountsHash);
+            const emptyVoteCounts = domainobjs_1.VoteCounts.generateBlank(this.maxVoteOptions, this.treeDepths.voteOptionTreeDepth);
+            while (this.voteCounts.length < this.publicKeys.length) {
+                this.voteCountsTree.insert(this.emptyVoteCountsHash);
+                this.voteCounts.push(emptyVoteCounts);
+            }
             this.stateCopied = true;
         };
         /**
          * Process one message.
          * @param message - The message to process.
-         * @param encPubKey - The public key associated with the encryption private key.
+         * @param encryptionPublicKey - The public key associated with the encryption private key.
          * @returns A number of variables which will be used in the zk-SNARK circuit.
          */
-        this.processMessage = (message, encPubKey, qv = true) => {
+        this.processMessage = (message, encryptionPublicKey) => {
             try {
                 // Decrypt the message
-                const sharedKey = domainobjs_1.Keypair.genEcdhSharedKey(this.coordinatorKeypair.privKey, encPubKey);
-                const { command, signature } = domainobjs_1.PCommand.decrypt(message, sharedKey);
+                const sharedKey = domainobjs_1.Keypair.generateEcdhSharedKey(this.coordinatorKeypair.privateKey, encryptionPublicKey);
+                const { command, signature } = domainobjs_1.VoteCommand.decrypt(message, sharedKey);
                 const stateLeafIndex = command.stateIndex;
                 // If the state tree index in the command is invalid, do nothing
                 if (stateLeafIndex >= BigInt(this.ballots.length) ||
@@ -136,7 +143,7 @@ class Poll {
                 // The ballot to update (or not)
                 const ballot = this.ballots[Number(stateLeafIndex)];
                 // If the signature is invalid, do nothing
-                if (!command.verifySignature(signature, stateLeaf.pubKey)) {
+                if (!command.verifySignature(signature, stateLeaf.publicKey)) {
                     throw new errors_1.ProcessMessageError(errors_1.ProcessMessageErrors.InvalidSignature);
                 }
                 // If the nonce is invalid, do nothing
@@ -149,49 +156,48 @@ class Poll {
                 }
                 const voteOptionIndex = Number(command.voteOptionIndex);
                 const originalVoteWeight = ballot.votes[voteOptionIndex];
-                // the voice credits left are:
-                // voiceCreditsBalance (how many the user has) +
-                // voiceCreditsPreviouslySpent (the original vote weight for this option) ** 2 -
-                // command.newVoteWeight ** 2 (the new vote weight squared)
-                // basically we are replacing the previous vote weight for this
-                // particular vote option with the new one
-                // but we need to ensure that we are not going >= balance
-                // @note that above comment is valid for quadratic voting
-                // for non quadratic voting, we simply remove the exponentiation
-                const voiceCreditsLeft = qv
-                    ? stateLeaf.voiceCreditBalance +
-                        originalVoteWeight * originalVoteWeight -
-                        command.newVoteWeight * command.newVoteWeight
-                    : stateLeaf.voiceCreditBalance + originalVoteWeight - command.newVoteWeight;
+                const voiceCreditsLeft = this.getVoiceCreditsLeft({
+                    stateLeaf,
+                    originalVoteWeight,
+                    newVoteWeight: command.newVoteWeight,
+                    mode: this.mode,
+                });
                 // If the remaining voice credits is insufficient, do nothing
                 if (voiceCreditsLeft < 0n) {
                     throw new errors_1.ProcessMessageError(errors_1.ProcessMessageErrors.InsufficientVoiceCredits);
                 }
+                // If there are some voice credits left for full credits mode, do nothing
+                if (this.mode === constants_1.EMode.FULL && voiceCreditsLeft > 0n) {
+                    throw new errors_1.ProcessMessageError(errors_1.ProcessMessageErrors.InvalidVoiceCredits);
+                }
                 // Deep-copy the state leaf and update its attributes
                 const newStateLeaf = stateLeaf.copy();
                 newStateLeaf.voiceCreditBalance = voiceCreditsLeft;
                 // if the key changes, this is effectively a key-change message too
-                newStateLeaf.pubKey = command.newPubKey.copy();
+                newStateLeaf.publicKey = command.newPublicKey.copy();
                 // Deep-copy the ballot and update its attributes
                 const newBallot = ballot.copy();
                 // increase the nonce
                 newBallot.nonce += 1n;
                 // we change the vote for this exact vote option
                 newBallot.votes[voteOptionIndex] = command.newVoteWeight;
+                if (this.mode === constants_1.EMode.FULL) {
+                    newBallot.votes = newBallot.votes.map((votes, index) => (voteOptionIndex === index ? votes : 0n));
+                }
                 // calculate the path elements for the state tree given the original state tree (before any changes)
                 // changes could effectively be made by this new vote - either a key change or vote change
                 // would result in a different state leaf
-                const originalStateLeafPathElements = this.pollStateTree?.genProof(Number(stateLeafIndex)).pathElements;
+                const { pathElements: originalStateLeafPathElements } = this.pollStateTree.generateProof(Number(stateLeafIndex));
                 // calculate the path elements for the ballot tree given the original ballot tree (before any changes)
                 // changes could effectively be made by this new ballot
-                const originalBallotPathElements = this.ballotTree?.genProof(Number(stateLeafIndex)).pathElements;
+                const { pathElements: originalBallotPathElements } = this.ballotTree.generateProof(Number(stateLeafIndex));
                 // create a new quinary tree where we insert the votes of the origin (up until this message is processed) ballot
-                const vt = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
+                const voteTree = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
                 for (let i = 0; i < this.ballots[0].votes.length; i += 1) {
-                    vt.insert(ballot.votes[i]);
+                    voteTree.insert(ballot.votes[i]);
                 }
                 // calculate the path elements for the vote option tree given the original vote option tree (before any changes)
-                const originalVoteWeightsPathElements = vt.genProof(voteOptionIndex).pathElements;
+                const { pathElements: originalVoteWeightsPathElements } = voteTree.generateProof(voteOptionIndex);
                 // we return the data which is then to be used in the processMessage circuit
                 // to generate a proof of processing
                 return {
@@ -220,40 +226,40 @@ class Poll {
          * Inserts a Message and the corresponding public key used to generate the
          * ECDH shared key which was used to encrypt said message.
          * @param message - The message to insert
-         * @param encPubKey - The public key used to encrypt the message
+         * @param encryptionPublicKey - The public key used to encrypt the message
          */
-        this.publishMessage = (message, encPubKey) => {
-            (0, assert_1.default)(encPubKey.rawPubKey[0] < crypto_1.SNARK_FIELD_SIZE && encPubKey.rawPubKey[1] < crypto_1.SNARK_FIELD_SIZE, "The public key is not in the correct range");
+        this.publishMessage = (message, encryptionPublicKey) => {
+            (0, assert_1.default)(encryptionPublicKey.raw[0] < crypto_1.SNARK_FIELD_SIZE && encryptionPublicKey.raw[1] < crypto_1.SNARK_FIELD_SIZE, "The public key is not in the correct range");
             message.data.forEach((d) => {
                 (0, assert_1.default)(d < crypto_1.SNARK_FIELD_SIZE, "The message data is not in the correct range");
             });
-            // store the encryption pub key
-            this.encPubKeys.push(encPubKey);
+            // store the encryption public key
+            this.encryptionPublicKeys.push(encryptionPublicKey);
             // store the message locally
             this.messages.push(message);
             // add the message hash to the message tree
-            const messageHash = message.hash(encPubKey);
+            const messageHash = message.hash(encryptionPublicKey);
             // update chain hash
             this.updateChainHash(messageHash);
             // Decrypt the message and store the Command
             // step 1. we generate the shared key
-            const sharedKey = domainobjs_1.Keypair.genEcdhSharedKey(this.coordinatorKeypair.privKey, encPubKey);
+            const sharedKey = domainobjs_1.Keypair.generateEcdhSharedKey(this.coordinatorKeypair.privateKey, encryptionPublicKey);
             try {
                 // step 2. we decrypt it
-                const { command } = domainobjs_1.PCommand.decrypt(message, sharedKey);
+                const { command } = domainobjs_1.VoteCommand.decrypt(message, sharedKey);
                 // step 3. we store it in the commands array
                 this.commands.push(command);
             }
             catch (e) {
                 // if there is an error we store an empty command
-                const keyPair = new domainobjs_1.Keypair();
-                const command = new domainobjs_1.PCommand(0n, keyPair.pubKey, 0n, 0n, 0n, 0n, 0n);
+                const keypair = new domainobjs_1.Keypair();
+                const command = new domainobjs_1.VoteCommand(0n, keypair.publicKey, 0n, 0n, 0n, 0n, 0n);
                 this.commands.push(command);
             }
         };
         /**
          * Updates message chain hash
-         * @param messageHash hash of message with encPubKey
+         * @param messageHash hash of message with encryptionPublicKey
          */
         this.updateChainHash = (messageHash) => {
             this.chainHash = (0, crypto_1.hash2)([this.chainHash, messageHash]);
@@ -267,16 +273,16 @@ class Poll {
          * @param args Poll joining circuit inputs
          * @returns stringified circuit inputs
          */
-        this.joiningCircuitInputs = ({ maciPrivKey, stateLeafIndex, pollPubKey, }) => {
+        this.joiningCircuitInputs = ({ maciPrivateKey, stateLeafIndex, pollPublicKey, }) => {
             // calculate the path elements for the state tree given the original state tree
             const { siblings, index } = this.stateTree.generateProof(Number(stateLeafIndex));
             const siblingsLength = siblings.length;
             // The index must be converted to a list of indices, 1 for each tree level.
-            // The circuit tree depth is this.stateTreeDepth, so the number of siblings must be this.stateTreeDepth,
+            // The circuit tree depth is this.treeDepths.stateTreeDepth, so the number of siblings must be this.treeDepths.stateTreeDepth,
             // even if the tree depth is actually 3. The missing siblings can be set to 0, as they
             // won't be used to calculate the root in the circuit.
             const indices = [];
-            for (let i = 0; i < this.stateTreeDepth; i += 1) {
+            for (let i = 0; i < this.treeDepths.stateTreeDepth; i += 1) {
                 // eslint-disable-next-line no-bitwise
                 indices.push(BigInt((index >> i) & 1));
                 if (i >= siblingsLength) {
@@ -285,15 +291,15 @@ class Poll {
             }
             const siblingsArray = siblings.map((sibling) => [sibling]);
             // Create nullifier from private key
-            const inputNullifier = BigInt(maciPrivKey.asCircuitInputs());
+            const inputNullifier = BigInt(maciPrivateKey.asCircuitInputs());
             const nullifier = (0, crypto_1.poseidon)([inputNullifier, this.pollId]);
             // Get state tree's root
             const stateRoot = this.stateTree.root;
             // Set actualStateTreeDepth as number of initial siblings length
             const actualStateTreeDepth = BigInt(siblingsLength);
             const circuitInputs = {
-                privKey: maciPrivKey.asCircuitInputs(),
-                pollPubKey: pollPubKey.asCircuitInputs(),
+                privateKey: maciPrivateKey.asCircuitInputs(),
+                pollPublicKey: pollPublicKey.asCircuitInputs(),
                 siblings: siblingsArray,
                 indices,
                 nullifier,
@@ -308,23 +314,20 @@ class Poll {
          * @param args Poll joined circuit inputs
          * @returns stringified circuit inputs
          */
-        this.joinedCircuitInputs = ({ maciPrivKey, stateLeafIndex, voiceCreditsBalance, joinTimestamp, }) => {
+        this.joinedCircuitInputs = ({ maciPrivateKey, stateLeafIndex, voiceCreditsBalance, }) => {
             // calculate the path elements for the state tree given the original state tree
-            const { pathElements, pathIndices } = this.pollStateTree.genProof(Number(stateLeafIndex));
-            // Get poll state tree's root
-            const stateRoot = this.pollStateTree.root;
+            const { root: stateRoot, pathElements, pathIndices } = this.pollStateTree.generateProof(Number(stateLeafIndex));
             const elementsLength = pathIndices.length;
-            for (let i = 0; i < this.stateTreeDepth; i += 1) {
+            for (let i = 0; i < this.treeDepths.stateTreeDepth; i += 1) {
                 if (i >= elementsLength) {
                     pathElements[i] = [0n];
                     pathIndices[i] = 0;
                 }
             }
             const circuitInputs = {
-                privKey: maciPrivKey.asCircuitInputs(),
+                privateKey: maciPrivateKey.asCircuitInputs(),
                 pathElements: pathElements.map((item) => item.toString()),
                 voiceCreditsBalance: voiceCreditsBalance.toString(),
-                joinTimestamp: joinTimestamp.toString(),
                 pathIndices: pathIndices.map((item) => item.toString()),
                 actualStateTreeDepth: BigInt(this.actualStateTreeDepth),
                 stateRoot,
@@ -350,7 +353,7 @@ class Poll {
             if (this.messages.length > batchSize && this.messages.length % batchSize > 0) {
                 totalBatches += 1;
             }
-            return this.numBatchesProcessed < totalBatches;
+            return this.totalBatchesProcessed < totalBatches;
         };
         /**
          * Process _batchSize messages starting from the saved index. This
@@ -366,10 +369,10 @@ class Poll {
          * @param quiet - Whether to log errors or not
          * @returns stringified circuit inputs
          */
-        this.processMessages = (pollId, qv = true, quiet = true) => {
+        this.processMessages = (pollId, quiet = true) => {
             (0, assert_1.default)(this.hasUnprocessedMessages(), "No more messages to process");
             const batchSize = this.batchSizes.messageBatchSize;
-            if (this.numBatchesProcessed === 0) {
+            if (this.totalBatchesProcessed === 0) {
                 // Prevent other polls from being processed until this poll has
                 // been fully processed
                 this.maciStateRef.pollBeingProcessed = true;
@@ -390,7 +393,7 @@ class Poll {
                 throw new Error("You must update the poll with the correct data first");
             }
             // Generate circuit inputs
-            const circuitInputs = (0, crypto_1.stringifyBigInts)(this.genProcessMessagesCircuitInputsPartial(this.currentMessageBatchIndex));
+            const circuitInputs = (0, crypto_1.stringifyBigInts)(this.generateProcessMessagesCircuitInputsPartial(this.currentMessageBatchIndex));
             // we want to store the state leaves at this point in time
             // and the path elements of the state tree
             const currentStateLeaves = [];
@@ -409,29 +412,29 @@ class Poll {
                 const idx = this.currentMessageBatchIndex * batchSize - i - 1;
                 (0, assert_1.default)(idx >= 0, "The message index must be >= 0");
                 let message;
-                let encPubKey;
+                let encryptionPublicKey;
                 if (idx < this.messages.length) {
                     message = this.messages[idx];
-                    encPubKey = this.encPubKeys[idx];
+                    encryptionPublicKey = this.encryptionPublicKeys[idx];
                     try {
                         // check if the command is valid
-                        const r = this.processMessage(message, encPubKey, qv);
-                        const index = r.stateLeafIndex;
+                        const { stateLeafIndex, originalStateLeaf, originalBallot, originalVoteWeight, originalVoteWeightsPathElements, originalStateLeafPathElements, originalBallotPathElements, newStateLeaf, newBallot, } = this.processMessage(message, encryptionPublicKey);
+                        const index = stateLeafIndex;
                         // we add at position 0 the original data
-                        currentStateLeaves.unshift(r.originalStateLeaf);
-                        currentBallots.unshift(r.originalBallot);
-                        currentVoteWeights.unshift(r.originalVoteWeight);
-                        currentVoteWeightsPathElements.unshift(r.originalVoteWeightsPathElements);
-                        currentStateLeavesPathElements.unshift(r.originalStateLeafPathElements);
-                        currentBallotsPathElements.unshift(r.originalBallotPathElements);
+                        currentStateLeaves.unshift(originalStateLeaf);
+                        currentBallots.unshift(originalBallot);
+                        currentVoteWeights.unshift(originalVoteWeight);
+                        currentVoteWeightsPathElements.unshift(originalVoteWeightsPathElements);
+                        currentStateLeavesPathElements.unshift(originalStateLeafPathElements);
+                        currentBallotsPathElements.unshift(originalBallotPathElements);
                         // update the state leaves with the new state leaf (result of processing the message)
-                        this.pollStateLeaves[index] = r.newStateLeaf.copy();
+                        this.pollStateLeaves[index] = newStateLeaf.copy();
                         // we also update the state tree with the hash of the new state leaf
-                        this.pollStateTree?.update(index, r.newStateLeaf.hash());
+                        this.pollStateTree?.update(index, newStateLeaf.hash());
                         // store the new ballot
-                        this.ballots[index] = r.newBallot;
+                        this.ballots[index] = newBallot;
                         // update the ballot tree
-                        this.ballotTree?.update(index, r.newBallot.hash());
+                        this.ballotTree?.update(index, newBallot.hash());
                     }
                     catch (e) {
                         // if the error is not a ProcessMessageError we throw it and exit here
@@ -450,20 +453,20 @@ class Poll {
                             // which sends a message that when force decrypted on the circuit
                             // results in a valid state index thus forcing the circuit to look
                             // for a valid state leaf, and failing to generate a proof
-                            // gen shared key
-                            const sharedKey = domainobjs_1.Keypair.genEcdhSharedKey(this.coordinatorKeypair.privKey, encPubKey);
+                            // generate shared key
+                            const sharedKey = domainobjs_1.Keypair.generateEcdhSharedKey(this.coordinatorKeypair.privateKey, encryptionPublicKey);
                             // force decrypt it
-                            const { command } = domainobjs_1.PCommand.decrypt(message, sharedKey, true);
+                            const { command } = domainobjs_1.VoteCommand.decrypt(message, sharedKey, true);
                             // cache state leaf index
                             const stateLeafIndex = command.stateIndex;
                             // if the state leaf index is valid then use it
                             if (stateLeafIndex < this.pollStateLeaves.length) {
                                 currentStateLeaves.unshift(this.pollStateLeaves[Number(stateLeafIndex)].copy());
-                                currentStateLeavesPathElements.unshift(this.pollStateTree.genProof(Number(stateLeafIndex)).pathElements);
+                                currentStateLeavesPathElements.unshift(this.pollStateTree.generateProof(Number(stateLeafIndex)).pathElements);
                                 // copy the ballot
                                 const ballot = this.ballots[Number(stateLeafIndex)].copy();
                                 currentBallots.unshift(ballot);
-                                currentBallotsPathElements.unshift(this.ballotTree.genProof(Number(stateLeafIndex)).pathElements);
+                                currentBallotsPathElements.unshift(this.ballotTree.generateProof(Number(stateLeafIndex)).pathElements);
                                 // @note we check that command.voteOptionIndex is valid so < voteOptions
                                 // this might be unnecessary but we do it to prevent a possible DoS attack
                                 // from voters who could potentially encrypt a message in such as way that
@@ -471,39 +474,39 @@ class Poll {
                                 if (command.voteOptionIndex < this.voteOptions) {
                                     currentVoteWeights.unshift(ballot.votes[Number(command.voteOptionIndex)]);
                                     // create a new quinary tree and add all votes we have so far
-                                    const vt = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
+                                    const voteTree = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
                                     // fill the vote option tree with the votes we have so far
                                     for (let j = 0; j < this.ballots[0].votes.length; j += 1) {
-                                        vt.insert(ballot.votes[j]);
+                                        voteTree.insert(ballot.votes[j]);
                                     }
                                     // get the path elements for the first vote leaf
-                                    currentVoteWeightsPathElements.unshift(vt.genProof(Number(command.voteOptionIndex)).pathElements);
+                                    currentVoteWeightsPathElements.unshift(voteTree.generateProof(Number(command.voteOptionIndex)).pathElements);
                                 }
                                 else {
                                     currentVoteWeights.unshift(ballot.votes[0]);
                                     // create a new quinary tree and add all votes we have so far
-                                    const vt = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
+                                    const voteTree = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
                                     // fill the vote option tree with the votes we have so far
                                     for (let j = 0; j < this.ballots[0].votes.length; j += 1) {
-                                        vt.insert(ballot.votes[j]);
+                                        voteTree.insert(ballot.votes[j]);
                                     }
                                     // get the path elements for the first vote leaf
-                                    currentVoteWeightsPathElements.unshift(vt.genProof(0).pathElements);
+                                    currentVoteWeightsPathElements.unshift(voteTree.generateProof(0).pathElements);
                                 }
                             }
                             else {
                                 // just use state leaf index 0
                                 currentStateLeaves.unshift(this.pollStateLeaves[0].copy());
-                                currentStateLeavesPathElements.unshift(this.pollStateTree.genProof(0).pathElements);
+                                currentStateLeavesPathElements.unshift(this.pollStateTree.generateProof(0).pathElements);
                                 currentBallots.unshift(this.ballots[0].copy());
-                                currentBallotsPathElements.unshift(this.ballotTree.genProof(0).pathElements);
+                                currentBallotsPathElements.unshift(this.ballotTree.generateProof(0).pathElements);
                                 // Since the command is invalid, we use a zero vote weight
                                 currentVoteWeights.unshift(this.ballots[0].votes[0]);
                                 // create a new quinary tree and add an empty vote
-                                const vt = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
-                                vt.insert(this.ballots[0].votes[0]);
+                                const voteTree = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
+                                voteTree.insert(this.ballots[0].votes[0]);
                                 // get the path elements for this empty vote weight leaf
-                                currentVoteWeightsPathElements.unshift(vt.genProof(0).pathElements);
+                                currentVoteWeightsPathElements.unshift(voteTree.generateProof(0).pathElements);
                             }
                         }
                         else {
@@ -514,17 +517,17 @@ class Poll {
                 else {
                     // Since we don't have a command at that position, use a blank state leaf
                     currentStateLeaves.unshift(this.pollStateLeaves[0].copy());
-                    currentStateLeavesPathElements.unshift(this.pollStateTree.genProof(0).pathElements);
+                    currentStateLeavesPathElements.unshift(this.pollStateTree.generateProof(0).pathElements);
                     // since the command is invliad we use the blank ballot
                     currentBallots.unshift(this.ballots[0].copy());
-                    currentBallotsPathElements.unshift(this.ballotTree.genProof(0).pathElements);
+                    currentBallotsPathElements.unshift(this.ballotTree.generateProof(0).pathElements);
                     // Since the command is invalid, we use a zero vote weight
                     currentVoteWeights.unshift(this.ballots[0].votes[0]);
                     // create a new quinary tree and add an empty vote
-                    const vt = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
-                    vt.insert(this.ballots[0].votes[0]);
+                    const voteTree = new crypto_1.IncrementalQuinTree(this.treeDepths.voteOptionTreeDepth, 0n, constants_1.VOTE_OPTION_TREE_ARITY, crypto_1.hash5);
+                    voteTree.insert(this.ballots[0].votes[0]);
                     // get the path elements for this empty vote weight leaf
-                    currentVoteWeightsPathElements.unshift(vt.genProof(0).pathElements);
+                    currentVoteWeightsPathElements.unshift(voteTree.generateProof(0).pathElements);
                 }
             }
             // store the data in the circuit inputs object
@@ -532,7 +535,7 @@ class Poll {
             // we need to fill the array with 0s to match the length of the state leaves
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let i = 0; i < currentStateLeavesPathElements.length; i += 1) {
-                while (currentStateLeavesPathElements[i].length < this.stateTreeDepth) {
+                while (currentStateLeavesPathElements[i].length < this.treeDepths.stateTreeDepth) {
                     currentStateLeavesPathElements[i].push([0n]);
                 }
             }
@@ -542,14 +545,14 @@ class Poll {
             circuitInputs.currentVoteWeights = currentVoteWeights;
             circuitInputs.currentVoteWeightsPathElements = currentVoteWeightsPathElements;
             // record that we processed one batch
-            this.numBatchesProcessed += 1;
+            this.totalBatchesProcessed += 1;
             if (this.currentMessageBatchIndex > 0) {
                 this.currentMessageBatchIndex -= 1;
             }
             // ensure newSbSalt differs from currentSbSalt
-            let newSbSalt = (0, crypto_1.genRandomSalt)();
+            let newSbSalt = (0, crypto_1.generateRandomSalt)();
             while (this.sbSalts[this.currentMessageBatchIndex] === newSbSalt) {
-                newSbSalt = (0, crypto_1.genRandomSalt)();
+                newSbSalt = (0, crypto_1.generateRandomSalt)();
             }
             this.sbSalts[this.currentMessageBatchIndex] = newSbSalt;
             // store the salt in the circuit inputs
@@ -559,9 +562,9 @@ class Poll {
             // create a commitment to the state and ballot tree roots
             // this will be the hash of the roots with a salt
             circuitInputs.newSbCommitment = (0, crypto_1.hash3)([newStateRoot, newBallotRoot, newSbSalt]);
-            const coordinatorPublicKeyHash = this.coordinatorKeypair.pubKey.hash();
+            const coordinatorPublicKeyHash = this.coordinatorKeypair.publicKey.hash();
             // If this is the last batch, release the lock
-            if (this.numBatchesProcessed * batchSize >= this.messages.length) {
+            if (this.totalBatchesProcessed * batchSize >= this.messages.length) {
                 this.maciStateRef.pollBeingProcessed = false;
             }
             // ensure we pass the dynamic tree depth
@@ -576,33 +579,33 @@ class Poll {
          * @param index - The index of the partial batch.
          * @returns stringified partial circuit inputs
          */
-        this.genProcessMessagesCircuitInputsPartial = (index) => {
+        this.generateProcessMessagesCircuitInputsPartial = (index) => {
             const { messageBatchSize } = this.batchSizes;
             (0, assert_1.default)(index <= this.messages.length, "The index must be <= the number of messages");
-            // fill the msgs array with a copy of the messages we have
+            // fill the messages array with a copy of the messages we have
             // plus empty messages to fill the batch
             // @note create a message with state index 0 to add as padding
             // this way the message will look for state leaf 0
             // and no effect will take place
             // create a random key
             const key = new domainobjs_1.Keypair();
-            // gen ecdh key
-            const ecdh = domainobjs_1.Keypair.genEcdhSharedKey(key.privKey, this.coordinatorKeypair.pubKey);
+            // generate ecdh key
+            const ecdh = domainobjs_1.Keypair.generateEcdhSharedKey(key.privateKey, this.coordinatorKeypair.publicKey);
             // create an empty command with state index 0n
-            const emptyCommand = new domainobjs_1.PCommand(0n, key.pubKey, 0n, 0n, 0n, 0n, 0n);
+            const emptyCommand = new domainobjs_1.VoteCommand(0n, key.publicKey, 0n, 0n, 0n, 0n, 0n);
             // encrypt it
-            const msg = emptyCommand.encrypt(emptyCommand.sign(key.privKey), ecdh);
+            const emptyMessage = emptyCommand.encrypt(emptyCommand.sign(key.privateKey), ecdh);
             // copy the messages to a new array
-            let msgs = this.messages.map((x) => x.asCircuitInputs());
+            let messages = this.messages.map((x) => x.asCircuitInputs());
             // pad with our state index 0 message
-            while (msgs.length % messageBatchSize > 0) {
-                msgs.push(msg.asCircuitInputs());
+            while (messages.length % messageBatchSize > 0) {
+                messages.push(emptyMessage.asCircuitInputs());
             }
             // copy the public keys, pad the array with the last keys if needed
-            let encPubKeys = this.encPubKeys.map((x) => x.copy());
-            while (encPubKeys.length % messageBatchSize > 0) {
+            let encryptionPublicKeys = this.encryptionPublicKeys.map((x) => x.copy());
+            while (encryptionPublicKeys.length % messageBatchSize > 0) {
                 // pad with the public key used to encrypt the message with state index 0 (padding)
-                encPubKeys.push(key.pubKey.copy());
+                encryptionPublicKeys.push(key.publicKey.copy());
             }
             // validate that the batch index is correct, if not fix it
             // this means that the end will be the last message
@@ -612,11 +615,11 @@ class Poll {
             }
             const batchStartIndex = index > 0 ? (index - 1) * messageBatchSize : 0;
             // we only take the messages we need for this batch
-            // it slice msgs array from index of first message in current batch to
+            // it slice messages array from index of first message in current batch to
             // index of last message in current batch
-            msgs = msgs.slice(batchStartIndex, index * messageBatchSize);
+            messages = messages.slice(batchStartIndex, index * messageBatchSize);
             // then take the ones part of this batch
-            encPubKeys = encPubKeys.slice(batchStartIndex, index * messageBatchSize);
+            encryptionPublicKeys = encryptionPublicKeys.slice(batchStartIndex, index * messageBatchSize);
             // cache tree roots
             const currentStateRoot = this.pollStateTree.root;
             const currentBallotRoot = this.ballotTree.root;
@@ -627,15 +630,15 @@ class Poll {
             const inputBatchHash = this.batchHashes[index - 1];
             const outputBatchHash = this.batchHashes[index];
             return (0, crypto_1.stringifyBigInts)({
-                numSignUps: BigInt(this.numSignups),
+                totalSignups: BigInt(this.totalSignups),
                 batchEndIndex: BigInt(batchEndIndex),
                 index: BigInt(batchStartIndex),
                 inputBatchHash,
                 outputBatchHash,
-                msgs,
+                messages,
                 actualStateTreeDepth: BigInt(this.actualStateTreeDepth),
-                coordPrivKey: this.coordinatorKeypair.privKey.asCircuitInputs(),
-                encPubKeys: encPubKeys.map((x) => x.asCircuitInputs()),
+                coordinatorPrivateKey: this.coordinatorKeypair.privateKey.asCircuitInputs(),
+                encryptionPublicKeys: encryptionPublicKeys.map((x) => x.asCircuitInputs()),
                 currentStateRoot,
                 currentBallotRoot,
                 currentSbCommitment,
@@ -665,7 +668,8 @@ class Poll {
         this.hasUntalliedBallots = () => this.numBatchesTallied * this.batchSizes.tallyBatchSize < this.ballots.length;
         /**
          * This method tallies a ballots and updates the tally results.
-         * @returns the circuit inputs for the TallyVotes circuit.
+         *
+         * @returns the circuit inputs for the VoteTally circuit.
          */
         this.tallyVotes = () => {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -678,193 +682,150 @@ class Poll {
             const batchStartIndex = this.numBatchesTallied * batchSize;
             // get the salts needed for the commitments
             const currentResultsRootSalt = batchStartIndex === 0 ? 0n : this.resultRootSalts[batchStartIndex - batchSize];
-            const currentPerVOSpentVoiceCreditsRootSalt = batchStartIndex === 0 ? 0n : this.preVOSpentVoiceCreditsRootSalts[batchStartIndex - batchSize];
+            const currentPerVoteOptionSpentVoiceCreditsRootSalt = batchStartIndex === 0 ? 0n : this.perVoteOptionSpentVoiceCreditsRootSalts[batchStartIndex - batchSize];
             const currentSpentVoiceCreditSubtotalSalt = batchStartIndex === 0 ? 0n : this.spentVoiceCreditSubtotalSalts[batchStartIndex - batchSize];
             // generate a commitment to the current results
-            const currentResultsCommitment = (0, crypto_1.genTreeCommitment)(this.tallyResult, currentResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
-            // generate a commitment to the current per VO spent voice credits
-            const currentPerVOSpentVoiceCreditsCommitment = this.genPerVOSpentVoiceCreditsCommitment(currentPerVOSpentVoiceCreditsRootSalt, batchStartIndex, true);
+            const currentResultsCommitment = (0, crypto_1.generateTreeCommitment)(this.tallyResult, currentResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
+            // generate a commitment to the current per vote option spent voice credits
+            const currentPerVoteOptionSpentVoiceCreditsCommitment = this.generatePerVoteOptionSpentVoiceCreditsCommitment(currentPerVoteOptionSpentVoiceCreditsRootSalt, batchStartIndex, this.mode);
             // generate a commitment to the current spent voice credits
-            const currentSpentVoiceCreditsCommitment = this.genSpentVoiceCreditSubtotalCommitment(currentSpentVoiceCreditSubtotalSalt, batchStartIndex, true);
+            const currentSpentVoiceCreditsCommitment = this.generateSpentVoiceCreditSubtotalCommitment(currentSpentVoiceCreditSubtotalSalt, batchStartIndex, this.mode);
             // the current commitment for the first batch will be 0
             // otherwise calculate as
             // hash([
             //  currentResultsCommitment,
             //  currentSpentVoiceCreditsCommitment,
-            //  currentPerVOSpentVoiceCreditsCommitment
             // ])
-            const currentTallyCommitment = batchStartIndex === 0
+            // or for QV
+            // hash([
+            //  currentResultsCommitment,
+            //  currentSpentVoiceCreditsCommitment,
+            //  currentPerVoteOptionSpentVoiceCreditsCommitment
+            // ])
+            // TODO: use commitment for vote counts
+            const currentTallyCommitmentQv = this.mode !== constants_1.EMode.QV || batchStartIndex === 0
                 ? 0n
                 : (0, crypto_1.hash3)([
                     currentResultsCommitment,
                     currentSpentVoiceCreditsCommitment,
-                    currentPerVOSpentVoiceCreditsCommitment,
+                    currentPerVoteOptionSpentVoiceCreditsCommitment,
                 ]);
+            const currentTallyCommitmentNonQv = this.mode === constants_1.EMode.QV || batchStartIndex === 0
+                ? 0n
+                : (0, crypto_1.hashLeftRight)(currentResultsCommitment, currentSpentVoiceCreditsCommitment);
+            const currentTallyCommitment = currentTallyCommitmentNonQv || currentTallyCommitmentQv;
+            const startIndex = this.numBatchesTallied * batchSize;
+            const endIndex = this.numBatchesTallied * batchSize + batchSize;
             const ballots = [];
+            const voteCounts = [];
+            const voteCountsData = [];
             const currentResults = this.tallyResult.map((x) => BigInt(x.toString()));
-            const currentPerVOSpentVoiceCredits = this.perVOSpentVoiceCredits.map((x) => BigInt(x.toString()));
+            const currentPerVoteOptionSpentVoiceCredits = this.perVoteOptionSpentVoiceCredits.map((x) => BigInt(x.toString()));
             const currentSpentVoiceCreditSubtotal = BigInt(this.totalSpentVoiceCredits.toString());
             // loop in normal order to tally the ballots one by one
-            for (let i = this.numBatchesTallied * batchSize; i < this.numBatchesTallied * batchSize + batchSize; i += 1) {
+            for (let i = startIndex; i < endIndex; i += 1) {
                 // we stop if we have no more ballots to tally
                 if (i >= this.ballots.length) {
                     break;
                 }
                 // save to the local ballot array
                 ballots.push(this.ballots[i]);
+                const ballot = this.ballots[i];
+                const newVoteCounts = this.voteCounts[i].copy();
+                newVoteCounts.counts = ballot.votes.map((votes, voteOptionIndex) => this.voteCounts[i].counts[voteOptionIndex] + BigInt(votes !== 0n));
+                // save to the local vote counts array
+                this.voteCountsTree?.update(i, newVoteCounts.hash());
+                this.voteCounts[i] = newVoteCounts;
+                voteCounts.push(newVoteCounts);
+                voteCountsData.push(newVoteCounts.counts);
                 // for each possible vote option we loop and calculate
                 for (let j = 0; j < this.maxVoteOptions; j += 1) {
-                    const v = this.ballots[i].votes[j];
-                    // the vote itself will be a quadratic vote (sqrt(voiceCredits))
-                    this.tallyResult[j] += v;
-                    // the per vote option spent voice credits will be the sum of the squares of the votes
-                    this.perVOSpentVoiceCredits[j] += v * v;
-                    // the total spent voice credits will be the sum of the squares of the votes
-                    this.totalSpentVoiceCredits += v * v;
+                    const votes = this.ballots[i].votes[j];
+                    this.tallyResult[j] += votes;
+                    if (this.mode === constants_1.EMode.QV) {
+                        // the per vote option spent voice credits will be the sum of the squares of the votes
+                        this.perVoteOptionSpentVoiceCredits[j] += votes * votes;
+                        // the total spent voice credits will be the sum of the squares of the votes
+                        this.totalSpentVoiceCredits += votes * votes;
+                    }
+                    else {
+                        // the total spent voice credits will be the sum of the votes
+                        this.totalSpentVoiceCredits += votes;
+                    }
                 }
             }
             const emptyBallot = new domainobjs_1.Ballot(this.maxVoteOptions, this.treeDepths.voteOptionTreeDepth);
+            const emptyVoteCounts = new domainobjs_1.VoteCounts(this.maxVoteOptions, this.treeDepths.voteOptionTreeDepth);
             // pad the ballots array
             while (ballots.length < batchSize) {
                 ballots.push(emptyBallot);
             }
-            // generate the new salts
-            const newResultsRootSalt = (0, crypto_1.genRandomSalt)();
-            const newPerVOSpentVoiceCreditsRootSalt = (0, crypto_1.genRandomSalt)();
-            const newSpentVoiceCreditSubtotalSalt = (0, crypto_1.genRandomSalt)();
-            // and save them to be used in the next batch
-            this.resultRootSalts[batchStartIndex] = newResultsRootSalt;
-            this.preVOSpentVoiceCreditsRootSalts[batchStartIndex] = newPerVOSpentVoiceCreditsRootSalt;
-            this.spentVoiceCreditSubtotalSalts[batchStartIndex] = newSpentVoiceCreditSubtotalSalt;
-            // generate the new results commitment with the new salts and data
-            const newResultsCommitment = (0, crypto_1.genTreeCommitment)(this.tallyResult, newResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
-            // generate the new spent voice credits commitment with the new salts and data
-            const newSpentVoiceCreditsCommitment = this.genSpentVoiceCreditSubtotalCommitment(newSpentVoiceCreditSubtotalSalt, batchStartIndex + batchSize, true);
-            // generate the new per VO spent voice credits commitment with the new salts and data
-            const newPerVOSpentVoiceCreditsCommitment = this.genPerVOSpentVoiceCreditsCommitment(newPerVOSpentVoiceCreditsRootSalt, batchStartIndex + batchSize, true);
-            // generate the new tally commitment
-            const newTallyCommitment = (0, crypto_1.hash3)([
-                newResultsCommitment,
-                newSpentVoiceCreditsCommitment,
-                newPerVOSpentVoiceCreditsCommitment,
-            ]);
-            // cache vars
-            const stateRoot = this.pollStateTree.root;
-            const ballotRoot = this.ballotTree.root;
-            const sbSalt = this.sbSalts[this.currentMessageBatchIndex];
-            const sbCommitment = (0, crypto_1.hash3)([stateRoot, ballotRoot, sbSalt]);
-            const ballotSubrootProof = this.ballotTree?.genSubrootProof(batchStartIndex, batchStartIndex + batchSize);
-            const votes = ballots.map((x) => x.votes);
-            const circuitInputs = (0, crypto_1.stringifyBigInts)({
-                stateRoot,
-                ballotRoot,
-                sbSalt,
-                index: BigInt(batchStartIndex),
-                numSignUps: BigInt(this.numSignups),
-                sbCommitment,
-                currentTallyCommitment,
-                newTallyCommitment,
-                ballots: ballots.map((x) => x.asCircuitInputs()),
-                ballotPathElements: ballotSubrootProof.pathElements,
-                votes,
-                currentResults,
-                currentResultsRootSalt,
-                currentSpentVoiceCreditSubtotal,
-                currentSpentVoiceCreditSubtotalSalt,
-                currentPerVOSpentVoiceCredits,
-                currentPerVOSpentVoiceCreditsRootSalt,
-                newResultsRootSalt,
-                newPerVOSpentVoiceCreditsRootSalt,
-                newSpentVoiceCreditSubtotalSalt,
-            });
-            this.numBatchesTallied += 1;
-            return circuitInputs;
-        };
-        this.tallyVotesNonQv = () => {
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (this.sbSalts[this.currentMessageBatchIndex] === undefined) {
-                throw new Error("You must process the messages first");
-            }
-            const batchSize = this.batchSizes.tallyBatchSize;
-            (0, assert_1.default)(this.hasUntalliedBallots(), "No more ballots to tally");
-            // calculate where we start tallying next
-            const batchStartIndex = this.numBatchesTallied * batchSize;
-            // get the salts needed for the commitments
-            const currentResultsRootSalt = batchStartIndex === 0 ? 0n : this.resultRootSalts[batchStartIndex - batchSize];
-            const currentSpentVoiceCreditSubtotalSalt = batchStartIndex === 0 ? 0n : this.spentVoiceCreditSubtotalSalts[batchStartIndex - batchSize];
-            // generate a commitment to the current results
-            const currentResultsCommitment = (0, crypto_1.genTreeCommitment)(this.tallyResult, currentResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
-            // generate a commitment to the current spent voice credits
-            const currentSpentVoiceCreditsCommitment = this.genSpentVoiceCreditSubtotalCommitment(currentSpentVoiceCreditSubtotalSalt, batchStartIndex, false);
-            // the current commitment for the first batch will be 0
-            // otherwise calculate as
-            // hash([
-            //  currentResultsCommitment,
-            //  currentSpentVoiceCreditsCommitment,
-            // ])
-            const currentTallyCommitment = batchStartIndex === 0 ? 0n : (0, crypto_1.hashLeftRight)(currentResultsCommitment, currentSpentVoiceCreditsCommitment);
-            const ballots = [];
-            const currentResults = this.tallyResult.map((x) => BigInt(x.toString()));
-            const currentSpentVoiceCreditSubtotal = BigInt(this.totalSpentVoiceCredits.toString());
-            // loop in normal order to tally the ballots one by one
-            for (let i = this.numBatchesTallied * batchSize; i < this.numBatchesTallied * batchSize + batchSize; i += 1) {
-                // we stop if we have no more ballots to tally
-                if (i >= this.ballots.length) {
-                    break;
-                }
-                // save to the local ballot array
-                ballots.push(this.ballots[i]);
-                // for each possible vote option we loop and calculate
-                for (let j = 0; j < this.maxVoteOptions; j += 1) {
-                    const v = this.ballots[i].votes[j];
-                    this.tallyResult[j] += v;
-                    // the total spent voice credits will be the sum of the votes
-                    this.totalSpentVoiceCredits += v;
-                }
-            }
-            const emptyBallot = new domainobjs_1.Ballot(this.maxVoteOptions, this.treeDepths.voteOptionTreeDepth);
-            // pad the ballots array
-            while (ballots.length < batchSize) {
-                ballots.push(emptyBallot);
+            // pad the vote counts array
+            while (voteCounts.length < batchSize) {
+                voteCounts.push(emptyVoteCounts);
             }
             // generate the new salts
-            const newResultsRootSalt = (0, crypto_1.genRandomSalt)();
-            const newSpentVoiceCreditSubtotalSalt = (0, crypto_1.genRandomSalt)();
+            const newResultsRootSalt = (0, crypto_1.generateRandomSalt)();
+            const newPerVoteOptionSpentVoiceCreditsRootSalt = (0, crypto_1.generateRandomSalt)();
+            const newSpentVoiceCreditSubtotalSalt = (0, crypto_1.generateRandomSalt)();
             // and save them to be used in the next batch
             this.resultRootSalts[batchStartIndex] = newResultsRootSalt;
+            this.perVoteOptionSpentVoiceCreditsRootSalts[batchStartIndex] = newPerVoteOptionSpentVoiceCreditsRootSalt;
             this.spentVoiceCreditSubtotalSalts[batchStartIndex] = newSpentVoiceCreditSubtotalSalt;
             // generate the new results commitment with the new salts and data
-            const newResultsCommitment = (0, crypto_1.genTreeCommitment)(this.tallyResult, newResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
+            const newResultsCommitment = (0, crypto_1.generateTreeCommitment)(this.tallyResult, newResultsRootSalt, this.treeDepths.voteOptionTreeDepth);
             // generate the new spent voice credits commitment with the new salts and data
-            const newSpentVoiceCreditsCommitment = this.genSpentVoiceCreditSubtotalCommitment(newSpentVoiceCreditSubtotalSalt, batchStartIndex + batchSize, false);
+            const newSpentVoiceCreditsCommitment = this.generateSpentVoiceCreditSubtotalCommitment(newSpentVoiceCreditSubtotalSalt, batchStartIndex + batchSize, this.mode);
+            // generate the new per vote option spent voice credits commitment with the new salts and data
+            const newPerVoteOptionSpentVoiceCreditsCommitment = this.generatePerVoteOptionSpentVoiceCreditsCommitment(newPerVoteOptionSpentVoiceCreditsRootSalt, batchStartIndex + batchSize, this.mode);
             // generate the new tally commitment
-            const newTallyCommitment = (0, crypto_1.hashLeftRight)(newResultsCommitment, newSpentVoiceCreditsCommitment);
+            const newTallyCommitment = this.mode === constants_1.EMode.QV
+                ? (0, crypto_1.hash3)([newResultsCommitment, newSpentVoiceCreditsCommitment, newPerVoteOptionSpentVoiceCreditsCommitment])
+                : (0, crypto_1.hashLeftRight)(newResultsCommitment, newSpentVoiceCreditsCommitment);
             // cache vars
             const stateRoot = this.pollStateTree.root;
             const ballotRoot = this.ballotTree.root;
+            const voteCountsRoot = this.voteCountsTree.root;
             const sbSalt = this.sbSalts[this.currentMessageBatchIndex];
             const sbCommitment = (0, crypto_1.hash3)([stateRoot, ballotRoot, sbSalt]);
-            const ballotSubrootProof = this.ballotTree?.genSubrootProof(batchStartIndex, batchStartIndex + batchSize);
+            const ballotSubrootProof = this.ballotTree?.generateSubrootProof(batchStartIndex, batchStartIndex + batchSize);
+            const voteCountsSubrootProof = this.voteCountsTree?.generateSubrootProof(batchStartIndex, batchStartIndex + batchSize);
             const votes = ballots.map((x) => x.votes);
-            const circuitInputs = (0, crypto_1.stringifyBigInts)({
+            // Don't include these inputs in the circuit inputs until individual vote counts are implemented
+            const excludedCircuitInputs = ["voteCountsData", "voteCountsPathElements", "voteCounts", "voteCountsRoot"];
+            const circuitInputs = (0, crypto_1.stringifyBigInts)((0, omit_1.default)({
                 stateRoot,
                 ballotRoot,
                 sbSalt,
                 index: BigInt(batchStartIndex),
-                numSignUps: BigInt(this.numSignups),
+                totalSignups: BigInt(this.totalSignups),
                 sbCommitment,
                 currentTallyCommitment,
                 newTallyCommitment,
                 ballots: ballots.map((x) => x.asCircuitInputs()),
                 ballotPathElements: ballotSubrootProof.pathElements,
                 votes,
+                voteCountsRoot,
+                voteCounts: voteCounts.map((x) => x.asCircuitInputs()),
+                voteCountsPathElements: voteCountsSubrootProof.pathElements,
+                voteCountsData,
                 currentResults,
                 currentResultsRootSalt,
                 currentSpentVoiceCreditSubtotal,
                 currentSpentVoiceCreditSubtotalSalt,
+                currentPerVoteOptionSpentVoiceCredits,
+                currentPerVoteOptionSpentVoiceCreditsRootSalt,
+                newPerVoteOptionSpentVoiceCreditsRootSalt,
                 newResultsRootSalt,
                 newSpentVoiceCreditSubtotalSalt,
-            });
+            }, this.mode !== constants_1.EMode.QV
+                ? [
+                    ...excludedCircuitInputs,
+                    "currentPerVoteOptionSpentVoiceCredits",
+                    "currentPerVoteOptionSpentVoiceCreditsRootSalt",
+                    "newPerVoteOptionSpentVoiceCreditsRootSalt",
+                ]
+                : [...excludedCircuitInputs]));
             this.numBatchesTallied += 1;
             return circuitInputs;
         };
@@ -873,19 +834,19 @@ class Poll {
          *
          * This is the hash of the total spent voice credits and a salt, computed as Poseidon([totalCredits, _salt]).
          * @param salt - The salt used in the hash function.
-         * @param numBallotsToCount - The number of ballots to count for the calculation.
-         * @param useQuadraticVoting - Whether to use quadratic voting or not. Default is true.
+         * @param ballotsToCount - The number of ballots to count for the calculation.
+         * @param mode - Voting mode, default is QV.
          * @returns Returns the hash of the total spent voice credits and a salt, computed as Poseidon([totalCredits, _salt]).
          */
-        this.genSpentVoiceCreditSubtotalCommitment = (salt, numBallotsToCount, useQuadraticVoting = true) => {
+        this.generateSpentVoiceCreditSubtotalCommitment = (salt, ballotsToCount, mode = constants_1.EMode.QV) => {
             let subtotal = 0n;
-            for (let i = 0; i < numBallotsToCount; i += 1) {
+            for (let i = 0; i < ballotsToCount; i += 1) {
                 if (this.ballots.length <= i) {
                     break;
                 }
                 for (let j = 0; j < this.tallyResult.length; j += 1) {
-                    const v = BigInt(`${this.ballots[i].votes[j]}`);
-                    subtotal += useQuadraticVoting ? v * v : v;
+                    const vote = BigInt(`${this.ballots[i].votes[j]}`);
+                    subtotal += mode === constants_1.EMode.QV ? vote * vote : vote;
                 }
             }
             return (0, crypto_1.hashLeftRight)(subtotal, salt);
@@ -895,23 +856,23 @@ class Poll {
          *
          * This is the hash of the Merkle root of the spent voice credits per vote option and a salt, computed as Poseidon([root, _salt]).
          * @param salt - The salt used in the hash function.
-         * @param numBallotsToCount - The number of ballots to count for the calculation.
-         * @param useQuadraticVoting - Whether to use quadratic voting or not. Default is true.
+         * @param ballotsToCount - The number of ballots to count for the calculation.
+         * @param mode - Voting mode, default is QV.
          * @returns Returns the hash of the Merkle root of the spent voice credits per vote option and a salt, computed as Poseidon([root, _salt]).
          */
-        this.genPerVOSpentVoiceCreditsCommitment = (salt, numBallotsToCount, useQuadraticVoting = true) => {
+        this.generatePerVoteOptionSpentVoiceCreditsCommitment = (salt, ballotsToCount, mode = constants_1.EMode.QV) => {
             const leaves = Array(this.tallyResult.length).fill(0n);
-            for (let i = 0; i < numBallotsToCount; i += 1) {
+            for (let i = 0; i < ballotsToCount; i += 1) {
                 // check that is a valid index
                 if (i >= this.ballots.length) {
                     break;
                 }
                 for (let j = 0; j < this.tallyResult.length; j += 1) {
-                    const v = this.ballots[i].votes[j];
-                    leaves[j] += useQuadraticVoting ? v * v : v;
+                    const vote = this.ballots[i].votes[j];
+                    leaves[j] += mode === constants_1.EMode.QV ? vote * vote : vote;
                 }
             }
-            return (0, crypto_1.genTreeCommitment)(leaves, salt, this.treeDepths.voteOptionTreeDepth);
+            return (0, crypto_1.generateTreeCommitment)(leaves, salt, this.treeDepths.voteOptionTreeDepth);
         };
         /**
          * Create a deep copy of the Poll object.
@@ -919,32 +880,37 @@ class Poll {
          */
         this.copy = () => {
             const copied = new Poll(BigInt(this.pollEndTimestamp.toString()), this.coordinatorKeypair.copy(), {
-                intStateTreeDepth: Number(this.treeDepths.intStateTreeDepth),
+                tallyProcessingStateTreeDepth: Number(this.treeDepths.tallyProcessingStateTreeDepth),
                 voteOptionTreeDepth: Number(this.treeDepths.voteOptionTreeDepth),
+                stateTreeDepth: Number(this.treeDepths.stateTreeDepth),
             }, {
                 tallyBatchSize: Number(this.batchSizes.tallyBatchSize.toString()),
                 messageBatchSize: Number(this.batchSizes.messageBatchSize.toString()),
-            }, this.maciStateRef, this.voteOptions);
-            copied.pubKeys = this.pubKeys.map((x) => x.copy());
+            }, this.maciStateRef, this.voteOptions, this.mode);
+            copied.publicKeys = this.publicKeys.map((x) => x.copy());
             copied.pollStateLeaves = this.pollStateLeaves.map((x) => x.copy());
             copied.messages = this.messages.map((x) => x.copy());
             copied.commands = this.commands.map((x) => x.copy());
             copied.ballots = this.ballots.map((x) => x.copy());
-            copied.encPubKeys = this.encPubKeys.map((x) => x.copy());
+            copied.encryptionPublicKeys = this.encryptionPublicKeys.map((x) => x.copy());
+            copied.voteCounts = this.voteCounts.map((x) => x.copy());
             if (this.ballotTree) {
                 copied.ballotTree = this.ballotTree.copy();
             }
+            if (this.voteCountsTree) {
+                copied.voteCountsTree = this.voteCountsTree.copy();
+            }
             copied.currentMessageBatchIndex = this.currentMessageBatchIndex;
             copied.maciStateRef = this.maciStateRef;
             copied.tallyResult = this.tallyResult.map((x) => BigInt(x.toString()));
-            copied.perVOSpentVoiceCredits = this.perVOSpentVoiceCredits.map((x) => BigInt(x.toString()));
-            copied.numBatchesProcessed = Number(this.numBatchesProcessed.toString());
+            copied.perVoteOptionSpentVoiceCredits = this.perVoteOptionSpentVoiceCredits.map((x) => BigInt(x.toString()));
+            copied.totalBatchesProcessed = Number(this.totalBatchesProcessed.toString());
             copied.numBatchesTallied = Number(this.numBatchesTallied.toString());
             copied.pollId = this.pollId;
             copied.totalSpentVoiceCredits = BigInt(this.totalSpentVoiceCredits.toString());
             copied.sbSalts = {};
             copied.resultRootSalts = {};
-            copied.preVOSpentVoiceCreditsRootSalts = {};
+            copied.perVoteOptionSpentVoiceCreditsRootSalts = {};
             copied.spentVoiceCreditSubtotalSalts = {};
             Object.keys(this.sbSalts).forEach((k) => {
                 copied.sbSalts[k] = BigInt(this.sbSalts[k].toString());
@@ -952,41 +918,41 @@ class Poll {
             Object.keys(this.resultRootSalts).forEach((k) => {
                 copied.resultRootSalts[k] = BigInt(this.resultRootSalts[k].toString());
             });
-            Object.keys(this.preVOSpentVoiceCreditsRootSalts).forEach((k) => {
-                copied.preVOSpentVoiceCreditsRootSalts[k] = BigInt(this.preVOSpentVoiceCreditsRootSalts[k].toString());
+            Object.keys(this.perVoteOptionSpentVoiceCreditsRootSalts).forEach((k) => {
+                copied.perVoteOptionSpentVoiceCreditsRootSalts[k] = BigInt(this.perVoteOptionSpentVoiceCreditsRootSalts[k].toString());
             });
             Object.keys(this.spentVoiceCreditSubtotalSalts).forEach((k) => {
                 copied.spentVoiceCreditSubtotalSalts[k] = BigInt(this.spentVoiceCreditSubtotalSalts[k].toString());
             });
             // update the number of signups
-            copied.setNumSignups(this.numSignups);
+            copied.setTotalSignups(this.totalSignups);
             return copied;
         };
         /**
          * Check if the Poll object is equal to another Poll object.
-         * @param p - The Poll object to compare.
+         * @param poll - The Poll object to compare.
          * @returns True if the two Poll objects are equal, false otherwise.
          */
-        this.equals = (p) => {
-            const result = this.coordinatorKeypair.equals(p.coordinatorKeypair) &&
-                this.treeDepths.intStateTreeDepth === p.treeDepths.intStateTreeDepth &&
-                this.treeDepths.voteOptionTreeDepth === p.treeDepths.voteOptionTreeDepth &&
-                this.batchSizes.tallyBatchSize === p.batchSizes.tallyBatchSize &&
-                this.batchSizes.messageBatchSize === p.batchSizes.messageBatchSize &&
-                this.maxVoteOptions === p.maxVoteOptions &&
-                this.messages.length === p.messages.length &&
-                this.encPubKeys.length === p.encPubKeys.length &&
-                this.numSignups === p.numSignups;
+        this.equals = (poll) => {
+            const result = this.coordinatorKeypair.equals(poll.coordinatorKeypair) &&
+                this.treeDepths.tallyProcessingStateTreeDepth === poll.treeDepths.tallyProcessingStateTreeDepth &&
+                this.treeDepths.voteOptionTreeDepth === poll.treeDepths.voteOptionTreeDepth &&
+                this.batchSizes.tallyBatchSize === poll.batchSizes.tallyBatchSize &&
+                this.batchSizes.messageBatchSize === poll.batchSizes.messageBatchSize &&
+                this.maxVoteOptions === poll.maxVoteOptions &&
+                this.messages.length === poll.messages.length &&
+                this.encryptionPublicKeys.length === poll.encryptionPublicKeys.length &&
+                this.totalSignups === poll.totalSignups;
             if (!result) {
                 return false;
             }
             for (let i = 0; i < this.messages.length; i += 1) {
-                if (!this.messages[i].equals(p.messages[i])) {
+                if (!this.messages[i].equals(poll.messages[i])) {
                     return false;
                 }
             }
-            for (let i = 0; i < this.encPubKeys.length; i += 1) {
-                if (!this.encPubKeys[i].equals(p.encPubKeys[i])) {
+            for (let i = 0; i < this.encryptionPublicKeys.length; i += 1) {
+                if (!this.encryptionPublicKeys[i].equals(poll.encryptionPublicKeys[i])) {
                     return false;
                 }
             }
@@ -997,40 +963,73 @@ class Poll {
          * @param serializedPrivateKey - the serialized private key
          */
         this.setCoordinatorKeypair = (serializedPrivateKey) => {
-            this.coordinatorKeypair = new domainobjs_1.Keypair(domainobjs_1.PrivKey.deserialize(serializedPrivateKey));
+            this.coordinatorKeypair = new domainobjs_1.Keypair(domainobjs_1.PrivateKey.deserialize(serializedPrivateKey));
         };
         /**
          * Set the number of signups to match the ones from the contract
-         * @param numSignups - the number of signups
+         * @param totalSignups - the number of signups
          */
-        this.setNumSignups = (numSignups) => {
-            this.numSignups = numSignups;
+        this.setTotalSignups = (totalSignups) => {
+            this.totalSignups = totalSignups;
         };
         /**
          * Get the number of signups
          * @returns The number of signups
          */
-        this.getNumSignups = () => this.numSignups;
+        this.getTotalSignups = () => this.totalSignups;
+        if (voteOptions > constants_1.VOTE_OPTION_TREE_ARITY ** treeDepths.voteOptionTreeDepth) {
+            throw new Error("Vote options cannot be greater than the number of leaves in the vote option tree");
+        }
         this.pollEndTimestamp = pollEndTimestamp;
         this.coordinatorKeypair = coordinatorKeypair;
         this.treeDepths = treeDepths;
         this.batchSizes = batchSizes;
-        if (voteOptions > constants_1.VOTE_OPTION_TREE_ARITY ** treeDepths.voteOptionTreeDepth) {
-            throw new Error("Vote options cannot be greater than the number of leaves in the vote option tree");
-        }
         this.voteOptions = voteOptions;
         this.maxVoteOptions = constants_1.VOTE_OPTION_TREE_ARITY ** treeDepths.voteOptionTreeDepth;
         this.maciStateRef = maciStateRef;
         this.pollId = BigInt(maciStateRef.polls.size);
-        this.stateTreeDepth = maciStateRef.stateTreeDepth;
-        this.actualStateTreeDepth = maciStateRef.stateTreeDepth;
+        this.actualStateTreeDepth = treeDepths.stateTreeDepth;
         this.currentMessageBatchIndex = 0;
+        this.mode = mode;
         this.pollNullifiers = new Map();
         this.tallyResult = new Array(this.maxVoteOptions).fill(0n);
-        this.perVOSpentVoiceCredits = new Array(this.maxVoteOptions).fill(0n);
+        this.perVoteOptionSpentVoiceCredits = new Array(this.maxVoteOptions).fill(0n);
         // we put a blank state leaf to prevent a DoS attack
-        this.emptyBallot = domainobjs_1.Ballot.genBlankBallot(this.maxVoteOptions, treeDepths.voteOptionTreeDepth);
+        this.emptyBallot = domainobjs_1.Ballot.generateBlank(this.maxVoteOptions, treeDepths.voteOptionTreeDepth);
         this.ballots.push(this.emptyBallot);
+        this.emptyBallotHash = this.emptyBallot.hash();
+        this.emptyVoteCounts = domainobjs_1.VoteCounts.generateBlank(this.maxVoteOptions, treeDepths.voteOptionTreeDepth);
+        this.voteCounts.push(this.emptyVoteCounts);
+        this.emptyVoteCountsHash = this.emptyVoteCounts.hash();
+    }
+    /**
+     * Get voice credits left for the voting command.
+     *
+     * @param args - arguments for getting voice credits
+     * @returns voice credits left
+     */
+    getVoiceCreditsLeft({ stateLeaf, originalVoteWeight, newVoteWeight, mode }) {
+        switch (mode) {
+            case constants_1.EMode.QV: {
+                // the voice credits left are:
+                // voiceCreditsBalance (how many the user has) +
+                // voiceCreditsPreviouslySpent (the original vote weight for this option) ** 2 -
+                // command.newVoteWeight ** 2 (the new vote weight squared)
+                // basically we are replacing the previous vote weight for this
+                // particular vote option with the new one
+                // but we need to ensure that we are not going >= balance
+                return stateLeaf.voiceCreditBalance + originalVoteWeight * originalVoteWeight - newVoteWeight * newVoteWeight;
+            }
+            case constants_1.EMode.NON_QV:
+            case constants_1.EMode.FULL: {
+                // for non quadratic voting, we simply remove the exponentiation
+                // for full credits voting, it will be zero
+                return stateLeaf.voiceCreditBalance + originalVoteWeight - newVoteWeight;
+            }
+            default: {
+                throw new Error("Voting mode is not supported");
+            }
+        }
     }
     /**
      * Serialize the Poll object to a JSON object
@@ -1038,6 +1037,7 @@ class Poll {
      */
     toJSON() {
         return {
+            stateTreeDepth: Number(this.treeDepths.stateTreeDepth),
             pollEndTimestamp: this.pollEndTimestamp.toString(),
             treeDepths: this.treeDepths,
             batchSizes: this.batchSizes,
@@ -1046,16 +1046,18 @@ class Poll {
             messages: this.messages.map((message) => message.toJSON()),
             commands: this.commands.map((command) => command.toJSON()),
             ballots: this.ballots.map((ballot) => ballot.toJSON()),
-            encPubKeys: this.encPubKeys.map((encPubKey) => encPubKey.serialize()),
+            voteCounts: this.voteCounts.map((voteCounts) => voteCounts.toJSON()),
+            encryptionPublicKeys: this.encryptionPublicKeys.map((encryptionPublicKey) => encryptionPublicKey.serialize()),
             currentMessageBatchIndex: this.currentMessageBatchIndex,
-            pubKeys: this.pubKeys.map((leaf) => leaf.toJSON()),
+            publicKeys: this.publicKeys.map((leaf) => leaf.toJSON()),
             pollStateLeaves: this.pollStateLeaves.map((leaf) => leaf.toJSON()),
             results: this.tallyResult.map((result) => result.toString()),
-            numBatchesProcessed: this.numBatchesProcessed,
-            numSignups: this.numSignups.toString(),
+            totalBatchesProcessed: this.totalBatchesProcessed,
+            totalSignups: this.totalSignups.toString(),
             chainHash: this.chainHash.toString(),
             pollNullifiers: [...this.pollNullifiers.keys()].map((nullifier) => nullifier.toString()),
             batchHashes: this.batchHashes.map((batchHash) => batchHash.toString()),
+            mode: this.mode,
         };
     }
     /**
@@ -1065,21 +1067,22 @@ class Poll {
      * @returns a new Poll instance
      */
     static fromJSON(json, maciState) {
-        const poll = new Poll(BigInt(json.pollEndTimestamp), new domainobjs_1.Keypair(), json.treeDepths, json.batchSizes, maciState, BigInt(json.voteOptions));
+        const poll = new Poll(BigInt(json.pollEndTimestamp), new domainobjs_1.Keypair(), json.treeDepths, json.batchSizes, maciState, BigInt(json.voteOptions), json.mode);
         // set all properties
         poll.pollStateLeaves = json.pollStateLeaves.map((leaf) => domainobjs_1.StateLeaf.fromJSON(leaf));
         poll.ballots = json.ballots.map((ballot) => domainobjs_1.Ballot.fromJSON(ballot));
-        poll.encPubKeys = json.encPubKeys.map((key) => domainobjs_1.PubKey.deserialize(key));
+        poll.voteCounts = json.voteCounts.map((voteCounts) => domainobjs_1.VoteCounts.fromJSON(voteCounts));
+        poll.encryptionPublicKeys = json.encryptionPublicKeys.map((key) => domainobjs_1.PublicKey.deserialize(key));
         poll.messages = json.messages.map((message) => domainobjs_1.Message.fromJSON(message));
-        poll.commands = json.commands.map((command) => domainobjs_1.PCommand.fromJSON(command));
+        poll.commands = json.commands.map((command) => domainobjs_1.VoteCommand.fromJSON(command));
         poll.tallyResult = json.results.map((result) => BigInt(result));
         poll.currentMessageBatchIndex = json.currentMessageBatchIndex;
-        poll.numBatchesProcessed = json.numBatchesProcessed;
+        poll.totalBatchesProcessed = json.totalBatchesProcessed;
         poll.chainHash = BigInt(json.chainHash);
         poll.batchHashes = json.batchHashes.map((batchHash) => BigInt(batchHash));
         poll.pollNullifiers = new Map(json.pollNullifiers.map((nullifier) => [BigInt(nullifier), true]));
         // copy maci state
-        poll.updatePoll(BigInt(json.numSignups));
+        poll.updatePoll(BigInt(json.totalSignups));
         return poll;
     }
 }