User intermediate proof in circuit

Author: jzaki

how-to/recursive-proofs/circuits/not_odd/src/main.nr

@@ -1,13 +1,8 @@
 #[recursive]
-fn main(n: Field) -> pub u8 {
-    // not_odd(n);
-    n as u8
+fn main(n: Field) -> pub bool {
+    not_odd(n)
 }
 
-// fn main(x: Field, y: Field) -> pub bool {
-//     not_odd(x) & not_odd(y) & not_equal(x, y);
-// }
-
 fn not_equal(x: Field, y: Field) -> bool {
     x != y
 }

how-to/recursive-proofs/circuits/recurse/src/lib.nr

@@ -1,24 +1,11 @@
 use dep::std;
-// use dep::simple;
-
-// #[export]
-// fn main_call(x: Field, y: Field) -> bool {
-//     let mut res = simple::not_odd(x);
-//     res &= simple::not_odd(y);
-//     res &= simple::not_equal(x, y);
-//     res
-// }
 
 #[export]
-fn main(x: Field, y: Field) -> pub bool {
-    // Hash public inputs together
-    //TODO: take proofs
-    x != y
+fn main(verification_key: [Field; 114], proof: [Field; 93], public_inputs: [Field; 1], key_hash: Field) {
+    std::verify_proof(
+        verification_key.as_slice(),
+        proof.as_slice(),
+        public_inputs.as_slice(),
+        key_hash
+    );
 }
-
-// #[test]
-// fn test_not_equal() {
-//     assert(main_call(2, 4));
-//     // Uncomment to make test fail
-//     // assert(not_equal(1, 1));
-// }

how-to/recursive-proofs/main.ts

@@ -13,7 +13,6 @@ async function getCircuit(name: string) {
   const basePath = resolve(join('./circuits', name));
   const fm = createFileManager(basePath);
   const compiled = await compile(fm, basePath);
-  console.log(compiled.program.abi);
   if (!('program' in compiled)) {
     throw new Error('Compilation failed');
   }
@@ -23,21 +22,35 @@ async function getCircuit(name: string) {
 const input1 = { n: 2 };
 const input2 = { n: 4 };
 
+async function fullNoirFromCircuit(circuitName: string): Promise<FullNoir> {
+  const circuit: CompiledCircuit = await getCircuit('not_odd');
+  const backend: BarretenbergBackend = new BarretenbergBackend(circuit, { threads: 8 });
+  const noir: Noir = new Noir(circuit, backend);
+  return { circuit, backend, noir };
+}
+
+type FullNoir = {
+  circuit: CompiledCircuit,
+  backend: BarretenbergBackend,
+  noir: Noir
+}
+
 async function start() {
-  let simpleCircuit: CompiledCircuit = await getCircuit('not_odd');
-  let simpleBackend: BarretenbergBackend = new BarretenbergBackend(simpleCircuit, { threads: 8 });
-  let simpleNoir: Noir = new Noir(simpleCircuit, simpleBackend);
+  const simple: FullNoir = await fullNoirFromCircuit('not_odd');
+
+  const witness1 = (await simple.noir.execute(input1)).witness;
+  const proof1: ProofData = await simple.backend.generateProof(witness1);
 
-  const witness1 = (await simpleNoir.execute(input1)).witness;
-  let proof1: ProofData = await simpleBackend.generateProof(witness1);
+  // const witness2 = (await simple.noir.execute(input2)).witness;
+  // const proof2: ProofData = await simple.backend.generateProof(witness2);
 
-  const witness2 = (await simpleNoir.execute(input2)).witness;
-  let proof2: ProofData = await simpleBackend.generateProof(witness2);
+  const { proofAsFields, vkAsFields, vkHash } = await simple.backend.generateRecursiveProofArtifacts(proof1, 1);
+  // console.log({ proofAsFields, vkAsFields, vkHash });
 
-  // let res = await main(/* intermediate proofs */);
-  // console.log(res);
+  let res = await main(vkAsFields, proofAsFields, ["7"], vkHash);
+  console.log(res);
 
-  simpleBackend.destroy();
+  simple.backend.destroy();
 }
 
 start();