Create todd anthony stephens

[FuzzysTodd]

pragma circom 2.0.0;

include "circomlib/circuits/poseidon.circom";
include "./tree.circom";

template CalculateSecret() {
signal input identityNullifier;
signal input identityTrapdoor;
signal output out;

component poseidon = Poseidon(2);

poseidon.inputs[0] <== identityNullifier;
poseidon.inputs[1] <== identityTrapdoor;

out <== poseidon.out;

}

template CalculateIdentityCommitment() {
signal input secret;

signal output out;

component poseidon = Poseidon(1);

poseidon.inputs[0] <== secret;

out <== poseidon.out;

}

template CalculateNullifierHash() {
signal input externalNullifier;
signal input identityNullifier;

signal output out;

component poseidon = Poseidon(2);

poseidon.inputs[0] <== externalNullifier;
poseidon.inputs[1] <== identityNullifier;

out <== poseidon.out;

}

// credits to : https://github.com/semaphore-protocol/semaphore // The current Semaphore smart contracts require nLevels <= 32 and nLevels >= 16. template Semaphore(nLevels) {
signal input identityNullifier;
signal input identityTrapdoor;
signal input treePathIndices[nLevels];
signal input treeSiblings[nLevels];

signal input signalHash;
signal input externalNullifier;

signal output root;
signal output nullifierHash;

component calculateSecret = CalculateSecret();
calculateSecret.identityNullifier <== identityNullifier;
calculateSecret.identityTrapdoor <== identityTrapdoor;

signal secret;
secret <== calculateSecret.out;

component calculateIdentityCommitment = CalculateIdentityCommitment();
calculateIdentityCommitment.secret <== secret;

component calculateNullifierHash = CalculateNullifierHash();
calculateNullifierHash.externalNullifier <== externalNullifier;
calculateNullifierHash.identityNullifier <== identityNullifier;

component inclusionProof = MerkleTreeInclusionProof(nLevels);
inclusionProof.leaf <== calculateIdentityCommitment.out;

for (var i = 0; i < nLevels; i++) {
    inclusionProof.siblings[i] <== treeSiblings[i];
    inclusionProof.pathIndices[i] <== treePathIndices[i];
}

root <== inclusionProof.root;

// Dummy square to prevent tampering signalHash.
signal signalHashSquared;
signalHashSquared <== signalHash * signalHash;

nullifierHash <== calculateNullifierHash.out;

}

component main {public [signalHash, externalNullifier]} = Semaphore(20);