o1js-pack 0.4.1 → 0.4.2

package/build/src/lib/packed-types/PackedUInt32.js

@@ -1,50 +1,50 @@
-import { Provable, UInt32 } from 'o1js';
-import { PackingPlant } from '../PackingPlant.js';
-const L = 7; // 7 32-bit uints fit in one Field
-const SIZE_IN_BITS = 32n;
-export function PackedUInt32Factory(l = L) {
-    class PackedUInt32_ extends PackingPlant(UInt32, l, SIZE_IN_BITS) {
-        static extractField(input) {
-            return input.value;
-        }
-        static sizeInBits() {
-            return SIZE_IN_BITS;
-        }
-        /**
-         *
-         * @param f Field, packed with the information, as returned by #pack
-         * @returns Array of UInt32
-         */
-        static unpack(f) {
-            const unpacked = Provable.witness(Provable.Array(UInt32, l), () => {
-                const unpacked = this.unpackToBigints(f);
-                return unpacked.map((x) => UInt32.from(x));
-            });
-            f.assertEquals(PackedUInt32_.pack(unpacked));
-            return unpacked;
-        }
-        /**
-         *
-         * @param uint32s Array of UInt32s to be packed
-         * @returns Instance of the implementing class
-         */
-        static fromUInt32s(uint32s) {
-            const packed = PackedUInt32_.pack(uint32s);
-            return new PackedUInt32_(packed);
-        }
-        /**
-         *
-         * @param bigints Array of bigints to be packed
-         * @returns Instance of the implementing class
-         */
-        static fromBigInts(bigints) {
-            const uint32s = bigints.map((x) => UInt32.from(x));
-            return PackedUInt32_.fromUInt32s(uint32s);
-        }
-        toBigInts() {
-            return PackedUInt32_.unpack(this.packed).map((x) => x.toBigint());
-        }
-    }
-    return PackedUInt32_;
-}
+import { Provable, UInt32 } from 'o1js';
+import { PackingPlant } from '../PackingPlant.js';
+const L = 7; // 7 32-bit uints fit in one Field
+const SIZE_IN_BITS = 32n;
+export function PackedUInt32Factory(l = L) {
+    class PackedUInt32_ extends PackingPlant(UInt32, l, SIZE_IN_BITS) {
+        static extractField(input) {
+            return input.value;
+        }
+        static sizeInBits() {
+            return SIZE_IN_BITS;
+        }
+        /**
+         *
+         * @param f Field, packed with the information, as returned by #pack
+         * @returns Array of UInt32
+         */
+        static unpack(f) {
+            const unpacked = Provable.witness(Provable.Array(UInt32, l), () => {
+                const unpacked = this.unpackToBigints(f);
+                return unpacked.map((x) => UInt32.from(x));
+            });
+            f.assertEquals(PackedUInt32_.pack(unpacked));
+            return unpacked;
+        }
+        /**
+         *
+         * @param uint32s Array of UInt32s to be packed
+         * @returns Instance of the implementing class
+         */
+        static fromUInt32s(uint32s) {
+            const packed = PackedUInt32_.pack(uint32s);
+            return new PackedUInt32_(packed);
+        }
+        /**
+         *
+         * @param bigints Array of bigints to be packed
+         * @returns Instance of the implementing class
+         */
+        static fromBigInts(bigints) {
+            const uint32s = bigints.map((x) => UInt32.from(x));
+            return PackedUInt32_.fromUInt32s(uint32s);
+        }
+        toBigInts() {
+            return PackedUInt32_.unpack(this.packed).map((x) => x.toBigint());
+        }
+    }
+    return PackedUInt32_;
+}
 //# sourceMappingURL=PackedUInt32.js.map

package/build/src/lib/packed-types/PackedUInt32.test.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/build/src/lib/packed-types/PackedUInt32.test.js

@@ -1,84 +1,84 @@
-import { Provable, UInt32 } from 'o1js';
-import { PackedUInt32Factory } from './PackedUInt32';
-describe('PackedUInt32', () => {
-    class PackedUInt32 extends PackedUInt32Factory() {
-    }
-    describe('Outside of the circuit', () => {
-        const bigints = [10n, 2n ** 32n - 1n, 0n, 10n, 2n ** 32n - 100n, 42n, 0n];
-        const uints = bigints.map((x) => UInt32.from(x));
-        it('#fromBigInts', () => {
-            const myPackedUInt32 = PackedUInt32.fromBigInts(bigints);
-            expect(myPackedUInt32.toBigInts()).toMatchObject(bigints);
-        });
-        it('#pack and #unPack', () => {
-            const packed = PackedUInt32.pack(uints);
-            const unpacked = PackedUInt32.unpack(packed);
-            expect(unpacked.length).toBe(uints.length);
-            expect(unpacked).toMatchObject(uints);
-        });
-    });
-    describe('Provable Properties', () => {
-        it('#sizeInFields', () => {
-            class one extends PackedUInt32Factory(1) {
-            }
-            class seven extends PackedUInt32Factory(7) {
-            }
-            expect(one.sizeInFields()).toBe(1);
-            expect(seven.sizeInFields()).toBe(1);
-        });
-    });
-    describe('Defensive Cases', () => {
-        it('throws for input >= 8 uints', () => {
-            expect(() => PackedUInt32Factory(7)).not.toThrow();
-            expect(() => PackedUInt32Factory(8)).toThrow();
-        });
-        it('initalizes with more input than allowed', () => {
-            const bigints = [
-                10n,
-                2n ** 32n - 1n,
-                0n,
-                10n,
-                2n ** 32n - 100n,
-                42n,
-                0n,
-                0n,
-            ];
-            expect(() => {
-                PackedUInt32.fromBigInts(bigints);
-            }).toThrow();
-        });
-        it('initalizes with less input than specified', () => {
-            const bigints = [10n];
-            const expected = [10n, 0n, 0n, 0n, 0n, 0n, 0n];
-            expect(PackedUInt32.fromBigInts(bigints).toBigInts()).toMatchObject(expected);
-        });
-    });
-    describe('In the circuit', () => {
-        const bigints = [10n, 2n ** 32n - 1n, 0n, 10n, 2n ** 32n - 100n, 42n, 0n];
-        const outsidePackedUInt = PackedUInt32.fromBigInts(bigints);
-        it('Initializes', () => {
-            expect(() => {
-                Provable.runAndCheck(() => {
-                    const packedUInt32 = new PackedUInt32(outsidePackedUInt.packed);
-                    PackedUInt32.check({ packed: packedUInt32.packed });
-                });
-            }).not.toThrow();
-        });
-        it('#assertEquals', () => {
-            expect(() => {
-                Provable.runAndCheck(() => {
-                    const packedUInt32 = new PackedUInt32(outsidePackedUInt.packed);
-                    packedUInt32.assertEquals(outsidePackedUInt);
-                });
-            }).not.toThrow();
-            expect(() => {
-                Provable.runAndCheck(() => {
-                    const fakePacked = outsidePackedUInt.packed.add(32);
-                    const packedUInt32 = new PackedUInt32(fakePacked);
-                    packedUInt32.assertEquals(outsidePackedUInt);
-                });
-            }).toThrow();
-        });
-    });
-});
+import { Provable, UInt32 } from 'o1js';
+import { PackedUInt32Factory } from './PackedUInt32';
+describe('PackedUInt32', () => {
+    class PackedUInt32 extends PackedUInt32Factory() {
+    }
+    describe('Outside of the circuit', () => {
+        const bigints = [10n, 2n ** 32n - 1n, 0n, 10n, 2n ** 32n - 100n, 42n, 0n];
+        const uints = bigints.map((x) => UInt32.from(x));
+        it('#fromBigInts', () => {
+            const myPackedUInt32 = PackedUInt32.fromBigInts(bigints);
+            expect(myPackedUInt32.toBigInts()).toMatchObject(bigints);
+        });
+        it('#pack and #unPack', () => {
+            const packed = PackedUInt32.pack(uints);
+            const unpacked = PackedUInt32.unpack(packed);
+            expect(unpacked.length).toBe(uints.length);
+            expect(unpacked).toMatchObject(uints);
+        });
+    });
+    describe('Provable Properties', () => {
+        it('#sizeInFields', () => {
+            class one extends PackedUInt32Factory(1) {
+            }
+            class seven extends PackedUInt32Factory(7) {
+            }
+            expect(one.sizeInFields()).toBe(1);
+            expect(seven.sizeInFields()).toBe(1);
+        });
+    });
+    describe('Defensive Cases', () => {
+        it('throws for input >= 8 uints', () => {
+            expect(() => PackedUInt32Factory(7)).not.toThrow();
+            expect(() => PackedUInt32Factory(8)).toThrow();
+        });
+        it('initalizes with more input than allowed', () => {
+            const bigints = [
+                10n,
+                2n ** 32n - 1n,
+                0n,
+                10n,
+                2n ** 32n - 100n,
+                42n,
+                0n,
+                0n,
+            ];
+            expect(() => {
+                PackedUInt32.fromBigInts(bigints);
+            }).toThrow();
+        });
+        it('initalizes with less input than specified', () => {
+            const bigints = [10n];
+            const expected = [10n, 0n, 0n, 0n, 0n, 0n, 0n];
+            expect(PackedUInt32.fromBigInts(bigints).toBigInts()).toMatchObject(expected);
+        });
+    });
+    describe('In the circuit', () => {
+        const bigints = [10n, 2n ** 32n - 1n, 0n, 10n, 2n ** 32n - 100n, 42n, 0n];
+        const outsidePackedUInt = PackedUInt32.fromBigInts(bigints);
+        it('Initializes', () => {
+            expect(() => {
+                Provable.runAndCheck(() => {
+                    const packedUInt32 = new PackedUInt32(outsidePackedUInt.packed);
+                    PackedUInt32.check({ packed: packedUInt32.packed });
+                });
+            }).not.toThrow();
+        });
+        it('#assertEquals', () => {
+            expect(() => {
+                Provable.runAndCheck(() => {
+                    const packedUInt32 = new PackedUInt32(outsidePackedUInt.packed);
+                    packedUInt32.assertEquals(outsidePackedUInt);
+                });
+            }).not.toThrow();
+            expect(() => {
+                Provable.runAndCheck(() => {
+                    const fakePacked = outsidePackedUInt.packed.add(32);
+                    const packedUInt32 = new PackedUInt32(fakePacked);
+                    packedUInt32.assertEquals(outsidePackedUInt);
+                });
+            }).toThrow();
+        });
+    });
+});
 //# sourceMappingURL=PackedUInt32.test.js.map

package/examples/smart_contract/election/README.md

@@ -0,0 +1,3 @@
+## Election Smart Contract
+
+An election has multiple ballots, and a ballot has multiple options. We want to build an app that can track the state of the election, but there are more than 8 pieces of state. We'll have to use packing to store all of the results on chain.

package/examples/smart_contract/election/contract.ts

@@ -0,0 +1,79 @@
+import { SmartContract, state, State, method, UInt32 } from 'o1js';
+import { PackedUInt32Factory } from '../../../src/index.js';
+
+export class Ballot extends PackedUInt32Factory() {}
+
+export class Election extends SmartContract {
+  @state(Ballot) ballot1 = State<Ballot>();
+  @state(Ballot) ballot2 = State<Ballot>();
+  @state(Ballot) ballot3 = State<Ballot>();
+  @state(Ballot) ballot4 = State<Ballot>();
+
+  init() {
+    super.init();
+    this.ballot1.set(Ballot.fromBigInts([0n, 0n, 0n, 0n, 0n, 0n, 0n]));
+    this.ballot2.set(Ballot.fromBigInts([0n, 0n, 0n, 0n, 0n, 0n, 0n]));
+    this.ballot3.set(Ballot.fromBigInts([0n, 0n, 0n, 0n, 0n, 0n, 0n]));
+    this.ballot4.set(Ballot.fromBigInts([0n, 0n, 0n, 0n, 0n, 0n, 0n]));
+  }
+
+  @method
+  castBallot1(vote: Ballot) {
+    const unpackedVote = Ballot.unpack(vote.packed);
+    const ballot1 = this.ballot1.getAndAssertEquals();
+    const unpackedBallot1 = Ballot.unpack(ballot1.packed);
+
+    let voteSum = UInt32.from(0);
+    for (let i = 0; i < Ballot.l; i++) {
+      voteSum = voteSum.add(unpackedVote[i]);
+      unpackedBallot1[i] = unpackedBallot1[i].add(unpackedVote[i]);
+    }
+    voteSum.value.assertEquals(1); // vote must be exactly one vote for one choice
+    this.ballot1.set(Ballot.fromUInt32s(unpackedBallot1));
+  }
+
+  @method
+  castBallot2(vote: Ballot) {
+    const unpackedVote = Ballot.unpack(vote.packed);
+    const ballot2 = this.ballot2.getAndAssertEquals();
+    const unpackedBallot2 = Ballot.unpack(ballot2.packed);
+
+    let voteSum = UInt32.from(0);
+    for (let i = 0; i < Ballot.l; i++) {
+      voteSum = voteSum.add(unpackedVote[i]);
+      unpackedBallot2[i] = unpackedBallot2[i].add(unpackedVote[i]);
+    }
+    voteSum.value.assertEquals(1); // vote must be exactly one vote for one choice
+    this.ballot2.set(Ballot.fromUInt32s(unpackedBallot2));
+  }
+
+  @method
+  castBallot3(vote: Ballot) {
+    const unpackedVote = Ballot.unpack(vote.packed);
+    const ballot3 = this.ballot3.getAndAssertEquals();
+    const unpackedBallot3 = Ballot.unpack(ballot3.packed);
+
+    let voteSum = UInt32.from(0);
+    for (let i = 0; i < Ballot.l; i++) {
+      voteSum = voteSum.add(unpackedVote[i]);
+      unpackedBallot3[i] = unpackedBallot3[i].add(unpackedVote[i]);
+    }
+    voteSum.value.assertEquals(1); // vote must be exactly one vote for one choice
+    this.ballot3.set(Ballot.fromUInt32s(unpackedBallot3));
+  }
+
+  @method
+  castBallot4(vote: Ballot) {
+    const unpackedVote = Ballot.unpack(vote.packed);
+    const ballot4 = this.ballot4.getAndAssertEquals();
+    const unpackedBallot4 = Ballot.unpack(ballot4.packed);
+
+    let voteSum = UInt32.from(0);
+    for (let i = 0; i < Ballot.l; i++) {
+      voteSum = voteSum.add(unpackedVote[i]);
+      unpackedBallot4[i] = unpackedBallot4[i].add(unpackedVote[i]);
+    }
+    voteSum.value.assertEquals(1); // vote must be exactly one vote for one choice
+    this.ballot4.set(Ballot.fromUInt32s(unpackedBallot4));
+  }
+}

package/examples/smart_contract/election/run.ts

@@ -0,0 +1,98 @@
+import { AccountUpdate, Mina, PrivateKey } from 'o1js';
+import { Ballot, Election } from './contract.js';
+
+let Local = Mina.LocalBlockchain({ proofsEnabled: true });
+Mina.setActiveInstance(Local);
+
+// a test account that pays all the fees, and puts additional funds into the zkapp
+let { privateKey: senderKey, publicKey: sender } = Local.testAccounts[0];
+
+// the zkapp account
+let zkappKey = PrivateKey.random();
+let zkappAddress = zkappKey.toPublicKey();
+
+// a special account that is allowed to pull out half of the zkapp balance, once
+let privilegedKey = PrivateKey.random();
+let privilegedAddress = privilegedKey.toPublicKey();
+
+let initialBalance = 10_000_000_000;
+let zkapp = new Election(zkappAddress);
+
+console.time('compile');
+await Election.compile();
+console.timeEnd('compile');
+
+console.time('deploy');
+let tx = await Mina.transaction(sender, () => {
+  let senderUpdate = AccountUpdate.fundNewAccount(sender);
+  senderUpdate.send({ to: zkappAddress, amount: initialBalance });
+  zkapp.deploy({ zkappKey });
+});
+await tx.prove();
+await tx.sign([senderKey]).send();
+console.timeEnd('deploy');
+
+console.log(
+  'initial state: ',
+  zkapp.ballot1.get().toBigInts(),
+  zkapp.ballot2.get().toBigInts(),
+  zkapp.ballot3.get().toBigInts(),
+  zkapp.ballot4.get().toBigInts()
+);
+
+console.time('vote on ballot 1');
+tx = await Mina.transaction(sender, () => {
+  const myVote = Ballot.fromBigInts([0n, 0n, 1n, 0n, 0n, 0n, 0n]);
+  zkapp.castBallot1(myVote);
+});
+await tx.prove();
+await tx.sign([senderKey]).send();
+console.timeEnd('vote on ballot 1');
+
+console.time('vote on ballot 3');
+tx = await Mina.transaction(sender, () => {
+  const myVote = Ballot.fromBigInts([0n, 0n, 0n, 0n, 0n, 0n, 1n]);
+  zkapp.castBallot3(myVote);
+});
+await tx.prove();
+await tx.sign([senderKey]).send();
+console.timeEnd('vote on ballot 3');
+
+console.log(
+  'final state: ',
+  zkapp.ballot1.get().toBigInts(),
+  zkapp.ballot2.get().toBigInts(),
+  zkapp.ballot3.get().toBigInts(),
+  zkapp.ballot4.get().toBigInts()
+);
+
+// compile: 28.710s
+// deploy: 1.848s
+// initial state:  [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ]
+// vote on ballot 1: 24.752s
+// vote on ballot 3: 23.132s
+// final state:  [
+//   0n, 0n, 1n, 0n,
+//   0n, 0n, 0n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 1n
+// ] [
+//   0n, 0n, 0n, 0n,
+//   0n, 0n, 0n
+// ]

package/examples/zk_program/age_gate/README.md

@@ -0,0 +1,7 @@
+## Age Gate
+
+This example Zk Program stores a counter of accepted, a counter of rejected, and a method to check an input age.
+
+If the age is above a required limit, the accepted counter is incremented, else the rejected counter is incremented.
+
+The 2 counters are stored in a single packed UInt, and the data type for age is a packed string.

package/examples/zk_program/age_gate/circuit.ts

@@ -0,0 +1,75 @@
+import {
+  Field,
+  Experimental,
+  UInt32,
+  Provable,
+  Poseidon,
+  SelfProof,
+  Character,
+  Bool,
+  Empty,
+} from 'o1js';
+import {
+  PackedUInt32Factory,
+  PackedStringFactory,
+} from '../../../src/index.js';
+
+export class PackedCounters extends PackedUInt32Factory(2) {}
+
+export class PackedString extends PackedStringFactory(8) {}
+
+const isOlderThan = (reference: PackedString, toVerify: PackedString): Bool => {
+  let ref = Field(0);
+  let ver = Field(0);
+
+  const referenceDate = PackedString.unpack(reference.packed);
+  const dateToVerify = PackedString.unpack(toVerify.packed);
+
+  for (let i = 0; i < PackedString.l; i++) {
+    const exp = PackedString.l - i;
+    ref = ref.add(referenceDate[i].value.mul(10 ** exp));
+    ver = ver.add(dateToVerify[i].value.mul(10 ** exp));
+  }
+
+  return ver.greaterThan(ref);
+};
+
+export const AgeGateCircuit = Experimental.ZkProgram({
+  publicOutput: PackedCounters,
+
+  methods: {
+    init: {
+      privateInputs: [],
+      method() {
+        return PackedCounters.fromBigInts([0n, 0n]);
+      },
+    },
+    verifyAge: {
+      privateInputs: [SelfProof, PackedString],
+      method(
+        oldProof: SelfProof<Empty, PackedCounters>,
+        dateToVerify: PackedString
+      ) {
+        oldProof.verify();
+        const counters = PackedCounters.unpack(oldProof.publicOutput.packed);
+        const referenceDate = PackedString.fromString('20000101'); // hard-coded - date to verify must be older than new years in the year 2000
+        const isOlder = isOlderThan(referenceDate, dateToVerify);
+        const deltaCounter0 = Provable.if(
+          isOlder,
+          UInt32.from(1),
+          UInt32.from(0)
+        );
+        const deltaCounter1 = Provable.if(
+          isOlder,
+          UInt32.from(0),
+          UInt32.from(1)
+        );
+        counters[0] = counters[0].add(deltaCounter0);
+        counters[1] = counters[1].add(deltaCounter1);
+        return PackedCounters.fromUInt32s(counters);
+      },
+    },
+  },
+});
+
+export const AgeGateCircuitProof = Experimental.ZkProgram.Proof(AgeGateCircuit);

package/examples/zk_program/age_gate/non-packed-circuit.ts

@@ -0,0 +1,68 @@
+import {
+  Field,
+  Experimental,
+  UInt32,
+  Provable,
+  Poseidon,
+  SelfProof,
+  Character,
+  Bool,
+  Empty,
+  CircuitString,
+} from 'o1js';
+
+const isOlderThan = (
+  reference: CircuitString,
+  toVerify: CircuitString
+): Bool => {
+  let ref = Field(0);
+  let ver = Field(0);
+
+  for (let i = 0; i < 8; i++) {
+    const exp = 8 - i;
+    ref = ref.add(reference.values[i].value.mul(10 ** exp));
+    ver = ver.add(toVerify.values[i].value.mul(10 ** exp));
+  }
+
+  return ver.greaterThan(ref);
+};
+
+export const AgeGateCircuit = Experimental.ZkProgram({
+  publicOutput: Provable.Array(UInt32, 2),
+
+  methods: {
+    init: {
+      privateInputs: [],
+      method() {
+        return [UInt32.from(0), UInt32.from(0)];
+      },
+    },
+    verifyAge: {
+      privateInputs: [SelfProof, CircuitString],
+      method(
+        oldProof: SelfProof<Empty, Array<UInt32>>,
+        dateToVerify: CircuitString
+      ) {
+        oldProof.verify();
+        const counters = oldProof.publicOutput;
+        const referenceDate = CircuitString.fromString('20000101'); // hard-coded - date to verify must be older than new years in the year 2000
+        const isOlder = isOlderThan(referenceDate, dateToVerify);
+        const deltaCounter0 = Provable.if(
+          isOlder,
+          UInt32.from(1),
+          UInt32.from(0)
+        );
+        const deltaCounter1 = Provable.if(
+          isOlder,
+          UInt32.from(0),
+          UInt32.from(1)
+        );
+        counters[0] = counters[0].add(deltaCounter0);
+        counters[1] = counters[1].add(deltaCounter1);
+        return counters;
+      },
+    },
+  },
+});
+
+export const AgeGateCircuitProof = Experimental.ZkProgram.Proof(AgeGateCircuit);

package/examples/zk_program/age_gate/non-packed-run.ts

@@ -0,0 +1,36 @@
+import { AgeGateCircuit } from './non-packed-circuit.js';
+import { CircuitString } from 'o1js';
+
+console.time('Compiling...');
+await AgeGateCircuit.compile();
+console.timeEnd('Compiling...');
+
+console.time('Running...');
+let old_proof = await AgeGateCircuit.init();
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  CircuitString.fromString('20210927')
+);
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  CircuitString.fromString('19011225')
+);
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  CircuitString.fromString('20071031')
+);
+console.timeEnd('Running...');
+
+// Now we expect old_proof to have a counter of [2, 1] - 2 dates were older than 2000-01-01, 1 date was younger
+const counters = old_proof.publicOutput;
+console.log(counters.toString());
+
+const circuitAnalysis = AgeGateCircuit.analyzeMethods();
+console.log('Number of gates in method 0: ', circuitAnalysis[0].rows);
+console.log('Number of gates in method 1: ', circuitAnalysis[1].rows);
+
+// Compiling...: 1:00.331 (m:ss.mmm)
+// Running...: 3:31.711 (m:ss.mmm)
+// 2,1
+// Number of gates in method 0:  0
+// Number of gates in method 1:  651

package/examples/zk_program/age_gate/run.ts

@@ -0,0 +1,35 @@
+import { AgeGateCircuit, PackedCounters, PackedString } from './circuit.js';
+
+console.time('Compiling...');
+await AgeGateCircuit.compile();
+console.timeEnd('Compiling...');
+
+console.time('Running...');
+let old_proof = await AgeGateCircuit.init();
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  PackedString.fromString('20210927')
+);
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  PackedString.fromString('19011225')
+);
+old_proof = await AgeGateCircuit.verifyAge(
+  old_proof,
+  PackedString.fromString('20071031')
+);
+console.timeEnd('Running...');
+
+// Now we expect old_proof to have a counter of [2, 1] - 2 dates were older than 2000-01-01, 1 date was younger
+const counters = PackedCounters.unpack(old_proof.publicOutput.packed);
+console.log(counters.toString());
+
+const circuitAnalysis = AgeGateCircuit.analyzeMethods();
+console.log('Number of gates in method 0: ', circuitAnalysis[0].rows);
+console.log('Number of gates in method 1: ', circuitAnalysis[1].rows);
+
+// Compiling...: 59.405s
+// Running...: 3:31.839 (m:ss.mmm)
+// 2,1
+// Number of gates in method 0:  0
+// Number of gates in method 1:  551