@maci-protocol/circuits 0.0.0-ci.a1bedc5 → 0.0.0-ci.a51dc13

package/circom/utils/non-qv/{stateLeafAndBallotTransformer.circom → StateLeafAndBallotTransformer.circom}

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // circomlib import
 include "./mux1.circom";
 // local import
-include "./messageValidator.circom";
+include "./MessageValidator.circom";
 
 /**
  * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
@@ -13,18 +13,18 @@ include "./messageValidator.circom";
  */
 template StateLeafAndBallotTransformerNonQv() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    var PACKED_COMMAND_LENGTH = 4;
 
     // Number of user sign-ups in the state tree.
-    signal input numSignUps;
+    signal input totalSignups;
     // Number of valid vote options for the poll.
     signal input voteOptions;
 
     // The following signals represents a state leaf (signed up user).
     // Public key.
-    signal input slPubKey[2];
+    signal input stateLeafPublicKey[2];
     // Current voice credit balance.
-    signal input slVoiceCreditBalance;
+    signal input stateLeafVoiceCreditBalance;
 
     // The following signals represents a ballot.
     // Nonce.
@@ -34,29 +34,29 @@ template StateLeafAndBallotTransformerNonQv() {
 
     // The following signals represents a command.
     // State index of the user.
-    signal input cmdStateIndex;
+    signal input commandStateIndex;
     // Public key of the user.
-    signal input cmdNewPubKey[2];
+    signal input commandPublicKey[2];
     // Vote option index.
-    signal input cmdVoteOptionIndex;
+    signal input commandVoteOptionIndex;
     // Vote weight.
-    signal input cmdNewVoteWeight;
+    signal input commandNewVoteWeight;
     // Nonce.
-    signal input cmdNonce;
+    signal input commandNonce;
     // Poll identifier.
-    signal input cmdPollId;
+    signal input commandPollId;
     // Salt.
-    signal input cmdSalt;
-    // ECDSA signature of the command (R part).
-    signal input cmdSigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input cmdSigS;
+    signal input commandSalt;
+    // EdDSA signature of the command (R part).
+    signal input commandSignaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input commandSignatureScalar;
     // Packed command. 
     // nb. we are assuming that the packedCommand is always valid.
-    signal input packedCommand[PACKED_CMD_LENGTH];
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
 
     // New state leaf (if the command is valid).
-    signal output newSlPubKey[2];
+    signal output newStateLeafPublicKey[2];
     // New ballot (if the command is valid).
     signal output newBallotNonce;
     
@@ -68,38 +68,38 @@ template StateLeafAndBallotTransformerNonQv() {
     signal output isVoteOptionIndexValid;
 
     // Check if the command / message is valid.
-    var (computedMessageValidator, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
-        cmdStateIndex,
-        numSignUps,
-        cmdVoteOptionIndex,
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidatorNonQv()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
         voteOptions,
         ballotNonce,
-        cmdNonce,
+        commandNonce,
         packedCommand,
-        slPubKey,
-        cmdSigR8,
-        cmdSigS,
-        slVoiceCreditBalance,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
         ballotCurrentVotesForOption,
-        cmdNewVoteWeight
+        commandNewVoteWeight
     );
 
     // If the message is valid then we swap out the public key.
     // This means using a Mux1() for publicKey[0] and another one
     // for publicKey[1].
-    var computedNewSlPubKey0Mux = Mux1()([slPubKey[0], cmdNewPubKey[0]], computedMessageValidator);
-    var computedNewSlPubKey1Mux = Mux1()([slPubKey[1], cmdNewPubKey[1]], computedMessageValidator);
+    var computedNewstateLeafPublicKey0Mux = Mux1()([stateLeafPublicKey[0], commandPublicKey[0]], computedIsValid);
+    var computedNewstateLeafPublicKey1Mux = Mux1()([stateLeafPublicKey[1], commandPublicKey[1]], computedIsValid);
 
-    newSlPubKey[0] <== computedNewSlPubKey0Mux;
-    newSlPubKey[1] <== computedNewSlPubKey1Mux;
+    newStateLeafPublicKey[0] <== computedNewstateLeafPublicKey0Mux;
+    newStateLeafPublicKey[1] <== computedNewstateLeafPublicKey1Mux;
 
     // If the message is valid, then we swap out the ballot nonce
     // using a Mux1().
-    var computedNewBallotNonceMux = Mux1()([ballotNonce, cmdNonce], computedMessageValidator);
+    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedIsValid);
 
     newBallotNonce <== computedNewBallotNonceMux;
 
-    isValid <== computedMessageValidator;
+    isValid <== computedIsValid;
     isStateLeafIndexValid <== computedIsStateLeafIndexValid;
     isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
 }

package/circom/utils/qv/{messageValidator.circom → MessageValidator.circom}

@@ -11,12 +11,14 @@ include "../VerifySignature.circom";
  */
 template MessageValidator() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    var PACKED_COMMAND_LENGTH = 4;
+    // Number of checks to be performed.
+    var TOTAL_CHECKS = 6;
 
     // State index of the user.
     signal input stateTreeIndex;
     // Number of user sign-ups in the state tree.
-    signal input numSignUps;
+    signal input totalSignups;
     // Vote option index.
     signal input voteOptionIndex;
     // Number of valid vote options for the poll.
@@ -24,15 +26,15 @@ template MessageValidator() {
     // Ballot nonce.
     signal input originalNonce;
     // Command nonce.
-    signal input nonce;
+    signal input commandNonce;
     // Packed command.
-    signal input cmd[PACKED_CMD_LENGTH];
+    signal input command[PACKED_COMMAND_LENGTH];
     // Public key of the state leaf (user).
     signal input publicKey[2];
-    // ECDSA signature of the command (R part).
-    signal input sigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input sigS;
+    // EdDSA signature of the command (R part).
+    signal input signaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input signatureScalar;
     // State leaf current voice credit balance.
     signal input currentVoiceCreditBalance;
     // Current number of votes for specific option. 
@@ -48,19 +50,19 @@ template MessageValidator() {
     signal output isVoteOptionIndexValid;
 
     // Check (1) - The state leaf index must be valid.
-    // The check ensure that the stateTreeIndex < numSignUps as first validation.
+    // The check ensure that the stateTreeIndex < totalSignups as first validation.
     // Must be < because the stateTreeIndex is 0-based. Zero is for blank state leaf
     // while 1 is for the first actual user.
-    var computedIsStateLeafIndexValid = SafeLessThan(252)([stateTreeIndex, numSignUps]);
+    var computedIsStateLeafIndexValid = SafeLessThan(252)([stateTreeIndex, totalSignups]);
 
     // Check (2) - The vote option index must be less than the number of valid vote options (0 indexed).
     var computedIsVoteOptionIndexValid = SafeLessThan(252)([voteOptionIndex, voteOptions]);
 
     // Check (3) - The nonce must be correct.    
-    var computedIsNonceValid = IsEqual()([originalNonce + 1, nonce]);
+    var computedIsNonceValid = IsEqual()([originalNonce + 1, commandNonce]);
 
     // Check (4) - The signature must be correct.    
-    var computedIsSignatureValid = VerifySignature()(publicKey, sigR8, sigS, cmd);
+    var computedIsSignatureValid = VerifySignature()(publicKey, signaturePoint, signatureScalar, command);
 
     // Check (5) - There must be sufficient voice credits.
     // The check ensure that the voteWeight is < sqrt(field size)
@@ -79,7 +81,7 @@ template MessageValidator() {
     // When all six checks are correct, then isValid = 1.
     var computedIsUpdateValid = IsEqual()(
         [
-            6,
+            TOTAL_CHECKS,
             computedIsSignatureValid + 
             computedAreVoiceCreditsSufficient +
             computedIsVoteWeightValid +

package/circom/utils/qv/{stateLeafAndBallotTransformer.circom → StateLeafAndBallotTransformer.circom}

@@ -3,7 +3,7 @@ pragma circom 2.0.0;
 // circomlib import
 include "./mux1.circom";
 // local import
-include "./messageValidator.circom";
+include "./MessageValidator.circom";
 
 /**
  * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
@@ -13,18 +13,18 @@ include "./messageValidator.circom";
  */
 template StateLeafAndBallotTransformer() {
     // Length of the packed command.
-    var PACKED_CMD_LENGTH = 4;
+    var PACKED_COMMAND_LENGTH = 4;
 
     // Number of user sign-ups in the state tree.
-    signal input numSignUps;
+    signal input totalSignups;
     // Number of valid vote options for the poll.
     signal input voteOptions;
 
     // The following signals represents a state leaf (signed up user).
     // Public key.
-    signal input slPubKey[2];
+    signal input stateLeafPublicKey[2];
     // Current voice credit balance.
-    signal input slVoiceCreditBalance;
+    signal input stateLeafVoiceCreditBalance;
 
     // The following signals represents a ballot.
     // Nonce.
@@ -34,29 +34,29 @@ template StateLeafAndBallotTransformer() {
 
     // The following signals represents a command.
     // State index of the user.
-    signal input cmdStateIndex;
+    signal input commandStateIndex;
     // Public key of the user.
-    signal input cmdNewPubKey[2];
+    signal input commandPublicKey[2];
     // Vote option index.
-    signal input cmdVoteOptionIndex;
+    signal input commandVoteOptionIndex;
     // Vote weight.
-    signal input cmdNewVoteWeight;
+    signal input commandNewVoteWeight;
     // Nonce.
-    signal input cmdNonce;
+    signal input commandNonce;
     // Poll identifier.
-    signal input cmdPollId;
+    signal input commandPollId;
     // Salt.
-    signal input cmdSalt;
-    // ECDSA signature of the command (R part).
-    signal input cmdSigR8[2];
-    // ECDSA signature of the command (S part).
-    signal input cmdSigS;
+    signal input commandSalt;
+    // EdDSA signature of the command (R part).
+    signal input commandSignaturePoint[2];
+    // EdDSA signature of the command (S part).
+    signal input commandSignatureScalar;
     // Packed command. 
     // nb. we are assuming that the packedCommand is always valid.
-    signal input packedCommand[PACKED_CMD_LENGTH];
+    signal input packedCommand[PACKED_COMMAND_LENGTH];
 
     // New state leaf (if the command is valid).
-    signal output newSlPubKey[2];
+    signal output newStateLeafPublicKey[2];
     // New ballot (if the command is valid).
     signal output newBallotNonce;
     
@@ -68,38 +68,38 @@ template StateLeafAndBallotTransformer() {
     signal output isVoteOptionIndexValid;
 
     // Check if the command / message is valid.
-    var (computedMessageValidator, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidator()(
-        cmdStateIndex,
-        numSignUps,
-        cmdVoteOptionIndex,
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidator()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
         voteOptions,
         ballotNonce,
-        cmdNonce,
+        commandNonce,
         packedCommand,
-        slPubKey,
-        cmdSigR8,
-        cmdSigS,
-        slVoiceCreditBalance,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
         ballotCurrentVotesForOption,
-        cmdNewVoteWeight
+        commandNewVoteWeight
     );
 
     // If the message is valid then we swap out the public key.
     // This means using a Mux1() for publicKey[0] and another one
     // for publicKey[1].
-    var computedNewSlPubKey0Mux = Mux1()([slPubKey[0], cmdNewPubKey[0]], computedMessageValidator);
-    var computedNewSlPubKey1Mux = Mux1()([slPubKey[1], cmdNewPubKey[1]], computedMessageValidator);
+    var computedNewstateLeafPublicKey0Mux = Mux1()([stateLeafPublicKey[0], commandPublicKey[0]], computedIsValid);
+    var computedNewstateLeafPublicKey1Mux = Mux1()([stateLeafPublicKey[1], commandPublicKey[1]], computedIsValid);
 
-    newSlPubKey[0] <== computedNewSlPubKey0Mux;
-    newSlPubKey[1] <== computedNewSlPubKey1Mux;
+    newStateLeafPublicKey[0] <== computedNewstateLeafPublicKey0Mux;
+    newStateLeafPublicKey[1] <== computedNewstateLeafPublicKey1Mux;
 
     // If the message is valid, then we swap out the ballot nonce
     // using a Mux1().
-    var computedNewBallotNonceMux = Mux1()([ballotNonce, cmdNonce], computedMessageValidator);
+    var computedNewBallotNonceMux = Mux1()([ballotNonce, commandNonce], computedIsValid);
 
     newBallotNonce <== computedNewBallotNonceMux;
 
-    isValid <== computedMessageValidator;
+    isValid <== computedIsValid;
     isStateLeafIndexValid <== computedIsStateLeafIndexValid;
     isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
 }

package/circom/utils/trees/LeafExists.circom

@@ -13,13 +13,13 @@ template LeafExists(levels) {
   // The elements along the path needed for the inclusion proof.
   signal input path_elements[levels][1];
   // The indices indicating the path taken through the tree for the leaf.
-  signal input path_index[levels];
+  signal input path_indices[levels];
   // The root of the Merkle tree, against which the inclusion is verified.
   signal input root;
 
   var computedMerkleRoot = MerkleTreeInclusionProof(levels)(
     leaf,
-    path_index,
+    path_indices,
     path_elements
   );
 

package/circom/utils/trees/{MerkleGeneratePathIndices.circom → MerklePathIndicesGenerator.circom}

@@ -10,7 +10,7 @@ include "../CalculateTotal.circom";
  * Given a node index within an IMT and the total tree levels, it outputs the path indices leading to that node.
  * The template handles the modulo and division operations to break down the tree index into its constituent path indices.
  */
-template MerkleGeneratePathIndices(levels) {
+template MerklePathIndicesGenerator(levels) {
     // The base used for the modulo and division operations, set to 2 for binary trees.
     var BASE = 2;
 

package/circom/utils/trees/MerkleTreeInclusionProof.circom

@@ -12,7 +12,7 @@ template MerkleTreeInclusionProof(n_levels) {
     // The leaf node from which the Merkle root is calculated.
     signal input leaf;
     // Indices indicating left or right child for each level of the tree.
-    signal input path_index[n_levels];
+    signal input path_indices[n_levels];
     // Sibling node values required to compute the hash at each level.
     signal input path_elements[n_levels][1];
 
@@ -25,8 +25,8 @@ template MerkleTreeInclusionProof(n_levels) {
     levelHashes[0] <== leaf;
 
     for (var i = 0; i < n_levels; i++) {
-        // Validate path_index to be either 0 or 1, ensuring no other values.
-        path_index[i] * (1 - path_index[i]) === 0;
+        // Validate path_indices to be either 0 or 1, ensuring no other values.
+        path_indices[i] * (1 - path_indices[i]) === 0;
 
         // Configure the multiplexer based on the path index for the current level.
         var multiplexer[2][2] = [
@@ -36,7 +36,7 @@ template MerkleTreeInclusionProof(n_levels) {
 
         var multiplexerResult[2] = MultiMux1(2)(
             multiplexer,
-            path_index[i]
+            path_indices[i]
         );
 
         var computedLevelHash = PoseidonHasher(2)([multiplexerResult[0], multiplexerResult[1]]);

package/circom/utils/trees/QuinaryCheckRoot.circom

@@ -0,0 +1,54 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../PoseidonHasher.circom";
+
+/**
+ * Computes the root of a quintary Merkle tree given a list of leaves.
+ * This template constructs a Merkle tree with each node having 5 children (quintary)
+ * and computes the root by hashing with Poseidon the leaves and intermediate nodes in the given order.
+ * The computation is performed by first hashing groups of 5 leaves to form the bottom layer of nodes,
+ * then recursively hashing groups of these nodes to form the next layer, and so on, until the root is computed.
+ */
+template QuinaryCheckRoot(levels) {
+    var LEAVES_PER_NODE = 5;
+    var totalLeaves = LEAVES_PER_NODE ** levels;
+    var numLeafHashers = LEAVES_PER_NODE ** (levels - 1); 
+
+    signal input leaves[totalLeaves];
+    signal output root;
+
+    // Determine the total number of hashers.
+    var numHashers = 0;
+    for (var i = 0; i < levels; i++) {
+        numHashers += LEAVES_PER_NODE ** i;
+    }
+
+    var computedHashers[numHashers]; 
+
+    // Initialize hashers for the leaves.
+    for (var i = 0; i < numLeafHashers; i++) {
+        computedHashers[i] = PoseidonHasher(5)([
+            leaves[i * LEAVES_PER_NODE + 0],
+            leaves[i * LEAVES_PER_NODE + 1],
+            leaves[i * LEAVES_PER_NODE + 2],
+            leaves[i * LEAVES_PER_NODE + 3],
+            leaves[i * LEAVES_PER_NODE + 4]
+        ]);
+    }
+
+    // Initialize hashers for intermediate nodes and compute the root.
+    var k = 0;
+    for (var i = numLeafHashers; i < numHashers; i++) {
+        computedHashers[i] = PoseidonHasher(5)([
+            computedHashers[k * LEAVES_PER_NODE + 0],
+            computedHashers[k * LEAVES_PER_NODE + 1],
+            computedHashers[k * LEAVES_PER_NODE + 2],
+            computedHashers[k * LEAVES_PER_NODE + 3],
+            computedHashers[k * LEAVES_PER_NODE + 4]
+        ]);
+        k++;
+    }
+
+    root <== computedHashers[numHashers - 1]; 
+}

package/circom/utils/trees/QuinaryGeneratePathIndices.circom

@@ -0,0 +1,44 @@
+pragma circom 2.0.0;
+
+// zk-kit import
+include "./safe-comparators.circom";
+// local imports
+include "../CalculateTotal.circom";
+
+/**
+ * Calculates the path indices required for Merkle proof verifications (e.g., QuinaryTreeInclusionProof, QuinaryLeafExists). 
+ * Given a node index within an IQT and the total tree levels, it outputs the path indices leading to that node.
+ * The template handles the modulo and division operations to break down the tree index into its constituent path indices.
+ * e.g., if the index is 30 and the number of levels is 4, the output should be [0, 1, 1, 0].
+ */
+template QuinaryGeneratePathIndices(levels) {
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+
+    // The index within the tree
+    signal input index;
+    // The generated path indices leading to the node of the provided index
+    signal output out[levels];
+
+    var indexModulus = index;
+    var computedResults[levels];
+
+    for (var i = 0; i < levels; i++) {
+        // circom's best practices suggests to avoid using <-- unless you
+        // are aware of what's going on. This is the only way to do modulo operation.
+        out[i] <-- indexModulus % LEAVES_PER_NODE;
+        indexModulus = indexModulus \ LEAVES_PER_NODE;
+
+        // Check that each output element is less than the base.
+        var computedIsOutputElementLessThanBase = SafeLessThan(3)([out[i], LEAVES_PER_NODE]);
+        computedIsOutputElementLessThanBase === 1;
+
+        // Re-compute the total sum.
+        computedResults[i] = out[i] * (LEAVES_PER_NODE ** i);
+    }
+    
+    // Check that the total sum matches the index.
+    var computedCalculateTotal = CalculateTotal(levels)(computedResults);
+
+    computedCalculateTotal === index;
+}

package/circom/utils/trees/QuinaryLeafExists.circom

@@ -0,0 +1,30 @@
+pragma circom 2.0.0;
+
+// local imports
+include "./QuinaryTreeInclusionProof.circom";
+
+/**
+ * Verifies if a given leaf exists within an IQT.
+ * Takes a leaf, its path to the root (specified by indices and path elements),
+ * and the root itself, to verify the leaf's inclusion within the tree.
+ */
+template QuinaryLeafExists(levels){
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+    // Number of leaves per path level (excluding the leaf itself)
+    var LEAVES_PER_PATH_LEVEL = LEAVES_PER_NODE - 1;
+
+    // The leaf to check for inclusion
+    signal input leaf;
+    // The path indices at each level of the tree
+    signal input path_indices[levels];
+    // The sibling nodes at each level of the tree
+    signal input path_elements[levels][LEAVES_PER_PATH_LEVEL];
+    // The computed root of the tree
+    signal input root;
+
+    // Verify the Merkle path.
+    var computedRoot = QuinaryTreeInclusionProof(levels)(leaf, path_indices, path_elements);
+
+    root === computedRoot;
+}

package/circom/utils/trees/QuinarySelector.circom

@@ -0,0 +1,42 @@
+pragma circom 2.0.0;
+
+// zk-kit import
+include "./safe-comparators.circom";
+// local imports
+include "../CalculateTotal.circom";
+
+/**
+ * Selects an item from a list based on the given index.
+ * It verifies the index is within the valid range and then iterates over the inputs to find the match.
+ * For each item, it checks if its position equals the given index and if so, multiplies the item 
+ * by the result of the equality check, effectively selecting it.
+ * The sum of these results yields the selected item, ensuring only the item at the specified index be the output.
+ *
+ * nb. The number of items must be less than 8, and the index must be less than the number of items.
+ */
+template QuinarySelector(choices) {
+    // The input elements to select from.
+    signal input in[choices];
+    // The index of the element to select
+    signal input index;
+    // The selected total sum of the elements.
+    signal output out;
+    
+    // Ensure that index < choices.
+    var computedIndex = SafeLessThan(3)([index, choices]);
+    computedIndex === 1;
+
+    // Initialize an array to hold the results of equality checks.
+    var computedResults[choices];
+
+    // For each item, check whether its index equals the input index.
+    // The result is multiplied by the corresponding input value.
+    for (var i = 0; i < choices; i++) {
+        var computedIsIndexEqual = IsEqual()([i, index]);
+
+        computedResults[i] = computedIsIndexEqual * in[i];
+    }
+
+    // Calculate the total sum of the results array.
+    out <== CalculateTotal(choices)(computedResults);
+}

package/circom/utils/trees/QuinaryTreeInclusionProof.circom

@@ -0,0 +1,55 @@
+pragma circom 2.0.0;
+
+// local imports
+include "../PoseidonHasher.circom";
+include "./Splicer.circom";
+
+/**
+ * Computes the root of an IQT given a leaf, its path, and sibling nodes at each level of the tree. 
+ * It iteratively incorporates the leaf or the hash from the previous level with sibling nodes using 
+ * the Splicer to place the leaf or hash at the correct position based on path_indices. 
+ * Then, it hashes these values together with PoseidonHasher to move up the tree. 
+ * This process repeats for each level (levels) of the tree, culminating in the computation of the tree's root.
+ */
+template QuinaryTreeInclusionProof(levels) {
+    // The number of leaves per node (tree arity)
+    var LEAVES_PER_NODE = 5;
+    // Number of leaves per path level (excluding the leaf itself)
+    var LEAVES_PER_PATH_LEVEL = LEAVES_PER_NODE - 1;
+
+    // The leaf to check for inclusion
+    signal input leaf;
+    // The path indices at each level of the tree
+    signal input path_indices[levels];
+    // The sibling nodes at each level of the tree
+    signal input path_elements[levels][LEAVES_PER_PATH_LEVEL];
+    // The computed root of the tree
+    signal output root;
+
+    var currentLeaf = leaf;
+
+    // Iteratively hash each level of path_elements with the leaf or previous hash
+    for (var i = 0; i < levels; i++) {
+        var elements[LEAVES_PER_PATH_LEVEL];
+
+        for (var j = 0; j < LEAVES_PER_PATH_LEVEL; j++) {
+            elements[j] = path_elements[i][j];
+        }
+
+        var computedSplicedLeaf[LEAVES_PER_NODE] = Splicer(LEAVES_PER_PATH_LEVEL)(
+            elements, 
+            currentLeaf, 
+            path_indices[i]
+        );
+
+        currentLeaf = PoseidonHasher(5)([
+            computedSplicedLeaf[0],
+            computedSplicedLeaf[1],
+            computedSplicedLeaf[2],
+            computedSplicedLeaf[3],
+            computedSplicedLeaf[4]
+        ]);
+    }
+
+    root <== currentLeaf;
+}