@aztec/simulator 0.35.0 → 0.36.0

package/src/client/view_data_oracle.ts

@@ -14,7 +14,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-import { type NoteData, TypedOracle } from '../acvm/index.js';
+import { type NoteData, type NullifierKeys, TypedOracle } from '../acvm/index.js';
 import { type DBOracle } from './db_oracle.js';
 import { pickNotes } from './pick_notes.js';
 
@@ -35,11 +35,14 @@ export class ViewDataOracle extends TypedOracle {
   }
 
   /**
-   * Return the nullifier key pair of an account to use in a specific contract.
-   * @param account - The account address of the nullifier key.
+   * Retrieve nullifier keys associated with a specific account and app/contract address.
+   *
+   * @param accountAddress - The account address.
+   * @returns A Promise that resolves to nullifier keys of a requested account and contract.
+   * @throws An error if the account is not registered in the database.
    */
-  public getNullifierKeyPair(account: AztecAddress) {
-    return this.db.getNullifierKeyPair(account, this.contractAddress);
+  public override getNullifierKeys(account: AztecAddress): Promise<NullifierKeys> {
+    return this.db.getNullifierKeys(account, this.contractAddress);
   }
 
   /**
@@ -49,7 +52,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param leafValue - The leaf value
    * @returns The index and sibling path concatenated [index, sibling_path]
    */
-  public async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+  public override async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
     const index = await this.db.findLeafIndex(blockNumber, treeId, leafValue);
     if (!index) {
       throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]}`);
@@ -65,7 +68,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param leafIndex - Index of the leaf to get sibling path for
    * @returns The sibling path.
    */
-  public getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr): Promise<Fr[]> {
+  public override getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr): Promise<Fr[]> {
     return this.db.getSiblingPath(blockNumber, treeId, leafIndex.toBigInt());
   }
 
@@ -75,7 +78,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param nullifier - Nullifier we try to find witness for.
    * @returns The nullifier membership witness (if found).
    */
-  public async getNullifierMembershipWitness(
+  public override async getNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
@@ -91,7 +94,7 @@ export class ViewDataOracle extends TypedOracle {
    * 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 async getLowNullifierMembershipWitness(
+  public override async getLowNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
@@ -104,7 +107,10 @@ export class ViewDataOracle extends TypedOracle {
    * @param leafSlot - The slot of the public data tree to get the witness for.
    * @returns - The witness
    */
-  public async getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+  public override async getPublicDataTreeWitness(
+    blockNumber: number,
+    leafSlot: Fr,
+  ): Promise<PublicDataWitness | undefined> {
     return await this.db.getPublicDataTreeWitness(blockNumber, leafSlot);
   }
 
@@ -113,7 +119,7 @@ export class ViewDataOracle extends TypedOracle {
    * @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 async getHeader(blockNumber: number): Promise<Header | undefined> {
+  public override async getHeader(blockNumber: number): Promise<Header | undefined> {
     const block = await this.db.getBlock(blockNumber);
     if (!block) {
       return undefined;
@@ -126,7 +132,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param address - Address to fetch the complete address for.
    * @returns A complete address associated with the input address.
    */
-  public getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
+  public override getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
     return this.db.getCompleteAddress(address);
   }
 
@@ -135,7 +141,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param address - Address.
    * @returns A contract instance.
    */
-  public getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+  public override getContractInstance(address: AztecAddress): Promise<ContractInstance> {
     return this.db.getContractInstance(address);
   }
 
@@ -145,7 +151,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param messageHash - Hash of the message to authenticate.
    * @returns Authentication witness for the requested message hash.
    */
-  public getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
+  public override getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
     return Promise.resolve(
       this.authWitnesses.find(w => w.requestHash.equals(messageHash))?.witness ?? this.db.getAuthWitness(messageHash),
     );
@@ -156,7 +162,7 @@ export class ViewDataOracle extends TypedOracle {
    * @returns The capsule values
    * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
    */
-  public popCapsule(): Promise<Fr[]> {
+  public override popCapsule(): Promise<Fr[]> {
     return this.db.popCapsule();
   }
 
@@ -181,7 +187,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param status - The status of notes to fetch.
    * @returns Array of note data.
    */
-  public async getNotes(
+  public override async getNotes(
     storageSlot: Fr,
     numSelects: number,
     selectByIndexes: number[],
@@ -218,7 +224,7 @@ export class ViewDataOracle extends TypedOracle {
    * @param innerNullifier - The inner nullifier.
    * @returns A boolean indicating whether the nullifier exists in the tree or not.
    */
-  public async checkNullifierExists(innerNullifier: Fr) {
+  public override async checkNullifierExists(innerNullifier: Fr) {
     const nullifier = siloNullifier(this.contractAddress, innerNullifier!);
     const index = await this.db.getNullifierIndex(nullifier);
     return index !== undefined;
@@ -232,26 +238,16 @@ export class ViewDataOracle extends TypedOracle {
    * @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 async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
+  public override async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
     return await this.db.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
   }
 
-  /**
-   * Retrieves the portal contract address associated with the given contract address.
-   * Throws an error if the input contract address is not found or invalid.
-   * @param contractAddress - The address of the contract whose portal address is to be fetched.
-   * @returns The portal contract address.
-   */
-  public getPortalContractAddress(contractAddress: AztecAddress) {
-    return this.db.getPortalContractAddress(contractAddress);
-  }
-
   /**
    * Read the public storage data.
    * @param startStorageSlot - The starting storage slot.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public async storageRead(startStorageSlot: Fr, numberOfElements: number) {
+  public override async storageRead(startStorageSlot: Fr, numberOfElements: number) {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);

package/src/mocks/fixtures.ts

@@ -5,11 +5,9 @@ import {
   CallContext,
   CallRequest,
   type ContractStorageUpdateRequest,
-  EthAddress,
   Fr,
   FunctionData,
   Gas,
-  GasSettings,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
@@ -67,18 +65,7 @@ export class PublicExecutionResultBuilder {
     revertReason?: SimulationError;
   }) {
     const builder = new PublicExecutionResultBuilder({
-      callContext: new CallContext(
-        from,
-        tx.to,
-        EthAddress.ZERO,
-        tx.functionData.selector,
-        Gas.test(),
-        false,
-        false,
-        0,
-        GasSettings.default(),
-        Fr.ZERO,
-      ),
+      callContext: new CallContext(from, tx.to, tx.functionData.selector, false, false, 0),
       contractAddress: tx.to,
       functionData: tx.functionData,
       args: tx.args,
@@ -115,7 +102,7 @@ export class PublicExecutionResultBuilder {
     return this;
   }
 
-  build(): PublicExecutionResult {
+  build(overrides: Partial<PublicExecutionResult> = {}): PublicExecutionResult {
     return {
       execution: this._execution,
       nestedExecutions: this._nestedExecutions,
@@ -127,12 +114,16 @@ export class PublicExecutionResultBuilder {
       newNullifiers: [],
       newL2ToL1Messages: [],
       contractStorageReads: [],
+      unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       startSideEffectCounter: Fr.ZERO,
       endSideEffectCounter: Fr.ZERO,
       reverted: this._reverted,
       revertReason: this._revertReason,
-      gasLeft: this._execution.callContext.gasLeft.mul(0.9),
+      startGasLeft: Gas.test(),
+      endGasLeft: Gas.test(),
+      transactionFee: Fr.ZERO,
+      ...overrides,
     };
   }
 }

package/src/public/abstract_phase_manager.ts

@@ -1,5 +1,6 @@
 import {
   MerkleTreeId,
+  type ProcessReturnValues,
   type PublicKernelRequest,
   type SimulationError,
   type Tx,
@@ -26,7 +27,10 @@ import {
   MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_UNENCRYPTED_LOGS_PER_CALL,
   MembershipWitness,
+  NoteHash,
+  Nullifier,
   type PrivateKernelTailCircuitPublicInputs,
   type Proof,
   PublicCallData,
@@ -41,19 +45,11 @@ import {
   ReadRequest,
   RevertCode,
   SideEffect,
-  SideEffectLinkedToNoteHash,
   VK_TREE_HEIGHT,
   VerificationKey,
   makeEmptyProof,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
-import {
-  type AbiType,
-  type DecodedReturn,
-  type FunctionArtifact,
-  type ProcessReturnValues,
-  decodeReturnValues,
-} from '@aztec/foundation/abi';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type Tuple } from '@aztec/foundation/serialize';
@@ -232,17 +228,18 @@ export abstract class AbstractPhaseManager {
 
     const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
 
+    // Transaction fee is zero for all phases except teardown
+    const transactionFee = this.getTransactionFee(tx, previousPublicKernelOutput);
+
     // TODO(#1684): Should multiple separately enqueued public calls be treated as
     // separate public callstacks to be proven by separate public kernel sequences
     // and submitted separately to the base rollup?
 
-    const returns = [];
+    let returns: ProcessReturnValues = undefined;
 
     for (const enqueuedCall of enqueuedCalls) {
       const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
 
-      let currentReturn: DecodedReturn | undefined = undefined;
-
       // Keep track of which result is for the top/enqueued call
       let enqueuedExecutionResult: PublicExecutionResult | undefined;
 
@@ -250,9 +247,17 @@ export abstract class AbstractPhaseManager {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
         const sideEffectCounter = lastSideEffectCounter(tx) + 1;
+        const availableGas = this.getAvailableGas(tx, previousPublicKernelOutput);
 
         const result = isExecutionRequest
-          ? await this.publicExecutor.simulate(current, this.globalVariables, sideEffectCounter)
+          ? await this.publicExecutor.simulate(
+              current,
+              this.globalVariables,
+              availableGas,
+              tx.data.constants.txContext,
+              transactionFee,
+              sideEffectCounter,
+            )
           : current;
 
         const functionSelector = result.execution.functionData.selector.toString();
@@ -301,21 +306,12 @@ export abstract class AbstractPhaseManager {
 
         if (!enqueuedExecutionResult) {
           enqueuedExecutionResult = result;
-
-          // TODO(#5450) Need to use the proper return values here
-          const returnTypes: AbiType[] = [
-            { kind: 'array', length: result.returnValues.length, type: { kind: 'field' } },
-          ];
-          const mockArtifact = { returnTypes } as any as FunctionArtifact;
-
-          currentReturn = decodeReturnValues(mockArtifact, result.returnValues);
+          returns = result.returnValues;
         }
       }
       // HACK(#1622): Manually patches the ordering of public state actions
       // TODO(#757): Enforce proper ordering of public state actions
       patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult!, this.phase);
-
-      returns.push(currentReturn);
     }
 
     // TODO(#3675): This should be done in a public kernel circuit
@@ -324,6 +320,17 @@ export abstract class AbstractPhaseManager {
     return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns];
   }
 
+  protected getAvailableGas(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+    return tx.data.constants.txContext.gasSettings
+      .getLimits() // No need to subtract teardown limits since they are already included in end.gasUsed
+      .sub(previousPublicKernelOutput.end.gasUsed)
+      .sub(previousPublicKernelOutput.endNonRevertibleData.gasUsed);
+  }
+
+  protected getTransactionFee(_tx: Tx, _previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+    return Fr.ZERO;
+  }
+
   protected async runKernelCircuit(
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
@@ -364,7 +371,7 @@ export abstract class AbstractPhaseManager {
     return new PublicKernelData(previousOutput, previousProof, vk, vkIndex, vkSiblingPath);
   }
 
-  protected async getPublicCircuitPublicInputs(result: PublicExecutionResult) {
+  protected async getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest = false) {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
     this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
 
@@ -375,16 +382,14 @@ export abstract class AbstractPhaseManager {
       MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
     );
 
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-    const unencryptedLogsHash = Fr.fromBuffer(result.unencryptedLogs.hash());
     const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
 
-    return PublicCircuitPublicInputs.from({
+    const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
       callContext: result.execution.callContext,
       proverAddress: AztecAddress.ZERO,
       argsHash: computeVarArgsHash(result.execution.args),
-      newNoteHashes: padArrayEnd(result.newNoteHashes, SideEffect.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
-      newNullifiers: padArrayEnd(result.newNullifiers, SideEffectLinkedToNoteHash.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
+      newNoteHashes: padArrayEnd(result.newNoteHashes, NoteHash.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
+      newNullifiers: padArrayEnd(result.newNullifiers, Nullifier.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
       newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
       startSideEffectCounter: result.startSideEffectCounter,
       endSideEffectCounter: result.endSideEffectCounter,
@@ -410,20 +415,25 @@ export abstract class AbstractPhaseManager {
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
       ),
       publicCallStackHashes,
-      unencryptedLogsHash,
+      unencryptedLogsHashes: padArrayEnd(
+        result.unencryptedLogsHashes,
+        SideEffect.empty(),
+        MAX_UNENCRYPTED_LOGS_PER_CALL,
+      ),
       unencryptedLogPreimagesLength,
       historicalHeader: this.historicalHeader,
+      globalVariables: this.globalVariables,
+      startGasLeft: Gas.from(result.startGasLeft),
+      endGasLeft: Gas.from(result.endGasLeft),
+      transactionFee: result.transactionFee,
       // TODO(@just-mitch): need better mapping from simulator to revert code.
       revertCode: result.reverted ? RevertCode.REVERTED : RevertCode.OK,
-      gasLeft: Gas.from(result.gasLeft),
     });
-  }
 
-  protected async getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest = false) {
     return new PublicCallStackItem(
       result.execution.contractAddress,
       result.execution.functionData,
-      await this.getPublicCircuitPublicInputs(result),
+      publicCircuitPublicInputs,
       isExecutionRequest,
     );
   }
@@ -461,8 +471,7 @@ export abstract class AbstractPhaseManager {
       c.toCallRequest(callStackItem.publicInputs.callContext),
     );
     const publicCallStack = padArrayEnd(publicCallRequests, CallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
-    const portalContractAddress = result.execution.callContext.portalContractAddress.toField();
-    return new PublicCallData(callStackItem, publicCallStack, makeEmptyProof(), portalContractAddress, bytecodeHash);
+    return new PublicCallData(callStackItem, publicCallStack, makeEmptyProof(), bytecodeHash);
   }
 }
 
@@ -518,29 +527,9 @@ function patchPublicStorageActionOrdering(
   // so the returned result will be a subset of the public kernel output.
 
   const simPublicDataReads = collectPublicDataReads(execResult);
-  // verify that each read is in the kernel output
-  for (const read of simPublicDataReads) {
-    if (!publicDataReads.find(item => item.equals(read))) {
-      throw new Error(
-        `Public data reads from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataReads
-          .map(p => p.toFriendlyJSON())
-          .join(', ')}\nFrom public kernel: ${publicDataReads.map(i => i.toFriendlyJSON()).join(', ')}`,
-      );
-    }
-  }
 
   const simPublicDataUpdateRequests = collectPublicDataUpdateRequests(execResult);
-  for (const update of simPublicDataUpdateRequests) {
-    if (!publicDataUpdateRequests.find(item => item.equals(update))) {
-      throw new Error(
-        `Public data update requests from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataUpdateRequests
-          .map(p => p.toFriendlyJSON())
-          .join(', ')}\nFrom public kernel revertible: ${publicDataUpdateRequests
-          .map(i => i.toFriendlyJSON())
-          .join(', ')}`,
-      );
-    }
-  }
+
   // We only want to reorder the items from the public inputs of the
   // most recently processed top/enqueued call.
 

package/src/public/app_logic_phase_manager.ts

@@ -17,14 +17,14 @@ import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simul
  */
 export class AppLogicPhaseManager extends AbstractPhaseManager {
   constructor(
-    protected db: MerkleTreeOperations,
-    protected publicExecutor: PublicExecutor,
-    protected publicKernel: PublicKernelCircuitSimulator,
-    protected globalVariables: GlobalVariables,
-    protected historicalHeader: Header,
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernel: PublicKernelCircuitSimulator,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-    public phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
+    phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }

package/src/public/db.ts

@@ -1,5 +1,5 @@
 import { type NullifierMembershipWitness } from '@aztec/circuit-types';
-import { type EthAddress, type FunctionSelector, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import { type FunctionSelector, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
@@ -61,13 +61,6 @@ export interface PublicContractsDB {
    */
   getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined>;
 
-  /**
-   * Returns the portal contract address for an L2 address.
-   * @param address - The L2 contract address.
-   * @returns The portal contract address or undefined if not found.
-   */
-  getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined>;
-
   /**
    * Returns a publicly deployed contract instance.
    * @param address - Address of the contract.
@@ -92,6 +85,12 @@ export interface CommitmentsDB {
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
 
+  /**
+   * @param leafIndex the leaf to look up
+   * @returns The l1 to l2 leaf value or undefined if not found.
+   */
+  getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined>;
+
   /**
    * Gets the index of a commitment in the note hash tree.
    * @param commitment - The commitment.

package/src/public/execution.ts

@@ -1,16 +1,16 @@
 import { type SimulationError, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
-  type AztecAddress,
   type ContractStorageRead,
   type ContractStorageUpdateRequest,
   type Fr,
   type L2ToL1Message,
+  type NoteHash,
+  type Nullifier,
   type PublicCallRequest,
   PublicDataRead,
   PublicDataUpdateRequest,
   type ReadRequest,
   type SideEffect,
-  type SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
 import { computePublicDataTreeLeafSlot, computePublicDataTreeValue } from '@aztec/circuits.js/hash';
 
@@ -25,7 +25,7 @@ export interface PublicExecutionResult {
   /** The return values of the function. */
   returnValues: Fr[];
   /** The new note hashes to be inserted into the note hashes tree. */
-  newNoteHashes: SideEffect[];
+  newNoteHashes: NoteHash[];
   /** The new l2 to l1 messages generated in this call. */
   newL2ToL1Messages: L2ToL1Message[];
   /** The side effect counter at the start of the function call. */
@@ -33,7 +33,7 @@ export interface PublicExecutionResult {
   /** The side effect counter after executing this function call */
   endSideEffectCounter: Fr;
   /** The new nullifiers to be inserted into the nullifier tree. */
-  newNullifiers: SideEffectLinkedToNoteHash[];
+  newNullifiers: Nullifier[];
   /** The nullifier read requests emitted in this call. */
   nullifierReadRequests: ReadRequest[];
   /** The nullifier non existent read requests emitted in this call. */
@@ -44,9 +44,14 @@ export interface PublicExecutionResult {
   contractStorageUpdateRequests: ContractStorageUpdateRequest[];
   /** The results of nested calls. */
   nestedExecutions: this[];
+  /**
+   * The hashed logs with side effect counter.
+   * Note: required as we don't track the counter anywhere else.
+   */
+  unencryptedLogsHashes: SideEffect[];
   /**
    * Unencrypted logs emitted during execution of this function call.
-   * Note: These are preimages to `unencryptedLogsHash`.
+   * Note: These are preimages to `unencryptedLogsHashes`.
    */
   unencryptedLogs: UnencryptedFunctionL2Logs;
   /**
@@ -57,8 +62,12 @@ export interface PublicExecutionResult {
    * The revert reason if the execution reverted.
    */
   revertReason: SimulationError | undefined;
+  /** How much gas was available for this public execution. */
+  startGasLeft: Gas;
   /** How much gas was left after this public execution. */
-  gasLeft: Gas;
+  endGasLeft: Gas;
+  /** Transaction fee set for this tx. */
+  transactionFee: Fr;
 }
 
 /**
@@ -85,10 +94,8 @@ export function isPublicExecutionResult(
  */
 export function collectPublicDataReads(execResult: PublicExecutionResult): PublicDataRead[] {
   // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const contractAddress = execResult.execution.callContext.storageContractAddress;
-
   const thisExecPublicDataReads = execResult.contractStorageReads.map(read =>
-    contractStorageReadToPublicDataRead(read, contractAddress),
+    contractStorageReadToPublicDataRead(read),
   );
   const unsorted = [
     ...thisExecPublicDataReads,
@@ -105,10 +112,8 @@ export function collectPublicDataReads(execResult: PublicExecutionResult): Publi
  */
 export function collectPublicDataUpdateRequests(execResult: PublicExecutionResult): PublicDataUpdateRequest[] {
   // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const contractAddress = execResult.execution.callContext.storageContractAddress;
-
   const thisExecPublicDataUpdateRequests = execResult.contractStorageUpdateRequests.map(update =>
-    contractStorageUpdateRequestToPublicDataUpdateRequest(update, contractAddress),
+    contractStorageUpdateRequestToPublicDataUpdateRequest(update),
   );
   const unsorted = [
     ...thisExecPublicDataUpdateRequests,
@@ -123,9 +128,9 @@ export function collectPublicDataUpdateRequests(execResult: PublicExecutionResul
  * @param contractAddress - the contract address of the read
  * @returns The public data read.
  */
-function contractStorageReadToPublicDataRead(read: ContractStorageRead, contractAddress: AztecAddress): PublicDataRead {
+function contractStorageReadToPublicDataRead(read: ContractStorageRead): PublicDataRead {
   return new PublicDataRead(
-    computePublicDataTreeLeafSlot(contractAddress, read.storageSlot),
+    computePublicDataTreeLeafSlot(read.contractAddress!, read.storageSlot),
     computePublicDataTreeValue(read.currentValue),
     read.sideEffectCounter!,
   );
@@ -139,10 +144,9 @@ function contractStorageReadToPublicDataRead(read: ContractStorageRead, contract
  */
 function contractStorageUpdateRequestToPublicDataUpdateRequest(
   update: ContractStorageUpdateRequest,
-  contractAddress: AztecAddress,
 ): PublicDataUpdateRequest {
   return new PublicDataUpdateRequest(
-    computePublicDataTreeLeafSlot(contractAddress, update.storageSlot),
+    computePublicDataTreeLeafSlot(update.contractAddress!, update.storageSlot),
     computePublicDataTreeValue(update.newValue),
     update.sideEffectCounter!,
   );
@@ -154,8 +158,8 @@ function contractStorageUpdateRequestToPublicDataUpdateRequest(
  */
 
 export function checkValidStaticCall(
-  newNoteHashes: SideEffect[],
-  newNullifiers: SideEffectLinkedToNoteHash[],
+  newNoteHashes: NoteHash[],
+  newNullifiers: Nullifier[],
   contractStorageUpdateRequests: ContractStorageUpdateRequest[],
   newL2ToL1Messages: L2ToL1Message[],
   unencryptedLogs: UnencryptedFunctionL2Logs,