@maci-protocol/circuits 0.0.0-ci.00107eb

package/circom/utils/qv/ResultCommitmentVerifier.circom

@@ -0,0 +1,107 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./comparators.circom";
+// local imports
+include "../trees/QuinaryCheckRoot.circom";
+include "../PoseidonHasher.circom";
+
+/** 
+ * Performs verifications and computations related to current voting results. 
+ * Also, computes and outputs a commitment to the new results.
+ * This template supports the Quadratic Voting (QV).
+ */
+template ResultCommitmentVerifierQv(voteOptionTreeDepth) {
+    // Number of children per node in the tree, defining the tree's branching factor.
+    var TREE_ARITY = 5;
+    // Number of voting options available, determined by the depth of the vote option tree.
+    var totalVoteOptions = TREE_ARITY ** voteOptionTreeDepth;
+
+    // Equal to 1 if this is the first batch, otherwise 0.
+    signal input isFirstBatch;
+    // Commitment to the current tally before this batch.
+    signal input currentTallyCommitment;
+    // Commitment to the new tally after processing this batch.
+    signal input newTallyCommitment;
+
+    // Current results for each vote option.
+    signal input currentResults[totalVoteOptions];
+    // Salt for the root of the current results.
+    signal input currentResultsRootSalt;
+
+    // New results for each vote option.
+    signal input newResults[totalVoteOptions];
+    // Salt for the root of the new results.
+    signal input newResultsRootSalt;
+
+    // Total voice credits spent so far.
+    signal input currentSpentVoiceCreditSubtotal;
+    // Salt for the total spent voice credits.
+    signal input currentSpentVoiceCreditSubtotalSalt;
+
+    // Total new voice credits spent.
+    signal input newSpentVoiceCreditSubtotal;
+    // Salt for the new total spent voice credits.
+    signal input newSpentVoiceCreditSubtotalSalt;
+
+    // Spent voice credits per vote option.
+    signal input currentPerVoteOptionSpentVoiceCredits[totalVoteOptions];
+    // Salt for the root of spent credits per option.
+    signal input currentPerVoteOptionSpentVoiceCreditsRootSalt;
+
+    // New spent voice credits per vote option.
+    signal input newPerVoteOptionSpentVoiceCredits[totalVoteOptions];
+    // Salt for the root of new spent credits per option.
+    signal input newPerVoteOptionSpentVoiceCreditsRootSalt;
+
+    // Compute the commitment to the current results.
+    var computedCurrentResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(currentResults);
+
+    // Verify currentResultsCommitmentHash.
+    var computedCurrentResultsCommitment = PoseidonHasher(2)([computedCurrentResultsRoot, currentResultsRootSalt]);
+
+    // Compute the commitment to the current spent voice credits.
+    var computedCurrentSpentVoiceCreditsCommitment = PoseidonHasher(2)([currentSpentVoiceCreditSubtotal, currentSpentVoiceCreditSubtotalSalt]);
+
+    // Compute the root of the spent voice credits per vote option.
+    var computedCurrentPerVoteOptionSpentVoiceCreditsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(currentPerVoteOptionSpentVoiceCredits);
+    var computedCurrentPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedCurrentPerVoteOptionSpentVoiceCreditsRoot, currentPerVoteOptionSpentVoiceCreditsRootSalt]);
+
+    // Commit to the current tally.
+    var computedCurrentTallyCommitment = PoseidonHasher(3)([
+        computedCurrentResultsCommitment, 
+        computedCurrentSpentVoiceCreditsCommitment, 
+        computedCurrentPerVoteOptionSpentVoiceCreditsCommitment
+    ]);
+
+    // Check if the current tally commitment is correct only if this is not the first batch.
+    // computedIsZero.out is 1 if this is not the first batch.
+    // computedIsZero.out is 0 if this is the first batch.
+    var computedIsZero = IsZero()(isFirstBatch);
+
+    // isFirstCommitment is 0 if this is the first batch, currentTallyCommitment should be 0 if this is the first batch.
+    // isFirstCommitment is 1 if this is not the first batch, currentTallyCommitment should not be 0 if this is the first batch.
+    signal isFirstCommitment;
+    isFirstCommitment <== computedIsZero * computedCurrentTallyCommitment;
+    isFirstCommitment === currentTallyCommitment;
+
+    // Compute the root of the new results.
+    var computedNewResultsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(newResults);
+    var computedNewResultsCommitment = PoseidonHasher(2)([computedNewResultsRoot, newResultsRootSalt]);
+
+    // Compute the commitment to the new spent voice credits value.
+    var computedNewSpentVoiceCreditsCommitment = PoseidonHasher(2)([newSpentVoiceCreditSubtotal, newSpentVoiceCreditSubtotalSalt]);
+
+    // Compute the root of the spent voice credits per vote option.
+    var computedNewPerVoteOptionSpentVoiceCreditsRoot = QuinaryCheckRoot(voteOptionTreeDepth)(newPerVoteOptionSpentVoiceCredits);
+    var computedNewPerVoteOptionSpentVoiceCreditsCommitment = PoseidonHasher(2)([computedNewPerVoteOptionSpentVoiceCreditsRoot, newPerVoteOptionSpentVoiceCreditsRootSalt]);
+
+    // Commit to the new tally.
+    var computedNewTallyCommitment = PoseidonHasher(3)([
+        computedNewResultsCommitment,
+        computedNewSpentVoiceCreditsCommitment,
+        computedNewPerVoteOptionSpentVoiceCreditsCommitment
+    ]);
+    
+    computedNewTallyCommitment === newTallyCommitment;
+}

package/circom/utils/qv/StateLeafAndBallotTransformer.circom

@@ -0,0 +1,105 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local import
+include "./MessageValidator.circom";
+
+/**
+ * Processes a command by verifying its validity and updates the state leaf and ballot accordingly. 
+ * If the message is correct, updates the public key in the state leaf and the nonce 
+ * in the ballot using multiplexer components.
+ * This template supports the Quadratic Voting (QV).
+ */
+template StateLeafAndBallotTransformer() {
+    // Length of the packed command.
+    var PACKED_COMMAND_LENGTH = 4;
+
+    // Number of user sign-ups in the state tree.
+    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 stateLeafPublicKey[2];
+    // Current voice credit balance.
+    signal input stateLeafVoiceCreditBalance;
+
+    // The following signals represents a ballot.
+    // Nonce.
+    signal input ballotNonce;
+    // Current number of votes for specific option. 
+    signal input ballotCurrentVotesForOption;
+
+    // The following signals represents a command.
+    // State index of the user.
+    signal input commandStateIndex;
+    // Public key of the user.
+    signal input commandPublicKey[2];
+    // Vote option index.
+    signal input commandVoteOptionIndex;
+    // Vote weight.
+    signal input commandNewVoteWeight;
+    // Nonce.
+    signal input commandNonce;
+    // Poll identifier.
+    signal input commandPollId;
+    // Salt.
+    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_COMMAND_LENGTH];
+
+    // New state leaf (if the command is valid).
+    signal output newStateLeafPublicKey[2];
+    // New ballot (if the command is valid).
+    signal output newBallotNonce;
+    
+    // True when the command is valid; otherwise false.
+    signal output isValid;
+    // True if the state leaf index is valid
+    signal output isStateLeafIndexValid;
+    // True if the vote option index is valid
+    signal output isVoteOptionIndexValid;
+
+    // Check if the command / message is valid.
+    var (computedIsValid, computedIsStateLeafIndexValid, computedIsVoteOptionIndexValid) = MessageValidator()(
+        commandStateIndex,
+        totalSignups,
+        commandVoteOptionIndex,
+        voteOptions,
+        ballotNonce,
+        commandNonce,
+        packedCommand,
+        stateLeafPublicKey,
+        commandSignaturePoint,
+        commandSignatureScalar,
+        stateLeafVoiceCreditBalance,
+        ballotCurrentVotesForOption,
+        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 computedNewstateLeafPublicKey0Mux = Mux1()([stateLeafPublicKey[0], commandPublicKey[0]], computedIsValid);
+    var computedNewstateLeafPublicKey1Mux = Mux1()([stateLeafPublicKey[1], commandPublicKey[1]], computedIsValid);
+
+    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, commandNonce], computedIsValid);
+
+    newBallotNonce <== computedNewBallotNonceMux;
+
+    isValid <== computedIsValid;
+    isStateLeafIndexValid <== computedIsStateLeafIndexValid;
+    isVoteOptionIndexValid <== computedIsVoteOptionIndexValid;
+}

package/circom/utils/trees/BinaryMerkleRoot.circom

@@ -0,0 +1,65 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+include "./comparators.circom";
+// local import
+include "../PoseidonHasher.circom";
+
+// @note taken from @zk-kit/circuits
+// if used directly in MessageProcessor circom complains about duplicated
+// templates (Ark, Poseidon, etc.)
+// This circuit is designed to calculate the root of a binary Merkle
+// tree given a leaf, its depth, and the necessary sibling
+// information (aka proof of membership).
+// A circuit is designed without the capability to iterate through
+// a dynamic array. To address this, a parameter with the static maximum
+// tree depth is defined (i.e. 'MAX_DEPTH'). And additionally, the circuit
+// receives a dynamic depth as an input, which is utilized in calculating the
+// true root of the Merkle tree. The actual depth of the Merkle tree
+// may be equal to or less than the static maximum depth.
+// NOTE: This circuit will successfully verify `out = 0` for `depth > MAX_DEPTH`.
+// Make sure to enforce `depth <= MAX_DEPTH` outside the circuit.
+template BinaryMerkleRoot(MAX_DEPTH) {
+    // The leaf node of the Merkle tree.
+    signal input leaf;
+    // The depth of the Merkle tree.
+    signal input depth;
+    // The index of the leaf node in the Merkle tree.
+    signal input index;
+    // The sibling nodes of the leaf node in the Merkle tree.
+    signal input siblings[MAX_DEPTH][1];
+
+    // The output of the Merkle tree root.
+    signal output out;
+
+    // The indices of the leaf node in the Merkle tree.
+    signal indices[MAX_DEPTH] <== Num2Bits(MAX_DEPTH)(index);
+
+    signal nodes[MAX_DEPTH + 1];
+    nodes[0] <== leaf;
+
+    signal roots[MAX_DEPTH];
+    var root = 0;
+
+    for (var i = 0; i < MAX_DEPTH; i++) {
+        var isDepth = IsEqual()([depth, i]);
+
+        roots[i] <== isDepth * nodes[i];
+
+        root += roots[i];
+
+        var c[2][2] = [
+            [nodes[i], siblings[i][0]],
+            [siblings[i][0], nodes[i]]
+        ];
+        
+        var childNodes[2] = MultiMux1(2)(c, indices[i]);
+
+        nodes[i + 1] <== PoseidonHasher(2)(childNodes);
+    }
+
+    var isDepth = IsEqual()([depth, MAX_DEPTH]);
+
+    out <== root + isDepth * nodes[MAX_DEPTH];
+} 

package/circom/utils/trees/CheckRoot.circom

@@ -0,0 +1,49 @@
+pragma circom 2.0.0;
+
+// local import
+include "../PoseidonHasher.circom";
+
+/**
+ * Verifies the correct construction of a Merkle tree from a set of leaves.
+ * Given a Merkle root and a list of leaves, check if the root is the
+ * correct result of inserting all the leaves into the tree (in the given order).
+ */
+template CheckRoot(levels) {
+    // The total number of leaves in the Merkle tree, calculated as 2 to the power of `levels`.
+    var TOTAL_LEVELS = 2 ** levels;
+    // The number of first-level hashers needed, equal to half the total leaves, as each hasher combines two leaves.
+    var LEAF_HASHERS = TOTAL_LEVELS / 2;
+    // The number of intermediate hashers, one less than the number of leaf hashers, 
+    // as each level of hashing reduces the number of hash elements by about half.
+    var INTERMEDIATE_HASHERS = LEAF_HASHERS - 1;
+    
+    // Array of leaf values input to the circuit.
+    signal input leaves[TOTAL_LEVELS];
+
+    // Output signal for the Merkle root that results from hashing all the input leaves.
+    signal output root;
+
+    // Total number of hashers used in constructing the tree, one less than the total number of leaves,
+    // since each level of the tree combines two elements into one.
+    var hashersLength = TOTAL_LEVELS - 1;
+    var computedLevelHashers[hashersLength];
+
+    // Initialize hashers for the leaves, each taking two adjacent leaves as inputs.
+    for (var i = 0; i < LEAF_HASHERS; i++){
+        computedLevelHashers[i] = PoseidonHasher(2)([leaves[i * 2], leaves[i * 2 + 1]]);
+    }
+
+    // Initialize hashers for intermediate levels, each taking the outputs of two hashers from the previous level.
+    var index = 0;
+
+    for (var i = LEAF_HASHERS; i < LEAF_HASHERS + INTERMEDIATE_HASHERS; i++) {
+        computedLevelHashers[i] = PoseidonHasher(2)([
+            computedLevelHashers[index * 2],
+            computedLevelHashers[index * 2 + 1]
+        ]);
+        index++;
+    }
+
+    // Connect the output of the final hasher in the array to the root output signal.
+    root <== computedLevelHashers[hashersLength - 1];
+} 

package/circom/utils/trees/LeafExists.circom

@@ -0,0 +1,27 @@
+pragma circom 2.0.0;
+
+// local import
+include "./MerkleTreeInclusionProof.circom";
+
+/**
+ * Ensures that a leaf exists within a Merkle tree with a given root.
+ */
+template LeafExists(levels) {
+  // The leaf whose existence within the tree is being verified.
+  signal input leaf;
+
+  // 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_indices[levels];
+  // The root of the Merkle tree, against which the inclusion is verified.
+  signal input root;
+
+  var computedMerkleRoot = MerkleTreeInclusionProof(levels)(
+    leaf,
+    path_indices,
+    path_elements
+  );
+
+  root === computedMerkleRoot;
+}

package/circom/utils/trees/MerkleTreeInclusionProof.circom

@@ -0,0 +1,50 @@
+pragma circom 2.0.0;
+
+// circomlib import
+include "./mux1.circom";
+// local import
+include "../PoseidonHasher.circom";
+
+/**
+ * Recomputes a Merkle root from a given leaf and its path in a Merkle tree.
+ */
+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_indices[n_levels];
+    // Sibling node values required to compute the hash at each level.
+    signal input path_elements[n_levels][1];
+
+    // The merkle root.
+    signal output root;
+
+     // Stores the hash at each level starting from the leaf to the root.
+    signal levelHashes[n_levels + 1];
+    // Initialize the first level with the given leaf.
+    levelHashes[0] <== leaf;
+
+    for (var i = 0; i < n_levels; i++) {
+        // 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] = [
+            [levelHashes[i], path_elements[i][0]],
+            [path_elements[i][0], levelHashes[i]]
+        ];
+
+        var multiplexerResult[2] = MultiMux1(2)(
+            multiplexer,
+            path_indices[i]
+        );
+
+        var computedLevelHash = PoseidonHasher(2)([multiplexerResult[0], multiplexerResult[1]]);
+
+        // Store the resulting hash as the next level's hash.
+        levelHashes[i + 1] <== computedLevelHash;
+    }
+
+    // Set the final level hash as the root.
+    root <== levelHashes[n_levels];
+} 

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;
+}