Update zkprogram examples following the changes in the performance regression framework

Author: Shigoto-dev19

src/examples/zkprogram/gadgets.ts

@@ -1,5 +1,5 @@
 import { Field, Provable, Gadgets, ZkProgram } from 'o1js';
-import { perfStart, perfEnd } from '../../lib/testing/perf-regression.js';
+import { Performance } from '../../lib/testing/perf-regression.js';
 
 let cs = await Provable.constraintSystem(() => {
   let f = Provable.witness(Field, () => 12);
@@ -56,26 +56,27 @@ const BitwiseProver = ZkProgram({
 });
 
 const csBitwise = await BitwiseProver.analyzeMethods();
+const perfBitwise = Performance.create(BitwiseProver.name, csBitwise);
 
 console.log('\ncompiling..');
 
-perfStart('compile', BitwiseProver.name);
+perfBitwise.start('compile');
 await BitwiseProver.compile();
-perfEnd();
+perfBitwise.end();
 
 console.log('\nproving..');
 
-perfStart('prove', BitwiseProver.name, csBitwise, 'rot');
+perfBitwise.start('prove', 'rot');
 let { proof: rotProof } = await BitwiseProver.rot();
-perfEnd();
+perfBitwise.end();
 if (!(await BitwiseProver.verify(rotProof))) throw Error('rot: Invalid proof');
 
-perfStart('prove', BitwiseProver.name, csBitwise, 'xor');
+perfBitwise.start('prove', 'xor');
 let { proof: xorProof } = await BitwiseProver.xor();
-perfEnd();
+perfBitwise.end();
 if (!(await BitwiseProver.verify(xorProof))) throw Error('xor: Invalid proof');
 
-perfStart('prove', BitwiseProver.name, csBitwise, 'and');
+perfBitwise.start('prove', 'and');
 let { proof: andProof } = await BitwiseProver.and();
-perfEnd();
+perfBitwise.end();
 if (!(await BitwiseProver.verify(andProof))) throw Error('and: Invalid proof');

src/examples/zkprogram/hash-chain.ts

@@ -5,7 +5,7 @@
  * We implement this as a self-recursive ZkProgram, using `proveRecursivelyIf()`
  */
 import { assert, Bool, Experimental, Field, Poseidon, Provable, Struct, ZkProgram } from 'o1js';
-import { perfStart, perfEnd } from '../../lib/testing/perf-regression.js';
+import { Performance } from '../../lib/testing/perf-regression.js';
 
 const HASHES_PER_PROOF = 30;
 
@@ -49,17 +49,17 @@ const hashChain = ZkProgram({
 let hashChainRecursive = Experimental.Recursive(hashChain);
 
 const cs = await hashChain.analyzeMethods();
-
-perfStart('compile', hashChain.name);
+const perfHashChain = Performance.create(hashChain.name, cs);
+perfHashChain.start('compile');
 await hashChain.compile();
-perfEnd();
+perfHashChain.end();
 
 let n = 100;
 let x = Field.random();
 
-perfStart('prove', hashChain.name, cs, 'chain');
+perfHashChain.start('prove', 'chain');
 let { proof } = await hashChain.chain({ x, n });
-perfEnd();
+perfHashChain.end();
 
 assert(await hashChain.verify(proof), 'Proof invalid');
 

src/examples/zkprogram/mutual-recursion.ts

@@ -1,5 +1,5 @@
 import { ZkProgram, Field, DynamicProof, Proof, VerificationKey, Undefined, verify } from 'o1js';
-import { perfStart, perfEnd } from '../../lib/testing/perf-regression.js';
+import { Performance } from '../../lib/testing/perf-regression.js';
 
 /**
  * This example showcases mutual recursion (A -> B -> A) through two circuits that respectively
@@ -55,26 +55,29 @@ const multiply = ZkProgram({
 const csAdd = await add.analyzeMethods();
 const csMultiply = await multiply.analyzeMethods();
 
-perfStart('compile', add.name);
+const perfAdd = Performance.create(add.name, csAdd);
+const perfMultiply = Performance.create(multiply.name, csMultiply);
+
+perfAdd.start('compile');
 const addVk = (await add.compile()).verificationKey;
-perfEnd();
+perfAdd.end();
 
-perfStart('compile', multiply.name);
+perfMultiply.start('compile');
 const multiplyVk = (await multiply.compile()).verificationKey;
-perfEnd();
+perfMultiply.end();
 
 const dummyProof = await DynamicMultiplyProof.dummy(undefined, Field(0), 1);
 
-perfStart('prove', add.name, csAdd, 'performAddition');
+perfAdd.start('prove', 'performAddition');
 const { proof: baseCase } = await add.performAddition(Field(5), dummyProof, multiplyVk);
-perfEnd();
+perfAdd.end();
 
 const validBaseCase = await verify(baseCase, addVk);
 console.log('ok?', validBaseCase);
 
-perfStart('prove', multiply.name, csMultiply, 'performMultiplication');
+perfMultiply.start('prove', 'performMultiplication');
 const { proof: multiply1 } = await multiply.performMultiplication(Field(3), baseCase);
-perfEnd();
+perfMultiply.end();
 
 const validMultiplication = await verify(multiply1, multiplyVk);
 console.log('ok?', validMultiplication);

src/examples/zkprogram/program-with-chunking.ts

@@ -1,5 +1,5 @@
 import { Field, Cache, Gadgets, ZkProgram } from 'o1js';
-import { perfStart, perfEnd } from '../../lib/testing/perf-regression.js';
+import { Performance } from '../../lib/testing/perf-regression.js';
 
 let MyProgram = ZkProgram({
   chunks: 1,
@@ -24,15 +24,17 @@ let MyProgram = ZkProgram({
 });
 
 const cs = await MyProgram.analyzeMethods();
+const perf = Performance.create(MyProgram.name, cs);
+
 console.log('MyProgram baseCase method rows: ', cs.baseCase.rows);
 
-perfStart('compile', MyProgram.name);
+perf.start('compile');
 await MyProgram.compile({ cache: Cache.None });
-perfEnd();
+perf.end();
 
-perfStart('prove', MyProgram.name, cs, 'baseCase');
+perf.start('prove', 'baseCase');
 let { proof } = await MyProgram.baseCase(Field(0));
-perfEnd();
+perf.end();
 
 console.log('verify...');
 let ok = await MyProgram.verify(proof);

src/examples/zkprogram/side-loading/run.ts

@@ -6,18 +6,21 @@ import {
   MerkleTreeWitness,
   MainProgramState,
 } from './dynamic-keys-merkletree.js';
-import { perfStart, perfEnd } from '../../../lib/testing/perf-regression.js';
+import { Performance } from '../../../lib/testing/perf-regression.js';
 
 const csSide = await sideloadedProgram.analyzeMethods();
 const csMain = await mainProgram.analyzeMethods();
 
-perfStart('compile', sideloadedProgram.name);
+const perfSide = Performance.create(sideloadedProgram.name, csSide);
+const perfMain = Performance.create(mainProgram.name, csMain);
+
+perfSide.start('compile');
 const sideVk = (await sideloadedProgram.compile()).verificationKey;
-perfEnd();
+perfSide.end();
 
-perfStart('compile', mainProgram.name);
+perfMain.start('compile');
 const mainVk = (await mainProgram.compile()).verificationKey;
-perfEnd();
+perfMain.end();
 
 const tree = new MerkleTree(64);
 
@@ -26,7 +29,7 @@ const rootBefore = tree.getRoot();
 tree.setLeaf(1n, sideVk.hash);
 const witness = new MerkleTreeWitness(tree.getWitness(1n));
 
-perfStart('prove', mainProgram.name, csMain, 'addSideloadedProgram');
+perfMain.start('prove', 'addSideloadedProgram');
 const { proof: proof1 } = await mainProgram.addSideloadedProgram(
   new MainProgramState({
     treeRoot: rootBefore,
@@ -35,31 +38,31 @@ const { proof: proof1 } = await mainProgram.addSideloadedProgram(
   sideVk,
   witness
 );
-perfEnd();
+perfMain.end();
 
 console.log('\nProving child program execution');
-perfStart('prove', sideloadedProgram.name, csSide, 'compute');
+perfSide.start('prove', 'compute');
 const { proof: childProof1 } = await sideloadedProgram.compute(Field(0), Field(10));
-perfEnd();
+perfSide.end();
 
 console.log('\nProving verification inside main program');
-perfStart('prove', mainProgram.name, csMain, 'validateUsingTree');
+perfMain.start('prove', 'validateUsingTree');
 const { proof: proof2 } = await mainProgram.validateUsingTree(
   proof1.publicOutput,
   proof1,
   sideVk,
   witness,
   SideloadedProgramProof.fromProof(childProof1)
 );
-perfEnd();
+perfMain.end();
 
 const validProof2 = await verify(proof2, mainVk);
 console.log('ok?', validProof2);
 
 console.log('\nProving different method of child program');
-perfStart('prove', sideloadedProgram.name, csSide, 'assertAndAdd');
+perfSide.start('prove', 'assertAndAdd');
 const { proof: childProof2 } = await sideloadedProgram.assertAndAdd(Field(0), Field(10));
-perfEnd();
+perfSide.end();
 
 console.log('\nProving verification inside main program');
 const { proof: proof3 } = await mainProgram.validateUsingTree(

tests/vk-regression/diverse-zk-program-run.ts

@@ -1,19 +1,20 @@
 import assert from 'node:assert';
 import { diverse, Bytes128 } from './diverse-zk-program.js';
-import { perfStart, perfEnd } from '../../src/lib/testing/perf-regression.js';
+import { Performance } from '../../src/lib/testing/perf-regression.js';
 
 const cs = await diverse.analyzeMethods();
+const perfDiverse = Performance.create(diverse.name, cs);
 
-perfStart('compile', diverse.name, cs);
+perfDiverse.start('compile');
 await diverse.compile();
-perfEnd();
+perfDiverse.end();
 
-perfStart('prove', diverse.name, cs, 'sha3');
+perfDiverse.start('prove', 'sha3');
 let { proof: proof1 } = await diverse.sha3(Bytes128.fromString('hello'));
-perfEnd();
+perfDiverse.end();
 
-perfStart('prove', diverse.name, cs, 'recursive');
+perfDiverse.start('prove', 'recursive');
 let { proof: proof2 } = await diverse.recursive(proof1);
-perfEnd();
+perfDiverse.end();
 
 assert(await diverse.verify(proof2), 'verifies');