@aztec/simulator 0.47.0 → 0.47.1

package/src/public/abstract_phase_manager.ts

@@ -3,6 +3,7 @@ import {
   type AvmProvingRequest,
   MerkleTreeId,
   type NestedProcessReturnValues,
+  type PublicExecutionRequest,
   type PublicKernelNonTailRequest,
   PublicKernelType,
   type PublicProvingRequest,
@@ -13,7 +14,6 @@ import {
 import {
   type AvmExecutionHints,
   AztecAddress,
-  CallRequest,
   ClientIvcProof,
   ContractStorageRead,
   ContractStorageUpdateRequest,
@@ -40,7 +40,7 @@ import {
   NoteHash,
   Nullifier,
   PublicCallData,
-  type PublicCallRequest,
+  PublicCallRequest,
   PublicCallStackItem,
   PublicCircuitPublicInputs,
   PublicKernelCircuitPrivateInputs,
@@ -62,7 +62,6 @@ import {
   getVKSiblingPath,
 } from '@aztec/noir-protocol-circuits-types';
 import {
-  type PublicExecutionRequest,
   type PublicExecutionResult,
   type PublicExecutor,
   accumulateReturnValues,
@@ -165,76 +164,18 @@ export abstract class AbstractPhaseManager {
     previousKernelArtifact: ProtocolArtifact,
   ): Promise<PhaseResult>;
 
-  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicCallRequest[]> {
-    const data = tx.data.forPublic;
-    if (!data) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: [],
-        [PublicKernelType.TAIL]: [],
-      };
-    }
-    const publicCallsStack = tx.enqueuedPublicFunctionCalls.slice().reverse();
-    const nonRevertibleCallStack = data.endNonRevertibleData.publicCallStack.filter(i => !i.isEmpty());
-    const revertibleCallStack = data.end.publicCallStack.filter(i => !i.isEmpty());
-
-    const callRequestsStack = publicCallsStack
-      .map(call => call.toCallRequest())
-      .filter(
-        // filter out enqueued calls that are not in the public call stack
-        // TODO mitch left a question about whether this is only needed when unit testing
-        // with mock data
-        call => revertibleCallStack.find(p => p.equals(call)) || nonRevertibleCallStack.find(p => p.equals(call)),
-      );
-
-    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
-
-    if (callRequestsStack.length === 0) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    }
-
-    // find the first call that is revertible
-    const firstRevertibleCallIndex = callRequestsStack.findIndex(
-      c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
-    );
-
-    if (firstRevertibleCallIndex === 0) {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: [],
-        [PublicKernelType.APP_LOGIC]: publicCallsStack,
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    } else if (firstRevertibleCallIndex === -1) {
-      // there's no app logic, split the functions between setup (many) and teardown (just one function call)
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: publicCallsStack,
-        [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    } else {
-      return {
-        [PublicKernelType.NON_PUBLIC]: [],
-        [PublicKernelType.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
-        [PublicKernelType.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
-        [PublicKernelType.TEARDOWN]: teardownCallStack,
-        [PublicKernelType.TAIL]: [],
-      };
-    }
+  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicExecutionRequest[]> {
+    const teardownRequest = tx.getPublicTeardownExecutionRequest();
+    return {
+      [PublicKernelType.NON_PUBLIC]: [],
+      [PublicKernelType.SETUP]: tx.getNonRevertiblePublicExecutionRequests(),
+      [PublicKernelType.APP_LOGIC]: tx.getRevertiblePublicExecutionRequests(),
+      [PublicKernelType.TEARDOWN]: teardownRequest ? [teardownRequest] : [],
+      [PublicKernelType.TAIL]: [],
+    };
   }
 
-  protected extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[] {
+  protected extractEnqueuedPublicCalls(tx: Tx): PublicExecutionRequest[] {
     const calls = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx)[this.phase];
 
     return calls;
@@ -245,7 +186,7 @@ export abstract class AbstractPhaseManager {
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousKernelArtifact: ProtocolArtifact,
   ): Promise<TxPublicCallsResult> {
-    const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
+    const enqueuedCalls = [...this.extractEnqueuedPublicCalls(tx)].reverse();
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
       return {
@@ -299,7 +240,7 @@ export abstract class AbstractPhaseManager {
 
         // Sanity check for a current upstream assumption.
         // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-        const functionSelector = result.executionRequest.functionSelector.toString();
+        const functionSelector = result.executionRequest.callContext.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
             `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
@@ -460,13 +401,6 @@ export abstract class AbstractPhaseManager {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
     this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
 
-    const callStackPreimages = await this.getPublicCallStackPreimages(result);
-    const publicCallStackHashes = padArrayEnd(
-      callStackPreimages.map(c => c.getCompressed().hash()),
-      Fr.ZERO,
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
-    );
-
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
       callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
@@ -507,7 +441,11 @@ export abstract class AbstractPhaseManager {
         ContractStorageUpdateRequest.empty(),
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
       ),
-      publicCallStackHashes,
+      publicCallRequests: padArrayEnd(
+        result.publicCallRequests,
+        PublicCallRequest.empty(),
+        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+      ),
       unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
@@ -520,23 +458,12 @@ export abstract class AbstractPhaseManager {
 
     return new PublicCallStackItem(
       result.executionRequest.contractAddress,
-      new FunctionData(result.executionRequest.functionSelector, false),
+      new FunctionData(result.executionRequest.callContext.functionSelector, false),
       publicCircuitPublicInputs,
       isExecutionRequest,
     );
   }
 
-  protected async getPublicCallStackPreimages(result: PublicExecutionResult): Promise<PublicCallStackItem[]> {
-    const nested = result.nestedExecutions;
-    if (nested.length > MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL) {
-      throw new Error(
-        `Public call stack size exceeded (max ${MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL}, got ${nested.length})`,
-      );
-    }
-
-    return await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
-  }
-
   /**
    * Looks at the side effects of a transaction and returns the highest counter
    * @param tx - A transaction
@@ -562,10 +489,7 @@ export abstract class AbstractPhaseManager {
 
     let max = 0;
     for (const sideEffect of sideEffectCounters) {
-      if ('startSideEffectCounter' in sideEffect) {
-        // 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 if ('counter' in sideEffect) {
+      if ('counter' in sideEffect) {
         max = Math.max(max, sideEffect.counter);
       } else {
         throw new Error('Unknown side effect type');
@@ -593,10 +517,6 @@ export abstract class AbstractPhaseManager {
   protected async getPublicCallData(result: PublicExecutionResult, isExecutionRequest = false) {
     const bytecodeHash = await this.getBytecodeHash(result);
     const callStackItem = await this.getPublicCallStackItem(result, isExecutionRequest);
-    const publicCallRequests = (await this.getPublicCallStackPreimages(result)).map(c =>
-      c.toCallRequest(callStackItem.publicInputs.callContext),
-    );
-    const publicCallStack = padArrayEnd(publicCallRequests, CallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
-    return new PublicCallData(callStackItem, publicCallStack, makeEmptyProof(), bytecodeHash);
+    return new PublicCallData(callStackItem, makeEmptyProof(), bytecodeHash);
   }
 }

package/src/public/execution.ts

@@ -1,18 +1,26 @@
-import { type SimulationError, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
+import {
+  type PublicExecutionRequest,
+  type SimulationError,
+  type UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
 import {
   type AvmExecutionHints,
   type ContractStorageRead,
   type ContractStorageUpdateRequest,
   type Fr,
+  Gas,
   type L2ToL1Message,
   type LogHash,
   type NoteHash,
   type Nullifier,
-  type PublicCallRequest,
+  PublicCallRequest,
+  PublicCallStackItemCompressed,
   type ReadRequest,
+  RevertCode,
 } from '@aztec/circuits.js';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 
-import { type Gas } from '../avm/avm_gas.js';
+import { type Gas as AvmGas } from '../avm/avm_gas.js';
 
 /**
  * The public function execution result.
@@ -26,9 +34,9 @@ export interface PublicExecutionResult {
   /** The side effect counter after executing this function call */
   endSideEffectCounter: Fr;
   /** How much gas was available for this public execution. */
-  startGasLeft: Gas;
+  startGasLeft: AvmGas;
   /** How much gas was left after this public execution. */
-  endGasLeft: Gas;
+  endGasLeft: AvmGas;
   /** Transaction fee set for this tx. */
   transactionFee: Fr;
 
@@ -79,6 +87,8 @@ export interface PublicExecutionResult {
 
   // TODO(dbanks12): add contract instance read requests
 
+  /** The requests to call public functions made by this call. */
+  publicCallRequests: PublicCallRequest[];
   /** The results of nested calls. */
   nestedExecutions: this[];
 
@@ -89,15 +99,6 @@ export interface PublicExecutionResult {
   functionName: string;
 }
 
-/**
- * The execution request of a public function.
- * A subset of PublicCallRequest
- */
-export type PublicExecutionRequest = Pick<
-  PublicCallRequest,
-  'contractAddress' | 'functionSelector' | 'callContext' | 'args'
->;
-
 /**
  * Returns if the input is a public execution result and not just a public execution.
  * @param input - Public execution or public execution result.
@@ -131,3 +132,18 @@ export function checkValidStaticCall(
     throw new Error('Static call cannot update the state, emit L2->L1 messages or generate logs');
   }
 }
+
+export function resultToPublicCallRequest(result: PublicExecutionResult) {
+  const request = result.executionRequest;
+  const item = new PublicCallStackItemCompressed(
+    request.contractAddress,
+    request.callContext,
+    computeVarArgsHash(request.args),
+    computeVarArgsHash(result.returnValues),
+    // TODO(@just-mitch): need better mapping from simulator to revert code.
+    result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
+    Gas.from(result.startGasLeft),
+    Gas.from(result.endGasLeft),
+  );
+  return new PublicCallRequest(item, result.startSideEffectCounter.toNumber());
+}

package/src/public/executor.ts

@@ -1,3 +1,4 @@
+import { type PublicExecutionRequest } from '@aztec/circuit-types';
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
 import { Fr, Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -10,7 +11,7 @@ import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
-import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+import { type PublicExecutionResult } from './execution.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
 
 /**
@@ -47,7 +48,7 @@ export class PublicExecutor {
     startSideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
     const address = executionRequest.contractAddress;
-    const selector = executionRequest.functionSelector;
+    const selector = executionRequest.callContext.functionSelector;
     const fnName = (await this.contractsDb.getDebugFunctionName(address, selector)) ?? `${address}:${selector}`;
 
     PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
@@ -122,7 +123,7 @@ function createAvmExecutionEnvironment(
     executionRequest.contractAddress,
     executionRequest.callContext.storageContractAddress,
     executionRequest.callContext.msgSender,
-    executionRequest.functionSelector,
+    executionRequest.callContext.functionSelector,
     /*contractCallDepth=*/ Fr.zero(),
     transactionFee,
     header,

package/src/public/index.ts

@@ -1,6 +1,6 @@
 export * from './abstract_phase_manager.js';
 export * from './db_interfaces.js';
-export { isPublicExecutionResult, type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+export { isPublicExecutionResult, type PublicExecutionResult } from './execution.js';
 export { PublicExecutor } from './executor.js';
 export * from './fee_payment.js';
 export { HintsBuilder } from './hints_builder.js';

package/src/public/side_effect_trace.ts

@@ -1,4 +1,4 @@
-import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { PublicExecutionRequest, UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
 import {
   AvmContractInstanceHint,
   AvmExecutionHints,
@@ -14,6 +14,7 @@ import {
   LogHash,
   NoteHash,
   Nullifier,
+  type PublicCallRequest,
   ReadRequest,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
@@ -23,7 +24,7 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { createSimulationError } from '../common/errors.js';
-import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+import { type PublicExecutionResult, resultToPublicCallRequest } from './execution.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
 export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
@@ -51,6 +52,8 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private allUnencryptedLogs: UnencryptedL2Log[] = [];
   private unencryptedLogsHashes: LogHash[] = [];
 
+  private publicCallRequests: PublicCallRequest[] = [];
+
   private gotContractInstances: ContractInstanceWithAddress[] = [];
 
   private nestedExecutions: PublicExecutionResult[] = [];
@@ -247,6 +250,9 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       result.startGasLeft.daGas - result.endGasLeft.daGas,
       result.startGasLeft.l2Gas - result.endGasLeft.l2Gas,
     );
+
+    this.publicCallRequests.push(resultToPublicCallRequest(result));
+
     this.avmCircuitHints.externalCalls.items.push(
       new AvmExternalCallHint(
         /*success=*/ new Fr(result.reverted ? 0 : 1),
@@ -305,6 +311,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       // TODO(dbanks12): process contract instance read requests in public kernel
       //gotContractInstances: this.gotContractInstances,
 
+      publicCallRequests: this.publicCallRequests,
       nestedExecutions: this.nestedExecutions,
 
       avmCircuitHints: this.avmCircuitHints,
@@ -325,11 +332,10 @@ function createPublicExecutionRequest(avmEnvironment: AvmExecutionEnvironment):
     isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
   });
-  return {
-    contractAddress: avmEnvironment.address,
-    functionSelector: avmEnvironment.functionSelector,
+  return new PublicExecutionRequest(
+    avmEnvironment.address,
     callContext,
     // execution request does not contain AvmContextInputs prefix
-    args: avmEnvironment.getCalldataWithoutPrefix(),
-  };
+    avmEnvironment.getCalldataWithoutPrefix(),
+  );
 }