Recursion, Pt 2

src/examples/program.ts

@@ -0,0 +1,43 @@
+import { Proof, Field, Program } from 'snarkyjs';
+
+class MyProof extends Proof<Field> {
+  static publicInputType = Field;
+  static tag: () => { name: string } = () => MyProgram;
+}
+
+let MyProgram = Program({
+  publicInput: Field,
+
+  methods: {
+    baseCase: {
+      privateInput: [],
+
+      method(publicInput: Field) {
+        publicInput.assertEquals(Field.zero);
+      },
+    },
+
+    plus1Case: {
+      privateInput: [MyProof],
+
+      method(publicInput: Field, earlierProof: MyProof) {
+        earlierProof.verify();
+        earlierProof.publicInput.add(1).assertEquals(publicInput);
+      },
+    },
+  },
+});
+
+console.log('compiling MyProgram...');
+await MyProgram.compile();
+
+console.log('proving base case...');
+let proof = await MyProgram.baseCase(Field.zero);
+
+console.log('proving step 1...');
+proof = await MyProgram.plus1Case(Field.one, proof);
+
+console.log('proving step 2...');
+proof = await MyProgram.plus1Case(Field(2), proof);
+
+console.log('ok?', proof.publicInput.toString() === '2');

src/index.ts

@@ -20,7 +20,7 @@ export * from './lib/int';
 export * as Mina from './lib/mina';
 export * from './lib/zkapp';
 export { state, State, declareState } from './lib/state';
-export * from './lib/proof_system';
+export { Proof, Program } from './lib/proof_system';
 export * from './lib/party';
 export {
   fetchAccount,

src/lib/global-context.ts

@@ -15,7 +15,7 @@ export {
 let mainContext = undefined as
   | {
       witnesses?: unknown[];
-      self: Party;
+      self?: Party;
       expectedAccesses: number | undefined;
       actualAccesses: number;
       inProver?: boolean;
@@ -24,7 +24,7 @@ let mainContext = undefined as
   | undefined;
 type PartialContext = {
   witnesses?: unknown[];
-  self: Party;
+  self?: Party;
   expectedAccesses?: number;
   actualAccesses?: number;
   inProver?: boolean;

src/lib/party.ts

@@ -879,6 +879,14 @@ type PartiesProved = {
   memo: string;
 };
 
+/**
+ * The public input for zkApps consists of certain hashes of the transaction and of the proving Party which is constructed during method execution.
+
+  In SmartContract.prove, a method is run twice: First outside the proof, to obtain the public input, and once in the prover,
+  which takes the public input as input. The current transaction is hashed again inside the prover, which asserts that the result equals the input public input,
+  as part of the snark circuit. The block producer will also hash the transaction they receive and pass it as a public input to the verifier.
+  Thus, the transaction is fully constrained by the proof - the proof couldn't be used to attest to a different transaction.
+ */
 type ZkappPublicInput = [transaction: Field, atParty: Field];
 let ZkappPublicInput = circuitValue<ZkappPublicInput>([Field, Field]);