@aztec/pxe 0.0.1-commit.db765a8 → 0.0.1-commit.df81a97b5

package/src/contract_sync/contract_sync_service.ts

@@ -20,12 +20,12 @@ export class ContractSyncService implements StagedStore {
   readonly storeName = 'contract_sync';
 
   // Tracks contracts synced since last wipe. The cache is keyed per individual scope address
-  // (`contractAddress:scopeAddress`), or `contractAddress:*` for undefined scopes (all accounts).
+  // (`contractAddress:scopeAddress`), or `contractAddress:*` for all scopes (all accounts).
   // The value is a promise that resolves when the contract is synced.
   private syncedContracts: Map<string, Promise<void>> = new Map();
 
-  // Per-job overridden contract addresses - these contracts should not be synced.
-  private overriddenContracts: Map<string, Set<string>> = new Map();
+  // Per-job excluded contract addresses - these contracts should not be synced.
+  private excludedFromSync: Map<string, Set<string>> = new Map();
 
   constructor(
     private aztecNode: AztecNode,
@@ -35,8 +35,8 @@ export class ContractSyncService implements StagedStore {
   ) {}
 
   /** Sets contracts that should be skipped during sync for a specific job. */
-  setOverriddenContracts(jobId: string, addresses: Set<string>): void {
-    this.overriddenContracts.set(jobId, addresses);
+  setExcludedFromSync(jobId: string, addresses: Set<string>): void {
+    this.excludedFromSync.set(jobId, addresses);
   }
 
   /**
@@ -56,47 +56,34 @@ export class ContractSyncService implements StagedStore {
     jobId: string,
     scopes: AccessScopes,
   ): Promise<void> {
-    // Skip sync if this contract has an override for this job (overrides are keyed by contract address only)
-    const overrides = this.overriddenContracts.get(jobId);
-    if (overrides?.has(contractAddress.toString())) {
+    if (this.#shouldSkipSync(jobId, contractAddress)) {
       return;
     }
 
-    // Skip sync if we already synced for "all scopes", or if we have an empty list of scopes
-    const allScopesKey = toKey(contractAddress, 'ALL_SCOPES');
-    const allScopesExisting = this.syncedContracts.get(allScopesKey);
-    if (allScopesExisting || (scopes !== 'ALL_SCOPES' && scopes.length == 0)) {
-      return;
-    }
-
-    const unsyncedScopes =
-      scopes === 'ALL_SCOPES'
-        ? scopes
-        : scopes.filter(scope => !this.syncedContracts.has(toKey(contractAddress, scope)));
-    const unsyncedScopesKeys = toKeys(contractAddress, unsyncedScopes);
-
-    if (unsyncedScopesKeys.length > 0) {
-      // Start sync and store the promise for all unsynced scopes
-      const promise = this.#doSync(
+    this.#startSyncIfNeeded(contractAddress, scopes, scopesToSync =>
+      this.#syncContract(
         contractAddress,
         functionToInvokeAfterSync,
         utilityExecutor,
         anchorBlockHeader,
         jobId,
-        unsyncedScopes,
-      ).catch(err => {
-        // There was an error syncing the contract, so we remove it from the cache so that it can be retried.
-        unsyncedScopesKeys.forEach(key => this.syncedContracts.delete(key));
-        throw err;
-      });
-      unsyncedScopesKeys.forEach(key => this.syncedContracts.set(key, promise));
-    }
+        scopesToSync,
+      ),
+    );
 
-    const promises = toKeys(contractAddress, scopes).map(key => this.syncedContracts.get(key)!);
-    await Promise.all(promises);
+    await this.#awaitSync(contractAddress, scopes);
   }
 
-  async #doSync(
+  /** Clears sync cache entries for the given scopes of a contract. Also clears the ALL_SCOPES entry. */
+  invalidateContractForScopes(contractAddress: AztecAddress, scopes: AztecAddress[]): void {
+    if (scopes.length === 0) {
+      return;
+    }
+    scopes.forEach(scope => this.syncedContracts.delete(toKey(contractAddress, scope)));
+    this.syncedContracts.delete(toKey(contractAddress, 'ALL_SCOPES'));
+  }
+
+  async #syncContract(
     contractAddress: AztecAddress,
     functionToInvokeAfterSync: FunctionSelector | null,
     utilityExecutor: (call: FunctionCall, scopes: AccessScopes) => Promise<any>,
@@ -129,8 +116,8 @@ export class ContractSyncService implements StagedStore {
   }
 
   commit(jobId: string): Promise<void> {
-    // Clear overridden contracts for this job
-    this.overriddenContracts.delete(jobId);
+    // Clear excluded contracts for this job
+    this.excludedFromSync.delete(jobId);
     return Promise.resolve();
   }
 
@@ -138,9 +125,51 @@ export class ContractSyncService implements StagedStore {
     // We clear the synced contracts cache here because, when the job is discarded, any associated database writes from
     // the sync are also undone.
     this.syncedContracts.clear();
-    this.overriddenContracts.delete(jobId);
+    this.excludedFromSync.delete(jobId);
     return Promise.resolve();
   }
+  /** Returns true if sync should be skipped for this contract */
+  #shouldSkipSync(jobId: string, contractAddress: AztecAddress): boolean {
+    return !!this.excludedFromSync.get(jobId)?.has(contractAddress.toString());
+  }
+
+  /** If there are unsynced scopes, starts sync and stores the promise in cache with error cleanup. */
+  #startSyncIfNeeded(
+    contractAddress: AztecAddress,
+    scopes: AccessScopes,
+    syncFn: (scopesToSync: AccessScopes) => Promise<void>,
+  ): void {
+    const scopesToSync = this.#getScopesToSync(contractAddress, scopes);
+    const keys = toKeys(contractAddress, scopesToSync);
+    if (keys.length === 0) {
+      return;
+    }
+    const promise = syncFn(scopesToSync).catch(err => {
+      keys.forEach(key => this.syncedContracts.delete(key));
+      throw err;
+    });
+    keys.forEach(key => this.syncedContracts.set(key, promise));
+  }
+
+  /** Filters out scopes that are already cached, returning only those that still need syncing. */
+  #getScopesToSync(contractAddress: AztecAddress, scopes: AccessScopes): AccessScopes {
+    if (this.syncedContracts.has(toKey(contractAddress, 'ALL_SCOPES'))) {
+      // If we are already syncing all scopes, then return an empty list
+      return [];
+    }
+    if (scopes === 'ALL_SCOPES') {
+      return 'ALL_SCOPES';
+    }
+    return scopes.filter(scope => !this.syncedContracts.has(toKey(contractAddress, scope)));
+  }
+
+  /** Collects all relevant scope promises (including in-flight ones from concurrent calls) and awaits them. */
+  async #awaitSync(contractAddress: AztecAddress, scopes: AccessScopes): Promise<void> {
+    const promises = toKeys(contractAddress, scopes)
+      .map(key => this.syncedContracts.get(key))
+      .filter(p => p !== undefined);
+    await Promise.all(promises);
+  }
 }
 
 function toKeys(contract: AztecAddress, scopes: AccessScopes) {

package/src/messages/message_context_service.ts

@@ -0,0 +1,45 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import { MessageTxContext } from '../contract_function_simulator/noir-structs/message_tx_context.js';
+
+/** Resolves transaction hashes into the context needed to process messages. */
+export class MessageContextService {
+  constructor(private readonly 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.
+   */
+  resolveMessageContexts(txHashes: Fr[], anchorBlockNumber: number): Promise<(MessageTxContext | null)[]> {
+    // TODO: optimize, we might be hitting the node to get the same txHash repeatedly
+    return Promise.all(
+      txHashes.map(async txHashField => {
+        // A zero tx hash indicates a tx-less offchain message (e.g. one not tied to any onchain transaction).
+        // These messages don't have a transaction context to resolve, so we return null.
+        if (txHashField.isZero()) {
+          return null;
+        }
+
+        const txHash = TxHash.fromField(txHashField);
+        const txEffect = await this.aztecNode.getTxEffect(txHash);
+        if (!txEffect || txEffect.l2BlockNumber > anchorBlockNumber) {
+          return null;
+        }
+
+        // Every tx has at least one nullifier (the first nullifier derived from the tx hash). Hitting this condition
+        // would mean a buggy node, but since we need to access data.nullifiers[0], the defensive check does no harm.
+        const data = txEffect.data;
+        if (data.nullifiers.length === 0) {
+          throw new Error(`Tx effect for ${txHash} has no nullifiers`);
+        }
+
+        return new MessageTxContext(data.txHash, data.noteHashes, data.nullifiers[0]);
+      }),
+    );
+  }
+}

package/src/oracle_version.ts

@@ -4,9 +4,9 @@
 ///
 /// @dev Whenever a contract function or Noir test is run, the `aztec_utl_assertCompatibleOracleVersion` oracle is called
 /// and if the oracle version is incompatible an error is thrown.
-export const ORACLE_VERSION = 14;
+export const ORACLE_VERSION = 18;
 
 /// This hash is computed as by hashing the Oracle interface and it is used to detect when the Oracle interface changes,
 /// which in turn implies that you need to update the ORACLE_VERSION constant in this file and in
 /// `noir-projects/aztec-nr/aztec/src/oracle/version.nr`.
-export const ORACLE_INTERFACE_HASH = '9fb918682455c164ce8dd3acb71c751e2b9b2fc48913604069c9ea885fa378ca';
+export const ORACLE_INTERFACE_HASH = '57e5b07c6d55fb167ef90f8d0f410f9bdb5b154a31159c624a061be40b02a2c2';

package/src/pxe.ts

@@ -68,6 +68,7 @@ import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
 import { PrivateEventFilterValidator } from './events/private_event_filter_validator.js';
 import { JobCoordinator } from './job_coordinator/job_coordinator.js';
+import { MessageContextService } from './messages/message_context_service.js';
 import {
   PrivateKernelExecutionProver,
   type PrivateKernelExecutionProverConfig,
@@ -106,7 +107,9 @@ export type SimulateTxOpts = {
   skipTxValidation?: boolean;
   /** If false, fees are enforced. */
   skipFeeEnforcement?: boolean;
-  /** State overrides for the simulation, such as contract instances and artifacts. */
+  /** If true, kernel logic is emulated in TS for simulation */
+  skipKernels?: boolean;
+  /** State overrides for the simulation, such as contract instances and artifacts. Requires skipKernels: true */
   overrides?: SimulationOverrides;
   /** Addresses whose private state and keys are accessible during private execution */
   scopes: AccessScopes;
@@ -158,6 +161,7 @@ export class PXE {
     private addressStore: AddressStore,
     private privateEventStore: PrivateEventStore,
     private contractSyncService: ContractSyncService,
+    private messageContextService: MessageContextService,
     private simulator: CircuitSimulator,
     private proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
@@ -213,6 +217,8 @@ export class PXE {
       noteStore,
       createLogger('pxe:contract_sync', bindings),
     );
+    const messageContextService = new MessageContextService(node);
+
     const synchronizer = new BlockSynchronizer(
       node,
       store,
@@ -254,6 +260,7 @@ export class PXE {
       addressStore,
       privateEventStore,
       contractSyncService,
+      messageContextService,
       simulator,
       proverEnabled,
       proofCreator,
@@ -295,6 +302,7 @@ export class PXE {
       privateEventStore: this.privateEventStore,
       simulator: this.simulator,
       contractSyncService: this.contractSyncService,
+      messageContextService: this.messageContextService,
     });
   }
 
@@ -414,7 +422,14 @@ export class PXE {
   ) {
     try {
       const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-      return contractFunctionSimulator.runUtility(call, authWitnesses ?? [], anchorBlockHeader, scopes, jobId);
+      const { result, offchainEffects } = await contractFunctionSimulator.runUtility(
+        call,
+        authWitnesses ?? [],
+        anchorBlockHeader,
+        scopes,
+        jobId,
+      );
+      return { result, offchainEffects };
     } catch (err) {
       if (err instanceof SimulationError) {
         await enrichSimulationError(err, this.contractStore, this.log);
@@ -554,6 +569,9 @@ export class PXE {
 
     if (wasAdded) {
       this.log.info(`Added sender:\n ${sender.toString()}`);
+      // Wipe the entire sync cache: the new sender's tagged logs could contain notes/events for any contract, so
+      // all contracts must re-sync to discover them.
+      this.contractSyncService.wipe();
     } else {
       this.log.info(`Sender:\n "${sender.toString()}"\n already registered.`);
     }
@@ -766,17 +784,17 @@ export class PXE {
         // transaction before this one is included in a block from this PXE, and that transaction contains a log with
         // a tag derived from the same secret, we would reuse the tag and the transactions would be linked. Hence
         // storing the tags here prevents linkage of txs sent from the same PXE.
-        const preTagsUsedInTheTx = privateExecutionResult.entrypoint.preTags;
-        if (preTagsUsedInTheTx.length > 0) {
+        const taggingIndexRangesUsedInTheTx = privateExecutionResult.entrypoint.taggingIndexRanges;
+        if (taggingIndexRangesUsedInTheTx.length > 0) {
           // TODO(benesjan): The following is an expensive operation. Figure out a way to avoid it.
           const txHash = (await txProvingResult.toTx()).txHash;
 
-          await this.senderTaggingStore.storePendingIndexes(preTagsUsedInTheTx, txHash, jobId);
-          this.log.debug(`Stored used pre-tags as sender for the tx`, {
-            preTagsUsedInTheTx,
+          await this.senderTaggingStore.storePendingIndexes(taggingIndexRangesUsedInTheTx, txHash, jobId);
+          this.log.debug(`Stored used tagging index ranges as sender for the tx`, {
+            taggingIndexRangesUsedInTheTx,
           });
         } else {
-          this.log.debug(`No pre-tags used in the tx`);
+          this.log.debug(`No tagging index ranges used in the tx`);
         }
 
         return txProvingResult;
@@ -883,7 +901,14 @@ export class PXE {
    */
   public simulateTx(
     txRequest: TxExecutionRequest,
-    { simulatePublic, skipTxValidation = false, skipFeeEnforcement = false, overrides, scopes }: SimulateTxOpts,
+    {
+      simulatePublic,
+      skipTxValidation = false,
+      skipFeeEnforcement = false,
+      skipKernels = true,
+      overrides,
+      scopes,
+    }: SimulateTxOpts,
   ): Promise<TxSimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
     // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
@@ -907,17 +932,20 @@ export class PXE {
         await this.blockStateSynchronizer.sync();
         const syncTime = syncTimer.ms();
 
-        const contractFunctionSimulator = this.#getSimulatorForTx(overrides);
-        // Temporary: in case there are overrides, we have to skip the kernels or validations
-        // will fail. Consider handing control to the user/wallet on whether they want to run them
-        // or not.
         const overriddenContracts = overrides?.contracts ? new Set(Object.keys(overrides.contracts)) : undefined;
         const hasOverriddenContracts = overriddenContracts !== undefined && overriddenContracts.size > 0;
-        const skipKernels = hasOverriddenContracts;
 
-        // Set overridden contracts on the sync service so it knows to skip syncing them
+        if (hasOverriddenContracts && !skipKernels) {
+          throw new Error(
+            'Simulating with overridden contracts is not compatible with kernel execution. Please set skipKernels to true when simulating with overridden contracts.',
+          );
+        }
+        const contractFunctionSimulator = this.#getSimulatorForTx(overrides);
+
         if (hasOverriddenContracts) {
-          this.contractSyncService.setOverriddenContracts(jobId, overriddenContracts);
+          // Overridden contracts don't have a sync function, so calling sync on them would fail.
+          // We exclude them so the sync service skips them entirely.
+          this.contractSyncService.setExcludedFromSync(jobId, overriddenContracts);
         }
 
         // Execution of private functions only; no proving, and no kernel logic.
@@ -1049,7 +1077,7 @@ export class PXE {
           scopes,
         );
 
-        const executionResult = await this.#executeUtility(
+        const { result: executionResult, offchainEffects } = await this.#executeUtility(
           contractFunctionSimulator,
           call,
           authwits ?? [],
@@ -1070,7 +1098,12 @@ export class PXE {
         };
 
         const simulationStats = contractFunctionSimulator.getStats();
-        return { result: executionResult, stats: { timings, nodeRPCCalls: simulationStats.nodeRPCCalls } };
+        return {
+          result: executionResult,
+          offchainEffects,
+          anchorBlockTimestamp: anchorBlockHeader.globalVariables.timestamp,
+          stats: { timings, nodeRPCCalls: simulationStats.nodeRPCCalls },
+        };
       } catch (err: any) {
         const { to, name, args } = call;
         const stringifiedArgs = args.map(arg => arg.toString()).join(', ');

package/src/storage/metadata.ts

@@ -1 +1 @@
-export const PXE_DATA_SCHEMA_VERSION = 3;
+export const PXE_DATA_SCHEMA_VERSION = 4;