@maci-protocol/core 0.0.0-ci.98aa65d → 0.0.0-ci.9acdf3f

package/build/ts/Poll.js

@@ -27,9 +27,9 @@ class Poll {
         this.ballots = [];
         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.sbSalts = {};
@@ -38,7 +38,7 @@ class Poll {
         this.spentVoiceCreditSubtotalSalts = {};
         // For vote tallying
         this.tallyResult = [];
-        this.perVOSpentVoiceCredits = [];
+        this.perVoteOptionSpentVoiceCredits = [];
         this.numBatchesTallied = 0;
         this.totalSpentVoiceCredits = 0n;
         // message chain hash
@@ -48,7 +48,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 +56,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 +74,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 +86,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);
@@ -104,10 +103,10 @@ class Poll {
             });
             // 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);
             }
@@ -116,14 +115,14 @@ class Poll {
         /**
          * 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, qv = true) => {
             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 +135,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
@@ -171,7 +170,7 @@ class Poll {
                 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
@@ -181,17 +180,17 @@ class Poll {
                 // 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.genProof(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.genProof(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.genProof(voteOptionIndex);
                 // we return the data which is then to be used in the processMessage circuit
                 // to generate a proof of processing
                 return {
@@ -220,40 +219,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 +266,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 +284,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 +307,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.genProof(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,
@@ -390,7 +386,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 +405,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, qv);
+                        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,10 +446,10 @@ 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
@@ -471,24 +467,24 @@ 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.genProof(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.genProof(0).pathElements);
                                 }
                             }
                             else {
@@ -500,10 +496,10 @@ class Poll {
                                 // 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.genProof(0).pathElements);
                             }
                         }
                         else {
@@ -521,10 +517,10 @@ class Poll {
                     // 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.genProof(0).pathElements);
                 }
             }
             // store the data in the circuit inputs object
@@ -532,7 +528,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]);
                 }
             }
@@ -547,9 +543,9 @@ class Poll {
                 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,7 +555,7 @@ 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) {
                 this.maciStateRef.pollBeingProcessed = false;
@@ -576,33 +572,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 +608,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 +623,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,
@@ -678,12 +674,12 @@ 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.preVOSpentVoiceCreditsRootSalts[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 currentPerVOSpentVoiceCreditsCommitment = this.genPerVOSpentVoiceCreditsCommitment(currentPerVoteOptionSpentVoiceCreditsRootSalt, batchStartIndex, true);
             // generate a commitment to the current spent voice credits
             const currentSpentVoiceCreditsCommitment = this.genSpentVoiceCreditSubtotalCommitment(currentSpentVoiceCreditSubtotalSalt, batchStartIndex, true);
             // the current commitment for the first batch will be 0
@@ -702,7 +698,7 @@ class Poll {
                 ]);
             const ballots = [];
             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) {
@@ -718,7 +714,7 @@ class Poll {
                     // 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;
+                    this.perVoteOptionSpentVoiceCredits[j] += v * v;
                     // the total spent voice credits will be the sum of the squares of the votes
                     this.totalSpentVoiceCredits += v * v;
                 }
@@ -729,19 +725,19 @@ class Poll {
                 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)();
+            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.preVOSpentVoiceCreditsRootSalts[batchStartIndex] = newPerVOSpentVoiceCreditsRootSalt;
+            this.preVOSpentVoiceCreditsRootSalts[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, 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 per vote option spent voice credits commitment with the new salts and data
+            const newPerVOSpentVoiceCreditsCommitment = this.genPerVOSpentVoiceCreditsCommitment(newPerVoteOptionSpentVoiceCreditsRootSalt, batchStartIndex + batchSize, true);
             // generate the new tally commitment
             const newTallyCommitment = (0, crypto_1.hash3)([
                 newResultsCommitment,
@@ -760,7 +756,7 @@ class Poll {
                 ballotRoot,
                 sbSalt,
                 index: BigInt(batchStartIndex),
-                numSignUps: BigInt(this.numSignups),
+                totalSignups: BigInt(this.totalSignups),
                 sbCommitment,
                 currentTallyCommitment,
                 newTallyCommitment,
@@ -771,10 +767,10 @@ class Poll {
                 currentResultsRootSalt,
                 currentSpentVoiceCreditSubtotal,
                 currentSpentVoiceCreditSubtotalSalt,
-                currentPerVOSpentVoiceCredits,
-                currentPerVOSpentVoiceCreditsRootSalt,
+                currentPerVoteOptionSpentVoiceCredits,
+                currentPerVoteOptionSpentVoiceCreditsRootSalt,
                 newResultsRootSalt,
-                newPerVOSpentVoiceCreditsRootSalt,
+                newPerVoteOptionSpentVoiceCreditsRootSalt,
                 newSpentVoiceCreditSubtotalSalt,
             });
             this.numBatchesTallied += 1;
@@ -793,7 +789,7 @@ class Poll {
             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);
+            const currentResultsCommitment = (0, crypto_1.generateTreeCommitment)(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
@@ -828,13 +824,13 @@ class Poll {
                 ballots.push(emptyBallot);
             }
             // generate the new salts
-            const newResultsRootSalt = (0, crypto_1.genRandomSalt)();
-            const newSpentVoiceCreditSubtotalSalt = (0, crypto_1.genRandomSalt)();
+            const newResultsRootSalt = (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.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);
             // generate the new tally commitment
@@ -851,7 +847,7 @@ class Poll {
                 ballotRoot,
                 sbSalt,
                 index: BigInt(batchStartIndex),
-                numSignUps: BigInt(this.numSignups),
+                totalSignups: BigInt(this.totalSignups),
                 sbCommitment,
                 currentTallyCommitment,
                 newTallyCommitment,
@@ -911,7 +907,7 @@ class Poll {
                     leaves[j] += useQuadraticVoting ? v * v : v;
                 }
             }
-            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.
@@ -921,23 +917,24 @@ class Poll {
             const copied = new Poll(BigInt(this.pollEndTimestamp.toString()), this.coordinatorKeypair.copy(), {
                 intStateTreeDepth: Number(this.treeDepths.intStateTreeDepth),
                 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());
+            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());
             if (this.ballotTree) {
                 copied.ballotTree = this.ballotTree.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.perVoteOptionSpentVoiceCredits = this.perVoteOptionSpentVoiceCredits.map((x) => BigInt(x.toString()));
             copied.numBatchesProcessed = Number(this.numBatchesProcessed.toString());
             copied.numBatchesTallied = Number(this.numBatchesTallied.toString());
             copied.pollId = this.pollId;
@@ -959,34 +956,34 @@ class Poll {
                 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.intStateTreeDepth === poll.treeDepths.intStateTreeDepth &&
+                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,20 +994,20 @@ 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;
         this.pollEndTimestamp = pollEndTimestamp;
         this.coordinatorKeypair = coordinatorKeypair;
         this.treeDepths = treeDepths;
@@ -1022,12 +1019,11 @@ class Poll {
         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.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.ballots.push(this.emptyBallot);
@@ -1038,6 +1034,7 @@ class Poll {
      */
     toJSON() {
         return {
+            stateTreeDepth: Number(this.treeDepths.stateTreeDepth),
             pollEndTimestamp: this.pollEndTimestamp.toString(),
             treeDepths: this.treeDepths,
             batchSizes: this.batchSizes,
@@ -1046,13 +1043,13 @@ 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()),
+            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(),
+            totalSignups: this.totalSignups.toString(),
             chainHash: this.chainHash.toString(),
             pollNullifiers: [...this.pollNullifiers.keys()].map((nullifier) => nullifier.toString()),
             batchHashes: this.batchHashes.map((batchHash) => batchHash.toString()),
@@ -1069,9 +1066,9 @@ class Poll {
         // 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.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;
@@ -1079,7 +1076,7 @@ class Poll {
         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;
     }
 }