@aztec/pxe 5.0.0-rc.2 → 5.0.1

package/src/storage/fact_store/fact_service.ts

@@ -2,8 +2,15 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import { assertAllowedScope } from '../allowed_scopes.js';
-import type { FactCollection, FactStore } from './fact_store.js';
+import type { FactStore } from './fact_store.js';
 import type { FactCollectionKey, FactCollectionTypeKey, OriginBlock } from './fact_store_keys.js';
+import {
+  type FactCollectionWithOriginState,
+  type FactWithOriginState,
+  type TipBlockNumbers,
+  toFactWithOriginState,
+} from './origin_state.js';
+import type { Fact } from './stored_fact.js';
 
 /**
  * Wraps a {@link FactStore} with scope-based access control.
@@ -33,13 +40,30 @@ export class FactService {
     return this.factStore.deleteFactCollection(factCollectionKey, jobId);
   }
 
-  getFactCollection(factCollectionKey: FactCollectionKey, jobId: string): Promise<FactCollection | undefined> {
+  async getFactCollection(
+    factCollectionKey: FactCollectionKey,
+    tips: TipBlockNumbers,
+    jobId: string,
+  ): Promise<FactCollectionWithOriginState | undefined> {
     assertAllowedScope(factCollectionKey.scope, this.allowedScopes);
-    return this.factStore.getFactCollection(factCollectionKey, jobId);
+    const collection = await this.factStore.getFactCollection(factCollectionKey, jobId);
+    if (!collection) {
+      return undefined;
+    }
+    return { key: collection.key, facts: this.#annotate(collection.facts, tips) };
   }
 
-  getFactCollectionsByType(factCollectionTypeKey: FactCollectionTypeKey, jobId: string): Promise<FactCollection[]> {
+  async getFactCollectionsByType(
+    factCollectionTypeKey: FactCollectionTypeKey,
+    tips: TipBlockNumbers,
+    jobId: string,
+  ): Promise<FactCollectionWithOriginState[]> {
     assertAllowedScope(factCollectionTypeKey.scope, this.allowedScopes);
-    return this.factStore.getFactCollectionsByType(factCollectionTypeKey, jobId);
+    const collections = await this.factStore.getFactCollectionsByType(factCollectionTypeKey, jobId);
+    return collections.map(collection => ({ key: collection.key, facts: this.#annotate(collection.facts, tips) }));
+  }
+
+  #annotate(facts: Fact[], tips: TipBlockNumbers): FactWithOriginState[] {
+    return facts.map(fact => toFactWithOriginState(fact, tips));
   }
 }

package/src/storage/fact_store/fact_store.ts

@@ -82,7 +82,7 @@ export class FactStore implements StagedStore {
   }
 
   /**
-   * Records a fact in a collection.
+   * Records a fact in a collection, visible under the given scope.
    *
    * The collection is created implicitly on the first fact recorded for its key: recording into an existing collection
    * just adds to it.

package/src/storage/fact_store/index.ts

@@ -2,3 +2,13 @@ export { FactStore, type FactCollection } from './fact_store.js';
 export { FactService } from './fact_service.js';
 export { FactCollectionKey, FactCollectionTypeKey, type OriginBlock } from './fact_store_keys.js';
 export type { Fact } from './stored_fact.js';
+export {
+  OriginBlockState,
+  classifyOriginBlockState,
+  anchoredTipBlockNumbers,
+  toFactWithOriginState,
+  type TipBlockNumbers,
+  type RetractableFactOrigin,
+  type FactWithOriginState,
+  type FactCollectionWithOriginState,
+} from './origin_state.js';

package/src/storage/fact_store/origin_state.ts

@@ -0,0 +1,75 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2Tips } from '@aztec/stdlib/block';
+
+import type { FactCollectionKey, OriginBlock } from './fact_store_keys.js';
+import type { Fact } from './stored_fact.js';
+
+/**
+ * Chain state of a retractable fact's origin block, mirroring the L2 chain tips.
+ *
+ * - `Pending`: above the proven tip.
+ * - `Proven`: proof on L1 but not yet finalized.
+ * - `Finalized`: L1-finalized.
+ *
+ * The numeric discriminants must stay in sync with the Noir `OriginBlockState` in
+ * `noir-projects/aztec-nr/aztec/src/facts/origin_state.nr`: PXE serializes this value into the `Fact` oracle response
+ * and Noir deserializes it via `from_u8`, which rejects any value outside this set.
+ */
+export enum OriginBlockState {
+  Pending = 1,
+  Proven = 2,
+  Finalized = 3,
+}
+
+/** The two chain-tip block numbers needed to classify an origin block (`finalized <= proven` always holds). */
+export type TipBlockNumbers = { provenBlockNumber: number; finalizedBlockNumber: number };
+
+/**
+ * Projects the live chain tips to the block numbers used for classification, capped at the anchor block.
+ *
+ * A utility execution reads against a fixed anchor block, and every other node query in the oracle is bounded by it.
+ * Capping the proven/finalized tips at the anchor keeps origin-state consistent with that view and deterministic
+ * across runs: an origin block at or before the anchor classifies exactly as it would against the live tips, while an
+ * origin block above the anchor is reported `Pending` rather than trusting tips that look past the anchor.
+ */
+export function anchoredTipBlockNumbers(tips: L2Tips, anchorBlockNumber: number): TipBlockNumbers {
+  return {
+    provenBlockNumber: Math.min(tips.proven.block.number, anchorBlockNumber),
+    finalizedBlockNumber: Math.min(tips.finalized.block.number, anchorBlockNumber),
+  };
+}
+
+/** A retractable fact's origin block annotated with that block's current chain state. */
+export type RetractableFactOrigin = OriginBlock & { blockState: OriginBlockState };
+
+/** A fact enriched with origin-block state. `originBlock` is undefined for a non-retractable fact. */
+export type FactWithOriginState = { factTypeId: Fr; payload: Fr[]; originBlock: RetractableFactOrigin | undefined };
+
+/** A fact collection whose facts carry origin-block state. */
+export type FactCollectionWithOriginState = { key: FactCollectionKey; facts: FactWithOriginState[] };
+
+/**
+ * Classifies an origin block by number against the chain tips. A surviving retractable fact's origin block is
+ * guaranteed canonical (a reorg would have pruned the fact), so a number comparison is sufficient.
+ */
+export function classifyOriginBlockState(blockNumber: number, tips: TipBlockNumbers): OriginBlockState {
+  if (blockNumber <= tips.finalizedBlockNumber) {
+    return OriginBlockState.Finalized;
+  }
+  if (blockNumber <= tips.provenBlockNumber) {
+    return OriginBlockState.Proven;
+  }
+  return OriginBlockState.Pending;
+}
+
+/** Enriches a stored fact with the chain state of its origin block (when retractable). */
+export function toFactWithOriginState(fact: Fact, tips: TipBlockNumbers): FactWithOriginState {
+  const originBlock: RetractableFactOrigin | undefined = fact.originBlock
+    ? {
+        blockNumber: fact.originBlock.blockNumber,
+        blockHash: fact.originBlock.blockHash,
+        blockState: classifyOriginBlockState(fact.originBlock.blockNumber, tips),
+      }
+    : undefined;
+  return { factTypeId: fact.factTypeId, payload: fact.payload, originBlock };
+}

package/src/storage/metadata.ts

@@ -1 +1 @@
-export const PXE_DATA_SCHEMA_VERSION = 9;
+export const PXE_DATA_SCHEMA_VERSION = 13;

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';
+  }
+}

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -128,10 +128,11 @@ export class SenderTaggingStore implements StagedStore {
   }
 
   /**
-   * Stores pending index ranges.
+   * Stores pending index ranges, rejecting any range that disagrees with an already-stored one.
    * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
    * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
-   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug in
+   * callers that record indexes at prove time. Discovery from onchain logs must use `mergePendingIndexes` instead.
    * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
    * to be stored in the db.
    * @param txHash - The tx in which the tagging indexes were used in private logs.
@@ -141,6 +142,33 @@ export class SenderTaggingStore implements StagedStore {
    * @throws If a different range already exists for the same (secret, txHash) pair.
    */
   storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void> {
+    return this.#storePendingIndexes(ranges, txHash, jobId, false);
+  }
+
+  /**
+   * Stores pending index ranges, widening an existing entry for the same (secret, txHash) pair to the union of the
+   * stored and incoming ranges instead of throwing on a mismatch. Discovery from onchain logs needs this: it may see
+   * only the surviving (non-revertible phase) sub-range of a partially reverted tx recorded at prove time (the
+   * finalized receipt step of the sync resolves that difference), or indexes beyond a partially discovered entry
+   * when a tx from another PXE straddles a sync window boundary. Callers that record indexes at prove time must use
+   * `storePendingIndexes` instead, so that a range disagreement surfaces as a bug rather than being absorbed.
+   * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+   * to be stored in the db.
+   * @param txHash - The tx in which the tagging indexes were used in private logs.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+   * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+   */
+  mergePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void> {
+    return this.#storePendingIndexes(ranges, txHash, jobId, true);
+  }
+
+  #storePendingIndexes(
+    ranges: TaggingIndexRange[],
+    txHash: TxHash,
+    jobId: string,
+    mergeExisting: boolean,
+  ): Promise<void> {
     if (ranges.length === 0) {
       return Promise.resolve();
     }
@@ -187,21 +215,40 @@ export class SenderTaggingStore implements StagedStore {
         // Check if an entry with the same txHash already exists
         const existingEntry = pendingData.find(entry => entry.txHash === txHashStr);
 
-        if (existingEntry) {
-          // Assert that the ranges are equal — different ranges for the same (secret, txHash) indicates a bug
-          if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
-            throw new Error(
-              `Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` +
-                `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` +
-                `new [${range.lowestIndex}, ${range.highestIndex}]`,
-            );
-          }
-          // Exact duplicate — skip
-        } else {
-          this.#writePendingIndexes(jobId, secretStr, [
+        let updatedPending: PendingIndexesEntry[] | undefined;
+        if (!existingEntry) {
+          updatedPending = [
             ...pendingData,
             { lowestIndex: range.lowestIndex, highestIndex: range.highestIndex, txHash: txHashStr },
-          ]);
+          ];
+        } else if (mergeExisting) {
+          // Widen the entry to the union of both ranges, never shrink it: replacing would drop prove-time
+          // indexes the chain doesn't show (partially reverted tx), and skipping would drop onchain indexes
+          // discovered in a later sync window (tx straddling the window boundary).
+          const lowestIndex = Math.min(existingEntry.lowestIndex, range.lowestIndex);
+          const highestIndex = Math.max(existingEntry.highestIndex, range.highestIndex);
+          if (lowestIndex !== existingEntry.lowestIndex || highestIndex !== existingEntry.highestIndex) {
+            updatedPending = pendingData.map(entry =>
+              entry === existingEntry ? { lowestIndex, highestIndex, txHash: entry.txHash } : entry,
+            );
+          }
+        } else if (
+          existingEntry.lowestIndex !== range.lowestIndex ||
+          existingEntry.highestIndex !== range.highestIndex
+        ) {
+          // Different ranges for the same (secret, txHash) indicate a bug in callers that record indexes at prove
+          // time.
+          throw new Error(
+            `Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` +
+              `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` +
+              `new [${range.lowestIndex}, ${range.highestIndex}]`,
+          );
+        }
+        // Remaining cases (a merge whose union equals the stored range, or an identical range without
+        // mergeExisting): duplicate evidence, nothing to write.
+
+        if (updatedPending) {
+          this.#writePendingIndexes(jobId, secretStr, updatedPending);
         }
       }
     });

package/src/storage/tagging_store/tagging_secret_sources_store.ts

@@ -3,6 +3,14 @@ import { toArray } from '@aztec/foundation/iterable';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } 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.
  *
@@ -13,12 +21,13 @@ 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: AztecAsyncKVStore;
   #senders: AztecAsyncMap<string, true>;
-  #sharedSecretsByRecipient: AztecAsyncMultiMap<string, string>;
+  #sharedSecretsByRecipient: AztecAsyncMultiMap<string, StoredSharedSecret>;
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
@@ -61,52 +70,57 @@ export 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> {
     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: AztecAddress): Promise<Point[]> {
+  getSharedSecretsForRecipient(recipient: AztecAddress): Promise<SharedSecret[]> {
     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(): Promise<{ recipient: AztecAddress; secret: Point }[]> {
+  getAllSharedSecrets(): Promise<{ recipient: AztecAddress; kind: SharedSecretKind; secret: Point }[]> {
     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: AztecAddress, secret: Point): Promise<boolean> {
+  removeSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean> {
     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;
         }
       }
@@ -115,3 +129,10 @@ export class TaggingSecretSourcesStore {
     });
   }
 }
+
+/** The wire form a shared secret entry is persisted as. */
+type StoredSharedSecret = { kind: SharedSecretKind; secret: string };
+
+function deserializeSharedSecret(entry: StoredSharedSecret): SharedSecret {
+  return { kind: entry.kind, secret: Point.fromString(entry.secret) };
+}

package/src/tagging/constants.ts

@@ -1,10 +1,20 @@
-// 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/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -74,7 +74,7 @@ export async function syncSenderTaggingIndexes(
     }
 
     // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
-    // `storePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
+    // `mergePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
     // and is not re-fetched here.
     const knownSet = new Set(knownPendingTxHashes.map(h => h.toString()));
     const newPendingTxHashes = allPendingTxHashes.filter(h => !knownSet.has(h.toString()));

package/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -36,11 +36,15 @@ export async function loadAndStoreNewTaggingIndexes(
   const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
   const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
 
-  // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+  // 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()) {
     const txHash = TxHash.fromString(txHashStr);
     const ranges = [{ extendedSecret, lowestIndex: Math.min(...indexes), highestIndex: Math.max(...indexes) }];
-    await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+    await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
   }
 }
 

package/dest/contract_function_simulator/proxied_contract_data_source.d.ts

@@ -1,6 +0,0 @@
-import type { ContractOverrides } from '@aztec/stdlib/tx';
-import type { ContractStore } from '../storage/contract_store/contract_store.js';
-export declare class ProxiedContractStoreFactory {
-    static create(contractStore: ContractStore, overrides?: ContractOverrides): ContractStore;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveGllZF9jb250cmFjdF9kYXRhX3NvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9wcm94aWVkX2NvbnRyYWN0X2RhdGFfc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFjakYscUJBQWEsMkJBQTJCO0lBQ3RDLE1BQU0sQ0FBQyxNQUFNLENBQUMsYUFBYSxFQUFFLGFBQWEsRUFBRSxTQUFTLENBQUMsRUFBRSxpQkFBaUIsaUJBdUN4RTtDQUNGIn0=

package/dest/contract_function_simulator/proxied_contract_data_source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxied_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/proxied_contract_data_source.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAcjF,qBAAa,2BAA2B;IACtC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,iBAAiB,iBAuCxE;CACF"}

package/dest/contract_function_simulator/proxied_contract_data_source.js

@@ -1,51 +0,0 @@
-import { findFunctionArtifactBySelector } from '@aztec/stdlib/abi';
-/*
- * Proxy generator for a ContractStore that allows overriding contract instances at given addresses,
- * so the contract function simulator can execute different bytecode on certain addresses. An example
- * use case would be overriding your own account contract so that valid signatures don't have to be
- * provided while simulating.
- *
- * Function artifact lookups for an overridden address are routed via the override-instance's
- * `currentContractClassId` rather than the underlying ContractStore's address→class mapping —
- * `ContractStore.getFunctionArtifact` calls `this.getContractInstance` internally, which the proxy
- * cannot intercept (the binding sees the raw target, not the proxy). The target class must be
- * registered ahead of time via `pxe.registerContractClass(...)`.
- */ export class ProxiedContractStoreFactory {
-    static create(contractStore, overrides) {
-        if (!overrides) {
-            return contractStore;
-        }
-        return new Proxy(contractStore, {
-            get (target, prop) {
-                if (prop === 'getContractInstance') {
-                    return (address)=>{
-                        const override = overrides[address.toString()];
-                        return override ? Promise.resolve(override.instance) : target.getContractInstance(address);
-                    };
-                }
-                if (prop === 'getFunctionArtifact' || prop === 'getFunctionArtifactWithDebugMetadata') {
-                    return async (contractAddress, selector)=>{
-                        const override = overrides[contractAddress.toString()];
-                        if (!override) {
-                            return target[prop].call(target, contractAddress, selector);
-                        }
-                        const artifact = await target.getContractArtifact(override.instance.currentContractClassId);
-                        if (!artifact) {
-                            throw new Error(`No artifact registered for override class ${override.instance.currentContractClassId} ` + `at ${contractAddress}. Register it via pxe.registerContractClass(...) before simulating.`);
-                        }
-                        const fn = await findFunctionArtifactBySelector(artifact, selector);
-                        if (!fn) {
-                            throw new Error(`Function with selector ${selector} not found in stub artifact for overridden contract at ${contractAddress}.`);
-                        }
-                        return {
-                            ...fn,
-                            contractName: artifact.name
-                        };
-                    };
-                }
-                const value = Reflect.get(target, prop);
-                return typeof value === 'function' ? value.bind(target) : value;
-            }
-        });
-    }
-}

package/dest/contract_sync/contract_sync_service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract_sync_service.d.ts","sourceRoot":"","sources":["../../src/contract_sync/contract_sync_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAEzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAGrE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,WAAW;;IAanD,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAfb,QAAQ,CAAC,SAAS,mBAAmB;IAKrC,OAAO,CAAC,eAAe,CAAyC;IAIhE,OAAO,CAAC,wBAAwB,CAAyC;IAEzE,YACU,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACjB;IAEJ;;;;;;;;OAQG;IACG,oBAAoB,CACxB,eAAe,EAAE,YAAY,EAC7B,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,EAClD,eAAe,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EAC7E,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,IAAI,CAAC,CAMf;IAED,oEAAoE;IACpE,2BAA2B,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,CAKvF;IAED,gFAAgF;IAChF,IAAI,IAAI,IAAI,CAIX;IAED,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpC;IAED,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM3C;CAsFF"}

package/dest/contract_sync/helpers.d.ts

@@ -1,28 +0,0 @@
-import type { FunctionCall, FunctionSelector } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractInstance } from '@aztec/stdlib/contract';
-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';
-/**
- * Read the current class id of a contract as of the given block, as seen by the AztecNode. The node resolves it from
- * the same scheduled value change the AVM enforces against the public data tree. If the node has no record of the
- * instance (e.g. it was never publicly deployed), the original class id from the local instance is used.
- * @param contractAddress - The address of the contract to read the class id for.
- * @param instance - The local instance of the contract, used as a fallback when the node doesn't know it.
- * @param aztecNode - The Aztec node to query.
- * @param header - The header of the block at which to resolve the current class id.
- * @returns The current class id.
- */
-export declare function readCurrentClassId(contractAddress: AztecAddress, instance: ContractInstance, aztecNode: AztecNode, header: BlockHeader): Promise<import("@aztec/foundation/schemas").Fr>;
-export declare function syncScope(contractAddress: AztecAddress, contractStore: ContractStore, functionToInvokeAfterSync: FunctionSelector | null, utilityExecutor: (privateSyncCall: FunctionCall, scopes: AztecAddress[]) => Promise<any>, scope: AztecAddress): Promise<void>;
-/**
- * Verify that the current class id of a contract obtained from AztecNode is the same as the one in contract data
- * provider (i.e. PXE's own storage).
- * @param contractAddress - The address of the contract to verify.
- * @param aztecNode - The Aztec node to query for storage.
- * @param contractStore - The contract store to fetch the local instance from.
- * @param header - The header of the block at which to verify the current class id.
- */
-export declare function verifyCurrentClassId(contractAddress: AztecAddress, aztecNode: AztecNode, contractStore: ContractStore, header: BlockHeader): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X3N5bmMvaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9ELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBRWpGOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQixrQkFBa0IsQ0FDdEMsZUFBZSxFQUFFLFlBQVksRUFDN0IsUUFBUSxFQUFFLGdCQUFnQixFQUMxQixTQUFTLEVBQUUsU0FBUyxFQUNwQixNQUFNLEVBQUUsV0FBVyxtREFNcEI7QUFFRCx3QkFBc0IsU0FBUyxDQUM3QixlQUFlLEVBQUUsWUFBWSxFQUM3QixhQUFhLEVBQUUsYUFBYSxFQUM1Qix5QkFBeUIsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEVBQ2xELGVBQWUsRUFBRSxDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxLQUFLLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFDeEYsS0FBSyxFQUFFLFlBQVksaUJBZXBCO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixvQkFBb0IsQ0FDeEMsZUFBZSxFQUFFLFlBQVksRUFDN0IsU0FBUyxFQUFFLFNBQVMsRUFDcEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsTUFBTSxFQUFFLFdBQVcsaUJBYXBCIn0=

package/dest/contract_sync/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/contract_sync/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEjF;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,WAAW,mDAMpB;AAED,wBAAsB,SAAS,CAC7B,eAAe,EAAE,YAAY,EAC7B,aAAa,EAAE,aAAa,EAC5B,yBAAyB,EAAE,gBAAgB,GAAG,IAAI,EAClD,eAAe,EAAE,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,EACxF,KAAK,EAAE,YAAY,iBAepB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,WAAW,iBAapB"}