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

package/src/storage/private_event_data_provider/private_event_data_provider.ts

@@ -0,0 +1,148 @@
+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 { L2BlockHash } from '@aztec/stdlib/block';
+import { TxHash } from '@aztec/stdlib/tx';
+
+interface PrivateEventEntry {
+  msgContent: Buffer;
+  blockNumber: number;
+  blockHash: Buffer;
+  eventCommitmentIndex: number;
+  txHash: Buffer;
+}
+
+export type PrivateEvent = {
+  msgContent: Fr[];
+  blockNumber: number;
+  blockHash: L2BlockHash;
+  txHash: TxHash;
+  recipient: AztecAddress;
+};
+
+/**
+ * Stores decrypted private event logs.
+ */
+export class PrivateEventDataProvider {
+  #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,
+    blockHash: L2BlockHash,
+  ): 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,
+        blockHash: blockHash.toBuffer(),
+        eventCommitmentIndex,
+        txHash: txHash.toBuffer(),
+      });
+
+      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<PrivateEvent[]> {
+    const events: Array<{ eventCommitmentIndex: number; event: PrivateEvent }> = [];
+
+    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);
+        const txHash = TxHash.fromBuffer(entry.txHash);
+        const blockHash = L2BlockHash.fromBuffer(entry.blockHash);
+
+        events.push({
+          eventCommitmentIndex: entry.eventCommitmentIndex,
+          event: {
+            msgContent,
+            blockNumber: entry.blockNumber,
+            recipient,
+            txHash,
+            blockHash,
+          },
+        });
+      }
+    }
+
+    // Sort by eventCommitmentIndex only
+    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
+    return events.map(ev => ev.event);
+  }
+}

package/src/storage/sync_data_provider/sync_data_provider.ts

@@ -1,9 +1,7 @@
 import type { AztecAsyncKVStore, AztecAsyncSingleton } from '@aztec/kv-store';
 import { BlockHeader } from '@aztec/stdlib/tx';
 
-import type { DataProvider } from '../data_provider.js';
-
-export class SyncDataProvider implements DataProvider {
+export class SyncDataProvider {
   #store: AztecAsyncKVStore;
   #synchronizedHeader: AztecAsyncSingleton<Buffer>;
 
@@ -16,13 +14,13 @@ export class SyncDataProvider implements DataProvider {
     await this.#synchronizedHeader.set(header.toBuffer());
   }
 
-  async getBlockNumber(): Promise<number | undefined> {
+  async getBlockNumber(): Promise<number> {
     const headerBuffer = await this.#synchronizedHeader.getAsync();
     if (!headerBuffer) {
-      return undefined;
+      throw new Error(`Trying to get block number with a not-yet-synchronized PXE - this should never happen`);
     }
 
-    return Number(BlockHeader.fromBuffer(headerBuffer).globalVariables.blockNumber.toBigInt());
+    return BlockHeader.fromBuffer(headerBuffer).globalVariables.blockNumber;
   }
 
   async getBlockHeader(): Promise<BlockHeader> {
@@ -33,8 +31,4 @@ export class SyncDataProvider implements DataProvider {
 
     return BlockHeader.fromBuffer(headerBuffer);
   }
-
-  async getSize(): Promise<number> {
-    return (await this.#synchronizedHeader.getAsync())?.length ?? 0;
-  }
 }

package/src/storage/tagging_data_provider/tagging_data_provider.ts

@@ -1,62 +1,90 @@
-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';
+import type { DirectionalAppTaggingSecret, PreTag } 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>;
+  // Stores the last used index for each directional app tagging secret. Taking into account whether we are
+  // requesting the index as a sender or as a recipient because the sender and recipient can be in the same PXE.
+  #lastUsedIndexesAsSenders: AztecAsyncMap<string, number>;
+  #lastUsedIndexesAsRecipients: 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');
+    this.#lastUsedIndexesAsSenders = this.#store.openMap('last_used_indexes_as_senders');
+    this.#lastUsedIndexesAsRecipients = this.#store.openMap('last_used_indexes_as_recipients');
   }
 
-  async setTaggingSecretsIndexesAsSender(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForSenders);
-  }
-
-  async setTaggingSecretsIndexesAsRecipient(indexedSecrets: IndexedTaggingSecret[]): Promise<void> {
-    await this.#setTaggingSecretsIndexes(indexedSecrets, this.#taggingSecretIndexesForRecipients);
+  /**
+   * Sets the last used indexes when sending a log.
+   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
+   * updated in the db.
+   * @throws If any two pre tags contain the same directional app tagging secret
+   */
+  setLastUsedIndexesAsSender(preTags: PreTag[]) {
+    this.#assertUniqueSecrets(preTags, 'sender');
+
+    return Promise.all(
+      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsSenders.set(secret.toString(), index)),
+    );
   }
 
-  async #setTaggingSecretsIndexes(indexedSecrets: IndexedTaggingSecret[], storageMap: AztecAsyncMap<string, number>) {
-    await Promise.all(
-      indexedSecrets.map(indexedSecret =>
-        storageMap.set(indexedSecret.appTaggingSecret.toString(), indexedSecret.index),
-      ),
+  /**
+   * Sets the last used indexes when looking for logs.
+   * @param preTags - The pre tags containing the directional app tagging secrets and the indexes that are to be
+   * updated in the db.
+   * @throws If any two pre tags contain the same directional app tagging secret
+   */
+  setLastUsedIndexesAsRecipient(preTags: PreTag[]) {
+    this.#assertUniqueSecrets(preTags, 'recipient');
+
+    return Promise.all(
+      preTags.map(({ secret, index }) => this.#lastUsedIndexesAsRecipients.set(secret.toString(), index)),
     );
   }
 
-  async getTaggingSecretsIndexesAsRecipient(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForRecipients);
+  // It should never happen that we would receive any two pre tags on the input containing the same directional app
+  // tagging secret as everywhere we always just apply the largest index. Hence this check is a good way to catch
+  // bugs.
+  #assertUniqueSecrets(preTags: PreTag[], role: 'sender' | 'recipient'): void {
+    const secretStrings = preTags.map(({ secret }) => secret.toString());
+    const uniqueSecrets = new Set(secretStrings);
+    if (uniqueSecrets.size !== secretStrings.length) {
+      throw new Error(`Duplicate secrets found when setting last used indexes as ${role}`);
+    }
   }
 
-  async getTaggingSecretsIndexesAsSender(appTaggingSecrets: Fr[]) {
-    return await this.#getTaggingSecretsIndexes(appTaggingSecrets, this.#taggingSecretIndexesForSenders);
+  /**
+   * Returns the last used index when sending a log with a given secret.
+   * @param secret - The directional app tagging secret.
+   * @returns The last used index for the given directional app tagging secret, or undefined if not found.
+   */
+  async getLastUsedIndexesAsSender(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return await this.#lastUsedIndexesAsSenders.getAsync(secret.toString());
   }
 
-  #getTaggingSecretsIndexes(appTaggingSecrets: Fr[], storageMap: AztecAsyncMap<string, number>): Promise<number[]> {
-    return Promise.all(appTaggingSecrets.map(async secret => (await storageMap.getAsync(`${secret.toString()}`)) ?? 0));
+  /**
+   * Returns the last used indexes when looking for logs as a recipient.
+   * @param secrets - The directional app tagging secrets to obtain the indexes for.
+   * @returns The last used indexes for the given directional app tagging secrets, or undefined if have never yet found
+   * a log for a given secret.
+   */
+  getLastUsedIndexesAsRecipient(secrets: DirectionalAppTaggingSecret[]): Promise<(number | undefined)[]> {
+    return Promise.all(secrets.map(secret => this.#lastUsedIndexesAsRecipients.getAsync(secret.toString())));
   }
 
   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)));
+      const keysForSenders = await toArray(this.#lastUsedIndexesAsSenders.keysAsync());
+      await Promise.all(keysForSenders.map(secret => this.#lastUsedIndexesAsSenders.delete(secret)));
+      const keysForRecipients = await toArray(this.#lastUsedIndexesAsRecipients.keysAsync());
+      await Promise.all(keysForRecipients.map(secret => this.#lastUsedIndexesAsRecipients.delete(secret)));
     });
   }
 

package/src/synchronizer/synchronizer.ts

@@ -1,6 +1,5 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { L2TipsStore } from '@aztec/kv-store/stores';
+import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
@@ -10,13 +9,11 @@ import type { SyncDataProvider } from '../storage/sync_data_provider/sync_data_p
 import type { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 
 /**
- * The Synchronizer class manages the synchronization with the aztec node, allowing PXE to retrieve the
- * latest block header and handle reorgs.
- * It provides methods to trigger a sync and get the block number we are syncec to
- * details, and fetch transactions by hash.
+ * The Synchronizer class orchestrates synchronization between the PXE and Aztec node, maintaining an up-to-date
+ * view of the L2 chain state. It handles block header retrieval, chain reorganizations, and provides an interface
+ * for querying sync status.
  */
 export class Synchronizer implements L2BlockStreamEventHandler {
-  private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
   private log: Logger;
   private isSyncing: Promise<void> | undefined;
   protected readonly blockStream: L2BlockStream;
@@ -26,8 +23,8 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     private syncDataProvider: SyncDataProvider,
     private noteDataProvider: NoteDataProvider,
     private taggingDataProvider: TaggingDataProvider,
-    private l2TipsStore: L2TipsStore,
-    config: Partial<Pick<PXEConfig, 'l2StartingBlock'>> = {},
+    private l2TipsStore: L2TipsKVStore,
+    config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>> = {},
     loggerOrSuffix?: string | Logger,
   ) {
     this.log =
@@ -37,9 +34,12 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     this.blockStream = this.createBlockStream(config);
   }
 
-  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2StartingBlock'>>) {
+  protected createBlockStream(config: Partial<Pick<PXEConfig, 'l2BlockBatchSize'>>) {
     return new L2BlockStream(this.node, this.l2TipsStore, this, createLogger('pxe:block_stream'), {
-      startingBlock: config.l2StartingBlock,
+      batchSize: config.l2BlockBatchSize,
+      // Skipping finalized blocks makes us sync much faster - we only need to download blocks other than the latest one
+      // in order to detect reorgs, and there can be no reorgs on finalized block, making this safe.
+      skipFinalized: true,
     });
   }
 
@@ -49,28 +49,27 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     switch (event.type) {
       case 'blocks-added': {
-        const lastBlock = event.blocks.at(-1)!;
+        const lastBlock = event.blocks.at(-1)!.block;
         this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
           blockHash: lastBlock.hash(),
           archive: lastBlock.archive.root.toString(),
           header: lastBlock.header.toInspect(),
         });
-        await this.syncDataProvider.setHeader(lastBlock.header);
+        await this.syncDataProvider.setHeader(lastBlock.getBlockHeader());
         break;
       }
       case 'chain-pruned': {
-        this.log.warn(`Pruning data after block ${event.blockNumber} due to reorg`);
+        this.log.warn(`Pruning data after block ${event.block.number} due to reorg`);
         // We first unnullify and then remove so that unnullified notes that were created after the block number end up deleted.
         const lastSynchedBlockNumber = await this.syncDataProvider.getBlockNumber();
-        await this.noteDataProvider.unnullifyNotesAfter(event.blockNumber, lastSynchedBlockNumber);
-        await this.noteDataProvider.removeNotesAfter(event.blockNumber);
+        await this.noteDataProvider.rollbackNotesAndNullifiers(event.block.number, lastSynchedBlockNumber);
         // Remove all note tagging indexes to force a full resync. This is suboptimal, but unless we track the
         // block number in which each index is used it's all we can do.
         await this.taggingDataProvider.resetNoteSyncData();
         // Update the header to the last block.
-        const newHeader = await this.node.getBlockHeader(event.blockNumber);
+        const newHeader = await this.node.getBlockHeader(event.block.number);
         if (!newHeader) {
-          this.log.error(`Block header not found for block number ${event.blockNumber} during chain prune`);
+          this.log.error(`Block header not found for block number ${event.block.number} during chain prune`);
         } else {
           await this.syncDataProvider.setHeader(newHeader);
         }
@@ -80,7 +79,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
   }
 
   /**
-   * Syncs PXE and the node by dowloading the metadata of the latest blocks, allowing simulations to use
+   * Syncs PXE and the node by downloading the metadata of the latest blocks, allowing simulations to use
    * recent data (e.g. notes), and handling any reorgs that might have occurred.
    */
   public async sync() {
@@ -105,7 +104,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
 
     try {
       currentHeader = await this.syncDataProvider.getBlockHeader();
-    } catch (e) {
+    } catch {
       this.log.debug('Header is not set, requesting from the node');
     }
     if (!currentHeader) {
@@ -115,7 +114,7 @@ export class Synchronizer implements L2BlockStreamEventHandler {
     await this.blockStream.sync();
   }
 
-  public async getSynchedBlockNumber() {
-    return (await this.syncDataProvider.getBlockNumber()) ?? this.initialSyncBlockNumber;
+  public getSynchedBlockNumber() {
+    return this.syncDataProvider.getBlockNumber();
   }
 }

package/src/tagging/constants.ts

@@ -0,0 +1,2 @@
+// Half the size of the window we slide over the tagging indexes.
+export const WINDOW_HALF_SIZE = 10;

package/src/tagging/index.ts

@@ -0,0 +1,6 @@
+export * from './tag.js';
+export * from './constants.js';
+export * from './siloed_tag.js';
+export * from './utils.js';
+export { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+export { type PreTag } from '@aztec/stdlib/logs';

package/src/tagging/siloed_tag.ts

@@ -0,0 +1,22 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { Tag } from './tag.js';
+
+/**
+ * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
+ * address that emitted the log.
+ */
+export class SiloedTag {
+  private constructor(public readonly value: Fr) {}
+
+  static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
+    const siloedTag = await poseidon2Hash([app, tag.value]);
+    return new SiloedTag(siloedTag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+}

package/src/tagging/tag.ts

@@ -0,0 +1,16 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import type { Fr } from '@aztec/foundation/fields';
+import type { PreTag } from '@aztec/stdlib/logs';
+
+/**
+ * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
+ * with a contract address by kernels before being included in the final log.
+ */
+export class Tag {
+  private constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<Tag> {
+    const tag = await poseidon2Hash([preTag.secret.value, preTag.index]);
+    return new Tag(tag);
+  }
+}

package/src/tagging/utils.ts

@@ -0,0 +1,31 @@
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+
+// TODO(benesjan): Make this return tags instead - this will moves some complexity from syncTaggedLogs
+export function getPreTagsForTheWindow(
+  secretsAndWindows: { secret: DirectionalAppTaggingSecret; leftMostIndex: number; rightMostIndex: number }[],
+): PreTag[] {
+  const secrets = [];
+  for (const secretAndWindow of secretsAndWindows) {
+    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
+      secrets.push({ secret: secretAndWindow.secret, index: i });
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Creates a map from directional app tagging secret to initial index.
+ * @param preTags - The pre tags to get the initial indexes map from.
+ * @returns The map from directional app tagging secret to initial index.
+ */
+export function getInitialIndexesMap(preTags: { secret: DirectionalAppTaggingSecret; index: number | undefined }[]): {
+  [k: string]: number;
+} {
+  const initialIndexes: { [k: string]: number } = {};
+
+  for (const preTag of preTags) {
+    initialIndexes[preTag.secret.toString()] = preTag.index ?? 0;
+  }
+
+  return initialIndexes;
+}

package/dest/bin/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dest/bin/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dest/bin/index.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-import { createLogger } from '@aztec/foundation/log';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import { getPXEServiceConfig } from '../config/index.js';
-import { createPXEService } from '../entrypoints/server/utils.js';
-import { startPXEHttpServer } from '../pxe_http/index.js';
-const { PXE_PORT = 8080, AZTEC_NODE_URL = 'http://localhost:8079' } = process.env;
-const logger = createLogger('pxe:service');
-/**
- * Create and start a new PXE HTTP Server
- */ async function main() {
-    logger.info(`Setting up PXE...`);
-    const pxeConfig = getPXEServiceConfig();
-    const nodeRpcClient = createAztecNodeClient(AZTEC_NODE_URL, {});
-    const pxeService = await createPXEService(nodeRpcClient, pxeConfig);
-    const shutdown = ()=>{
-        logger.info('Shutting down...');
-        process.exit(0);
-    };
-    process.once('SIGINT', shutdown);
-    process.once('SIGTERM', shutdown);
-    startPXEHttpServer(pxeService, PXE_PORT);
-    logger.info(`PXE listening on port ${PXE_PORT}`);
-}
-main().catch((err)=>{
-    logger.error(err);
-    process.exit(1);
-});

package/dest/entrypoints/client/pxe_creation_options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pxe_creation_options.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/client/pxe_creation_options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B,CAAC"}

package/dest/kernel_oracle/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kernel_oracle/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAA2C,MAAM,kBAAkB,CAAC;AACvG,OAAO,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC;AACxG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAInF;;GAEG;AACH,qBAAa,YAAa,YAAW,iBAAiB;IAElD,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,GAAG;gBAJH,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,SAAS,EACf,WAAW,GAAE,aAAwB,EACrC,GAAG,yCAAoC;IAGpC,0BAA0B,CAAC,OAAO,EAAE,YAAY;;;;;;;;;;;IAQhD,0BAA0B,CAAC,eAAe,EAAE,EAAE;IAK9C,4BAA4B,CAAC,eAAe,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB;IAIlF,sBAAsB,CAAC,EAAE,EAAE,uBAAuB;IAKnD,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAS/G,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC;IAIvF,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC;IAQjC,kBAAkB,CAAC,eAAe,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC;IAInE,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1F,sBAAsB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA6BjG"}

package/dest/kernel_prover/hints/build_private_kernel_reset_private_inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_private_kernel_reset_private_inputs.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/hints/build_private_kernel_reset_private_inputs.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,gCAAgC,EAErC,sCAAsC,EAGtC,KAAK,2BAA2B,EAkBjC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,0BAA0B,EAAiB,MAAM,kBAAkB,CAAC;AAElF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAiDnE,qBAAa,sCAAsC;IAY/C,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,2BAA2B;IACnC,OAAO,CAAC,8BAA8B;IAdxC,OAAO,CAAC,cAAc,CAAmC;IAEzD,OAAO,CAAC,aAAa,CAAC,CAA6B;IAEnD,OAAO,CAAC,mBAAmB,CAAoE;IAC/F,OAAO,CAAC,oBAAoB,CAAoE;IAChG,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,uBAAuB,CAA8D;IAC7F,OAAO,CAAC,mBAAmB,CAA+B;gBAGhD,oBAAoB,EAAE,2BAA2B,CAAC,gCAAgC,CAAC,EACnF,cAAc,EAAE,0BAA0B,EAAE,EAC5C,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAChD,8BAA8B,EAAE,MAAM;IAahD,UAAU,IAAI,OAAO;IAwBf,KAAK,CAAC,MAAM,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAgEhF,OAAO,CAAC,uBAAuB;IA2B/B,OAAO,CAAC,8BAA8B;IAoDtC,OAAO,CAAC,+BAA+B;IAoDvC,OAAO,CAAC,uBAAuB;IAiB/B,OAAO,CAAC,uBAAuB;IAmE/B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,oBAAoB;CAmB7B"}