@aztec/simulator 0.65.2 → 0.66.0

package/src/public/public_db_sources.ts

@@ -9,9 +9,7 @@ import { type PublicDBAccessStats } from '@aztec/circuit-types/stats';
 import {
   type AztecAddress,
   type ContractClassPublic,
-  ContractClassRegisteredEvent,
   type ContractDataSource,
-  ContractInstanceDeployedEvent,
   type ContractInstanceWithAddress,
   Fr,
   type FunctionSelector,
@@ -24,7 +22,7 @@ import {
 import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent, ContractInstanceDeployedEvent } from '@aztec/protocol-contracts';
 import {
   type CommitmentsDB,
   MessageLoadOracleInputs,
@@ -51,13 +49,20 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   public addNewContracts(tx: Tx): Promise<void> {
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.contractClassLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, ProtocolContractAddress.ContractClassRegisterer).forEach(e => {
-      this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
-      this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
-    });
-    // We store the contract instance deployed event log in enc logs, contract_instance_deployer_contract/src/main.nr
-    const encLogs = tx.encryptedLogs.unrollLogs();
-    ContractInstanceDeployedEvent.fromLogs(encLogs).forEach(e => {
+    logs
+      .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
+      .forEach(log => {
+        const event = ContractClassRegisteredEvent.fromLog(log.data);
+        this.log.debug(`Adding class ${event.contractClassId.toString()} to public execution contract cache`);
+        this.classCache.set(event.contractClassId.toString(), event.toContractClassPublic());
+      });
+
+    // We store the contract instance deployed event log in private logs, contract_instance_deployer_contract/src/main.nr
+    const contractInstanceEvents = tx.data
+      .getNonEmptyPrivateLogs()
+      .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
+      .map(ContractInstanceDeployedEvent.fromLog);
+    contractInstanceEvents.forEach(e => {
       this.log.debug(
         `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
       );
@@ -76,12 +81,20 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?
     const logs = tx.contractClassLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, ProtocolContractAddress.ContractClassRegisterer).forEach(e =>
-      this.classCache.delete(e.contractClassId.toString()),
-    );
-    // We store the contract instance deployed event log in enc logs, contract_instance_deployer_contract/src/main.nr
-    const encLogs = tx.encryptedLogs.unrollLogs();
-    ContractInstanceDeployedEvent.fromLogs(encLogs).forEach(e => this.instanceCache.delete(e.address.toString()));
+    logs
+      .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
+      .forEach(log => {
+        const event = ContractClassRegisteredEvent.fromLog(log.data);
+        this.classCache.delete(event.contractClassId.toString());
+      });
+
+    // We store the contract instance deployed event log in private logs, contract_instance_deployer_contract/src/main.nr
+    const contractInstanceEvents = tx.data
+      .getNonEmptyPrivateLogs()
+      .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
+      .map(ContractInstanceDeployedEvent.fromLog);
+    contractInstanceEvents.forEach(e => this.instanceCache.delete(e.address.toString()));
+
     return Promise.resolve();
   }
 

package/src/public/public_processor.ts

@@ -13,7 +13,6 @@ import {
 } from '@aztec/circuit-types';
 import {
   type AztecAddress,
-  ContractClassRegisteredEvent,
   type ContractDataSource,
   Fr,
   type GlobalVariables,
@@ -26,7 +25,7 @@ import {
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent, ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
@@ -167,10 +166,9 @@ export class PublicProcessor {
           }
         }
 
-        await this.db.batchInsert(
+        await this.db.sequentialInsert(
           MerkleTreeId.PUBLIC_DATA_TREE,
           processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
-          0,
         );
         result.push(processedTx);
         returns = returns.concat(returnValues ?? []);
@@ -275,10 +273,10 @@ export class PublicProcessor {
     });
 
     this.metrics.recordClassRegistration(
-      ...ContractClassRegisteredEvent.fromLogs(
-        tx.contractClassLogs.unrollLogs(),
-        ProtocolContractAddress.ContractClassRegisterer,
-      ),
+      ...tx.contractClassLogs
+        .unrollLogs()
+        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
+        .map(log => ContractClassRegisteredEvent.fromLog(log.data)),
     );
 
     const phaseCount = processedPhases.length;

package/src/public/public_processor_metrics.ts

@@ -1,5 +1,5 @@
 import { type TxExecutionPhase } from '@aztec/circuit-types';
-import { type ContractClassRegisteredEvent } from '@aztec/circuits.js';
+import { type ContractClassRegisteredEvent } from '@aztec/protocol-contracts';
 import {
   Attributes,
   type Histogram,

package/src/public/public_tx_context.ts

@@ -2,6 +2,7 @@ import {
   type AvmProvingRequest,
   MerkleTreeId,
   type MerkleTreeReadOperations,
+  ProvingRequestType,
   type PublicExecutionRequest,
   type SimulationError,
   type Tx,
@@ -9,16 +10,19 @@ import {
   TxHash,
 } from '@aztec/circuit-types';
 import {
+  AppendOnlyTreeSnapshot,
+  AvmCircuitInputs,
   type AvmCircuitPublicInputs,
   Fr,
   Gas,
   type GasSettings,
   type GlobalVariables,
-  type Header,
   type PrivateToPublicAccumulatedData,
   type PublicCallRequest,
+  PublicCircuitPublicInputs,
   RevertCode,
   type StateReference,
+  TreeSnapshots,
   countAccumulatedItems,
 } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
@@ -26,13 +30,12 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
-import { type AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { AvmPersistableStateManager } from '../avm/index.js';
 import { DualSideEffectTrace } from './dual_side_effect_trace.js';
 import { PublicEnqueuedCallSideEffectTrace, SideEffectArrayLengths } from './enqueued_call_side_effect_trace.js';
 import { type WorldStateDB } from './public_db_sources.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
-import { generateAvmCircuitPublicInputs, generateAvmProvingRequest } from './transitional_adapters.js';
+import { generateAvmCircuitPublicInputs } from './transitional_adapters.js';
 import { getCallRequestsByPhase, getExecutionRequestsByPhase } from './utils.js';
 
 /**
@@ -58,7 +61,6 @@ export class PublicTxContext {
   constructor(
     public readonly state: PhaseStateManager,
     private readonly globalVariables: GlobalVariables,
-    private readonly historicalHeader: Header, // FIXME(dbanks12): remove
     private readonly startStateReference: StateReference,
     private readonly startGasUsed: Gas,
     private readonly gasSettings: GasSettings,
@@ -89,7 +91,7 @@ export class PublicTxContext {
     const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
       /*publicDataWrites*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.noteHashes),
-      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.nullifiers),
+      /*nullifiers=*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
       /*unencryptedLogsHashes*/ 0,
     );
@@ -105,7 +107,6 @@ export class PublicTxContext {
     return new PublicTxContext(
       new PhaseStateManager(txStateManager),
       globalVariables,
-      tx.data.constants.historicalHeader,
       await db.getStateReference(),
       tx.data.gasUsed,
       tx.data.constants.txContext.gasSettings,
@@ -301,11 +302,24 @@ export class PublicTxContext {
    */
   private generateAvmCircuitPublicInputs(endStateReference: StateReference): AvmCircuitPublicInputs {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
-    // TODO(dbanks12): use the state roots from ephemeral trees
-    endStateReference.partial.nullifierTree.root = this.state
-      .getActiveStateManager()
-      .merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!
-      .getRoot();
+    const ephemeralTrees = this.state.getActiveStateManager().merkleTrees.treeMap;
+
+    const getAppendSnaphot = (id: MerkleTreeId) => {
+      const tree = ephemeralTrees.get(id)!;
+      return new AppendOnlyTreeSnapshot(tree.getRoot(), Number(tree.leafCount));
+    };
+
+    const noteHashTree = getAppendSnaphot(MerkleTreeId.NOTE_HASH_TREE);
+    const nullifierTree = getAppendSnaphot(MerkleTreeId.NULLIFIER_TREE);
+    const publicDataTree = getAppendSnaphot(MerkleTreeId.PUBLIC_DATA_TREE);
+
+    const endTreeSnapshots = new TreeSnapshots(
+      endStateReference.l1ToL2MessageTree,
+      noteHashTree,
+      nullifierTree,
+      publicDataTree,
+    );
+
     return generateAvmCircuitPublicInputs(
       this.trace,
       this.globalVariables,
@@ -317,7 +331,7 @@ export class PublicTxContext {
       this.teardownCallRequests,
       this.nonRevertibleAccumulatedDataFromPrivate,
       this.revertibleAccumulatedDataFromPrivate,
-      endStateReference,
+      endTreeSnapshots,
       /*endGasUsed=*/ this.gasUsed,
       this.getTransactionFeeUnsafe(),
       this.revertCode,
@@ -328,38 +342,17 @@ export class PublicTxContext {
    * Generate the proving request for the AVM circuit.
    */
   generateProvingRequest(endStateReference: StateReference): AvmProvingRequest {
-    // TODO(dbanks12): Once we actually have tx-level proving, this will generate the entire
-    // proving request for the first time
-    this.avmProvingRequest!.inputs.output = this.generateAvmCircuitPublicInputs(endStateReference);
-    return this.avmProvingRequest!;
-  }
-
-  // TODO(dbanks12): remove once AVM proves entire public tx
-  updateProvingRequest(
-    real: boolean,
-    phase: TxExecutionPhase,
-    fnName: string,
-    stateManager: AvmPersistableStateManager,
-    executionRequest: PublicExecutionRequest,
-    result: AvmFinalizedCallResult,
-    allocatedGas: Gas,
-  ) {
-    if (this.avmProvingRequest === undefined) {
-      // Propagate the very first avmProvingRequest of the tx for now.
-      // Eventually this will be the proof for the entire public portion of the transaction.
-      this.avmProvingRequest = generateAvmProvingRequest(
-        real,
-        fnName,
-        stateManager,
-        this.historicalHeader,
-        this.globalVariables,
-        executionRequest,
-        // TODO(dbanks12): do we need this return type unless we are doing an isolated call?
-        stateManager.trace.toPublicEnqueuedCallExecutionResult(result),
-        allocatedGas,
-        this.getTransactionFee(phase),
-      );
-    }
+    const hints = this.trace.getAvmCircuitHints();
+    return {
+      type: ProvingRequestType.PUBLIC_VM,
+      inputs: new AvmCircuitInputs(
+        'public_dispatch',
+        [],
+        PublicCircuitPublicInputs.empty(),
+        hints,
+        this.generateAvmCircuitPublicInputs(endStateReference),
+      ),
+    };
   }
 }
 

package/src/public/public_tx_simulator.ts

@@ -290,17 +290,6 @@ export class PublicTxSimulator {
       `[AVM] Enqueued public call consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`,
     );
 
-    // TODO(dbanks12): remove once AVM proves entire public tx
-    context.updateProvingRequest(
-      this.realAvmProvingRequests,
-      phase,
-      fnName,
-      stateManager,
-      executionRequest,
-      result,
-      allocatedGas,
-    );
-
     stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);
 
     if (result.reverted) {

package/src/public/side_effect_trace.ts

@@ -138,7 +138,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     );
 
     // New hinting
-    this.avmCircuitHints.storageReadRequest.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
+    this.avmCircuitHints.publicDataReads.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
 
     this.log.debug(`SLOAD cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
@@ -168,7 +168,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 
     // New hinting
     const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.storageUpdateRequest.items.push(
+    this.avmCircuitHints.publicDataWrites.items.push(
       new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath),
     );
     this.log.debug(`SSTORE cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
@@ -193,7 +193,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       new AvmKeyValueHint(/*key=*/ new Fr(leafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
     );
     // New Hinting
-    this.avmCircuitHints.noteHashReadRequest.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    this.avmCircuitHints.noteHashReads.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
@@ -210,7 +210,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.log.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
 
     // New Hinting
-    this.avmCircuitHints.noteHashWriteRequest.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    this.avmCircuitHints.noteHashWrites.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.incrementSideEffectCounter();
   }
 
@@ -237,7 +237,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     );
 
     // New Hints
-    this.avmCircuitHints.nullifierReadRequest.items.push(
+    this.avmCircuitHints.nullifierReads.items.push(
       new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath),
     );
     this.log.debug(`NULLIFIER_EXISTS cnt: ${this.sideEffectCounter}`);
@@ -259,7 +259,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
     // New hinting
     const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.nullifierWriteHints.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
+    this.avmCircuitHints.nullifierWrites.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
@@ -282,7 +282,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     );
 
     // New Hinting
-    this.avmCircuitHints.l1ToL2MessageReadRequest.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
+    this.avmCircuitHints.l1ToL2MessageReads.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
     // NOTE: counter does not increment for l1tol2 message checks (because it doesn't rely on pending messages)
   }
 

package/src/public/transitional_adapters.ts

@@ -1,57 +1,28 @@
-import { type AvmProvingRequest, ProvingRequestType, type PublicExecutionRequest } from '@aztec/circuit-types';
 import {
-  AvmCircuitInputs,
-  AvmCircuitPublicInputs,
-  AztecAddress,
-  ContractStorageRead,
-  ContractStorageUpdateRequest,
-  Fr,
-  Gas,
+  type AvmCircuitPublicInputs,
+  type Fr,
+  type Gas,
   type GasSettings,
   type GlobalVariables,
-  type Header,
-  L2ToL1Message,
-  LogHash,
-  MAX_ENQUEUED_CALLS_PER_CALL,
-  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
-  MAX_L2_TO_L1_MSGS_PER_CALL,
   MAX_L2_TO_L1_MSGS_PER_TX,
-  MAX_NOTE_HASHES_PER_CALL,
   MAX_NOTE_HASHES_PER_TX,
-  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
-  MAX_NULLIFIERS_PER_CALL,
-  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
-  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
-  MAX_PUBLIC_DATA_READS_PER_CALL,
-  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MAX_UNENCRYPTED_LOGS_PER_CALL,
-  NoteHash,
-  Nullifier,
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
   type PrivateToPublicAccumulatedData,
   PublicCallRequest,
-  PublicCircuitPublicInputs,
   PublicDataWrite,
-  PublicInnerCallRequest,
-  ReadRequest,
-  RevertCode,
+  type RevertCode,
   type StateReference,
-  TreeLeafReadRequest,
   TreeSnapshots,
   countAccumulatedItems,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
-import { computeNoteHashNonce, computeUniqueNoteHash, computeVarArgsHash, siloNoteHash } from '@aztec/circuits.js/hash';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { assertLength } from '@aztec/foundation/serialize';
 
-import { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
-import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmPersistableStateManager } from '../avm/journal/journal.js';
 import { type PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
-import { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
 
 export function generateAvmCircuitPublicInputs(
   trace: PublicEnqueuedCallSideEffectTrace,
@@ -64,7 +35,7 @@ export function generateAvmCircuitPublicInputs(
   teardownCallRequests: PublicCallRequest[],
   nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
   revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
-  endStateReference: StateReference,
+  endTreeSnapshots: TreeSnapshots,
   endGasUsed: Gas,
   transactionFee: Fr,
   revertCode: RevertCode,
@@ -75,12 +46,6 @@ export function generateAvmCircuitPublicInputs(
     startStateReference.partial.nullifierTree,
     startStateReference.partial.publicDataTree,
   );
-  const endTreeSnapshots = new TreeSnapshots(
-    endStateReference.l1ToL2MessageTree,
-    endStateReference.partial.noteHashTree,
-    endStateReference.partial.nullifierTree,
-    endStateReference.partial.publicDataTree,
-  );
 
   const avmCircuitPublicInputs = trace.toAvmCircuitPublicInputs(
     globalVariables,
@@ -182,155 +147,3 @@ export function generateAvmCircuitPublicInputs(
   //console.log(`AvmCircuitPublicInputs:\n${inspect(avmCircuitPublicInputs)}`);
   return avmCircuitPublicInputs;
 }
-
-export function generateAvmProvingRequest(
-  real: boolean,
-  fnName: string,
-  stateManager: AvmPersistableStateManager,
-  historicalHeader: Header,
-  globalVariables: GlobalVariables,
-  executionRequest: PublicExecutionRequest,
-  result: EnqueuedPublicCallExecutionResult,
-  allocatedGas: Gas,
-  transactionFee: Fr,
-): AvmProvingRequest {
-  const avmExecutionEnv = new AvmExecutionEnvironment(
-    executionRequest.callContext.contractAddress,
-    executionRequest.callContext.msgSender,
-    executionRequest.callContext.functionSelector,
-    /*contractCallDepth=*/ Fr.zero(),
-    transactionFee,
-    globalVariables,
-    executionRequest.callContext.isStaticCall,
-    executionRequest.args,
-  );
-
-  const avmCallResult = new AvmFinalizedCallResult(result.reverted, result.returnValues, result.endGasLeft);
-
-  // Generate an AVM proving request
-  let avmProvingRequest: AvmProvingRequest;
-  if (real) {
-    const deprecatedFunctionCallResult = stateManager.trace.toPublicFunctionCallResult(
-      avmExecutionEnv,
-      /*startGasLeft=*/ allocatedGas,
-      Buffer.alloc(0),
-      avmCallResult,
-      fnName,
-    );
-    const publicInputs = getPublicCircuitPublicInputs(historicalHeader, globalVariables, deprecatedFunctionCallResult);
-    avmProvingRequest = makeAvmProvingRequest(publicInputs, deprecatedFunctionCallResult);
-  } else {
-    avmProvingRequest = emptyAvmProvingRequest();
-  }
-  return avmProvingRequest;
-}
-
-function emptyAvmProvingRequest(): AvmProvingRequest {
-  return {
-    type: ProvingRequestType.PUBLIC_VM,
-    inputs: AvmCircuitInputs.empty(),
-  };
-}
-function makeAvmProvingRequest(inputs: PublicCircuitPublicInputs, result: PublicFunctionCallResult): AvmProvingRequest {
-  return {
-    type: ProvingRequestType.PUBLIC_VM,
-    inputs: new AvmCircuitInputs(
-      result.functionName,
-      result.calldata,
-      inputs,
-      result.avmCircuitHints,
-      AvmCircuitPublicInputs.empty(),
-    ),
-  };
-}
-
-function getPublicCircuitPublicInputs(
-  historicalHeader: Header,
-  globalVariables: GlobalVariables,
-  result: PublicFunctionCallResult,
-) {
-  const header = historicalHeader.clone(); // don't modify the original
-  header.state.partial.publicDataTree.root = Fr.zero(); // AVM doesn't check this yet
-
-  return PublicCircuitPublicInputs.from({
-    callContext: result.executionRequest.callContext,
-    proverAddress: AztecAddress.ZERO,
-    argsHash: computeVarArgsHash(result.executionRequest.args),
-    noteHashes: padArrayEnd(
-      result.noteHashes,
-      NoteHash.empty(),
-      MAX_NOTE_HASHES_PER_CALL,
-      `Too many note hashes. Got ${result.noteHashes.length} with max being ${MAX_NOTE_HASHES_PER_CALL}`,
-    ),
-    nullifiers: padArrayEnd(
-      result.nullifiers,
-      Nullifier.empty(),
-      MAX_NULLIFIERS_PER_CALL,
-      `Too many nullifiers. Got ${result.nullifiers.length} with max being ${MAX_NULLIFIERS_PER_CALL}`,
-    ),
-    l2ToL1Msgs: padArrayEnd(
-      result.l2ToL1Messages,
-      L2ToL1Message.empty(),
-      MAX_L2_TO_L1_MSGS_PER_CALL,
-      `Too many L2 to L1 messages. Got ${result.l2ToL1Messages.length} with max being ${MAX_L2_TO_L1_MSGS_PER_CALL}`,
-    ),
-    startSideEffectCounter: result.startSideEffectCounter,
-    endSideEffectCounter: result.endSideEffectCounter,
-    returnsHash: computeVarArgsHash(result.returnValues),
-    noteHashReadRequests: padArrayEnd(
-      result.noteHashReadRequests,
-      TreeLeafReadRequest.empty(),
-      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
-      `Too many note hash read requests. Got ${result.noteHashReadRequests.length} with max being ${MAX_NOTE_HASH_READ_REQUESTS_PER_CALL}`,
-    ),
-    nullifierReadRequests: padArrayEnd(
-      result.nullifierReadRequests,
-      ReadRequest.empty(),
-      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
-      `Too many nullifier read requests. Got ${result.nullifierReadRequests.length} with max being ${MAX_NULLIFIER_READ_REQUESTS_PER_CALL}`,
-    ),
-    nullifierNonExistentReadRequests: padArrayEnd(
-      result.nullifierNonExistentReadRequests,
-      ReadRequest.empty(),
-      MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
-      `Too many nullifier non-existent read requests. Got ${result.nullifierNonExistentReadRequests.length} with max being ${MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL}`,
-    ),
-    l1ToL2MsgReadRequests: padArrayEnd(
-      result.l1ToL2MsgReadRequests,
-      TreeLeafReadRequest.empty(),
-      MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
-      `Too many L1 to L2 message read requests. Got ${result.l1ToL2MsgReadRequests.length} with max being ${MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL}`,
-    ),
-    contractStorageReads: padArrayEnd(
-      result.contractStorageReads,
-      ContractStorageRead.empty(),
-      MAX_PUBLIC_DATA_READS_PER_CALL,
-      `Too many public data reads. Got ${result.contractStorageReads.length} with max being ${MAX_PUBLIC_DATA_READS_PER_CALL}`,
-    ),
-    contractStorageUpdateRequests: padArrayEnd(
-      result.contractStorageUpdateRequests,
-      ContractStorageUpdateRequest.empty(),
-      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-      `Too many public data update requests. Got ${result.contractStorageUpdateRequests.length} with max being ${MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL}`,
-    ),
-    publicCallRequests: padArrayEnd(
-      result.publicCallRequests,
-      PublicInnerCallRequest.empty(),
-      MAX_ENQUEUED_CALLS_PER_CALL,
-      `Too many public call requests. Got ${result.publicCallRequests.length} with max being ${MAX_ENQUEUED_CALLS_PER_CALL}`,
-    ),
-    unencryptedLogsHashes: padArrayEnd(
-      result.unencryptedLogsHashes,
-      LogHash.empty(),
-      MAX_UNENCRYPTED_LOGS_PER_CALL,
-      `Too many unencrypted logs. Got ${result.unencryptedLogsHashes.length} with max being ${MAX_UNENCRYPTED_LOGS_PER_CALL}`,
-    ),
-    historicalHeader: header,
-    globalVariables: 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.APP_LOGIC_REVERTED : RevertCode.OK,
-  });
-}