feat: utilityGetUtilityContext oracle

Introduces a new `utilityGetUtilityContext` oracle that returns all the info needed for `UtilityContext` construction in a single call. This reduces the number of `AztecNode` calls from 5 to 1. This should significantly speed up utility function execution when there is a high latency between PXE and the node.

## Bug fix
Before this PR there was a serious bug in the `UtilityContext` construction because it was constructed based on values obtained from aztec node. This is just wrong because the simulation should be run against the `PXE`'s view of the network state and not against the node's view. I think we didn't stumble upon this being an issue because we perform a sync right when the simulation is started. But I think it would be inevitable to happen that a node would sync a block from p2p in between the initial `PXE` sync and construction of the utility context and at that point we would enter an undefined behavior and a world of pain of debugging.

## Followup work
As Nico mentioned in review round 1 seems to make sense to nuke the following oracles:
- `utilityGetChainId`
- `utilityGetVersion`
- `utilityGetTimestamp`

and possibly also
- `utilityGetBlockNumber`

as all these values are contained inside the response from the `utilityGetUtilityContext` oracle. That would also allow me to nuke these handlers from `PXEOracleInterface` which would make me very happy because the naming there was terrible (`PXEOracleInterface::getBlockHeader` returned block header of the latest block synchronized by `PXE` while `getTimestamp` and `getBlockNumber` returned values from aztec node.

Author: benesjan

barretenberg/cpp/src/barretenberg/vm2/common/protocol_contract_data.cpp

@@ -4,12 +4,12 @@
 namespace bb::avm2 {
 
 const std::unordered_map<CanonicalAddress, DerivedAddress> derived_addresses = {
-    { CANONICAL_AUTH_REGISTRY_ADDRESS, AztecAddress("0x1c2474a77af3c756895867fa7622e5e9295121b35849e965f4614d51f00c62e2") },
-	{ CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, AztecAddress("0x1f4284dea3e475d9d40283c7fe4c1aef5cdea59c012a8fa84c0c9ebe0752327e") },
-	{ CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, AztecAddress("0x1bd2e13b35e2745e638132262e6642a86ac4219f1b7a95086bebe250f5d557ea") },
-	{ MULTI_CALL_ENTRYPOINT_ADDRESS, AztecAddress("0x27b35c8e0851d28c56846ce8977155ffbb5725c4e6b47a67f5d5c6639d1c1a1c") },
-	{ FEE_JUICE_ADDRESS, AztecAddress("0x2ee34a2d304636f81114dffc8a2357e03e08345a008262eb36112f95aaa58eb1") },
-	{ ROUTER_ADDRESS, AztecAddress("0x180b58198cce7c0866a828841df6eca6369a71a6e884ca5cf08938301d7ad0ca") }
+    { CANONICAL_AUTH_REGISTRY_ADDRESS, AztecAddress("0x18544daa308f64e57ec663f668b0ea3b0cbebd1eb97f8df5aeb39e8d8719ecf5") },
+	{ CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, AztecAddress("0x171962d76064dbcb6fcb6ab6cbb32205bb47b55a5c74debcbe17ae62582817ce") },
+	{ CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, AztecAddress("0x016b8b23f165308f796bb8f578bbf4b9931dd0a90d99c7c2d2dddacdde181552") },
+	{ MULTI_CALL_ENTRYPOINT_ADDRESS, AztecAddress("0x2b1c3ae38d7f786b5509c369dc5e14d5ed42ad7bcbc11333cd67f2470d84a1c5") },
+	{ FEE_JUICE_ADDRESS, AztecAddress("0x006806d65634d483ae6e8b00cfa4fcbd6b1ed3af44370d893230ed6256ca6f15") },
+	{ ROUTER_ADDRESS, AztecAddress("0x05ccb6ee750c3b88305ebbc2c7390a6c08bf70f7a14eb48f9ab25af6c55da3c3") }
 };
 
 } // namespace bb::avm2

noir-projects/aztec-nr/aztec/src/context/utility_context.nr

@@ -1,9 +1,7 @@
-use crate::oracle::{
-    execution::{get_block_number, get_chain_id, get_contract_address, get_timestamp, get_version},
-    storage::storage_read,
-};
-use dep::protocol_types::{address::AztecAddress, traits::Packable};
+use crate::oracle::{execution::get_utility_context, storage::storage_read};
+use protocol_types::{address::AztecAddress, traits::Packable};
 
+// If you'll modify this struct don't forget to update utility_context.ts as well.
 pub struct UtilityContext {
     block_number: u32,
     timestamp: u64,
@@ -14,31 +12,35 @@ pub struct UtilityContext {
 
 impl UtilityContext {
     pub unconstrained fn new() -> Self {
-        // We could call these oracles on the getters instead of at creation, which makes sense given that they might
-        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user
-        // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not
-        // available.
-        let block_number = get_block_number();
-        let timestamp = get_timestamp();
-        let contract_address = get_contract_address();
-        let version = get_version();
-        let chain_id = get_chain_id();
-        Self { block_number, timestamp, contract_address, version, chain_id }
+        get_utility_context()
     }
 
     pub unconstrained fn at(contract_address: AztecAddress) -> Self {
-        let block_number = get_block_number();
-        let timestamp = get_timestamp();
-        let chain_id = get_chain_id();
-        let version = get_version();
-        Self { block_number, timestamp, contract_address, version, chain_id }
+        // We get a context with default contract address, and then we construct the final context with the provided
+        // contract address.
+        let default_context = get_utility_context();
+
+        Self {
+            block_number: default_context.block_number,
+            timestamp: default_context.timestamp,
+            contract_address,
+            version: default_context.version,
+            chain_id: default_context.chain_id,
+        }
     }
 
     pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {
-        let timestamp = get_timestamp();
-        let chain_id = get_chain_id();
-        let version = get_version();
-        Self { block_number, timestamp, contract_address, version, chain_id }
+        // We get a context with default contract address and block number, and then we construct the final context
+        // with the provided contract address and block number.
+        let default_context = get_utility_context();
+
+        Self {
+            block_number,
+            timestamp: default_context.timestamp,
+            contract_address,
+            version: default_context.version,
+            chain_id: default_context.chain_id,
+        }
     }
 
     pub fn block_number(self) -> u32 {

noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr

@@ -288,10 +288,9 @@ pub(crate) comptime fn transform_utility(f: FunctionDefinition) {
     // Create utility context
     let context_creation =
         quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };
-    let module_has_storage = module_has_storage(f.module());
 
     // Initialize Storage if module has storage
-    let storage_init = if module_has_storage {
+    let storage_init = if module_has_storage(f.module()) {
         quote {
             // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is
             // referenced. We instead ignore 'unused variable' warnings for it.

noir-projects/aztec-nr/aztec/src/messages/discovery/mod.nr

@@ -61,10 +61,13 @@ pub struct NoteHashAndNullifier {
 /// ```
 type ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* note nonce */ Field) -> Option<NoteHashAndNullifier>;
 
-/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,
-/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.
+/// Performs the message discovery process, in which private logs are downloaded and inspected to find new private
+/// notes, partial notes and events, etc., and pending partial notes are processed to search for their completion logs.
 /// This is the mechanism via which a contract updates its knowledge of its private state.
 ///
+/// Note that the state is synchronized up to the latest block synchronized by PXE. That should be close to the chain
+/// tip as block synchronization is performed before contract function simulation is done.
+///
 /// Receives the address of the contract on which discovery is performed along with its
 /// `compute_note_hash_and_nullifier` function.
 pub unconstrained fn discover_new_messages<Env>(

noir-projects/aztec-nr/aztec/src/oracle/execution.nr

@@ -1,3 +1,4 @@
+use crate::context::utility_context::UtilityContext;
 use dep::protocol_types::address::AztecAddress;
 
 #[oracle(utilityGetContractAddress)]
@@ -15,6 +16,9 @@ unconstrained fn get_chain_id_oracle() -> Field {}
 #[oracle(utilityGetVersion)]
 unconstrained fn get_version_oracle() -> Field {}
 
+#[oracle(utilityGetUtilityContext)]
+unconstrained fn get_utility_context_oracle() -> UtilityContext {}
+
 pub unconstrained fn get_contract_address() -> AztecAddress {
     get_contract_address_oracle()
 }
@@ -34,3 +38,7 @@ pub unconstrained fn get_chain_id() -> Field {
 pub unconstrained fn get_version() -> Field {
     get_version_oracle()
 }
+
+pub unconstrained fn get_utility_context() -> UtilityContext {
+    get_utility_context_oracle()
+}

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

@@ -9,3 +9,4 @@ export { Oracle } from './oracle/oracle.js';
 export { executePrivateFunction, extractPrivateCircuitPublicInputs } from './oracle/private_execution.js';
 export { generateSimulatedProvingResult } from './contract_function_simulator.js';
 export { packAsRetrievedNote } from './oracle/note_packing_utils.js';
+export { UtilityContext } from './noir-structs/utility_context.js';

yarn-project/pxe/src/contract_function_simulator/noir-structs/utility_context.ts

@@ -0,0 +1,42 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+/**
+ * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
+ */
+export class UtilityContext {
+  private constructor(
+    public readonly blockNumber: number,
+    public readonly timestamp: UInt64,
+    public readonly contractAddress: AztecAddress,
+    public readonly version: Fr,
+    public readonly chainId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<UtilityContext>) {
+    return new UtilityContext(
+      fields.blockNumber,
+      fields.timestamp,
+      fields.contractAddress,
+      fields.version,
+      fields.chainId,
+    );
+  }
+
+  /**
+   * Returns a representation of the utility context as expected by intrinsic Noir deserialization.
+   * The order of the fields has to be the same as the order of the fields in the utility_context.nr.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.blockNumber).toString() as string,
+      new Fr(this.timestamp).toString() as string,
+      this.contractAddress.toString() as string,
+      this.version.toString() as string,
+      this.chainId.toString() as string,
+    ];
+  }
+}

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

@@ -98,6 +98,11 @@ export class Oracle {
     return [toACVMField(await this.typedOracle.utilityGetChainId())];
   }
 
+  async utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = await this.typedOracle.utilityGetUtilityContext();
+    return context.toNoirRepresentation();
+  }
+
   async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
     const keyValidationRequest = await this.typedOracle.utilityGetKeyValidationRequest(Fr.fromString(pkMHash));
 

yarn-project/pxe/src/contract_function_simulator/oracle/oracle_version_is_checked.test.ts

@@ -23,10 +23,6 @@ describe('Oracle Version Check test suite', () => {
     executionDataProvider = mock<ExecutionDataProvider>();
 
     // Mock basic oracle responses
-    executionDataProvider.getChainId.mockResolvedValue(1);
-    executionDataProvider.getVersion.mockResolvedValue(1);
-    executionDataProvider.getTimestamp.mockResolvedValue(0n);
-    executionDataProvider.getBlockNumber.mockResolvedValue(1);
     executionDataProvider.getPublicStorageAt.mockResolvedValue(Fr.ZERO);
     executionDataProvider.loadCapsule.mockImplementation((_, __) => Promise.resolve(null));
     executionDataProvider.getBlockHeader.mockResolvedValue(BlockHeader.empty());

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

@@ -10,6 +10,7 @@ import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness }
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
+import type { UtilityContext } from '../noir-structs/utility_context.js';
 import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 
 /**
@@ -82,6 +83,10 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError(this.className, 'utilityGetVersion'));
   }
 
+  utilityGetUtilityContext(): Promise<UtilityContext> {
+    return Promise.reject(new OracleMethodNotAvailableError(this.className, 'utilityGetUtilityContext'));
+  }
+
   utilityGetKeyValidationRequest(_pkMHash: Fr): Promise<KeyValidationRequest> {
     return Promise.reject(new OracleMethodNotAvailableError(this.className, 'utilityGetKeyValidationRequest'));
   }