@aztec/pxe 0.80.0 → 0.82.0

package/src/pxe_service/pxe_service.ts

@@ -32,8 +32,9 @@ import {
   type ContractInstanceWithAddress,
   type NodeInfo,
   type PartialAddress,
+  computeContractAddressFromInstance,
+  getContractClassFromArtifact,
 } from '@aztec/stdlib/contract';
-import { computeContractAddressFromInstance, getContractClassFromArtifact } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { EventMetadata, L1EventPayload } from '@aztec/stdlib/event';
 import type { GasFees } from '@aztec/stdlib/gas';
@@ -47,7 +48,7 @@ import type {
   PXEInfo,
   PrivateKernelProver,
 } from '@aztec/stdlib/interfaces/client';
-import { type PrivateKernelSimulateOutput, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { PrivateKernelExecutionProofOutput, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import { computeAddressSecret } from '@aztec/stdlib/keys';
 import type { LogFilter } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
@@ -56,11 +57,12 @@ import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   PrivateExecutionResult,
   PrivateSimulationResult,
-  type PublicSimulationOutput,
-  type Tx,
+  PublicSimulationOutput,
+  Tx,
   type TxEffect,
-  type TxExecutionRequest,
+  TxExecutionRequest,
   type TxHash,
+  TxProfileResult,
   TxProvingResult,
   type TxReceipt,
   TxSimulationResult,
@@ -70,11 +72,13 @@ import { inspect } from 'util';
 
 import type { PXEServiceConfig } from '../config/index.js';
 import { getPackageInfo } from '../config/package_info.js';
-import { KernelOracle } from '../kernel_oracle/index.js';
-import { KernelProver, type ProvingConfig } from '../kernel_prover/kernel_prover.js';
+import {
+  PrivateKernelExecutionProver,
+  type PrivateKernelExecutionProverConfig,
+} from '../private_kernel/private_kernel_execution_prover.js';
+import { PrivateKernelOracleImpl } from '../private_kernel/private_kernel_oracle_impl.js';
 import { PXEOracleInterface } from '../pxe_oracle_interface/pxe_oracle_interface.js';
 import { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
-import { AuthWitnessDataProvider } from '../storage/auth_witness_data_provider/auth_witness_data_provider.js';
 import { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
 import { ContractDataProvider } from '../storage/contract_data_provider/contract_data_provider.js';
 import { NoteDataProvider } from '../storage/note_data_provider/note_data_provider.js';
@@ -97,7 +101,6 @@ export class PXEService implements PXE {
     private syncDataProvider: SyncDataProvider,
     private taggingDataProvider: TaggingDataProvider,
     private addressDataProvider: AddressDataProvider,
-    private authWitnessDataProvider: AuthWitnessDataProvider,
     private simulator: AcirSimulator,
     private packageVersion: string,
     private proverEnabled: boolean,
@@ -131,7 +134,6 @@ export class PXEService implements PXE {
     const packageVersion = getPackageInfo().version;
     const proverEnabled = !!config.proverEnabled;
     const addressDataProvider = new AddressDataProvider(store);
-    const authWitnessDataProvider = new AuthWitnessDataProvider(store);
     const contractDataProvider = new ContractDataProvider(store);
     const noteDataProvider = await NoteDataProvider.create(store);
     const syncDataProvider = new SyncDataProvider(store);
@@ -158,7 +160,6 @@ export class PXEService implements PXE {
       syncDataProvider,
       taggingDataProvider,
       addressDataProvider,
-      authWitnessDataProvider,
       log,
     );
     const simulator = new AcirSimulator(pxeOracleInterface, simulationProvider);
@@ -174,7 +175,6 @@ export class PXEService implements PXE {
       syncDataProvider,
       taggingDataProvider,
       addressDataProvider,
-      authWitnessDataProvider,
       simulator,
       packageVersion,
       proverEnabled,
@@ -192,6 +192,68 @@ export class PXEService implements PXE {
     return pxeService;
   }
 
+  // Aztec node proxy methods
+
+  public isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
+    return this.node.isL1ToL2MessageSynced(l1ToL2Message);
+  }
+
+  public getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
+    return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
+  }
+
+  public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    return this.node.getTxReceipt(txHash);
+  }
+
+  public getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
+    return this.node.getTxEffect(txHash);
+  }
+
+  public getBlockNumber(): Promise<number> {
+    return this.node.getBlockNumber();
+  }
+
+  public getProvenBlockNumber(): Promise<number> {
+    return this.node.getProvenBlockNumber();
+  }
+
+  public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
+    return this.node.getPublicLogs(filter);
+  }
+
+  public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
+    return this.node.getContractClassLogs(filter);
+  }
+
+  public getPublicStorageAt(contract: AztecAddress, slot: Fr) {
+    return this.node.getPublicStorageAt('latest', contract, slot);
+  }
+
+  public async getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
+    return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
+  }
+
+  // Internal methods
+
+  #contextualizeError(err: Error, ...context: string[]): Error {
+    let contextStr = '';
+    if (context.length > 0) {
+      contextStr = `\nContext:\n${context.join('\n')}`;
+    }
+    if (err instanceof SimulationError) {
+      err.setAztecContext(contextStr);
+    } else {
+      this.log.error(err.name, err);
+      this.log.debug(contextStr);
+    }
+    return err;
+  }
+
   /**
    * Enqueues a job for execution once no other jobs are running. Returns a promise that will resolve once the job is
    * complete.
@@ -209,16 +271,164 @@ export class PXEService implements PXE {
     return this.jobQueue.put(fn);
   }
 
-  isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean> {
-    return this.node.isL1ToL2MessageSynced(l1ToL2Message);
+  async #registerProtocolContracts() {
+    const registered: Record<string, string> = {};
+    for (const name of protocolContractNames) {
+      const { address, contractClass, instance, artifact } =
+        await this.protocolContractsProvider.getProtocolContractArtifact(name);
+      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
+      await this.contractDataProvider.addContractInstance(instance);
+      registered[name] = address.toString();
+    }
+    this.log.verbose(`Registered protocol contracts in pxe`, registered);
+  }
+
+  async #isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
+    return !!(await this.node.getContractClass(id));
+  }
+
+  async #isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
+    return !!(await this.node.getContract(address));
+  }
+
+  async #isContractInitialized(address: AztecAddress): Promise<boolean> {
+    const initNullifier = await siloNullifier(address, address.toField());
+    return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
+  }
+
+  async #getFunctionCall(functionName: string, args: any[], to: AztecAddress): Promise<FunctionCall> {
+    const contract = await this.contractDataProvider.getContract(to);
+    if (!contract) {
+      throw new Error(
+        `Unknown contract ${to}: add it to PXE Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`,
+      );
+    }
+
+    const functionDao = contract.functions.find(f => f.name === functionName);
+    if (!functionDao) {
+      throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
+    }
+
+    return {
+      name: functionDao.name,
+      args: encodeArguments(functionDao, args),
+      selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+      type: functionDao.functionType,
+      to,
+      isStatic: functionDao.isStatic,
+      returnTypes: functionDao.returnTypes,
+    };
+  }
+
+  async #executePrivate(
+    txRequest: TxExecutionRequest,
+    msgSender?: AztecAddress,
+    scopes?: AztecAddress[],
+  ): Promise<PrivateExecutionResult> {
+    const { origin: contractAddress, functionSelector } = txRequest;
+
+    try {
+      const result = await this.simulator.run(txRequest, contractAddress, functionSelector, msgSender, scopes);
+      this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
+      return result;
+    } catch (err) {
+      if (err instanceof SimulationError) {
+        await enrichSimulationError(err, this.contractDataProvider, this.log);
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Simulate an unconstrained transaction on the given contract, without considering constraints set by ACIR.
+   * The simulation parameters are fetched using ContractDataProvider and executed using AcirSimulator.
+   * Returns the simulation result containing the outputs of the unconstrained function.
+   *
+   * @param execRequest - The transaction request object containing the target contract and function data.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+   * @returns The simulation result containing the outputs of the unconstrained function.
+   */
+  async #simulateUnconstrained(execRequest: FunctionCall, authWitnesses?: AuthWitness[], scopes?: AztecAddress[]) {
+    const { to: contractAddress, selector: functionSelector } = execRequest;
+
+    this.log.debug('Executing unconstrained simulator...');
+    try {
+      const result = await this.simulator.runUnconstrained(
+        execRequest,
+        contractAddress,
+        functionSelector,
+        authWitnesses ?? [],
+        scopes,
+      );
+      this.log.verbose(`Unconstrained simulation for ${contractAddress}.${functionSelector} completed`);
+
+      return result;
+    } catch (err) {
+      if (err instanceof SimulationError) {
+        await enrichSimulationError(err, this.contractDataProvider, this.log);
+      }
+      throw err;
+    }
   }
 
+  /**
+   * Simulate the public part of a transaction.
+   * This allows to catch public execution errors before submitting the transaction.
+   * It can also be used for estimating gas in the future.
+   * @param tx - The transaction to be simulated.
+   */
+  async #simulatePublicCalls(tx: Tx, skipFeeEnforcement: boolean) {
+    // Simulating public calls can throw if the TX fails in a phase that doesn't allow reverts (setup)
+    // Or return as reverted if it fails in a phase that allows reverts (app logic, teardown)
+    try {
+      const result = await this.node.simulatePublicCalls(tx, skipFeeEnforcement);
+      if (result.revertReason) {
+        throw result.revertReason;
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof SimulationError) {
+        try {
+          await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
+        } catch (enrichErr) {
+          this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
+        }
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Generate a kernel proof, and create a private kernel output.
+   * The function takes in a transaction execution request, and the result of private execution
+   * and then generates a kernel proof.
+   *
+   * @param txExecutionRequest - The transaction request to be simulated and proved.
+   * @param proofCreator - The proof creator to use for proving the execution.
+   * @param privateExecutionResult - The result of the private execution
+   * @param config - The configuration for the kernel execution prover.
+   * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
+   */
+  async #prove(
+    txExecutionRequest: TxExecutionRequest,
+    proofCreator: PrivateKernelProver,
+    privateExecutionResult: PrivateExecutionResult,
+    config: PrivateKernelExecutionProverConfig,
+  ): Promise<PrivateKernelExecutionProofOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const block = privateExecutionResult.getSimulationBlockNumber();
+    const kernelOracle = new PrivateKernelOracleImpl(this.contractDataProvider, this.keyStore, this.node, block);
+    const kernelTraceProver = new PrivateKernelExecutionProver(kernelOracle, proofCreator, !this.proverEnabled);
+    this.log.debug(`Executing kernel trace prover (${JSON.stringify(config)})...`);
+    return await kernelTraceProver.proveWithKernels(txExecutionRequest.toTxRequest(), privateExecutionResult, config);
+  }
+
+  // Public API
+
   /** Returns an estimate of the db size in bytes. */
   public async estimateDbSize() {
     const treeRootsSize = Object.keys(MerkleTreeId).length * Fr.SIZE_IN_BYTES;
     const dbSizes = await Promise.all([
       this.addressDataProvider.getSize(),
-      this.authWitnessDataProvider.getSize(),
       this.capsuleDataProvider.getSize(),
       this.contractDataProvider.getSize(),
       this.noteDataProvider.getSize(),
@@ -228,18 +438,6 @@ export class PXEService implements PXE {
     return [...dbSizes, treeRootsSize].reduce((sum, size) => sum + size, 0);
   }
 
-  public addAuthWitness(witness: AuthWitness) {
-    return this.authWitnessDataProvider.addAuthWitness(witness.requestHash, witness.witness);
-  }
-
-  public getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
-    return this.authWitnessDataProvider.getAuthWitness(messageHash);
-  }
-
-  public storeCapsule(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]) {
-    return this.capsuleDataProvider.storeCapsule(contract, storageSlot, capsule);
-  }
-
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return this.contractDataProvider.getContractInstance(address);
   }
@@ -319,9 +517,7 @@ export class PXEService implements PXE {
   }
 
   public getSenders(): Promise<AztecAddress[]> {
-    const senders = this.taggingDataProvider.getSenderAddresses();
-
-    return Promise.resolve(senders);
+    return this.taggingDataProvider.getSenderAddresses();
   }
 
   public async removeSender(address: AztecAddress): Promise<void> {
@@ -332,8 +528,6 @@ export class PXEService implements PXE {
     } else {
       this.log.info(`Sender:\n "${address.toString()}"\n not in address book.`);
     }
-
-    return Promise.resolve();
   }
 
   public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
@@ -375,9 +569,6 @@ export class PXEService implements PXE {
         .filter(fn => fn.functionType === FunctionType.PUBLIC)
         .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
       await this.node.registerContractFunctionSignatures(instance.address, publicFunctionSignatures);
-
-      // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
-      await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
     } else {
       // Otherwise, make sure there is an artifact already registered for that class id
       artifact = await this.contractDataProvider.getContractArtifact(instance.currentContractClassId);
@@ -416,8 +607,6 @@ export class PXEService implements PXE {
         .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
       await this.node.registerContractFunctionSignatures(contractAddress, publicFunctionSignatures);
 
-      // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
-      await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
       currentInstance.currentContractClassId = contractClass.id;
       await this.contractDataProvider.addContractInstance(currentInstance);
       this.log.info(`Updated contract ${artifact.name} at ${contractAddress.toString()} to class ${contractClass.id}`);
@@ -428,51 +617,27 @@ export class PXEService implements PXE {
     return this.contractDataProvider.getContractsAddresses();
   }
 
-  public async getPublicStorageAt(contract: AztecAddress, slot: Fr) {
-    return await this.node.getPublicStorageAt('latest', contract, slot);
-  }
-
   public async getNotes(filter: NotesFilter): Promise<UniqueNote[]> {
     const noteDaos = await this.noteDataProvider.getNotes(filter);
 
     const extendedNotes = noteDaos.map(async dao => {
-      let owner = filter.owner;
-      if (owner === undefined) {
+      let recipient = filter.recipient;
+      if (recipient === undefined) {
         const completeAddresses = await this.addressDataProvider.getCompleteAddresses();
-        const completeAddressIndex = (
-          await Promise.all(completeAddresses.map(completeAddresses => completeAddresses.address.toAddressPoint()))
-        ).findIndex(addressPoint => addressPoint.equals(dao.addressPoint));
+        const completeAddressIndex = completeAddresses.findIndex(completeAddress =>
+          completeAddress.address.equals(dao.recipient),
+        );
         const completeAddress = completeAddresses[completeAddressIndex];
         if (completeAddress === undefined) {
-          throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
+          throw new Error(`Cannot find complete address for recipient ${dao.recipient.toString()}`);
         }
-        owner = completeAddress.address;
+        recipient = completeAddress.address;
       }
-      return new UniqueNote(
-        dao.note,
-        owner,
-        dao.contractAddress,
-        dao.storageSlot,
-        dao.noteTypeId,
-        dao.txHash,
-        dao.nonce,
-      );
+      return new UniqueNote(dao.note, recipient, dao.contractAddress, dao.storageSlot, dao.txHash, dao.nonce);
     });
     return Promise.all(extendedNotes);
   }
 
-  public async getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-    return await getNonNullifiedL1ToL2MessageWitness(this.node, contractAddress, messageHash, secret);
-  }
-
-  public getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]> {
-    return this.node.getL2ToL1MessageMembershipWitness(blockNumber, l2Tol1Message);
-  }
-
   public async getBlock(blockNumber: number): Promise<L2Block | undefined> {
     // If a negative block number is provided the current block number is fetched.
     if (blockNumber < 0) {
@@ -500,12 +665,54 @@ export class PXEService implements PXE {
           {
             simulate: false,
             skipFeeEnforcement: false,
-            profile: false,
+            profileMode: 'none',
           },
         );
         return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
       } catch (err: any) {
-        throw this.contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
+        throw this.#contextualizeError(err, inspect(txRequest), inspect(privateExecutionResult));
+      }
+    });
+  }
+
+  public profileTx(
+    txRequest: TxExecutionRequest,
+    profileMode: 'full' | 'execution-steps' | 'gates',
+    msgSender?: AztecAddress,
+  ): Promise<TxProfileResult> {
+    // We disable concurrent profiles for consistency with simulateTx.
+    return this.#putInJobQueue(async () => {
+      try {
+        const txInfo = {
+          origin: txRequest.origin,
+          functionSelector: txRequest.functionSelector,
+          simulatePublic: false,
+          msgSender,
+          chainId: txRequest.txContext.chainId,
+          version: txRequest.txContext.version,
+          authWitnesses: txRequest.authWitnesses.map(w => w.requestHash),
+        };
+        this.log.info(
+          `Profiling transaction execution request to ${txRequest.functionSelector} at ${txRequest.origin}`,
+          txInfo,
+        );
+        await this.synchronizer.sync();
+        const privateExecutionResult = await this.#executePrivate(txRequest, msgSender);
+
+        const { executionSteps } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+          simulate: true,
+          skipFeeEnforcement: false,
+          profileMode,
+        });
+
+        return new TxProfileResult(executionSteps);
+      } catch (err: any) {
+        throw this.#contextualizeError(
+          err,
+          inspect(txRequest),
+          `profileMode=${profileMode}`,
+          `msgSender=${msgSender?.toString() ?? 'undefined'}`,
+        );
       }
     });
   }
@@ -517,7 +724,6 @@ export class PXEService implements PXE {
     msgSender: AztecAddress | undefined = undefined,
     skipTxValidation: boolean = false,
     skipFeeEnforcement: boolean = false,
-    profile: boolean = false,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
     // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
@@ -542,16 +748,11 @@ export class PXEService implements PXE {
         await this.synchronizer.sync();
         const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
 
-        const { publicInputs, profileResult } = await this.#prove(
-          txRequest,
-          this.proofCreator,
-          privateExecutionResult,
-          {
-            simulate: !profile,
-            skipFeeEnforcement,
-            profile,
-          },
-        );
+        const { publicInputs } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult, {
+          simulate: true,
+          skipFeeEnforcement,
+          profileMode: 'none',
+        });
 
         const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
         const simulatedTx = privateSimulationResult.toSimulatedTx();
@@ -571,7 +772,6 @@ export class PXEService implements PXE {
         this.log.info(`Simulation completed for ${txHash.toString()} in ${timer.ms()}ms`, {
           txHash,
           ...txInfo,
-          ...(profileResult ? { gateCounts: profileResult.gateCounts } : {}),
           ...(publicOutput
             ? {
                 gasUsed: publicOutput.gasUsed,
@@ -581,19 +781,14 @@ export class PXEService implements PXE {
             : {}),
         });
 
-        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
-          privateSimulationResult,
-          publicOutput,
-          profileResult,
-        );
+        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
       } catch (err: any) {
-        throw this.contextualizeError(
+        throw this.#contextualizeError(
           err,
           inspect(txRequest),
           `simulatePublic=${simulatePublic}`,
           `msgSender=${msgSender?.toString() ?? 'undefined'}`,
           `skipTxValidation=${skipTxValidation}`,
-          `profile=${profile}`,
           `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
         );
       }
@@ -607,7 +802,7 @@ export class PXEService implements PXE {
     }
     this.log.debug(`Sending transaction ${txHash}`);
     await this.node.sendTx(tx).catch(err => {
-      throw this.contextualizeError(err, inspect(tx));
+      throw this.#contextualizeError(err, inspect(tx));
     });
     this.log.info(`Sent transaction ${txHash}`);
     return txHash;
@@ -617,6 +812,7 @@ export class PXEService implements PXE {
     functionName: string,
     args: any[],
     to: AztecAddress,
+    authwits?: AuthWitness[],
     _from?: AztecAddress,
     scopes?: AztecAddress[],
   ): Promise<AbiDecoded> {
@@ -628,13 +824,13 @@ export class PXEService implements PXE {
         await this.synchronizer.sync();
         // TODO - Should check if `from` has the permission to call the view function.
         const functionCall = await this.#getFunctionCall(functionName, args, to);
-        const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
+        const executionResult = await this.#simulateUnconstrained(functionCall, authwits ?? [], scopes);
 
         // TODO - Return typed result based on the function artifact.
         return executionResult;
       } catch (err: any) {
         const stringifiedArgs = args.map(arg => arg.toString()).join(', ');
-        throw this.contextualizeError(
+        throw this.#contextualizeError(
           err,
           `simulateUnconstrained ${to}:${functionName}(${stringifiedArgs})`,
           `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
@@ -643,64 +839,6 @@ export class PXEService implements PXE {
     });
   }
 
-  public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
-    return this.node.getTxReceipt(txHash);
-  }
-
-  public getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
-    return this.node.getTxEffect(txHash);
-  }
-
-  public async getBlockNumber(): Promise<number> {
-    return await this.node.getBlockNumber();
-  }
-
-  public async getProvenBlockNumber(): Promise<number> {
-    return await this.node.getProvenBlockNumber();
-  }
-
-  /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  public getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
-    return this.node.getPublicLogs(filter);
-  }
-
-  /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  public getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
-    return this.node.getContractClassLogs(filter);
-  }
-
-  async #getFunctionCall(functionName: string, args: any[], to: AztecAddress): Promise<FunctionCall> {
-    const contract = await this.contractDataProvider.getContract(to);
-    if (!contract) {
-      throw new Error(
-        `Unknown contract ${to}: add it to PXE Service by calling server.addContracts(...).\nSee docs for context: https://docs.aztec.network/developers/reference/debugging/aztecnr-errors#unknown-contract-0x0-add-it-to-pxe-by-calling-serveraddcontracts`,
-      );
-    }
-
-    const functionDao = contract.functions.find(f => f.name === functionName);
-    if (!functionDao) {
-      throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
-    }
-
-    return {
-      name: functionDao.name,
-      args: encodeArguments(functionDao, args),
-      selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
-      type: functionDao.functionType,
-      to,
-      isStatic: functionDao.isStatic,
-      returnTypes: functionDao.returnTypes,
-    };
-  }
-
   public async getNodeInfo(): Promise<NodeInfo> {
     const [nodeVersion, protocolVersion, chainId, enr, contractAddresses, protocolContractAddresses] =
       await Promise.all([
@@ -736,151 +874,6 @@ export class PXEService implements PXE {
     });
   }
 
-  async #registerProtocolContracts() {
-    const registered: Record<string, string> = {};
-    for (const name of protocolContractNames) {
-      const { address, contractClass, instance, artifact } =
-        await this.protocolContractsProvider.getProtocolContractArtifact(name);
-      await this.contractDataProvider.addContractArtifact(contractClass.id, artifact);
-      await this.contractDataProvider.addContractInstance(instance);
-      registered[name] = address.toString();
-    }
-    this.log.verbose(`Registered protocol contracts in pxe`, registered);
-  }
-
-  /**
-   * Retrieves the simulation parameters required to run an ACIR simulation.
-   * This includes the contract address, function artifact, and historical tree roots.
-   *
-   * @param execRequest - The transaction request object containing details of the contract call.
-   * @returns An object containing the contract address, function artifact, and historical tree roots.
-   */
-  #getSimulationParameters(execRequest: FunctionCall | TxExecutionRequest) {
-    const contractAddress = (execRequest as FunctionCall).to ?? (execRequest as TxExecutionRequest).origin;
-    const functionSelector =
-      (execRequest as FunctionCall).selector ?? (execRequest as TxExecutionRequest).functionSelector;
-
-    return {
-      contractAddress,
-      functionSelector,
-    };
-  }
-
-  async #executePrivate(
-    txRequest: TxExecutionRequest,
-    msgSender?: AztecAddress,
-    scopes?: AztecAddress[],
-  ): Promise<PrivateExecutionResult> {
-    // TODO - Pause syncing while simulating.
-    const { contractAddress, functionSelector } = this.#getSimulationParameters(txRequest);
-
-    try {
-      const result = await this.simulator.run(txRequest, contractAddress, functionSelector, msgSender, scopes);
-      this.log.debug(`Private simulation completed for ${contractAddress.toString()}:${functionSelector}`);
-      return result;
-    } catch (err) {
-      if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.contractDataProvider, this.log);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Simulate an unconstrained transaction on the given contract, without considering constraints set by ACIR.
-   * The simulation parameters are fetched using ContractDataProvider and executed using AcirSimulator.
-   * Returns the simulation result containing the outputs of the unconstrained function.
-   *
-   * @param execRequest - The transaction request object containing the target contract and function data.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns The simulation result containing the outputs of the unconstrained function.
-   */
-  async #simulateUnconstrained(execRequest: FunctionCall, scopes?: AztecAddress[]) {
-    const { contractAddress, functionSelector } = this.#getSimulationParameters(execRequest);
-
-    this.log.debug('Executing unconstrained simulator...');
-    try {
-      const result = await this.simulator.runUnconstrained(execRequest, contractAddress, functionSelector, scopes);
-      this.log.verbose(`Unconstrained simulation for ${contractAddress}.${functionSelector} completed`);
-
-      return result;
-    } catch (err) {
-      if (err instanceof SimulationError) {
-        await enrichSimulationError(err, this.contractDataProvider, this.log);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Simulate the public part of a transaction.
-   * This allows to catch public execution errors before submitting the transaction.
-   * It can also be used for estimating gas in the future.
-   * @param tx - The transaction to be simulated.
-   */
-  async #simulatePublicCalls(tx: Tx, skipFeeEnforcement: boolean) {
-    // Simulating public calls can throw if the TX fails in a phase that doesn't allow reverts (setup)
-    // Or return as reverted if it fails in a phase that allows reverts (app logic, teardown)
-    try {
-      const result = await this.node.simulatePublicCalls(tx, skipFeeEnforcement);
-      if (result.revertReason) {
-        throw result.revertReason;
-      }
-      return result;
-    } catch (err) {
-      if (err instanceof SimulationError) {
-        try {
-          await enrichPublicSimulationError(err, this.contractDataProvider, this.log);
-        } catch (enrichErr) {
-          this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
-        }
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Generate a kernel proof, and create a private kernel output.
-   * The function takes in a transaction execution request, and the result of private execution
-   * and then generates a kernel proof.
-   *
-   * @param txExecutionRequest - The transaction request to be simulated and proved.
-   * @param proofCreator - The proof creator to use for proving the execution.
-   * @param privateExecutionResult - The result of the private execution
-   * @returns An object that contains the output of the kernel execution, including the ClientIvcProof if proving is enabled.
-   */
-  async #prove(
-    txExecutionRequest: TxExecutionRequest,
-    proofCreator: PrivateKernelProver,
-    privateExecutionResult: PrivateExecutionResult,
-    { simulate, skipFeeEnforcement, profile }: ProvingConfig,
-  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
-    // use the block the tx was simulated against
-    const block =
-      privateExecutionResult.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
-    const kernelOracle = new KernelOracle(this.contractDataProvider, this.keyStore, this.node, block);
-    const kernelProver = new KernelProver(kernelOracle, proofCreator, !this.proverEnabled);
-    this.log.debug(`Executing kernel prover (simulate: ${simulate}, profile: ${profile})...`);
-    return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult, {
-      simulate,
-      skipFeeEnforcement,
-      profile,
-    });
-  }
-
-  async #isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
-    return !!(await this.node.getContractClass(id));
-  }
-
-  async #isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
-    return !!(await this.node.getContract(address));
-  }
-
-  async #isContractInitialized(address: AztecAddress): Promise<boolean> {
-    const initNullifier = await siloNullifier(address, address.toField());
-    return !!(await this.node.getNullifierMembershipWitness('latest', initNullifier));
-  }
-
   public async getPrivateEvents<T>(
     eventMetadataDef: EventMetadataDefinition,
     from: number,
@@ -985,18 +978,4 @@ export class PXEService implements PXE {
   async resetNoteSyncData() {
     return await this.taggingDataProvider.resetNoteSyncData();
   }
-
-  private contextualizeError(err: Error, ...context: string[]): Error {
-    let contextStr = '';
-    if (context.length > 0) {
-      contextStr = `\nContext:\n${context.join('\n')}`;
-    }
-    if (err instanceof SimulationError) {
-      err.setAztecContext(contextStr);
-    } else {
-      this.log.error(err.name, err);
-      this.log.debug(contextStr);
-    }
-    return err;
-  }
 }