Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
console.error(input, 'does not exist')
return
}
// Run the trusted setup process if the output keyfiles don't exist, or the
// user wants to overwrite them
if (overwrite || !existsSync(provingKeyOutput) || !existsSync(verifyingKeyOutput)) {
try {
// Load the circuit
const circuitDef = JSON.parse(
readFileSync(input, 'utf8')
)
const circuit = new snarkjs.Circuit(circuitDef);
// Perform the setup
const setup = snarkjs.groth.setup(circuit);
// Save the keys
const provingKey = setup.vk_proof
const verifyingKey = setup.vk_verifier
writeFileSync(
provingKeyOutput,
JSON.stringify(stringifyBigInts(provingKey)),
'utf8'
)
writeFileSync(
verifyingKeyOutput,
JSON.stringify(stringifyBigInts(verifyingKey)),
'utf8'
)
const w = this.circuit.calculateWitness(inputs);
const witness_bin = proof_util.convertWitness(snarkjs.stringifyBigInts(w));
const publicSignals = w.slice(1, this.circuit.nPubInputs + this.circuit.nOutputs+1);
logger.info(`calculating witness (ended at ${Date.now()})`);
const root = w[this.circuit.getSignalIdx('main.root')];
const nullifiers_hash = w[this.circuit.getSignalIdx('main.nullifiers_hash')];
assert(this.circuit.checkWitness(w));
logger.info(`identity commitment from proof: ${w[this.circuit.getSignalIdx('main.identity_commitment.out[0]')].toString()}`);
assert.equal(w[this.circuit.getSignalIdx('main.root')].toString(), identity_path.root);
logger.info(`generating proof (started at ${Date.now()})`);
const proof = await proof_util.prove(witness_bin.buffer, this.vk_proof.buffer);
logger.info(`proof: ${JSON.stringify(stringifyBigInts(proof))}`);
assert(snarkjs.groth.isValid(this.verifier_key, proof, publicSignals));
logger.info(`generating proof (ended at ${Date.now()})`);
logger.debug(`publicSignals: ${publicSignals}`);
// publicSignals = (root, nullifiers_hash, signal_hash, external_nullifier)
const public_signals_to_broadcast = [ publicSignals[0].toString(), publicSignals[1].toString(), publicSignals[2].toString(), publicSignals[3].toString() ];
const proof_to_broadcast = [
[ proof.pi_a[0].toString(), proof.pi_a[1].toString() ],
[ [ proof.pi_b[0][1].toString(), proof.pi_b[0][0].toString() ], [ proof.pi_b[1][1].toString(), proof.pi_b[1][0].toString() ] ],
[ proof.pi_c[0].toString(), proof.pi_c[1].toString() ],
];
if (this.server_broadcast) {
const response = await fetch(`${this.semaphore_server_url}/broadcast_signal`, {
method: 'post',
body: JSON.stringify({
const verifyingKey = unstringifyBigInts(JSON.parse(readFileSync(verifyingKeyInput, "utf8")))
const proof = unstringifyBigInts(JSON.parse(readFileSync(proofFile, "utf8")))
const publicSignals = unstringifyBigInts(JSON.parse(readFileSync(publicSignalsFile, "utf8")))
const circuitDef = JSON.parse(readFileSync(circuitFile, "utf8"))
console.log(new Date(), 'Loading circuit')
const circuit = new snarkjs.Circuit(circuitDef)
console.log(new Date(), 'Calculating witness')
const witness = circuit.calculateWitness(testInput)
console.log('Hash calculated by JS :', testInput.pubSolnHash)
console.log('Hash calculated by circuit:', witness[circuit.getSignalIdx('main.solnHashOut')])
console.log(new Date(), 'Verifying proof')
const valid = snarkjs.groth.isValid(verifyingKey, proof, publicSignals)
console.log(new Date(), 'Done')
if (valid) {
console.log("The proof is valid");
} else {
console.log("The proof is not valid");
}
}
it("It should do a zkSnark test", async () => {
const bn128 = await buildBn128();
const signals = fs.readFileSync(path.join(__dirname, "data", "witness.bin"));
const provingKey = fs.readFileSync(path.join(__dirname, "data", "proving_key.bin"));
const proofS = await bn128.proof(signals.buffer, provingKey.buffer);
const proof = snarkjs.unstringifyBigInts(proofS);
const verifierKey = snarkjs.unstringifyBigInts(JSON.parse(fs.readFileSync(path.join(__dirname, "data", "verification_key.json"), "utf8")));
const pub = snarkjs.unstringifyBigInts(JSON.parse(fs.readFileSync(path.join(__dirname, "data", "public.json"), "utf8")));
assert(snarkjs.groth.isValid(verifierKey, proof, pub));
bn128.terminate();
}).timeout(10000000);
const crypto = require('crypto');
const fs = require('fs');
const del = require('del');
const path = require('path');
const snarkjs = require('snarkjs');
const circomlib = require('circomlib');
const test_util = require('../../src/test_util');
const bigInt = snarkjs.bigInt;
const eddsa = circomlib.eddsa;
const mimc7 = circomlib.mimc7;
const groth = snarkjs.groth;
const {unstringifyBigInts} = require('snarkjs/src/stringifybigint.js');
const assert = chai.assert;
const Semaphore = artifacts.require('Semaphore');
const RocksDb = require('../../../sbmtjs/src/storage/rocksdb');
const MerkleTree = require('../../../sbmtjs/src/tree');
const Mimc7Hasher = require('../../../sbmtjs/src/hasher/mimc7');
beBuff2int = function(buff) {
let res = bigInt.zero;
for (let i=0; i
pubGuessB: guessArr[1],
pubGuessC: guessArr[2],
pubGuessD: guessArr[3],
privSolnA: solnArr[0],
privSolnB: solnArr[1],
privSolnC: solnArr[2],
privSolnD: solnArr[3],
}
const pkFile = './mastermind/setup/mastermind.pk.json'
const circuitFile = './mastermind/circuits/mastermind.json'
const provingKey = unstringifyBigInts(JSON.parse(readFileSync(pkFile, "utf8")))
const circuitDef = JSON.parse(readFileSync(circuitFile, "utf8"))
const circuit = new snarkjs.Circuit(circuitDef)
const witness = circuit.calculateWitness(input)
const {proof, publicSignals} = snarkjs.groth.genProof(provingKey, witness);
console.log(JSON.stringify(stringifyBigInts(proof)))
console.log(JSON.stringify(stringifyBigInts(publicSignals)))
console.log(hashedSaltedSoln.toString())
}
}
const provingKey = unstringifyBigInts(JSON.parse(readFileSync(provingKeyInput, "utf8")))
const verifyingKey = unstringifyBigInts(JSON.parse(readFileSync(verifyingKeyInput, "utf8")))
const circuitDef = JSON.parse(readFileSync(circuitFile, "utf8"))
console.log(new Date(), 'Loading circuit')
const circuit = new snarkjs.Circuit(circuitDef)
console.log(new Date(), 'Calculating witness')
const witness = circuit.calculateWitness(testInput)
console.log('Hash calculated by JS :', testInput.pubSolnHash)
console.log('Hash calculated by circuit:', witness[circuit.getSignalIdx('main.solnHashOut')])
console.log(new Date(), 'Generating proof')
const {proof, publicSignals} = snarkjs.groth.genProof(provingKey, witness);
writeFileSync(
proofOutput,
JSON.stringify(stringifyBigInts(proof)),
'utf8'
)
writeFileSync(
publicSignalsOutput,
JSON.stringify(stringifyBigInts(publicSignals)),
'utf8'
)
}
*/
const crypto = require('crypto');
const {unstringifyBigInts, stringifyBigInts} = require('snarkjs/src/stringifybigint.js');
const Web3 = require('web3');
const chai = require('chai');
const assert = chai.assert;
const snarkjs = require('snarkjs');
const bigInt = snarkjs.bigInt;
const eddsa = require('circomlib/src/eddsa');
const mimcsponge = require('circomlib/src/mimcsponge');
const groth = snarkjs.groth;
const fetch = require('node-fetch');
var FileSaver = require('file-saver');
const SemaphoreModules = require('./semaphore.js');
const SemaphoreClient = SemaphoreModules.client;
const generate_identity = SemaphoreModules.generate_identity;
const logger = {
info: (msg) => console.log(`INFO: ${msg}`),
error: (msg) => console.log(`ERRROR: ${msg}`),
debug: (msg) => {},
verbose: (msg) => {},
//debug: (msg) => console.log(`DEBUG: ${msg}`),
//verbose: (msg) => console.log(`VERBOSE: ${msg}`),
};
const fs = require('fs');
const path = require('path');
const {unstringifyBigInts, stringifyBigInts} = require('snarkjs/src/stringifybigint.js');
const chai = require('chai');
const assert = chai.assert;
const snarkjs = require('snarkjs');
const circomlib = require('circomlib');
const bigInt = snarkjs.bigInt;
const eddsa = circomlib.eddsa;
const groth = snarkjs.groth;
const fetch = require("node-fetch");
const Web3 = require('web3');
const winston = require('winston');
const BASE_DIR = process.env.BASE_DIR || process.cwd();
const SemaphoreABI = require(BASE_DIR + '/build/contracts/Semaphore.json');
const SemaphoreModules = require('./semaphore.js');
const SemaphoreClient = SemaphoreModules.client;
const generate_identity = SemaphoreModules.generate_identity;
if (process.env.CONFIG_ENV) {
const correctGuess = guessAsNum === (
psGuessA * 1000 +
psGuessB * 100 +
psGuessC * 10 +
psGuessD * 1
)
const correctClue =
parseInt(publicSignals[5], 10) === guess['nb'] &&
parseInt(publicSignals[6], 10) === guess['nw']
const correctHash =
this.solnHash.equals(publicSignals[7])
this.guesses[i]['verified'] =
snarkjs.groth.isValid(
this.verifyingKey,
proof,
publicSignals
) && correctClue && correctHash
if (this.guesses[i]['verified']) {
this.logEntry('Verified!')
} else {
this.logEntry('Invalid')
}
this.guesses[i]['verifying'] = false
}