@aztec/ivc-integration 0.84.0 → 0.85.0

package/src/index.ts

@@ -1,260 +1 @@
-import type { CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
-import { type ForeignCallOutput, Noir } from '@aztec/noir-noir_js';
-
-import createDebug from 'debug';
-import { ungzip } from 'pako';
-
-import MockAppCreatorCircuit from '../artifacts/app_creator.json' assert { type: 'json' };
-import MockAppReaderCircuit from '../artifacts/app_reader.json' assert { type: 'json' };
-import MockAppCreatorVk from '../artifacts/keys/app_creator.vk.data.json' assert { type: 'json' };
-import MockAppReaderVk from '../artifacts/keys/app_reader.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInitVk from '../artifacts/keys/mock_private_kernel_init.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInnerVk from '../artifacts/keys/mock_private_kernel_inner.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelResetVk from '../artifacts/keys/mock_private_kernel_reset.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelTailVk from '../artifacts/keys/mock_private_kernel_tail.vk.data.json' assert { type: 'json' };
-import MockPrivateKernelInitCircuit from '../artifacts/mock_private_kernel_init.json' assert { type: 'json' };
-import MockPrivateKernelInnerCircuit from '../artifacts/mock_private_kernel_inner.json' assert { type: 'json' };
-import MockPrivateKernelResetCircuit from '../artifacts/mock_private_kernel_reset.json' assert { type: 'json' };
-import MockPrivateKernelTailCircuit from '../artifacts/mock_private_kernel_tail.json' assert { type: 'json' };
-import MockPublicBaseCircuit from '../artifacts/mock_public_base.json' assert { type: 'json' };
-import type {
-  AppCreatorInputType,
-  AppPublicInputs,
-  AppReaderInputType,
-  FixedLengthArray,
-  KernelPublicInputs,
-  MockPrivateKernelInitInputType,
-  MockPrivateKernelInnerInputType,
-  MockPrivateKernelResetInputType,
-  MockPrivateKernelTailInputType,
-  MockPublicBaseInputType,
-  PrivateKernelPublicInputs,
-  u8,
-} from './types/index.js';
-
-// Re export the circuit jsons
-export {
-  MockAppCreatorCircuit,
-  MockAppReaderCircuit,
-  MockPrivateKernelInitCircuit,
-  MockPrivateKernelInnerCircuit,
-  MockPrivateKernelResetCircuit,
-  MockPrivateKernelTailCircuit,
-  MockPublicBaseCircuit,
-  MockAppCreatorVk,
-  MockAppReaderVk,
-  MockPrivateKernelInitVk,
-  MockPrivateKernelInnerVk,
-  MockPrivateKernelResetVk,
-  MockPrivateKernelTailVk,
-};
-
-const logger = createDebug('aztec:ivc-test');
-
-/* eslint-disable camelcase */
-
-export const MOCK_MAX_COMMITMENTS_PER_TX = 4;
-
-function foreignCallHandler(): Promise<ForeignCallOutput[]> {
-  throw new Error('Unexpected foreign call');
-}
-
-export interface WitnessGenResult<PublicInputsType> {
-  witness: Uint8Array;
-  publicInputs: PublicInputsType;
-}
-
-export async function witnessGenCreatorAppMockCircuit(
-  args: AppCreatorInputType,
-): Promise<WitnessGenResult<AppPublicInputs>> {
-  const program = new Noir(MockAppCreatorCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as AppPublicInputs,
-  };
-}
-
-export async function witnessGenReaderAppMockCircuit(
-  args: AppReaderInputType,
-): Promise<WitnessGenResult<AppPublicInputs>> {
-  const program = new Noir(MockAppReaderCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as AppPublicInputs,
-  };
-}
-
-export async function witnessGenMockPrivateKernelInitCircuit(
-  args: MockPrivateKernelInitInputType,
-): Promise<WitnessGenResult<PrivateKernelPublicInputs>> {
-  const program = new Noir(MockPrivateKernelInitCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as PrivateKernelPublicInputs,
-  };
-}
-
-export async function witnessGenMockPrivateKernelInnerCircuit(
-  args: MockPrivateKernelInnerInputType,
-): Promise<WitnessGenResult<PrivateKernelPublicInputs>> {
-  const program = new Noir(MockPrivateKernelInnerCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as PrivateKernelPublicInputs,
-  };
-}
-
-export async function witnessGenMockPrivateKernelResetCircuit(
-  args: MockPrivateKernelResetInputType,
-): Promise<WitnessGenResult<PrivateKernelPublicInputs>> {
-  const program = new Noir(MockPrivateKernelResetCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as PrivateKernelPublicInputs,
-  };
-}
-
-export async function witnessGenMockPrivateKernelTailCircuit(
-  args: MockPrivateKernelTailInputType,
-): Promise<WitnessGenResult<KernelPublicInputs>> {
-  const program = new Noir(MockPrivateKernelTailCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as KernelPublicInputs,
-  };
-}
-
-export async function witnessGenMockPublicBaseCircuit(args: MockPublicBaseInputType): Promise<WitnessGenResult<u8>> {
-  const program = new Noir(MockPublicBaseCircuit);
-  const { witness, returnValue } = await program.execute(args, foreignCallHandler);
-  return {
-    witness,
-    publicInputs: returnValue as u8,
-  };
-}
-
-export function getVkAsFields(vk: {
-  keyAsBytes: string;
-  keyAsFields: string[];
-}): FixedLengthArray<string, typeof CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS> {
-  return vk.keyAsFields as FixedLengthArray<string, typeof CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS>;
-}
-
-export async function generate3FunctionTestingIVCStack(): Promise<[string[], Uint8Array[]]> {
-  const tx = {
-    number_of_calls: '0x1',
-  };
-
-  // Witness gen app and kernels
-  const appWitnessGenResult = await witnessGenCreatorAppMockCircuit({ commitments_to_create: ['0x1', '0x2'] });
-  logger('generated app mock circuit witness');
-
-  const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
-    app_inputs: appWitnessGenResult.publicInputs,
-    tx,
-    app_vk: getVkAsFields(MockAppCreatorVk),
-  });
-  logger('generated mock private kernel init witness');
-
-  const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
-    prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
-    kernel_vk: getVkAsFields(MockPrivateKernelResetVk),
-  });
-  logger('generated mock private kernel tail witness');
-
-  // Create client IVC proof
-  const bytecodes = [
-    MockAppCreatorCircuit.bytecode,
-    MockPrivateKernelInitCircuit.bytecode,
-    MockPrivateKernelTailCircuit.bytecode,
-  ];
-  const witnessStack = [appWitnessGenResult.witness, initWitnessGenResult.witness, tailWitnessGenResult.witness];
-
-  return [bytecodes, witnessStack];
-}
-
-export async function generate6FunctionTestingIVCStack(): Promise<[string[], Uint8Array[]]> {
-  const tx = {
-    number_of_calls: '0x2',
-  };
-  // Witness gen app and kernels
-  const creatorAppWitnessGenResult = await witnessGenCreatorAppMockCircuit({ commitments_to_create: ['0x1', '0x2'] });
-  const readerAppWitnessGenResult = await witnessGenReaderAppMockCircuit({ commitments_to_read: ['0x2', '0x0'] });
-
-  const initWitnessGenResult = await witnessGenMockPrivateKernelInitCircuit({
-    app_inputs: creatorAppWitnessGenResult.publicInputs,
-    tx,
-    app_vk: getVkAsFields(MockAppCreatorVk),
-  });
-  const innerWitnessGenResult = await witnessGenMockPrivateKernelInnerCircuit({
-    prev_kernel_public_inputs: initWitnessGenResult.publicInputs,
-    app_inputs: readerAppWitnessGenResult.publicInputs,
-    app_vk: getVkAsFields(MockAppReaderVk),
-    kernel_vk: getVkAsFields(MockPrivateKernelInitVk),
-  });
-
-  const resetWitnessGenResult = await witnessGenMockPrivateKernelResetCircuit({
-    prev_kernel_public_inputs: innerWitnessGenResult.publicInputs,
-    commitment_read_hints: [
-      '0x1', // Reader reads commitment 0x2, which is at index 1 of the created commitments
-      MOCK_MAX_COMMITMENTS_PER_TX.toString(), // Pad with no-ops
-      MOCK_MAX_COMMITMENTS_PER_TX.toString(),
-      MOCK_MAX_COMMITMENTS_PER_TX.toString(),
-    ],
-    kernel_vk: getVkAsFields(MockPrivateKernelInnerVk),
-  });
-
-  const tailWitnessGenResult = await witnessGenMockPrivateKernelTailCircuit({
-    prev_kernel_public_inputs: resetWitnessGenResult.publicInputs,
-    kernel_vk: getVkAsFields(MockPrivateKernelResetVk),
-  });
-
-  // Create client IVC proof
-  const bytecodes = [
-    MockAppCreatorCircuit.bytecode,
-    MockPrivateKernelInitCircuit.bytecode,
-    MockAppReaderCircuit.bytecode,
-    MockPrivateKernelInnerCircuit.bytecode,
-    MockPrivateKernelResetCircuit.bytecode,
-    MockPrivateKernelTailCircuit.bytecode,
-  ];
-  const witnessStack = [
-    creatorAppWitnessGenResult.witness,
-    initWitnessGenResult.witness,
-    readerAppWitnessGenResult.witness,
-    innerWitnessGenResult.witness,
-    resetWitnessGenResult.witness,
-    tailWitnessGenResult.witness,
-  ];
-
-  return [bytecodes, witnessStack];
-}
-
-function base64ToUint8Array(base64: string): Uint8Array {
-  return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
-}
-
-export async function proveThenVerifyAztecClient(
-  bytecodes: string[],
-  witnessStack: Uint8Array[],
-  threads?: number,
-): Promise<boolean> {
-  const { AztecClientBackend } = await import('@aztec/bb.js');
-  const backend = new AztecClientBackend(
-    bytecodes.map(base64ToUint8Array).map((arr: Uint8Array) => ungzip(arr)),
-    { threads },
-  );
-  try {
-    const [proof, vk] = await backend.prove(witnessStack.map((arr: Uint8Array) => ungzip(arr)));
-    const verified = await backend.verify(proof, vk);
-    return verified;
-  } finally {
-    await backend.destroy();
-  }
-}
+export * from './witgen.js';

package/src/prove_native.ts

@@ -0,0 +1,238 @@
+import {
+  BB_RESULT,
+  PROOF_FILENAME,
+  PUBLIC_INPUTS_FILENAME,
+  type UltraHonkFlavor,
+  VK_FILENAME,
+  executeBbClientIvcProof,
+  extractVkData,
+  generateAvmProofV2,
+  generateProof,
+  generateTubeProof,
+  readClientIVCProofFromOutputDirectory,
+  readProofAsFields,
+  verifyProof,
+} from '@aztec/bb-prover';
+import {
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  TUBE_PROOF_LENGTH,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { makeProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { ClientIvcProof, Proof } from '@aztec/stdlib/proofs';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
+
+import { encode } from '@msgpack/msgpack';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export async function proveClientIVC(
+  bbBinaryPath: string,
+  bbWorkingDirectory: string,
+  witnessStack: Uint8Array[],
+  bytecodes: string[],
+  logger: Logger,
+): Promise<ClientIvcProof> {
+  await fs.writeFile(
+    path.join(bbWorkingDirectory, 'acir.msgpack'),
+    encode(bytecodes.map(bytecode => Buffer.from(bytecode, 'base64'))),
+  );
+
+  await fs.writeFile(path.join(bbWorkingDirectory, 'witnesses.msgpack'), encode(witnessStack));
+  const provingResult = await executeBbClientIvcProof(
+    bbBinaryPath,
+    bbWorkingDirectory,
+    path.join(bbWorkingDirectory, 'acir.msgpack'),
+    path.join(bbWorkingDirectory, 'witnesses.msgpack'),
+    logger.info,
+    true,
+  );
+
+  if (provingResult.status === BB_RESULT.FAILURE) {
+    throw new Error(provingResult.reason);
+  }
+
+  return readClientIVCProofFromOutputDirectory(bbWorkingDirectory);
+}
+
+async function verifyProofWithKey(
+  pathToBB: string,
+  workingDirectory: string,
+  verificationKey: VerificationKeyData,
+  proof: Proof,
+  flavor: UltraHonkFlavor,
+  logger: Logger,
+) {
+  const publicInputsFileName = path.join(workingDirectory, PUBLIC_INPUTS_FILENAME);
+  const proofFileName = path.join(workingDirectory, PROOF_FILENAME);
+  const verificationKeyPath = path.join(workingDirectory, VK_FILENAME);
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
+  await fs.writeFile(publicInputsFileName, proof.buffer.slice(0, proof.numPublicInputs * 32));
+  await fs.writeFile(proofFileName, proof.buffer.slice(proof.numPublicInputs * 32));
+  await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+
+  const result = await verifyProof(pathToBB, proofFileName, verificationKeyPath, flavor, logger);
+  if (result.status === BB_RESULT.FAILURE) {
+    throw new Error(`Failed to verify proof from key!`);
+  }
+  logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
+}
+
+export async function proveTube(pathToBB: string, workingDirectory: string, logger: Logger) {
+  const tubeResult = await generateTubeProof(pathToBB, workingDirectory, workingDirectory.concat('/vk'), logger.info);
+
+  if (tubeResult.status != BB_RESULT.SUCCESS) {
+    throw new Error('Failed to prove tube');
+  }
+
+  const tubeVK = await extractVkData(tubeResult.vkPath!);
+  const tubeProof = await readProofAsFields(tubeResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH, logger);
+
+  // Sanity check the tube proof
+  await verifyProofWithKey(pathToBB, workingDirectory, tubeVK, tubeProof.binaryProof, 'ultra_rollup_honk', logger);
+
+  return makeProofAndVerificationKey(tubeProof, tubeVK);
+}
+
+async function proveRollupCircuit<T extends UltraHonkFlavor, ProofLength extends number>(
+  name: string,
+  pathToBB: string,
+  workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+  flavor: T,
+  proofLength: ProofLength,
+) {
+  await fs.writeFile(path.join(workingDirectory, 'witness.gz'), witness);
+  const proofResult = await generateProof(
+    pathToBB,
+    workingDirectory,
+    name,
+    Buffer.from(circuit.bytecode, 'base64'),
+    true,
+    path.join(workingDirectory, 'witness.gz'),
+    flavor,
+    logger.info,
+  );
+
+  if (proofResult.status != BB_RESULT.SUCCESS) {
+    throw new Error(`Failed to generate proof for ${name} with flavor ${flavor}`);
+  }
+
+  const vk = await extractVkData(proofResult.vkPath!);
+  const proof = await readProofAsFields(proofResult.proofPath!, vk, proofLength, logger);
+
+  await verifyProofWithKey(pathToBB, workingDirectory, vk, proof.binaryProof, flavor, logger);
+
+  return makeProofAndVerificationKey(proof, vk);
+}
+
+export function proveRollupHonk(
+  name: string,
+  pathToBB: string,
+  workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+) {
+  return proveRollupCircuit(
+    name,
+    pathToBB,
+    workingDirectory,
+    circuit,
+    witness,
+    logger,
+    'ultra_rollup_honk',
+    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  );
+}
+
+export function proveKeccakHonk(
+  name: string,
+  pathToBB: string,
+  workingDirectory: string,
+  circuit: NoirCompiledCircuit,
+  witness: Uint8Array,
+  logger: Logger,
+) {
+  return proveRollupCircuit(
+    name,
+    pathToBB,
+    workingDirectory,
+    circuit,
+    witness,
+    logger,
+    'ultra_keccak_honk',
+    NESTED_RECURSIVE_PROOF_LENGTH,
+  );
+}
+
+export async function proveAvm(
+  avmCircuitInputs: AvmCircuitInputs,
+  workingDirectory: string,
+  logger: Logger,
+): Promise<{
+  vk: Fr[];
+  proof: Fr[];
+  publicInputs: AvmCircuitPublicInputs;
+}> {
+  // The paths for the barretenberg binary and the write path are hardcoded for now.
+  const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb');
+
+  // Then we prove.
+  const proofRes = await generateAvmProofV2(bbPath, workingDirectory, avmCircuitInputs, logger);
+  if (proofRes.status === BB_RESULT.FAILURE) {
+    throw new Error(`AVM V2 proof generation failed: ${proofRes.reason}`);
+  } else if (proofRes.status === BB_RESULT.ALREADY_PRESENT) {
+    throw new Error(`AVM V2 proof already exists`);
+  }
+
+  const avmProofPath = proofRes.proofPath;
+  const avmVkPath = proofRes.vkPath;
+  expect(avmProofPath).toBeDefined();
+  expect(avmVkPath).toBeDefined();
+
+  // Read the binary proof
+  const avmProofBuffer = await fs.readFile(avmProofPath!);
+  const reader = BufferReader.asReader(avmProofBuffer);
+
+  const proof: Fr[] = [];
+  while (!reader.isEmpty()) {
+    proof.push(Fr.fromBuffer(reader));
+  }
+
+  // We extend to a fixed-size padded proof as during development any new AVM circuit column changes the
+  // proof length and we do not have a mechanism to feedback a cpp constant to noir/TS.
+  // TODO(#13390): Revive a non-padded AVM proof
+  while (proof.length < AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED) {
+    proof.push(new Fr(0));
+  }
+
+  // Read the key
+  const vkBuffer = await fs.readFile(avmVkPath!);
+  const vkReader = BufferReader.asReader(vkBuffer);
+  const vk: Fr[] = [];
+  while (!vkReader.isEmpty()) {
+    vk.push(Fr.fromBuffer(vkReader));
+  }
+  // We extend to a fixed-size padded vk as during development any new AVM circuit precomputed
+  // column changes the vk length and we do not have a mechanism to feedback a cpp constant to noir/TS.
+  // TODO(#13390): Revive a non-padded vk proof
+  while (vk.length < AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED) {
+    vk.push(new Fr(0));
+  }
+
+  return {
+    proof,
+    vk,
+    publicInputs: avmCircuitInputs.publicInputs,
+  };
+}

package/src/prove_wasm.ts

@@ -0,0 +1,24 @@
+import { ungzip } from 'pako';
+
+function base64ToUint8Array(base64: string): Uint8Array {
+  return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+}
+
+export async function proveThenVerifyAztecClient(
+  bytecodes: string[],
+  witnessStack: Uint8Array[],
+  threads?: number,
+): Promise<boolean> {
+  const { AztecClientBackend } = await import('@aztec/bb.js');
+  const backend = new AztecClientBackend(
+    bytecodes.map(base64ToUint8Array).map((arr: Uint8Array) => ungzip(arr)),
+    { threads },
+  );
+  try {
+    const [proof, vk] = await backend.prove(witnessStack.map((arr: Uint8Array) => ungzip(arr)));
+    const verified = await backend.verify(proof, vk);
+    return verified;
+  } finally {
+    await backend.destroy();
+  }
+}

package/src/scripts/generate_ts_from_abi.ts

@@ -14,7 +14,10 @@ const circuits = [
   'mock_private_kernel_inner',
   'mock_private_kernel_reset',
   'mock_private_kernel_tail',
-  'mock_public_base',
+  'mock_rollup_base_public',
+  'mock_rollup_base_private',
+  'mock_rollup_merge',
+  'mock_rollup_root',
 ];
 
 const main = async () => {

package/src/serve.ts

@@ -1,6 +1,7 @@
 import createDebug from 'debug';
 
-import { generate3FunctionTestingIVCStack, proveThenVerifyAztecClient } from './index.js';
+import { generate3FunctionTestingIVCStack } from './index.js';
+import { proveThenVerifyAztecClient } from './prove_wasm.js';
 
 const logger = createDebug('aztec:ivc-test');
 

package/src/types/index.ts

@@ -10,7 +10,6 @@ export { type ForeignCallHandler } from "@aztec/noir-noir_js"
 export type FixedLengthArray<T, L extends number> = L extends 0 ? never[]: T[] & { length: L }
 export type Field = string;
 export type u32 = string;
-export type u8 = string;
 
 export type AppPublicInputs = {
   commitments: FixedLengthArray<Field, 2>;
@@ -31,6 +30,27 @@ export type KernelPublicInputs = {
   commitments: FixedLengthArray<Field, 4>;
 }
 
+export type TubeData = {
+  public_inputs: KernelPublicInputs;
+  proof: FixedLengthArray<Field, 535>;
+  vk_data: VerificationKey;
+}
+
+export type VerificationKey = {
+  key: FixedLengthArray<Field, 139>;
+  hash: Field;
+}
+
+export type RollupPublicInputs = {
+  accumulated: u32;
+}
+
+export type PreviousRollupData = {
+  base_or_merge_public_inputs: RollupPublicInputs;
+  proof: FixedLengthArray<Field, 535>;
+  vk: VerificationKey;
+}
+
 
 export type AppCreatorInputType = {
   commitments_to_create: FixedLengthArray<Field, 2>;
@@ -118,18 +138,60 @@ export async function MockPrivateKernelTail(prev_kernel_public_inputs: PrivateKe
   const { returnValue } = await program.execute(args, foreignCallHandler);
   return returnValue as KernelPublicInputs;
 }
-export type MockPublicBaseInputType = {
-  verification_key: FixedLengthArray<Field, 86>;
-  proof: FixedLengthArray<Field, 4154>;
-  pub_cols_flattened: FixedLengthArray<Field, 2956>;
+export type MockRollupBasePublicInputType = {
+  tube_data: TubeData;
+  verification_key: FixedLengthArray<Field, 1000>;
+  proof: FixedLengthArray<Field, 20000>;
+  pub_cols_flattened: FixedLengthArray<Field, 1>;
+}
+
+export type MockRollupBasePublicReturnType = RollupPublicInputs;
+
+
+export async function MockRollupBasePublic(tube_data: TubeData, verification_key: FixedLengthArray<Field, 1000>, proof: FixedLengthArray<Field, 20000>, pub_cols_flattened: FixedLengthArray<Field, 1>, MockRollupBasePublic_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupBasePublic_circuit);
+  const args: InputMap = { tube_data, verification_key, proof, pub_cols_flattened };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as RollupPublicInputs;
+}
+export type MockRollupBasePrivateInputType = {
+  tube_data: TubeData;
+}
+
+export type MockRollupBasePrivateReturnType = RollupPublicInputs;
+
+
+export async function MockRollupBasePrivate(tube_data: TubeData, MockRollupBasePrivate_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupBasePrivate_circuit);
+  const args: InputMap = { tube_data };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as RollupPublicInputs;
+}
+export type MockRollupMergeInputType = {
+  a: PreviousRollupData;
+  b: PreviousRollupData;
+}
+
+export type MockRollupMergeReturnType = RollupPublicInputs;
+
+
+export async function MockRollupMerge(a: PreviousRollupData, b: PreviousRollupData, MockRollupMerge_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupMerge_circuit);
+  const args: InputMap = { a, b };
+  const { returnValue } = await program.execute(args, foreignCallHandler);
+  return returnValue as RollupPublicInputs;
+}
+export type MockRollupRootInputType = {
+  a: PreviousRollupData;
+  b: PreviousRollupData;
 }
 
-export type MockPublicBaseReturnType = u8;
+export type MockRollupRootReturnType = RollupPublicInputs;
 
 
-export async function MockPublicBase(verification_key: FixedLengthArray<Field, 86>, proof: FixedLengthArray<Field, 4154>, pub_cols_flattened: FixedLengthArray<Field, 2956>, MockPublicBase_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<u8> {
-  const program = new Noir(MockPublicBase_circuit);
-  const args: InputMap = { verification_key, proof, pub_cols_flattened };
+export async function MockRollupRoot(a: PreviousRollupData, b: PreviousRollupData, MockRollupRoot_circuit: CompiledCircuit, foreignCallHandler?: ForeignCallHandler): Promise<RollupPublicInputs> {
+  const program = new Noir(MockRollupRoot_circuit);
+  const args: InputMap = { a, b };
   const { returnValue } = await program.execute(args, foreignCallHandler);
-  return returnValue as u8;
+  return returnValue as RollupPublicInputs;
 }