How to use the snarkjs.groth function in snarkjs

To help you get started, weโ€™ve selected a few snarkjs examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github weijiekoh / zkmm / mastermind / src / trustedsetup.ts View on Github external
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'
            )
github kobigurk / semaphore / semaphorejs / src / client / semaphore.js View on Github external
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({
github weijiekoh / zkmm / mastermind / src / test_js_verification.ts View on Github external
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");
    }

}
github iden3 / websnark / test / bn128_prover.js View on Github external
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);
github kobigurk / semaphore / test / contracts / semaphore.js View on Github external
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
github weijiekoh / zkmm / backend / proofgen / index.ts View on Github external
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())
}
github weijiekoh / zkmm / mastermind / src / generateproof.ts View on Github external
}

    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'
    )
}
github kobigurk / semaphore / semaphorejs / src / web / client_web.js View on Github external
*/

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}`),
};
github kobigurk / semaphore / semaphorejs / src / client / client.js View on Github external
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) {
github weijiekoh / zkmm / frontend / src / models / GameStore.tsx View on Github external
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
    }