@aztec/pxe 5.0.0-rc.1 → 5.0.0

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/fact_store/stored_fact.ts

@@ -0,0 +1,80 @@
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { FactCollectionKey, type OriginBlock } from './fact_store_keys.js';
+
+/** A fact as returned by the fact store. */
+export type Fact = { factTypeId: Fr; payload: Fr[]; originBlock: OriginBlock | undefined };
+
+/**
+ * A single immutable fact belonging to a fact collection.
+ */
+export class StoredFact {
+  constructor(
+    public readonly factCollectionKey: FactCollectionKey,
+    public readonly factTypeId: Fr,
+    public readonly payload: Fr[],
+    public readonly originBlock: OriginBlock | undefined,
+  ) {}
+
+  /** Whether this fact is deleted on block pruning (true) or survives reorgs (false). */
+  get isRetractable(): boolean {
+    return this.originBlock !== undefined;
+  }
+
+  /** Stable digest of the payload, used for fact idempotency. */
+  payloadHash(): Fr {
+    return sha256ToField([this.payload.length, ...this.payload]);
+  }
+
+  /** Returns the externally facing view of this fact. */
+  toFact(): Fact {
+    return { factTypeId: this.factTypeId, payload: this.payload, originBlock: this.originBlock };
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.factCollectionKey.contractAddress,
+      this.factCollectionKey.scope,
+      this.factCollectionKey.factCollectionTypeId,
+      this.factCollectionKey.factCollectionId,
+      this.factTypeId,
+      this.payload.length,
+      ...this.payload,
+      this.originBlock !== undefined,
+      this.originBlock ? this.originBlock.blockNumber : 0,
+      this.originBlock ? this.originBlock.blockHash : Fr.ZERO,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): StoredFact {
+    const reader = BufferReader.asReader(buffer);
+    const contractAddress = reader.readObject(AztecAddress);
+    const scope = reader.readObject(AztecAddress);
+    const factCollectionTypeId = reader.readObject(Fr);
+    const factCollectionId = reader.readObject(Fr);
+    const factTypeId = reader.readObject(Fr);
+    const payloadLen = reader.readNumber();
+    const payload = reader.readArray(payloadLen, Fr);
+    const hasOriginBlock = reader.readBoolean();
+    const blockNumber = reader.readNumber();
+    const blockHash = reader.readObject(Fr);
+    const originBlock = hasOriginBlock ? { blockNumber, blockHash } : undefined;
+    return new StoredFact(
+      new FactCollectionKey(contractAddress, scope, factCollectionTypeId, factCollectionId),
+      factTypeId,
+      [...payload],
+      originBlock,
+    );
+  }
+}
+
+/**
+ * Builds the serialized key that identifies a fact in the store.
+ */
+export function factKeyStrOf(fact: StoredFact): string {
+  const origin = fact.originBlock ? `${fact.originBlock.blockNumber}:${fact.originBlock.blockHash}` : 'none';
+  return `${fact.factCollectionKey}:${fact.factTypeId}:${fact.payloadHash()}:${origin}`;
+}

package/src/storage/index.ts

@@ -2,6 +2,7 @@ export * from './address_store/index.js';
 export * from './anchor_block_store/index.js';
 export * from './capsule_store/index.js';
 export * from './contract_store/index.js';
+export * from './fact_store/index.js';
 export * from './note_store/index.js';
 export * from './tagging_store/index.js';
 export * from './metadata.js';

package/src/storage/metadata.ts

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

package/src/storage/open_pxe_stores.ts

@@ -7,9 +7,10 @@ import { AddressStore } from './address_store/address_store.js';
 import { AnchorBlockStore } from './anchor_block_store/anchor_block_store.js';
 import { CapsuleStore } from './capsule_store/capsule_store.js';
 import { ContractStore } from './contract_store/contract_store.js';
+import { FactStore } from './fact_store/fact_store.js';
 import { NoteStore } from './note_store/note_store.js';
 import { PrivateEventStore } from './private_event_store/private_event_store.js';
-import { RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from './tagging_store/index.js';
+import { RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore } from './tagging_store/index.js';
 
 /**
  * The set of sub-stores opened against a single `AztecAsyncKVStore` to back PXE state.
@@ -21,11 +22,12 @@ export type PxeStores = {
   noteStore: NoteStore;
   anchorBlockStore: AnchorBlockStore;
   senderTaggingStore: SenderTaggingStore;
-  senderAddressBookStore: SenderAddressBookStore;
+  taggingSecretSourcesStore: TaggingSecretSourcesStore;
   recipientTaggingStore: RecipientTaggingStore;
   capsuleStore: CapsuleStore;
   keyStore: KeyStore;
   l2TipsStore: L2TipsKVStore;
+  factStore: FactStore;
 };
 
 /**
@@ -40,10 +42,11 @@ export function openPxeStores(store: AztecAsyncKVStore, initialBlockHash: BlockH
     noteStore: new NoteStore(store),
     anchorBlockStore: new AnchorBlockStore(store),
     senderTaggingStore: new SenderTaggingStore(store),
-    senderAddressBookStore: new SenderAddressBookStore(store),
+    taggingSecretSourcesStore: new TaggingSecretSourcesStore(store),
     recipientTaggingStore: new RecipientTaggingStore(store),
     capsuleStore: new CapsuleStore(store),
     keyStore: new KeyStore(store),
     l2TipsStore: new L2TipsKVStore(store, 'pxe', initialBlockHash),
+    factStore: new FactStore(store),
   };
 }

package/src/storage/tagging_store/index.ts

@@ -1,3 +1,3 @@
 export { SenderTaggingStore } from './sender_tagging_store.js';
-export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { TaggingSecretSourcesStore } from './tagging_secret_sources_store.js';
 export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/src/storage/tagging_store/tagging_secret_sources_store.ts

@@ -0,0 +1,138 @@
+import { Point } from '@aztec/foundation/curves/grumpkin';
+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.
+ *
+ * Two kinds of source are held:
+ * - Sender addresses: combined with a recipient to derive a shared tagging secret via ECDH. These are global (not
+ *   scoped to a recipient) because the per-recipient binding comes from re-mixing the recipient's keys during
+ *   derivation, so each account only ever derives secrets meant for it.
+ * - 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 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, StoredSharedSecret>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#senders = this.#store.openMap('senders');
+    this.#sharedSecretsByRecipient = this.#store.openMultiMap('recipient_shared_secrets');
+  }
+
+  addSender(address: AztecAddress): Promise<boolean> {
+    return this.#store.transactionAsync(async () => {
+      if (await this.#senders.hasAsync(address.toString())) {
+        return false;
+      }
+
+      await this.#senders.set(address.toString(), true);
+
+      return true;
+    });
+  }
+
+  getSenders(): Promise<AztecAddress[]> {
+    return this.#store.transactionAsync(async () => {
+      return (await toArray(this.#senders.keysAsync())).map(AztecAddress.fromStringUnsafe);
+    });
+  }
+
+  removeSender(address: AztecAddress): Promise<boolean> {
+    return this.#store.transactionAsync(async () => {
+      if (!(await this.#senders.hasAsync(address.toString()))) {
+        return false;
+      }
+
+      await this.#senders.delete(address.toString());
+
+      return true;
+    });
+  }
+
+  /**
+   * 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, 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.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(), { kind, secret: secretStr });
+
+      return true;
+    });
+  }
+
+  /** Returns the pre-shared tagging secrets registered for a given recipient. */
+  getSharedSecretsForRecipient(recipient: AztecAddress): Promise<SharedSecret[]> {
+    return this.#store.transactionAsync(async () => {
+      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; kind: SharedSecretKind; secret: Point }[]> {
+    return this.#store.transactionAsync(async () => {
+      const entries = await toArray(this.#sharedSecretsByRecipient.entriesAsync());
+      return entries.map(([recipient, entry]) => ({
+        recipient: AztecAddress.fromStringUnsafe(recipient),
+        ...deserializeSharedSecret(entry),
+      }));
+    });
+  }
+
+  /**
+   * 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, 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.kind === kind && existing.secret === secretStr) {
+          await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), existing);
+          return true;
+        }
+      }
+
+      return false;
+    });
+  }
+}
+
+/** 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/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,27 +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 from the execution data provider or AztecNode. If not found, class id
- * from the instance is used.
- * @param contractAddress - The address of the contract to read the class id for.
- * @param instance - The instance of the contract.
- * @param aztecNode - The Aztec node to query for storage.
- * @param header - The header of the block at which to load the DelayedPublicMutable storing the 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X3N5bmMvaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBRWpGOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLGtCQUFrQixDQUN0QyxlQUFlLEVBQUUsWUFBWSxFQUM3QixRQUFRLEVBQUUsZ0JBQWdCLEVBQzFCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLE1BQU0sRUFBRSxXQUFXLG1EQWFwQjtBQUVELHdCQUFzQixTQUFTLENBQzdCLGVBQWUsRUFBRSxZQUFZLEVBQzdCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLHlCQUF5QixFQUFFLGdCQUFnQixHQUFHLElBQUksRUFDbEQsZUFBZSxFQUFFLENBQUMsZUFBZSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLEtBQUssT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUN4RixLQUFLLEVBQUUsWUFBWSxpQkFlcEI7QUFFRDs7Ozs7OztHQU9HO0FBQ0gsd0JBQXNCLG9CQUFvQixDQUN4QyxlQUFlLEVBQUUsWUFBWSxFQUM3QixTQUFTLEVBQUUsU0FBUyxFQUNwQixhQUFhLEVBQUUsYUFBYSxFQUM1QixNQUFNLEVBQUUsV0FBVyxpQkFhcEIifQ==

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;AAE/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;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,WAAW,mDAapB;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"}

package/dest/contract_sync/helpers.js

@@ -1,53 +0,0 @@
-import { ProtocolContractAddress, isProtocolContract } from '@aztec/protocol-contracts';
-import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
-/**
- * Read the current class id of a contract from the execution data provider or AztecNode. If not found, class id
- * from the instance is used.
- * @param contractAddress - The address of the contract to read the class id for.
- * @param instance - The instance of the contract.
- * @param aztecNode - The Aztec node to query for storage.
- * @param header - The header of the block at which to load the DelayedPublicMutable storing the class id.
- * @returns The current class id.
- */ export async function readCurrentClassId(contractAddress, instance, aztecNode, header) {
-    const blockHash = await header.hash();
-    const timestamp = header.globalVariables.timestamp;
-    const { delayedPublicMutableSlot } = await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(contractAddress);
-    const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(delayedPublicMutableSlot, (slot)=>aztecNode.getPublicStorageAt(blockHash, ProtocolContractAddress.ContractInstanceRegistry, slot));
-    let currentClassId = delayedPublicMutableValues.svc.getCurrentAt(timestamp)[0];
-    if (currentClassId.isZero()) {
-        currentClassId = instance.originalContractClassId;
-    }
-    return currentClassId;
-}
-export async function syncScope(contractAddress, contractStore, functionToInvokeAfterSync, utilityExecutor, scope) {
-    // Protocol contracts don't have private state to sync
-    if (isProtocolContract(contractAddress)) {
-        return;
-    }
-    const syncStateFunctionCall = await contractStore.getFunctionCall('sync_state', [
-        scope
-    ], contractAddress);
-    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
-    ]);
-}
-/**
- * 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 async function verifyCurrentClassId(contractAddress, aztecNode, contractStore, header) {
-    const instance = await contractStore.getContractInstance(contractAddress);
-    if (!instance) {
-        throw new Error(`No contract instance found for address ${contractAddress.toString()}`);
-    }
-    const currentClassId = await readCurrentClassId(contractAddress, instance, aztecNode, header);
-    if (!instance.currentContractClassId.equals(currentClassId)) {
-        throw new Error(`Contract ${contractAddress} is outdated, current class id is ${currentClassId}, local class id is ${instance.currentContractClassId}`);
-    }
-}

package/dest/messages/message_context_service.d.ts

@@ -1,17 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { MessageContext } from '@aztec/stdlib/logs';
-/** Resolves transaction hashes into the context needed to process messages. */
-export declare class MessageContextService {
-    private readonly aztecNode;
-    constructor(aztecNode: AztecNode);
-    /**
-     * Resolves a list of tx hashes into their message contexts.
-     *
-     * For each tx hash, looks up the corresponding tx effect and extracts the note hashes and first nullifier needed to
-     * process messages that originated from that transaction. Returns `null` for tx hashes that are zero, not yet
-     * available, or in blocks beyond the anchor block.
-     */
-    getMessageContextsByTxHash(txHashes: Fr[], anchorBlockNumber: number): Promise<(MessageContext | null)[]>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV9jb250ZXh0X3NlcnZpY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdlcy9tZXNzYWdlX2NvbnRleHRfc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBR3BELCtFQUErRTtBQUMvRSxxQkFBYSxxQkFBcUI7SUFDcEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBQXRDLFlBQTZCLFNBQVMsRUFBRSxTQUFTLEVBQUk7SUFFckQ7Ozs7OztPQU1HO0lBQ0csMEJBQTBCLENBQUMsUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxjQUFjLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQTJDOUc7Q0FDRiJ9

package/dest/messages/message_context_service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message_context_service.d.ts","sourceRoot":"","sources":["../../src/messages/message_context_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,+EAA+E;AAC/E,qBAAa,qBAAqB;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,SAAS,EAAI;IAErD;;;;;;OAMG;IACG,0BAA0B,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,CA2C9G;CACF"}

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

@@ -1,14 +0,0 @@
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-/**
- * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
- * to derive directional app tagging secrets that are then used to sync the logs.
- */
-export declare class SenderAddressBookStore {
-    #private;
-    constructor(store: AztecAsyncKVStore);
-    addSender(address: AztecAddress): Promise<boolean>;
-    getSenders(): Promise<AztecAddress[]>;
-    removeSender(address: AztecAddress): Promise<boolean>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX2FkZHJlc3NfYm9va19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS9zZW5kZXJfYWRkcmVzc19ib29rX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRDs7O0dBR0c7QUFDSCxxQkFBYSxzQkFBc0I7O0lBSWpDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUluQztJQUVELFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVakQ7SUFFRCxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBSXBDO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVVwRDtDQUNGIn0=

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

@@ -1 +0,0 @@
-{"version":3,"file":"sender_address_book_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_address_book_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;GAGG;AACH,qBAAa,sBAAsB;;IAIjC,YAAY,KAAK,EAAE,iBAAiB,EAInC;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;CACF"}

package/dest/storage/tagging_store/sender_address_book_store.js

@@ -1,36 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-/**
- * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
- * to derive directional app tagging secrets that are then used to sync the logs.
- */ export class SenderAddressBookStore {
-    #store;
-    #addressBook;
-    constructor(store){
-        this.#store = store;
-        this.#addressBook = this.#store.openMap('address_book');
-    }
-    addSender(address) {
-        return this.#store.transactionAsync(async ()=>{
-            if (await this.#addressBook.hasAsync(address.toString())) {
-                return false;
-            }
-            await this.#addressBook.set(address.toString(), true);
-            return true;
-        });
-    }
-    getSenders() {
-        return this.#store.transactionAsync(async ()=>{
-            return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
-        });
-    }
-    removeSender(address) {
-        return this.#store.transactionAsync(async ()=>{
-            if (!await this.#addressBook.hasAsync(address.toString())) {
-                return false;
-            }
-            await this.#addressBook.delete(address.toString());
-            return true;
-        });
-    }
-}