@aztec/pxe 0.42.0 → 0.43.0

package/dest/note_processor/note_processor.js

@@ -1,22 +1,22 @@
-import { L1NotePayload, TaggedNote, } from '@aztec/circuit-types';
-import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX } from '@aztec/circuits.js';
+import { L1NotePayload, TaggedLog } from '@aztec/circuit-types';
+import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ContractNotFoundError } from '@aztec/simulator';
-import { DeferredNoteDao } from '../database/deferred_note_dao.js';
 import { getAcirSimulator } from '../simulator/index.js';
-import { produceNoteDao } from './produce_note_dao.js';
+import { produceNoteDaos } from './produce_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 class NoteProcessor {
-    constructor(
-    /**
-     * The public counterpart to the private key to be used in note decryption.
-     */
-    masterIncomingViewingPublicKey, keyStore, db, node, startingBlock = INITIAL_L2_BLOCK_NUM, simulator = getAcirSimulator(db, node, keyStore), log = createDebugLogger('aztec:note_processor')) {
-        this.masterIncomingViewingPublicKey = masterIncomingViewingPublicKey;
+    constructor(account, 
+    /** The public counterpart to the secret key to be used in the decryption of incoming note logs. */
+    ivpkM, 
+    /** The public counterpart to the secret key to be used in the decryption of outgoing note logs. */
+    ovpkM, keyStore, db, node, startingBlock, simulator, log) {
+        this.account = account;
+        this.ivpkM = ivpkM;
+        this.ovpkM = ovpkM;
         this.keyStore = keyStore;
         this.db = db;
         this.node = node;
@@ -26,7 +26,21 @@ export class NoteProcessor {
         /** Keeps track of processing time since an instance is created. */
         this.timer = new Timer();
         /** Stats accumulated for this processor. */
-        this.stats = { seen: 0, decrypted: 0, deferred: 0, failed: 0, blocks: 0, txs: 0 };
+        this.stats = {
+            seen: 0,
+            decryptedIncoming: 0,
+            decryptedOutgoing: 0,
+            deferredIncoming: 0,
+            deferredOutgoing: 0,
+            failed: 0,
+            blocks: 0,
+            txs: 0,
+        };
+    }
+    static async create(account, keyStore, db, node, startingBlock = INITIAL_L2_BLOCK_NUM, simulator = getAcirSimulator(db, node, keyStore), log = createDebugLogger('aztec:note_processor')) {
+        const ivpkM = await keyStore.getMasterIncomingViewingPublicKey(account);
+        const ovpkM = await keyStore.getMasterOutgoingViewingPublicKey(account);
+        return new NoteProcessor(account, ivpkM, ovpkM, keyStore, db, node, startingBlock, simulator, log);
     }
     /**
      * Check if the NoteProcessor is synchronized with the remote block number.
@@ -46,37 +60,34 @@ export class NoteProcessor {
         return { syncedToBlock: this.getSyncedToBlock() };
     }
     getSyncedToBlock() {
-        return this.db.getSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey) ?? this.startingBlock - 1;
+        return this.db.getSynchedBlockNumberForPublicKey(this.ivpkM) ?? this.startingBlock - 1;
     }
     /**
      * Extracts new user-relevant notes from the information contained in the provided L2 blocks and encrypted logs.
      *
-     * @throws If the number of blocks and encrypted logs do not match.
-     * @param l2Blocks - L2 blocks to be processed.
-     * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
+     * @param blocks - L2 blocks to be processed.
      * @returns A promise that resolves once the processing is completed.
      */
-    async process(l2Blocks, encryptedL2BlockLogs) {
-        if (l2Blocks.length !== encryptedL2BlockLogs.length) {
-            throw new Error(`Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`);
-        }
-        if (l2Blocks.length === 0) {
+    async process(blocks) {
+        if (blocks.length === 0) {
             return;
         }
         const blocksAndNotes = [];
         // Keep track of notes that we couldn't process because the contract was not found.
-        const deferredNoteDaos = [];
+        const deferredIncomingNotes = [];
+        const deferredOutgoingNotes = [];
+        const ivskM = await this.keyStore.getMasterSecretKey(this.ivpkM);
+        const ovskM = await this.keyStore.getMasterSecretKey(this.ovpkM);
         // Iterate over both blocks and encrypted logs.
-        for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
+        for (const block of blocks) {
             this.stats.blocks++;
-            const { txLogs } = encryptedL2BlockLogs[blockIndex];
-            const block = l2Blocks[blockIndex];
+            const { txLogs } = block.body.noteEncryptedLogs;
             const dataStartIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
                 block.body.numberOfTxsIncludingPadded * MAX_NEW_NOTE_HASHES_PER_TX;
             // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
             // multiple encrypted logs in a tx pertaining to a user.
-            const noteDaos = [];
-            const secretKey = await this.keyStore.getMasterIncomingViewingSecretKeyForPublicKey(this.masterIncomingViewingPublicKey);
+            const incomingNotes = [];
+            const outgoingNotes = [];
             // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
             for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
                 this.stats.txs++;
@@ -89,42 +100,57 @@ export class NoteProcessor {
                 for (const functionLogs of txFunctionLogs) {
                     for (const log of functionLogs.logs) {
                         this.stats.seen++;
-                        // @todo Issue(#6410) We should also try decrypting as outgoing if this fails.
-                        const taggedNote = TaggedNote.decryptAsIncoming(log.data, secretKey);
-                        if (taggedNote?.notePayload) {
-                            const { notePayload: payload } = taggedNote;
-                            // We have successfully decrypted the data.
+                        const incomingTaggedNote = TaggedLog.decryptAsIncoming(log.data, ivskM);
+                        const outgoingTaggedNote = TaggedLog.decryptAsOutgoing(log.data, ovskM);
+                        if (incomingTaggedNote || outgoingTaggedNote) {
+                            // TODO(#7053): Re-enable this check
+                            // if (
+                            //   incomingTaggedNote &&
+                            //   outgoingTaggedNote &&
+                            //   !incomingTaggedNote.payload.equals(outgoingTaggedNote.payload)
+                            // ) {
+                            //   throw new Error(
+                            //     `Incoming and outgoing note payloads do not match. Incoming: ${JSON.stringify(
+                            //       incomingTaggedNote.payload,
+                            //     )}, Outgoing: ${JSON.stringify(outgoingTaggedNote.payload)}`,
+                            //   );
+                            // }
+                            const payload = incomingTaggedNote?.payload || outgoingTaggedNote?.payload;
                             const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
-                            try {
-                                const noteDao = await produceNoteDao(this.simulator, this.masterIncomingViewingPublicKey, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices);
-                                noteDaos.push(noteDao);
-                                this.stats.decrypted++;
+                            const { incomingNote, outgoingNote, incomingDeferredNote, outgoingDeferredNote } = await produceNoteDaos(this.simulator, incomingTaggedNote ? this.ivpkM : undefined, outgoingTaggedNote ? this.ovpkM : undefined, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices, this.log);
+                            if (incomingNote) {
+                                incomingNotes.push(incomingNote);
+                                this.stats.decryptedIncoming++;
+                            }
+                            if (outgoingNote) {
+                                outgoingNotes.push(outgoingNote);
+                                this.stats.decryptedOutgoing++;
+                            }
+                            if (incomingDeferredNote) {
+                                deferredIncomingNotes.push(incomingDeferredNote);
+                                this.stats.deferredIncoming++;
                             }
-                            catch (e) {
-                                if (e instanceof ContractNotFoundError) {
-                                    this.stats.deferred++;
-                                    this.log.warn(e.message);
-                                    const deferredNoteDao = new DeferredNoteDao(this.masterIncomingViewingPublicKey, payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, newNoteHashes, dataStartIndexForTx);
-                                    deferredNoteDaos.push(deferredNoteDao);
-                                }
-                                else {
-                                    this.stats.failed++;
-                                    this.log.error(`Could not process note because of "${e}". Discarding note...`);
-                                }
+                            if (outgoingDeferredNote) {
+                                deferredOutgoingNotes.push(outgoingDeferredNote);
+                                this.stats.deferredOutgoing++;
+                            }
+                            if (incomingNote == undefined && outgoingNote == undefined && incomingDeferredNote == undefined) {
+                                this.stats.failed++;
                             }
                         }
                     }
                 }
             }
             blocksAndNotes.push({
-                block: l2Blocks[blockIndex],
-                noteDaos,
+                block,
+                incomingNotes,
+                outgoingNotes,
             });
         }
         await this.processBlocksAndNotes(blocksAndNotes);
-        await this.processDeferredNotes(deferredNoteDaos);
-        const syncedToBlock = l2Blocks[l2Blocks.length - 1].number;
-        await this.db.setSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey, syncedToBlock);
+        await this.processDeferredNotes(deferredIncomingNotes, deferredOutgoingNotes);
+        const syncedToBlock = blocks[blocks.length - 1].number;
+        await this.db.setSynchedBlockNumberForPublicKey(this.ivpkM, syncedToBlock);
         this.log.debug(`Synched block ${syncedToBlock}`);
     }
     /**
@@ -137,15 +163,19 @@ export class NoteProcessor {
      * @param blocksAndNotes - Array of objects containing L2 blocks, user-pertaining transaction indices, and NoteDaos.
      */
     async processBlocksAndNotes(blocksAndNotes) {
-        const noteDaos = blocksAndNotes.flatMap(b => b.noteDaos);
-        if (noteDaos.length) {
-            await this.db.addNotes(noteDaos);
-            noteDaos.forEach(noteDao => {
-                this.log.verbose(`Added note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} with nullifier ${noteDao.siloedNullifier.toString()}`);
+        const incomingNotes = blocksAndNotes.flatMap(b => b.incomingNotes);
+        const outgoingNotes = blocksAndNotes.flatMap(b => b.outgoingNotes);
+        if (incomingNotes.length || outgoingNotes.length) {
+            await this.db.addNotes(incomingNotes, outgoingNotes);
+            incomingNotes.forEach(noteDao => {
+                this.log.verbose(`Added incoming note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} with nullifier ${noteDao.siloedNullifier.toString()}`);
+            });
+            outgoingNotes.forEach(noteDao => {
+                this.log.verbose(`Added outgoing note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`);
             });
         }
         const newNullifiers = blocksAndNotes.flatMap(b => b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers));
-        const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.masterIncomingViewingPublicKey);
+        const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.ivpkM);
         removedNotes.forEach(noteDao => {
             this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} with nullifier ${noteDao.siloedNullifier.toString()}`);
         });
@@ -153,13 +183,17 @@ export class NoteProcessor {
     /**
      * Store the given deferred notes in the database for later decoding.
      *
-     * @param deferredNoteDaos - notes that are intended for us but we couldn't process because the contract was not found.
+     * @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.
      */
-    async processDeferredNotes(deferredNoteDaos) {
-        if (deferredNoteDaos.length) {
-            await this.db.addDeferredNotes(deferredNoteDaos);
-            deferredNoteDaos.forEach(noteDao => {
-                this.log.verbose(`Deferred note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} in tx ${noteDao.txHash.toString()}`);
+    async processDeferredNotes(deferredIncomingNotes, deferredOutgoingNotes) {
+        if (deferredIncomingNotes.length || deferredOutgoingNotes.length) {
+            await this.db.addDeferredNotes([...deferredIncomingNotes, ...deferredOutgoingNotes]);
+            deferredIncomingNotes.forEach(noteDao => {
+                this.log.verbose(`Deferred incoming note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} in tx ${noteDao.txHash.toString()}`);
+            });
+            deferredOutgoingNotes.forEach(noteDao => {
+                this.log.verbose(`Deferred outgoing note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot} in tx ${noteDao.txHash.toString()}`);
             });
         }
     }
@@ -167,28 +201,41 @@ export class NoteProcessor {
      * 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 array of NoteDaos that were successfully decoded.
+     * @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.
      */
     async decodeDeferredNotes(deferredNoteDaos) {
         const excludedIndices = new Set();
-        const noteDaos = [];
+        const incomingNotes = [];
+        const outgoingNotes = [];
         for (const deferredNote of deferredNoteDaos) {
-            const { note, contractAddress, storageSlot, noteTypeId, txHash, newNoteHashes, dataStartIndexForTx } = deferredNote;
+            const { publicKey, note, contractAddress, storageSlot, noteTypeId, txHash, newNoteHashes, dataStartIndexForTx } = deferredNote;
             const payload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
-            try {
-                const noteDao = await produceNoteDao(this.simulator, this.masterIncomingViewingPublicKey, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices);
-                noteDaos.push(noteDao);
-                this.stats.decrypted++;
+            const isIncoming = publicKey.equals(this.ivpkM);
+            const isOutgoing = publicKey.equals(this.ovpkM);
+            if (!isIncoming && !isOutgoing) {
+                // The note does not belong to this note processor
+                continue;
             }
-            catch (e) {
-                this.stats.failed++;
-                this.log.warn(`Could not process deferred note because of "${e}". Discarding note...`);
+            const { incomingNote, outgoingNote } = await produceNoteDaos(this.simulator, isIncoming ? this.ivpkM : undefined, isOutgoing ? this.ovpkM : undefined, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices, this.log);
+            if (isIncoming) {
+                if (!incomingNote) {
+                    throw new Error('Deferred incoming note could not be decoded');
+                }
+                incomingNotes.push(incomingNote);
+                this.stats.decryptedIncoming++;
+            }
+            if (outgoingNote) {
+                if (!outgoingNote) {
+                    throw new Error('Deferred outgoing note could not be decoded');
+                }
+                outgoingNotes.push(outgoingNote);
+                this.stats.decryptedOutgoing++;
             }
         }
-        return noteDaos;
+        return { incomingNotes, outgoingNotes };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"note_processor.js","sourceRoot":"","sources":["../../src/note_processor/note_processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EAEb,UAAU,GACX,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,oBAAoB,EAAE,0BAA0B,EAAkB,MAAM,oBAAoB,CAAC;AAEtG,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAGnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAgBvD;;;GAGG;AACH,MAAM,OAAO,aAAa;IAOxB;IACE;;OAEG;IACa,8BAAyC,EACjD,QAAkB,EAClB,EAAe,EACf,IAAe,EACf,gBAAwB,oBAAoB,EAC5C,YAAY,gBAAgB,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,EAChD,MAAM,iBAAiB,CAAC,sBAAsB,CAAC;QANvC,mCAA8B,GAA9B,8BAA8B,CAAW;QACjD,aAAQ,GAAR,QAAQ,CAAU;QAClB,OAAE,GAAF,EAAE,CAAa;QACf,SAAI,GAAJ,IAAI,CAAW;QACf,kBAAa,GAAb,aAAa,CAA+B;QAC5C,cAAS,GAAT,SAAS,CAAuC;QAChD,QAAG,GAAH,GAAG,CAA4C;QAhBzD,mEAAmE;QACnD,UAAK,GAAU,IAAI,KAAK,EAAE,CAAC;QAE3C,4CAA4C;QAC5B,UAAK,GAAuB,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;IAa9G,CAAC;IAEJ;;;;;;OAMG;IACI,KAAK,CAAC,cAAc;QACzB,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC,gBAAgB,EAAE,KAAK,iBAAiB,CAAC;IACvD,CAAC;IAED;;OAEG;IACH,IAAW,MAAM;QACf,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC;IACpD,CAAC;IAEO,gBAAgB;QACtB,OAAO,IAAI,CAAC,EAAE,CAAC,iCAAiC,CAAC,IAAI,CAAC,8BAA8B,CAAC,IAAI,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;IAClH,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,OAAO,CAAC,QAAmB,EAAE,oBAAkD;QAC1F,IAAI,QAAQ,CAAC,MAAM,KAAK,oBAAoB,CAAC,MAAM,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CACb,6DAA6D,QAAQ,CAAC,MAAM,YAAY,oBAAoB,CAAC,MAAM,kBAAkB,CACtI,CAAC;QACJ,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,MAAM,cAAc,GAAoB,EAAE,CAAC;QAC3C,mFAAmF;QACnF,MAAM,gBAAgB,GAAsB,EAAE,CAAC;QAE/C,+CAA+C;QAC/C,KAAK,IAAI,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,oBAAoB,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,CAAC;YAChF,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAC;YACpD,MAAM,KAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;YACnC,MAAM,sBAAsB,GAC1B,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,sBAAsB;gBAC9D,KAAK,CAAC,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;YAErE,2GAA2G;YAC3G,wDAAwD;YACxD,MAAM,QAAQ,GAAc,EAAE,CAAC;YAC/B,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,6CAA6C,CACjF,IAAI,CAAC,8BAA8B,CACpC,CAAC;YAEF,8FAA8F;YAC9F,KAAK,IAAI,iBAAiB,GAAG,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,iBAAiB,EAAE,CAAC;gBACvF,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;gBACjB,MAAM,mBAAmB,GAAG,sBAAsB,GAAG,iBAAiB,GAAG,0BAA0B,CAAC;gBACpG,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,UAAU,CAAC;gBACzE,yGAAyG;gBACzG,yCAAyC;gBACzC,MAAM,cAAc,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC;gBAC9D,MAAM,eAAe,GAAgB,IAAI,GAAG,EAAE,CAAC;gBAC/C,KAAK,MAAM,YAAY,IAAI,cAAc,EAAE,CAAC;oBAC1C,KAAK,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC;wBACpC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;wBAClB,8EAA8E;wBAC9E,MAAM,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;wBACrE,IAAI,UAAU,EAAE,WAAW,EAAE,CAAC;4BAC5B,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;4BAC5C,2CAA2C;4BAC3C,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC;4BAC9D,IAAI,CAAC;gCACH,MAAM,OAAO,GAAG,MAAM,cAAc,CAClC,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,8BAA8B,EACnC,OAAO,EACP,MAAM,EACN,aAAa,EACb,mBAAmB,EACnB,eAAe,CAChB,CAAC;gCACF,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gCACvB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;4BACzB,CAAC;4BAAC,OAAO,CAAC,EAAE,CAAC;gCACX,IAAI,CAAC,YAAY,qBAAqB,EAAE,CAAC;oCACvC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;oCACtB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;oCACzB,MAAM,eAAe,GAAG,IAAI,eAAe,CACzC,IAAI,CAAC,8BAA8B,EACnC,OAAO,CAAC,IAAI,EACZ,OAAO,CAAC,eAAe,EACvB,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,UAAU,EAClB,MAAM,EACN,aAAa,EACb,mBAAmB,CACpB,CAAC;oCACF,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gCACzC,CAAC;qCAAM,CAAC;oCACN,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;oCACpB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,sCAAsC,CAAC,uBAAuB,CAAC,CAAC;gCACjF,CAAC;4BACH,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;YAED,cAAc,CAAC,IAAI,CAAC;gBAClB,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;gBAC3B,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;QAED,MAAM,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;QACjD,MAAM,IAAI,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;QAElD,MAAM,aAAa,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;QAC3D,MAAM,IAAI,CAAC,EAAE,CAAC,iCAAiC,CAAC,IAAI,CAAC,8BAA8B,EAAE,aAAa,CAAC,CAAC;QAEpG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,iBAAiB,aAAa,EAAE,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;;OAQG;IACK,KAAK,CAAC,qBAAqB,CAAC,cAA+B;QACjE,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;QACzD,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACjC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACzB,IAAI,CAAC,GAAG,CAAC,OAAO,CACd,2BAA2B,OAAO,CAAC,eAAe,YAChD,OAAO,CAAC,WACV,mBAAmB,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,CACxD,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,aAAa,GAAS,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CACrD,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAChE,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,aAAa,EAAE,IAAI,CAAC,8BAA8B,CAAC,CAAC;QAC5G,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC7B,IAAI,CAAC,GAAG,CAAC,OAAO,CACd,6BAA6B,OAAO,CAAC,eAAe,YAClD,OAAO,CAAC,WACV,mBAAmB,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,CACxD,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,oBAAoB,CAAC,gBAAmC;QACpE,IAAI,gBAAgB,CAAC,MAAM,EAAE,CAAC;YAC5B,MAAM,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;YACjD,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACjC,IAAI,CAAC,GAAG,CAAC,OAAO,CACd,8BAA8B,OAAO,CAAC,eAAe,YACnD,OAAO,CAAC,WACV,UAAU,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,CACtC,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,mBAAmB,CAAC,gBAAmC;QAClE,MAAM,eAAe,GAAgB,IAAI,GAAG,EAAE,CAAC;QAC/C,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,MAAM,YAAY,IAAI,gBAAgB,EAAE,CAAC;YAC5C,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,mBAAmB,EAAE,GAClG,YAAY,CAAC;YACf,MAAM,OAAO,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;YAElF,IAAI,CAAC;gBACH,MAAM,OAAO,GAAG,MAAM,cAAc,CAClC,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,8BAA8B,EACnC,OAAO,EACP,MAAM,EACN,aAAa,EACb,mBAAmB,EACnB,eAAe,CAChB,CAAC;gBACF,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACvB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;YACzB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;gBACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,+CAA+C,CAAC,uBAAuB,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"note_processor.js","sourceRoot":"","sources":["../../src/note_processor/note_processor.ts"],"names":[],"mappings":"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"}

package/dest/note_processor/produce_note_dao.d.ts

@@ -1,21 +1,30 @@
 import { type L1NotePayload, type TxHash } from '@aztec/circuit-types';
 import { Fr, type PublicKey } from '@aztec/circuits.js';
+import { type Logger } from '@aztec/foundation/log';
 import { type AcirSimulator } from '@aztec/simulator';
-import { NoteDao } from '../database/note_dao.js';
+import { DeferredNoteDao } from '../database/deferred_note_dao.js';
+import { IncomingNoteDao } from '../database/incoming_note_dao.js';
+import { OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 /**
  * Decodes a note from a transaction that we know was intended for us.
  * Throws if we do not yet have the contract corresponding to the note in our database.
  * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
  * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
  *
- * @param publicKey - The public counterpart to the private key to be used in note decryption.
+ * @param ivpkM - The public counterpart to the secret key to be used in the decryption of incoming note logs.
+ * @param ovpkM - The public counterpart to the secret key to be used in the decryption of outgoing note logs.
  * @param payload - An instance of l1NotePayload.
  * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
  * @param newNoteHashes - New note hashes in this transaction, one of which belongs to this note.
  * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same l1NotePayload, we need to find a different index for each replicate.
  * @param simulator - An instance of AcirSimulator.
- * @returns an instance of NoteDao, or throws. inserts the index of the note into the excludedIndices set.
+ * @returns An object containing the incoming, outgoing, and deferred notes.
  */
-export declare function produceNoteDao(simulator: AcirSimulator, publicKey: PublicKey, payload: L1NotePayload, txHash: TxHash, newNoteHashes: Fr[], dataStartIndexForTx: number, excludedIndices: Set<number>): Promise<NoteDao>;
+export declare function produceNoteDaos(simulator: AcirSimulator, ivpkM: PublicKey | undefined, ovpkM: PublicKey | undefined, payload: L1NotePayload, txHash: TxHash, newNoteHashes: Fr[], dataStartIndexForTx: number, excludedIndices: Set<number>, log: Logger): Promise<{
+    incomingNote: IncomingNoteDao | undefined;
+    outgoingNote: OutgoingNoteDao | undefined;
+    incomingDeferredNote: DeferredNoteDao | undefined;
+    outgoingDeferredNote: DeferredNoteDao | undefined;
+}>;
 //# sourceMappingURL=produce_note_dao.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"produce_note_dao.d.ts","sourceRoot":"","sources":["../../src/note_processor/produce_note_dao.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAClC,SAAS,EAAE,aAAa,EACxB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,EAAE,EAAE,EACnB,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,OAAO,CAAC,OAAO,CAAC,CAsBlB"}
+{"version":3,"file":"produce_note_dao.d.ts","sourceRoot":"","sources":["../../src/note_processor/produce_note_dao.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,EAAE,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,aAAa,EAAyB,MAAM,kBAAkB,CAAC;AAE7E,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAEnE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,EAAE,EAAE,EACnB,mBAAmB,EAAE,MAAM,EAC3B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,EAC5B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IACT,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;IAC1C,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;IAC1C,oBAAoB,EAAE,eAAe,GAAG,SAAS,CAAC;IAClD,oBAAoB,EAAE,eAAe,GAAG,SAAS,CAAC;CACnD,CAAC,CA4HD"}

package/dest/note_processor/produce_note_dao.js

@@ -1,60 +1,117 @@
 import { Fr } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { NoteDao } from '../database/note_dao.js';
+import { ContractNotFoundError } from '@aztec/simulator';
+import { DeferredNoteDao } from '../database/deferred_note_dao.js';
+import { IncomingNoteDao } from '../database/incoming_note_dao.js';
+import { OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 /**
  * Decodes a note from a transaction that we know was intended for us.
  * Throws if we do not yet have the contract corresponding to the note in our database.
  * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
  * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
  *
- * @param publicKey - The public counterpart to the private key to be used in note decryption.
+ * @param ivpkM - The public counterpart to the secret key to be used in the decryption of incoming note logs.
+ * @param ovpkM - The public counterpart to the secret key to be used in the decryption of outgoing note logs.
  * @param payload - An instance of l1NotePayload.
  * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
  * @param newNoteHashes - New note hashes in this transaction, one of which belongs to this note.
  * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same l1NotePayload, we need to find a different index for each replicate.
  * @param simulator - An instance of AcirSimulator.
- * @returns an instance of NoteDao, or throws. inserts the index of the note into the excludedIndices set.
+ * @returns An object containing the incoming, outgoing, and deferred notes.
  */
-export async function produceNoteDao(simulator, publicKey, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices) {
-    const { commitmentIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(simulator, newNoteHashes, txHash, payload, excludedIndices);
-    const index = BigInt(dataStartIndexForTx + commitmentIndex);
-    excludedIndices?.add(commitmentIndex);
-    return new NoteDao(payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, nonce, innerNoteHash, siloedNullifier, index, publicKey);
+export async function produceNoteDaos(simulator, ivpkM, ovpkM, payload, txHash, newNoteHashes, dataStartIndexForTx, excludedIndices, log) {
+    if (!ivpkM && !ovpkM) {
+        throw new Error('Both ivpkM and ovpkM are undefined. Cannot create note.');
+    }
+    let incomingNote;
+    let outgoingNote;
+    let incomingDeferredNote;
+    let outgoingDeferredNote;
+    try {
+        if (ivpkM) {
+            const { noteHashIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(simulator, newNoteHashes, txHash, payload, excludedIndices, true);
+            const index = BigInt(dataStartIndexForTx + noteHashIndex);
+            excludedIndices?.add(noteHashIndex);
+            incomingNote = new IncomingNoteDao(payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, nonce, innerNoteHash, siloedNullifier, index, ivpkM);
+        }
+    }
+    catch (e) {
+        if (e instanceof ContractNotFoundError) {
+            log.warn(e.message);
+            if (ivpkM) {
+                incomingDeferredNote = new DeferredNoteDao(ivpkM, payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, newNoteHashes, dataStartIndexForTx);
+            }
+        }
+        else {
+            log.error(`Could not process note because of "${e}". Discarding note...`);
+        }
+    }
+    try {
+        if (ovpkM) {
+            if (incomingNote) {
+                // Incoming note is defined meaning that this PXE has both the incoming and outgoing keys. We can skip computing
+                // note hash and note index since we already have them in the incoming note.
+                outgoingNote = new OutgoingNoteDao(payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, incomingNote.nonce, incomingNote.innerNoteHash, incomingNote.index, ovpkM);
+            }
+            else {
+                const { noteHashIndex, nonce, innerNoteHash } = await findNoteIndexAndNullifier(simulator, newNoteHashes, txHash, payload, excludedIndices, false);
+                const index = BigInt(dataStartIndexForTx + noteHashIndex);
+                excludedIndices?.add(noteHashIndex);
+                outgoingNote = new OutgoingNoteDao(payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, nonce, innerNoteHash, index, ovpkM);
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof ContractNotFoundError) {
+            log.warn(e.message);
+            if (ovpkM) {
+                outgoingDeferredNote = new DeferredNoteDao(ovpkM, payload.note, payload.contractAddress, payload.storageSlot, payload.noteTypeId, txHash, newNoteHashes, dataStartIndexForTx);
+            }
+        }
+        else {
+            log.error(`Could not process note because of "${e}". Discarding note...`);
+        }
+    }
+    return {
+        incomingNote,
+        outgoingNote,
+        incomingDeferredNote,
+        outgoingDeferredNote,
+    };
 }
 /**
- * Find the index of the note in the note hash tree by computing the note hash with different nonce and see which
- * commitment for the current tx matches this value.
- * Compute a nullifier for a given l1NotePayload.
- * The nullifier is calculated using the private key of the account,
- * contract address, and the note associated with the l1NotePayload.
- * This method assists in identifying spent commitments in the private state.
- * @param commitments - Commitments in the tx. One of them should be the note's commitment.
- * @param txHash - First nullifier in the tx.
- * @param l1NotePayload - An instance of l1NotePayload.
+ * Finds nonce, index, inner hash and siloed nullifier for a given note.
+ * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
+ * the current tx matches this value.
+ * @remarks This method assists in identifying spent notes in the note hash tree.
+ * @param noteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
+ * @param txHash - Hash of a tx the note was emitted in.
+ * @param l1NotePayload - The note payload.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
  * l1NotePayload. We need to find a different index for each replicate.
- * @returns Information for a decrypted note, including the index of its commitment, nonce, inner note
- * hash, and the siloed nullifier. Throw if cannot find the nonce for the note.
+ * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
+ * @returns Nonce, index, inner hash and siloed nullifier for a given note.
+ * @throws If cannot find the nonce for the note.
  */
-async function findNoteIndexAndNullifier(simulator, commitments, txHash, { contractAddress, storageSlot, noteTypeId, note }, excludedIndices) {
-    let commitmentIndex = 0;
+async function findNoteIndexAndNullifier(simulator, noteHashes, txHash, { contractAddress, storageSlot, noteTypeId, note }, excludedIndices, computeNullifier) {
+    let noteHashIndex = 0;
     let nonce;
     let innerNoteHash;
     let siloedNoteHash;
     let innerNullifier;
     const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
-    for (; commitmentIndex < commitments.length; ++commitmentIndex) {
-        if (excludedIndices.has(commitmentIndex)) {
+    for (; noteHashIndex < noteHashes.length; ++noteHashIndex) {
+        if (excludedIndices.has(noteHashIndex)) {
             continue;
         }
-        const commitment = commitments[commitmentIndex];
-        if (commitment.equals(Fr.ZERO)) {
+        const noteHash = noteHashes[noteHashIndex];
+        if (noteHash.equals(Fr.ZERO)) {
             break;
         }
-        const expectedNonce = computeNoteHashNonce(firstNullifier, commitmentIndex);
-        ({ innerNoteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndNullifier(contractAddress, expectedNonce, storageSlot, noteTypeId, note));
-        if (commitment.equals(siloedNoteHash)) {
+        const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
+        ({ innerNoteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(contractAddress, expectedNonce, storageSlot, noteTypeId, computeNullifier, note));
+        if (noteHash.equals(siloedNoteHash)) {
             nonce = expectedNonce;
             break;
         }
@@ -62,13 +119,13 @@ async function findNoteIndexAndNullifier(simulator, commitments, txHash, { contr
     if (!nonce) {
         // NB: this used to warn the user that a decrypted log didn't match any notes.
         // This was previously fine as we didn't chop transient note logs, but now we do (#1641 complete).
-        throw new Error('Cannot find a matching commitment for the note.');
+        throw new Error('Cannot find a matching note hash for the note.');
     }
     return {
-        commitmentIndex,
+        noteHashIndex,
         nonce,
         innerNoteHash: innerNoteHash,
         siloedNullifier: siloNullifier(contractAddress, innerNullifier),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/pxe_service/create_pxe_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create_pxe_service.d.ts","sourceRoot":"","sources":["../../src/pxe_service/create_pxe_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAczE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,gBAAgB,EACxB,YAAY,GAAE,MAAM,GAAG,OAAO,GAAG,SAAqB,EACtD,YAAY,CAAC,EAAE,YAAY,uBAwC5B"}
+{"version":3,"file":"create_pxe_service.d.ts","sourceRoot":"","sources":["../../src/pxe_service/create_pxe_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAezE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,gBAAgB,EACxB,YAAY,GAAE,MAAM,GAAG,OAAO,GAAG,SAAqB,EACtD,YAAY,CAAC,EAAE,YAAY,uBAyC5B"}

package/dest/pxe_service/create_pxe_service.js

@@ -4,6 +4,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
 import { initStoreForRollup } from '@aztec/kv-store/utils';
+import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
@@ -48,10 +49,11 @@ export async function createPXEService(aztecNode, config, useLogSuffix = undefin
         getCanonicalMultiCallEntrypointContract(),
         getCanonicalGasToken(),
         getCanonicalKeyRegistry(),
+        getCanonicalAuthRegistry(),
     ]) {
         await server.registerContract(contract);
     }
     await server.start();
     return server;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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