Try to do real proving; no executionResult;

(note: need to set BB_BINARY_PATH
               and BB_WORKING_DIRECTORY)

.vscode/settings.json

@@ -120,7 +120,7 @@
     "editor.defaultFormatter": "hashicorp.terraform"
   },
   "[typescript]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
+    "editor.defaultFormatter": "vscode.typescript-language-features"
   },
   "[javascript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"

yarn-project/bb-prover/src/bb/execute.ts

@@ -225,6 +225,8 @@ export async function generateProof(
 
   try {
     // Write the bytecode to the working directory
+    log(`bytecodePath ${bytecodePath}`);
+    log(`outputPath ${outputPath}`);
     await fs.writeFile(bytecodePath, bytecode); // FOLDINGSTACK: circuit bytecode is written to a file here
     // FOLDINGSTACK: input to bb execution is 3 paths: 1) where to write proof/vk, 2) bytecode path, 3) witness path. Maybe the easiest
     // (also most correct?) thing to do is to simply store vectors of bytecode/witness paths, then send those all in one go to BB for

yarn-project/bb-prover/src/prover/bb_native_proof_creator.ts

@@ -316,25 +316,25 @@ export class BBNativeProofCreator implements ProofCreator {
 
     await fs.writeFile(inputsWitnessFile, compressedBincodedWitness); // FOLDINGSTACK: witness is written to a file here
 
-    // LONDONTODO(FoldingStack): Every circuit processed by full.test passes through this method during proof construction. Here I'm just writing the
-    // acir data (acir bytecode + witness) to a test fixtures file in bberg. (This should be all that's needed to construct corresponding bberg circuits).
-    // Hoping this provides a quick way to start playing around with accumulation. Probably easiest to start in the integration tests suite. That's where
-    // I'll plan to pick up tomorrow unless something else makes more sense by the time I get back to it. Once things are working there we can work to
-    // fill in the real pieces, e.g. better organization/serialization of this data, a proper flow in the bb binary (which is maybe just the existing
-    // flow if we end up serializing into a WitnessStack). One issue is going to be that the kernel circuits will have recursive verifiers. Might be easy
-    // enough to just 'delete' those op codes from the acir representation, but might also make sense to have versions of the kernels without recursion
-    // since we'll need them soon enough anyway.
-    let fixturesDir = path.resolve(this.bbBinaryPath, '../../../../', 'e2e_fixtures/folding_stack');
-    // Get circuit name; replace colons with underscores
-    const circuitName = (appCircuitName ? appCircuitName : circuitType).replace(/:/g, '_');
-    const stackItemDir = path.join(fixturesDir, circuitName);
-    await fs.mkdir(stackItemDir, { recursive: true });
-    // Write the acir bytecode and witness data to file
-    const bytecodePath = `${stackItemDir}/bytecode`;
-    const witnessPath = `${stackItemDir}/witness.gz`;
-    this.log.info(`Writing data for ${circuitName} to ${fixturesDir}`);
-    await fs.writeFile(bytecodePath, bytecode);
-    await fs.writeFile(witnessPath, compressedBincodedWitness); // FOLDINGSTACK: witness is written to a file here
+    // // LONDONTODO(FoldingStack): Every circuit processed by full.test passes through this method during proof construction. Here I'm just writing the
+    // // acir data (acir bytecode + witness) to a test fixtures file in bberg. (This should be all that's needed to construct corresponding bberg circuits).
+    // // Hoping this provides a quick way to start playing around with accumulation. Probably easiest to start in the integration tests suite. That's where
+    // // I'll plan to pick up tomorrow unless something else makes more sense by the time I get back to it. Once things are working there we can work to
+    // // fill in the real pieces, e.g. better organization/serialization of this data, a proper flow in the bb binary (which is maybe just the existing
+    // // flow if we end up serializing into a WitnessStack). One issue is going to be that the kernel circuits will have recursive verifiers. Might be easy
+    // // enough to just 'delete' those op codes from the acir representation, but might also make sense to have versions of the kernels without recursion
+    // // since we'll need them soon enough anyway.
+    // let fixturesDir = path.resolve(this.bbBinaryPath, '../../../../', 'e2e_fixtures/folding_stack');
+    // // Get circuit name; replace colons with underscores
+    // const circuitName = (appCircuitName ? appCircuitName : circuitType).replace(/:/g, '_');
+    // const stackItemDir = path.join(fixturesDir, circuitName);
+    // await fs.mkdir(stackItemDir, { recursive: true });
+    // // Write the acir bytecode and witness data to file
+    // const bytecodePath = `${stackItemDir}/bytecode`;
+    // const witnessPath = `${stackItemDir}/witness.gz`;
+    // this.log.info(`Writing data for ${circuitName} to ${fixturesDir}`);
+    // await fs.writeFile(bytecodePath, bytecode);
+    // await fs.writeFile(witnessPath, compressedBincodedWitness); // FOLDINGSTACK: witness is written to a file here
 
     this.log.debug(`Written ${inputsWitnessFile}`);
 

yarn-project/pxe/src/kernel_prover/kernel_prover.test.ts

@@ -1,5 +1,7 @@
 import { Note, type ProofCreator } from '@aztec/circuit-types';
-import { type BBNativeProofCreator } from '@aztec/bb-prover';
+import { BBNativeProofCreator } from '@aztec/bb-prover';
+// import { createConsoleLogger } from '@aztec/foundation/log';
+// import { createDebugLogger } from '@aztec/foundation/log';
 import {
   FunctionData,
   FunctionSelector,
@@ -31,15 +33,16 @@ import { mock } from 'jest-mock-extended';
 import { KernelProver } from './kernel_prover.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
+// const log = createDebugLogger('aztec:native_kernel_prover_tests');
+
 describe('Kernel Prover Native', () => {
   let txRequest: TxRequest;
   let oracle: ReturnType<typeof mock<ProvingDataOracle>>;
-  // LONDONTODO(Client): replace with non-mocked and see what happens? This means we fake it
-  let proofCreator: ReturnType<typeof mock<ProofCreator>>;
+  let proofCreator: BBNativeProofCreator;
   let prover: KernelProver;
   let dependencies: { [name: string]: string[] } = {};
 
-  const contractAddress = AztecAddress.fromBigInt(987654n);
+  // const contractAddress = AztecAddress.fromBigInt(987654n);
 
   const notesAndSlots: NoteAndSlot[] = Array(10)
     .fill(null)
@@ -50,9 +53,9 @@ describe('Kernel Prover Native', () => {
       owner: { x: Fr.random(), y: Fr.random() },
     }));
 
-  const createFakeSiloedCommitment = (commitment: Fr) => new Fr(commitment.value + 1n);
+  // const createFakeSiloedCommitment = (commitment: Fr) => new Fr(commitment.value + 1n);
   const generateFakeCommitment = (noteAndSlot: NoteAndSlot) => noteAndSlot.note.items[0];
-  const generateFakeSiloedCommitment = (note: NoteAndSlot) => createFakeSiloedCommitment(generateFakeCommitment(note));
+  // const generateFakeSiloedCommitment = (note: NoteAndSlot) => createFakeSiloedCommitment(generateFakeCommitment(note));
 
   const createExecutionResult = (fnName: string, newNoteIndices: number[] = []): ExecutionResult => {
     const publicInputs = PrivateCircuitPublicInputs.empty();
@@ -84,60 +87,60 @@ describe('Kernel Prover Native', () => {
     };
   };
 
-  const createProofOutput = (newNoteIndices: number[]) => {
-    const publicInputs = PrivateKernelCircuitPublicInputs.empty();
-    const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, ScopedNoteHash.empty);
-    for (let i = 0; i < newNoteIndices.length; i++) {
-      noteHashes[i] = new NoteHash(generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]), 0).scope(
-        0,
-        contractAddress,
-      );
-    }
-
-    publicInputs.end.newNoteHashes = noteHashes;
-    return {
-      publicInputs,
-      proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const createProofOutputFinal = (newNoteIndices: number[]) => {
-    const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
-    const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, () => Fr.ZERO);
-    for (let i = 0; i < newNoteIndices.length; i++) {
-      noteHashes[i] = generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]);
-    }
-    publicInputs.forRollup!.end.newNoteHashes = noteHashes;
-
-    return {
-      publicInputs,
-      proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const createAppCircuitProofOutput = () => {
-    return {
-      proof: makeRecursiveProof<typeof RECURSIVE_PROOF_LENGTH>(RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const expectExecution = (fns: string[]) => {
-    const callStackItemsInit = proofCreator.createProofInit.mock.calls.map(args =>
-      String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
-    );
-    const callStackItemsInner = proofCreator.createProofInner.mock.calls.map(args =>
-      String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
-    );
-
-    expect(proofCreator.createProofInit).toHaveBeenCalledTimes(Math.min(1, fns.length));
-    expect(proofCreator.createProofInner).toHaveBeenCalledTimes(Math.max(0, fns.length - 1));
-    expect(callStackItemsInit.concat(callStackItemsInner)).toEqual(fns);
-    proofCreator.createProofInner.mockClear();
-    proofCreator.createProofInit.mockClear();
-  };
+  // const createProofOutput = (newNoteIndices: number[]) => {
+  //   const publicInputs = PrivateKernelCircuitPublicInputs.empty();
+  //   const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, ScopedNoteHash.empty);
+  //   for (let i = 0; i < newNoteIndices.length; i++) {
+  //     noteHashes[i] = new NoteHash(generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]), 0).scope(
+  //       0,
+  //       contractAddress,
+  //     );
+  //   }
+
+  //   publicInputs.end.newNoteHashes = noteHashes;
+  //   return {
+  //     publicInputs,
+  //     proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
+  //     verificationKey: VerificationKeyAsFields.makeEmpty(),
+  //   };
+  // };
+
+  // const createProofOutputFinal = (newNoteIndices: number[]) => {
+  //   const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
+  //   const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, () => Fr.ZERO);
+  //   for (let i = 0; i < newNoteIndices.length; i++) {
+  //     noteHashes[i] = generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]);
+  //   }
+  //   publicInputs.forRollup!.end.newNoteHashes = noteHashes;
+
+  //   return {
+  //     publicInputs,
+  //     proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
+  //     verificationKey: VerificationKeyAsFields.makeEmpty(),
+  //   };
+  // };
+
+  // const createAppCircuitProofOutput = () => {
+  //   return {
+  //     proof: makeRecursiveProof<typeof RECURSIVE_PROOF_LENGTH>(RECURSIVE_PROOF_LENGTH),
+  //     verificationKey: VerificationKeyAsFields.makeEmpty(),
+  //   };
+  // };
+
+  // const expectExecution = (fns: string[]) => {
+  //   const callStackItemsInit = proofCreator.createProofInit.mock.calls.map(args =>
+  //     String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
+  //   );
+  //   const callStackItemsInner = proofCreator.createProofInner.mock.calls.map(args =>
+  //     String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
+  //   );
+
+  //   expect(proofCreator.createProofInit).toHaveBeenCalledTimes(Math.min(1, fns.length));
+  //   expect(proofCreator.createProofInner).toHaveBeenCalledTimes(Math.max(0, fns.length - 1));
+  //   expect(callStackItemsInit.concat(callStackItemsInner)).toEqual(fns);
+  //   proofCreator.createProofInner.mockClear();
+  //   proofCreator.createProofInit.mockClear();
+  // };
 
   const prove = (executionResult: ExecutionResult) => prover.prove(txRequest, executionResult);
 
@@ -159,220 +162,227 @@ describe('Kernel Prover Native', () => {
       privateFunctionsRoot: Fr.random(),
     });
 
-    proofCreator = mock<ProofCreator>();
-    proofCreator.getSiloedCommitments.mockImplementation(publicInputs =>
-      Promise.resolve(publicInputs.newNoteHashes.map(com => createFakeSiloedCommitment(com.value))),
+    const {
+      // BB_RELEASE_DIR = 'barretenberg/cpp/build/bin',
+      BB_BINARY_PATH,
+      // TEMP_DIR = tmpdir(),
+      BB_WORKING_DIRECTORY = '',
+    } = process.env;
+
+    proofCreator = new BBNativeProofCreator(
+      BB_BINARY_PATH!,
+      BB_WORKING_DIRECTORY
     );
-    proofCreator.createProofInit.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofInner.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofReset.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofTail.mockResolvedValue(createProofOutputFinal([]));
-    proofCreator.createAppCircuitProof.mockResolvedValue(createAppCircuitProofOutput());
+    // proofCreator.getSiloedCommitments.mockImplementation(publicInputs =>
+    //   Promise.resolve(publicInputs.newNoteHashes.map(com => createFakeSiloedCommitment(com.value))),
+    // );
+    // proofCreator.createProofInit.mockResolvedValue(createProofOutput([]));
+    // proofCreator.createProofInner.mockResolvedValue(createProofOutput([]));
+    // proofCreator.createProofReset.mockResolvedValue(createProofOutput([]));
+    // proofCreator.createProofTail.mockResolvedValue(createProofOutputFinal([]));
+    // proofCreator.createAppCircuitProof.mockResolvedValue(createAppCircuitProofOutput());
 
     prover = new KernelProver(oracle, proofCreator);
   });
 
-  // LONDONTODO(Client): Iterate on this and not the updated full test?
   it('should create proofs in correct order', async () => {
     {
       dependencies = { a: [] };
       const executionResult = createExecutionResult('a');
       await prove(executionResult);
-      expectExecution(['a']);
+      // expectExecution(['a']);
     }
 
-    {
-      dependencies = {
-        a: ['b', 'd'],
-        b: ['c'],
-      };
-      const executionResult = createExecutionResult('a');
-      await prove(executionResult);
-      expectExecution(['a', 'b', 'c', 'd']);
-    }
-
-    {
-      dependencies = {
-        k: ['m', 'o'],
-        m: ['q'],
-        o: ['n', 'p', 'r'],
-      };
-      const executionResult = createExecutionResult('k');
-      await prove(executionResult);
-      expectExecution(['k', 'm', 'q', 'o', 'n', 'p', 'r']);
-    }
+    // {
+    //   dependencies = {
+    //     a: ['b', 'd'],
+    //     b: ['c'],
+    //   };
+    //   const executionResult = createExecutionResult('a');
+    //   await prove(executionResult);
+    //   // expectExecution(['a', 'b', 'c', 'd']);
+    // }
+
+    // {
+    //   dependencies = {
+    //     k: ['m', 'o'],
+    //     m: ['q'],
+    //     o: ['n', 'p', 'r'],
+    //   };
+    //   const executionResult = createExecutionResult('k');
+    //   await prove(executionResult);
+    //   // expectExecution(['k', 'm', 'q', 'o', 'n', 'p', 'r']);
+    // }
   });
 });
 
-describe('Kernel Prover Mocked', () => {
-  let txRequest: TxRequest;
-  let oracle: ReturnType<typeof mock<ProvingDataOracle>>;
-  // LONDONTODO(Client): replace with non-mocked and see what happens? This means we fake it
-  let proofCreator: ReturnType<typeof mock<ProofCreator>>;
-  let prover: KernelProver;
-  let dependencies: { [name: string]: string[] } = {};
-
-  const contractAddress = AztecAddress.fromBigInt(987654n);
-
-  const notesAndSlots: NoteAndSlot[] = Array(10)
-    .fill(null)
-    .map(() => ({
-      note: new Note([Fr.random(), Fr.random(), Fr.random()]),
-      storageSlot: Fr.random(),
-      noteTypeId: Fr.random(),
-      owner: { x: Fr.random(), y: Fr.random() },
-    }));
-
-  const createFakeSiloedCommitment = (commitment: Fr) => new Fr(commitment.value + 1n);
-  const generateFakeCommitment = (noteAndSlot: NoteAndSlot) => noteAndSlot.note.items[0];
-  const generateFakeSiloedCommitment = (note: NoteAndSlot) => createFakeSiloedCommitment(generateFakeCommitment(note));
-
-  const createExecutionResult = (fnName: string, newNoteIndices: number[] = []): ExecutionResult => {
-    const publicInputs = PrivateCircuitPublicInputs.empty();
-    publicInputs.newNoteHashes = makeTuple(
-      MAX_NEW_NOTE_HASHES_PER_CALL,
-      i =>
-        i < newNoteIndices.length
-          ? new NoteHash(generateFakeCommitment(notesAndSlots[newNoteIndices[i]]), 0)
-          : NoteHash.empty(),
-      0,
-    );
-    const functionData = FunctionData.empty();
-    functionData.selector = new FunctionSelector(fnName.charCodeAt(0));
-    return {
-      callStackItem: new PrivateCallStackItem(AztecAddress.ZERO, functionData, publicInputs),
-      nestedExecutions: (dependencies[fnName] || []).map(name => createExecutionResult(name)), // LONDONTODO(Client): recursive call
-      vk: VerificationKey.makeFake().toBuffer(),
-      newNotes: newNoteIndices.map(idx => notesAndSlots[idx]),
-      nullifiedNoteHashCounters: new Map(),
-      noteHashLeafIndexMap: new Map(),
-      returnValues: [],
-      acir: Buffer.alloc(0), // LONDONTODO(Client): returning an empty circuit - doesn't ever appear to be populated with smthng nontrivial
-      partialWitness: new Map(),
-      enqueuedPublicFunctionCalls: [],
-      publicTeardownFunctionCall: PublicCallRequest.empty(),
-      noteEncryptedLogs: [],
-      encryptedLogs: [],
-      unencryptedLogs: [],
-    };
-  };
-
-  const createProofOutput = (newNoteIndices: number[]) => {
-    const publicInputs = PrivateKernelCircuitPublicInputs.empty();
-    const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, ScopedNoteHash.empty);
-    for (let i = 0; i < newNoteIndices.length; i++) {
-      noteHashes[i] = new NoteHash(generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]), 0).scope(
-        0,
-        contractAddress,
-      );
-    }
-
-    publicInputs.end.newNoteHashes = noteHashes;
-    return {
-      publicInputs,
-      proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const createProofOutputFinal = (newNoteIndices: number[]) => {
-    const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
-    const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, () => Fr.ZERO);
-    for (let i = 0; i < newNoteIndices.length; i++) {
-      noteHashes[i] = generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]);
-    }
-    publicInputs.forRollup!.end.newNoteHashes = noteHashes;
-
-    return {
-      publicInputs,
-      proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const createAppCircuitProofOutput = () => {
-    return {
-      proof: makeRecursiveProof<typeof RECURSIVE_PROOF_LENGTH>(RECURSIVE_PROOF_LENGTH),
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
-    };
-  };
-
-  const expectExecution = (fns: string[]) => {
-    const callStackItemsInit = proofCreator.createProofInit.mock.calls.map(args =>
-      String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
-    );
-    const callStackItemsInner = proofCreator.createProofInner.mock.calls.map(args =>
-      String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
-    );
-
-    expect(proofCreator.createProofInit).toHaveBeenCalledTimes(Math.min(1, fns.length));
-    expect(proofCreator.createProofInner).toHaveBeenCalledTimes(Math.max(0, fns.length - 1));
-    expect(callStackItemsInit.concat(callStackItemsInner)).toEqual(fns);
-    proofCreator.createProofInner.mockClear();
-    proofCreator.createProofInit.mockClear();
-  };
-
-  const prove = (executionResult: ExecutionResult) => prover.prove(txRequest, executionResult);
-
-  beforeEach(() => {
-    txRequest = makeTxRequest();
-
-    oracle = mock<ProvingDataOracle>();
-    // TODO(dbanks12): will need to mock oracle.getNoteMembershipWitness() to test non-transient reads
-    oracle.getVkMembershipWitness.mockResolvedValue(MembershipWitness.random(VK_TREE_HEIGHT));
-
-    oracle.getContractAddressPreimage.mockResolvedValue({
-      contractClassId: Fr.random(),
-      publicKeysHash: Fr.random(),
-      saltedInitializationHash: Fr.random(),
-    });
-    oracle.getContractClassIdPreimage.mockResolvedValue({
-      artifactHash: Fr.random(),
-      publicBytecodeCommitment: Fr.random(),
-      privateFunctionsRoot: Fr.random(),
-    });
-
-    proofCreator = mock<ProofCreator>();
-    proofCreator.getSiloedCommitments.mockImplementation(publicInputs =>
-      Promise.resolve(publicInputs.newNoteHashes.map(com => createFakeSiloedCommitment(com.value))),
-    );
-    proofCreator.createProofInit.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofInner.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofReset.mockResolvedValue(createProofOutput([]));
-    proofCreator.createProofTail.mockResolvedValue(createProofOutputFinal([]));
-    proofCreator.createAppCircuitProof.mockResolvedValue(createAppCircuitProofOutput());
-
-    prover = new KernelProver(oracle, proofCreator);
-  });
-
-  // LONDONTODO(Client): Iterate on this and not the updated full test?
-  it('should create proofs in correct order', async () => {
-    {
-      dependencies = { a: [] };
-      const executionResult = createExecutionResult('a');
-      await prove(executionResult);
-      expectExecution(['a']);
-    }
-
-    {
-      dependencies = {
-        a: ['b', 'd'],
-        b: ['c'],
-      };
-      const executionResult = createExecutionResult('a');
-      await prove(executionResult);
-      expectExecution(['a', 'b', 'c', 'd']);
-    }
-
-    {
-      dependencies = {
-        k: ['m', 'o'],
-        m: ['q'],
-        o: ['n', 'p', 'r'],
-      };
-      const executionResult = createExecutionResult('k');
-      await prove(executionResult);
-      expectExecution(['k', 'm', 'q', 'o', 'n', 'p', 'r']);
-    }
-  });
-});
+// describe('Kernel Prover Mocked', () => {
+//   let txRequest: TxRequest;
+//   let oracle: ReturnType<typeof mock<ProvingDataOracle>>;
+//   let proofCreator: ReturnType<typeof mock<ProofCreator>>;
+//   let prover: KernelProver;
+//   let dependencies: { [name: string]: string[] } = {};
+
+//   const contractAddress = AztecAddress.fromBigInt(987654n);
+
+//   const notesAndSlots: NoteAndSlot[] = Array(10)
+//     .fill(null)
+//     .map(() => ({
+//       note: new Note([Fr.random(), Fr.random(), Fr.random()]),
+//       storageSlot: Fr.random(),
+//       noteTypeId: Fr.random(),
+//       owner: { x: Fr.random(), y: Fr.random() },
+//     }));
+
+//   const createFakeSiloedCommitment = (commitment: Fr) => new Fr(commitment.value + 1n);
+//   const generateFakeCommitment = (noteAndSlot: NoteAndSlot) => noteAndSlot.note.items[0];
+//   const generateFakeSiloedCommitment = (note: NoteAndSlot) => createFakeSiloedCommitment(generateFakeCommitment(note));
+
+//   const createExecutionResult = (fnName: string, newNoteIndices: number[] = []): ExecutionResult => {
+//     const publicInputs = PrivateCircuitPublicInputs.empty();
+//     publicInputs.newNoteHashes = makeTuple(
+//       MAX_NEW_NOTE_HASHES_PER_CALL,
+//       i =>
+//         i < newNoteIndices.length
+//           ? new NoteHash(generateFakeCommitment(notesAndSlots[newNoteIndices[i]]), 0)
+//           : NoteHash.empty(),
+//       0,
+//     );
+//     const functionData = FunctionData.empty();
+//     functionData.selector = new FunctionSelector(fnName.charCodeAt(0));
+//     return {
+//       callStackItem: new PrivateCallStackItem(AztecAddress.ZERO, functionData, publicInputs),
+//       nestedExecutions: (dependencies[fnName] || []).map(name => createExecutionResult(name)), // LONDONTODO(Client): recursive call
+//       vk: VerificationKey.makeFake().toBuffer(),
+//       newNotes: newNoteIndices.map(idx => notesAndSlots[idx]),
+//       nullifiedNoteHashCounters: new Map(),
+//       noteHashLeafIndexMap: new Map(),
+//       returnValues: [],
+//       acir: Buffer.alloc(0), // LONDONTODO(Client): returning an empty circuit - doesn't ever appear to be populated with smthng nontrivial
+//       partialWitness: new Map(),
+//       enqueuedPublicFunctionCalls: [],
+//       publicTeardownFunctionCall: PublicCallRequest.empty(),
+//       noteEncryptedLogs: [],
+//       encryptedLogs: [],
+//       unencryptedLogs: [],
+//     };
+//   };
+
+//   const createProofOutput = (newNoteIndices: number[]) => {
+//     const publicInputs = PrivateKernelCircuitPublicInputs.empty();
+//     const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, ScopedNoteHash.empty);
+//     for (let i = 0; i < newNoteIndices.length; i++) {
+//       noteHashes[i] = new NoteHash(generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]), 0).scope(
+//         0,
+//         contractAddress,
+//       );
+//     }
+
+//     publicInputs.end.newNoteHashes = noteHashes;
+//     return {
+//       publicInputs,
+//       proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
+//       verificationKey: VerificationKeyAsFields.makeEmpty(),
+//     };
+//   };
+
+//   const createProofOutputFinal = (newNoteIndices: number[]) => {
+//     const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
+//     const noteHashes = makeTuple(MAX_NEW_NOTE_HASHES_PER_TX, () => Fr.ZERO);
+//     for (let i = 0; i < newNoteIndices.length; i++) {
+//       noteHashes[i] = generateFakeSiloedCommitment(notesAndSlots[newNoteIndices[i]]);
+//     }
+//     publicInputs.forRollup!.end.newNoteHashes = noteHashes;
+
+//     return {
+//       publicInputs,
+//       proof: makeRecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH),
+//       verificationKey: VerificationKeyAsFields.makeEmpty(),
+//     };
+//   };
+
+//   const createAppCircuitProofOutput = () => {
+//     return {
+//       proof: makeRecursiveProof<typeof RECURSIVE_PROOF_LENGTH>(RECURSIVE_PROOF_LENGTH),
+//       verificationKey: VerificationKeyAsFields.makeEmpty(),
+//     };
+//   };
+
+//   const expectExecution = (fns: string[]) => {
+//     const callStackItemsInit = proofCreator.createProofInit.mock.calls.map(args =>
+//       String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
+//     );
+//     const callStackItemsInner = proofCreator.createProofInner.mock.calls.map(args =>
+//       String.fromCharCode(args[0].privateCall.callStackItem.functionData.selector.value),
+//     );
+
+//     expect(proofCreator.createProofInit).toHaveBeenCalledTimes(Math.min(1, fns.length));
+//     expect(proofCreator.createProofInner).toHaveBeenCalledTimes(Math.max(0, fns.length - 1));
+//     expect(callStackItemsInit.concat(callStackItemsInner)).toEqual(fns);
+//     proofCreator.createProofInner.mockClear();
+//     proofCreator.createProofInit.mockClear();
+//   };
+
+//   const prove = (executionResult: ExecutionResult) => prover.prove(txRequest, executionResult);
+
+//   beforeEach(() => {
+//     txRequest = makeTxRequest();
+
+//     oracle = mock<ProvingDataOracle>();
+//     // TODO(dbanks12): will need to mock oracle.getNoteMembershipWitness() to test non-transient reads
+//     oracle.getVkMembershipWitness.mockResolvedValue(MembershipWitness.random(VK_TREE_HEIGHT));
+
+//     oracle.getContractAddressPreimage.mockResolvedValue({
+//       contractClassId: Fr.random(),
+//       publicKeysHash: Fr.random(),
+//       saltedInitializationHash: Fr.random(),
+//     });
+//     oracle.getContractClassIdPreimage.mockResolvedValue({
+//       artifactHash: Fr.random(),
+//       publicBytecodeCommitment: Fr.random(),
+//       privateFunctionsRoot: Fr.random(),
+//     });
+
+//     proofCreator = mock<ProofCreator>();
+//     proofCreator.getSiloedCommitments.mockImplementation(publicInputs =>
+//       Promise.resolve(publicInputs.newNoteHashes.map(com => createFakeSiloedCommitment(com.value))),
+//     );
+//     proofCreator.createProofInit.mockResolvedValue(createProofOutput([]));
+//     proofCreator.createProofInner.mockResolvedValue(createProofOutput([]));
+//     proofCreator.createProofReset.mockResolvedValue(createProofOutput([]));
+//     proofCreator.createProofTail.mockResolvedValue(createProofOutputFinal([]));
+//     proofCreator.createAppCircuitProof.mockResolvedValue(createAppCircuitProofOutput());
+
+//     prover = new KernelProver(oracle, proofCreator);
+//   });
+
+//   it('should create proofs in correct order', async () => {
+//     {
+//       dependencies = { a: [] };
+//       const executionResult = createExecutionResult('a');
+//       await prove(executionResult);
+//       expectExecution(['a']);
+//     }
+
+//     {
+//       dependencies = {
+//         a: ['b', 'd'],
+//         b: ['c'],
+//       };
+//       const executionResult = createExecutionResult('a');
+//       await prove(executionResult);
+//       expectExecution(['a', 'b', 'c', 'd']);
+//     }
+
+//     {
+//       dependencies = {
+//         k: ['m', 'o'],
+//         m: ['q'],
+//         o: ['n', 'p', 'r'],
+//       };
+//       const executionResult = createExecutionResult('k');
+//       await prove(executionResult);
+//       expectExecution(['k', 'm', 'q', 'o', 'n', 'p', 'r']);
+//     }
+//   });
+// });