@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.17

package/src/{avm → public/avm}/journal/nullifiers.ts

@@ -1,6 +1,6 @@
-import { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
 
-import type { CommitmentsDB } from '../../server.js';
+import type { WorldStateDB } from '../../public_db_sources.js';
 
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
@@ -10,7 +10,7 @@ import type { CommitmentsDB } from '../../server.js';
 export class NullifierManager {
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostNullifiers: CommitmentsDB,
+    private readonly hostNullifiers: WorldStateDB,
     /** Cache of siloed nullifiers. */
     private cache: Set<bigint> = new Set(),
     /** Parent nullifier manager to fall back on */
@@ -50,24 +50,25 @@ export class NullifierManager {
    *
    * @param siloedNullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists at all,
-   *          isPending: whether the nullifier was found in a cache,
-   *          leafIndex: the nullifier's leaf index if it exists and is not pending (comes from host state).
+   *          cacheHit: whether the nullifier was found in a cache,
    */
-  public async checkExists(
-    siloedNullifier: Fr,
-  ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
+  public async checkExists(siloedNullifier: Fr): Promise<{ exists: boolean; cacheHit: boolean }> {
     // Check this cache and parent's (recursively)
-    const existsAsPending = this.checkExistsHereOrParent(siloedNullifier);
-    // Finally try the host's Aztec state (a trip to the database)
-    // If the value is found in the database, it will be associated with a leaf index!
-    let leafIndex: bigint | undefined = undefined;
-    if (!existsAsPending) {
-      // silo the nullifier before checking for its existence in the host
-      leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
+    const cacheHit = this.checkExistsHereOrParent(siloedNullifier);
+    let existsInTree = false;
+    if (!cacheHit) {
+      // Finally try the host's Aztec state (a trip to the database)
+      //const leafOrLowLeafIndex = await this.hostNullifiers.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, siloedNullifier.toBigInt());
+      //assert(
+      //  leafOrLowLeafIndex !== undefined,
+      //  `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]} low leaf index should always be found (even if target leaf does not exist)`,
+      //);
+      //existsInTree = leafOrLowLeafIndex.alreadyPresent;
+      const leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
+      existsInTree = leafIndex !== undefined;
     }
-    const exists = existsAsPending || leafIndex !== undefined;
-    leafIndex = leafIndex === undefined ? BigInt(0) : leafIndex;
-    return Promise.resolve([exists, existsAsPending, new Fr(leafIndex)]);
+    const exists = cacheHit || existsInTree;
+    return Promise.resolve({ exists, cacheHit });
   }
 
   /**
@@ -76,7 +77,7 @@ export class NullifierManager {
    * @param siloedNullifier - the nullifier to stage
    */
   public async append(siloedNullifier: Fr) {
-    const [exists, ,] = await this.checkExists(siloedNullifier);
+    const { exists } = await this.checkExists(siloedNullifier);
     if (exists) {
       throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
     }

package/src/{avm → public/avm}/journal/public_storage.ts

@@ -1,7 +1,7 @@
-import { type AztecAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { PublicStateDB } from '../../server.js';
+import type { PublicStateDB } from '../../../common/db_interfaces.js';
 
 type PublicStorageReadResult = {
   value: Fr;

package/src/{avm → public/avm}/opcodes/contract.ts

@@ -58,7 +58,7 @@ export class GetContractInstance extends Instruction {
           memberValue = new Field(instance.deployer.toField());
           break;
         case ContractInstanceMember.CLASS_ID:
-          memberValue = new Field(instance.contractClassId.toField());
+          memberValue = new Field(instance.currentContractClassId.toField());
           break;
         case ContractInstanceMember.INIT_HASH:
           memberValue = new Field(instance.initializationHash);

package/src/{avm → public/avm}/opcodes/control_flow.ts

@@ -1,5 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { type IntegralValue } from '../avm_memory_types.js';
+import type { IntegralValue } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';

package/src/{avm → public/avm}/opcodes/conversion.ts

@@ -1,4 +1,4 @@
-import { type AvmContext } from '../avm_context.js';
+import type { AvmContext } from '../avm_context.js';
 import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
 import { InvalidToRadixInputsError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';

package/src/{avm → public/avm}/opcodes/ec_add.ts

@@ -1,7 +1,7 @@
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { Grumpkin } from '@aztec/foundation/crypto';
 import { Point } from '@aztec/foundation/fields';
 
-import { type AvmContext } from '../avm_context.js';
+import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';

package/src/{avm → public/avm}/opcodes/external_calls.ts

@@ -1,7 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
-import { type AvmContractCallResult } from '../avm_contract_call_result.js';
+import type { AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
-import { AvmSimulator } from '../avm_simulator.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -60,9 +59,9 @@ abstract class ExternalCall extends Instruction {
     context.machineState.consumeGas(allocatedGas);
 
     const aztecAddress = callAddress.toAztecAddress();
-    const nestedContext = context.createNestedContractCallContext(aztecAddress, calldata, allocatedGas, callType);
+    const nestedContext = await context.createNestedContractCallContext(aztecAddress, calldata, allocatedGas, callType);
 
-    const simulator = await AvmSimulator.build(nestedContext);
+    const simulator = await context.provideSimulator!(nestedContext);
     const nestedCallResults: AvmContractCallResult = await simulator.execute();
     const success = !nestedCallResults.reverted;
 
@@ -90,9 +89,9 @@ abstract class ExternalCall extends Instruction {
 
     // Merge nested call's state and trace based on whether it succeeded.
     if (success) {
-      context.persistableState.merge(nestedContext.persistableState);
+      await context.persistableState.merge(nestedContext.persistableState);
     } else {
-      context.persistableState.reject(nestedContext.persistableState);
+      await context.persistableState.reject(nestedContext.persistableState);
     }
   }
 

package/src/{avm → public/avm}/opcodes/hashing.ts

@@ -1,6 +1,6 @@
 import { keccakf1600, poseidon2Permutation, sha256Compression } from '@aztec/foundation/crypto';
 
-import { type AvmContext } from '../avm_context.js';
+import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';

package/src/public/avm/opcodes/index.ts

@@ -0,0 +1,15 @@
+export * from './arithmetic.js';
+export * from './bitwise.js';
+export * from './control_flow.js';
+export * from './contract.js';
+export * from './conversion.js';
+export * from './instruction.js';
+export * from './comparators.js';
+export * from './memory.js';
+export * from './misc.js';
+export * from './storage.js';
+export * from './external_calls.js';
+export * from './environment_getters.js';
+export * from './accrued_substate.js';
+export * from './hashing.js';
+export * from './ec_add.js';

package/src/{avm → public/avm}/opcodes/instruction.ts

@@ -2,8 +2,8 @@ import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
 import { type Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
-import { type BufferCursor } from '../serialization/buffer_cursor.js';
-import { type Serializable } from '../serialization/bytecode_serialization.js';
+import type { BufferCursor } from '../serialization/buffer_cursor.js';
+import type { Serializable } from '../serialization/bytecode_serialization.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {

package/src/{avm → public/avm}/opcodes/misc.ts

@@ -1,6 +1,6 @@
 import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
 
-import { type AvmContext } from '../avm_context.js';
+import type { AvmContext } from '../avm_context.js';
 import { TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';

package/src/public/avm/serialization/bytecode_serialization.ts

@@ -0,0 +1,204 @@
+import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
+import {
+  Add,
+  And,
+  Call,
+  CalldataCopy,
+  Cast,
+  DebugLog,
+  Div,
+  EcAdd,
+  EmitNoteHash,
+  EmitNullifier,
+  EmitUnencryptedLog,
+  Eq,
+  FieldDiv,
+  GetContractInstance,
+  GetEnvVar,
+  Instruction,
+  InternalCall,
+  InternalReturn,
+  Jump,
+  JumpI,
+  KeccakF1600,
+  L1ToL2MessageExists,
+  Lt,
+  Lte,
+  Mov,
+  Mul,
+  Not,
+  NoteHashExists,
+  NullifierExists,
+  Or,
+  Poseidon2,
+  Return,
+  ReturndataCopy,
+  ReturndataSize,
+  Revert,
+  SLoad,
+  SStore,
+  SendL2ToL1Message,
+  Set,
+  Sha256Compression,
+  Shl,
+  Shr,
+  StaticCall,
+  Sub,
+  ToRadixBE,
+  Xor,
+} from '../opcodes/index.js';
+import { BufferCursor } from './buffer_cursor.js';
+import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
+
+export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
+
+export interface Serializable {
+  serialize(): Buffer;
+}
+
+export interface Deserializable {
+  deserialize: InstructionDeserializer;
+}
+
+export type InstructionSet = Map<Opcode, InstructionDeserializer>;
+export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
+  [Opcode.ADD_8, Add.as(Add.wireFormat8).deserialize],
+  [Opcode.ADD_16, Add.as(Add.wireFormat16).deserialize],
+  [Opcode.SUB_8, Sub.as(Sub.wireFormat8).deserialize],
+  [Opcode.SUB_16, Sub.as(Sub.wireFormat16).deserialize],
+  [Opcode.MUL_8, Mul.as(Mul.wireFormat8).deserialize],
+  [Opcode.MUL_16, Mul.as(Mul.wireFormat16).deserialize],
+  [Opcode.DIV_8, Div.as(Div.wireFormat8).deserialize],
+  [Opcode.DIV_16, Div.as(Div.wireFormat16).deserialize],
+  [Opcode.FDIV_8, FieldDiv.as(FieldDiv.wireFormat8).deserialize],
+  [Opcode.FDIV_16, FieldDiv.as(FieldDiv.wireFormat16).deserialize],
+  [Opcode.EQ_8, Eq.as(Eq.wireFormat8).deserialize],
+  [Opcode.EQ_16, Eq.as(Eq.wireFormat16).deserialize],
+  [Opcode.LT_8, Lt.as(Lt.wireFormat8).deserialize],
+  [Opcode.LT_16, Lt.as(Lt.wireFormat16).deserialize],
+  [Opcode.LTE_8, Lte.as(Lte.wireFormat8).deserialize],
+  [Opcode.LTE_16, Lte.as(Lte.wireFormat16).deserialize],
+  [Opcode.AND_8, And.as(And.wireFormat8).deserialize],
+  [Opcode.AND_16, And.as(And.wireFormat16).deserialize],
+  [Opcode.OR_8, Or.as(Or.wireFormat8).deserialize],
+  [Opcode.OR_16, Or.as(Or.wireFormat16).deserialize],
+  [Opcode.XOR_8, Xor.as(Xor.wireFormat8).deserialize],
+  [Opcode.XOR_16, Xor.as(Xor.wireFormat16).deserialize],
+  [Opcode.NOT_8, Not.as(Not.wireFormat8).deserialize],
+  [Opcode.NOT_16, Not.as(Not.wireFormat16).deserialize],
+  [Opcode.SHL_8, Shl.as(Shl.wireFormat8).deserialize],
+  [Opcode.SHL_16, Shl.as(Shl.wireFormat16).deserialize],
+  [Opcode.SHR_8, Shr.as(Shr.wireFormat8).deserialize],
+  [Opcode.SHR_16, Shr.as(Shr.wireFormat16).deserialize],
+  [Opcode.CAST_8, Cast.as(Cast.wireFormat8).deserialize],
+  [Opcode.CAST_16, Cast.as(Cast.wireFormat16).deserialize],
+  // Execution Environment
+  [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
+  [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
+  [Opcode.RETURNDATASIZE, Instruction.deserialize.bind(ReturndataSize)],
+  [Opcode.RETURNDATACOPY, Instruction.deserialize.bind(ReturndataCopy)],
+
+  // Machine State - Internal Control Flow
+  [Jump.opcode, Instruction.deserialize.bind(Jump)],
+  [JumpI.opcode, Instruction.deserialize.bind(JumpI)],
+  [InternalCall.opcode, Instruction.deserialize.bind(InternalCall)],
+  [InternalReturn.opcode, Instruction.deserialize.bind(InternalReturn)],
+  [Opcode.SET_8, Set.as(Set.wireFormat8).deserialize],
+  [Opcode.SET_16, Set.as(Set.wireFormat16).deserialize],
+  [Opcode.SET_32, Set.as(Set.wireFormat32).deserialize],
+  [Opcode.SET_64, Set.as(Set.wireFormat64).deserialize],
+  [Opcode.SET_128, Set.as(Set.wireFormat128).deserialize],
+  [Opcode.SET_FF, Set.as(Set.wireFormatFF).deserialize],
+  [Opcode.MOV_8, Mov.as(Mov.wireFormat8).deserialize],
+  [Opcode.MOV_16, Mov.as(Mov.wireFormat16).deserialize],
+
+  // World State
+  [SLoad.opcode, Instruction.deserialize.bind(SLoad)], // Public Storage
+  [SStore.opcode, Instruction.deserialize.bind(SStore)], // Public Storage
+  [NoteHashExists.opcode, Instruction.deserialize.bind(NoteHashExists)], // Notes & Nullifiers
+  [EmitNoteHash.opcode, Instruction.deserialize.bind(EmitNoteHash)], // Notes & Nullifiers
+  [NullifierExists.opcode, Instruction.deserialize.bind(NullifierExists)], // Notes & Nullifiers
+  [EmitNullifier.opcode, Instruction.deserialize.bind(EmitNullifier)], // Notes & Nullifiers
+  [L1ToL2MessageExists.opcode, Instruction.deserialize.bind(L1ToL2MessageExists)], // Messages
+
+  // Accrued Substate
+  [EmitUnencryptedLog.opcode, Instruction.deserialize.bind(EmitUnencryptedLog)],
+  [SendL2ToL1Message.opcode, Instruction.deserialize.bind(SendL2ToL1Message)],
+  [GetContractInstance.opcode, Instruction.deserialize.bind(GetContractInstance)],
+
+  // Control Flow - Contract Calls
+  [Call.opcode, Instruction.deserialize.bind(Call)],
+  [StaticCall.opcode, Instruction.deserialize.bind(StaticCall)],
+  [Return.opcode, Instruction.deserialize.bind(Return)],
+  [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).deserialize],
+  [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).deserialize],
+
+  // Misc
+  [DebugLog.opcode, Instruction.deserialize.bind(DebugLog)],
+
+  // Gadgets
+  [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
+  [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
+  [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
+  [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],
+
+  // Conversions
+  [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
+]);
+
+/**
+ * Serializes an array of instructions to bytecode.
+ */
+export function encodeToBytecode(instructions: Serializable[]): Buffer {
+  return Buffer.concat(instructions.map(i => i.serialize()));
+}
+
+// For testing only
+export function decodeFromBytecode(bytecode: Buffer, instructionSet: InstructionSet = INSTRUCTION_SET): Instruction[] {
+  const instructions: Instruction[] = [];
+  let pc = 0;
+  while (pc < bytecode.length) {
+    const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
+    instructions.push(instruction);
+    pc += bytesConsumed;
+  }
+  return instructions;
+}
+
+// Returns the instruction and the number of bytes consumed.
+export function decodeInstructionFromBytecode(
+  bytecode: Buffer,
+  pc: number,
+  instructionSet: InstructionSet = INSTRUCTION_SET,
+): [Instruction, number] {
+  if (pc >= bytecode.length) {
+    throw new InvalidProgramCounterError(pc, bytecode.length);
+  }
+
+  try {
+    const cursor = new BufferCursor(bytecode, pc);
+    const startingPosition = cursor.position();
+    const opcode: number = cursor.bufferAtPosition().readUint8(); // peek.
+
+    if (opcode > MAX_OPCODE_VALUE) {
+      throw new InvalidOpcodeError(
+        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`,
+      );
+    }
+
+    const instructionDeserializerOrUndef = instructionSet.get(opcode);
+    if (instructionDeserializerOrUndef === undefined) {
+      throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
+    }
+
+    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
+    const instruction = instructionDeserializer(cursor);
+    return [instruction, cursor.position() - startingPosition];
+  } catch (error) {
+    if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
+      throw error;
+    } else {
+      throw new AvmParsingError(`${error}`);
+    }
+  }
+}

package/src/{avm → public/avm}/serialization/instruction_serialization.ts

@@ -81,7 +81,6 @@ export enum Opcode {
   SHA256COMPRESSION,
   KECCAKF1600,
   ECADD,
-  MSM,
   // Conversion
   TORADIXBE,
 }

package/src/{avm → public/avm}/test_utils.ts

@@ -1,19 +1,18 @@
+import { Fr } from '@aztec/foundation/fields';
 import {
   type ContractClassPublic,
   type ContractInstanceWithAddress,
-  Fr,
   computePublicBytecodeCommitment,
-} from '@aztec/circuits.js';
+} from '@aztec/stdlib/contract';
 
-import { type jest } from '@jest/globals';
+import type { jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
 
-import { type WorldStateDB } from '../public/public_db_sources.js';
-import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
+import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
 
 export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
   const commitment = await computePublicBytecodeCommitment(bytecode);
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecode.mockResolvedValue(bytecode);
   (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
 }
 
@@ -37,6 +36,10 @@ export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage
   );
 }
 
+export function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
+}
+
 export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr) {
   (worldStateDB as jest.Mocked<WorldStateDB>).getCommitmentValue.mockImplementation((index: bigint) => {
     if (index == _leafIndex.toBigInt()) {
@@ -48,7 +51,7 @@ export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, v
   });
 }
 
-export function mockNullifierExists(worldStateDB: WorldStateDB, leafIndex: Fr, _value?: Fr) {
+export function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr) {
   (worldStateDB as jest.Mocked<WorldStateDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
 }
 

package/src/public/execution.ts

@@ -1,23 +1,20 @@
-import { type PublicExecutionRequest, type SimulationError } from '@aztec/circuit-types';
+import type { Fr } from '@aztec/foundation/fields';
 import {
   type AvmExecutionHints,
   type ContractStorageRead,
   type ContractStorageUpdateRequest,
-  type Fr,
-  Gas,
-  type L2ToL1Message,
-  type NoteHash,
-  type Nullifier,
   PublicCallStackItemCompressed,
   type PublicDataUpdateRequest,
   PublicInnerCallRequest,
-  type PublicLog,
-  type ReadRequest,
   RevertCode,
-  type ScopedL2ToL1Message,
-  type TreeLeafReadRequest,
-} from '@aztec/circuits.js';
-import { computeVarArgsHash } from '@aztec/circuits.js/hash';
+} from '@aztec/stdlib/avm';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+import type { NoteHash, Nullifier, ReadRequest, TreeLeafReadRequest } from '@aztec/stdlib/kernel';
+import type { PublicLog } from '@aztec/stdlib/logs';
+import type { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import type { PublicExecutionRequest } from '@aztec/stdlib/tx';
 
 export interface PublicSideEffects {
   /** The contract storage update requests performed. */

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,32 +1,24 @@
-import { MerkleTreeId, type MerkleTreeWriteOperations, PublicExecutionRequest, type Tx } from '@aztec/circuit-types';
-import {
-  type AvmCircuitPublicInputs,
-  CallContext,
-  FunctionSelector,
-  GasFees,
-  GlobalVariables,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
-  PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_DISPATCH_SELECTOR,
-} from '@aztec/circuits.js';
-import { type ContractArtifact, encodeArguments } from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
+import { type ContractArtifact, FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { PublicExecutionRequest, type Tx } from '@aztec/stdlib/tx';
+import { CallContext, GlobalVariables } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../../avm/fixtures/base_avm_simulation_tester.js';
-import { getContractFunctionArtifact, getFunctionSelector } from '../../avm/fixtures/index.js';
-import { SimpleContractDataSource } from '../../avm/fixtures/simple_contract_data_source.js';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { getContractFunctionArtifact, getFunctionSelector } from '../avm/fixtures/index.js';
+import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
 import { WorldStateDB } from '../public_db_sources.js';
 import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator.js';
 import { createTxForPublicCalls } from './index.js';
 
 const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
+export const DEFAULT_BLOCK_NUMBER = 42;
 
 export type TestEnqueuedCall = {
   address: AztecAddress;
@@ -47,31 +39,26 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     private worldStateDB: WorldStateDB,
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
-    skipContractDeployments: boolean,
   ) {
-    super(contractDataSource, merkleTrees, skipContractDeployments);
+    super(contractDataSource, merkleTrees);
   }
 
-  public static async create(skipContractDeployments = false): Promise<PublicTxSimulationTester> {
+  public static async create(): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
     const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees, skipContractDeployments);
+    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees);
   }
 
-  public async simulateTx(
+  public async createTx(
     sender: AztecAddress,
     setupCalls: TestEnqueuedCall[] = [],
     appCalls: TestEnqueuedCall[] = [],
     teardownCall?: TestEnqueuedCall,
-    feePayer: AztecAddress = AztecAddress.zero(),
-  ): Promise<PublicTxResult> {
-    const globals = GlobalVariables.empty();
-    globals.timestamp = TIMESTAMP;
-    globals.gasFees = DEFAULT_GAS_FEES;
-
-    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
-
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+  ): Promise<Tx> {
     const setupExecutionRequests: PublicExecutionRequest[] = [];
     for (let i = 0; i < setupCalls.length; i++) {
       const address = setupCalls[i].address;
@@ -115,51 +102,38 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       );
     }
 
-    // Use a fake "first nullifier" to make sure note hash nonces are computed properly,
-    // but make sure each tx has a unique first nullifier.
-    const firstNullifier = new Fr(420000 + this.txCount++);
-
-    const tx: Tx = await createTxForPublicCalls(
+    return await createTxForPublicCalls(
       firstNullifier,
       setupExecutionRequests,
       appExecutionRequests,
       teardownExecutionRequest,
       feePayer,
     );
+  }
+
+  public async simulateTx(
+    sender: AztecAddress,
+    setupCalls: TestEnqueuedCall[] = [],
+    appCalls: TestEnqueuedCall[] = [],
+    teardownCall?: TestEnqueuedCall,
+    feePayer: AztecAddress = sender,
+    /* need some unique first nullifier for note-nonce computations */
+    firstNullifier = new Fr(420000 + this.txCount++),
+    globals = defaultGlobals(),
+  ): Promise<PublicTxResult> {
+    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier);
+
+    await this.setFeePayerBalance(feePayer);
+
+    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
 
     const startTime = performance.now();
     const avmResult = await simulator.simulate(tx);
     const endTime = performance.now();
     this.logger.debug(`Public transaction simulation took ${endTime - startTime}ms`);
 
-    if (avmResult.revertCode.isOK()) {
-      await this.commitTxStateUpdates(avmResult.avmProvingRequest.inputs.publicInputs);
-    }
-
     return avmResult;
   }
-
-  private async commitTxStateUpdates(avmCircuitInputs: AvmCircuitPublicInputs) {
-    await this.merkleTrees.appendLeaves(
-      MerkleTreeId.NOTE_HASH_TREE,
-      padArrayEnd(avmCircuitInputs.accumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
-    try {
-      await this.merkleTrees.batchInsert(
-        MerkleTreeId.NULLIFIER_TREE,
-        padArrayEnd(avmCircuitInputs.accumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
-        NULLIFIER_SUBTREE_HEIGHT,
-      );
-    } catch (error) {
-      this.logger.warn(`Detected duplicate nullifier.`);
-    }
-
-    await this.merkleTrees.batchInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      avmCircuitInputs.accumulatedData.publicDataWrites.map(w => w.toBuffer()),
-      PUBLIC_DATA_TREE_HEIGHT,
-    );
-  }
 }
 
 async function executionRequestForCall(
@@ -183,3 +157,11 @@ async function executionRequestForCall(
   );
   return new PublicExecutionRequest(callContext, calldata);
 }
+
+function defaultGlobals() {
+  const globals = GlobalVariables.empty();
+  globals.timestamp = TIMESTAMP;
+  globals.gasFees = DEFAULT_GAS_FEES; // apply some nonzero default gas fees
+  globals.blockNumber = new Fr(DEFAULT_BLOCK_NUMBER);
+  return globals;
+}