Sequencing events

src/examples/api_exploration.ts

@@ -7,6 +7,7 @@ import {
   PrivateKey,
   PublicKey,
   Signature,
+  Int64,
 } from 'snarkyjs';
 
 /* This file demonstrates the classes and functions available in snarky.js */
@@ -115,6 +116,14 @@ const c = Circuit.if(
 
 console.assert(c.bar.someFieldElt.equals(x1).toBoolean());
 
+// Circuit.switch is a generalization of Circuit.if, for when you need to distinguish between multiple cases.
+let x = Circuit.switch([Bool(false), Bool(true), Bool(false)], Int64, [
+  Int64.from(1),
+  Int64.from(2),
+  Int64.from(3),
+]);
+x.assertEquals(Int64.from(2));
+
 /* # Signature
  */
 

src/examples/state_update_rollup.ts

@@ -0,0 +1,135 @@
+import {
+  Field,
+  state,
+  State,
+  method,
+  PrivateKey,
+  SmartContract,
+  Experimental,
+  Mina,
+  Party,
+  isReady,
+  Permissions,
+} from 'snarkyjs';
+
+await isReady;
+
+const INCREMENT = Field.one;
+
+class CounterZkapp extends SmartContract {
+  // the "reducer" field describes a type of action that we can dispatch, and reduce later
+  reducer = Experimental.Reducer({ actionType: Field });
+
+  // on-chain version of our state. it will typically lag behind the
+  // version that's implicitly represented by the list of actions
+  @state(Field) counter = State<Field>();
+  // helper field to store the point in the action history that our on-chain state is at
+  @state(Field) actionsHash = State<Field>();
+
+  @method incrementCounter() {
+    this.reducer.dispatch(INCREMENT);
+  }
+
+  @method rollupIncrements() {
+    // get previous counter & actions hash, assert that they're the same as on-chain values
+    let counter = this.counter.get();
+    this.counter.assertEquals(counter);
+    let actionsHash = this.actionsHash.get();
+    this.actionsHash.assertEquals(actionsHash);
+
+    // compute the new counter and hash from pending actions
+    // remark: it's not feasible to pass in the pending actions as method arguments, because they have dynamic size
+    let { state: newCounter, actionsHash: newActionsHash } =
+      this.reducer.reduce(
+        pendingActions,
+        // state type
+        Field,
+        // function that says how to apply an action
+        (state: Field, _action: Field) => {
+          return state.add(1);
+        },
+        { state: counter, actionsHash }
+      );
+
+    // update on-chain state
+    this.counter.set(newCounter);
+    this.actionsHash.set(newActionsHash);
+  }
+}
+
+const doProofs = false;
+const initialCounter = Field.zero;
+
+// this is a data structure where we internally keep track of the pending actions
+// TODO: get these from a Mina node / the local blockchain
+// note: each entry in pendingActions is itself an array -- the list of actions dispatched by one method
+// this is the structure we need to do the hashing correctly
+let pendingActions: Field[][] = [];
+
+let Local = Mina.LocalBlockchain();
+Mina.setActiveInstance(Local);
+
+// a test account that pays all the fees, and puts additional funds into the zkapp
+let feePayer = Local.testAccounts[0].privateKey;
+
+// the zkapp account
+let zkappKey = PrivateKey.random();
+let zkappAddress = zkappKey.toPublicKey();
+
+let zkapp = new CounterZkapp(zkappAddress);
+if (doProofs) {
+  console.log('compile');
+  await CounterZkapp.compile(zkappAddress);
+}
+
+console.log('deploy');
+let tx = await Mina.transaction(feePayer, () => {
+  Party.fundNewAccount(feePayer);
+  zkapp.deploy({ zkappKey });
+  if (!doProofs) {
+    zkapp.setPermissions({
+      ...Permissions.default(),
+      editState: Permissions.proofOrSignature(),
+      editSequenceState: Permissions.proofOrSignature(),
+    });
+  }
+  zkapp.counter.set(initialCounter);
+  zkapp.actionsHash.set(Experimental.Reducer.initialActionsHash);
+});
+tx.send();
+
+console.log('action 1');
+tx = await Mina.transaction(feePayer, () => {
+  zkapp.incrementCounter();
+  if (!doProofs) zkapp.sign(zkappKey);
+});
+if (doProofs) await tx.prove();
+tx.send();
+// update internal state
+pendingActions.push([INCREMENT]);
+
+console.log('action 2');
+tx = await Mina.transaction(feePayer, () => {
+  zkapp.incrementCounter();
+  if (!doProofs) zkapp.sign(zkappKey);
+});
+if (doProofs) await tx.prove();
+tx.send();
+// update internal state
+pendingActions.push([INCREMENT]);
+
+console.log('state (on-chain): ' + zkapp.counter.get());
+console.log('pending actions:', JSON.stringify(pendingActions));
+
+console.log('rollup transaction');
+tx = await Mina.transaction(feePayer, () => {
+  zkapp.rollupIncrements();
+  if (!doProofs) zkapp.sign(zkappKey);
+});
+if (doProofs) await tx.prove();
+tx.send();
+// reset pending actions
+pendingActions = [];
+
+console.log('state (on-chain): ' + zkapp.counter.get());
+console.log('pending actions:', JSON.stringify(pendingActions));

src/index.ts

@@ -4,7 +4,6 @@ export {
   Group,
   Scalar,
   AsFieldElements,
-  Circuit,
   Ledger,
   isReady,
   shutdown,
@@ -14,11 +13,28 @@ export type { VerificationKey, Keypair } from './snarky';
 export * from './snarky/addons';
 export { Poseidon } from './lib/hash';
 export * from './lib/signature';
-export * from './lib/circuit_value';
+export {
+  Circuit,
+  CircuitValue,
+  prop,
+  arrayProp,
+  matrixProp,
+  public_,
+  circuitMain,
+  circuitValue,
+} from './lib/circuit_value';
 
 export * from './lib/int';
 export * as Mina from './lib/mina';
-export * from './lib/zkapp';
+export {
+  SmartContract,
+  Experimental,
+  method,
+  deploy,
+  DeployArgs,
+  signFeePayer,
+  declareMethods,
+} from './lib/zkapp';
 export { state, State, declareState } from './lib/state';
 export { Proof, SelfProof, ZkProgram, verify } from './lib/proof_system';
 export * from './lib/party';

src/lib/circuit_value.test.ts

@@ -0,0 +1,25 @@
+import { Bool, Circuit, isReady, shutdown, Int64 } from '../../dist/server';
+
+describe('circuit', () => {
+  beforeAll(() => isReady);
+  afterAll(() => setTimeout(shutdown, 0));
+
+  it('Circuit.switch picks the right value', () => {
+    const x = Circuit.switch([Bool(false), Bool(true), Bool(false)], Int64, [
+      Int64.from(-1),
+      Int64.from(-2),
+      Int64.from(-3),
+    ]);
+    expect(x.toString()).toBe('-2');
+  });
+
+  it('Circuit.switch throws when mask has >1 nonzero elements', () => {
+    expect(() =>
+      Circuit.switch([Bool(true), Bool(true), Bool(false)], Int64, [
+        Int64.from(-1),
+        Int64.from(-2),
+        Int64.from(-3),
+      ])
+    ).toThrow(/`mask` must have 0 or 1 true element, found 2/);
+  });
+});

src/lib/circuit_value.ts

@@ -2,19 +2,21 @@ import 'reflect-metadata';
 import { Circuit, Field, Bool, JSONValue, AsFieldElements } from '../snarky';
 import { withContext } from './global-context';
 
+// external API
 export {
+  Circuit,
   CircuitValue,
   prop,
   arrayProp,
   matrixProp,
   public_,
   circuitMain,
-  cloneCircuitValue,
-  circuitValueEquals,
-  circuitArray,
   circuitValue,
 };
 
+// internal API
+export { cloneCircuitValue, circuitValueEquals, circuitArray };
+
 type AnyConstructor = new (...args: any) => any;
 
 abstract class CircuitValue {
@@ -67,14 +69,18 @@ abstract class CircuitValue {
     return (this.constructor as any).toJSON(this);
   }
 
-  equals(x: this): Bool {
+  equals(x: this) {
     return Circuit.equal(this, x);
   }
 
-  assertEquals(x: this): void {
+  assertEquals(x: this) {
     Circuit.assertEqual(this, x);
   }
 
+  isConstant(x: this) {
+    return x.toFields().every((x) => x.isConstant());
+  }
+
   static ofFields<T extends AnyConstructor>(
     this: T,
     xs: Field[]
@@ -324,11 +330,11 @@ function circuitValue<T>(typeObj: any): AsFieldElements<T> {
   function sizeInFields(typeObj: any): number {
     if (!complexTypes.has(typeof typeObj) || typeObj === null) return 0;
     if (Array.isArray(typeObj))
-      return typeObj.map(sizeInFields).reduce((a, b) => a + b);
+      return typeObj.map(sizeInFields).reduce((a, b) => a + b, 0);
     if ('sizeInFields' in typeObj) return typeObj.sizeInFields();
     return Object.values(typeObj)
       .map(sizeInFields)
-      .reduce((a, b) => a + b);
+      .reduce((a, b) => a + b, 0);
   }
   function toFields(typeObj: any, obj: any): Field[] {
     if (!complexTypes.has(typeof typeObj) || typeObj === null) return [];
@@ -467,3 +473,38 @@ function circuitValueEquals<T>(a: T, b: T): boolean {
     ([key, value]) => key in b && circuitValueEquals((b as any)[key], value)
   );
 }
+
+// TODO: move `Circuit` to JS entirely, this patching harms code discoverability
+Circuit.switch = function <T, A extends AsFieldElements<T>>(
+  mask: Bool[],
+  type: A,
+  values: T[]
+): T {
+  // picks the value at the index where mask is true
+  let nValues = values.length;
+  if (mask.length !== nValues)
+    throw Error(
+      `Circuit.switch: \`values\` and \`mask\` have different lengths (${values.length} vs. ${mask.length}), which is not allowed.`
+    );
+  let checkMask = () => {
+    let nTrue = mask.filter((b) => b.toBoolean()).length;
+    if (nTrue > 1) {
+      throw Error(
+        `Circuit.switch: \`mask\` must have 0 or 1 true element, found ${nTrue}.`
+      );
+    }
+  };
+  if (mask.every((b) => b.toField().isConstant())) checkMask();
+  else Circuit.asProver(checkMask);
+  let size = type.sizeInFields();
+  let fields = Array(size).fill(Field.zero);
+  for (let i = 0; i < nValues; i++) {
+    let valueFields = type.toFields(values[i]);
+    let maskField = mask[i].toField();
+    for (let j = 0; j < size; j++) {
+      let maybeField = valueFields[j].mul(maskField);
+      fields[j] = fields[j].add(maybeField);
+    }
+  }
+  return type.ofFields(fields);
+};

src/lib/global-context.ts

@@ -8,6 +8,7 @@ export {
   inProver,
   inCompile,
   inCheckedComputation,
+  inAnalyze,
 };
 
 // context for compiling / proving
@@ -21,6 +22,8 @@ let mainContext = undefined as
       inProver?: boolean;
       inCompile?: boolean;
       inCheckedComputation?: boolean;
+      inAnalyze?: boolean;
+      otherContext?: any;
     }
   | undefined;
 type PartialContext = {
@@ -31,6 +34,8 @@ type PartialContext = {
   inProver?: boolean;
   inCompile?: boolean;
   inCheckedComputation?: boolean;
+  inAnalyze?: boolean;
+  otherContext?: any;
 };
 
 function withContext<T>(
@@ -105,3 +110,6 @@ function inCheckedComputation() {
     !!mainContext?.inCheckedComputation
   );
 }
+function inAnalyze() {
+  return !!mainContext?.inAnalyze;
+}