@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5daedc8

package/src/private/providers/acvm_wasm_with_blobs.ts

@@ -1,50 +0,0 @@
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-
-import { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
-import type { WitnessMap } from '@noir-lang/types';
-
-import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
-import type { ACVMWitness } from '../acvm/acvm_types.js';
-import { type SimulationProvider, parseErrorPayload } from './simulation_provider.js';
-
-/**
- * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
- * This class is temporary while brillig cannot handle the blob math, and it is kept separate
- * because the zkg commitment library used in the blob code is not browser compatible.
- *
- * It is only used in the context of server-side code executing simulated protocol circuits.
- */
-export class WASMSimulatorWithBlobs implements SimulationProvider {
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    // Execute the circuit on those initial witness values
-    //
-    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
-    //
-    // Execute the circuit
-    try {
-      const _witnessMap = await executeCircuit(
-        decodedBytecode,
-        input,
-        foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
-      );
-
-      return _witnessMap;
-    } catch (err) {
-      // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
-      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
-      }
-      throw new Error(`Circuit execution failed: ${err}`);
-    }
-  }
-
-  executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
-    _callback: ACIRCallback,
-  ): Promise<ACIRExecutionResult> {
-    throw new Error('Not implemented');
-  }
-}

package/src/private/providers/simulation_provider.ts

@@ -1,45 +0,0 @@
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-
-import type { ExecutionError } from '@noir-lang/acvm_js';
-import { abiDecodeError } from '@noir-lang/noirc_abi';
-import type { Abi, WitnessMap } from '@noir-lang/types';
-
-import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
-import type { ACVMWitness } from '../acvm/acvm_types.js';
-
-/**
- * Low level simulation interface
- */
-export interface SimulationProvider {
-  executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
-  executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback): Promise<ACIRExecutionResult>;
-}
-
-export type ErrorWithPayload = ExecutionError & { decodedAssertionPayload?: any };
-
-// Error handling taken from noir/noir-repo/tooling/noir_js/src/witness_generation.ts.
-// TODO: import this in isolation without having to import noir_js in its entirety.
-export function parseErrorPayload(abi: Abi, originalError: ExecutionError): Error {
-  const payload = originalError.rawAssertionPayload;
-  if (!payload) {
-    return originalError;
-  }
-  const enrichedError = originalError as ErrorWithPayload;
-
-  try {
-    // Decode the payload
-    const decodedPayload = abiDecodeError(abi, payload);
-
-    if (typeof decodedPayload === 'string') {
-      // If it's a string, just add it to the error message
-      enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
-    } else {
-      // If not, attach the payload to the original error
-      enrichedError.decodedAssertionPayload = decodedPayload;
-    }
-  } catch (_errorDecoding) {
-    // Ignore errors decoding the payload
-  }
-
-  return enrichedError;
-}

package/src/private/simulator.ts

@@ -1,147 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { FunctionCall } from '@aztec/stdlib/abi';
-import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CallContext, PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
-
-import { createSimulationError } from '../common/errors.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
-import { ExecutionNoteCache } from './execution_note_cache.js';
-import { HashedValuesCache } from './hashed_values_cache.js';
-import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
-import { PrivateExecutionOracle } from './private_execution_oracle.js';
-import type { SimulationProvider } from './providers/simulation_provider.js';
-import { executeUnconstrainedFunction } from './unconstrained_execution.js';
-import { UnconstrainedExecutionOracle } from './unconstrained_execution_oracle.js';
-
-/**
- * The ACIR simulator.
- */
-export class AcirSimulator {
-  private log: Logger;
-
-  constructor(private executionDataProvider: ExecutionDataProvider, private simulationProvider: SimulationProvider) {
-    this.log = createLogger('simulator');
-  }
-
-  /**
-   * Runs a private function.
-   * @param request - The transaction request.
-   * @param entryPointArtifact - The artifact of the entry point function.
-   * @param contractAddress - The address of the contract (should match request.origin)
-   * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   * @returns The result of the execution.
-   */
-  public async run(
-    request: TxExecutionRequest,
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-    msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
-    scopes?: AztecAddress[],
-  ): Promise<PrivateExecutionResult> {
-    const header = await this.executionDataProvider.getBlockHeader();
-
-    await verifyCurrentClassId(contractAddress, this.executionDataProvider);
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
-
-    if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
-      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
-    }
-
-    if (request.origin !== contractAddress) {
-      this.log.warn(
-        `Request origin does not match contract address in simulation. Request origin: ${request.origin}, contract address: ${contractAddress}`,
-      );
-    }
-
-    // reserve the first side effect for the tx hash (inserted by the private kernel)
-    const startSideEffectCounter = 1;
-
-    const callContext = new CallContext(
-      msgSender,
-      contractAddress,
-      await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
-      entryPointArtifact.isStatic,
-    );
-
-    const txRequestHash = await request.toTxRequest().hash();
-    const noteCache = new ExecutionNoteCache(txRequestHash);
-
-    const context = new PrivateExecutionOracle(
-      request.firstCallArgsHash,
-      request.txContext,
-      callContext,
-      header,
-      request.authWitnesses,
-      request.capsules,
-      HashedValuesCache.create(request.argsOfCalls),
-      noteCache,
-      this.executionDataProvider,
-      this.simulationProvider,
-      /*totalPublicArgsCount=*/ 0,
-      startSideEffectCounter,
-      undefined,
-      scopes,
-    );
-
-    try {
-      const executionResult = await executePrivateFunction(
-        this.simulationProvider,
-        context,
-        entryPointArtifact,
-        contractAddress,
-        request.functionSelector,
-      );
-      const { usedTxRequestHashForNonces } = noteCache.finish();
-      const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
-      return new PrivateExecutionResult(executionResult, firstNullifierHint);
-    } catch (err) {
-      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-    }
-  }
-
-  /**
-   * Runs an unconstrained function.
-   * @param request - The transaction request.
-   * @param entryPointArtifact - The artifact of the entry point function.
-   * @param contractAddress - The address of the contract.
-   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
-   */
-  public async runUnconstrained(
-    request: FunctionCall,
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-    scopes?: AztecAddress[],
-  ) {
-    await verifyCurrentClassId(contractAddress, this.executionDataProvider);
-    const entryPointArtifact = await this.executionDataProvider.getFunctionArtifact(contractAddress, selector);
-
-    if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
-      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as unconstrained`);
-    }
-
-    const context = new UnconstrainedExecutionOracle(
-      contractAddress,
-      [],
-      [],
-      this.executionDataProvider,
-      undefined,
-      scopes,
-    );
-
-    try {
-      return await executeUnconstrainedFunction(
-        this.simulationProvider,
-        context,
-        entryPointArtifact,
-        contractAddress,
-        request.selector,
-        request.args,
-      );
-    } catch (err) {
-      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
-    }
-  }
-}

package/src/private/unconstrained_execution.ts

@@ -1,50 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { type AbiDecoded, type FunctionArtifact, type FunctionSelector, decodeFromAbi } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { witnessMapToFields } from './acvm/deserialize.js';
-import { Oracle, extractCallStack, toACVMWitness } from './acvm/index.js';
-import type { SimulationProvider } from './providers/simulation_provider.js';
-import type { UnconstrainedExecutionOracle } from './unconstrained_execution_oracle.js';
-
-// docs:start:execute_unconstrained_function
-/**
- * Execute an unconstrained function and return the decoded values.
- */
-export async function executeUnconstrainedFunction(
-  simulatorProvider: SimulationProvider,
-  oracle: UnconstrainedExecutionOracle,
-  artifact: FunctionArtifact,
-  contractAddress: AztecAddress,
-  functionSelector: FunctionSelector,
-  args: Fr[],
-  log = createLogger('simulator:unconstrained_execution'),
-): Promise<AbiDecoded> {
-  log.verbose(`Executing unconstrained function ${artifact.name}`, {
-    contract: contractAddress,
-    selector: functionSelector,
-  });
-
-  const acir = artifact.bytecode;
-  const initialWitness = toACVMWitness(0, args);
-  const acirExecutionResult = await simulatorProvider
-    .executeUserCircuit(acir, initialWitness, new Oracle(oracle))
-    .catch((err: Error) => {
-      err.message = resolveAssertionMessageFromError(err, artifact);
-      throw new ExecutionError(
-        err.message,
-        {
-          contractAddress,
-          functionSelector,
-        },
-        extractCallStack(err, artifact.debug),
-        { cause: err },
-      );
-    });
-
-  const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-  return decodeFromAbi(artifact.returnTypes, returnWitness);
-}
-// docs:end:execute_unconstrained_function

package/src/private/unconstrained_execution_oracle.ts

@@ -1,373 +0,0 @@
-import { Aes128 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
-import type { AuthWitness } from '@aztec/stdlib/auth-witness';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
-import { siloNullifier } from '@aztec/stdlib/hash';
-import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
-import type { NoteStatus } from '@aztec/stdlib/note';
-import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader, Capsule } from '@aztec/stdlib/tx';
-
-import { type NoteData, TypedOracle } from './acvm/index.js';
-import type { ExecutionDataProvider } from './execution_data_provider.js';
-import { pickNotes } from './pick_notes.js';
-
-/**
- * The oracle for an unconstrained function execution.
- */
-export class UnconstrainedExecutionOracle extends TypedOracle {
-  constructor(
-    protected readonly contractAddress: AztecAddress,
-    /** List of transient auth witnesses to be used during this simulation */
-    protected readonly authWitnesses: AuthWitness[],
-    protected readonly capsules: Capsule[],
-    protected readonly executionDataProvider: ExecutionDataProvider,
-    protected log = createLogger('simulator:client_view_context'),
-    protected readonly scopes?: AztecAddress[],
-  ) {
-    super();
-  }
-
-  public override getBlockNumber(): Promise<number> {
-    return this.executionDataProvider.getBlockNumber();
-  }
-
-  public override getContractAddress(): Promise<AztecAddress> {
-    return Promise.resolve(this.contractAddress);
-  }
-
-  public override getChainId(): Promise<Fr> {
-    return Promise.resolve(this.executionDataProvider.getChainId().then(id => new Fr(id)));
-  }
-
-  public override getVersion(): Promise<Fr> {
-    return Promise.resolve(this.executionDataProvider.getVersion().then(v => new Fr(v)));
-  }
-
-  /**
-   * Retrieve keys associated with a specific master public key and app address.
-   * @param pkMHash - The master public key hash.
-   * @returns A Promise that resolves to nullifier keys.
-   * @throws If the keys are not registered in the key store.
-   */
-  public override getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest> {
-    return this.executionDataProvider.getKeyValidationRequest(pkMHash, this.contractAddress);
-  }
-
-  /**
-   * Fetches the index and sibling path of a leaf at a given block from a given tree.
-   * @param blockNumber - The block number at which to get the membership witness.
-   * @param treeId - Id of the tree to get the sibling path from.
-   * @param leafValue - The leaf value
-   * @returns The index and sibling path concatenated [index, sibling_path]
-   */
-  public override getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    return this.executionDataProvider.getMembershipWitness(blockNumber, treeId, leafValue);
-  }
-
-  /**
-   * Returns a nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
-   * @param nullifier - Nullifier we try to find witness for.
-   * @returns The nullifier membership witness (if found).
-   */
-  public override async getNullifierMembershipWitness(
-    blockNumber: number,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    return await this.executionDataProvider.getNullifierMembershipWitness(blockNumber, nullifier);
-  }
-
-  /**
-   * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
-   * @param nullifier - Nullifier we try to find the low nullifier witness for.
-   * @returns The low nullifier membership witness (if found).
-   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
-   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
-   * we are trying to prove non-inclusion for.
-   */
-  public override async getLowNullifierMembershipWitness(
-    blockNumber: number,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    return await this.executionDataProvider.getLowNullifierMembershipWitness(blockNumber, nullifier);
-  }
-
-  /**
-   * Returns a public data tree witness for a given leaf slot at a given block.
-   * @param blockNumber - The block number at which to get the index.
-   * @param leafSlot - The slot of the public data tree to get the witness for.
-   * @returns - The witness
-   */
-  public override async getPublicDataTreeWitness(
-    blockNumber: number,
-    leafSlot: Fr,
-  ): Promise<PublicDataWitness | undefined> {
-    return await this.executionDataProvider.getPublicDataTreeWitness(blockNumber, leafSlot);
-  }
-
-  /**
-   * Fetches a block header of a given block.
-   * @param blockNumber - The number of a block of which to get the block header.
-   * @returns Block extracted from a block with block number `blockNumber`.
-   */
-  public override async getBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
-    const block = await this.executionDataProvider.getBlock(blockNumber);
-    if (!block) {
-      return undefined;
-    }
-    return block.header;
-  }
-
-  /**
-   * Retrieve the complete address associated to a given address.
-   * @param account - The account address.
-   * @returns A complete address associated with the input address.
-   * @throws An error if the account is not registered in the database.
-   */
-  public override getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
-    return this.executionDataProvider.getCompleteAddress(account);
-  }
-
-  /**
-   * Returns a contract instance associated with an address or throws if not found.
-   * @param address - Address.
-   * @returns A contract instance.
-   */
-  public override getContractInstance(address: AztecAddress): Promise<ContractInstance> {
-    return this.executionDataProvider.getContractInstance(address);
-  }
-
-  /**
-   * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
-   * for this transaction first, and falls back to the local database if not found.
-   * @param messageHash - Hash of the message to authenticate.
-   * @returns Authentication witness for the requested message hash.
-   */
-  public override getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
-    return Promise.resolve(
-      this.authWitnesses.find(w => w.requestHash.equals(messageHash))?.witness ??
-        this.executionDataProvider.getAuthWitness(messageHash),
-    );
-  }
-
-  /**
-   * Gets some notes for a contract address and storage slot.
-   * Returns a flattened array containing filtered notes.
-   *
-   * @remarks
-   * Check for pending notes with matching slot.
-   * Real notes coming from DB will have a leafIndex which
-   * represents their index in the note hash tree.
-   *
-   * @param storageSlot - The storage slot.
-   * @param numSelects - The number of valid selects in selectBy and selectValues.
-   * @param selectBy - An array of indices of the fields to selects.
-   * @param selectValues - The values to match.
-   * @param selectComparators - The comparators to use to match values.
-   * @param sortBy - An array of indices of the fields to sort.
-   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
-   * @param limit - The number of notes to retrieve per query.
-   * @param offset - The starting index for pagination.
-   * @param status - The status of notes to fetch.
-   * @returns Array of note data.
-   */
-  public override async getNotes(
-    storageSlot: Fr,
-    numSelects: number,
-    selectByIndexes: number[],
-    selectByOffsets: number[],
-    selectByLengths: number[],
-    selectValues: Fr[],
-    selectComparators: number[],
-    sortByIndexes: number[],
-    sortByOffsets: number[],
-    sortByLengths: number[],
-    sortOrder: number[],
-    limit: number,
-    offset: number,
-    status: NoteStatus,
-  ): Promise<NoteData[]> {
-    const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, storageSlot, status, this.scopes);
-    return pickNotes<NoteData>(dbNotes, {
-      selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
-        selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },
-        value: selectValues[i],
-        comparator: selectComparators[i],
-      })),
-      sorts: sortByIndexes.map((index, i) => ({
-        selector: { index, offset: sortByOffsets[i], length: sortByLengths[i] },
-        order: sortOrder[i],
-      })),
-      limit,
-      offset,
-    });
-  }
-
-  /**
-   * Check if a nullifier exists in the nullifier tree.
-   * @param innerNullifier - The inner nullifier.
-   * @returns A boolean indicating whether the nullifier exists in the tree or not.
-   */
-  public override async checkNullifierExists(innerNullifier: Fr) {
-    const nullifier = await siloNullifier(this.contractAddress, innerNullifier!);
-    const index = await this.executionDataProvider.getNullifierIndex(nullifier);
-    return index !== undefined;
-  }
-
-  /**
-   * Fetches a message from the executionDataProvider, given its key.
-   * @param contractAddress - Address of a contract by which the message was emitted.
-   * @param messageHash - Hash of the message.
-   * @param secret - Secret used to compute a nullifier.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */
-  public override async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
-    return await this.executionDataProvider.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
-  }
-
-  /**
-   * Read the public storage data.
-   * @param contractAddress - The address to read storage from.
-   * @param startStorageSlot - The starting storage slot.
-   * @param blockNumber - The block number to read storage at.
-   * @param numberOfElements - Number of elements to read from the starting storage slot.
-   */
-  public override async storageRead(
-    contractAddress: AztecAddress,
-    startStorageSlot: Fr,
-    blockNumber: number,
-    numberOfElements: number,
-  ) {
-    const values = [];
-    for (let i = 0n; i < numberOfElements; i++) {
-      const storageSlot = new Fr(startStorageSlot.value + i);
-      const value = await this.executionDataProvider.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
-
-      this.log.debug(
-        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
-      );
-      values.push(value);
-    }
-    return values;
-  }
-
-  public override debugLog(message: string, fields: Fr[]): void {
-    // TODO(#10558) Remove this check once the debug log is fixed
-    if (message.startsWith('Context.note_hashes, after pushing new note hash:')) {
-      return;
-    }
-    this.log.verbose(`${applyStringFormatting(message, fields)}`, { module: `${this.log.module}:debug_log` });
-  }
-
-  /**
-   * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
-   * Includes the next index to be used used for tagging with this secret.
-   * For this to work, the ivsk_m of the sender must be known.
-   * @param sender - The address sending the note
-   * @param recipient - The address receiving the note
-   * @returns A tagging secret that can be used to tag notes.
-   */
-  public override async getIndexedTaggingSecretAsSender(
-    sender: AztecAddress,
-    recipient: AztecAddress,
-  ): Promise<IndexedTaggingSecret> {
-    return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
-  }
-
-  public override async syncNotes() {
-    const taggedLogsByRecipient = await this.executionDataProvider.syncTaggedLogs(
-      this.contractAddress,
-      await this.executionDataProvider.getBlockNumber(),
-      this.scopes,
-    );
-
-    for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
-    }
-
-    await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
-  }
-
-  public override async deliverNote(
-    contractAddress: AztecAddress,
-    storageSlot: Fr,
-    nonce: Fr,
-    content: Fr[],
-    noteHash: Fr,
-    nullifier: Fr,
-    txHash: Fr,
-    recipient: AztecAddress,
-  ) {
-    // TODO(#10727): allow other contracts to deliver notes
-    if (!this.contractAddress.equals(contractAddress)) {
-      throw new Error(`Got a note delivery request from ${contractAddress}, expected ${this.contractAddress}`);
-    }
-
-    await this.executionDataProvider.deliverNote(
-      contractAddress,
-      storageSlot,
-      nonce,
-      content,
-      noteHash,
-      nullifier,
-      txHash,
-      recipient,
-    );
-  }
-
-  public override getLogByTag(tag: Fr): Promise<LogWithTxData | null> {
-    return this.executionDataProvider.getLogByTag(tag);
-  }
-
-  public override storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
-    if (!contractAddress.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-    }
-    return this.executionDataProvider.storeCapsule(this.contractAddress, slot, capsule);
-  }
-
-  public override async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
-    if (!contractAddress.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-    }
-    return (
-      this.capsules.find(c => c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ??
-      (await this.executionDataProvider.loadCapsule(this.contractAddress, slot))
-    );
-  }
-
-  public override deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
-    if (!contractAddress.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-    }
-    return this.executionDataProvider.deleteCapsule(this.contractAddress, slot);
-  }
-
-  public override copyCapsule(
-    contractAddress: AztecAddress,
-    srcSlot: Fr,
-    dstSlot: Fr,
-    numEntries: number,
-  ): Promise<void> {
-    if (!contractAddress.equals(this.contractAddress)) {
-      // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
-      throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
-    }
-    return this.executionDataProvider.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
-  }
-
-  // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
-  public override aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer> {
-    const aes128 = new Aes128();
-    return aes128.decryptBufferCBC(ciphertext, iv, symKey);
-  }
-}

package/src/public/avm/bytecode_utils.ts

@@ -1,17 +0,0 @@
-import { Opcode } from './serialization/instruction_serialization.js';
-
-const AVM_MAGIC_SUFFIX = Buffer.from([
-  Opcode.MOV_16, // opcode
-  0x00, // indirect
-  ...Buffer.from('18ca', 'hex'), // srcOffset
-  ...Buffer.from('18ca', 'hex'), // dstOffset
-]);
-
-export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
-  return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
-}
-
-export function isAvmBytecode(bytecode: Buffer): boolean {
-  const magicSize = AVM_MAGIC_SUFFIX.length;
-  return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
-}