@aztec/simulator 0.35.1 → 0.37.0

package/src/public/tail_phase_manager.ts

@@ -1,14 +1,24 @@
-import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
 import {
-  type Fr,
+  type PublicKernelRequest,
+  PublicKernelType,
+  type Tx,
+  UnencryptedFunctionL2Logs,
+  type UnencryptedL2Log,
+} from '@aztec/circuit-types';
+import {
+  Fr,
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
   MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  type MAX_UNENCRYPTED_LOGS_PER_TX,
+  type NoteHash,
   type Proof,
   type PublicKernelCircuitPublicInputs,
   PublicKernelTailCircuitPrivateInputs,
-  type SideEffect,
+  SideEffect,
   makeEmptyProof,
   mergeAccumulatedData,
   sortByCounter,
@@ -23,14 +33,14 @@ import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simul
 
 export class TailPhaseManager 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 readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
+    phase: PublicKernelPhase = PublicKernelPhase.TAIL,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
@@ -47,7 +57,8 @@ export class TailPhaseManager extends AbstractPhaseManager {
         throw err;
       },
     );
-
+    // Temporary hack. Should sort them in the tail circuit.
+    this.patchLogsOrdering(tx, previousPublicKernelOutput);
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
@@ -71,13 +82,17 @@ export class TailPhaseManager extends AbstractPhaseManager {
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
   ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
+    // Temporary hack. Should sort them in the tail circuit.
+    previousOutput.end.unencryptedLogsHashes = this.sortLogsHashes<typeof MAX_UNENCRYPTED_LOGS_PER_TX>(
+      previousOutput.end.unencryptedLogsHashes,
+    );
     const [inputs, output] = await this.simulate(previousOutput, previousProof);
 
     // Temporary hack. Should sort them in the tail circuit.
     const noteHashes = mergeAccumulatedData(
-      MAX_NEW_NOTE_HASHES_PER_TX,
       previousOutput.endNonRevertibleData.newNoteHashes,
       previousOutput.end.newNoteHashes,
+      MAX_NEW_NOTE_HASHES_PER_TX,
     );
     output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
 
@@ -88,33 +103,93 @@ export class TailPhaseManager extends AbstractPhaseManager {
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
   ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
+    const inputs = await this.buildPrivateInputs(previousOutput, previousProof);
+    // We take a deep copy (clone) of these to pass to the prover
+    return [inputs.clone(), await this.publicKernel.publicKernelCircuitTail(inputs)];
+  }
+
+  private async buildPrivateInputs(previousOutput: PublicKernelCircuitPublicInputs, previousProof: Proof) {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
 
     const { validationRequests, endNonRevertibleData, end } = previousOutput;
-    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
-      validationRequests.nullifierReadRequests,
+
+    const pendingNullifiers = mergeAccumulatedData(
       endNonRevertibleData.newNullifiers,
       end.newNullifiers,
+      MAX_NEW_NULLIFIERS_PER_TX,
+    );
+
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      validationRequests.nullifierReadRequests,
+      pendingNullifiers,
     );
+
     const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
       validationRequests.nullifierNonExistentReadRequests,
-      endNonRevertibleData.newNullifiers,
-      end.newNullifiers,
+      pendingNullifiers,
     );
 
-    // We take a deep copy (clone) of these to pass to the prover
-    const inputs = new PublicKernelTailCircuitPrivateInputs(
+    const pendingPublicDataWrites = mergeAccumulatedData(
+      endNonRevertibleData.publicDataUpdateRequests,
+      end.publicDataUpdateRequests,
+      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+    );
+
+    const publicDataHints = await this.hintsBuilder.getPublicDataHints(
+      validationRequests.publicDataReads,
+      pendingPublicDataWrites,
+    );
+
+    const publicDataReadRequestHints = this.hintsBuilder.getPublicDataReadRequestHints(
+      validationRequests.publicDataReads,
+      pendingPublicDataWrites,
+      publicDataHints,
+    );
+
+    const currentState = await this.db.getStateReference();
+
+    return new PublicKernelTailCircuitPrivateInputs(
       previousKernel,
       nullifierReadRequestHints,
       nullifierNonExistentReadRequestHints,
+      publicDataHints,
+      publicDataReadRequestHints,
+      currentState.partial,
     );
-    return [inputs.clone(), await this.publicKernel.publicKernelCircuitTail(inputs)];
   }
 
-  private sortNoteHashes<N extends number>(noteHashes: Tuple<SideEffect, N>): Tuple<Fr, N> {
-    return sortByCounter(noteHashes.map(n => ({ ...n, counter: n.counter.toNumber() }))).map(n => n.value) as Tuple<
-      Fr,
-      N
-    >;
+  private sortNoteHashes<N extends number>(noteHashes: Tuple<NoteHash, N>): Tuple<Fr, N> {
+    return sortByCounter(noteHashes).map(n => n.value) as Tuple<Fr, N>;
+  }
+
+  private sortLogsHashes<N extends number>(unencryptedLogsHashes: Tuple<SideEffect, N>): Tuple<SideEffect, N> {
+    return sortByCounter(
+      unencryptedLogsHashes.map(n => ({ ...n, counter: n.counter.toNumber(), isEmpty: () => n.isEmpty() })),
+    ).map(h => new SideEffect(h.value, new Fr(h.counter))) as Tuple<SideEffect, N>;
+  }
+
+  // As above, this is a hack for unencrypted logs ordering, now they are sorted. Since the public kernel
+  // cannot keep track of side effects that happen after or before a nested call, we override the gathered logs.
+  // As a sanity check, we at least verify that the elements are the same, so we are only tweaking their ordering.
+  // See same fn in pxe_service.ts
+  // Added as part of resolving #5017
+  private patchLogsOrdering(tx: Tx, publicInputs: PublicKernelCircuitPublicInputs) {
+    const unencLogs = tx.unencryptedLogs.unrollLogs();
+    const sortedUnencLogs = publicInputs.end.unencryptedLogsHashes;
+
+    const finalUnencLogs: UnencryptedL2Log[] = [];
+    sortedUnencLogs.forEach((sideEffect: SideEffect) => {
+      if (!sideEffect.isEmpty()) {
+        const isLog = (log: UnencryptedL2Log) => Fr.fromBuffer(log.hash()).equals(sideEffect.value);
+        const thisLogIndex = unencLogs.findIndex(isLog);
+        finalUnencLogs.push(unencLogs[thisLogIndex]);
+      }
+    });
+    const unencryptedLogs = new UnencryptedFunctionL2Logs(finalUnencLogs);
+
+    tx.unencryptedLogs.functionLogs[0] = unencryptedLogs;
+    for (let i = 1; i < tx.unencryptedLogs.functionLogs.length; i++) {
+      tx.unencryptedLogs.functionLogs[i] = UnencryptedFunctionL2Logs.empty();
+    }
   }
 }

package/src/public/teardown_phase_manager.ts

@@ -1,5 +1,7 @@
 import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
 import {
+  type Fr,
+  type Gas,
   type GlobalVariables,
   type Header,
   type Proof,
@@ -8,6 +10,8 @@ import {
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
+import { inspect } from 'util';
+
 import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 import { type ContractsDataSourcePublicDB } from './public_executor.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
@@ -17,14 +21,14 @@ import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simul
  */
 export class TeardownPhaseManager 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.TEARDOWN,
+    phase: PublicKernelPhase = PublicKernelPhase.TEARDOWN,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
@@ -63,4 +67,18 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
       returnValues: undefined,
     };
   }
+
+  protected override getTransactionFee(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs): Fr {
+    const gasSettings = tx.data.constants.txContext.gasSettings;
+    const gasFees = this.globalVariables.gasFees;
+    // No need to add teardown limits since they are already included in end.gasUsed
+    const gasUsed = previousPublicKernelOutput.end.gasUsed.add(previousPublicKernelOutput.endNonRevertibleData.gasUsed);
+    const txFee = gasSettings.inclusionFee.add(gasUsed.computeFee(gasFees));
+    this.log.debug(`Computed tx fee`, { txFee, gasUsed: inspect(gasUsed), gasFees: inspect(gasFees) });
+    return txFee;
+  }
+
+  protected override getAvailableGas(tx: Tx, _previousPublicKernelOutput: PublicKernelCircuitPublicInputs): Gas {
+    return tx.data.constants.txContext.gasSettings.getTeardownLimits();
+  }
 }

package/src/public/transitional_adaptors.ts

@@ -6,12 +6,14 @@ import {
   ContractStorageUpdateRequest,
   FunctionData,
   Gas,
+  type GasSettings,
   type GlobalVariables,
   type Header,
   L2ToL1Message,
+  NoteHash,
+  Nullifier,
   ReadRequest,
   SideEffect,
-  SideEffectLinkedToNoteHash,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -37,14 +39,13 @@ export function createAvmExecutionEnvironment(
   current: PublicExecution,
   header: Header,
   globalVariables: GlobalVariables,
+  gasSettings: GasSettings,
+  transactionFee: Fr,
 ): AvmExecutionEnvironment {
   return new AvmExecutionEnvironment(
     current.contractAddress,
     current.callContext.storageContractAddress,
-    current.callContext.msgSender, // TODO: origin is not available
     current.callContext.msgSender,
-    current.callContext.portalContractAddress,
-    globalVariables.gasFees.feePerL1Gas,
     globalVariables.gasFees.feePerL2Gas,
     globalVariables.gasFees.feePerDaGas,
     /*contractCallDepth=*/ Fr.zero(),
@@ -53,8 +54,8 @@ export function createAvmExecutionEnvironment(
     current.callContext.isStaticCall,
     current.callContext.isDelegateCall,
     current.args,
-    current.callContext.gasSettings,
-    current.callContext.transactionFee,
+    gasSettings,
+    transactionFee,
     current.functionData.selector,
   );
 }
@@ -64,14 +65,10 @@ export function createPublicExecutionContext(avmContext: AvmContext, calldata: F
   const callContext = CallContext.from({
     msgSender: avmContext.environment.sender,
     storageContractAddress: avmContext.environment.storageAddress,
-    portalContractAddress: avmContext.environment.portal,
     functionSelector: avmContext.environment.temporaryFunctionSelector,
-    gasLeft: Gas.from(avmContext.machineState.gasLeft),
     isDelegateCall: avmContext.environment.isDelegateCall,
     isStaticCall: avmContext.environment.isStaticCall,
     sideEffectCounter: sideEffectCounter,
-    gasSettings: avmContext.environment.gasSettings,
-    transactionFee: avmContext.environment.transactionFee,
   });
   const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
   const execution: PublicExecution = {
@@ -91,6 +88,9 @@ export function createPublicExecutionContext(avmContext: AvmContext, calldata: F
     avmContext.persistableState.hostStorage.publicStateDb,
     avmContext.persistableState.hostStorage.contractsDb,
     avmContext.persistableState.hostStorage.commitmentsDb,
+    Gas.from(avmContext.machineState.gasLeft),
+    avmContext.environment.transactionFee,
+    avmContext.environment.gasSettings,
   );
 
   return context;
@@ -113,10 +113,10 @@ export async function convertAvmResults(
   const execution = executionContext.execution;
 
   const contractStorageReads: ContractStorageRead[] = newWorldState.storageReads.map(
-    read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber()),
+    read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber(), read.storageAddress),
   );
   const contractStorageUpdateRequests: ContractStorageUpdateRequest[] = newWorldState.storageWrites.map(
-    write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber()),
+    write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber(), write.storageAddress),
   );
   // We need to write the storage updates to the DB, because that's what the ACVM expects.
   // Assumes the updates are in the right order.
@@ -125,7 +125,7 @@ export async function convertAvmResults(
   }
 
   const newNoteHashes = newWorldState.newNoteHashes.map(
-    noteHash => new SideEffect(noteHash.noteHash, noteHash.counter),
+    noteHash => new NoteHash(noteHash.noteHash, noteHash.counter.toNumber()),
   );
   const nullifierReadRequests: ReadRequest[] = newWorldState.nullifierChecks
     .filter(nullifierCheck => nullifierCheck.exists)
@@ -133,17 +133,20 @@ export async function convertAvmResults(
   const nullifierNonExistentReadRequests: ReadRequest[] = newWorldState.nullifierChecks
     .filter(nullifierCheck => !nullifierCheck.exists)
     .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
-  const newNullifiers: SideEffectLinkedToNoteHash[] = newWorldState.newNullifiers.map(
+  const newNullifiers: Nullifier[] = newWorldState.newNullifiers.map(
     tracedNullifier =>
-      new SideEffectLinkedToNoteHash(
+      new Nullifier(
         /*value=*/ tracedNullifier.nullifier,
+        tracedNullifier.counter.toNumber(),
         /*noteHash=*/ Fr.ZERO, // NEEDED?
-        tracedNullifier.counter,
       ),
   );
   const unencryptedLogs: UnencryptedFunctionL2Logs = new UnencryptedFunctionL2Logs(
     newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)),
   );
+  const unencryptedLogsHashes = newWorldState.newLogsHashes.map(
+    logHash => new SideEffect(logHash.logHash, logHash.counter),
+  );
   const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
 
   const returnValues = result.output;
@@ -167,10 +170,13 @@ export async function convertAvmResults(
     contractStorageUpdateRequests,
     returnValues,
     nestedExecutions,
+    unencryptedLogsHashes,
     unencryptedLogs,
     reverted: result.reverted,
     revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
-    gasLeft: endMachineState.gasLeft,
+    startGasLeft: executionContext.availableGas,
+    endGasLeft: endMachineState.gasLeft,
+    transactionFee: executionContext.transactionFee,
   };
 }
 
@@ -211,7 +217,7 @@ export function updateAvmContextFromPublicExecutionResult(ctx: AvmContext, resul
     ctx.persistableState.trace.newNullifiers.push({
       storageAddress: ctx.environment.storageAddress,
       nullifier: nullifier.value,
-      counter: nullifier.counter,
+      counter: new Fr(nullifier.counter),
     });
   }
 
@@ -219,7 +225,7 @@ export function updateAvmContextFromPublicExecutionResult(ctx: AvmContext, resul
     ctx.persistableState.trace.newNoteHashes.push({
       storageAddress: ctx.environment.storageAddress,
       noteHash: noteHash.value,
-      counter: noteHash.counter,
+      counter: new Fr(noteHash.counter),
     });
   }
 

package/src/public/utils.ts

@@ -14,6 +14,7 @@ export function lastSideEffectCounter(tx: Tx): number {
     ...data.endNonRevertibleData.publicCallStack,
     ...data.end.newNoteHashes,
     ...data.end.newNullifiers,
+    ...data.end.unencryptedLogsHashes,
     ...data.end.publicCallStack,
   ];
 
@@ -23,7 +24,8 @@ export function lastSideEffectCounter(tx: Tx): number {
       // look at both start and end counters because for enqueued public calls start > 0 while end === 0
       max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
     } else {
-      max = Math.max(max, sideEffect.counter.toNumber());
+      const counter = typeof sideEffect.counter === 'number' ? sideEffect.counter : sideEffect.counter.toNumber();
+      max = Math.max(max, counter);
     }
   }
 

package/src/test/utils.ts

@@ -1,6 +1,6 @@
 import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/circuit-types';
 import { type AztecAddress, EthAddress, type Fr } from '@aztec/circuits.js';
-import { computeMessageSecretHash } from '@aztec/circuits.js/hash';
+import { computeSecretHash } from '@aztec/circuits.js/hash';
 import { sha256ToField } from '@aztec/foundation/crypto';
 
 /**
@@ -21,9 +21,7 @@ export const buildL1ToL2Message = (
   const selectorBuf = Buffer.from(selector, 'hex');
 
   const content = sha256ToField([selectorBuf, ...contentPreimage]);
-  const secretHash = computeMessageSecretHash(secret);
+  const secretHash = computeSecretHash(secret);
 
-  // Eventually the kernel will need to prove the kernel portal pair exists within the contract tree,
-  // EthAddress.random() will need to be replaced when this happens
   return new L1ToL2Message(new L1Actor(EthAddress.random(), 1), new L2Actor(targetContract, 1), content, secretHash);
 };