@aztec/pxe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/contract_function_simulator/tagging_utils.ts

@@ -1,32 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { IndexedTaggingSecret } from '@aztec/stdlib/logs';
-
-// Half the size of the window we slide over the tagging secret indexes.
-export const WINDOW_HALF_SIZE = 10;
-
-export function getIndexedTaggingSecretsForTheWindow(
-  secretsAndWindows: { appTaggingSecret: Fr; leftMostIndex: number; rightMostIndex: number }[],
-): IndexedTaggingSecret[] {
-  const secrets: IndexedTaggingSecret[] = [];
-  for (const secretAndWindow of secretsAndWindows) {
-    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
-      secrets.push(new IndexedTaggingSecret(secretAndWindow.appTaggingSecret, i));
-    }
-  }
-  return secrets;
-}
-
-/**
- * Creates a map from app tagging secret to initial index.
- * @param indexedTaggingSecrets - The indexed tagging secrets to get the initial indexes from.
- * @returns The map from app tagging secret to initial index.
- */
-export function getInitialIndexesMap(indexedTaggingSecrets: IndexedTaggingSecret[]): { [k: string]: number } {
-  const initialIndexes: { [k: string]: number } = {};
-
-  for (const indexedTaggingSecret of indexedTaggingSecrets) {
-    initialIndexes[indexedTaggingSecret.appTaggingSecret.toString()] = indexedTaggingSecret.index;
-  }
-
-  return initialIndexes;
-}

package/src/pxe_service/index.ts

@@ -1,2 +0,0 @@
-export * from './pxe_service.js';
-export { enrichPublicSimulationError } from './error_enriching.js';

package/src/storage/address_data_provider/index.ts

@@ -1 +0,0 @@
-export { AddressDataProvider } from './address_data_provider.js';

package/src/storage/capsule_data_provider/index.ts

@@ -1 +0,0 @@
-export { CapsuleDataProvider } from './capsule_data_provider.js';

package/src/storage/contract_data_provider/index.ts

@@ -1 +0,0 @@
-export { ContractDataProvider } from './contract_data_provider.js';

package/src/storage/data_provider.ts

@@ -1,3 +0,0 @@
-export interface DataProvider {
-  getSize(): Promise<number>;
-}

package/src/storage/note_data_provider/index.ts

@@ -1,2 +0,0 @@
-export { NoteDao } from './note_dao.js';
-export { NoteDataProvider } from './note_data_provider.js';

package/src/storage/note_data_provider/note_dao.ts

@@ -1,154 +0,0 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr, Point } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Note } from '@aztec/stdlib/note';
-import { TxHash } from '@aztec/stdlib/tx';
-
-import type { NoteData } from '../../contract_function_simulator/oracle/typed_oracle.js';
-
-/**
- * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
- * information required to use it during execution and manage its state.
- */
-export class NoteDao implements NoteData {
-  constructor(
-    // Note information
-
-    /** The packed content of the note, as will be returned in the getNotes oracle. */
-    public note: Note,
-    /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
-    public contractAddress: AztecAddress,
-    /**
-     * The storage location of the note. This value is not used for anything in PXE, but we do index by storage slot
-     * since contracts typically make queries based on it.
-     */
-    public storageSlot: Fr,
-    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
-    public noteNonce: Fr,
-
-    // Computed values
-    /**
-     * The inner hash (non-unique, non-siloed) of the note. Each contract determines how the note is hashed. Can
-     * be used alongside contractAddress and nonce to compute the uniqueNoteHash and the siloedNoteHash.
-     */
-    public noteHash: Fr,
-    /**
-     * The nullifier of the note, siloed by contract address.
-     * Note: Might be set as 0 if the note was added to PXE as nullified.
-     */
-    public siloedNullifier: Fr,
-
-    // Metadata
-    /** The hash of the tx in which this note was created. Knowing the tx hash allows for efficient node queries e.g.
-     *  when searching for txEffects.
-     */
-    public txHash: TxHash,
-    /** The L2 block number in which the tx with this note was included. Used for note management while processing
-     * reorgs.*/
-    public l2BlockNumber: number,
-    /** The L2 block hash in which the tx with this note was included. Used for note management while processing
-     * reorgs.*/
-    public l2BlockHash: string,
-    /** The index of the leaf in the global note hash tree the note is stored at */
-    public index: bigint,
-    /**
-     * The address whose public key was used to encrypt the note log during delivery.
-     * (This is the x-coordinate of the public key.)
-     */
-    public recipient: AztecAddress,
-  ) {}
-
-  toBuffer(): Buffer {
-    return serializeToBuffer([
-      this.note,
-      this.contractAddress,
-      this.storageSlot,
-      this.noteNonce,
-      this.noteHash,
-      this.siloedNullifier,
-      this.txHash,
-      this.l2BlockNumber,
-      Fr.fromHexString(this.l2BlockHash),
-      this.index,
-      this.recipient,
-    ]);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-
-    const note = Note.fromBuffer(reader);
-    const contractAddress = AztecAddress.fromBuffer(reader);
-    const storageSlot = Fr.fromBuffer(reader);
-    const noteNonce = Fr.fromBuffer(reader);
-    const noteHash = Fr.fromBuffer(reader);
-    const siloedNullifier = Fr.fromBuffer(reader);
-    const txHash = reader.readObject(TxHash);
-    const l2BlockNumber = reader.readNumber();
-    const l2BlockHash = Fr.fromBuffer(reader).toString();
-    const index = toBigIntBE(reader.readBytes(32));
-    const recipient = AztecAddress.fromBuffer(reader);
-
-    return new NoteDao(
-      note,
-      contractAddress,
-      storageSlot,
-      noteNonce,
-      noteHash,
-      siloedNullifier,
-      txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      index,
-      recipient,
-    );
-  }
-
-  toString() {
-    return '0x' + this.toBuffer().toString('hex');
-  }
-
-  static fromString(str: string) {
-    const hex = str.replace(/^0x/, '');
-    return NoteDao.fromBuffer(Buffer.from(hex, 'hex'));
-  }
-
-  /**
-   * Returns the size in bytes of the Note Dao.
-   * @returns - Its size in bytes.
-   */
-  public getSize() {
-    const indexSize = Math.ceil(Math.log2(Number(this.index)));
-    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
-    return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize;
-  }
-
-  static async random({
-    note = Note.random(),
-    contractAddress = undefined,
-    storageSlot = Fr.random(),
-    noteNonce = Fr.random(),
-    noteHash = Fr.random(),
-    siloedNullifier = Fr.random(),
-    txHash = TxHash.random(),
-    l2BlockNumber = Math.floor(Math.random() * 1000),
-    l2BlockHash = Fr.random().toString(),
-    index = Fr.random().toBigInt(),
-    recipient = undefined,
-  }: Partial<NoteDao> = {}) {
-    return new NoteDao(
-      note,
-      contractAddress ?? (await AztecAddress.random()),
-      storageSlot,
-      noteNonce,
-      noteHash,
-      siloedNullifier,
-      txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      index,
-      recipient ?? (await AztecAddress.random()),
-    );
-  }
-}

package/src/storage/private_event_data_provider/private_event_data_provider.ts

@@ -1,134 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { AztecAsyncArray, AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { EventSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { TxHash } from '@aztec/stdlib/tx';
-
-import type { DataProvider } from '../data_provider.js';
-
-interface PrivateEventEntry {
-  msgContent: Buffer;
-  blockNumber: number;
-  eventCommitmentIndex: number;
-}
-
-/**
- * Stores decrypted private event logs.
- */
-export class PrivateEventDataProvider implements DataProvider {
-  #store: AztecAsyncKVStore;
-  /** Array storing the actual private event log entries containing the log content and block number */
-  #eventLogs: AztecAsyncArray<PrivateEventEntry>;
-  /** Map from contract_address_recipient_eventSelector to array of indices into #eventLogs for efficient lookup */
-  #eventLogIndex: AztecAsyncMap<string, number[]>;
-  /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
-  #seenLogs: AztecAsyncMap<number, boolean>;
-
-  logger = createLogger('private_event_data_provider');
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-    this.#eventLogs = this.#store.openArray('private_event_logs');
-    this.#eventLogIndex = this.#store.openMap('private_event_log_index');
-    this.#seenLogs = this.#store.openMap('seen_logs');
-  }
-
-  /**
-   * Store a private event log.
-   * @param contractAddress - The address of the contract that emitted the event.
-   * @param recipient - The recipient of the event.
-   * @param eventSelector - The event selector of the event.
-   * @param msgContent - The content of the event.
-   * @param txHash - The transaction hash of the event log.
-   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
-   * @param blockNumber - The block number in which the event was emitted.
-   */
-  storePrivateEventLog(
-    contractAddress: AztecAddress,
-    recipient: AztecAddress,
-    eventSelector: EventSelector,
-    msgContent: Fr[],
-    txHash: TxHash,
-    eventCommitmentIndex: number,
-    blockNumber: number,
-  ): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
-
-      // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
-      const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
-      if (hasBeenSeen) {
-        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), eventCommitmentIndex });
-        return;
-      }
-
-      this.logger.verbose('storing private event log', { contractAddress, recipient, msgContent, blockNumber });
-
-      const index = await this.#eventLogs.lengthAsync();
-      await this.#eventLogs.push({
-        msgContent: serializeToBuffer(msgContent),
-        blockNumber,
-        eventCommitmentIndex,
-      });
-
-      const existingIndices = (await this.#eventLogIndex.getAsync(key)) || [];
-      await this.#eventLogIndex.set(key, [...existingIndices, index]);
-
-      // Mark this log as seen using eventCommitmentIndex
-      await this.#seenLogs.set(eventCommitmentIndex, true);
-    });
-  }
-
-  /**
-   * Returns the private events given search parameters.
-   * @param contractAddress - The address of the contract to get events from.
-   * @param from - The block number to search from.
-   * @param numBlocks - The amount of blocks to search.
-   * @param recipients - The addresses that decrypted the logs.
-   * @param eventSelector - The event selector to filter by.
-   * @returns - The event log contents.
-   */
-  public async getPrivateEvents(
-    contractAddress: AztecAddress,
-    from: number,
-    numBlocks: number,
-    recipients: AztecAddress[],
-    eventSelector: EventSelector,
-  ): Promise<Fr[][]> {
-    const events: Array<{ msgContent: Fr[]; blockNumber: number; eventCommitmentIndex: number }> = [];
-
-    for (const recipient of recipients) {
-      const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
-      const indices = (await this.#eventLogIndex.getAsync(key)) || [];
-
-      for (const index of indices) {
-        const entry = await this.#eventLogs.atAsync(index);
-        if (!entry || entry.blockNumber < from || entry.blockNumber >= from + numBlocks) {
-          continue;
-        }
-
-        // Convert buffer back to Fr array
-        const reader = BufferReader.asReader(entry.msgContent);
-        const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
-        const msgContent = reader.readArray(numFields, Fr);
-
-        events.push({
-          msgContent,
-          blockNumber: entry.blockNumber,
-          eventCommitmentIndex: entry.eventCommitmentIndex,
-        });
-      }
-    }
-
-    // Sort by eventCommitmentIndex only
-    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
-
-    return events.map(e => e.msgContent);
-  }
-
-  getSize(): Promise<number> {
-    return this.#eventLogs.lengthAsync();
-  }
-}

package/src/storage/sync_data_provider/index.ts

@@ -1 +0,0 @@
-export { SyncDataProvider } from './sync_data_provider.js';

package/src/storage/tagging_data_provider/index.ts

@@ -1 +0,0 @@
-export { TaggingDataProvider } from './tagging_data_provider.js';

package/src/storage/tagging_data_provider/tagging_data_provider.ts

@@ -1,123 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { IndexedTaggingSecret } from '@aztec/stdlib/logs';
-
-export class TaggingDataProvider {
-  #store: AztecAsyncKVStore;
-  #addressBook: AztecAsyncMap<string, true>;
-
-  // Stores the last index used for each tagging secret, taking direction into account
-  // This is necessary to avoid reusing the same index for the same secret, which happens if
-  // sender and recipient are the same
-  #taggingSecretIndexesForSenders: AztecAsyncMap<string, number>;
-  #taggingSecretIndexesForRecipients: AztecAsyncMap<string, number>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-
-    this.#addressBook = this.#store.openMap('address_book');
-
-    this.#taggingSecretIndexesForSenders = this.#store.openMap('tagging_secret_indexes_for_senders');
-    this.#taggingSecretIndexesForRecipients = this.#store.openMap('tagging_secret_indexes_for_recipients');
-  }
-
-  setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[], sender: AztecAddress) {
-    return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders, sender);
-  }
-
-  setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[], recipient: AztecAddress) {
-    return this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients, recipient);
-  }
-
-  /**
-   * Sets the indexes of the tagging secrets for the given app tagging secrets in the direction of the given address.
-   * @dev We need to specify the direction because app tagging secrets are direction-less due to the way they are generated
-   * but we need to guarantee that the index is stored under a uni-directional key because the tags are themselves
-   * uni-directional.
-   * @param indexedSecrets - The app tagging secrets and indexes to set.
-   * @param storageMap - The storage map to set the indexes in.
-   * @param inDirectionOf - The address that the secrets are in the direction of.
-   */
-  #setTaggingSecretsIndexes(
-    indexedSecrets: IndexedTaggingSecret[],
-    storageMap: AztecAsyncMap<string, number>,
-    inDirectionOf: AztecAddress,
-  ) {
-    return Promise.all(
-      indexedSecrets.map(indexedSecret =>
-        storageMap.set(`${indexedSecret.appTaggingSecret.toString()}_${inDirectionOf.toString()}`, indexedSecret.index),
-      ),
-    );
-  }
-
-  getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[], recipient: AztecAddress) {
-    return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients, recipient);
-  }
-
-  getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[], sender: AztecAddress) {
-    return this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders, sender);
-  }
-
-  /**
-   * Returns the indexes of the tagging secrets for the given app tagging secrets in the direction of the given address.
-   * @dev We need to specify the direction because app tagging secrets are direction-less due to the way they are generated
-   * but we need to guarantee that the index is stored under a uni-directional key because the tags are themselves
-   * uni-directional.
-   * @param appTaggingSecrets - The app tagging secrets to get the indexes for.
-   * @param storageMap - The storage map to get the indexes from.
-   * @param inDirectionOf - The address that the secrets are in the direction of.
-   * @returns The indexes of the tagging secrets.
-   */
-  #getTaggingSecretsIndexes(
-    appTaggingSecrets: Fr[],
-    storageMap: AztecAsyncMap<string, number>,
-    inDirectionOf: AztecAddress,
-  ): Promise<number[]> {
-    return Promise.all(
-      appTaggingSecrets.map(
-        async secret => (await storageMap.getAsync(`${secret.toString()}_${inDirectionOf.toString()}`)) ?? 0,
-      ),
-    );
-  }
-
-  resetNoteSyncData(): Promise<void> {
-    return this.#store.transactionAsync(async () => {
-      const recipients = await toArray(this.#taggingSecretIndexesForRecipients.keysAsync());
-      await Promise.all(recipients.map(recipient => this.#taggingSecretIndexesForRecipients.delete(recipient)));
-      const senders = await toArray(this.#taggingSecretIndexesForSenders.keysAsync());
-      await Promise.all(senders.map(sender => this.#taggingSecretIndexesForSenders.delete(sender)));
-    });
-  }
-
-  async addSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (await this.#addressBook.hasAsync(address.toString())) {
-      return false;
-    }
-
-    await this.#addressBook.set(address.toString(), true);
-
-    return true;
-  }
-
-  async getSenderAddresses(): Promise<AztecAddress[]> {
-    return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-  }
-
-  async removeSenderAddress(address: AztecAddress): Promise<boolean> {
-    if (!(await this.#addressBook.hasAsync(address.toString()))) {
-      return false;
-    }
-
-    await this.#addressBook.delete(address.toString());
-
-    return true;
-  }
-
-  async getSize() {
-    const addressesCount = (await toArray(this.#addressBook.keysAsync())).length;
-    // All keys are addresses
-    return 3 * addressesCount * AztecAddress.SIZE_IN_BYTES;
-  }
-}

package/src/synchronizer/index.ts

@@ -1 +0,0 @@
-export * from './synchronizer.js';

package/src/test/pxe_test_suite.ts

@@ -1,113 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import {
-  randomContractArtifact,
-  randomContractInstanceWithAddress,
-  randomDeployedContract,
-} from '@aztec/stdlib/testing';
-
-import omit from 'lodash.omit';
-
-export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
-  describe(testName, () => {
-    let pxe: PXE;
-
-    beforeAll(async () => {
-      pxe = await pxeSetup();
-    }, 120_000);
-
-    it('registers an account and returns it as an account only and not as a recipient', async () => {
-      const randomSecretKey = Fr.random();
-      const randomPartialAddress = Fr.random();
-      const completeAddress = await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-
-      // Check that the account is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      expect(accounts).toContainEqual(completeAddress);
-    });
-
-    it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
-      const randomSecretKey = Fr.random();
-      const randomPartialAddress = Fr.random();
-
-      await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-      await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-    });
-
-    it('successfully adds a contract', async () => {
-      const contracts = await Promise.all([randomDeployedContract(), randomDeployedContract()]);
-      for (const contract of contracts) {
-        await pxe.registerContract(contract);
-      }
-
-      const expectedContractAddresses = contracts.map(contract => contract.instance.address);
-      const contractAddresses = await pxe.getContracts();
-      expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
-    });
-
-    it('registers a class and adds a contract for it', async () => {
-      const artifact = randomContractArtifact();
-      const contractClass = await getContractClassFromArtifact(artifact);
-      const contractClassId = contractClass.id;
-      const instance = await randomContractInstanceWithAddress({ contractClassId });
-
-      await pxe.registerContractClass(artifact);
-      expect((await pxe.getContractClassMetadata(contractClassId)).contractClass).toMatchObject(
-        omit(contractClass, 'privateFunctionsRoot', 'publicBytecodeCommitment'),
-      );
-
-      await pxe.registerContract({ instance });
-      expect((await pxe.getContractMetadata(instance.address)).contractInstance).toEqual(instance);
-    });
-
-    it('refuses to register a class with a mismatched address', async () => {
-      const artifact = randomContractArtifact();
-      const contractClass = await getContractClassFromArtifact(artifact);
-      const contractClassId = contractClass.id;
-      const instance = await randomContractInstanceWithAddress({ contractClassId });
-      await expect(
-        pxe.registerContract({
-          instance: {
-            ...instance,
-            address: await AztecAddress.random(),
-          },
-          artifact,
-        }),
-      ).rejects.toThrow(/Added a contract in which the address does not match the contract instance./);
-    });
-
-    it('refuses to register a contract with a class that has not been registered', async () => {
-      const instance = await randomContractInstanceWithAddress();
-      await expect(pxe.registerContract({ instance })).rejects.toThrow(
-        /Artifact not found when registering an instance/,
-      );
-    });
-
-    it('refuses to register a contract with an artifact with mismatching class id', async () => {
-      const artifact = randomContractArtifact();
-      const instance = await randomContractInstanceWithAddress();
-      await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
-    });
-
-    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `simulateUtility` here as it
-    //       requires a larger setup and it's sufficiently tested in the e2e tests.
-
-    // Note: Not testing `getContractData`, `getPublicLogs` and `getPublicStorageAt` here as these
-    //       functions only call AztecNode and these methods are frequently used by the e2e tests.
-
-    it('successfully gets a block number', async () => {
-      const blockNum = await pxe.getBlockNumber();
-      expect(blockNum).toBeGreaterThanOrEqual(INITIAL_L2_BLOCK_NUM);
-    });
-
-    it('successfully gets node info', async () => {
-      const nodeInfo = await pxe.getNodeInfo();
-      expect(typeof nodeInfo.rollupVersion).toEqual('number');
-      expect(typeof nodeInfo.l1ChainId).toEqual('number');
-      expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
-    });
-  });
-};