@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/contract_function_simulator/execution_note_cache.ts

@@ -0,0 +1,252 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+
+import type { NoteData } from './oracle/interfaces.js';
+
+interface PendingNote {
+  note: NoteData;
+  counter: number;
+  noteHashForConsumption: Fr;
+}
+
+/**
+ * Data that's accessible by all the function calls in an execution.
+ */
+export class ExecutionNoteCache {
+  /**
+   * New notes created in this transaction.
+   * They are pushed to this array in the same order as they are emitted.
+   */
+  private notes: PendingNote[] = [];
+  /**
+   * This mapping maps from a contract address to the notes in the contract.
+   */
+  private noteMap: Map<bigint, PendingNote[]> = new Map();
+
+  /**
+   * This maps from a contract address to the nullifiers emitted from the contract.
+   * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
+   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
+   */
+  private nullifierMap: Map<bigint, Set<bigint>> = new Map();
+
+  /**
+   * Nullifiers emitted by private calls in this transaction.
+   */
+  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;
+
+  /**
+   * 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: boolean | undefined;
+
+  constructor(private readonly protocolNullifier: Fr) {}
+
+  /**
+   * Enters the revertible phase of the transaction.
+   * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
+   */
+  public async setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
+    if (this.inRevertiblePhase) {
+      throw new Error(
+        `Cannot enter the revertible phase twice. Current counter: ${minRevertibleSideEffectCounter}. Previous enter counter: ${this.minRevertibleSideEffectCounter}`,
+      );
+    }
+    this.inRevertiblePhase = true;
+    this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
+
+    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 "unique" note hashes.
+    const updatedNotes = await Promise.all(
+      this.notes.map(async ({ note, counter }, i) => {
+        const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
+        const uniqueNoteHash = await computeUniqueNoteHash(
+          noteNonce,
+          await siloNoteHash(note.contractAddress, note.noteHash),
+        );
+        return {
+          counter,
+          note: { ...note, noteNonce },
+          noteHashForConsumption: uniqueNoteHash,
+        };
+      }),
+    );
+    // Rebuild the data.
+    this.notes = [];
+    this.noteMap = new Map();
+    updatedNotes.forEach(n => this.#addNote(n));
+  }
+
+  public isSideEffectCounterRevertible(sideEffectCounter: number): boolean {
+    if (!this.inRevertiblePhase) {
+      return false;
+    }
+    return sideEffectCounter >= this.minRevertibleSideEffectCounter;
+  }
+
+  public finish() {
+    // 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.getEmittedNullifiers().length === 0;
+    }
+  }
+
+  /**
+   * Add a new note to cache.
+   * @param note - New note created during execution.
+   */
+  public addNewNote(note: NoteData, counter: number) {
+    const previousNote = this.notes[this.notes.length - 1];
+    if (previousNote && previousNote.counter >= counter) {
+      throw new Error(
+        `Note hash counters must be strictly increasing. Current counter: ${counter}. Previous counter: ${previousNote.counter}.`,
+      );
+    }
+
+    this.#addNote({ note, counter, noteHashForConsumption: note.noteHash });
+  }
+
+  /**
+   * Add a nullifier to cache. It could be for a db note or a new note created during execution.
+   * @param contractAddress - Contract address of the note.
+   * @param innerNullifier - Inner nullifier of the note.
+   * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
+   * transaction (and thus not a new note).
+   */
+  public async nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
+    const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
+    let nullifiedNoteHashCounter: number | undefined = undefined;
+    // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
+    if (!noteHash.isEmpty()) {
+      const notesInContract = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+      const noteIndexToRemove = notesInContract.findIndex(n => n.noteHashForConsumption.equals(noteHash));
+      if (noteIndexToRemove === -1) {
+        throw new Error('Attempt to remove a pending note that does not exist.');
+      }
+
+      const note = notesInContract.splice(noteIndexToRemove, 1)[0];
+      nullifiedNoteHashCounter = note.counter;
+      this.noteMap.set(contractAddress.toBigInt(), notesInContract);
+      this.notes = this.notes.filter(n => n.counter !== note.counter);
+
+      // 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);
+      }
+    } else {
+      // If the note being nullified comes from a previous tx the nullifier will be emitted.
+      this.#recordNullifier(contractAddress, siloedNullifier);
+    }
+    return nullifiedNoteHashCounter;
+  }
+
+  /**
+   * Adds a nullifier to the cache. Note cache needs to track all nullifiers to decide which nullifier to use for note siloing.
+   * @param contractAddress - Contract address that emitted the nullifier.
+   * @param innerNullifier
+   */
+  public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
+    const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
+    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, owner: AztecAddress | undefined, storageSlot: Fr) {
+    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+    return notes
+      .filter(n => owner === undefined || n.note.owner.equals(owner))
+      .filter(n => n.note.storageSlot.equals(storageSlot))
+      .map(n => n.note);
+  }
+
+  /**
+   * Check if a note exists in the newNotes array.
+   * @param contractAddress - Contract address of the note.
+   * @param storageSlot - Storage slot of the note.
+   * @param noteHash - A hash of the note.
+   **/
+  public checkNoteExists(contractAddress: AztecAddress, noteHash: Fr) {
+    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+    return notes.some(n => n.note.noteHash.equals(noteHash));
+  }
+
+  /**
+   * Return all nullifiers emitted from a contract.
+   * @param contractAddress - Address of the contract.
+   */
+  public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
+    return this.nullifierMap.get(contractAddress.toBigInt()) ?? new Set();
+  }
+
+  #addNote(note: PendingNote) {
+    this.notes.push(note);
+
+    const notes = this.noteMap.get(note.note.contractAddress.toBigInt()) ?? [];
+    notes.push(note);
+    this.noteMap.set(note.note.contractAddress.toBigInt(), notes);
+  }
+
+  getAllNotes(): PendingNote[] {
+    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[] {
+    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) {
+    const nullifiers = this.getNullifiers(contractAddress);
+
+    if (nullifiers.has(siloedNullifier)) {
+      throw new Error(`Duplicate siloed nullifier ${siloedNullifier} emitted by contract ${contractAddress}`);
+    }
+
+    nullifiers.add(siloedNullifier);
+    this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
+    this.emittedNullifiers.add(siloedNullifier);
+  }
+}

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -0,0 +1,32 @@
+import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+
+/**
+ * A map that stores the tagging index for a given 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();
+
+  public getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString());
+  }
+
+  public setLastUsedIndex(secret: DirectionalAppTaggingSecret, 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}`);
+    }
+    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).
+   */
+  public getUsedPreTags(): PreTag[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, index]) => ({
+      secret: DirectionalAppTaggingSecret.fromString(secret),
+      index,
+    }));
+  }
+}

package/src/contract_function_simulator/hashed_values_cache.ts

@@ -0,0 +1,47 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { HashedValues } from '@aztec/stdlib/tx';
+
+/**
+ * A cache for hashed values (arguments, returns) during transaction execution.
+ */
+export class HashedValuesCache {
+  private cache: Map<bigint, Fr[]>;
+
+  constructor(initialArguments: HashedValues[] = []) {
+    this.cache = new Map();
+    for (const initialArg of initialArguments) {
+      this.cache.set(initialArg.hash.toBigInt(), initialArg.values);
+    }
+  }
+
+  /**
+   * Creates a new hashed values cache.
+   * @param initialArguments - The initial arguments to add to the cache.
+   * @returns The new hashed values cache.
+   */
+  public static create(initialArguments: HashedValues[] = []) {
+    return new HashedValuesCache(initialArguments);
+  }
+
+  /**
+   * Gets preimage of a hash.
+   * @param hash - The hash to get the preimage of.
+   * @returns The preimage.
+   */
+  public getPreimage(hash: Fr): Fr[] | undefined {
+    if (hash.isEmpty()) {
+      return [];
+    } else {
+      return this.cache.get(hash.toBigInt());
+    }
+  }
+
+  /**
+   * Stores values in cache and returns its hash.
+   * @param values - The values to store.
+   * @returns The hash of the values.
+   */
+  public store(values: Fr[], hash: Fr) {
+    this.cache.set(hash.toBigInt(), values);
+  }
+}

package/src/contract_function_simulator/index.ts

@@ -0,0 +1,13 @@
+export { ExecutionNoteCache } from './execution_note_cache.js';
+export { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
+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 { 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 { 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

@@ -0,0 +1,51 @@
+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 `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 {
+    const reader = FieldReader.asReader(fields);
+
+    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);
+
+    const eventCommitment = reader.readField();
+    const txHash = TxHash.fromField(reader.readField());
+    const recipient = AztecAddress.fromField(reader.readField());
+
+    return new EventValidationRequest(
+      contractAddress,
+      eventTypeId,
+      randomness,
+      serializedEvent,
+      eventCommitment,
+      txHash,
+      recipient,
+    );
+  }
+}

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

@@ -0,0 +1,28 @@
+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
+ * type to be stored in a `CapsuleArray`.
+ */
+export class LogRetrievalRequest {
+  constructor(
+    public contractAddress: AztecAddress,
+    public tag: Tag,
+  ) {}
+
+  toFields(): Fr[] {
+    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 tag = new Tag(reader.readField());
+
+    return new LogRetrievalRequest(contractAddress, tag);
+  }
+}

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

@@ -0,0 +1,69 @@
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
+import { range } from '@aztec/foundation/array';
+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);
+
+/**
+ * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
+ * type in a `CapsuleArray`.
+ */
+export class LogRetrievalResponse {
+  constructor(
+    public logPayload: Fr[],
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+  ) {}
+
+  toFields(): Fr[] {
+    return [
+      // We need to trim the payload since public logs can be larger than MAX_LOG_CONTENT_LEN.
+      // This is currently not a problem since this class is only used with public logs for note completion.
+      ...serializeBoundedVec(this.logPayload.slice(0, MAX_LOG_CONTENT_LEN), MAX_LOG_CONTENT_LEN),
+      this.txHash.hash,
+      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+    ];
+  }
+
+  static toEmptyFields(): Fr[] {
+    const serializationLen =
+      MAX_LOG_CONTENT_LEN +
+      1 /* logPayload BVec */ +
+      1 /* txHash */ +
+      MAX_NOTE_HASHES_PER_TX +
+      1 /* uniqueNoteHashesInTx BVec */ +
+      1; /* firstNullifierInTx */
+    return range(serializationLen).map(_ => Fr.zero());
+  }
+
+  static toSerializedOption(response: LogRetrievalResponse | null): Fr[] {
+    if (response) {
+      return [new Fr(1), ...response.toFields()];
+    } else {
+      return [new Fr(0), ...LogRetrievalResponse.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

@@ -0,0 +1,64 @@
+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 = 10;
+
+/**
+ * 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,
+    public content: Fr[],
+    public noteHash: Fr,
+    public nullifier: Fr,
+    public txHash: TxHash,
+    public recipient: AztecAddress,
+  ) {}
+
+  static fromFields(fields: Fr[] | FieldReader): 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 contentLen = reader.readField().toNumber();
+    const content = contentStorage.slice(0, contentLen);
+
+    const noteHash = reader.readField();
+    const nullifier = reader.readField();
+    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 NoteValidationRequest. Hint: check that MAX_NOTE_PACKED_LEN is consistent with private_notes::MAX_NOTE_PACKED_LEN in Aztec-nr.`,
+      );
+    }
+
+    return new NoteValidationRequest(
+      contractAddress,
+      owner,
+      storageSlot,
+      randomness,
+      noteNonce,
+      content,
+      noteHash,
+      nullifier,
+      txHash,
+      recipient,
+    );
+  }
+}

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

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

package/src/contract_function_simulator/oracle/index.ts

@@ -0,0 +1,16 @@
+import type { Oracle } from './oracle.js';
+
+export * from './oracle.js';
+export * from './interfaces.js';
+
+/**
+ * A conditional type that takes a type `T` and returns a union of its method names.
+ */
+type MethodNames<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+/**
+ * Available oracle function names.
+ */
+export type ORACLE_NAMES = MethodNames<Oracle>;