@aztec/pxe 0.62.0 → 0.63.1

package/src/synchronizer/synchronizer.ts

@@ -1,21 +1,10 @@
-import { type AztecNode, type L2Block, MerkleTreeId, type TxHash } from '@aztec/circuit-types';
-import { type NoteProcessorCaughtUpStats } from '@aztec/circuit-types/stats';
-import {
-  type AztecAddress,
-  type CompleteAddress,
-  type Fr,
-  INITIAL_L2_BLOCK_NUM,
-  type PublicKey,
-} from '@aztec/circuits.js';
+import { type AztecNode, type L2Block } from '@aztec/circuit-types';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { type KeyStore } from '@aztec/key-store';
 
-import { type DeferredNoteDao } from '../database/deferred_note_dao.js';
-import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
-import { NoteProcessor } from '../note_processor/index.js';
 
 /**
  * The Synchronizer class manages the synchronization of note processors and interacts with the Aztec node
@@ -26,11 +15,9 @@ import { NoteProcessor } from '../note_processor/index.js';
  */
 export class Synchronizer {
   private runningPromise?: RunningPromise;
-  private noteProcessors: NoteProcessor[] = [];
   private running = false;
   private initialSyncBlockNumber = INITIAL_L2_BLOCK_NUM - 1;
   private log: DebugLogger;
-  private noteProcessorsToCatchUp: NoteProcessor[] = [];
 
   constructor(private node: AztecNode, private db: PxeDatabase, private jobQueue: SerialQueue, logSuffix = '') {
     this.log = createDebugLogger(logSuffix ? `aztec:pxe_synchronizer_${logSuffix}` : 'aztec:pxe_synchronizer');
@@ -80,13 +67,7 @@ export class Synchronizer {
       let moreWork = true;
       // keep external this.running flag to interrupt greedy sync
       while (moreWork && this.running) {
-        if (this.noteProcessorsToCatchUp.length > 0) {
-          // There is a note processor that needs to catch up. We hijack the main loop to catch up the note processor.
-          moreWork = await this.workNoteProcessorCatchUp(limit);
-        } else {
-          // No note processor needs to catch up. We continue with the normal flow.
-          moreWork = await this.work(limit);
-        }
+        moreWork = await this.work(limit);
       }
     });
   }
@@ -108,11 +89,6 @@ export class Synchronizer {
       // Update latest tree roots from the most recent block
       const latestBlock = blocks[blocks.length - 1];
       await this.setHeaderFromBlock(latestBlock);
-
-      this.log.debug(`Forwarding ${blocks.length} blocks to ${this.noteProcessors.length} note processors`);
-      for (const noteProcessor of this.noteProcessors) {
-        await noteProcessor.process(blocks);
-      }
       return true;
     } catch (err) {
       this.log.error(`Error in synchronizer work`, err);
@@ -120,104 +96,6 @@ export class Synchronizer {
     }
   }
 
-  /**
-   * Catch up note processors that are lagging behind the main sync.
-   * e.g. because we just added a new account.
-   *
-   * @param limit - the maximum number of encrypted, unencrypted logs and blocks to fetch in each iteration.
-   * @returns true if there could be more work, false if there was an error which allows a retry with delay.
-   */
-  protected async workNoteProcessorCatchUp(limit = 1): Promise<boolean> {
-    const toBlockNumber = this.getSynchedBlockNumber();
-
-    // filter out note processors that are already caught up
-    // and sort them by the block number they are lagging behind in ascending order
-    const noteProcessorsToCatchUp: NoteProcessor[] = [];
-
-    this.noteProcessorsToCatchUp.forEach(noteProcessor => {
-      if (noteProcessor.status.syncedToBlock >= toBlockNumber) {
-        // Note processor is ahead of main sync, nothing to do
-        this.noteProcessors.push(noteProcessor);
-      } else {
-        noteProcessorsToCatchUp.push(noteProcessor);
-      }
-    });
-
-    this.noteProcessorsToCatchUp = noteProcessorsToCatchUp;
-
-    if (!this.noteProcessorsToCatchUp.length) {
-      // No note processors to catch up, nothing to do here,
-      // but we return true to continue with the normal flow.
-      return true;
-    }
-
-    // create a copy so that:
-    // 1. we can modify the original array while iterating over it
-    // 2. we don't need to serialize insertions into the array
-    const catchUpGroup = this.noteProcessorsToCatchUp
-      .slice()
-      // sort by the block number they are lagging behind
-      .sort((a, b) => a.status.syncedToBlock - b.status.syncedToBlock);
-
-    // grab the note processor that is lagging behind the most
-    const from = catchUpGroup[0].status.syncedToBlock + 1;
-    // Ensuring that the note processor does not sync further than the main sync.
-    limit = Math.min(limit, toBlockNumber - from + 1);
-    // this.log(`Catching up ${catchUpGroup.length} note processors by up to ${limit} blocks starting at block ${from}`);
-
-    if (limit < 1) {
-      throw new Error(`Unexpected limit ${limit} for note processor catch up`);
-    }
-
-    try {
-      const blocks = await this.node.getBlocks(from, limit);
-      if (!blocks.length) {
-        // This should never happen because this function should only be called when the note processor is lagging
-        // behind main sync.
-        throw new Error('No blocks in processor catch up mode');
-      }
-
-      for (const noteProcessor of catchUpGroup) {
-        // find the index of the first block that the note processor is not yet synced to
-        const index = blocks.findIndex(block => block.number > noteProcessor.status.syncedToBlock);
-        if (index === -1) {
-          // Due to the limit, we might not have fetched a new enough block for the note processor.
-          // And since the group is sorted, we break as soon as we find a note processor
-          // that needs blocks newer than the newest block we fetched.
-          break;
-        }
-
-        this.log.debug(
-          `Catching up note processor ${noteProcessor.account.toString()} by processing ${
-            blocks.length - index
-          } blocks`,
-        );
-        await noteProcessor.process(blocks.slice(index));
-
-        if (noteProcessor.status.syncedToBlock === toBlockNumber) {
-          // Note processor caught up, move it to `noteProcessors` from `noteProcessorsToCatchUp`.
-          this.log.debug(`Note processor for ${noteProcessor.account.toString()} has caught up`, {
-            eventName: 'note-processor-caught-up',
-            account: noteProcessor.account.toString(),
-            duration: noteProcessor.timer.ms(),
-            dbSize: await this.db.estimateSize(),
-            ...noteProcessor.stats,
-          } satisfies NoteProcessorCaughtUpStats);
-
-          this.noteProcessorsToCatchUp = this.noteProcessorsToCatchUp.filter(
-            np => !np.account.equals(noteProcessor.account),
-          );
-          this.noteProcessors.push(noteProcessor);
-        }
-      }
-
-      return true; // could be more work, immediately continue syncing
-    } catch (err) {
-      this.log.error(`Error in synchronizer workNoteProcessorCatchUp`, err);
-      return false;
-    }
-  }
-
   private async setHeaderFromBlock(latestBlock: L2Block) {
     if (latestBlock.number < this.initialSyncBlockNumber) {
       return;
@@ -239,46 +117,6 @@ export class Synchronizer {
     this.log.info('Stopped');
   }
 
-  /**
-   * Add a new account to the Synchronizer with the specified private key.
-   * Creates a NoteProcessor instance for the account and pushes it into the noteProcessors array.
-   * The method resolves immediately after pushing the new note processor.
-   *
-   * @param publicKey - The public key for the account.
-   * @param keyStore - The key store.
-   * @param startingBlock - The block where to start scanning for notes for this accounts.
-   * @returns A promise that resolves once the account is added to the Synchronizer.
-   */
-  public addAccount(account: CompleteAddress, keyStore: KeyStore, startingBlock: number) {
-    const predicate = (x: NoteProcessor) => x.account.equals(account);
-    const processor = this.noteProcessors.find(predicate) ?? this.noteProcessorsToCatchUp.find(predicate);
-    if (processor) {
-      return;
-    }
-
-    this.noteProcessorsToCatchUp.push(NoteProcessor.create(account, keyStore, this.db, this.node, startingBlock));
-  }
-
-  /**
-   * Checks if the specified account is synchronized.
-   * @param account - The aztec address for which to query the sync status.
-   * @returns True if the account is fully synched, false otherwise.
-   * @remarks Checks whether all the notes from all the blocks have been processed. If it is not the case, the
-   *          retrieved information from contracts might be old/stale (e.g. old token balance).
-   * @throws If checking a sync status of account which is not registered.
-   */
-  public async isAccountStateSynchronized(account: AztecAddress) {
-    const findByAccountAddress = (x: NoteProcessor) => x.account.address.equals(account);
-    const processor =
-      this.noteProcessors.find(findByAccountAddress) ?? this.noteProcessorsToCatchUp.find(findByAccountAddress);
-    if (!processor) {
-      throw new Error(
-        `Checking if account is synched is not possible for ${account} because it is only registered as a recipient.`,
-      );
-    }
-    return await processor.isSynchronized();
-  }
-
   private getSynchedBlockNumber() {
     return this.db.getBlockNumber() ?? this.initialSyncBlockNumber;
   }
@@ -302,94 +140,6 @@ export class Synchronizer {
     const lastBlockNumber = this.getSynchedBlockNumber();
     return {
       blocks: lastBlockNumber,
-      notes: Object.fromEntries(this.noteProcessors.map(n => [n.account.address.toString(), n.status.syncedToBlock])),
     };
   }
-
-  /**
-   * Returns the note processor stats.
-   * @returns The note processor stats for notes for each public key being tracked.
-   */
-  public getSyncStats() {
-    return Object.fromEntries(this.noteProcessors.map(n => [n.account.address.toString(), n.stats]));
-  }
-
-  /**
-   * Retry decoding any deferred notes for the specified contract address.
-   * @param contractAddress - the contract address that has just been added
-   */
-  public reprocessDeferredNotesForContract(contractAddress: AztecAddress): Promise<void> {
-    return this.jobQueue.put(() => this.#reprocessDeferredNotesForContract(contractAddress));
-  }
-
-  async #reprocessDeferredNotesForContract(contractAddress: AztecAddress): Promise<void> {
-    const deferredNotes = await this.db.getDeferredNotesByContract(contractAddress);
-
-    // group deferred notes by txHash to properly deal with possible duplicates
-    const txHashToDeferredNotes: Map<TxHash, DeferredNoteDao[]> = new Map();
-    for (const note of deferredNotes) {
-      const notesForTx = txHashToDeferredNotes.get(note.txHash) ?? [];
-      notesForTx.push(note);
-      txHashToDeferredNotes.set(note.txHash, notesForTx);
-    }
-
-    // keep track of decoded notes
-    const incomingNotes: IncomingNoteDao[] = [];
-
-    // now process each txHash
-    for (const deferredNotes of txHashToDeferredNotes.values()) {
-      // to be safe, try each note processor in case the deferred notes are for different accounts.
-      for (const processor of this.noteProcessors) {
-        const { incomingNotes: inNotes, outgoingNotes: outNotes } = await processor.decodeDeferredNotes(deferredNotes);
-        incomingNotes.push(...inNotes);
-
-        await this.db.addNotes(inNotes, outNotes, processor.account.address);
-
-        inNotes.forEach(noteDao => {
-          this.log.debug(
-            `Decoded deferred incoming note under account ${processor.account.toString()} for contract ${
-              noteDao.contractAddress
-            } at slot ${noteDao.storageSlot} with nullifier ${noteDao.siloedNullifier.toString()}`,
-          );
-        });
-
-        outNotes.forEach(noteDao => {
-          this.log.debug(
-            `Decoded deferred outgoing note under account ${processor.account.toString()} for contract ${
-              noteDao.contractAddress
-            } at slot ${noteDao.storageSlot}`,
-          );
-        });
-      }
-    }
-
-    // now drop the deferred notes, and add the decoded notes
-    await this.db.removeDeferredNotesByContract(contractAddress);
-
-    await this.#removeNullifiedNotes(incomingNotes);
-  }
-
-  async #removeNullifiedNotes(notes: IncomingNoteDao[]) {
-    // now group the decoded incoming notes by public key
-    const addressPointToIncomingNotes: Map<PublicKey, IncomingNoteDao[]> = new Map();
-    for (const noteDao of notes) {
-      const notesForAddressPoint = addressPointToIncomingNotes.get(noteDao.addressPoint) ?? [];
-      notesForAddressPoint.push(noteDao);
-      addressPointToIncomingNotes.set(noteDao.addressPoint, notesForAddressPoint);
-    }
-
-    // now for each group, look for the nullifiers in the nullifier tree
-    for (const [publicKey, notes] of addressPointToIncomingNotes.entries()) {
-      const nullifiers = notes.map(n => n.siloedNullifier);
-      const relevantNullifiers: Fr[] = [];
-      for (const nullifier of nullifiers) {
-        // NOTE: this leaks information about the nullifiers I'm interested in to the node.
-        const found = await this.node.findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
-        if (found) {
-          relevantNullifiers.push(nullifier);
-        }
-      }
-      await this.db.removeNullifiedNotes(relevantNullifiers, publicKey);
-    }
-  }
 }

package/dest/database/deferred_note_dao.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { L1NotePayload, TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
-import { Fr, type PublicKey } from '@aztec/circuits.js';
-import { BufferReader } from '@aztec/foundation/serialize';
-/**
- * A note that is intended for us, but we cannot decode it yet because the contract is not yet in our database.
- *
- * So keep the state that we need to decode it later.
- */
-export declare class DeferredNoteDao {
-    /** Address Point or OvpkM (depending on if incoming or outgoing) the note was encrypted with. */
-    publicKey: PublicKey;
-    /** The note payload delivered via L1. */
-    payload: L1NotePayload;
-    /** The hash of the tx the note was created in. Equal to the first nullifier */
-    txHash: TxHash;
-    /** New note hashes in this transaction, one of which belongs to this note */
-    noteHashes: Fr[];
-    /** The next available leaf index for the note hash tree for this transaction */
-    dataStartIndexForTx: number;
-    /** Unencrypted logs for the transaction (used to complete partial notes) */
-    unencryptedLogs: UnencryptedTxL2Logs;
-    constructor(
-    /** Address Point or OvpkM (depending on if incoming or outgoing) the note was encrypted with. */
-    publicKey: PublicKey, 
-    /** The note payload delivered via L1. */
-    payload: L1NotePayload, 
-    /** The hash of the tx the note was created in. Equal to the first nullifier */
-    txHash: TxHash, 
-    /** New note hashes in this transaction, one of which belongs to this note */
-    noteHashes: Fr[], 
-    /** The next available leaf index for the note hash tree for this transaction */
-    dataStartIndexForTx: number, 
-    /** Unencrypted logs for the transaction (used to complete partial notes) */
-    unencryptedLogs: UnencryptedTxL2Logs);
-    toBuffer(): Buffer;
-    static fromBuffer(buffer: Buffer | BufferReader): DeferredNoteDao;
-}
-//# sourceMappingURL=deferred_note_dao.d.ts.map

package/dest/database/deferred_note_dao.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deferred_note_dao.d.ts","sourceRoot":"","sources":["../../src/database/deferred_note_dao.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAE,EAAE,EAAS,KAAK,SAAS,EAAU,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E;;;;GAIG;AACH,qBAAa,eAAe;IAExB,iGAAiG;IAC1F,SAAS,EAAE,SAAS;IAC3B,yCAAyC;IAClC,OAAO,EAAE,aAAa;IAC7B,+EAA+E;IACxE,MAAM,EAAE,MAAM;IACrB,6EAA6E;IACtE,UAAU,EAAE,EAAE,EAAE;IACvB,gFAAgF;IACzE,mBAAmB,EAAE,MAAM;IAClC,4EAA4E;IACrE,eAAe,EAAE,mBAAmB;;IAX3C,iGAAiG;IAC1F,SAAS,EAAE,SAAS;IAC3B,yCAAyC;IAClC,OAAO,EAAE,aAAa;IAC7B,+EAA+E;IACxE,MAAM,EAAE,MAAM;IACrB,6EAA6E;IACtE,UAAU,EAAE,EAAE,EAAE;IACvB,gFAAgF;IACzE,mBAAmB,EAAE,MAAM;IAClC,4EAA4E;IACrE,eAAe,EAAE,mBAAmB;IAG7C,QAAQ,IAAI,MAAM;IAUlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;CAWhD"}

package/dest/database/deferred_note_dao.js

@@ -1,38 +0,0 @@
-import { L1NotePayload, TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
-import { Fr, Point, Vector } from '@aztec/circuits.js';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-/**
- * A note that is intended for us, but we cannot decode it yet because the contract is not yet in our database.
- *
- * So keep the state that we need to decode it later.
- */
-export class DeferredNoteDao {
-    constructor(
-    /** Address Point or OvpkM (depending on if incoming or outgoing) the note was encrypted with. */
-    publicKey, 
-    /** The note payload delivered via L1. */
-    payload, 
-    /** The hash of the tx the note was created in. Equal to the first nullifier */
-    txHash, 
-    /** New note hashes in this transaction, one of which belongs to this note */
-    noteHashes, 
-    /** The next available leaf index for the note hash tree for this transaction */
-    dataStartIndexForTx, 
-    /** Unencrypted logs for the transaction (used to complete partial notes) */
-    unencryptedLogs) {
-        this.publicKey = publicKey;
-        this.payload = payload;
-        this.txHash = txHash;
-        this.noteHashes = noteHashes;
-        this.dataStartIndexForTx = dataStartIndexForTx;
-        this.unencryptedLogs = unencryptedLogs;
-    }
-    toBuffer() {
-        return serializeToBuffer(this.publicKey, this.payload, this.txHash, new Vector(this.noteHashes), this.dataStartIndexForTx, this.unencryptedLogs);
-    }
-    static fromBuffer(buffer) {
-        const reader = BufferReader.asReader(buffer);
-        return new DeferredNoteDao(reader.readObject(Point), reader.readObject(L1NotePayload), reader.readObject(TxHash), reader.readVector(Fr), reader.readNumber(), reader.readObject(UnencryptedTxL2Logs));
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmZXJyZWRfbm90ZV9kYW8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGF0YWJhc2UvZGVmZXJyZWRfbm90ZV9kYW8udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRixPQUFPLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBa0IsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdkUsT0FBTyxFQUFFLFlBQVksRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTlFOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUMxQjtJQUNFLGlHQUFpRztJQUMxRixTQUFvQjtJQUMzQix5Q0FBeUM7SUFDbEMsT0FBc0I7SUFDN0IsK0VBQStFO0lBQ3hFLE1BQWM7SUFDckIsNkVBQTZFO0lBQ3RFLFVBQWdCO0lBQ3ZCLGdGQUFnRjtJQUN6RSxtQkFBMkI7SUFDbEMsNEVBQTRFO0lBQ3JFLGVBQW9DO1FBVnBDLGNBQVMsR0FBVCxTQUFTLENBQVc7UUFFcEIsWUFBTyxHQUFQLE9BQU8sQ0FBZTtRQUV0QixXQUFNLEdBQU4sTUFBTSxDQUFRO1FBRWQsZUFBVSxHQUFWLFVBQVUsQ0FBTTtRQUVoQix3QkFBbUIsR0FBbkIsbUJBQW1CLENBQVE7UUFFM0Isb0JBQWUsR0FBZixlQUFlLENBQXFCO0lBQzFDLENBQUM7SUFFSixRQUFRO1FBQ04sT0FBTyxpQkFBaUIsQ0FDdEIsSUFBSSxDQUFDLFNBQVMsRUFDZCxJQUFJLENBQUMsT0FBTyxFQUNaLElBQUksQ0FBQyxNQUFNLEVBQ1gsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUMzQixJQUFJLENBQUMsbUJBQW1CLEVBQ3hCLElBQUksQ0FBQyxlQUFlLENBQ3JCLENBQUM7SUFDSixDQUFDO0lBQ0QsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUE2QjtRQUM3QyxNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzdDLE9BQU8sSUFBSSxlQUFlLENBQ3hCLE1BQU0sQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLEVBQ3hCLE1BQU0sQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLEVBQ2hDLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLEVBQ3pCLE1BQU0sQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDLEVBQ3JCLE1BQU0sQ0FBQyxVQUFVLEVBQUUsRUFDbkIsTUFBTSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxDQUN2QyxDQUFDO0lBQ0osQ0FBQztDQUNGIn0=

package/dest/note_processor/index.d.ts

@@ -1,2 +0,0 @@
-export * from './note_processor.js';
-//# sourceMappingURL=index.d.ts.map

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

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

package/dest/note_processor/index.js

@@ -1,2 +0,0 @@
-export * from './note_processor.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZV9wcm9jZXNzb3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQyJ9

package/dest/note_processor/note_processor.d.ts

@@ -1,83 +0,0 @@
-import { type AztecNode, type L2Block } from '@aztec/circuit-types';
-import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
-import { type CompleteAddress } from '@aztec/circuits.js';
-import { type Logger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { type KeyStore } from '@aztec/key-store';
-import { type AcirSimulator } from '@aztec/simulator';
-import { type DeferredNoteDao } from '../database/deferred_note_dao.js';
-import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
-import { type PxeDatabase } from '../database/index.js';
-import { type OutgoingNoteDao } from '../database/outgoing_note_dao.js';
-/**
- * NoteProcessor is responsible for decrypting logs and converting them to notes via their originating contracts
- * before storing them against their owner.
- */
-export declare class NoteProcessor {
-    readonly account: CompleteAddress;
-    private keyStore;
-    private db;
-    private node;
-    private startingBlock;
-    private simulator;
-    private log;
-    /** Keeps track of processing time since an instance is created. */
-    readonly timer: Timer;
-    /** Stats accumulated for this processor. */
-    readonly stats: NoteProcessorStats;
-    private constructor();
-    static create(account: CompleteAddress, keyStore: KeyStore, db: PxeDatabase, node: AztecNode, startingBlock?: number, simulator?: AcirSimulator, log?: Logger): NoteProcessor;
-    /**
-     * Check if the NoteProcessor is synchronized with the remote block number.
-     * The function queries the remote block number from the AztecNode and compares it with the syncedToBlock value in the NoteProcessor.
-     * If the values are equal, then the NoteProcessor is considered to be synchronized, otherwise not.
-     *
-     * @returns A boolean indicating whether the NoteProcessor is synchronized with the remote block number or not.
-     */
-    isSynchronized(): Promise<boolean>;
-    /**
-     * Returns synchronization status (ie up to which block has been synced ) for this note processor.
-     */
-    get status(): {
-        syncedToBlock: number;
-    };
-    private getSyncedToBlock;
-    /**
-     * Extracts new user-relevant notes from the information contained in the provided L2 blocks and encrypted logs.
-     *
-     * @param blocks - L2 blocks to be processed.
-     * @returns A promise that resolves once the processing is completed.
-     */
-    process(blocks: L2Block[]): Promise<void>;
-    /**
-     * Process the given blocks and their associated transaction auxiliary data.
-     * This function updates the database with information about new transactions,
-     * user-pertaining transaction indices, and auxiliary data. It also removes nullified
-     * transaction auxiliary data from the database. This function keeps track of new nullifiers
-     * and ensures all other transactions are updated with newly settled block information.
-     *
-     * @param blocksAndNotes - Array of objects containing L2 blocks, user-pertaining transaction indices, and NoteDaos.
-     */
-    private processBlocksAndNotes;
-    /**
-     * Store the given deferred notes in the database for later decoding.
-     *
-     * @param deferredIncomingNotes - incoming notes that are intended for us but we couldn't process because the contract was not found.
-     * @param deferredOutgoingNotes - outgoing notes that we couldn't process because the contract was not found.
-     */
-    private processDeferredNotes;
-    /**
-     * Retry decoding the given deferred notes because we now have the contract code.
-     *
-     * @param deferredNoteDaos - notes that we have previously deferred because the contract was not found
-     * @returns An object containing arrays of incoming and outgoing notes that were successfully decoded.
-     *
-     * @remarks Caller is responsible for making sure that we have the contract for the
-     * deferred notes provided: we will not retry notes that fail again.
-     */
-    decodeDeferredNotes(deferredNoteDaos: DeferredNoteDao[]): Promise<{
-        incomingNotes: IncomingNoteDao[];
-        outgoingNotes: OutgoingNoteDao[];
-    }>;
-}
-//# sourceMappingURL=note_processor.d.ts.map

package/dest/note_processor/note_processor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"note_processor.d.ts","sourceRoot":"","sources":["../../src/note_processor/note_processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAiB,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EACL,KAAK,eAAe,EAKrB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,KAAK,MAAM,EAAqB,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAgBxE;;;GAGG;AACH,qBAAa,aAAa;aAiBN,OAAO,EAAE,eAAe;IACxC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAtBb,mEAAmE;IACnE,SAAgB,KAAK,EAAE,KAAK,CAAe;IAE3C,4CAA4C;IAC5C,SAAgB,KAAK,EAAE,kBAAkB,CASvC;IAEF,OAAO;WAUO,MAAM,CAClB,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,SAAS,EACf,aAAa,GAAE,MAA6B,EAC5C,SAAS,gBAAuC,EAChD,GAAG,SAA4C;IAKjD;;;;;;OAMG;IACU,cAAc;IAK3B;;OAEG;IACH,IAAW,MAAM;;MAEhB;IAED,OAAO,CAAC,gBAAgB;IAIxB;;;;;OAKG;IACU,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA4HtD;;;;;;;;OAQG;YACW,qBAAqB;IA8BnC;;;;;OAKG;YACW,oBAAoB;IAuBlC;;;;;;;;OAQG;IACU,mBAAmB,CAAC,gBAAgB,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;QAC7E,aAAa,EAAE,eAAe,EAAE,CAAC;QACjC,aAAa,EAAE,eAAe,EAAE,CAAC;KAClC,CAAC;CAgDH"}