@zkpersona/noir-social-verify
Version:
A library that provides a simple way to verify ownership of social accounts by proving e-mails.
133 lines (131 loc) • 15.4 kB
JavaScript
import { generateEmailVerifierInputs } from '@zk-email/zkemail-nr';
import { UltraPlonkBackend, UltraHonkBackend } from '@aztec/bb.js';
import { Noir } from '@noir-lang/noir_js';
// src/helpers.ts
var circuitParams = {
google: {
maxHeadersLength: 576,
maxBodyLength: 16384,
extractFrom: true,
extractTo: true
},
x: {
maxHeadersLength: 576,
maxBodyLength: 16384,
extractFrom: true,
extractTo: true
}
};
var createProver = (circuit, backend) => {
const prover = new ZKEmailProver(circuit, backend);
return prover;
};
var generateCircuitInputs = async (emailContent, circuitType) => {
const inputs = await generateEmailVerifierInputs(
emailContent,
circuitParams[circuitType]
);
return inputs;
};
var ZKEmailProver = class {
plonk;
honk;
noir;
provingBackend;
constructor(circuit, provingBackend) {
const acirBytecode = circuit.bytecode;
if (provingBackend.type === "plonk" || provingBackend.type === "all") {
this.plonk = new UltraPlonkBackend(
acirBytecode,
provingBackend.options,
provingBackend.circuitOptions
);
}
if (provingBackend.type === "honk" || provingBackend.type === "all") {
this.honk = new UltraHonkBackend(
acirBytecode,
provingBackend.options,
provingBackend.circuitOptions
);
}
this.provingBackend = provingBackend;
this.noir = new Noir(circuit);
}
/**
* Compute the witness for a given input to the circuit without generating a proof
*
* @param input - the input that should produce a satisfying witness for the circuit
* @returns - the witness for the input and the output of the circuit if satisfiable
*/
async simulateWitness(input) {
return await this.noir.execute(input);
}
/**
* Generate a proof of a satisfying input to the circuit using a provided witness
*
* @param input - a satisfying witness for the circuit
* @param provingBackend - optionally provided if the class was initialized with both proving schemes
* @returns proof of valid execution of the circuit
*/
async prove(witness, provingBackend) {
const backend = this.getProvingBackend(provingBackend?.type);
return await backend.generateProof(witness);
}
/**
* Simulate the witness for a given input and generate a proof
*
* @param input - the input that should produce a satisfying witness for the circuit
* @param provingBackend - optionally provided if the class was initialized with both proving schemes
* @returns proof of valid execution of the circuit
*/
async fullProve(input, provingBackend) {
const { witness } = await this.simulateWitness(input);
return this.prove(witness, provingBackend);
}
/**
* Verify a proof of a satisfying input to the circuit for a given proving scheme
*
* @param proof - the proof to verify
* @param provingBackend - optionally provided if the class was initialized with both proving schemes
* @returns true if the proof is valid, false otherwise
*/
async verify(proof, provingBackend) {
const backend = this.getProvingBackend(provingBackend?.type);
return await backend.verifyProof(proof);
}
/**
* End the prover wasm instance(s) and clean up resources
*/
async destroy() {
if (this.plonk) {
await this.plonk.destroy();
}
if (this.honk) {
await this.honk.destroy();
}
}
getProvingBackend(backendType) {
let type;
if (backendType === "plonk" || this.provingBackend.type === "plonk") {
type = "plonk";
} else if (backendType === "honk" || this.provingBackend.type === "honk") {
type = "honk";
} else {
throw new Error(
'Specify a proving backend from either "plonk" or "honk"'
);
}
let backend;
if (type === "plonk" && this.plonk) {
backend = this.plonk;
} else if (type === "honk" && this.honk) {
backend = this.honk;
} else {
throw new Error(`Proving backend ${type} not initialized`);
}
return backend;
}
};
export { ZKEmailProver, circuitParams, createProver, generateCircuitInputs };
//# sourceMappingURL=index.mjs.map
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/helpers.ts","../src/prover.ts"],"names":[],"mappings":";;;;;AAQO,IAAM,aAA0D,GAAA;AAAA,EACrE,MAAQ,EAAA;AAAA,IACN,gBAAkB,EAAA,GAAA;AAAA,IAClB,aAAe,EAAA,KAAA;AAAA,IACf,WAAa,EAAA,IAAA;AAAA,IACb,SAAW,EAAA;AAAA,GACb;AAAA,EACA,CAAG,EAAA;AAAA,IACD,gBAAkB,EAAA,GAAA;AAAA,IAClB,aAAe,EAAA,KAAA;AAAA,IACf,WAAa,EAAA,IAAA;AAAA,IACb,SAAW,EAAA;AAAA;AAEf;AAEa,IAAA,YAAA,GAAe,CAC1B,OAAA,EACA,OACG,KAAA;AACH,EAAA,MAAM,MAAS,GAAA,IAAI,aAAc,CAAA,OAAA,EAAS,OAAO,CAAA;AACjD,EAAO,OAAA,MAAA;AACT;AAEa,IAAA,qBAAA,GAAwB,OACnC,YAAA,EACA,WACG,KAAA;AACH,EAAA,MAAM,SAAS,MAAM,2BAAA;AAAA,IACnB,YAAA;AAAA,IACA,cAAc,WAAW;AAAA,GAC3B;AAEA,EAAO,OAAA,MAAA;AACT;ACrBO,IAAM,gBAAN,MAAoB;AAAA,EACzB,KAAA;AAAA,EACA,IAAA;AAAA,EACA,IAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,SAA0B,cAAgC,EAAA;AACpE,IAAA,MAAM,eAAe,OAAQ,CAAA,QAAA;AAC7B,IAAA,IAAI,cAAe,CAAA,IAAA,KAAS,OAAW,IAAA,cAAA,CAAe,SAAS,KAAO,EAAA;AACpE,MAAA,IAAA,CAAK,QAAQ,IAAI,iBAAA;AAAA,QACf,YAAA;AAAA,QACA,cAAe,CAAA,OAAA;AAAA,QACf,cAAe,CAAA;AAAA,OACjB;AAAA;AAEF,IAAA,IAAI,cAAe,CAAA,IAAA,KAAS,MAAU,IAAA,cAAA,CAAe,SAAS,KAAO,EAAA;AACnE,MAAA,IAAA,CAAK,OAAO,IAAI,gBAAA;AAAA,QACd,YAAA;AAAA,QACA,cAAe,CAAA,OAAA;AAAA,QACf,cAAe,CAAA;AAAA,OACjB;AAAA;AAEF,IAAA,IAAA,CAAK,cAAiB,GAAA,cAAA;AACtB,IAAK,IAAA,CAAA,IAAA,GAAO,IAAI,IAAA,CAAK,OAAO,CAAA;AAAA;AAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,gBACJ,KAC2D,EAAA;AAC3D,IAAA,OAAO,MAAM,IAAA,CAAK,IAAK,CAAA,OAAA,CAAQ,KAAK,CAAA;AAAA;AACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,KACJ,CAAA,OAAA,EACA,cACoB,EAAA;AACpB,IAAA,MAAM,OAAU,GAAA,IAAA,CAAK,iBAAkB,CAAA,cAAA,EAAgB,IAAI,CAAA;AAC3D,IAAO,OAAA,MAAM,OAAQ,CAAA,aAAA,CAAc,OAAO,CAAA;AAAA;AAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,SACJ,CAAA,KAAA,EACA,cACoB,EAAA;AACpB,IAAA,MAAM,EAAE,OAAQ,EAAA,GAAI,MAAM,IAAA,CAAK,gBAAgB,KAAK,CAAA;AACpD,IAAO,OAAA,IAAA,CAAK,KAAM,CAAA,OAAA,EAAS,cAAc,CAAA;AAAA;AAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,MACJ,CAAA,KAAA,EACA,cACkB,EAAA;AAClB,IAAA,MAAM,OAAU,GAAA,IAAA,CAAK,iBAAkB,CAAA,cAAA,EAAgB,IAAI,CAAA;AAC3D,IAAO,OAAA,MAAM,OAAQ,CAAA,WAAA,CAAY,KAAK,CAAA;AAAA;AACxC;AAAA;AAAA;AAAA,EAKA,MAAM,OAAU,GAAA;AACd,IAAA,IAAI,KAAK,KAAO,EAAA;AACd,MAAM,MAAA,IAAA,CAAK,MAAM,OAAQ,EAAA;AAAA;AAE3B,IAAA,IAAI,KAAK,IAAM,EAAA;AACb,MAAM,MAAA,IAAA,CAAK,KAAK,OAAQ,EAAA;AAAA;AAC1B;AACF,EAEQ,kBAAkB,WAAsC,EAAA;AAC9D,IAAI,IAAA,IAAA;AACJ,IAAA,IAAI,WAAgB,KAAA,OAAA,IAAW,IAAK,CAAA,cAAA,CAAe,SAAS,OAAS,EAAA;AACnE,MAAO,IAAA,GAAA,OAAA;AAAA,eACE,WAAgB,KAAA,MAAA,IAAU,IAAK,CAAA,cAAA,CAAe,SAAS,MAAQ,EAAA;AACxE,MAAO,IAAA,GAAA,MAAA;AAAA,KACF,MAAA;AACL,MAAA,MAAM,IAAI,KAAA;AAAA,QACR;AAAA,OACF;AAAA;AAGF,IAAI,IAAA,OAAA;AACJ,IAAI,IAAA,IAAA,KAAS,OAAW,IAAA,IAAA,CAAK,KAAO,EAAA;AAClC,MAAA,OAAA,GAAU,IAAK,CAAA,KAAA;AAAA,KACN,MAAA,IAAA,IAAA,KAAS,MAAU,IAAA,IAAA,CAAK,IAAM,EAAA;AACvC,MAAA,OAAA,GAAU,IAAK,CAAA,IAAA;AAAA,KACV,MAAA;AACL,MAAA,MAAM,IAAI,KAAA,CAAM,CAAmB,gBAAA,EAAA,IAAI,CAAkB,gBAAA,CAAA,CAAA;AAAA;AAG3D,IAAO,OAAA,OAAA;AAAA;AAEX","file":"index.mjs","sourcesContent":["import type { CompiledCircuit } from '@noir-lang/noir_js';\nimport {\n  type InputGenerationArgs,\n  generateEmailVerifierInputs,\n} from '@zk-email/zkemail-nr';\nimport { type ProvingBackend, ZKEmailProver } from '../src';\nimport type { CircuitInputMap, CircuitType } from './types';\n\nexport const circuitParams: Record<CircuitType, InputGenerationArgs> = {\n  google: {\n    maxHeadersLength: 576,\n    maxBodyLength: 16384,\n    extractFrom: true,\n    extractTo: true,\n  },\n  x: {\n    maxHeadersLength: 576,\n    maxBodyLength: 16384,\n    extractFrom: true,\n    extractTo: true,\n  },\n};\n\nexport const createProver = (\n  circuit: CompiledCircuit,\n  backend: ProvingBackend\n) => {\n  const prover = new ZKEmailProver(circuit, backend);\n  return prover;\n};\n\nexport const generateCircuitInputs = async <T extends CircuitType>(\n  emailContent: Buffer | string,\n  circuitType: T\n) => {\n  const inputs = await generateEmailVerifierInputs(\n    emailContent,\n    circuitParams[circuitType]\n  );\n\n  return inputs as CircuitInputMap[T];\n};\n","import {\n  type BackendOptions,\n  type ProofData,\n  UltraHonkBackend,\n  UltraPlonkBackend,\n} from '@aztec/bb.js';\nimport { type CompiledCircuit, type InputMap, Noir } from '@noir-lang/noir_js';\ntype InputValue = InputMap[string];\n\ntype CircuitOptions = {\n  /** @description Whether to produce SNARK friendly proofs */\n  recursive: boolean;\n};\n\nexport type ProvingBackend = {\n  type: 'honk' | 'plonk' | 'all';\n  options?: BackendOptions;\n  circuitOptions?: CircuitOptions;\n};\n\nexport class ZKEmailProver {\n  plonk?: UltraPlonkBackend;\n  honk?: UltraHonkBackend;\n  noir: Noir;\n  provingBackend: ProvingBackend;\n\n  constructor(circuit: CompiledCircuit, provingBackend: ProvingBackend) {\n    const acirBytecode = circuit.bytecode;\n    if (provingBackend.type === 'plonk' || provingBackend.type === 'all') {\n      this.plonk = new UltraPlonkBackend(\n        acirBytecode,\n        provingBackend.options,\n        provingBackend.circuitOptions\n      );\n    }\n    if (provingBackend.type === 'honk' || provingBackend.type === 'all') {\n      this.honk = new UltraHonkBackend(\n        acirBytecode,\n        provingBackend.options,\n        provingBackend.circuitOptions\n      );\n    }\n    this.provingBackend = provingBackend;\n    this.noir = new Noir(circuit);\n  }\n\n  /**\n   * Compute the witness for a given input to the circuit without generating a proof\n   *\n   * @param input - the input that should produce a satisfying witness for the circuit\n   * @returns - the witness for the input and the output of the circuit if satisfiable\n   */\n  async simulateWitness(\n    input: InputMap\n  ): Promise<{ witness: Uint8Array; returnValue: InputValue }> {\n    return await this.noir.execute(input);\n  }\n\n  /**\n   * Generate a proof of a satisfying input to the circuit using a provided witness\n   *\n   * @param input - a satisfying witness for the circuit\n   * @param provingBackend - optionally provided if the class was initialized with both proving schemes\n   * @returns proof of valid execution of the circuit\n   */\n  async prove(\n    witness: Uint8Array,\n    provingBackend?: ProvingBackend\n  ): Promise<ProofData> {\n    const backend = this.getProvingBackend(provingBackend?.type);\n    return await backend.generateProof(witness);\n  }\n\n  /**\n   * Simulate the witness for a given input and generate a proof\n   *\n   * @param input - the input that should produce a satisfying witness for the circuit\n   * @param provingBackend - optionally provided if the class was initialized with both proving schemes\n   * @returns proof of valid execution of the circuit\n   */\n  async fullProve(\n    input: InputMap,\n    provingBackend?: ProvingBackend\n  ): Promise<ProofData> {\n    const { witness } = await this.simulateWitness(input);\n    return this.prove(witness, provingBackend);\n  }\n\n  /**\n   * Verify a proof of a satisfying input to the circuit for a given proving scheme\n   *\n   * @param proof - the proof to verify\n   * @param provingBackend - optionally provided if the class was initialized with both proving schemes\n   * @returns true if the proof is valid, false otherwise\n   */\n  async verify(\n    proof: ProofData,\n    provingBackend?: ProvingBackend\n  ): Promise<boolean> {\n    const backend = this.getProvingBackend(provingBackend?.type);\n    return await backend.verifyProof(proof);\n  }\n\n  /**\n   * End the prover wasm instance(s) and clean up resources\n   */\n  async destroy() {\n    if (this.plonk) {\n      await this.plonk.destroy();\n    }\n    if (this.honk) {\n      await this.honk.destroy();\n    }\n  }\n\n  private getProvingBackend(backendType?: ProvingBackend['type']) {\n    let type: 'plonk' | 'honk';\n    if (backendType === 'plonk' || this.provingBackend.type === 'plonk') {\n      type = 'plonk';\n    } else if (backendType === 'honk' || this.provingBackend.type === 'honk') {\n      type = 'honk';\n    } else {\n      throw new Error(\n        'Specify a proving backend from either \"plonk\" or \"honk\"'\n      );\n    }\n\n    let backend: UltraPlonkBackend | UltraHonkBackend;\n    if (type === 'plonk' && this.plonk) {\n      backend = this.plonk;\n    } else if (type === 'honk' && this.honk) {\n      backend = this.honk;\n    } else {\n      throw new Error(`Proving backend ${type} not initialized`);\n    }\n\n    return backend;\n  }\n}\n"]}