@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.f295ac2

package/src/contract_function_simulator/execution_note_cache.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 
@@ -32,19 +32,22 @@ export class ExecutionNoteCache {
   private nullifierMap: Map<bigint, Set<bigint>> = new Map();
 
   /**
-   * All nullifiers emitted in this transaction.
+   * Nullifiers emitted by private calls in this transaction.
    */
-  private allNullifiers: Set<bigint> = new Set();
+  private emittedNullifiers: Set<bigint> = new Set();
 
+  /**
+   * The counter that separates non-revertible side effects (which persist even if the tx reverts) from revertible ones.
+   */
   private minRevertibleSideEffectCounter = 0;
 
   private inRevertiblePhase = false;
 
   /**
-   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
-   * In that case we disable injecting the tx request hash as a nullifier.
+   * Whether the protocol nullifier was used for nonce generation.
+   * We don't need to use the protocol nullifier if a non-revertible nullifier is emitted.
    */
-  private usedProtocolNullifierForNonces = true;
+  private usedProtocolNullifierForNonces: boolean | undefined;
 
   constructor(private readonly protocolNullifier: Fr) {}
 
@@ -60,17 +63,18 @@ export class ExecutionNoteCache {
     }
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
-    let nonceGenerator = this.protocolNullifier;
-    const nullifiers = this.getAllNullifiers();
-    if (nullifiers.length > 0) {
-      nonceGenerator = new Fr(nullifiers[0]);
-      this.usedProtocolNullifierForNonces = false;
-    }
+
+    const nullifiers = this.getEmittedNullifiers();
+    // If there are no nullifiers emitted by private calls so far, we use the protocol nullifier as the nonce generator.
+    // Note: There could still be nullifiers emitted after the counter is set, but those nullifiers are revertible, so
+    // we don't want to use them as the nonce generator.
+    this.usedProtocolNullifierForNonces = nullifiers.length === 0;
+    const nonceGenerator = this.usedProtocolNullifierForNonces ? this.protocolNullifier : new Fr(nullifiers[0]);
 
     // The existing pending notes are all non-revertible.
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
     // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
-    // The nonces will be used to create the "complete" nullifier.
+    // The nonces will be used to create the "unique" note hashes.
     const updatedNotes = await Promise.all(
       this.notes.map(async ({ note, counter }, i) => {
         const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
@@ -99,15 +103,11 @@ export class ExecutionNoteCache {
   }
 
   public finish() {
-    // If we never entered the revertible phase, we need to use the protocol nullifier to compute the nonces for the
-    // notes if no nullifiers have been emitted.
+    // If we never entered the revertible phase, and there are no nullifiers emitted, we need to use the protocol
+    // nullifier as the nonce generator.
     if (!this.inRevertiblePhase) {
-      this.usedProtocolNullifierForNonces = this.getAllNullifiers().length === 0;
+      this.usedProtocolNullifierForNonces = this.getEmittedNullifiers().length === 0;
     }
-    // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
-    return {
-      usedProtocolNullifierForNonces: this.usedProtocolNullifierForNonces,
-    };
   }
 
   /**
@@ -150,11 +150,11 @@ export class ExecutionNoteCache {
 
       // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
       if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
-        this.recordNullifier(contractAddress, siloedNullifier);
+        this.#recordNullifier(contractAddress, siloedNullifier);
       }
     } else {
       // If the note being nullified comes from a previous tx the nullifier will be emitted.
-      this.recordNullifier(contractAddress, siloedNullifier);
+      this.#recordNullifier(contractAddress, siloedNullifier);
     }
     return nullifiedNoteHashCounter;
   }
@@ -166,19 +166,22 @@ export class ExecutionNoteCache {
    */
   public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
     const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
-    this.recordNullifier(contractAddress, siloedNullifier);
+    this.#recordNullifier(contractAddress, siloedNullifier);
   }
 
   /**
    * Return notes created up to current point in execution.
    * If a nullifier for a note in this list is emitted, the note will be deleted.
    * @param contractAddress - Contract address of the notes.
-   * @param owner - Owner of the notes.
+   * @param owner - Owner of the notes. If undefined, returns all notes regardless of owner.
    * @param storageSlot - Storage slot of the notes.
    **/
-  public getNotes(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr) {
+  public getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr) {
     const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
-    return notes.filter(n => n.note.owner.equals(owner) && n.note.storageSlot.equals(storageSlot)).map(n => n.note);
+    return notes
+      .filter(n => owner === undefined || n.note.owner.equals(owner))
+      .filter(n => n.note.storageSlot.equals(storageSlot))
+      .map(n => n.note);
   }
 
   /**
@@ -212,11 +215,30 @@ export class ExecutionNoteCache {
     return this.notes;
   }
 
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction.
+   */
+  getEmittedNullifiers(): Fr[] {
+    return [...this.emittedNullifiers].map(n => new Fr(n));
+  }
+
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction. If the protocol nullifier was used as the
+   * nonce generator, it is injected as the first nullifier.
+   */
   getAllNullifiers(): Fr[] {
-    return [...this.allNullifiers].map(n => new Fr(n));
+    if (this.usedProtocolNullifierForNonces === undefined) {
+      throw new Error('usedProtocolNullifierForNonces is not set yet. Call finish() to complete the transaction.');
+    }
+    const allNullifiers = this.getEmittedNullifiers();
+    return [...(this.usedProtocolNullifierForNonces ? [this.protocolNullifier] : []), ...allNullifiers];
+  }
+
+  getNonceGenerator(): Fr {
+    return this.getAllNullifiers()[0];
   }
 
-  recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
+  #recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
     const nullifiers = this.getNullifiers(contractAddress);
 
     if (nullifiers.has(siloedNullifier)) {
@@ -225,6 +247,6 @@ export class ExecutionNoteCache {
 
     nullifiers.add(siloedNullifier);
     this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-    this.allNullifiers.add(siloedNullifier);
+    this.emittedNullifiers.add(siloedNullifier);
   }
 }

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -21,7 +21,7 @@ export class ExecutionTaggingIndexCache {
   }
 
   /**
-   * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+   * Returns the pre-tags that were used in this execution (and that need to be stored in the db).
    */
   public getUsedPreTags(): PreTag[] {
     return Array.from(this.taggingIndexMap.entries()).map(([secret, index]) => ({

package/src/contract_function_simulator/hashed_values_cache.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { HashedValues } from '@aztec/stdlib/tx';
 
 /**

package/src/contract_function_simulator/noir-structs/event_validation_request.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { EventSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -15,6 +15,7 @@ export class EventValidationRequest {
   constructor(
     public contractAddress: AztecAddress,
     public eventTypeId: EventSelector,
+    public randomness: Fr,
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
@@ -27,6 +28,8 @@ export class EventValidationRequest {
     const contractAddress = AztecAddress.fromField(reader.readField());
     const eventTypeId = EventSelector.fromField(reader.readField());
 
+    const randomness = reader.readField();
+
     const eventStorage = reader.readFieldArray(MAX_EVENT_SERIALIZED_LEN);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
@@ -38,6 +41,7 @@ export class EventValidationRequest {
     return new EventValidationRequest(
       contractAddress,
       eventTypeId,
+      randomness,
       serializedEvent,
       eventCommitment,
       txHash,

package/src/contract_function_simulator/noir-structs/log_retrieval_request.ts

@@ -1,6 +1,7 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Tag } from '@aztec/stdlib/logs';
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
@@ -9,19 +10,19 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 export class LogRetrievalRequest {
   constructor(
     public contractAddress: AztecAddress,
-    public unsiloedTag: Fr,
+    public tag: Tag,
   ) {}
 
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), this.unsiloedTag];
+    return [this.contractAddress.toField(), this.tag.value];
   }
 
   static fromFields(fields: Fr[] | FieldReader): LogRetrievalRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
-    const unsiloedTag = reader.readField();
+    const tag = new Tag(reader.readField());
 
-    return new LogRetrievalRequest(contractAddress, unsiloedTag);
+    return new LogRetrievalRequest(contractAddress, tag);
   }
 }

package/src/contract_function_simulator/noir-structs/log_retrieval_response.ts

@@ -1,6 +1,6 @@
 import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { range } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 import { MAX_NOTE_PACKED_LEN } from './note_validation_request.js';

package/src/contract_function_simulator/noir-structs/note_validation_request.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxHash } from '@aztec/stdlib/tx';

package/src/contract_function_simulator/noir-structs/utility_context.ts

@@ -1,42 +1,23 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { toACVMField } from '@aztec/simulator/client';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { UInt64 } from '@aztec/stdlib/types';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
 /**
  * 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,
+  constructor(
+    public readonly blockHeader: BlockHeader,
     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,
-    ];
+    const blockHeaderFields = this.blockHeader.toFields().map(toACVMField);
+    return [...blockHeaderFields, this.contractAddress.toString() as string];
   }
 }

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -1,16 +1,17 @@
 import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import type { ContractClassLog } from '@aztec/stdlib/logs';
+import type { ContractClassLog, Tag } from '@aztec/stdlib/logs';
 import type { Note, NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
-import type { Tag } from '../../tagging/tag.js';
 import type { UtilityContext } from '../noir-structs/utility_context.js';
 import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 
@@ -32,10 +33,10 @@ export interface NoteData {
   noteNonce: Fr;
   /** A hash of the note as it gets stored in the note hash tree. */
   noteHash: Fr;
+  /** True if the note is pending, false if settled. */
+  isPending: boolean;
   /** The corresponding nullifier of the note. Undefined for pending notes. */
   siloedNullifier?: Fr;
-  /** The note's leaf index in the note hash tree. Undefined for pending notes. */
-  index?: bigint;
 }
 
 // These interfaces contain the list of oracles required by aztec-nr in order to simulate and execute transactions, i.e.
@@ -62,24 +63,24 @@ export interface IMiscOracle {
 export interface IUtilityExecutionOracle {
   isUtility: true;
 
-  utilityGetUtilityContext(): Promise<UtilityContext>;
+  utilityGetUtilityContext(): UtilityContext;
   utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
   utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance>;
-  utilityGetMembershipWitness(blockNumber: BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
+  utilityGetMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
   utilityGetNullifierMembershipWitness(
-    blockNumber: BlockNumber,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
-  utilityGetPublicDataWitness(blockNumber: BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  utilityGetPublicDataWitness(blockHash: L2BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
   utilityGetLowNullifierMembershipWitness(
-    blockNumber: BlockNumber,
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
   utilityGetBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
   utilityGetPublicKeysAndPartialAddress(account: AztecAddress): Promise<CompleteAddress>;
   utilityGetAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
   utilityGetNotes(
-    owner: AztecAddress,
+    owner: AztecAddress | undefined,
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -102,9 +103,9 @@ export interface IUtilityExecutionOracle {
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
   utilityStorageRead(
+    blockHash: L2BlockHash,
     contractAddress: AztecAddress,
     startStorageSlot: Fr,
-    blockNumber: BlockNumber,
     numberOfElements: number,
   ): Promise<Fr[]>;
   utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;

package/src/contract_function_simulator/oracle/message_load_oracle_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { SiblingPath } from '@aztec/foundation/trees';
 
 export class MessageLoadOracleInputs<N extends number> {

package/src/contract_function_simulator/oracle/note_packing_utils.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { Note } from '@aztec/stdlib/note';
 
@@ -24,31 +24,45 @@ function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { sta
  * and only after that it packs the retrieved note. Hence it doesn't map one to one with `RetrievedNote::pack()`.
  *
  * @param contractAddress - The address of the contract that owns the note
+ * @param owner - The owner of the note
  * @param randomness - The randomness injected into the note to get the hiding property of commitments
+ * @param storageSlot - The storage slot of the note
  * @param noteNonce - The nonce injected into the note hash preimage by kernels.
- * @param index - Optional index in the note hash tree. If undefined, indicates a transient note
+ * @param isPending - True if the note is pending, false if settled
  * @param note - The note content containing the actual note data
  * @returns The packed note as an array of field elements
  */
 export function packAsRetrievedNote({
   contractAddress,
+  owner,
   randomness,
+  storageSlot,
   noteNonce,
-  index,
+  isPending,
   note,
 }: {
   contractAddress: AztecAddress;
+  owner: AztecAddress;
   randomness: Fr;
+  storageSlot: Fr;
   noteNonce: Fr;
-  index?: bigint;
+  isPending: boolean;
   note: Note;
 }) {
-  // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-  const nonzeroNoteHashCounter = index === undefined;
+  // If the note is pending it means it has a non-zero note hash counter associated with it.
+  const nonZeroNoteHashCounter = isPending;
 
   // To pack the note as retrieved note we first need to reconstruct the note metadata.
-  const noteMetadata = fromRawData(nonzeroNoteHashCounter, noteNonce);
+  const noteMetadata = fromRawData(nonZeroNoteHashCounter, noteNonce);
 
-  // Pack metadata first (stage and maybe_note_nonce), followed by the rest
-  return [...note.items, contractAddress, randomness, new Fr(noteMetadata.stage), noteMetadata.maybeNoteNonce];
+  // Pack in order: note, contract_address, owner, randomness, storage_slot, metadata (stage, maybe_note_nonce)
+  return [
+    ...note.items,
+    contractAddress,
+    owner,
+    randomness,
+    storageSlot,
+    new Fr(noteMetadata.stage),
+    noteMetadata.maybeNoteNonce,
+  ];
 }

package/src/contract_function_simulator/oracle/oracle.ts

@@ -1,5 +1,6 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import {
   type ACIRCallback,
   type ACVMField,
@@ -11,6 +12,7 @@ import {
 } from '@aztec/simulator/client';
 import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import { ContractClassLog, ContractClassLogFields } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
@@ -111,9 +113,9 @@ export class Oracle {
     return [values.map(toACVMField)];
   }
 
-  async utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
-    const context = await this.handlerAsUtility().utilityGetUtilityContext();
-    return context.toNoirRepresentation();
+  utilityGetUtilityContext(): Promise<(ACVMField | ACVMField[])[]> {
+    const context = this.handlerAsUtility().utilityGetUtilityContext();
+    return Promise.resolve(context.toNoirRepresentation());
   }
 
   async utilityGetKeyValidationRequest([pkMHash]: ACVMField[]): Promise<ACVMField[]> {
@@ -137,76 +139,77 @@ export class Oracle {
   }
 
   async utilityGetMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [treeId]: ACVMField[],
     [leafValue]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedTreeId = Fr.fromString(treeId).toNumber();
     const parsedLeafValue = Fr.fromString(leafValue);
 
     const witness = await this.handlerAsUtility().utilityGetMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedTreeId,
       parsedLeafValue,
     );
     if (!witness) {
       throw new Error(
-        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block ${parsedBlockNumber}.`,
+        `Leaf ${leafValue} not found in the tree ${MerkleTreeId[parsedTreeId]} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return [toACVMField(witness[0]), witness.slice(1).map(toACVMField)];
   }
 
   async utilityGetNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the witness for (to prove inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetNullifierMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
-      throw new Error(`Nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetLowNullifierMembershipWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [nullifier]: ACVMField[], // nullifier, we try to find the low nullifier witness for (to prove non-inclusion)
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedNullifier = Fr.fromString(nullifier);
 
     const witness = await this.handlerAsUtility().utilityGetLowNullifierMembershipWitness(
-      BlockNumber(parsedBlockNumber),
+      parsedBlockHash,
       parsedNullifier,
     );
     if (!witness) {
       throw new Error(
-        `Low nullifier witness not found for nullifier ${parsedNullifier} at block ${parsedBlockNumber}.`,
+        `Low nullifier witness not found for nullifier ${parsedNullifier} at block hash ${parsedBlockHash.toString()}.`,
       );
     }
     return witness.toNoirRepresentation();
   }
 
   async utilityGetPublicDataWitness(
-    [blockNumber]: ACVMField[],
+    [blockHash]: ACVMField[],
     [leafSlot]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
-    const parsedBlockNumber = Fr.fromString(blockNumber).toNumber();
+    const parsedBlockHash = L2BlockHash.fromString(blockHash);
     const parsedLeafSlot = Fr.fromString(leafSlot);
 
-    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(
-      BlockNumber(parsedBlockNumber),
-      parsedLeafSlot,
-    );
+    const witness = await this.handlerAsUtility().utilityGetPublicDataWitness(parsedBlockHash, parsedLeafSlot);
     if (!witness) {
-      throw new Error(`Public data witness not found for slot ${parsedLeafSlot} at block ${parsedBlockNumber}.`);
+      throw new Error(
+        `Public data witness not found for slot ${parsedLeafSlot} at block hash ${parsedBlockHash.toString()}.`,
+      );
     }
     return witness.toNoirRepresentation();
   }
@@ -239,7 +242,8 @@ export class Oracle {
   }
 
   async utilityGetNotes(
-    [owner]: ACVMField[],
+    [ownerSome]: ACVMField[],
+    [ownerValue]: ACVMField[],
     [storageSlot]: ACVMField[],
     [numSelects]: ACVMField[],
     selectByIndexes: ACVMField[],
@@ -257,8 +261,10 @@ export class Oracle {
     [maxNotes]: ACVMField[],
     [packedRetrievedNoteLength]: ACVMField[],
   ): Promise<(ACVMField | ACVMField[])[]> {
+    // Parse Option<AztecAddress>: ownerSome is 0 for None, 1 for Some
+    const owner = Fr.fromString(ownerSome).toNumber() === 1 ? AztecAddress.fromString(ownerValue) : undefined;
     const noteDatas = await this.handlerAsUtility().utilityGetNotes(
-      AztecAddress.fromString(owner),
+      owner,
       Fr.fromString(storageSlot),
       +numSelects,
       selectByIndexes.map(s => +s),
@@ -275,7 +281,17 @@ export class Oracle {
       +status,
     );
 
-    const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(packAsRetrievedNote);
+    const returnDataAsArrayOfPackedRetrievedNotes = noteDatas.map(noteData =>
+      packAsRetrievedNote({
+        contractAddress: noteData.contractAddress,
+        owner: noteData.owner,
+        randomness: noteData.randomness,
+        storageSlot: noteData.storageSlot,
+        noteNonce: noteData.noteNonce,
+        isPending: noteData.isPending,
+        note: noteData.note,
+      }),
+    );
 
     // Now we convert each sub-array to an array of ACVMField
     const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfPackedRetrievedNotes.map(subArray =>
@@ -344,15 +360,15 @@ export class Oracle {
   }
 
   async utilityStorageRead(
+    [blockHash]: ACVMField[],
     [contractAddress]: ACVMField[],
     [startStorageSlot]: ACVMField[],
-    [blockNumber]: ACVMField[],
     [numberOfElements]: ACVMField[],
   ): Promise<ACVMField[][]> {
     const values = await this.handlerAsUtility().utilityStorageRead(
+      L2BlockHash.fromString(blockHash),
       new AztecAddress(Fr.fromString(contractAddress)),
       Fr.fromString(startStorageSlot),
-      BlockNumber(+blockNumber),
       +numberOfElements,
     );
     return [values.map(toACVMField)];