@aztec/pxe 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

package/dest/tagging/sender_sync/utils/classify_pending_txs.js

@@ -0,0 +1,61 @@
+import { TxHash, TxStatus } from '@aztec/stdlib/tx';
+/** Groups a window's pending txs by what its logs say about them. */ export function classifyPendingTxsFromLogs(pendingTxs, txsInLogs, finalizedBlockNumber) {
+    const txHashesFinalized = [];
+    const txHashesWithExecutionReverted = [];
+    const txHashesAbsent = [];
+    for (const pendingTx of pendingTxs){
+        const txHash = TxHash.fromString(pendingTx.txHash);
+        const txInLogs = txsInLogs.get(pendingTx.txHash);
+        if (!txInLogs) {
+            txHashesAbsent.push(txHash);
+        } else if (txInLogs.blockNumber > finalizedBlockNumber) {
+        // A tx in the logs is mined in the log's block, so it is finalized exactly when that block is at or below the
+        // finalized tip. This one is not, so it belongs to no group until the tip catches up.
+        } else if (txInLogs.taggingIndexes.includes(pendingTx.highestIndex)) {
+            txHashesFinalized.push(txHash);
+        } else {
+            // A partially reverted tx: the revert dropped the logs carrying its higher indexes.
+            txHashesWithExecutionReverted.push(txHash);
+        }
+    }
+    return {
+        txHashesFinalized,
+        txHashesWithExecutionReverted,
+        txHashesAbsent
+    };
+}
+/** Groups pending txs by what their receipts say, for the txs the logs could not resolve. */ export async function classifyPendingTxsFromReceipts(pending, aztecNode) {
+    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
+    const txHashesFinalized = [];
+    const txHashesDropped = [];
+    const txHashesWithExecutionReverted = [];
+    for(let i = 0; i < receipts.length; i++){
+        const receipt = receipts[i];
+        const txHash = pending[i];
+        if (receipt.status === TxStatus.FINALIZED) {
+            // Tx has been included in a block and the corresponding block is finalized
+            if (receipt.hasExecutionSucceeded()) {
+                // No part of execution reverted - we just finalize all the indexes.
+                txHashesFinalized.push(txHash);
+            } else if (receipt.hasExecutionReverted()) {
+                // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+                // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+                txHashesWithExecutionReverted.push(txHash);
+            } else {
+                // Defensive check - this branch should never be triggered
+                throw new Error('Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.');
+            }
+        } else if (receipt.isDropped()) {
+            // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
+            txHashesDropped.push(txHash);
+        } else {
+        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do
+        // anything.
+        }
+    }
+    return {
+        txHashesFinalized,
+        txHashesDropped,
+        txHashesWithExecutionReverted
+    };
+}

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.d.ts

@@ -1,9 +1,12 @@
-import type { BlockHash } from '@aztec/stdlib/block';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import { type AppTaggingSecret } from '@aztec/stdlib/logs';
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
+import { type LogQueryAnchor } from '../../get_all_logs_by_tags.js';
 /**
- * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider. Returns the txs the
+ * window's logs carried, keyed by tx hash string, with the block each was mined in and the window indexes it used,
+ * so the caller can classify their finalization status without further node queries.
  * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
  * place is when a tx is being sent from this PXE.
  * @param extendedSecret - The app tagging secret whose indexes are being synced.
@@ -11,9 +14,16 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
- * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param anchor - Block the log query is anchored to.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */
-export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQW9CZCJ9
+export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchor: LogQueryAnchor, jobId: string): Promise<Map<string, TxInLogs>>;
+/** A tx that a sync window's logs carried. */
+export type TxInLogs = {
+    /** The block the tx was mined in, which decides whether it is finalized. */
+    blockNumber: BlockNumber;
+    /** The window's tagging indexes whose siloed tags this tx's logs carried. */
+    taggingIndexes: number[];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBNkIsTUFBTSxvQkFBb0IsQ0FBQztBQUd0RixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdEQUF3RCxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMkIsTUFBTSwrQkFBK0IsQ0FBQztBQUU3Rjs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHdCQUFzQiw2QkFBNkIsQ0FDakQsY0FBYyxFQUFFLGdCQUFnQixFQUNoQyxLQUFLLEVBQUUsTUFBTSxFQUNiLEdBQUcsRUFBRSxNQUFNLEVBQ1gsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxNQUFNLEVBQUUsY0FBYyxFQUN0QixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBNkJoQztBQUVELDhDQUE4QztBQUM5QyxNQUFNLE1BQU0sUUFBUSxHQUFHO0lBQ3JCLDRFQUE0RTtJQUM1RSxXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLDZFQUE2RTtJQUM3RSxjQUFjLEVBQUUsTUFBTSxFQUFFLENBQUM7Q0FDMUIsQ0FBQyJ9

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAoBd"}
+{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAA6B,MAAM,oBAAoB,CAAC;AAGtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AACjG,OAAO,EAAE,KAAK,cAAc,EAA2B,MAAM,+BAA+B,CAAC;AAE7F;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CA6BhC;AAED,8CAA8C;AAC9C,MAAM,MAAM,QAAQ,GAAG;IACrB,4EAA4E;IAC5E,WAAW,EAAE,WAAW,CAAC;IACzB,6EAA6E;IAC7E,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC"}

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.js

@@ -2,7 +2,9 @@ import { SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 /**
- * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider. Returns the txs the
+ * window's logs carried, keyed by tx hash string, with the block each was mined in and the window indexes it used,
+ * so the caller can classify their finalization status without further node queries.
  * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
  * place is when a tx is being sent from this PXE.
  * @param extendedSecret - The app tagging secret whose indexes are being synced.
@@ -10,10 +12,10 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
- * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param anchor - Block the log query is anchored to.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
- */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId) {
+ */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchor, jobId) {
     // We compute the tags for the current window of indexes
     const siloedTagsForWindow = await Promise.all(Array.from({
         length: end - start
@@ -21,56 +23,51 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
             extendedSecret,
             index: start + i
         })));
-    const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-    const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
+    const allLogs = await getAllPrivateLogsByTags(aztecNode, siloedTagsForWindow, anchor);
+    if (allLogs.length !== siloedTagsForWindow.length) {
+        throw new Error(`Number of log arrays does not match number of tags. ${allLogs.length} !== ${siloedTagsForWindow.length}`);
+    }
+    const txsInLogs = getTxsInLogs(allLogs, start);
     // Now we iterate over the map, construct the tagging index ranges and store them in the db. A tx already tracked
     // in the store is merged rather than range-checked: if this PXE sent the tx and it partially reverted, the chain
     // only shows the surviving sub-range of the prove-time entry (the finalized receipt step of the sync owns
     // resolving that difference), and a tx from another PXE may straddle a sync window boundary, in which case the
     // entry is widened so the next index choice covers the full onchain range.
-    for (const [txHashStr, indexes] of txIndexesMap.entries()){
+    for (const [txHashStr, { taggingIndexes }] of txsInLogs.entries()){
         const txHash = TxHash.fromString(txHashStr);
         const ranges = [
             {
                 extendedSecret,
-                lowestIndex: Math.min(...indexes),
-                highestIndex: Math.max(...indexes)
+                lowestIndex: Math.min(...taggingIndexes),
+                highestIndex: Math.max(...taggingIndexes)
             }
         ];
         await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
     }
+    return txsInLogs;
 }
-// Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
-// an array for each tag.
-async function getTxsContainingTags(tags, aztecNode, anchorBlockHash) {
-    // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-    // pagination here. Sender sync only needs `txHash` from each log, so we leave `includeEffects` off.
-    const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
-    return allLogs.map((logs)=>logs.map((log)=>log.txHash));
-}
-// Returns a map of txHash to all indexes for that txHash.
-function getTxIndexesMap(txHashesForTags, start, count) {
-    if (txHashesForTags.length !== count) {
-        throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
-    }
-    const indexesMap = new Map();
+// Returns a map of txHash to the block it was mined in and all window indexes used by it.
+function getTxsInLogs(logsForTags, start) {
+    const txsInLogs = new Map();
     // Iterate over indexes
-    for(let i = 0; i < txHashesForTags.length; i++){
+    for(let i = 0; i < logsForTags.length; i++){
         const taggingIndex = start + i;
-        const txHashesForTag = txHashesForTags[i];
-        // iterate over tx hashes that used that index (tag)
-        for (const txHash of txHashesForTag){
-            const key = txHash.toString();
-            const existing = indexesMap.get(key);
+        // iterate over logs that used that index (tag)
+        for (const log of logsForTags[i]){
+            const key = log.txHash.toString();
+            const existing = txsInLogs.get(key);
             // Add the index to the tx's indexes
             if (existing) {
-                existing.push(taggingIndex);
+                existing.taggingIndexes.push(taggingIndex);
             } else {
-                indexesMap.set(key, [
-                    taggingIndex
-                ]);
+                txsInLogs.set(key, {
+                    blockNumber: log.blockNumber,
+                    taggingIndexes: [
+                        taggingIndex
+                    ]
+                });
             }
         }
     }
-    return indexesMap;
+    return txsInLogs;
 }

package/dest/tagging/sender_sync/utils/resolve_pending_txs.d.ts

@@ -0,0 +1,29 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type MinedTxReceipt, type TxHash } from '@aztec/stdlib/tx';
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+/** What a window's node reads established about each of its pending txs. */
+export type ResolvedPendingTxs = {
+    txHashesFinalizedFromLogs: TxHash[];
+    txHashesFinalizedFromReceipts: TxHash[];
+    txHashesDropped: TxHash[];
+    /** Both sources land here: the logs when a surviving tag fell inside the window, a receipt otherwise. */
+    receiptsWithExecutionReverted: MinedTxReceipt<{
+        includeTxEffect: true;
+    }>[];
+};
+/**
+ * Resolves a window's pending txs. All of the window's node reads happen here.
+ *
+ * The logs it is handed settle most txs on their own, as {@link classifyPendingTxsFromLogs} explains. Two groups are
+ * left over, and share one further round trip:
+ *
+ * - txs absent from the logs, whose receipt is what tells whether they are still in the mempool, dropped, or reverted;
+ * - txs the logs show as reverted, which only their tx effect resolves.
+ *
+ * A third round trip is paid only when those receipts reveal a reverted tx, since its effect cannot be requested
+ * before its status says it reverted.
+ */
+export declare function resolvePendingTxs(pendingTxs: PendingTx[], txsInLogs: Map<string, TxInLogs>, finalizedBlockNumber: BlockNumber, aztecNode: AztecNode): Promise<ResolvedPendingTxs>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZV9wZW5kaW5nX3R4cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvcmVzb2x2ZV9wZW5kaW5nX3R4cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQUUsS0FBSyxNQUFNLEVBQTRCLE1BQU0sa0JBQWtCLENBQUM7QUFFOUYsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFFeEYsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFeEUsNEVBQTRFO0FBQzVFLE1BQU0sTUFBTSxrQkFBa0IsR0FBRztJQUMvQix5QkFBeUIsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNwQyw2QkFBNkIsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUN4QyxlQUFlLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDMUIseUdBQXlHO0lBQ3pHLDZCQUE2QixFQUFFLGNBQWMsQ0FBQztRQUFFLGVBQWUsRUFBRSxJQUFJLENBQUE7S0FBRSxDQUFDLEVBQUUsQ0FBQztDQUM1RSxDQUFDO0FBRUY7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCx3QkFBc0IsaUJBQWlCLENBQ3JDLFVBQVUsRUFBRSxTQUFTLEVBQUUsRUFDdkIsU0FBUyxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLEVBQ2hDLG9CQUFvQixFQUFFLFdBQVcsRUFDakMsU0FBUyxFQUFFLFNBQVMsR0FDbkIsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBbUI3QiJ9

package/dest/tagging/sender_sync/utils/resolve_pending_txs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve_pending_txs.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/resolve_pending_txs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAA4B,MAAM,kBAAkB,CAAC;AAE9F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wDAAwD,CAAC;AAExF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAExE,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yBAAyB,EAAE,MAAM,EAAE,CAAC;IACpC,6BAA6B,EAAE,MAAM,EAAE,CAAC;IACxC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,yGAAyG;IACzG,6BAA6B,EAAE,cAAc,CAAC;QAAE,eAAe,EAAE,IAAI,CAAA;KAAE,CAAC,EAAE,CAAC;CAC5E,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAChC,oBAAoB,EAAE,WAAW,EACjC,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,kBAAkB,CAAC,CAmB7B"}

package/dest/tagging/sender_sync/utils/resolve_pending_txs.js

@@ -0,0 +1,41 @@
+import { TxStatus } from '@aztec/stdlib/tx';
+import { classifyPendingTxsFromLogs, classifyPendingTxsFromReceipts } from './classify_pending_txs.js';
+/**
+ * Resolves a window's pending txs. All of the window's node reads happen here.
+ *
+ * The logs it is handed settle most txs on their own, as {@link classifyPendingTxsFromLogs} explains. Two groups are
+ * left over, and share one further round trip:
+ *
+ * - txs absent from the logs, whose receipt is what tells whether they are still in the mempool, dropped, or reverted;
+ * - txs the logs show as reverted, which only their tx effect resolves.
+ *
+ * A third round trip is paid only when those receipts reveal a reverted tx, since its effect cannot be requested
+ * before its status says it reverted.
+ */ export async function resolvePendingTxs(pendingTxs, txsInLogs, finalizedBlockNumber, aztecNode) {
+    const statusFromLogs = classifyPendingTxsFromLogs(pendingTxs, txsInLogs, finalizedBlockNumber);
+    const [statusOfAbsent, receiptsOfRevertedInLogs] = await Promise.all([
+        classifyPendingTxsFromReceipts(statusFromLogs.txHashesAbsent, aztecNode),
+        getReceiptsWithEffect(statusFromLogs.txHashesWithExecutionReverted, aztecNode)
+    ]);
+    const receiptsOfRevertedAbsent = await getReceiptsWithEffect(statusOfAbsent.txHashesWithExecutionReverted, aztecNode);
+    return {
+        txHashesFinalizedFromLogs: statusFromLogs.txHashesFinalized,
+        txHashesFinalizedFromReceipts: statusOfAbsent.txHashesFinalized,
+        txHashesDropped: statusOfAbsent.txHashesDropped,
+        // Both groups were judged finalized before this fetch, the first off our own tip and the second off an earlier
+        // receipt, so both are confirmed against what the node says now. Finalizing off a reorgeable block would burn
+        // the indexes.
+        receiptsWithExecutionReverted: [
+            ...receiptsOfRevertedInLogs,
+            ...receiptsOfRevertedAbsent
+        ].filter(isFinalized)
+    };
+}
+function getReceiptsWithEffect(txHashes, aztecNode) {
+    return Promise.all(txHashes.map((txHash)=>aztecNode.getTxReceipt(txHash, {
+            includeTxEffect: true
+        })));
+}
+function isFinalized(receipt) {
+    return receipt.status === TxStatus.FINALIZED;
+}

package/dest/tagging/sender_sync/utils/test_utils.d.ts

@@ -0,0 +1,16 @@
+import type { MinedTxStatus, TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { MinedTxReceipt, TxExecutionResult } from '@aztec/stdlib/tx';
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+/** A tx the store holds as pending, tracked up to the given index. */
+export declare function pendingTx(txHash: TxHash, highestIndex: number): PendingTx;
+/** One tx as a window's logs show it: the block it was mined in and the tagging indexes its logs carried. */
+export declare function minedIn(blockNumber: number, taggingIndexes: number[]): TxInLogs;
+/** Builds the tx-hash-keyed map a window's logs would produce. */
+export declare function txsInLogs(...entries: [TxHash, TxInLogs][]): Map<string, TxInLogs>;
+/** The receipt of a mined tx, successful and without a tx effect unless stated otherwise. */
+export declare function minedReceipt(txHash: TxHash, status: MinedTxStatus, blockNumber: number, { executionResult, txEffect }?: {
+    executionResult?: TxExecutionResult;
+    txEffect?: TxEffect;
+}): MinedTxReceipt;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvdGVzdF91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxjQUFjLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVyRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUN4RixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUV4RSxzRUFBc0U7QUFDdEUsd0JBQWdCLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUV6RTtBQUVELDZHQUE2RztBQUM3Ryx3QkFBZ0IsT0FBTyxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFFLE1BQU0sRUFBRSxHQUFHLFFBQVEsQ0FFL0U7QUFFRCxrRUFBa0U7QUFDbEUsd0JBQWdCLFNBQVMsQ0FBQyxHQUFHLE9BQU8sRUFBRSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsRUFBRSxHQUFHLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBRWpGO0FBRUQsNkZBQTZGO0FBQzdGLHdCQUFnQixZQUFZLENBQzFCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsTUFBTSxFQUFFLGFBQWEsRUFDckIsV0FBVyxFQUFFLE1BQU0sRUFDbkIsRUFDRSxlQUEyQyxFQUMzQyxRQUFRLEVBQ1QsR0FBRTtJQUFFLGVBQWUsQ0FBQyxFQUFFLGlCQUFpQixDQUFDO0lBQUMsUUFBUSxDQUFDLEVBQUUsUUFBUSxDQUFBO0NBQU8sR0FDbkUsY0FBYyxDQWFoQiJ9

package/dest/tagging/sender_sync/utils/test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/test_utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wDAAwD,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAExE,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,CAEzE;AAED,6GAA6G;AAC7G,wBAAgB,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,QAAQ,CAE/E;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,GAAG,OAAO,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAEjF;AAED,6FAA6F;AAC7F,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,EACnB,EACE,eAA2C,EAC3C,QAAQ,EACT,GAAE;IAAE,eAAe,CAAC,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAO,GACnE,cAAc,CAahB"}

package/dest/tagging/sender_sync/utils/test_utils.js

@@ -0,0 +1,24 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockHash } from '@aztec/stdlib/block';
+import { MinedTxReceipt, TxExecutionResult } from '@aztec/stdlib/tx';
+/** A tx the store holds as pending, tracked up to the given index. */ export function pendingTx(txHash, highestIndex) {
+    return {
+        txHash: txHash.toString(),
+        highestIndex
+    };
+}
+/** One tx as a window's logs show it: the block it was mined in and the tagging indexes its logs carried. */ export function minedIn(blockNumber, taggingIndexes) {
+    return {
+        blockNumber: BlockNumber(blockNumber),
+        taggingIndexes
+    };
+}
+/** Builds the tx-hash-keyed map a window's logs would produce. */ export function txsInLogs(...entries) {
+    return new Map(entries.map(([txHash, txInLogs])=>[
+            txHash.toString(),
+            txInLogs
+        ]));
+}
+/** The receipt of a mined tx, successful and without a tx effect unless stated otherwise. */ export function minedReceipt(txHash, status, blockNumber, { executionResult = TxExecutionResult.SUCCESS, txEffect } = {}) {
+    return new MinedTxReceipt(txHash, status, executionResult, 1n, BlockHash.random(), BlockNumber(blockNumber), SlotNumber(Number(blockNumber)), 0, EpochNumber(1), txEffect);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.321f6a9",
+  "version": "0.0.1-commit.330febf",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -71,20 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.321f6a9",
-    "@aztec/bb.js": "0.0.1-commit.321f6a9",
-    "@aztec/builder": "0.0.1-commit.321f6a9",
-    "@aztec/constants": "0.0.1-commit.321f6a9",
-    "@aztec/ethereum": "0.0.1-commit.321f6a9",
-    "@aztec/foundation": "0.0.1-commit.321f6a9",
-    "@aztec/key-store": "0.0.1-commit.321f6a9",
-    "@aztec/kv-store": "0.0.1-commit.321f6a9",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.321f6a9",
-    "@aztec/noir-types": "0.0.1-commit.321f6a9",
-    "@aztec/protocol-contracts": "0.0.1-commit.321f6a9",
-    "@aztec/simulator": "0.0.1-commit.321f6a9",
-    "@aztec/standard-contracts": "0.0.1-commit.321f6a9",
-    "@aztec/stdlib": "0.0.1-commit.321f6a9",
+    "@aztec/bb-prover": "0.0.1-commit.330febf",
+    "@aztec/bb.js": "6.0.0-nightly.20260807",
+    "@aztec/builder": "0.0.1-commit.330febf",
+    "@aztec/constants": "0.0.1-commit.330febf",
+    "@aztec/ethereum": "0.0.1-commit.330febf",
+    "@aztec/foundation": "0.0.1-commit.330febf",
+    "@aztec/key-store": "0.0.1-commit.330febf",
+    "@aztec/kv-store": "0.0.1-commit.330febf",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.330febf",
+    "@aztec/noir-types": "0.0.1-commit.330febf",
+    "@aztec/protocol-contracts": "0.0.1-commit.330febf",
+    "@aztec/simulator": "0.0.1-commit.330febf",
+    "@aztec/standard-contracts": "0.0.1-commit.330febf",
+    "@aztec/stdlib": "0.0.1-commit.330febf",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -93,8 +93,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.321f6a9",
-    "@aztec/world-state": "0.0.1-commit.321f6a9",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.330febf",
+    "@aztec/world-state": "0.0.1-commit.330febf",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/bin/check_oracle_version.ts

@@ -1,11 +1,8 @@
 import { keccak256String } from '@aztec/foundation/crypto/keccak';
 
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-
 import { ORACLE_REGISTRY } from '../contract_function_simulator/index.js';
-import { ORACLE_INTERFACE_HASH, ORACLE_VERSION_MAJOR } from '../oracle_version.js';
-import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_helpers.js';
+import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
+import { getOracleRegistrySignature } from './oracle_version_helpers.js';
 
 /**
  * Verifies that the Oracle interface matches the expected interface hash.
@@ -28,45 +25,4 @@ function assertOracleInterfaceMatches(): void {
   }
 }
 
-/**
- * Verifies that `ORACLE_VERSION_MAJOR` is identical across all of its hand-maintained copies.
- *
- * The major version is duplicated across the PXE TypeScript constant and two Noir constants (Aztec.nr and the protocol
- * contracts' `aztec_sublib`) because those layers can't import each other. This static check fails fast at build time,
- * naming each file and its value.
- *
- * Only the major version is checked: the minor version legitimately diverges under the "environment minor >= contract
- * minor" tolerance, so asserting minor equality would false-positive.
- */
-function assertContractOracleVersionMajorInSync(): void {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then up two more to the git root.
-  const packageRoot = dirname(dirname(currentDir));
-  const gitRoot = join(packageRoot, '..', '..');
-
-  const copies = [
-    { label: 'pxe/src/oracle_version.ts', value: ORACLE_VERSION_MAJOR },
-    {
-      label: 'aztec-nr/aztec/src/oracle/version.nr',
-      value: readNumericGlobal(
-        join(gitRoot, 'noir-projects/aztec-nr/aztec/src/oracle/version.nr'),
-        'ORACLE_VERSION_MAJOR',
-      ),
-    },
-    {
-      label: 'aztec_sublib/src/oracle/version.nr',
-      value: readNumericGlobal(
-        join(gitRoot, 'noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr'),
-        'ORACLE_VERSION_MAJOR',
-      ),
-    },
-  ];
-
-  if (new Set(copies.map(copy => copy.value)).size > 1) {
-    const details = copies.map(copy => `${copy.label}=${copy.value}`).join(', ');
-    throw new Error(`ORACLE_VERSION_MAJOR is out of sync: ${details}. Bump all copies together.`);
-  }
-}
-
 assertOracleInterfaceMatches();
-assertContractOracleVersionMajorInSync();

package/src/bin/index.ts

@@ -1 +1 @@
-export { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_helpers.js';
+export { getOracleRegistrySignature } from './oracle_version_helpers.js';

package/src/bin/oracle_version_helpers.ts

@@ -1,5 +1,3 @@
-import { readFileSync } from 'fs';
-
 import type { OracleRegistryEntry } from '../contract_function_simulator/index.js';
 
 /**
@@ -30,25 +28,3 @@ export function getOracleRegistrySignature(registry: Record<string, OracleRegist
 
   return oracleSignatures.join('\n');
 }
-
-/**
- * Reads an integer-valued global constant from a Noir or TypeScript source file.
- *
- * Matches both the Noir form (`pub global NAME: Field = N;`) and the TypeScript form (`export const NAME = N;`). This
- * lets us compare a version constant that is hand-duplicated across the TS and Noir layers (which can't import each
- * other) without depending on either compiler. Only the assignment form `NAME = N` matches, so later usages of the
- * constant are ignored regardless of their order in the file.
- *
- * @param sourcePath - Absolute path to the source file to read.
- * @param name - Name of the global constant whose integer value should be extracted.
- * @returns The integer value assigned to the constant.
- * @throws If the constant's declaration is not found in the file.
- */
-export function readNumericGlobal(sourcePath: string, name: string): number {
-  const sourceCode = readFileSync(sourcePath, 'utf-8');
-  const match = sourceCode.match(new RegExp(`\\b${name}\\s*(?::\\s*\\w+\\s*)?=\\s*(\\d+)`));
-  if (!match) {
-    throw new Error(`Could not find numeric global '${name}' in ${sourcePath}.`);
-  }
-  return Number(match[1]);
-}

package/src/block_synchronizer/block_synchronizer.ts

@@ -4,12 +4,11 @@ import { SerialQueue } from '@aztec/foundation/queue';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { L2TipsKVStore } from '@aztec/kv-store/stores';
 import { BlockHash, L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
-import type { ContractClassService } from '../contract/contract_class_service.js';
 import type { ContractSyncService } from '../contract/contract_sync_service.js';
+import type { CachingAztecNode } from '../node/caching_aztec_node.js';
 import type { AnchorBlockStore } from '../storage/anchor_block_store/index.js';
 import type { FactStore } from '../storage/fact_store/fact_store.js';
 import type { NoteStore } from '../storage/note_store/index.js';
@@ -28,7 +27,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
   protected readonly blockStream: L2BlockStream;
 
   constructor(
-    private readonly node: AztecNode,
+    private readonly node: CachingAztecNode,
     private readonly store: AztecAsyncKVStore,
     private readonly anchorBlockStore: AnchorBlockStore,
     private readonly noteStore: NoteStore,
@@ -36,7 +35,6 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private readonly factStore: FactStore,
     private readonly l2TipsStore: L2TipsKVStore,
     private readonly contractSyncService: ContractSyncService,
-    private readonly contractClassService: ContractClassService,
     private readonly config: Partial<BlockSynchronizerConfig> = {},
     bindings?: LoggerBindings,
   ) {
@@ -68,21 +66,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     switch (event.type) {
       case 'chain-proposed': {
         if (this.config.syncChainTip === undefined || this.config.syncChainTip === 'proposed') {
-          // Fetch the proposed tip header by hash. By-hash is safer than by-number against a same-height reorg.
-          const block = await this.node.getBlockData(BlockHash.fromString(event.block.hash));
-          if (!block) {
-            // The node served a proposed tip whose block data it cannot return — a node inconsistency, since the
-            // stream events and the block data come from the same node (same reasoning as the chain-pruned throw
-            // below). Throwing here propagates before the tips-store cursor advances, so the cursor stays put and the
-            // next sync re-emits chain-proposed (at-least-once). Were we to warn-and-skip, the cursor would advance and
-            // a quiet chain would never re-emit, leaving the anchor stale indefinitely.
-            throw new Error(
-              `Block header for proposed block ${event.block.number} and hash ${event.block.hash} not found. This ` +
-                `likely indicates a bug in the node, as we receive block stream events and fetch block headers from ` +
-                `the same node.`,
-            );
-          }
-          await this.updateAnchorBlockHeader(block.header);
+          await this.updateAnchorBlockHeader(event.header);
         }
         break;
       }
@@ -180,10 +164,9 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     // execution.
     this.contractSyncService.wipe();
 
-    // The contract class service keeps a per-block cache - since updating our anchor means it is very unlikely we'd
-    // ever re-simulate at past anchors, we wipe its cache to prevent runaway memory growth on very long-lived PXE
-    // instances.
-    this.contractClassService.wipe();
+    // Cached node reads stay correct indefinitely, so this wipe is only about bounding memory growth. An anchor
+    // update is the recurring trigger PXE already has.
+    this.node.wipeCache();
 
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);

package/src/contract/contract_class_service.ts

@@ -14,14 +14,6 @@ import type { ContractStore } from '../storage/contract_store/contract_store.js'
  * falling back to a local instance if no upgrades were scheduled.
  */
 export class ContractClassService {
-  /**
-   * Class ids are cached per `(address, anchorHash)`. This avoid unnecessary network roundtrips in scenarios where
-   * multiple executions are done on the same anchor block (e.g. simulation followed by witgen), or when the same
-   * contract is invoked multiple times in an execution (e.g. authwit checks).
-   * It also means the callers don't need to worry about caching this service's return values, simplifying callsites.
-   */
-  #cache: Map<string, Promise<Fr | undefined>> = new Map();
-
   constructor(
     private node: AztecNode,
     private contractStore: ContractStore,
@@ -40,44 +32,14 @@ export class ContractClassService {
       return instance?.originalContractClassId;
     }
 
-    const key = `${address.toString()}:${(await anchorBlockHeader.hash()).toString()}`;
-    let promise = this.#cache.get(key);
-    if (!promise) {
-      promise = (async () => {
-        // The node resolves the current class from the same scheduled value change the AVM enforces against the public
-        // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means
-        // no upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original
-        // class is current.
-
-        const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
-
-        if (nodeInstance) {
-          return nodeInstance.currentContractClassId;
-        } else {
-          return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
-        }
-      })().catch(err => {
-        this.#cache.delete(key);
-        throw err;
-      });
-      this.#cache.set(key, promise);
-    }
-
-    const classId = await promise;
-    if (classId === undefined) {
-      // Don't memoize a missing instance: it may be registered later in this PXE (e.g. via contract sync
-      // mid-execution), and a cached miss would then hide it. Only successful resolutions stay cached.
-      this.#cache.delete(key);
+    // The node resolves the current class from the same scheduled value change the AVM enforces against the public
+    // data tree. If the contract was upgraded the node returns a non-undefined instance; an undefined result means no
+    // upgrade happened (or the node has no record of it, e.g. it was never publicly deployed), so the original class
+    // is current.
+    const nodeInstance = await this.node.getContract(address, await anchorBlockHeader.hash());
+    if (nodeInstance) {
+      return nodeInstance.currentContractClassId;
     }
-    return classId;
-  }
-
-  /**
-   * Clears the cache.
-   *
-   * This is not required for correctness, only to limit how much memory the cache uses. The cache is resilient against
-   * reorgs etc. as it is based on block hashes, not block numbers. */
-  wipe(): void {
-    this.#cache.clear();
+    return (await this.contractStore.getContractInstance(address))?.originalContractClassId;
   }
 }