feat: utilityGetUtilityContext oracle (#16179)

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 4 to 1. This should
significantly speed up utility function execution when there is a high
latency between PXE and the node.

## Bug fix in this PR
Before, in PXE, 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'));
   }