@aztec/pxe 0.0.1-commit.f295ac2 → 0.0.1-commit.f2ce05ee

package/src/notes/note_service.ts

@@ -1,21 +1,20 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { DataInBlock } from '@aztec/stdlib/block';
-import { L2BlockHash } from '@aztec/stdlib/block';
 import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import { type AztecNode, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/client';
 import { Note, NoteDao, NoteStatus } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { TxHash } from '@aztec/stdlib/tx';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
-import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
 
 export class NoteService {
   constructor(
     private readonly noteStore: NoteStore,
     private readonly aztecNode: AztecNode,
-    private readonly anchorBlockStore: AnchorBlockStore,
+    private readonly anchorBlockHeader: BlockHeader,
+    private readonly jobId: string,
   ) {}
 
   /**
@@ -34,13 +33,16 @@ export class NoteService {
     status: NoteStatus,
     scopes?: AztecAddress[],
   ) {
-    const noteDaos = await this.noteStore.getNotes({
-      contractAddress,
-      owner,
-      storageSlot,
-      status,
-      scopes,
-    });
+    const noteDaos = await this.noteStore.getNotes(
+      {
+        contractAddress,
+        owner,
+        storageSlot,
+        status,
+        scopes,
+      },
+      this.jobId,
+    );
     return noteDaos.map(
       ({ contractAddress, owner, storageSlot, randomness, noteNonce, note, noteHash, siloedNullifier }) => ({
         contractAddress,
@@ -69,9 +71,9 @@ export class NoteService {
    * @param contractAddress - The contract whose notes should be checked and nullified.
    */
   public async syncNoteNullifiers(contractAddress: AztecAddress): Promise<void> {
-    const anchorBlockHash = L2BlockHash.fromField(await (await this.anchorBlockStore.getBlockHeader()).hash());
+    const anchorBlockHash = await this.anchorBlockHeader.hash();
 
-    const contractNotes = await this.noteStore.getNotes({ contractAddress });
+    const contractNotes = await this.noteStore.getNotes({ contractAddress }, this.jobId);
 
     if (contractNotes.length === 0) {
       return;
@@ -105,10 +107,10 @@ export class NoteService {
       })
       .filter(nullifier => nullifier !== undefined) as DataInBlock<Fr>[];
 
-    await this.noteStore.applyNullifiers(foundNullifiers);
+    await this.noteStore.applyNullifiers(foundNullifiers, this.jobId);
   }
 
-  public async storeNote(
+  public async validateAndStoreNote(
     contractAddress: AztecAddress,
     owner: AztecAddress,
     storageSlot: Fr,
@@ -139,9 +141,8 @@ export class NoteService {
     // number which *should* be recent enough to be available, even for non-archive nodes.
     // Also note that the note should never be ahead of the synced block here since `fetchTaggedLogs` only processes
     // logs up to the synced block making this only an additional safety check.
-    const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-    const anchorBlockNumber = anchorBlockHeader.getBlockNumber();
-    const anchorBlockHash = L2BlockHash.fromField(await anchorBlockHeader.hash());
+    const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
+    const anchorBlockHash = await this.anchorBlockHeader.hash();
 
     // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
     // of other contracts, which would constitute a security breach.
@@ -183,12 +184,12 @@ export class NoteService {
     );
 
     // The note was found by `recipient`, so we use that as the scope when storing the note.
-    await this.noteStore.addNotes([noteDao], recipient);
+    await this.noteStore.addNotes([noteDao], recipient, this.jobId);
 
     if (nullifierIndex !== undefined) {
       // We found nullifier index which implies that the note has already been nullified.
       const { data: _, ...blockHashAndNum } = nullifierIndex;
-      await this.noteStore.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }]);
+      await this.noteStore.applyNullifiers([{ data: siloedNullifier, ...blockHashAndNum }], this.jobId);
     }
   }
 }

package/src/oracle_version.ts

@@ -4,8 +4,9 @@
 ///
 /// @dev Whenever a contract function or Noir test is run, the `utilityAssertCompatibleOracleVersion` oracle is called
 /// and if the oracle version is incompatible an error is thrown.
-export const ORACLE_VERSION = 6;
+export const ORACLE_VERSION = 11;
 
 /// 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.
-export const ORACLE_INTERFACE_HASH = 'cc2a1f26a3b39ef194d710f94683929f63939d725f10b4fe2c82749a47a74c7b';
+/// 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 = '20c4d02d8cd5e448c11001a5f72ea2e0927630aeda75e537550872a9627bf40b';

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -1,6 +1,6 @@
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto/keys';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
@@ -56,13 +56,16 @@ export interface PrivateKernelExecutionProverConfig {
  * inform state tree updates.
  */
 export class PrivateKernelExecutionProver {
-  private log = createLogger('pxe:private-kernel-execution-prover');
+  private log: Logger;
 
   constructor(
     private oracle: PrivateKernelOracle,
     private proofCreator: PrivateKernelProver,
     private fakeProofs = false,
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('pxe:private-kernel-execution-prover', bindings);
+  }
 
   /**
    * Generate a proof for a given transaction request and execution result.

package/src/private_kernel/private_kernel_oracle.ts

@@ -7,7 +7,7 @@ import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-type
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
+import { BlockHash } from '@aztec/stdlib/block';
 import {
   type ContractInstanceWithAddress,
   computeContractClassIdPreimage,
@@ -30,7 +30,7 @@ export class PrivateKernelOracle {
     private contractStore: ContractStore,
     private keyStore: KeyStore,
     private node: AztecNode,
-    private blockHash: L2BlockHash,
+    private blockHash: BlockHash,
   ) {}
 
   /** Retrieves the preimage of a contract address from the registered contract instances db. */

package/src/pxe.ts

@@ -1,7 +1,7 @@
 import type { PrivateEventFilter } from '@aztec/aztec.js/wallet';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
@@ -18,7 +18,6 @@ import {
 } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2BlockHash } from '@aztec/stdlib/block';
 import {
   CompleteAddress,
   type ContractInstanceWithAddress,
@@ -34,6 +33,7 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import {
+  BlockHeader,
   type ContractOverrides,
   type InTx,
   PrivateExecutionResult,
@@ -59,8 +59,9 @@ import {
   ContractFunctionSimulator,
   generateSimulatedProvingResult,
 } from './contract_function_simulator/contract_function_simulator.js';
-import { readCurrentClassId } from './contract_function_simulator/oracle/private_execution.js';
 import { ProxiedContractStoreFactory } from './contract_function_simulator/proxied_contract_data_source.js';
+import { ContractSyncService } from './contract_sync/contract_sync_service.js';
+import { readCurrentClassId } from './contract_sync/helpers.js';
 import { PXEDebugUtils } from './debug/pxe_debug_utils.js';
 import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
 import { PrivateEventFilterValidator } from './events/private_event_filter_validator.js';
@@ -103,6 +104,7 @@ export class PXE {
     private recipientTaggingStore: RecipientTaggingStore,
     private addressStore: AddressStore,
     private privateEventStore: PrivateEventStore,
+    private contractSyncService: ContractSyncService,
     private simulator: CircuitSimulator,
     private proverEnabled: boolean,
     private proofCreator: PrivateKernelProver,
@@ -129,6 +131,10 @@ export class PXE {
     config: PXEConfig,
     loggerOrSuffix?: string | Logger,
   ) {
+    // Extract bindings from the logger, or use empty bindings if a string suffix is provided.
+    const bindings: LoggerBindings | undefined =
+      loggerOrSuffix && typeof loggerOrSuffix !== 'string' ? loggerOrSuffix.getBindings() : undefined;
+
     const log =
       !loggerOrSuffix || typeof loggerOrSuffix === 'string'
         ? createLogger(loggerOrSuffix ? `pxe:service:${loggerOrSuffix}` : `pxe:service`)
@@ -138,7 +144,7 @@ export class PXE {
     const addressStore = new AddressStore(store);
     const privateEventStore = new PrivateEventStore(store);
     const contractStore = new ContractStore(store);
-    const noteStore = await NoteStore.create(store);
+    const noteStore = new NoteStore(store);
     const anchorBlockStore = new AnchorBlockStore(store);
     const senderTaggingStore = new SenderTaggingStore(store);
     const senderAddressBookStore = new SenderAddressBookStore(store);
@@ -146,6 +152,12 @@ export class PXE {
     const capsuleStore = new CapsuleStore(store);
     const keyStore = new KeyStore(store);
     const tipsStore = new L2TipsKVStore(store, 'pxe');
+    const contractSyncService = new ContractSyncService(
+      node,
+      contractStore,
+      noteStore,
+      createLogger('pxe:contract_sync', bindings),
+    );
     const synchronizer = new BlockSynchronizer(
       node,
       store,
@@ -153,14 +165,22 @@ export class PXE {
       noteStore,
       privateEventStore,
       tipsStore,
+      contractSyncService,
       config,
-      loggerOrSuffix,
+      bindings,
     );
 
-    const jobCoordinator = new JobCoordinator(store);
-    jobCoordinator.registerStores([capsuleStore, senderTaggingStore, recipientTaggingStore, privateEventStore]);
+    const jobCoordinator = new JobCoordinator(store, bindings);
+    jobCoordinator.registerStores([
+      capsuleStore,
+      senderTaggingStore,
+      recipientTaggingStore,
+      privateEventStore,
+      noteStore,
+      contractSyncService,
+    ]);
 
-    const debugUtils = new PXEDebugUtils(contractStore, noteStore);
+    const debugUtils = new PXEDebugUtils(contractSyncService, noteStore, synchronizer, anchorBlockStore);
 
     const jobQueue = new SerialQueue();
 
@@ -177,6 +197,7 @@ export class PXE {
       recipientTaggingStore,
       addressStore,
       privateEventStore,
+      contractSyncService,
       simulator,
       proverEnabled,
       proofCreator,
@@ -187,7 +208,11 @@ export class PXE {
       debugUtils,
     );
 
-    debugUtils.setPXE(pxe);
+    debugUtils.setPXEHelpers(
+      pxe.#putInJobQueue.bind(pxe),
+      pxe.#getSimulatorForTx.bind(pxe),
+      pxe.#simulateUtility.bind(pxe),
+    );
 
     pxe.jobQueue.start();
 
@@ -208,13 +233,13 @@ export class PXE {
       this.keyStore,
       this.addressStore,
       BenchmarkedNodeFactory.create(this.node),
-      this.anchorBlockStore,
       this.senderTaggingStore,
       this.recipientTaggingStore,
       this.senderAddressBookStore,
       this.capsuleStore,
       this.privateEventStore,
       this.simulator,
+      this.contractSyncService,
     );
   }
 
@@ -289,6 +314,14 @@ export class PXE {
     try {
       const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
 
+      await this.contractSyncService.ensureContractSynced(
+        contractAddress,
+        functionSelector,
+        privateSyncCall => this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
+        anchorBlockHeader,
+        jobId,
+      );
+
       const result = await contractFunctionSimulator.run(
         txRequest,
         contractAddress,
@@ -384,15 +417,33 @@ export class PXE {
     config: PrivateKernelExecutionProverConfig,
   ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
     const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
-    const anchorBlockHash = L2BlockHash.fromField(await anchorBlockHeader.hash());
+    const anchorBlockHash = await anchorBlockHeader.hash();
     const kernelOracle = new PrivateKernelOracle(this.contractStore, this.keyStore, this.node, anchorBlockHash);
-    const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
+    const kernelTraceProver = new PrivateKernelExecutionProver(
+      kernelOracle,
+      proofCreator,
+      !this.proverEnabled,
+      this.log.getBindings(),
+    );
     this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
     return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
   }
 
   // Public API
 
+  /**
+   * Returns the block header up to which the PXE has synced.
+   * @returns The synced block header
+   */
+  public getSyncedBlockHeader(): Promise<BlockHeader> {
+    return this.anchorBlockStore.getBlockHeader();
+  }
+
+  /**
+   * Returns the contract instance for a given address, if it's registered in the PXE.
+   * @param address - The contract address.
+   * @returns The contract instance if found, undefined otherwise.
+   */
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return this.contractStore.getContractInstance(address);
   }
@@ -428,7 +479,6 @@ export class PXE {
     }
 
     await this.addressStore.addCompleteAddress(accountCompleteAddress);
-    await this.noteStore.addScope(accountCompleteAddress.address);
     return accountCompleteAddress;
   }
 
@@ -827,7 +877,14 @@ export class PXE {
         // 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 skipKernels = overrides?.contracts !== undefined && Object.keys(overrides.contracts ?? {}).length > 0;
+        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) {
+          this.contractSyncService.setOverriddenContracts(jobId, overriddenContracts);
+        }
 
         // Execution of private functions only; no proving, and no kernel logic.
         const privateExecutionResult = await this.#executePrivate(contractFunctionSimulator, txRequest, scopes, jobId);
@@ -838,7 +895,7 @@ export class PXE {
         if (skipKernels) {
           ({ publicInputs, executionSteps } = await generateSimulatedProvingResult(
             privateExecutionResult,
-            this.contractStore,
+            (addr, sel) => this.contractStore.getDebugFunctionName(addr, sel),
           ));
         } else {
           // Kernel logic, plus proving of all private functions and kernels.
@@ -948,8 +1005,13 @@ export class PXE {
         const functionTimer = new Timer();
         const contractFunctionSimulator = this.#getSimulatorForTx();
 
-        await this.contractStore.syncPrivateState(call.to, call.selector, privateSyncCall =>
-          this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
+        const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+        await this.contractSyncService.ensureContractSynced(
+          call.to,
+          call.selector,
+          privateSyncCall => this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
+          anchorBlockHeader,
+          jobId,
         );
 
         const executionResult = await this.#simulateUtility(
@@ -1008,15 +1070,18 @@ export class PXE {
     await this.#putInJobQueue(async jobId => {
       await this.blockStateSynchronizer.sync();
 
-      anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
+      const anchorBlockHeader = await this.anchorBlockStore.getBlockHeader();
+      anchorBlockNumber = anchorBlockHeader.getBlockNumber();
 
       const contractFunctionSimulator = this.#getSimulatorForTx();
 
-      await this.contractStore.syncPrivateState(
+      await this.contractSyncService.ensureContractSynced(
         filter.contractAddress,
         null,
         async privateSyncCall =>
           await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], undefined, jobId),
+        anchorBlockHeader,
+        jobId,
       );
     });
 

package/src/storage/address_store/address_store.ts

@@ -43,23 +43,23 @@ export class AddressStore {
     });
   }
 
-  async #getCompleteAddress(address: AztecAddress): Promise<CompleteAddress | undefined> {
-    const index = await this.#completeAddressIndex.getAsync(address.toString());
-    if (index === undefined) {
-      return undefined;
-    }
-
-    const value = await this.#completeAddresses.atAsync(index);
-    return value ? await CompleteAddress.fromBuffer(value) : undefined;
-  }
-
   getCompleteAddress(account: AztecAddress): Promise<CompleteAddress | undefined> {
-    return this.#getCompleteAddress(account);
+    return this.#store.transactionAsync(async () => {
+      const index = await this.#completeAddressIndex.getAsync(account.toString());
+      if (index === undefined) {
+        return undefined;
+      }
+
+      const value = await this.#completeAddresses.atAsync(index);
+      return value ? await CompleteAddress.fromBuffer(value) : undefined;
+    });
   }
 
-  async getCompleteAddresses(): Promise<CompleteAddress[]> {
-    return await Promise.all(
-      (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
-    );
+  getCompleteAddresses(): Promise<CompleteAddress[]> {
+    return this.#store.transactionAsync(async () => {
+      return await Promise.all(
+        (await toArray(this.#completeAddresses.valuesAsync())).map(v => CompleteAddress.fromBuffer(v)),
+      );
+    });
   }
 }

package/src/storage/anchor_block_store/anchor_block_store.ts

@@ -10,6 +10,14 @@ export class AnchorBlockStore {
     this.#synchronizedHeader = this.#store.openSingleton('header');
   }
 
+  /**
+   * Sets the currently synchronized block
+   *
+   * Important: this method is only called from BlockSynchronizer, and since we need it to run atomically with other
+   * stores in the case of a reorg, it MUST NOT be wrapped in a `transactionAsync` call. Doing so would result in a
+   * deadlock when the backend is IndexedDB, because `transactionAsync` is not designed to support reentrancy.
+   *
+   */
   async setHeader(header: BlockHeader): Promise<void> {
     await this.#synchronizedHeader.set(header.toBuffer());
   }

package/src/storage/capsule_store/capsule_store.ts

@@ -57,14 +57,14 @@ export class CapsuleStore implements StagedStore {
    */
   async #getFromStage(jobId: string, dbSlotKey: string): Promise<Buffer | null | undefined> {
     const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
-    let staged: Buffer | null | undefined = jobStagedCapsules.get(dbSlotKey);
-    // Note that if staged === null, we marked it for deletion, so we don't want to
-    // re-read it from DB
-    if (staged === undefined) {
-      // If we don't have a staged version of this dbSlotKey, first we check if there's one in DB
-      staged = await this.#loadCapsuleFromDb(dbSlotKey);
-    }
-    return staged;
+    const staged: Buffer | null | undefined = jobStagedCapsules.get(dbSlotKey);
+
+    // Always issue DB read to keep IndexedDB transaction alive, even if the value is in the job staged data. This
+    // keeps IndexedDB transactions alive (they auto-commit when a new micro-task starts and there are no pending read
+    // requests). The staged value still takes precedence if it exists (including null for deletions).
+    const dbValue = await this.#loadCapsuleFromDb(dbSlotKey);
+
+    return staged !== undefined ? staged : dbValue;
   }
 
   /**

package/src/storage/contract_store/contract_store.ts

@@ -3,7 +3,6 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import { isProtocolContract } from '@aztec/protocol-contracts';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -43,10 +42,12 @@ export class ContractStore {
   /** Map from contract address to contract class id */
   #contractClassIdMap: Map<string, Fr> = new Map();
 
+  #store: AztecAsyncKVStore;
   #contractArtifacts: AztecAsyncMap<string, Buffer>;
   #contractInstances: AztecAsyncMap<string, Buffer>;
 
   constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
     this.#contractArtifacts = store.openMap('contract_artifacts');
     this.#contractInstances = store.openMap('contracts_instances');
   }
@@ -54,6 +55,7 @@ export class ContractStore {
   // Setters
 
   public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
+    // Validation outside transactionAsync - these are not DB operations
     const privateFunctions = contract.functions.filter(
       functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE,
     );
@@ -70,7 +72,9 @@ export class ContractStore {
       throw new Error('Repeated function selectors of private functions');
     }
 
-    await this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract));
+    await this.#store.transactionAsync(() =>
+      this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract)),
+    );
   }
 
   async addContractInstance(contract: ContractInstanceWithAddress): Promise<void> {
@@ -124,21 +128,27 @@ export class ContractStore {
 
   // Public getters
 
-  async getContractsAddresses(): Promise<AztecAddress[]> {
-    const keys = await toArray(this.#contractInstances.keysAsync());
-    return keys.map(AztecAddress.fromString);
+  getContractsAddresses(): Promise<AztecAddress[]> {
+    return this.#store.transactionAsync(async () => {
+      const keys = await toArray(this.#contractInstances.keysAsync());
+      return keys.map(AztecAddress.fromString);
+    });
   }
 
   /** Returns a contract instance for a given address. Throws if not found. */
-  public async getContractInstance(contractAddress: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const contract = await this.#contractInstances.getAsync(contractAddress.toString());
-    return contract && SerializableContractInstance.fromBuffer(contract).withAddress(contractAddress);
+  public getContractInstance(contractAddress: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return this.#store.transactionAsync(async () => {
+      const contract = await this.#contractInstances.getAsync(contractAddress.toString());
+      return contract && SerializableContractInstance.fromBuffer(contract).withAddress(contractAddress);
+    });
   }
 
-  public async getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | undefined> {
-    const contract = await this.#contractArtifacts.getAsync(contractClassId.toString());
-    // TODO(@spalladino): AztecAsyncMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
-    return contract && contractArtifactFromBuffer(Buffer.from(contract));
+  public getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | undefined> {
+    return this.#store.transactionAsync(async () => {
+      const contract = await this.#contractArtifacts.getAsync(contractClassId.toString());
+      // TODO(@spalladino): AztecAsyncMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
+      return contract && contractArtifactFromBuffer(Buffer.from(contract));
+    });
   }
 
   /** Returns a contract class for a given class id. Throws if not found. */
@@ -306,34 +316,15 @@ export class ContractStore {
       throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
     }
 
-    return {
+    return FunctionCall.from({
       name: functionDao.name,
-      args: encodeArguments(functionDao, args),
+      to,
       selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
       type: functionDao.functionType,
-      to,
       hideMsgSender: false,
       isStatic: functionDao.isStatic,
+      args: encodeArguments(functionDao, args),
       returnTypes: functionDao.returnTypes,
-    };
-  }
-
-  // Synchronize target contract data
-  public async syncPrivateState(
-    contractAddress: AztecAddress,
-    functionToInvokeAfterSync: FunctionSelector | null,
-    utilityExecutor: (privateSyncCall: FunctionCall) => Promise<any>,
-  ) {
-    // Protocol contracts don't have private state to sync
-    if (!isProtocolContract(contractAddress)) {
-      const syncPrivateStateFunctionCall = await this.getFunctionCall('sync_private_state', [], contractAddress);
-      if (functionToInvokeAfterSync && functionToInvokeAfterSync.equals(syncPrivateStateFunctionCall.selector)) {
-        throw new Error(
-          'Forbidden `sync_private_state` invocation. `sync_private_state` can only be invoked by PXE, manual execution can lead to inconsistencies.',
-        );
-      }
-
-      return utilityExecutor(syncPrivateStateFunctionCall);
-    }
+    });
   }
 }

package/src/storage/metadata.ts

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