@aztec/simulator 0.35.0 → 0.36.0

package/src/public/executor.ts

@@ -1,5 +1,12 @@
 import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
-import { Fr, Gas, type GlobalVariables, type Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
+import {
+  Fr,
+  Gas,
+  type GlobalVariables,
+  type Header,
+  PublicCircuitPublicInputs,
+  type TxContext,
+} from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { spawn } from 'child_process';
@@ -64,9 +71,11 @@ async function executePublicFunctionAvm(executionContext: PublicExecutionContext
     executionContext.execution,
     executionContext.header,
     executionContext.globalVariables,
+    executionContext.gasSettings,
+    executionContext.transactionFee,
   );
 
-  const machineState = new AvmMachineState(executionContext.execution.callContext.gasLeft);
+  const machineState = new AvmMachineState(executionContext.availableGas);
   const context = new AvmContext(worldStateJournal, executionEnv, machineState);
   const simulator = new AvmSimulator(context);
 
@@ -148,10 +157,13 @@ async function executePublicFunctionAcvm(
       contractStorageReads: [],
       contractStorageUpdateRequests: [],
       nestedExecutions: [],
+      unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
-      gasLeft: Gas.empty(),
+      startGasLeft: context.availableGas,
+      endGasLeft: Gas.empty(),
+      transactionFee: context.transactionFee,
     };
   }
 
@@ -169,6 +181,7 @@ async function executePublicFunctionAcvm(
     newNullifiers: newNullifiersPadded,
     startSideEffectCounter,
     endSideEffectCounter,
+    unencryptedLogsHashes: unencryptedLogsHashesPadded,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
   const returnValues = await context.unpackReturns(returnsHash);
 
@@ -177,6 +190,7 @@ async function executePublicFunctionAcvm(
   const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isEmpty());
   const newNoteHashes = newNoteHashesPadded.filter(v => !v.isEmpty());
   const newNullifiers = newNullifiersPadded.filter(v => !v.isEmpty());
+  const unencryptedLogsHashes = unencryptedLogsHashesPadded.filter(v => !v.isEmpty());
 
   const { contractStorageReads, contractStorageUpdateRequests } = context.getStorageActionData();
 
@@ -193,7 +207,10 @@ async function executePublicFunctionAcvm(
 
   const nestedExecutions = context.getNestedExecutions();
   const unencryptedLogs = context.getUnencryptedLogs();
-  const gasLeft = context.execution.callContext.gasLeft; // No gas metering for ACVM
+
+  // TODO(palla/gas): We should be loading these values from the returned PublicCircuitPublicInputs
+  const startGasLeft = context.availableGas;
+  const endGasLeft = context.availableGas; // No gas consumption in non-AVM
 
   return {
     execution,
@@ -208,10 +225,13 @@ async function executePublicFunctionAcvm(
     contractStorageUpdateRequests,
     returnValues,
     nestedExecutions,
+    unencryptedLogsHashes,
     unencryptedLogs,
     reverted: false,
     revertReason: undefined,
-    gasLeft,
+    startGasLeft,
+    endGasLeft,
+    transactionFee: context.transactionFee,
   };
 }
 
@@ -236,6 +256,9 @@ export class PublicExecutor {
   public async simulate(
     execution: PublicExecution,
     globalVariables: GlobalVariables,
+    availableGas: Gas,
+    txContext: TxContext,
+    transactionFee: Fr = Fr.ZERO,
     sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
     // Functions can request to pack arguments before calling other functions.
@@ -251,6 +274,9 @@ export class PublicExecutor {
       this.stateDb,
       this.contractsDb,
       this.commitmentsDb,
+      availableGas,
+      transactionFee,
+      txContext.gasSettings,
     );
 
     const executionResult = await executePublicFunction(context, /*nested=*/ false);

package/src/public/hints_builder.ts

@@ -1,65 +1,77 @@
 import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
-  MAX_NEW_NULLIFIERS_PER_TX,
+  type MAX_NEW_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  MAX_PUBLIC_DATA_READS_PER_TX,
+  type MAX_PUBLIC_DATA_HINTS,
+  type MAX_PUBLIC_DATA_READS_PER_TX,
+  type MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   NULLIFIER_TREE_HEIGHT,
+  type Nullifier,
   PUBLIC_DATA_TREE_HEIGHT,
+  type PublicDataHint,
   type PublicDataRead,
-  PublicDataTreeLeafPreimage,
+  type PublicDataTreeLeafPreimage,
+  type PublicDataUpdateRequest,
   type ReadRequestContext,
-  type SideEffectLinkedToNoteHash,
   buildNullifierNonExistentReadRequestHints,
   buildNullifierReadRequestHints,
-  mergeAccumulatedData,
+  buildPublicDataHints,
+  buildPublicDataReadRequestHints,
 } from '@aztec/circuits.js';
-import { makeTuple } from '@aztec/foundation/array';
 import { type Tuple } from '@aztec/foundation/serialize';
-import { type MerkleTreeOperations } from '@aztec/world-state';
+import { type IndexedTreeId, type MerkleTreeOperations } from '@aztec/world-state';
 
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
   getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    return buildNullifierReadRequestHints(
-      this,
-      nullifierReadRequests,
-      mergeAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
-    );
+    return buildNullifierReadRequestHints(this, nullifierReadRequests, pendingNullifiers);
   }
 
   getNullifierNonExistentReadRequestHints(
     nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
   ) {
-    const pendingNullifiers = mergeAccumulatedData(
-      MAX_NEW_NULLIFIERS_PER_TX,
-      nullifiersNonRevertible,
-      nullifiersRevertible,
-    );
     return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
   }
 
+  getPublicDataHints(
+    publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
+    publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
+  ) {
+    return buildPublicDataHints(this, publicDataReads, publicDataUpdateRequests);
+  }
+
+  getPublicDataReadRequestHints(
+    publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
+    publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
+    publicDataHints: Tuple<PublicDataHint, typeof MAX_PUBLIC_DATA_HINTS>,
+  ) {
+    return buildPublicDataReadRequestHints(publicDataReads, publicDataUpdateRequests, publicDataHints);
+  }
+
   async getNullifierMembershipWitness(nullifier: Fr) {
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (index === undefined) {
-      return;
+      throw new Error(`Cannot find the leaf for nullifier ${nullifier.toBigInt()}.`);
     }
 
-    return this.getNullifierMembershipWitnessWithPreimage(index);
+    return this.getMembershipWitnessWithPreimage<typeof NULLIFIER_TREE_HEIGHT>(
+      MerkleTreeId.NULLIFIER_TREE,
+      NULLIFIER_TREE_HEIGHT,
+      index,
+    );
   }
 
   async getLowNullifierMembershipWitness(nullifier: Fr) {
     const res = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
-    if (res === undefined) {
+    if (!res) {
       throw new Error(`Cannot find the low leaf for nullifier ${nullifier.toBigInt()}.`);
     }
 
@@ -68,52 +80,40 @@ export class HintsBuilder {
       throw new Error(`Nullifier ${nullifier.toBigInt()} already exists in the tree.`);
     }
 
-    return this.getNullifierMembershipWitnessWithPreimage(index);
-  }
-
-  private async getNullifierMembershipWitnessWithPreimage(index: bigint) {
-    const siblingPath = await this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(MerkleTreeId.NULLIFIER_TREE, index);
-    const membershipWitness = new MembershipWitness(
+    return this.getMembershipWitnessWithPreimage<typeof NULLIFIER_TREE_HEIGHT>(
+      MerkleTreeId.NULLIFIER_TREE,
       NULLIFIER_TREE_HEIGHT,
       index,
-      siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
     );
+  }
 
-    const leafPreimage = await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-    if (!leafPreimage) {
-      throw new Error(`Cannot find the leaf preimage at index ${index}.`);
+  async getMatchOrLowPublicDataMembershipWitness(leafSlot: bigint) {
+    const res = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!res) {
+      throw new Error(`Cannot find the previous value index for public data ${leafSlot}.`);
     }
 
-    return { membershipWitness, leafPreimage };
+    const { membershipWitness, leafPreimage } = await this.getMembershipWitnessWithPreimage<
+      typeof PUBLIC_DATA_TREE_HEIGHT
+    >(MerkleTreeId.PUBLIC_DATA_TREE, PUBLIC_DATA_TREE_HEIGHT, res.index);
+
+    // Should find a way to stop casting IndexedTreeLeafPreimage as PublicDataTreeLeafPreimage everywhere.
+    return { membershipWitness, leafPreimage: leafPreimage as PublicDataTreeLeafPreimage };
   }
 
-  async getPublicDataReadsInfo(publicDataReads: PublicDataRead[]) {
-    const newPublicDataReadsWitnesses: Tuple<
-      MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
-      typeof MAX_PUBLIC_DATA_READS_PER_TX
-    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT, 0n));
-
-    const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
-      makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
-
-    for (const i in publicDataReads) {
-      const leafSlot = publicDataReads[i].leafSlot.value;
-      const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-      if (!lowLeafResult) {
-        throw new Error(`Public data tree should have one initial leaf`);
-      }
-      const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-      const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-      newPublicDataReadsWitnesses[i] = new MembershipWitness(
-        PUBLIC_DATA_TREE_HEIGHT,
-        BigInt(lowLeafResult.index),
-        path.toTuple<typeof PUBLIC_DATA_TREE_HEIGHT>(),
-      );
-      newPublicDataReadsPreimages[i] = preimage! as PublicDataTreeLeafPreimage;
+  private async getMembershipWitnessWithPreimage<TREE_HEIGHT extends number>(
+    treeId: IndexedTreeId,
+    treeHeight: TREE_HEIGHT,
+    index: bigint,
+  ) {
+    const siblingPath = await this.db.getSiblingPath(treeId, index);
+    const membershipWitness = new MembershipWitness<TREE_HEIGHT>(treeHeight, index, siblingPath.toTuple());
+
+    const leafPreimage = await this.db.getLeafPreimage(treeId, index);
+    if (!leafPreimage) {
+      throw new Error(`Cannot find the leaf preimage for tree ${treeId} at index ${index}.`);
     }
-    return {
-      newPublicDataReadsWitnesses,
-      newPublicDataReadsPreimages,
-    };
+
+    return { membershipWitness, leafPreimage };
   }
 }

package/src/public/public_execution_context.ts

@@ -3,11 +3,13 @@ import {
   CallContext,
   FunctionData,
   type FunctionSelector,
+  type Gas,
+  type GasSettings,
   type GlobalVariables,
   type Header,
+  PublicContextInputs,
 } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstance } from '@aztec/types/contracts';
@@ -39,6 +41,9 @@ export class PublicExecutionContext extends TypedOracle {
     public readonly stateDb: PublicStateDB,
     public readonly contractsDb: PublicContractsDB,
     public readonly commitmentsDb: CommitmentsDB,
+    public readonly availableGas: Gas,
+    public readonly transactionFee: Fr,
+    public readonly gasSettings: GasSettings,
     private log = createDebugLogger('aztec:simulator:public_execution_context'),
   ) {
     super();
@@ -56,14 +61,15 @@ export class PublicExecutionContext extends TypedOracle {
    */
   public getInitialWitness(witnessStartIndex = 0) {
     const { callContext, args } = this.execution;
-    const fields = [
-      ...callContext.toFields(),
-      ...this.header.toFields(),
-      ...this.globalVariables.toFields(),
-      new Fr(this.sideEffectCounter.current()),
-      ...args,
-    ];
-
+    const publicContextInputs = new PublicContextInputs(
+      callContext,
+      this.header,
+      this.globalVariables,
+      this.sideEffectCounter.current(),
+      this.availableGas,
+      this.transactionFee,
+    );
+    const fields = [...publicContextInputs.toFields(), ...args];
     return toACVMWitness(witnessStartIndex, fields);
   }
 
@@ -90,10 +96,10 @@ export class PublicExecutionContext extends TypedOracle {
   }
 
   /**
-   * Pack the given arguments.
+   * Pack the given array of arguments.
    * @param args - Arguments to pack
    */
-  public packArguments(args: Fr[]): Promise<Fr> {
+  public override packArgumentsArray(args: Fr[]): Promise<Fr> {
     return Promise.resolve(this.packedValuesCache.pack(args));
   }
 
@@ -101,7 +107,7 @@ export class PublicExecutionContext extends TypedOracle {
    * Pack the given returns.
    * @param returns - Returns to pack
    */
-  public packReturns(returns: Fr[]): Promise<Fr> {
+  public override packReturns(returns: Fr[]): Promise<Fr> {
     return Promise.resolve(this.packedValuesCache.pack(returns));
   }
 
@@ -109,7 +115,7 @@ export class PublicExecutionContext extends TypedOracle {
    * Unpack the given returns.
    * @param returnsHash - Returns hash to unpack
    */
-  public unpackReturns(returnsHash: Fr): Promise<Fr[]> {
+  public override unpackReturns(returnsHash: Fr): Promise<Fr[]> {
     return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
   }
 
@@ -121,7 +127,7 @@ export class PublicExecutionContext 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.commitmentsDb.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
   }
 
@@ -129,20 +135,11 @@ export class PublicExecutionContext extends TypedOracle {
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public emitUnencryptedLog(log: UnencryptedL2Log) {
+  public override emitUnencryptedLog(log: UnencryptedL2Log) {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/885)
     this.unencryptedLogs.push(log);
     this.log.verbose(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
-  }
-
-  /**
-   * Retrieves the portal contract address associated with the given contract address.
-   * Returns zero address 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 async getPortalContractAddress(contractAddress: AztecAddress) {
-    return (await this.contractsDb.getPortalContractAddress(contractAddress)) ?? EthAddress.ZERO;
+    return Fr.fromBuffer(log.hash());
   }
 
   /**
@@ -150,7 +147,7 @@ export class PublicExecutionContext extends TypedOracle {
    * @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 = 0; i < Number(numberOfElements); i++) {
       const storageSlot = new Fr(startStorageSlot.value + BigInt(i));
@@ -167,7 +164,7 @@ export class PublicExecutionContext extends TypedOracle {
    * @param startStorageSlot - The starting storage slot.
    * @param values - The values to be written.
    */
-  public async storageWrite(startStorageSlot: Fr, values: Fr[]) {
+  public override async storageWrite(startStorageSlot: Fr, values: Fr[]) {
     const newValues = [];
     for (let i = 0; i < values.length; i++) {
       const storageSlot = new Fr(startStorageSlot.toBigInt() + BigInt(i));
@@ -188,7 +185,7 @@ export class PublicExecutionContext extends TypedOracle {
    * @param argsHash - The packed arguments to pass to the function.
    * @returns The return values of the public function.
    */
-  public async callPublicFunction(
+  public override async callPublicFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
     argsHash: Fr,
@@ -203,20 +200,14 @@ export class PublicExecutionContext extends TypedOracle {
       `Public function call: addr=${targetContractAddress} selector=${functionSelector} args=${args.join(',')}`,
     );
 
-    const portalAddress = (await this.contractsDb.getPortalContractAddress(targetContractAddress)) ?? EthAddress.ZERO;
     const functionData = new FunctionData(functionSelector, /*isPrivate=*/ false);
-    const { transactionFee, gasSettings, gasLeft } = this.execution.callContext;
     const callContext = CallContext.from({
       msgSender: isDelegateCall ? this.execution.callContext.msgSender : this.execution.contractAddress,
       storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
-      portalContractAddress: portalAddress,
       functionSelector,
-      gasLeft, // Propagate the same gas left as when we started since ACVM public functions don't have any metering
       isDelegateCall,
       isStaticCall,
       sideEffectCounter,
-      gasSettings,
-      transactionFee,
     });
 
     const nestedExecution: PublicExecution = {
@@ -235,6 +226,9 @@ export class PublicExecutionContext extends TypedOracle {
       this.stateDb,
       this.contractsDb,
       this.commitmentsDb,
+      this.availableGas,
+      this.transactionFee,
+      this.gasSettings,
       this.log,
     );
 
@@ -256,12 +250,12 @@ export class PublicExecutionContext extends TypedOracle {
     return childExecutionResult.returnValues;
   }
 
-  public async checkNullifierExists(nullifier: Fr): Promise<boolean> {
+  public override async checkNullifierExists(nullifier: Fr): Promise<boolean> {
     const witness = await this.commitmentsDb.getNullifierMembershipWitnessAtLatestBlock(nullifier);
     return !!witness;
   }
 
-  public async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
+  public override async getContractInstance(address: AztecAddress): Promise<ContractInstance> {
     // Note to AVM implementor: The wrapper of the oracle call get_contract_instance in aztec-nr
     // automatically checks that the returned instance is correct, by hashing it together back
     // into the address. However, in the AVM, we also need to prove the negative, otherwise a malicious

package/src/public/public_executor.ts

@@ -3,7 +3,6 @@ import {
   type AztecAddress,
   ContractClassRegisteredEvent,
   ContractInstanceDeployedEvent,
-  type EthAddress,
   Fr,
   type FunctionSelector,
   type L1_TO_L2_MSG_TREE_HEIGHT,
@@ -95,11 +94,6 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     }
     return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
   }
-
-  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
-    const contract = await this.getContractInstance(address);
-    return contract?.portalContractAddress;
-  }
 }
 
 /**
@@ -257,6 +251,10 @@ export class WorldStateDB implements CommitmentsDB {
     return new MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>(messageIndex, siblingPath);
   }
 
+  public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
+    return await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+  }
+
   public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
     return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
   }

package/src/public/public_processor.ts

@@ -1,6 +1,7 @@
 import {
   type BlockProver,
   type FailedTx,
+  type ProcessReturnValues,
   type ProcessedTx,
   type PublicKernelRequest,
   type SimulationError,
@@ -13,7 +14,6 @@ import {
 } from '@aztec/circuit-types';
 import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
 import { type GlobalVariables, type Header, type KernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { type ProcessReturnValues } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';

package/src/public/setup_phase_manager.ts

@@ -17,14 +17,14 @@ import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simul
  */
 export class SetupPhaseManager 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.SETUP,
+    phase: PublicKernelPhase = PublicKernelPhase.SETUP,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }

package/src/public/state_actions.ts

@@ -83,6 +83,7 @@ export class ContractStorageActionsCollector {
   public collect(): [ContractStorageRead[], ContractStorageUpdateRequest[]] {
     const reads = Array.from(this.contractStorageReads.entries()).map(([slot, valueAndCounter]) =>
       ContractStorageRead.from({
+        contractAddress: this.address,
         storageSlot: new Fr(slot),
         ...valueAndCounter,
       }),
@@ -90,6 +91,7 @@ export class ContractStorageActionsCollector {
 
     const updateRequests = Array.from(this.contractStorageUpdateRequests.entries()).map(([slot, valuesAndCounter]) =>
       ContractStorageUpdateRequest.from({
+        contractAddress: this.address,
         storageSlot: new Fr(slot),
         ...valuesAndCounter,
       }),