refactor(pxe): decompose PXEOracleInterface

Deprecate `PXEOracleInterface` in favor of more granular and explicit dependencies.

I apologize in advance for the length of this PR, the commits show the progression that led to this final form, and prove that the end result didn't come to me OTOH, but it was the result of dozens of stepwise refactors. At the current state it is possible to spin multiple little PRs off this one if that's deemed saner, it just wasn't clear that would be the case when I originally set out to do this.

## New service layer

To replace `PXEOracleInterface` (aka `ExecutionDataProvider`), and at the same time keep oracle classes relatively lean and concerns separated, I'm introducing a service layer on top of the existing providers layer.

Due to this PR being big enough as is, and there being more pressing issues to address, I'm not applying this idea to completion, just using it where it helps me untangle things. I do think going further in this direction would help make everything be more unit testable.

The core rules of thumb behind this (long term) are:

- Providers shouldn't talk to each other. This is a simplicity forcing function. Providers are database abstractions.
- Services can talk to each other, and to the provider(s) they encapsulate. Each provider should only be accessed by one service, but one service can manage multiple data providers. So: services get other read/write data needs met by talking to other services.
- The rest of the app talks to services instead of directly to providers. Again, I'm not tackling that here because the PR is big enough as is, but it's an architecture we could slowly move towards.

## Capsules as plumbing

Something that became clear along the way of this refactor is that capsule state management in many cases is a transport concern, and as such code becomes much more cohesive if we separate the code that deals with that, from the code that actually operates on the contents. Maybe the nicest example of that can be seen in `utilityBulkRetrieveLogs`.

## Working with Anchor blocks

I think most of the places where we now consume `AnchorBlockDataProvider` to get the current anchor block, should be modified to instead receive the anchor block as param, which will make it easier to see that in reality the anchor block is pinned for a given `ContractFunctionSimulator` activation. That, in turn, should make the work on DB integrity easier, and it will also be helpful to eventually adopt a less conservative approach towards concurrency.

## Temporary complexity increase (waiting for new tagging sync work)

There are some parts of the app that might look a bit more convoluted with this refactor, mostly due to porting sync tagging functionality to make things compile and pass tests. Note that @benesjan is overhauling sync tagging, so I'm deliberately not investing effort on simplifying those parts and will instead wait and see what's necessary once that work is available.

Some specific cases of this situation are found on:
- Test setup of `oracle_version_is_checked.test.ts`: it got much more complex given `ContractFunctionSimulator` now receives all the data providers it needs to operate instead of hiding everything under `PXEOracleInterface`. A lot of this complexity is probably derived from the old tag sync'ing logic and I'm expecting it to just disintegrate.
- `private_execution.test.ts`: I'm hoping a lot of the boilerplate will be unnecessary once the new work on tagging lands.
- `LogService` and its tests

Fixes #17776

Author: mverzilli

yarn-project/pxe/src/contract_function_simulator/contract_function_simulator.ts

@@ -21,6 +21,7 @@ import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import type { KeyStore } from '@aztec/key-store';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import {
@@ -44,6 +45,7 @@ import {
   siloNoteHash,
   siloNullifier,
 } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import {
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
@@ -69,15 +71,22 @@ import {
   getFinalMinRevertibleSideEffectCounter,
 } from '@aztec/stdlib/tx';
 
-import type { ContractDataProvider } from '../storage/index.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
+import type { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
+import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+import type { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
+import type { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
+import type { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
+import type { PrivateEventDataProvider } from '../storage/private_event_data_provider/private_event_data_provider.js';
+import type { RecipientTaggingDataProvider } from '../storage/tagging_data_provider/recipient_tagging_data_provider.js';
+import type { SenderTaggingDataProvider } from '../storage/tagging_data_provider/sender_tagging_data_provider.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
 import { Oracle } from './oracle/oracle.js';
 import { executePrivateFunction, verifyCurrentClassId } from './oracle/private_execution.js';
 import { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 import { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
+import type { ProxiedNode } from './proxied_node.js';
 
 /**
  * The contract function simulator.
@@ -86,7 +95,16 @@ export class ContractFunctionSimulator {
   private log: Logger;
 
   constructor(
-    private executionDataProvider: ExecutionDataProvider,
+    private contractDataProvider: ContractDataProvider,
+    private noteDataProvider: NoteDataProvider,
+    private keyStore: KeyStore,
+    private addressDataProvider: AddressDataProvider,
+    private aztecNode: AztecNode,
+    private anchorBlockDataProvider: AnchorBlockDataProvider,
+    private senderTaggingDataProvider: SenderTaggingDataProvider,
+    private recipientTaggingDataProvider: RecipientTaggingDataProvider,
+    private capsuleDataProvider: CapsuleDataProvider,
+    private privateEventDataProvider: PrivateEventDataProvider,
     private simulator: CircuitSimulator,
   ) {
     this.log = createLogger('simulator');
@@ -116,9 +134,12 @@ export class ContractFunctionSimulator {
   ): Promise<PrivateExecutionResult> {
     const simulatorSetupTimer = new Timer();
 
-    await verifyCurrentClassId(contractAddress, this.executionDataProvider, anchorBlockHeader);
+    await verifyCurrentClassId(contractAddress, this.aztecNode, this.contractDataProvider, anchorBlockHeader);
 
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
+    const entryPointArtifact = await this.contractDataProvider.getFunctionArtifactWithDebugMetadata(
+      contractAddress,
+      selector,
+    );
 
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
@@ -154,7 +175,16 @@ export class ContractFunctionSimulator {
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
       taggingIndexCache,
-      this.executionDataProvider,
+      this.contractDataProvider,
+      this.noteDataProvider,
+      this.keyStore,
+      this.addressDataProvider,
+      this.aztecNode,
+      this.anchorBlockDataProvider,
+      this.senderTaggingDataProvider,
+      this.recipientTaggingDataProvider,
+      this.capsuleDataProvider,
+      this.privateEventDataProvider,
       0, // totalPublicArgsCount
       startSideEffectCounter,
       undefined, // log
@@ -226,9 +256,12 @@ export class ContractFunctionSimulator {
     anchorBlockHeader: BlockHeader,
     scopes?: AztecAddress[],
   ): Promise<Fr[]> {
-    await verifyCurrentClassId(call.to, this.executionDataProvider, anchorBlockHeader);
+    await verifyCurrentClassId(call.to, this.aztecNode, this.contractDataProvider, anchorBlockHeader);
 
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(call.to, call.selector);
+    const entryPointArtifact = await this.contractDataProvider.getFunctionArtifactWithDebugMetadata(
+      call.to,
+      call.selector,
+    );
 
     if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
@@ -239,7 +272,16 @@ export class ContractFunctionSimulator {
       authwits,
       [],
       anchorBlockHeader,
-      this.executionDataProvider,
+      this.contractDataProvider,
+      this.noteDataProvider,
+      this.keyStore,
+      this.addressDataProvider,
+      this.aztecNode,
+      this.anchorBlockDataProvider,
+      this.senderTaggingDataProvider,
+      this.recipientTaggingDataProvider,
+      this.capsuleDataProvider,
+      this.privateEventDataProvider,
       undefined,
       scopes,
     );
@@ -274,8 +316,15 @@ export class ContractFunctionSimulator {
   }
   // docs:end:execute_utility_function
 
+  /**
+   * Returns the execution statistics collected during the simulator run.
+   * @returns The execution statistics.
+   */
   getStats() {
-    return this.executionDataProvider.getStats();
+    const nodeRPCCalls =
+      typeof (this.aztecNode as ProxiedNode).getStats === 'function' ? (this.aztecNode as ProxiedNode).getStats() : {};
+
+    return { nodeRPCCalls };
   }
 }