test(txe): struct support in oracle serialization roundtrip tests (#24588)

Author: nchamo

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

@@ -1,4 +1,4 @@
-use crate::oracle::{execution::get_utility_context, storage::storage_read};
+use crate::oracle::{execution::{get_utility_context, UtilityContextData}, storage::storage_read};
 use crate::protocol::{
     abis::block_header::BlockHeader, address::AztecAddress, constants::NULL_MSG_SENDER_CONTRACT_ADDRESS,
     traits::Packable,
@@ -11,6 +11,12 @@ pub struct UtilityContext {
     msg_sender: AztecAddress,
 }
 
+impl From<UtilityContextData> for UtilityContext {
+    fn from(data: UtilityContextData) -> Self {
+        Self { block_header: data.block_header, contract_address: data.contract_address, msg_sender: data.msg_sender }
+    }
+}
+
 impl UtilityContext {
     pub unconstrained fn new() -> Self {
         get_utility_context()

noir-projects/aztec-nr/aztec/src/macros/oracle_testing.nr

@@ -1,10 +1,20 @@
 use crate::context::UtilityContext;
+use crate::protocol::{abis::block_header::BlockHeader, address::AztecAddress};
+
+/// Wire shape of [`get_utility_context_oracle`]'s response. [`UtilityContext`] is built from it rather than returned
+/// directly so its fields stay private to its module.
+#[derive(Eq)]
+pub(crate) struct UtilityContextData {
+    pub(crate) block_header: BlockHeader,
+    pub(crate) contract_address: AztecAddress,
+    pub(crate) msg_sender: AztecAddress,
+}
 
 #[oracle(aztec_utl_getUtilityContext)]
-unconstrained fn get_utility_context_oracle() -> UtilityContext {}
+unconstrained fn get_utility_context_oracle() -> UtilityContextData {}
 
 /// Returns a utility context built from the global variables of anchor block and the contract address of the function
 /// being executed.
 pub unconstrained fn get_utility_context() -> UtilityContext {
-    get_utility_context_oracle()
+    UtilityContext::from(get_utility_context_oracle())
 }

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

@@ -16,16 +16,25 @@ use crate::macros::oracle_testing::{generate_oracle_tests, generate_oracle_tests
         quote { calldata_copy_opcode },
         quote { return_opcode },
         quote { revert_opcode },
-        // TODO: implement once we support more complex types
+        // TODO: implement once we support slices
         quote { emit_public_log_opcode },
         quote { returndata_copy_opcode },
     ],
 )]
 pub mod avm;
+#[generate_oracle_tests_excluding(
+    @[
+        // TODO: cover once the iv/sym_key BUFFER mapping is expressible as a plain fixed array of bytes, so the
+        // fixture synthesizer does not need to special-case it.
+        quote { aes128_decrypt_oracle },
+    ],
+)]
 pub mod aes128_decrypt;
 #[generate_oracle_tests]
 pub mod auth_witness;
+#[generate_oracle_tests]
 pub mod block_header;
+#[generate_oracle_tests]
 pub mod call_private_function;
 #[generate_oracle_tests]
 pub mod call_utility_function;
@@ -39,45 +48,71 @@ pub(crate) mod transient_oracles;
 pub mod contract_sync;
 #[generate_oracle_tests_excluding(
     @[
-        quote { record_fact_oracle }, // TODO: implement once we support more complex types
-        quote { get_fact_collection_oracle }, // TODO: implement once we support more complex types
-        quote { get_fact_collections_by_type_oracle }, // TODO: implement once we support more complex types
+        // TODO: implement once the test resolver can serve EphemeralArray contents.
+        quote { record_fact_oracle },
+        quote { get_fact_collection_oracle },
+        quote { get_fact_collections_by_type_oracle },
     ],
 )]
 pub mod fact_store;
 #[generate_oracle_tests]
 pub mod public_call;
+// TODO: cover with oracle tests once the test resolver can serve EphemeralArray contents.
 pub mod tx_resolution;
 #[generate_oracle_tests]
 pub mod resolve_custom_request;
 #[generate_oracle_tests_excluding(
     @[
-        quote { resolve_tagging_strategy_oracle }, // TODO: implement once we support more complex types
+        // TODO: needs a hand-written multi-scenario synthesizer entry (enum-like type with private fields,
+        // one named scenario per constructor) on both sides.
+        quote { resolve_tagging_strategy_oracle },
     ],
 )]
 pub mod resolve_tagging_strategy;
 #[generate_oracle_tests]
 pub mod tx_phase;
+#[generate_oracle_tests]
 pub mod execution;
 #[generate_oracle_tests]
 pub mod execution_cache;
+#[generate_oracle_tests]
+pub mod get_contract_instance;
 #[generate_oracle_tests_excluding(
     @[
-        quote { get_contract_instance_oracle }, // TODO: implement once we support more complex types
+        // TODO: cover once the sibling-path mapping is expressible as a plain fixed array
+        quote { get_l1_to_l2_membership_witness_oracle },
     ],
 )]
-pub mod get_contract_instance;
 pub mod get_l1_to_l2_membership_witness;
+#[generate_oracle_tests_excluding(
+    @[
+        // TODO: cover once the sibling-path mapping is expressible as a plain fixed array
+        quote { get_low_nullifier_membership_witness_oracle },
+        quote { get_nullifier_membership_witness_oracle },
+    ],
+)]
 pub mod get_nullifier_membership_witness;
+#[generate_oracle_tests_excluding(
+    @[
+        // TODO: cover once the sibling-path mapping is expressible as a plain fixed array
+        quote { get_public_data_witness_oracle },
+    ],
+)]
 pub mod get_public_data_witness;
+#[generate_oracle_tests]
 pub mod get_membership_witness;
+#[generate_oracle_tests]
 pub mod keys;
+#[generate_oracle_tests]
 pub mod key_validation_request;
+// TODO: cover with oracle tests once the two sides agree on the param grouping (TS wraps them in a single struct).
 pub mod logs;
+// TODO: cover with oracle tests once the test resolver can serve EphemeralArray contents.
 pub mod message_processing;
 #[generate_oracle_tests_excluding(
     @[
-        quote { get_notes_oracle }, // TODO: implement once we support more complex types
+        // TODO: implement once the test resolver can serve EphemeralArray contents.
+        quote { get_notes_oracle },
     ],
 )]
 pub mod notes;
@@ -89,6 +124,7 @@ pub mod offchain_effect;
 pub mod version;
 #[generate_oracle_tests]
 pub mod random;
+// TODO: cover with oracle tests once the test resolver can serve EphemeralArray contents.
 pub mod shared_secret;
 #[generate_oracle_tests]
 pub mod storage;

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

@@ -32,13 +32,16 @@ export {
   PENDING_TAGGED_LOG,
   POINT,
   PROVIDED_SECRET,
+  SLOT_NUMBER,
   STR,
   STRUCT,
   U32,
+  tryFieldWidth,
   type InputSlot,
   type MaybePromise,
   type OutputSlot,
   type SlotShape,
+  type StructField,
   type TypeMapping,
 } from './oracle/oracle_type_mappings.js';
 export { ExecutionNoteCache } from './execution_note_cache.js';

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

@@ -292,7 +292,7 @@ export const ETH_ADDRESS: TypeMapping<EthAddress> = {
   shape: ['scalar'],
 };
 
-const SLOT_NUMBER: TypeMapping<SlotNumber> = {
+export const SLOT_NUMBER: TypeMapping<SlotNumber> = {
   serialization: { fn: v => [new Fr(v)] },
   shape: ['scalar'],
 };
@@ -619,20 +619,26 @@ export function ARRAY<T>(inner: TypeMapping<T>): TypeMapping<T[]> & { kind: 'arr
 }
 
 /**
- * Noir's fixed-length array `[T; maxLength]` in one slot: serializes `values` (each flattened via `element`)
- * zero-padded to exactly `maxLength * elementWidth` fields, and deserializes all `maxLength` elements back. An absent
+ * Noir's fixed-length array `[T; length]` in one slot: serializes `values` (each flattened via `element`)
+ * zero-padded to exactly `length * elementWidth` fields, and deserializes all `length` elements back. An absent
  * element is the zero encoding, so the padding is derived from the shape.
  */
-export function FIXED_ARRAY<T>(element: TypeMapping<T>, maxLength: number): TypeMapping<T[]> {
+export function FIXED_ARRAY<T>(
+  element: TypeMapping<T>,
+  length: number,
+): TypeMapping<T[]> & { kind: 'fixed-array'; inner: TypeMapping<T>; length: number } {
   const elementWidth = fieldWidth(element.shape);
   return {
+    kind: 'fixed-array',
+    inner: element,
+    length,
     serialization: element.serialization
-      ? { fn: values => [padArrayEnd(packElements(element, values), Fr.ZERO, maxLength * elementWidth)] }
+      ? { fn: values => [padArrayEnd(packElements(element, values), Fr.ZERO, length * elementWidth)] }
       : undefined,
     deserialization: element.deserialization
-      ? { fn: ([reader]) => unpackElements(element, reader, maxLength) }
+      ? { fn: ([reader]) => unpackElements(element, reader, length) }
       : undefined,
-    shape: [{ len: maxLength * elementWidth }],
+    shape: [{ len: length * elementWidth }],
   };
 }
 
@@ -692,9 +698,15 @@ export function BOUNDED_VEC<T>(
  * (zero-padded) followed by the actual length, with no length prefix, so the width is statically known. Serialize-only.
  * Throws if the input exceeds `maxLength`.
  */
-export function FIXED_BOUNDED_VEC<T>(element: TypeMapping<T>, maxLength: number): TypeMapping<T[]> {
+export function FIXED_BOUNDED_VEC<T>(
+  element: TypeMapping<T>,
+  maxLength: number,
+): TypeMapping<T[]> & { kind: 'fixed-bounded-vec'; inner: TypeMapping<T>; maxLength: number } {
   const width = fieldWidth(element.shape);
   return {
+    kind: 'fixed-bounded-vec',
+    inner: element,
+    maxLength,
     serialization: element.serialization
       ? {
           fn: values => {
@@ -805,15 +817,19 @@ export function EPHEMERAL_ARRAY<T>(element: TypeMapping<T>): TypeMapping<Ephemer
 }
 
 /** A named field within a {@link STRUCT}: it owns however many wire slots its {@link TypeMapping} declares. */
-type StructField<TName extends string = string, T = any> = { name: TName; type: TypeMapping<T> };
+export type StructField<TName extends string = string, T = any> = { name: TName; type: TypeMapping<T> };
 
 /**
  * A Noir struct: its `shape` and (de)serialization are the concatenation of its fields', so callers never hand-write a
  * `shape`. `T` is the struct's TS value type and must match the field layout — serialization reads each field by name
  * off the value, deserialization returns the decoded bag as `T`; convert in the handler, not here, when `T` differs.
  */
-export function STRUCT<T>(fields: readonly StructField[]): TypeMapping<T> {
+export function STRUCT<T>(
+  fields: readonly StructField[],
+): TypeMapping<T> & { kind: 'struct'; fields: readonly StructField[] } {
   return {
+    kind: 'struct',
+    fields,
     serialization: fields.every(f => f.type.serialization)
       ? {
           fn: (value: T) => {
@@ -846,7 +862,7 @@ export function slotsOf(mapping: TypeMapping): number {
 }
 
 /** Number of fields a fully-static shape occupies, or `undefined` if any slot is variable-width. */
-function tryFieldWidth(shape: SlotShape[]): number | undefined {
+export function tryFieldWidth(shape: SlotShape[]): number | undefined {
   let total = 0;
   for (const slot of shape) {
     if (slot === 'scalar') {