@aztec/pxe 5.0.0 → 5.0.1

package/package.json

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

package/src/contract_function_simulator/oracle/oracle_registry.ts

@@ -273,6 +273,11 @@ export const ORACLE_REGISTRY = {
     returnType: OPTION(TX_EFFECT),
   }),
 
+  aztec_utl_getTxEffects: makeEntry({
+    params: [{ name: 'txHashes', type: EPHEMERAL_ARRAY(TX_HASH) }],
+    returnType: EPHEMERAL_ARRAY(OPTION(TX_EFFECT)),
+  }),
+
   aztec_utl_setCapsule: makeEntry({
     params: [
       { name: 'contractAddress', type: AZTEC_ADDRESS },

package/src/contract_function_simulator/oracle/utility_execution_oracle.ts

@@ -35,6 +35,7 @@ import {
   type Capsule,
   type IndexedTxEffect,
   type OffchainEffect,
+  type TxEffect,
   type TxHash,
 } from '@aztec/stdlib/tx';
 
@@ -48,6 +49,7 @@ import { TxResolverService } from '../../messages/tx_resolver_service.js';
 import { NoteService } from '../../notes/note_service.js';
 import { ORACLE_VERSION_MAJOR } from '../../oracle_version.js';
 import type { AddressStore } from '../../storage/address_store/address_store.js';
+import { assertAllowedScope } from '../../storage/allowed_scopes.js';
 import type { CapsuleService } from '../../storage/capsule_store/capsule_service.js';
 import { FactCollectionKey, FactCollectionTypeKey, anchoredTipBlockNumbers } from '../../storage/fact_store/index.js';
 import type { FactService, OriginBlock } from '../../storage/fact_store/index.js';
@@ -612,6 +614,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       this.recipientTaggingStore,
       this.taggingSecretSourcesStore,
       this.addressStore,
+      this.scopes,
       this.jobId,
       this.logger.getBindings(),
     );
@@ -683,21 +686,25 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       throw new Error('Invalid tx hash passed into aztec_utl_getTxEffect oracle handler');
     }
 
-    const receipt = await this.aztecNodeReadCache.getTxReceiptWithEffect(txHash);
-    if (!receipt.isMined() || !receipt.txEffect || receipt.blockNumber > this.anchorBlockHeader.getBlockNumber()) {
-      return Option.none();
+    return await this.#getTxEffectOption(txHash);
+  }
+
+  /** Fetches transaction effects for all hashes, preserving request order. */
+  public async getTxEffects(txHashes: EphemeralArray<TxHash>): Promise<EphemeralArray<Option<TxEffectData>>> {
+    const hashes = txHashes.readAll(this.ephemeralArrayService);
+    const invalidHash = hashes.find(txHash => txHash.hash.isZero());
+    if (invalidHash) {
+      throw new Error('Invalid tx hash passed into aztec_utl_getTxEffects oracle handler');
     }
 
-    const txEffect = receipt.txEffect;
-    return Option.some({
-      ...txEffect,
-      publicLogs: FlatPublicLogs.fromLogs(txEffect.publicLogs),
-      contractClassLogs: txEffect.contractClassLogs.map(log => ({
-        contractAddress: log.contractAddress,
-        fields: log.fields.toFields(),
-        emittedLength: log.emittedLength,
-      })),
-    });
+    const uniqueTxHashes = uniqueBy(hashes, h => h.toString());
+    const options = await Promise.all(uniqueTxHashes.map(txHash => this.#getTxEffectOption(txHash)));
+    const optionsByHash = new Map(uniqueTxHashes.map((txHash, i) => [txHash.toString(), options[i]]));
+
+    return EphemeralArray.fromValues(
+      this.ephemeralArrayService,
+      hashes.map(txHash => optionsByHash.get(txHash.toString())!),
+    );
   }
 
   public setCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[], scope: AztecAddress): void {
@@ -871,7 +878,8 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    * @param ephPks - Ephemeral array containing the serialized Points.
    * @param contractAddress - The contract address for app-siloing (validated against execution context).
    * @returns A new ephemeral array containing the computed shared secrets, or an empty array when the PXE does not
-   * hold the keys for `address`, signaling that no secrets can be derived for it.
+   * hold the keys for `address`.
+   * @throws If `address` is not in the execution's allowed scopes.
    */
   public async getSharedSecrets(
     address: AztecAddress,
@@ -883,6 +891,11 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
         `getSharedSecrets called with contract address ${contractAddress}, expected ${this.contractAddress}`,
       );
     }
+
+    assertAllowedScope(address, this.scopes);
+
+    // An address can be in scope without the PXE holding its keys (e.g. syncing a registered but non-owned account),
+    // in which case no secrets can be derived and we return an empty array rather than failing.
     const recipientCompleteAddress = await this.addressStore.getCompleteAddress(address);
     if (!recipientCompleteAddress) {
       this.logger.warn(
@@ -1119,6 +1132,26 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     );
   }
 
+  async #getTxEffectOption(txHash: TxHash): Promise<Option<TxEffectData>> {
+    const receipt = await this.aztecNodeReadCache.getTxReceiptWithEffect(txHash);
+    if (!receipt.isMined() || !receipt.txEffect || receipt.blockNumber > this.anchorBlockHeader.getBlockNumber()) {
+      return Option.none();
+    }
+    return Option.some(this.#toTxEffectData(receipt.txEffect));
+  }
+
+  #toTxEffectData(txEffect: TxEffect): TxEffectData {
+    return {
+      ...txEffect,
+      publicLogs: FlatPublicLogs.fromLogs(txEffect.publicLogs),
+      contractClassLogs: txEffect.contractClassLogs.map(log => ({
+        contractAddress: log.contractAddress,
+        fields: log.fields.toFields(),
+        emittedLength: log.emittedLength,
+      })),
+    };
+  }
+
   /** Runs a query concurrently with a validation that the block hash is not ahead of the anchor block. */
   async #queryWithBlockHashNotAfterAnchor<T>(blockHash: BlockHash, query: () => Promise<T>): Promise<T> {
     // Most contracts query state at the "current" block, which is the anchor. Skip the validation when we can.

package/src/entrypoints/client/bundle/index.ts

@@ -6,3 +6,4 @@ export * from '../../../contract_logging.js';
 export * from '../../../storage/index.js';
 export * from './utils.js';
 export type { PXECreationOptions } from '../../pxe_creation_options.js';
+export { openBrowserStore } from '../store.js';

package/src/entrypoints/client/bundle/utils.ts

@@ -1,6 +1,5 @@
 import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { createLogger } from '@aztec/foundation/log';
-import { createStore } from '@aztec/kv-store/sqlite-opfs';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { WASMSimulator } from '@aztec/simulator/client';
 import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
@@ -12,6 +11,7 @@ import type { PXEConfig } from '../../../config/index.js';
 import { PXE } from '../../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../../storage/metadata.js';
 import { type PXECreationOptions, isPrivateKernelProver } from '../../pxe_creation_options.js';
+import { openBrowserStore } from '../store.js';
 
 /**
  * Create and start an PXE instance with the given AztecNode.
@@ -31,16 +31,28 @@ export async function createPXE(
   const actor = options.loggerActorLabel;
   const loggers = options.loggers ?? {};
 
-  const l1ContractAddresses = await aztecNode.getL1ContractAddresses();
+  const { l1ChainId, l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
   const configWithContracts = {
     ...config,
     ...l1ContractAddresses,
+    l1ChainId,
+    rollupVersion,
   } as PXEConfig;
 
   const storeLogger = loggers.store ?? createLogger('pxe:data', { actor });
 
   const store =
-    options.store ?? (await createStore('pxe_data', configWithContracts, PXE_DATA_SCHEMA_VERSION, storeLogger));
+    options.store ??
+    (await openBrowserStore(
+      'pxe_data',
+      PXE_DATA_SCHEMA_VERSION,
+      {
+        l1ChainId,
+        rollupAddress: l1ContractAddresses.rollupAddress,
+        dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+      },
+      storeLogger,
+    ));
 
   const simulator = options.simulator ?? new WASMSimulator();
   const proverLogger = loggers.prover ?? createLogger('pxe:bb:wasm:bundle', { actor });

package/src/entrypoints/client/lazy/index.ts

@@ -6,3 +6,4 @@ export * from '../../../error_enriching.js';
 export * from '../../../contract_logging.js';
 export * from './utils.js';
 export { type PXECreationOptions } from '../../pxe_creation_options.js';
+export { openBrowserStore } from '../store.js';

package/src/entrypoints/client/lazy/utils.ts

@@ -1,6 +1,5 @@
 import { BBLazyPrivateKernelProver } from '@aztec/bb-prover/client/lazy';
 import { createLogger } from '@aztec/foundation/log';
-import { createStore } from '@aztec/kv-store/sqlite-opfs';
 import { LazyProtocolContractsProvider } from '@aztec/protocol-contracts/providers/lazy';
 import { WASMSimulator } from '@aztec/simulator/client';
 import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry/lazy';
@@ -12,6 +11,7 @@ import type { PXEConfig } from '../../../config/index.js';
 import { PXE } from '../../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../../storage/metadata.js';
 import { type PXECreationOptions, isPrivateKernelProver } from '../../pxe_creation_options.js';
+import { openBrowserStore } from '../store.js';
 
 /**
  * Create and start an PXE instance with the given AztecNode.
@@ -29,10 +29,12 @@ export async function createPXE(
 ) {
   const actor = options.loggerActorLabel;
 
-  const l1ContractAddresses = await aztecNode.getL1ContractAddresses();
+  const { l1ChainId, l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
   const configWithContracts = {
     ...config,
     ...l1ContractAddresses,
+    l1ChainId,
+    rollupVersion,
   } as PXEConfig;
 
   const loggers = options.loggers ?? {};
@@ -40,7 +42,17 @@ export async function createPXE(
   const storeLogger = loggers.store ?? createLogger('pxe:data', { actor });
 
   const store =
-    options.store ?? (await createStore('pxe_data', configWithContracts, PXE_DATA_SCHEMA_VERSION, storeLogger));
+    options.store ??
+    (await openBrowserStore(
+      'pxe_data',
+      PXE_DATA_SCHEMA_VERSION,
+      {
+        l1ChainId,
+        rollupAddress: l1ContractAddresses.rollupAddress,
+        dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+      },
+      storeLogger,
+    ));
 
   const simulator = options.simulator ?? new WASMSimulator();
   const proverLogger = loggers.prover ?? createLogger('pxe:bb:wasm:bundle', { actor });

package/src/entrypoints/client/store.ts

@@ -0,0 +1,38 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { AztecSQLiteOPFSStore, storePoolDirectory } from '@aztec/kv-store/sqlite-opfs';
+
+import { assertStoreIdentity, effectiveStoreName } from '../../storage/store_identity.js';
+
+/**
+ * Opens the persistent browser (sqlite-opfs) store selected by `name` and identity `(config.l1ChainId,
+ * config.rollupAddress, schemaVersion)` triple. A store exists per identity: reopening with the same identity returns
+ * the same data, a different identity selects a different (possibly fresh) store.
+ */
+export async function openBrowserStore(
+  name: string,
+  schemaVersion: number,
+  config: { l1ChainId: number; rollupAddress: EthAddress; dataStoreMapSizeKb?: number },
+  log: Logger = createLogger('pxe:data'),
+): Promise<AztecSQLiteOPFSStore> {
+  const identity = { l1ChainId: config.l1ChainId, rollupAddress: config.rollupAddress, schemaVersion };
+  const storeName = effectiveStoreName(name, identity);
+  log.info(`Creating ${storeName} SQLite-OPFS data store`, {
+    storeName,
+    dataStoreMapSizeKb: config.dataStoreMapSizeKb,
+  });
+  const store = await AztecSQLiteOPFSStore.open(
+    createLogger('kv-store:sqlite-opfs'),
+    storeName,
+    false,
+    storePoolDirectory(storeName),
+  );
+  try {
+    await assertStoreIdentity(store, storeName, identity);
+  } catch (err) {
+    // The store handle owns a worker and OPFS locks; release them before surfacing the refusal.
+    await store.close().catch(() => {});
+    throw err;
+  }
+  return store;
+}

package/src/entrypoints/server/index.ts

@@ -6,6 +6,7 @@ export * from '../../config/index.js';
 export * from '../../error_enriching.js';
 export * from '../../storage/index.js';
 export * from './utils.js';
+export * from './store.js';
 export { NoteService } from '../../notes/note_service.js';
 export { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
 export { type PXECreationOptions } from '../pxe_creation_options.js';

package/src/entrypoints/server/store.ts

@@ -0,0 +1,47 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { type AztecLMDBStoreV2, openStoreAt } from '@aztec/kv-store/lmdb-v2';
+
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+
+import { storeIdentitySlug } from '../../storage/store_identity.js';
+
+/** Location and identity inputs for opening an identity-partitioned PXE-side store. */
+export type IdentityStoreConfig = {
+  dataDirectory: string;
+  /** Maximum LMDB map size in KB. When omitted, the kv-store default map size applies. */
+  dataStoreMapSizeKb?: number;
+  l1ChainId: number;
+  rollupAddress: EthAddress;
+};
+
+/**
+ * Opens the persistent LMDB store selected by `name` and identity triple `(l1ChainId, rollupAddress, schemaVersion)`.
+ * A store exists per identity: reopening with the same identity returns the same data, a different identity selects
+ * a different (possibly fresh) store. Callers wanting an ephemeral store use `openTmpStore` explicitly instead.
+ */
+export async function openStore(
+  name: string,
+  schemaVersion: number,
+  config: IdentityStoreConfig,
+  bindings?: LoggerBindings,
+): Promise<AztecLMDBStoreV2> {
+  // Stores live under `<dataDirectory>/<name>-stores/<l1ChainId>-<rollupAddress>-v<schemaVersion>`, a sibling of the
+  // legacy `<dataDirectory>/<name>` directory: older binaries reset the legacy directory on a rollup mismatch, so
+  // per-identity stores must not nest inside it.
+  const subDir = join(
+    config.dataDirectory,
+    `${name}-stores`,
+    storeIdentitySlug({ l1ChainId: config.l1ChainId, rollupAddress: config.rollupAddress, schemaVersion }),
+  );
+  await mkdir(subDir, { recursive: true });
+
+  createLogger(`pxe:data:${name}`, bindings).info(`Opening ${name} data store (LMDB v2)`, {
+    storeName: name,
+    subDir,
+    dataStoreMapSizeKb: config.dataStoreMapSizeKb,
+  });
+
+  return openStoreAt(subDir, config.dataStoreMapSizeKb, undefined, bindings);
+}

package/src/entrypoints/server/utils.ts

@@ -1,7 +1,7 @@
 import { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { createLogger } from '@aztec/foundation/log';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
 import { WASMSimulator } from '@aztec/simulator/client';
 import { MemoryCircuitRecorder, SimulatorRecorderWrapper } from '@aztec/simulator/server';
@@ -15,6 +15,7 @@ import type { PXEConfig } from '../../config/index.js';
 import { PXE } from '../../pxe.js';
 import { PXE_DATA_SCHEMA_VERSION } from '../../storage/index.js';
 import { type PXECreationOptions, isPrivateKernelProver } from '../pxe_creation_options.js';
+import { openStore } from './store.js';
 
 type PXEConfigWithoutDefaults = Omit<
   PXEConfig,
@@ -46,12 +47,25 @@ export async function createPXE(
 
   if (!options.store) {
     const storeLogger = loggers.store ?? createLogger('pxe:data:lmdb', { actor });
-    options.store = await createStore(
-      'pxe_data',
-      PXE_DATA_SCHEMA_VERSION,
-      configWithContracts,
-      storeLogger.getBindings(),
-    );
+    options.store = configWithContracts.dataDirectory
+      ? await openStore(
+          'pxe_data',
+          PXE_DATA_SCHEMA_VERSION,
+          {
+            dataDirectory: configWithContracts.dataDirectory,
+            dataStoreMapSizeKb: configWithContracts.dataStoreMapSizeKb,
+            l1ChainId,
+            rollupAddress: l1ContractAddresses.rollupAddress,
+          },
+          storeLogger.getBindings(),
+        )
+      : await openTmpStore(
+          'pxe_data',
+          true,
+          configWithContracts.dataStoreMapSizeKb,
+          undefined,
+          storeLogger.getBindings(),
+        );
   }
   const proverLogger = loggers.prover ?? createLogger('pxe:bb:native', { actor });
 

package/src/logs/log_service.ts

@@ -24,6 +24,7 @@ import type { LogRetrievalResponse } from '../contract_function_simulator/noir-s
 import type { PendingTaggedLog } from '../contract_function_simulator/noir-structs/pending_tagged_log.js';
 import { ResolvedTx } from '../contract_function_simulator/noir-structs/resolved_tx.js';
 import { AddressStore } from '../storage/address_store/address_store.js';
+import { assertAllowedScope } from '../storage/allowed_scopes.js';
 import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
 import {
@@ -47,6 +48,7 @@ export class LogService {
     private readonly recipientTaggingStore: RecipientTaggingStore,
     private readonly taggingSecretSourcesStore: TaggingSecretSourcesStore,
     private readonly addressStore: AddressStore,
+    private readonly scopes: AztecAddress[],
     private readonly jobId: string,
     bindings?: LoggerBindings,
   ) {
@@ -189,6 +191,8 @@ export class LogService {
     recipient: AztecAddress,
     providedSecrets: AppTaggingSecret[],
   ): Promise<PendingTaggedLog[]> {
+    assertAllowedScope(recipient, this.scopes);
+
     this.log.verbose(
       `Fetching tagged logs for contract ${contractAddress.toString()} and recipient ${recipient.toString()}`,
     );

package/src/notes/note_service.ts

@@ -26,7 +26,7 @@ export class NoteService {
    *
    * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
    * @param status - The status of notes to fetch.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @param scopes - The accounts whose notes we can access in this call. An empty list matches no notes.
    */
   public async getNotes(
     contractAddress: AztecAddress,

package/src/oracle_version.ts

@@ -11,7 +11,7 @@
 /// if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency without actually
 /// using any of the new oracles then there is no reason to throw.
 export const ORACLE_VERSION_MAJOR = 30;
-export const ORACLE_VERSION_MINOR = 7;
+export const ORACLE_VERSION_MINOR = 8;
 
 /// This hash is computed from the `ORACLE_REGISTRY` declaration (each oracle's name, ordered parameter names and
 /// types, and return type) and is used to detect when the oracle interface changes. When it does, you need to either:
@@ -19,4 +19,4 @@ export const ORACLE_VERSION_MINOR = 7;
 /// - increment only `ORACLE_VERSION_MINOR` if the change is additive (a new oracle was added).
 ///
 /// These constants must be kept in sync between this file and `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
-export const ORACLE_INTERFACE_HASH = '416b0e7d3e6dca5803ebe2a65ea93f1e79759dc39ef8ec4c52eeba5e2b0f3fca';
+export const ORACLE_INTERFACE_HASH = 'b302a8e65d37043c0a0dc08a39895603122dce334843f0442462edb3f56e32e2';

package/src/pxe.ts

@@ -37,7 +37,7 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import { computeAddressSecret } from '@aztec/stdlib/keys';
-import { deriveEcdhSharedSecretPoint } from '@aztec/stdlib/logs';
+import { deriveEcdhSharedSecretPoint, protectFromForgery } from '@aztec/stdlib/logs';
 import {
   BlockHeader,
   type ContractOverrides,
@@ -890,9 +890,11 @@ export class PXE {
   }
 
   /**
-   * Derives the shared secret of a handshake from its ephemeral public key: `S = addressSecret(recipient) * ephPk`,
-   * the same derivation the recipient-side scan uses for handshakes discovered onchain. The ephemeral key is
-   * reconstructed from its x-coordinate with a positive y, matching how the protocol generates it.
+   * Derives the shared secret of a handshake from its ephemeral public key: the raw ECDH secret
+   * `S = addressSecret(recipient) * ephPk` with the forgery protection applied,
+   * matching the protected secret the registry stores and the derivation the recipient-side scan uses for
+   * handshakes discovered onchain. The ephemeral key is reconstructed from its x-coordinate with a positive y,
+   * matching how the protocol generates it.
    *
    * @throws If `ephPk` is not the x-coordinate of a Grumpkin curve point, or if `recipient` is not an account of
    * this PXE, since the derivation needs its keys.
@@ -914,7 +916,8 @@ export class PXE {
 
     const ivskM = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
     const addressSecret = await computeAddressSecret(await completeAddress.getPreaddress(), ivskM);
-    return deriveEcdhSharedSecretPoint(addressSecret, ephPkPoint);
+    const rawSecret = await deriveEcdhSharedSecretPoint(addressSecret, ephPkPoint);
+    return protectFromForgery(rawSecret, ephPkPoint, await recipient.toAddressPoint());
   }
 
   /** Registers a resolved shared secret scoped to a recipient. Returns whether it was newly added. */

package/src/storage/store_identity.ts

@@ -0,0 +1,72 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { DatabaseVersion } from '@aztec/stdlib/database-version/version';
+
+/** The triple that determine which physical store a logical store name maps to. */
+export type StoreIdentity = {
+  /** Chain ID of the L1 the rollup is deployed to. */
+  l1ChainId: number;
+  /** Address of the rollup contract the store's data pertains to. */
+  rollupAddress: EthAddress;
+  /** Schema version of the data held in the store. */
+  schemaVersion: number;
+};
+
+/**
+ * Composes the store-name discriminator for a store identity. Two identities map to the same physical store iff
+ * their slugs are equal, so the format must stay stable: `<l1ChainId>-<rollupAddress>-v<schemaVersion>` — changing
+ * it orphans every existing store.
+ */
+export function storeIdentitySlug({ l1ChainId, rollupAddress, schemaVersion }: StoreIdentity): string {
+  return `${l1ChainId}-${rollupAddress.toString()}-v${schemaVersion}`;
+}
+
+/** Composes the physical store name for a logical store name and identity. */
+export function effectiveStoreName(name: string, identity: StoreIdentity): string {
+  return `${name}_${storeIdentitySlug(identity)}`;
+}
+
+/**
+ * Invariant check for stores whose physical name carries their identity: the recorded version can
+ * only disagree with the expected one if there is a store-naming bug.
+ */
+export async function assertStoreIdentity(
+  store: AztecAsyncKVStore,
+  storeName: string,
+  identity: StoreIdentity,
+): Promise<void> {
+  const expected = new DatabaseVersion(identity.schemaVersion, identity.rollupAddress);
+  const singleton = store.openSingleton<string>('dbVersion');
+  const stored = await singleton.getAsync();
+  if (stored === undefined) {
+    await singleton.set(expected.toBuffer().toString('utf-8'));
+    return;
+  }
+  let storedVersion: DatabaseVersion;
+  try {
+    storedVersion = DatabaseVersion.fromBuffer(Buffer.from(stored, 'utf-8'));
+  } catch {
+    throw new StoreIdentityMismatchError(storeName, expected.toString(), stored);
+  }
+  if (!storedVersion.equals(expected)) {
+    throw new StoreIdentityMismatchError(storeName, expected.toString(), storedVersion.toString());
+  }
+}
+
+/**
+ * Thrown when a store's recorded identity does not match the identity it was opened under. Since the identity is
+ * part of the physical store name, this can only indicate a store-naming bug; the store is left untouched.
+ */
+export class StoreIdentityMismatchError extends Error {
+  constructor(
+    public readonly storeName: string,
+    public readonly expected: string,
+    public readonly actual: string,
+  ) {
+    super(
+      `Store '${storeName}' records identity ${actual} but was opened as ${expected}. ` +
+        `Refusing to open; data was NOT modified.`,
+    );
+    this.name = 'StoreIdentityMismatchError';
+  }
+}