@aztec/simulator 0.37.0 → 0.39.0

package/src/avm/opcodes/environment_getters.ts

@@ -1,17 +1,15 @@
-import { type Fr } from '@aztec/circuits.js';
-
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue } from '../avm_memory_types.js';
+import { Field, type MemoryValue, Uint64 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { GetterInstruction } from './instruction_impl.js';
 
 abstract class EnvironmentGetterInstruction extends GetterInstruction {
   protected getValue(context: AvmContext): MemoryValue {
-    return new Field(this.getEnvironmentValue(context.environment));
+    return this.getEnvironmentValue(context.environment);
   }
 
-  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): Fr | number | bigint;
+  protected abstract getEnvironmentValue(env: AvmExecutionEnvironment): MemoryValue;
 }
 
 export class Address extends EnvironmentGetterInstruction {
@@ -19,7 +17,7 @@ export class Address extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.ADDRESS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.address;
+    return new Field(env.address.toField());
   }
 }
 
@@ -28,7 +26,7 @@ export class StorageAddress extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.STORAGEADDRESS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.storageAddress;
+    return new Field(env.storageAddress.toField());
   }
 }
 
@@ -37,7 +35,7 @@ export class Sender extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.SENDER;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.sender;
+    return new Field(env.sender.toField());
   }
 }
 
@@ -46,7 +44,7 @@ export class FeePerL2Gas extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.feePerL2Gas;
+    return new Field(env.feePerL2Gas);
   }
 }
 
@@ -55,7 +53,16 @@ export class FeePerDAGas extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.feePerDaGas;
+    return new Field(env.feePerDaGas);
+  }
+}
+
+export class TransactionFee extends EnvironmentGetterInstruction {
+  static type: string = 'TRANSACTIONFEE';
+  static readonly opcode: Opcode = Opcode.TRANSACTIONFEE;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.transactionFee);
   }
 }
 
@@ -64,7 +71,7 @@ export class ChainId extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.CHAINID;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.chainId;
+    return new Field(env.globals.chainId);
   }
 }
 
@@ -73,7 +80,7 @@ export class Version extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.VERSION;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.version;
+    return new Field(env.globals.version);
   }
 }
 
@@ -82,7 +89,7 @@ export class BlockNumber extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.BLOCKNUMBER;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.blockNumber;
+    return new Field(env.globals.blockNumber);
   }
 }
 
@@ -91,57 +98,6 @@ export class Timestamp extends EnvironmentGetterInstruction {
   static readonly opcode: Opcode = Opcode.TIMESTAMP;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return env.globals.timestamp;
+    return new Uint64(env.globals.timestamp.toBigInt());
   }
 }
-
-// export class Coinbase extends EnvironmentGetterInstruction {
-//     static type: string = 'COINBASE';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {coinbase} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, coinbase);
-
-//         this.incrementPc(machineState);
-//     }
-// }
-
-// export class BlockL2GasLimit extends EnvironmentGetterInstruction {
-//     static type: string = 'BLOCKL2GASLIMIT';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {blockL2GasLimit} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, blockL2GasLimit);
-
-//         this.incrementPc(machineState);
-//     }
-// }
-
-// export class BlockDAGasLimit extends EnvironmentGetterInstruction {
-//     static type: string = 'BLOCKDAGASLIMIT';
-//     static numberOfOperands = 1;
-
-//     constructor(private destOffset: number) {
-//         super();
-//     }
-
-//     async execute(machineState: AvmMachineState, _journal: AvmJournal): Promise<void> {
-//         const {blockDAGasLimit} = machineState.executionEnvironment.globals;
-
-//         machineState.memory.set(this.destOffset, blockDAGasLimit);
-
-//         this.incrementPc(machineState);
-//     }
-// }

package/src/avm/opcodes/external_calls.ts

@@ -1,16 +1,13 @@
-import { FunctionSelector } from '@aztec/circuits.js';
+import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { executePublicFunction } from '../../public/executor.js';
-import {
-  convertPublicExecutionResult,
-  createPublicExecutionContext,
-  updateAvmContextFromPublicExecutionResult,
-} from '../../public/transitional_adaptors.js';
+import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
 import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -69,7 +66,7 @@ abstract class ExternalCall extends Instruction {
     const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
     context.machineState.consumeGas(totalGas);
 
-    // TRANSITIONAL: This should be removed once the AVM is fully operational and the public executor is gone.
+    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -77,11 +74,21 @@ abstract class ExternalCall extends Instruction {
       this.type,
       FunctionSelector.fromField(functionSelector),
     );
-    const pxContext = createPublicExecutionContext(nestedContext, calldata);
-    const pxResults = await executePublicFunction(pxContext, /*nested=*/ true);
-    const nestedCallResults: AvmContractCallResults = convertPublicExecutionResult(pxResults);
-    updateAvmContextFromPublicExecutionResult(nestedContext, pxResults);
-    const nestedPersistableState = nestedContext.persistableState;
+    const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
+
+    const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
+    const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    const pxResults = convertAvmResultsToPxResult(
+      nestedCallResults,
+      startSideEffectCounter,
+      oldStyleExecution,
+      Gas.from(allocatedGas),
+      nestedContext,
+    );
+    // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
+    context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);
+    // END TRANSITIONAL
+
     // const nestedContext = context.createNestedContractCallContext(
     //   callAddress.toFr(),
     //   calldata,
@@ -90,10 +97,19 @@ abstract class ExternalCall extends Instruction {
     //   FunctionSelector.fromField(functionSelector),
     // );
     // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
-    // const nestedPersistableState = nestedContext.persistableState;
 
     const success = !nestedCallResults.reverted;
 
+    // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
+    //               This means that for now, the caller cannot recover from errors.
+    if (!success) {
+      if (!nestedCallResults.revertReason) {
+        throw new Error('A reverted nested call should be assigned a revert reason in the AVM execution loop');
+      }
+      // The nested call's revertReason will be used to track the stack of error causes down to the root.
+      throw new RethrownError(nestedCallResults.revertReason.message, nestedCallResults.revertReason);
+    }
+
     // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
     // than the specified size in order to prevent that memory to be left with garbage
     const returnData = nestedCallResults.output.slice(0, this.retSize);
@@ -112,9 +128,9 @@ abstract class ExternalCall extends Instruction {
 
     // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
     if (success) {
-      context.persistableState.acceptNestedCallState(nestedPersistableState);
+      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
     } else {
-      context.persistableState.rejectNestedCallState(nestedPersistableState);
+      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
     }
 
     memory.assert(memoryOperations);

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,4 +1,5 @@
 import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
+import { ToRadixLE } from '../opcodes/conversion.js';
 import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import type { Instruction } from '../opcodes/index.js';
 import {
@@ -46,6 +47,7 @@ import {
   StorageAddress,
   Sub,
   Timestamp,
+  TransactionFee,
   Version,
   Xor,
 } from '../opcodes/index.js';
@@ -82,6 +84,7 @@ const INSTRUCTION_SET = () =>
     [Sender.opcode, Sender],
     [FeePerL2Gas.opcode, FeePerL2Gas],
     [FeePerDAGas.opcode, FeePerDAGas],
+    [TransactionFee.opcode, TransactionFee],
     //[Contractcalldepth.opcode, Contractcalldepth],
     // Execution Environment - Globals
     [ChainId.opcode, ChainId],
@@ -134,6 +137,8 @@ const INSTRUCTION_SET = () =>
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],
     [Pedersen.opcode, Pedersen],
+    // Conversions
+    [ToRadixLE.opcode, ToRadixLE],
   ]);
 
 interface Serializable {

package/src/avm/serialization/instruction_serialization.ts

@@ -29,6 +29,7 @@ export enum Opcode {
   SENDER,
   FEEPERL2GAS,
   FEEPERDAGAS,
+  TRANSACTIONFEE,
   CONTRACTCALLDEPTH,
   CHAINID,
   VERSION,
@@ -73,6 +74,8 @@ export enum Opcode {
   POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+  // Conversion
+  TORADIXLE,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.

package/src/client/client_execution_context.ts

@@ -15,10 +15,8 @@ import {
   FunctionData,
   FunctionSelector,
   type Header,
-  NoteHashReadRequestMembershipWitness,
   PrivateContextInputs,
   PublicCallRequest,
-  type SideEffect,
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
@@ -32,7 +30,8 @@ import { type NoteData, toACVMWitness } from '../acvm/index.js';
 import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
-import { type ExecutionResult, type NoteAndSlot, type NullifiedNoteHashCounter } from './execution_result.js';
+import { CountedLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { type LogsCache } from './logs_cache.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -58,12 +57,13 @@ export class ClientExecutionContext extends ViewDataOracle {
    * because these notes are meant to be maintained on a per-call basis
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
-  private gotNotes: Map<bigint, bigint> = new Map();
-  private nullifiedNoteHashCounters: NullifiedNoteHashCounter[] = [];
-  private encryptedLogs: EncryptedL2Log[] = [];
-  private unencryptedLogs: UnencryptedL2Log[] = [];
+  private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
+  private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
+  private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
+  private publicTeardownFunctionCall: PublicCallRequest = PublicCallRequest.empty();
 
   constructor(
     contractAddress: AztecAddress,
@@ -76,6 +76,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     authWitnesses: AuthWitness[],
     private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
+    private readonly logsCache: LogsCache,
     db: DBOracle,
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
@@ -112,23 +113,11 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * This function will populate readRequestPartialWitnesses which
-   * here is just used to flag reads as "transient" for new notes created during this execution
-   * or to flag non-transient reads with their leafIndex.
-   * The KernelProver will use this to fully populate witnesses and provide hints to
-   * the kernel regarding which commitments each transient read request corresponds to.
-   * @param noteHashReadRequests - SideEffect containing Note hashed of the notes being read and counter.
-   * @returns An array of partially filled in read request membership witnesses.
+   * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
+   * regarding which note hash each settled read request corresponds to.
    */
-  public getNoteHashReadRequestPartialWitnesses(noteHashReadRequests: SideEffect[]) {
-    return noteHashReadRequests
-      .filter(r => !r.isEmpty())
-      .map(r => {
-        const index = this.gotNotes.get(r.value.toBigInt());
-        return index !== undefined
-          ? NoteHashReadRequestMembershipWitness.empty(index)
-          : NoteHashReadRequestMembershipWitness.emptyTransient();
-      });
+  public getNoteHashLeafIndexMap() {
+    return this.noteHashLeafIndexMap;
   }
 
   /**
@@ -147,14 +136,28 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Return the encrypted logs emitted during this execution.
    */
   public getEncryptedLogs() {
-    return new EncryptedFunctionL2Logs(this.encryptedLogs);
+    return this.encryptedLogs;
+  }
+
+  /**
+   * Return the encrypted logs emitted during this execution and nested executions.
+   */
+  public getAllEncryptedLogs() {
+    return new EncryptedFunctionL2Logs(this.logsCache.getEncryptedLogs());
   }
 
   /**
    * Return the encrypted logs emitted during this execution.
    */
   public getUnencryptedLogs() {
-    return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
+    return this.unencryptedLogs;
+  }
+
+  /**
+   * Return the unencrypted logs emitted during this execution and nested executions.
+   */
+  public getAllUnencryptedLogs() {
+    return new UnencryptedFunctionL2Logs(this.logsCache.getUnencryptedLogs());
   }
 
   /**
@@ -171,6 +174,13 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.enqueuedPublicFunctionCalls;
   }
 
+  /**
+   * Return the public teardown function call set during this execution.
+   */
+  public getPublicTeardownFunctionCall() {
+    return this.publicTeardownFunctionCall;
+  }
+
   /**
    * Pack the given array of arguments.
    * @param args - Arguments to pack
@@ -260,12 +270,12 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     notes.forEach(n => {
       if (n.index !== undefined) {
-        const siloedNoteHash = siloNoteHash(n.contractAddress, n.innerNoteHash);
-        const uniqueSiloedNoteHash = computeUniqueNoteHash(n.nonce, siloedNoteHash);
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
-        // Should always be uniqueSiloedNoteHash when publicly created notes include nonces.
-        const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash;
-        this.gotNotes.set(noteHashForReadRequest.value, n.index);
+        // Should always call computeUniqueNoteHash when publicly created notes include nonces.
+        const uniqueNoteHash = n.nonce.isZero() ? n.innerNoteHash : computeUniqueNoteHash(n.nonce, n.innerNoteHash);
+        const siloedNoteHash = siloNoteHash(n.contractAddress, uniqueNoteHash);
+        const noteHashForReadRequest = siloedNoteHash;
+        this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
       }
     });
 
@@ -321,7 +331,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       innerNoteHash,
     );
     if (nullifiedNoteHashCounter !== undefined) {
-      this.nullifiedNoteHashCounters.push({ noteHashCounter: nullifiedNoteHashCounter, nullifierCounter: counter });
+      this.nullifiedNoteHashCounters.set(nullifiedNoteHashCounter, counter);
     }
     return Promise.resolve();
   }
@@ -340,24 +350,45 @@ export class ClientExecutionContext extends ViewDataOracle {
     noteTypeId: Fr,
     publicKey: Point,
     log: Fr[],
+    counter: number,
   ) {
     const note = new Note(log);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
     const encryptedNote = taggedNote.toEncryptedBuffer(publicKey);
     const encryptedLog = new EncryptedL2Log(encryptedNote);
-    this.encryptedLogs.push(encryptedLog);
-    return Fr.fromBuffer(encryptedLog.hash());
+    this.encryptedLogs.push(new CountedLog(encryptedLog, counter));
+    this.logsCache.addEncryptedLog(encryptedLog);
+    return encryptedNote;
   }
 
   /**
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public override emitUnencryptedLog(log: UnencryptedL2Log) {
-    this.unencryptedLogs.push(log);
+  public override emitUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
     const text = log.toHumanReadable();
     this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+  }
+
+  /**
+   * Emit a contract class unencrypted log.
+   * This fn exists separately from emitUnencryptedLog because sha hashing the preimage
+   * is too large to compile (16,200 fields, 518,400 bytes) => the oracle hashes it.
+   * See private_context.nr
+   * @param log - The unencrypted log to be emitted.
+   */
+  public override emitContractClassUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
+    const text = log.toHumanReadable();
+    this.log.verbose(
+      `Emitted unencrypted log from ContractClassRegisterer: "${
+        text.length > 100 ? text.slice(0, 100) + '...' : text
+      }"`,
+    );
     return Fr.fromBuffer(log.hash());
   }
 
@@ -419,6 +450,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.authWitnesses,
       this.packedValuesCache,
       this.noteCache,
+      this.logsCache,
       this.db,
       this.node,
       sideEffectCounter,
@@ -441,9 +473,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Creates a PublicCallStackItem object representing the request to call a public function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Creates a PublicCallStackItem object representing the request to call a public function.
    * @param targetContractAddress - The address of the contract to call.
    * @param functionSelector - The function selector of the function to call.
    * @param argsHash - The packed arguments to pass to the function.
@@ -451,7 +481,8 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The public call stack item with the request information.
    */
-  public override async enqueuePublicFunctionCall(
+  protected async createPublicCallRequest(
+    callType: 'enqueued' | 'teardown',
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -470,20 +501,51 @@ export class ClientExecutionContext extends ViewDataOracle {
       isStaticCall,
     );
     const args = this.packedValuesCache.unpack(argsHash);
-    const enqueuedRequest = PublicCallRequest.from({
+
+    // TODO($846): if enqueued public calls are associated with global
+    // side-effect counter, that will leak info about how many other private
+    // side-effects occurred in the TX. Ultimately the private kernel should
+    // just output everything in the proper order without any counters.
+    this.log.verbose(
+      `Created PublicCallRequest of type [${callType}], side-effect counter [${sideEffectCounter}] to ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+    );
+
+    return PublicCallRequest.from({
       args,
       callContext: derivedCallContext,
       parentCallContext: this.callContext,
       functionData: FunctionData.fromAbi(targetArtifact),
       contractAddress: targetContractAddress,
     });
+  }
 
-    // TODO($846): if enqueued public calls are associated with global
-    // side-effect counter, that will leak info about how many other private
-    // side-effects occurred in the TX. Ultimately the private kernel should
-    // just output everything in the proper order without any counters.
-    this.log.verbose(
-      `Enqueued call to public function (with side-effect counter #${sideEffectCounter}) ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+  /**
+   * Creates and enqueues a PublicCallStackItem object representing the request to call a public function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function to call.
+   * @param argsHash - The packed arguments to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The public call stack item with the request information.
+   */
+  public override async enqueuePublicFunctionCall(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+    isDelegateCall: boolean,
+  ): Promise<PublicCallRequest> {
+    const enqueuedRequest = await this.createPublicCallRequest(
+      'enqueued',
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
+      isDelegateCall,
     );
 
     this.enqueuedPublicFunctionCalls.push(enqueuedRequest);
@@ -491,6 +553,40 @@ export class ClientExecutionContext extends ViewDataOracle {
     return enqueuedRequest;
   }
 
+  /**
+   * Creates a PublicCallStackItem and sets it as the public teardown function. No function
+   * is actually called, since that must happen on the sequencer side. All the fields related to the result
+   * of the execution are empty.
+   * @param targetContractAddress - The address of the contract to call.
+   * @param functionSelector - The function selector of the function to call.
+   * @param argsHash - The packed arguments to pass to the function.
+   * @param sideEffectCounter - The side effect counter at the start of the call.
+   * @param isStaticCall - Whether the call is a static call.
+   * @returns The public call stack item with the request information.
+   */
+  public override async setPublicTeardownFunctionCall(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+    isDelegateCall: boolean,
+  ): Promise<PublicCallRequest> {
+    const publicTeardownFunctionCall = await this.createPublicCallRequest(
+      'teardown',
+      targetContractAddress,
+      functionSelector,
+      argsHash,
+      sideEffectCounter,
+      isStaticCall,
+      isDelegateCall,
+    );
+
+    this.publicTeardownFunctionCall = publicTeardownFunctionCall;
+
+    return publicTeardownFunctionCall;
+  }
+
   /**
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.

package/src/client/db_oracle.ts

@@ -6,9 +6,9 @@ import {
   type PublicDataWitness,
 } from '@aztec/circuit-types';
 import { type CompleteAddress, type Header } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata, type FunctionSelector } from '@aztec/foundation/abi';
+import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr, type Point } from '@aztec/foundation/fields';
+import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData, type NullifierKeys } from '../acvm/index.js';
@@ -64,14 +64,6 @@ export interface DBOracle extends CommitmentsDB {
    */
   popCapsule(): Promise<Fr[]>;
 
-  /**
-   * Gets public keys for an address.
-   * @param The address to look up
-   * @returns The public keys for a specific address
-   * TODO(#5834): Replace with `getCompleteAddress`.
-   */
-  getPublicKeysForAddress(address: AztecAddress): Promise<Point[]>;
-
   /**
    * Retrieve nullifier keys associated with a specific account and app/contract address.
    *
@@ -102,10 +94,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param selector - The corresponding function selector.
    * @returns A Promise that resolves to a FunctionArtifact object.
    */
-  getFunctionArtifact(
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-  ): Promise<FunctionArtifactWithDebugMetadata>;
+  getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
 
   /**
    * Retrieves the artifact of a specified function within a given contract.
@@ -115,10 +104,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param functionName - The name of the function.
    * @returns The corresponding function's artifact as an object.
    */
-  getFunctionArtifactByName(
-    contractAddress: AztecAddress,
-    functionName: string,
-  ): Promise<FunctionArtifactWithDebugMetadata | undefined>;
+  getFunctionArtifactByName(contractAddress: AztecAddress, functionName: string): Promise<FunctionArtifact | undefined>;
 
   /**
    * Gets the index of a nullifier in the nullifier tree.