@aztec/pxe 0.0.1-commit.9b94fc1 → 0.0.1-commit.9ee6fcc6

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,18 +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. If undefined, returns all notes regardless of owner.
    * @param storageSlot - Storage slot of the notes.
    **/
-  public getNotes(contractAddress: 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.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);
   }
 
   /**
@@ -211,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)) {
@@ -224,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

@@ -1,32 +1,37 @@
-import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+import { ExtendedDirectionalAppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
 /**
- * A map that stores the tagging index for a given directional app tagging secret.
+ * A map that stores the tagging index range for a given extended directional app tagging secret.
  * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
  * of sender -> recipient matters.
  */
 export class ExecutionTaggingIndexCache {
-  private taggingIndexMap: Map<string, number> = new Map();
+  private taggingIndexMap: Map<string, { lowestIndex: number; highestIndex: number }> = new Map();
 
-  public getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined {
-    return this.taggingIndexMap.get(secret.toString());
+  public getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString())?.highestIndex;
   }
 
-  public setLastUsedIndex(secret: DirectionalAppTaggingSecret, index: number) {
+  public setLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, index: number) {
     const currentValue = this.taggingIndexMap.get(secret.toString());
-    if (currentValue !== undefined && currentValue !== index - 1) {
-      throw new Error(`Invalid tagging index update. Current value: ${currentValue}, new value: ${index}`);
+    if (currentValue !== undefined && currentValue.highestIndex !== index - 1) {
+      throw new Error(`Invalid tagging index update. Current value: ${currentValue.highestIndex}, new value: ${index}`);
+    }
+    if (currentValue !== undefined) {
+      currentValue.highestIndex = index;
+    } else {
+      this.taggingIndexMap.set(secret.toString(), { lowestIndex: index, highestIndex: index });
     }
-    this.taggingIndexMap.set(secret.toString(), index);
   }
 
   /**
-   * Returns the pre tags that were used in this execution (and that need to be stored in the db).
+   * Returns the tagging index ranges 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]) => ({
-      secret: DirectionalAppTaggingSecret.fromString(secret),
-      index,
+  public getUsedTaggingIndexRanges(): TaggingIndexRange[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, { lowestIndex, highestIndex }]) => ({
+      extendedSecret: ExtendedDirectionalAppTaggingSecret.fromString(secret),
+      lowestIndex,
+      highestIndex,
     }));
   }
 }

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/index.ts

@@ -4,10 +4,11 @@ export { HashedValuesCache } from './hashed_values_cache.js';
 export { pickNotes } from './pick_notes.js';
 export type { NoteData, IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
 export { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
+export { MessageContextService } from '../messages/message_context_service.js';
 export { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
 export { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 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 { packAsHintedNote } from './oracle/note_packing_utils.js';
 export { UtilityContext } from './noir-structs/utility_context.js';

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

@@ -1,33 +1,33 @@
-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';
 import { TxHash } from '@aztec/stdlib/tx';
 
-// TODO(#14617): should we compute this from constants? This value is aztec-nr specific.
-const MAX_EVENT_SERIALIZED_LEN = 12;
-
 /**
- * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
+ * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
  * expects for values of this type to be stored in a `CapsuleArray`.
  */
 export class EventValidationRequest {
   constructor(
     public contractAddress: AztecAddress,
     public eventTypeId: EventSelector,
+    public randomness: Fr,
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
     public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): EventValidationRequest {
+  static fromFields(fields: Fr[], maxEventSerializedLen: number): EventValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
     const eventTypeId = EventSelector.fromField(reader.readField());
 
-    const eventStorage = reader.readFieldArray(MAX_EVENT_SERIALIZED_LEN);
+    const randomness = reader.readField();
+
+    const eventStorage = reader.readFieldArray(maxEventSerializedLen);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
 
@@ -35,9 +35,16 @@ export class EventValidationRequest {
     const txHash = TxHash.fromField(reader.readField());
     const recipient = AztecAddress.fromField(reader.readField());
 
+    if (reader.remainingFields() !== 0) {
+      throw new Error(
+        `Error converting array of fields to EventValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+      );
+    }
+
     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,12 +1,9 @@
 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';
-
-const MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION = MAX_NOTE_PACKED_LEN;
-const MAX_LOG_CONTENT_LEN = Math.max(MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION, PRIVATE_LOG_CIPHERTEXT_LEN);
+const MAX_LOG_CONTENT_LEN = PRIVATE_LOG_CIPHERTEXT_LEN;
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this

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

@@ -0,0 +1,55 @@
+import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { range } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Intermediate struct used to return resolved message contexts from PXE. The
+ * `utilityResolveMessageContexts` oracle stores values of this type in a CapsuleArray.
+ */
+export class MessageTxContext {
+  constructor(
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+  ) {}
+
+  toFields(): Fr[] {
+    return [
+      this.txHash.hash,
+      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+    ];
+  }
+
+  static toEmptyFields(): Fr[] {
+    const serializationLen =
+      1 /* txHash */ + MAX_NOTE_HASHES_PER_TX + 1 /* uniqueNoteHashesInTx BVec */ + 1; /* firstNullifierInTx */
+    return range(serializationLen).map(_ => Fr.zero());
+  }
+
+  static toSerializedOption(response: MessageTxContext | null): Fr[] {
+    if (response) {
+      return [new Fr(1), ...response.toFields()];
+    } else {
+      return [new Fr(0), ...MessageTxContext.toEmptyFields()];
+    }
+  }
+}
+
+/**
+ * Helper function to serialize a bounded vector according to Noir's BoundedVec format
+ * @param values - The values to serialize
+ * @param maxLength - The maximum length of the bounded vector
+ * @returns The serialized bounded vector as Fr[]
+ */
+function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
+  if (values.length > maxLength) {
+    throw new Error(`Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`);
+  }
+
+  const lengthDiff = maxLength - values.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
+  const storage = values.concat(zeroPaddingArray);
+  return [...storage, new Fr(values.length)];
+}

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

@@ -1,18 +1,16 @@
-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';
 
-// TODO(#14617): should we compute this from constants? This value is aztec-nr specific.
-export const MAX_NOTE_PACKED_LEN = 11;
-
 /**
- * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
+ * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
  * expects for values of this type to be stored in a `CapsuleArray`.
  */
 export class NoteValidationRequest {
   constructor(
     public contractAddress: AztecAddress,
+    public owner: AztecAddress,
     public storageSlot: Fr,
     public randomness: Fr,
     public noteNonce: Fr,
@@ -23,15 +21,16 @@ export class NoteValidationRequest {
     public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): NoteValidationRequest {
+  static fromFields(fields: Fr[], maxNotePackedLen: number): NoteValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
+    const owner = AztecAddress.fromField(reader.readField());
     const storageSlot = reader.readField();
     const randomness = reader.readField();
     const noteNonce = reader.readField();
 
-    const contentStorage = reader.readFieldArray(MAX_NOTE_PACKED_LEN);
+    const contentStorage = reader.readFieldArray(maxNotePackedLen);
     const contentLen = reader.readField().toNumber();
     const content = contentStorage.slice(0, contentLen);
 
@@ -42,12 +41,13 @@ export class NoteValidationRequest {
 
     if (reader.remainingFields() !== 0) {
       throw new Error(
-        `Error converting array of fields to NoteValidationRequest. Hint: check that MAX_NOTE_PACKED_LEN is consistent with private_notes::MAX_NOTE_PACKED_LEN in Aztec-nr.`,
+        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxNotePackedLen=${maxNotePackedLen}).`,
       );
     }
 
     return new NoteValidationRequest(
       contractAddress,
+      owner,
       storageSlot,
       randomness,
       noteNonce,

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];
   }
 }