@aztec/pxe 5.0.0-rc.2 → 5.0.0

package/dest/storage/tagging_store/tagging_secret_sources_store.d.ts

@@ -1,6 +1,15 @@
 import { Point } from '@aztec/foundation/curves/grumpkin';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * The kinds of shared secret an entry can hold.
+ */
+export type SharedSecretKind = 'arbitrary-secret' | 'handshake';
+/** A shared secret registered for a recipient, with the kind that determines which tag streams it backs. */
+export type SharedSecret = {
+    kind: SharedSecretKind;
+    secret: Point;
+};
 /**
  * Stores the sources from which directional app tagging secrets are derived during recipient log synchronization.
  *
@@ -11,7 +20,8 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
  * - Pre-shared tagging secrets: shared secret points registered directly, bypassing ECDH. These are scoped to a
  *   specific recipient, since the derivation of the directional app tagging secret does not require any secret
  *   recipient data: given the original secret anyone can derive a recipient's app-siloed directional tagging secret,
- *   and so these must not be reused to preserve privacy.
+ *   and so these must not be reused across recipients to preserve privacy. Each carries the {@link SharedSecretKind}
+ *   it was registered through, which determines the tag streams it is scanned under.
  */
 export declare class TaggingSecretSourcesStore {
     #private;
@@ -23,18 +33,19 @@ export declare class TaggingSecretSourcesStore {
      * Registers a pre-shared tagging secret scoped to a recipient.
      * @returns true if the secret was newly added, false if it was already registered for that recipient.
      */
-    addSharedSecret(recipient: AztecAddress, secret: Point): Promise<boolean>;
+    addSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
     /** Returns the pre-shared tagging secrets registered for a given recipient. */
-    getSharedSecretsForRecipient(recipient: AztecAddress): Promise<Point[]>;
+    getSharedSecretsForRecipient(recipient: AztecAddress): Promise<SharedSecret[]>;
     /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */
     getAllSharedSecrets(): Promise<{
         recipient: AztecAddress;
+        kind: SharedSecretKind;
         secret: Point;
     }[]>;
     /**
-     * Removes a pre-shared tagging secret scoped to a recipient.
+     * Removes a pre-shared tagging secret scoped to a recipient. Both the secret and its kind must match.
      * @returns true if the secret was registered and removed, false if it was not registered for that recipient.
      */
-    removeSharedSecret(recipient: AztecAddress, secret: Point): Promise<boolean>;
+    removeSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19zZWNyZXRfc291cmNlc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS90YWdnaW5nX3NlY3JldF9zb3VyY2VzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBcUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFM0Q7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxxQkFBYSx5QkFBeUI7O0lBS3BDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUtuQztJQUVELFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVakQ7SUFFRCxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBSXBDO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVVwRDtJQUVEOzs7T0FHRztJQUNILGVBQWUsQ0FBQyxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxLQUFLLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWN4RTtJQUVELCtFQUErRTtJQUMvRSw0QkFBNEIsQ0FBQyxTQUFTLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQU10RTtJQUVELDBHQUEwRztJQUMxRyxtQkFBbUIsSUFBSSxPQUFPLENBQUM7UUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO1FBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtLQUFFLEVBQUUsQ0FBQyxDQVEzRTtJQUVEOzs7T0FHRztJQUNILGtCQUFrQixDQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBWTNFO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19zZWNyZXRfc291cmNlc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS90YWdnaW5nX3NlY3JldF9zb3VyY2VzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBcUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUcsa0JBQWtCLEdBQUcsV0FBVyxDQUFDO0FBRWhFLDRHQUE0RztBQUM1RyxNQUFNLE1BQU0sWUFBWSxHQUFHO0lBQUUsSUFBSSxFQUFFLGdCQUFnQixDQUFDO0lBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtDQUFFLENBQUM7QUFFckU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEseUJBQXlCOztJQUtwQyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRCxTQUFTLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBVWpEO0lBRUQsVUFBVSxJQUFJLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUlwQztJQUVELFlBQVksQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVcEQ7SUFFRDs7O09BR0c7SUFDSCxlQUFlLENBQUMsU0FBUyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBbUJoRztJQUVELCtFQUErRTtJQUMvRSw0QkFBNEIsQ0FBQyxTQUFTLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQU03RTtJQUVELDBHQUEwRztJQUMxRyxtQkFBbUIsSUFBSSxPQUFPLENBQUM7UUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO1FBQUMsSUFBSSxFQUFFLGdCQUFnQixDQUFDO1FBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtLQUFFLEVBQUUsQ0FBQyxDQVFuRztJQUVEOzs7T0FHRztJQUNILGtCQUFrQixDQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxLQUFLLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVluRztDQUNGIn0=

package/dest/storage/tagging_store/tagging_secret_sources_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tagging_secret_sources_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/tagging_secret_sources_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,qBAAa,yBAAyB;;IAKpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;IAED;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAcxE;IAED,+EAA+E;IAC/E,4BAA4B,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAMtE;IAED,0GAA0G;IAC1G,mBAAmB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC,CAQ3E;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3E;CACF"}
+{"version":3,"file":"tagging_secret_sources_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/tagging_secret_sources_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAEhE,4GAA4G;AAC5G,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAAyB;;IAKpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;IAED;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBhG;IAED,+EAA+E;IAC/E,4BAA4B,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAM7E;IAED,0GAA0G;IAC1G,mBAAmB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC,CAQnG;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnG;CACF"}

package/dest/storage/tagging_store/tagging_secret_sources_store.js

@@ -11,7 +11,8 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
  * - Pre-shared tagging secrets: shared secret points registered directly, bypassing ECDH. These are scoped to a
  *   specific recipient, since the derivation of the directional app tagging secret does not require any secret
  *   recipient data: given the original secret anyone can derive a recipient's app-siloed directional tagging secret,
- *   and so these must not be reused to preserve privacy.
+ *   and so these must not be reused across recipients to preserve privacy. Each carries the {@link SharedSecretKind}
+ *   it was registered through, which determines the tag streams it is scanned under.
  */ export class TaggingSecretSourcesStore {
     #store;
     #senders;
@@ -47,42 +48,48 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
     /**
    * Registers a pre-shared tagging secret scoped to a recipient.
    * @returns true if the secret was newly added, false if it was already registered for that recipient.
-   */ addSharedSecret(recipient, secret) {
+   */ addSharedSecret(recipient, kind, secret) {
         return this.#store.transactionAsync(async ()=>{
             const secretStr = secret.toString();
             // MultiMap.set silently ignores an identical (key, value), so we scan to report whether this is a new secret.
             for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
-                if (existing === secretStr) {
+                if (existing.secret === secretStr) {
+                    if (existing.kind !== kind) {
+                        throw new Error(`Secret already registered for recipient with kind '${existing.kind}', cannot re-register it as '${kind}'.`);
+                    }
                     return false;
                 }
             }
-            await this.#sharedSecretsByRecipient.set(recipient.toString(), secretStr);
+            await this.#sharedSecretsByRecipient.set(recipient.toString(), {
+                kind,
+                secret: secretStr
+            });
             return true;
         });
     }
     /** Returns the pre-shared tagging secrets registered for a given recipient. */ getSharedSecretsForRecipient(recipient) {
         return this.#store.transactionAsync(async ()=>{
-            return (await toArray(this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString()))).map((secret)=>Point.fromString(secret));
+            return (await toArray(this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString()))).map(deserializeSharedSecret);
         });
     }
     /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */ getAllSharedSecrets() {
         return this.#store.transactionAsync(async ()=>{
             const entries = await toArray(this.#sharedSecretsByRecipient.entriesAsync());
-            return entries.map(([recipient, secret])=>({
+            return entries.map(([recipient, entry])=>({
                     recipient: AztecAddress.fromStringUnsafe(recipient),
-                    secret: Point.fromString(secret)
+                    ...deserializeSharedSecret(entry)
                 }));
         });
     }
     /**
-   * Removes a pre-shared tagging secret scoped to a recipient.
+   * Removes a pre-shared tagging secret scoped to a recipient. Both the secret and its kind must match.
    * @returns true if the secret was registered and removed, false if it was not registered for that recipient.
-   */ removeSharedSecret(recipient, secret) {
+   */ removeSharedSecret(recipient, kind, secret) {
         return this.#store.transactionAsync(async ()=>{
             const secretStr = secret.toString();
             for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
-                if (existing === secretStr) {
-                    await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), secretStr);
+                if (existing.kind === kind && existing.secret === secretStr) {
+                    await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), existing);
                     return true;
                 }
             }
@@ -90,3 +97,9 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
         });
     }
 }
+function deserializeSharedSecret(entry) {
+    return {
+        kind: entry.kind,
+        secret: Point.fromString(entry.secret)
+    };
+}

package/dest/tagging/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsZUFBTyxNQUFNLHNDQUFzQyxLQUFLLENBQUMifQ==
+export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN: number;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBLGVBQU8sTUFBTSxzQ0FBc0MsUUFBK0IsQ0FBQyJ9

package/dest/tagging/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sCAAsC,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,sCAAsC,QAA+B,CAAC"}

package/dest/tagging/constants.js

@@ -1,10 +1,19 @@
-// This window has to be as large as the largest expected number of logs emitted in a tx for a given directional app
-// tagging secret. If we get more tag indexes consumed than this window, an error is thrown in `PXE::proveTx` function.
-// This is set to a larger value than MAX_PRIVATE_LOGS_PER_TX (currently 64) because there could be more than
-// MAX_PRIVATE_LOGS_PER_TX indexes consumed in case the logs are squashed. This happens when the log contains a note
-// and the note is nullified in the same tx.
+import { MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+// This window bounds how far a sender's next tag index for a directional app tagging secret can run ahead of that
+// secret's highest finalized index before `PXE::proveTx` throws.
 //
-// Having a large window significantly slowed down `e2e_l1_with_wall_time` test as there we perform sync for more than
-// 1000 secrets. For this reason we set it to a relatively low value of 20. 20 should be sufficient for all the use
-// cases.
-export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
+// MAX_PRIVATE_LOGS_PER_TX is a floor for ordinary transaction patterns: the private kernel accumulates every
+// surviving private log into a single tx-wide array of exactly this size, so a fresh secret's very first
+// ordinary tx can consume that many indexes before anything is finalized.
+//
+// The +20 on top is headroom for multiple pending ordinary txs to the same counterparty stacking up
+// before the first one is observed as mined. Only a run of near-MAX_PRIVATE_LOGS_PER_TX txs back-to-back would
+// exhaust this; ordinary transfers use far fewer logs per tx, so the same margin covers many more of those. Keep the
+// margin additive rather than another multiple of the floor. A larger window also makes recipient-side sync more
+// expensive, since discovery has to probe ahead of the last finalized index for every active secret.
+//
+// TODO(F-783): MAX_PRIVATE_LOGS_PER_TX is not a hard ceiling in general — a tx that creates and nullifies (squashes)
+// many notes/logs to the same secret can drive that secret's raw tag index arbitrarily higher, since indexes are
+// reserved at log emission time, before squashing is decided, and the kernel's reset/squash loop is not bounded by
+// MAX_PRIVATE_LOGS_PER_TX. No fixed window value closes that gap.
+export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = MAX_PRIVATE_LOGS_PER_TX + 20;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "5.0.0-rc.2",
+  "version": "5.0.0",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -71,20 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "5.0.0-rc.2",
-    "@aztec/bb.js": "5.0.0-rc.2",
-    "@aztec/builder": "5.0.0-rc.2",
-    "@aztec/constants": "5.0.0-rc.2",
-    "@aztec/ethereum": "5.0.0-rc.2",
-    "@aztec/foundation": "5.0.0-rc.2",
-    "@aztec/key-store": "5.0.0-rc.2",
-    "@aztec/kv-store": "5.0.0-rc.2",
-    "@aztec/noir-protocol-circuits-types": "5.0.0-rc.2",
-    "@aztec/noir-types": "5.0.0-rc.2",
-    "@aztec/protocol-contracts": "5.0.0-rc.2",
-    "@aztec/simulator": "5.0.0-rc.2",
-    "@aztec/standard-contracts": "5.0.0-rc.2",
-    "@aztec/stdlib": "5.0.0-rc.2",
+    "@aztec/bb-prover": "5.0.0",
+    "@aztec/bb.js": "5.0.0",
+    "@aztec/builder": "5.0.0",
+    "@aztec/constants": "5.0.0",
+    "@aztec/ethereum": "5.0.0",
+    "@aztec/foundation": "5.0.0",
+    "@aztec/key-store": "5.0.0",
+    "@aztec/kv-store": "5.0.0",
+    "@aztec/noir-protocol-circuits-types": "5.0.0",
+    "@aztec/noir-types": "5.0.0",
+    "@aztec/protocol-contracts": "5.0.0",
+    "@aztec/simulator": "5.0.0",
+    "@aztec/standard-contracts": "5.0.0",
+    "@aztec/stdlib": "5.0.0",
     "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": "5.0.0-rc.2",
-    "@aztec/world-state": "5.0.0-rc.2",
+    "@aztec/noir-test-contracts.js": "5.0.0",
+    "@aztec/world-state": "5.0.0",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/block_synchronizer/block_synchronizer.ts

@@ -8,7 +8,8 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
-import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractSyncService } from '../contract/contract_sync_service.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';
@@ -35,6 +36,7 @@ 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,
   ) {
@@ -177,6 +179,12 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     // Therefore, we clear the contract synchronization cache here such that the sync is re-triggered upon new
     // 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();
+
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);
   }

package/src/contract/contract_class_service.ts

@@ -0,0 +1,83 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Resolves the contract class id that an address runs at a given anchor block, as tracked by the chain.
+ *
+ * PXE does not store a contract's current class id: it is mutable, chain-derived state that changes when a contract is
+ * upgraded and can be undone by a reorg. Instead this service asks the node for the current class at an anchor block,
+ * 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,
+  ) {}
+
+  /**
+   * Returns the class id that corresponds to `address` as of `anchorBlockHeader`, or `undefined` if no instance is
+   * registered for `address`. A missing instance is an absence the caller decides how to handle, not an error; genuine
+   * failures (e.g. the node being unreachable) still throw.
+   */
+  async getCurrentClassId(address: AztecAddress, anchorBlockHeader: BlockHeader): Promise<Fr | undefined> {
+    // Protocol contracts are not in the registry and cannot be upgraded, so their original class is always current.
+    // Short-circuiting avoids a node round-trip.
+    if (isProtocolContract(address)) {
+      const instance = await this.contractStore.getContractInstance(address);
+      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);
+    }
+    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();
+  }
+}

package/src/{contract_sync → contract}/contract_sync_service.ts

@@ -10,7 +10,8 @@ import type { StagedStore } from '../job_coordinator/job_coordinator.js';
 import { NoteService } from '../notes/note_service.js';
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
-import { syncScope, verifyCurrentClassId } from './helpers.js';
+import type { ContractClassService } from './contract_class_service.js';
+import { syncScope } from './helpers.js';
 
 /**
  * Maximum number of scope syncs running concurrently within a single sync call. Sized to trade off parallelism
@@ -19,8 +20,8 @@ import { syncScope, verifyCurrentClassId } from './helpers.js';
 export const MAX_CONCURRENT_SCOPE_SYNCS = 5;
 
 /**
- * Service for syncing the private state of contracts and verifying that the PXE holds the current class artifact.
- * It uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
+ * Service for syncing the private state of contracts. It uses a cache to avoid redundant sync operations - the cache
+ * is wiped when the anchor block changes.
  *
  * TODO: The StagedStore naming is broken here. Figure out a better name.
  */
@@ -32,19 +33,16 @@ export class ContractSyncService implements StagedStore {
   // The value is a promise that resolves when the contract is synced.
   private syncedContracts: Map<string, Promise<void>> = new Map();
 
-  // Tracks class ID verification per contract. Keyed by contract address only (no scope), since
-  // class ID verification is scope-independent. Cleared on wipe/discard.
-  private classIdVerificationCache: Map<string, Promise<void>> = new Map();
-
   constructor(
     private aztecNode: AztecNode,
     private contractStore: ContractStore,
+    private contractClassService: ContractClassService,
     private noteStore: NoteStore,
     private log: Logger,
   ) {}
 
   /**
-   * Ensures a contract's private state is synchronized and that the PXE holds the current class artifact.
+   * Ensures a contract's private state is synchronized.
    * Uses a cache to avoid redundant sync operations - the cache is wiped when the anchor block changes.
    * @param contractAddress - The address of the contract to sync.
    * @param functionToInvokeAfterSync - The function selector that will be called after sync (used to validate it's
@@ -61,7 +59,15 @@ export class ContractSyncService implements StagedStore {
     scopes: AztecAddress[],
   ): Promise<void> {
     this.#startSyncIfNeeded(contractAddress, scopes, anchorBlockHeader, jobId, scope =>
-      syncScope(contractAddress, this.contractStore, functionToInvokeAfterSync, utilityExecutor, scope),
+      syncScope(
+        contractAddress,
+        this.contractStore,
+        this.contractClassService,
+        anchorBlockHeader,
+        functionToInvokeAfterSync,
+        utilityExecutor,
+        scope,
+      ),
     );
 
     await this.#awaitSync(contractAddress, scopes);
@@ -79,7 +85,6 @@ export class ContractSyncService implements StagedStore {
   wipe(): void {
     this.log.debug(`Wiping contract sync cache (${this.syncedContracts.size} entries)`);
     this.syncedContracts.clear();
-    this.classIdVerificationCache.clear();
   }
 
   commit(_jobId: string): Promise<void> {
@@ -90,15 +95,13 @@ export class ContractSyncService implements StagedStore {
     // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
     // the sync are also undone.
     this.syncedContracts.clear();
-    this.classIdVerificationCache.clear();
     return Promise.resolve();
   }
 
   /**
    * For each unsynced scope, creates a promise that waits on:
-   *  1. Class ID verification (cached per contract, scope-independent).
-   *  2. Note nullifier sync (shared, batched across all unsynced scopes).
-   *  3. Per-scope sync (individual, semaphore-bounded).
+   *  1. Note nullifier sync (shared, batched across all unsynced scopes).
+   *  2. Per-scope sync (individual, semaphore-bounded).
    */
   #startSyncIfNeeded(
     contractAddress: AztecAddress,
@@ -114,7 +117,6 @@ export class ContractSyncService implements StagedStore {
 
     this.log.debug(`Syncing contract ${contractAddress} for ${scopesToSync.length} scope(s)`);
 
-    const verifyPromise = this.#verifyClassId(contractAddress, anchorBlockHeader);
     const syncNullifiersPromise = this.#syncNoteNullifiers(contractAddress, anchorBlockHeader, jobId, scopesToSync);
 
     // We build a new semaphore for each sync call, so it rate-limits the scopes within that single call. We do
@@ -123,11 +125,7 @@ export class ContractSyncService implements StagedStore {
 
     for (const scope of scopesToSync) {
       const key = toKey(contractAddress, scope);
-      const promise = Promise.all([
-        verifyPromise,
-        syncNullifiersPromise,
-        runBounded(syncSlot, () => syncScopeFn(scope)),
-      ])
+      const promise = Promise.all([syncNullifiersPromise, runBounded(syncSlot, () => syncScopeFn(scope))])
         .then(() => {})
         .catch(err => {
           this.syncedContracts.delete(key);
@@ -137,23 +135,6 @@ export class ContractSyncService implements StagedStore {
     }
   }
 
-  /** Verifies the local class ID matches the on-chain value (cached, evicts on failure so retries re-verify). */
-  #verifyClassId(contractAddress: AztecAddress, anchorBlockHeader: BlockHeader): Promise<void> {
-    const contractKey = contractAddress.toString();
-    const cached = this.classIdVerificationCache.get(contractKey);
-    if (cached) {
-      return cached;
-    }
-    const promise = verifyCurrentClassId(contractAddress, this.aztecNode, this.contractStore, anchorBlockHeader).catch(
-      err => {
-        this.classIdVerificationCache.delete(contractKey);
-        throw err;
-      },
-    );
-    this.classIdVerificationCache.set(contractKey, promise);
-    return promise;
-  }
-
   /** Syncs note nullifiers across all unsynced scopes in a single batched call. */
   async #syncNoteNullifiers(
     contractAddress: AztecAddress,

package/src/contract/helpers.ts

@@ -0,0 +1,35 @@
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+import type { ContractClassService } from './contract_class_service.js';
+
+export async function syncScope(
+  contractAddress: AztecAddress,
+  contractStore: ContractStore,
+  contractClassService: ContractClassService,
+  anchorBlockHeader: BlockHeader,
+  functionToInvokeAfterSync: FunctionSelector | null,
+  utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>,
+  scope: AztecAddress,
+) {
+  // Protocol contracts don't have private state to sync
+  if (isProtocolContract(contractAddress)) {
+    return;
+  }
+
+  const classId = await contractClassService.getCurrentClassId(contractAddress, anchorBlockHeader);
+  if (!classId) {
+    throw new Error(`Cannot sync contract ${contractAddress}: its instance is not registered nor published.`);
+  }
+  const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [scope], contractAddress, classId);
+  if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncStateFunctionCall.selector)) {
+    throw new Error(
+      'Forbidden `sync_state` invocation. `sync_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
+    );
+  }
+
+  await utilityExecutor(syncStateFunctionCall, [scope]);
+}

package/src/contract_function_simulator/anchored_contract_data.ts

@@ -0,0 +1,74 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstancePreimageWithAddress } from '@aztec/stdlib/contract';
+import type { BlockHeader, ContractOverrides } from '@aztec/stdlib/tx';
+
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+
+/**
+ * Per-run view of contract data for a single simulation, bound to its anchor block.
+ *
+ * The {@link ContractStore} is pure class-id-keyed storage and has no notion of which class an address runs. This
+ * class bridges that gap: it resolves an address to its current class id (via the {@link ContractClassService}
+ * at the run's anchor block) and then serves artifacts from the store. It is also the single place contract
+ * overrides are applied — when an address is overridden, both its instance and its class id come from the override
+ * rather than the chain, so a simulation can execute different bytecode at that address. Overrides are only set for
+ * `simulateTx` (which skips the kernels), so the override path never reaches proving.
+ */
+export class AnchoredContractData {
+  constructor(
+    private readonly store: ContractStore,
+    private readonly contractClassService: ContractClassService,
+    private readonly anchorBlockHeader: BlockHeader,
+    private readonly overrides?: ContractOverrides,
+  ) {}
+
+  /** Returns the address preimage of the instance at `address`, from the override if any, else from storage. */
+  getContractInstance(address: AztecAddress): Promise<ContractInstancePreimageWithAddress | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance);
+    }
+    return this.store.getContractInstance(address);
+  }
+
+  /**
+   * Resolves the class id `address` runs in this simulation: the override's class if overridden, else resolved against
+   * the chain at the anchor block.
+   */
+  getCurrentClassId(address: AztecAddress): Promise<Fr | undefined> {
+    const override = this.overrides?.[address.toString()];
+    if (override) {
+      return Promise.resolve(override.instance.currentContractClassId);
+    }
+    return this.contractClassService.getCurrentClassId(address, this.anchorBlockHeader);
+  }
+
+  async getFunctionArtifact(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifact(classId, selector) : undefined;
+  }
+
+  async getFunctionArtifactWithDebugMetadata(
+    address: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getFunctionArtifactWithDebugMetadata(classId, selector) : undefined;
+  }
+
+  async getDebugContractName(address: AztecAddress): Promise<string | undefined> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugContractName(classId) : undefined;
+  }
+
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string> {
+    const classId = await this.getCurrentClassId(address);
+    return classId ? this.store.getDebugFunctionName(classId, selector) : `${address}:${selector}`;
+  }
+}