151 lines
4 KiB
JavaScript
151 lines
4 KiB
JavaScript
import { inflate } from "pako";
|
|
import metadata from "./metadata.js";
|
|
import * as wasmExports from "./wasm.js";
|
|
|
|
const initialize = async () => {
|
|
await wasmExports.init(inflate);
|
|
|
|
const defaultProvider = {
|
|
compile: (source, compileOptions = {}) => {
|
|
var {
|
|
curve = "bn128",
|
|
location = "main.zok",
|
|
resolveCallback = () => null,
|
|
config = {},
|
|
snarkjs = false,
|
|
} = compileOptions;
|
|
|
|
config = { snarkjs, ...config };
|
|
|
|
const ptr = wasmExports.compile(
|
|
source,
|
|
location,
|
|
resolveCallback,
|
|
config,
|
|
curve,
|
|
);
|
|
const result = Object.assign(
|
|
{
|
|
program: ptr.program(),
|
|
abi: ptr.abi(),
|
|
constraintCount: ptr.constraint_count(),
|
|
},
|
|
snarkjs ? { snarkjs: { program: ptr.snarkjs_program() } } : {},
|
|
);
|
|
ptr.free();
|
|
return result;
|
|
},
|
|
computeWitness: (input, args, computeOptions = {}) => {
|
|
const { program, abi } =
|
|
input instanceof Uint8Array ? { program: input, abi: null } : input;
|
|
|
|
const { snarkjs = false, logCallback = console.log } = computeOptions;
|
|
const ptr = wasmExports.compute_witness(
|
|
program,
|
|
abi,
|
|
JSON.stringify(args),
|
|
{
|
|
snarkjs: snarkjs,
|
|
},
|
|
logCallback,
|
|
);
|
|
|
|
const result = Object.assign(
|
|
{
|
|
witness: ptr.witness(),
|
|
output: ptr.output(),
|
|
},
|
|
snarkjs
|
|
? {
|
|
snarkjs: {
|
|
witness: ptr.snarkjs_witness(),
|
|
},
|
|
}
|
|
: {},
|
|
);
|
|
|
|
ptr.free();
|
|
return result;
|
|
},
|
|
setup: (program, entropy, options) => {
|
|
const ptr = wasmExports.setup(program, entropy, options);
|
|
const result = {
|
|
vk: ptr.vk(),
|
|
pk: ptr.pk(),
|
|
};
|
|
ptr.free();
|
|
return result;
|
|
},
|
|
universalSetup: (curve, size, entropy) => {
|
|
return wasmExports.universal_setup(curve, size, entropy);
|
|
},
|
|
setupWithSrs: (srs, program, options) => {
|
|
const ptr = wasmExports.setup_with_srs(srs, program, options);
|
|
const result = {
|
|
vk: ptr.vk(),
|
|
pk: ptr.pk(),
|
|
};
|
|
ptr.free();
|
|
return result;
|
|
},
|
|
generateProof: (program, witness, provingKey, entropy, options) => {
|
|
return wasmExports.generate_proof(
|
|
program,
|
|
witness,
|
|
provingKey,
|
|
entropy,
|
|
options,
|
|
);
|
|
},
|
|
verify: (vk, proof, options) => {
|
|
return wasmExports.verify(vk, proof, options);
|
|
},
|
|
exportSolidityVerifier: (vk) => {
|
|
return wasmExports.export_solidity_verifier(vk);
|
|
},
|
|
utils: {
|
|
formatProof: (proof) => {
|
|
return wasmExports.format_proof(proof);
|
|
},
|
|
},
|
|
};
|
|
|
|
const withOptions = (options) => {
|
|
return {
|
|
withOptions,
|
|
compile: (source, compileOptions = {}) =>
|
|
defaultProvider.compile(source, {
|
|
...compileOptions,
|
|
curve: options.curve,
|
|
}),
|
|
computeWitness: (artifacts, args, computeOptions = {}) =>
|
|
defaultProvider.computeWitness(artifacts, args, computeOptions),
|
|
setup: (program, entropy) =>
|
|
defaultProvider.setup(program, entropy, options),
|
|
universalSetup: (size, entropy) =>
|
|
defaultProvider.universalSetup(options.curve, size, entropy),
|
|
setupWithSrs: (srs, program) =>
|
|
defaultProvider.setupWithSrs(srs, program, options),
|
|
generateProof: (program, witness, provingKey, entropy) =>
|
|
defaultProvider.generateProof(
|
|
program,
|
|
witness,
|
|
provingKey,
|
|
entropy,
|
|
options,
|
|
),
|
|
verify: (vk, proof) => defaultProvider.verify(vk, proof, options),
|
|
exportSolidityVerifier: (vk) =>
|
|
defaultProvider.exportSolidityVerifier(vk),
|
|
utils: {
|
|
formatProof: (proof) => defaultProvider.utils.formatProof(proof),
|
|
},
|
|
};
|
|
};
|
|
|
|
return {
|
|
...withOptions({ backend: "ark", scheme: "g16", curve: "bn128" }),
|
|
};
|
|
};
|
|
|
|
export { initialize, metadata };
|