@aztec/simulator 0.0.1-commit.e6bd8901 → 0.0.1-commit.ec5f612

package/src/public/avm/fixtures/account_proof_fetcher.ts

@@ -0,0 +1,166 @@
+/**
+ * Fetches an account proof from the Ethereum mainnet and saves it as account_proof.json.
+ * This script is not using any Aztec library code, so it's easily portable.
+ */
+import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, fromRlp, hexToBytes, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RPC_URL = process.env.RPC_URL;
+const ADDRESS = (process.env.ADDRESS || '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045') as `0x${string}`;
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+
+function padTo(arr: number[], len: number) {
+  return [...arr, ...Array(len - arr.length).fill(0)].slice(0, len);
+}
+
+function toBytes(hex: `0x${string}`) {
+  return Array.from(hexToBytes(hex));
+}
+
+function bytesToU64s(bytes: number[]) {
+  const paddedBytes = padTo(bytes, 32);
+  return Array.from({ length: 4 }, (_, i) => {
+    let val = 0n;
+    for (let j = 0; j < 8; j++) {
+      val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+    }
+    return val.toString();
+  });
+}
+
+function toBytesAndLen(val: bigint | number) {
+  if (val === 0n || val === 0) {
+    return { bytes: [0], length: 0 };
+  }
+  let hex = val.toString(16);
+  if (hex.length % 2) {
+    hex = '0' + hex;
+  }
+  const bytes = toBytes(`0x${hex}`);
+  return { bytes, length: bytes.length };
+}
+
+function parseNode(rlp: `0x${string}`) {
+  // Should be safe when working with branches and extensions without embedded children.
+  const decoded = fromRlp(rlp) as `0x${string}`[];
+  const node = {
+    rows: Array(16)
+      .fill(0)
+      .map(() => Array(32).fill(0)),
+    row_exist: Array(16).fill(false),
+    node_type: 0,
+  };
+
+  if (decoded.length === 17) {
+    for (let i = 0; i < 16; i++) {
+      if (decoded[i] !== '0x') {
+        node.row_exist[i] = true;
+        node.rows[i] = padTo(toBytes(decoded[i]), 32);
+      }
+    }
+  } else if (decoded.length === 2) {
+    const keyBytes = toBytes(decoded[0]);
+    const prefix = keyBytes[0];
+    if (prefix >> 4 >= 2) {
+      throw new Error('Unsupported: leaf node in proof path');
+    }
+    node.node_type = 1;
+    // Extension header format expected by the noir code: check out storage_proof types.nr.
+    node.rows[0][0] = prefix >> 4;
+    node.rows[0][8] = prefix & 0x0f;
+    node.rows[0][16] = keyBytes.length - 1;
+
+    for (let i = 1; i < keyBytes.length && i < 32; i++) {
+      node.rows[1][i - 1] = keyBytes[i];
+    }
+    node.rows[2] = padTo(toBytes(decoded[1]), 32);
+    node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+  }
+  return node;
+}
+
+function parseProof(proof: `0x${string}`[], maxLen: number) {
+  const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+  while (nodes.length < maxLen) {
+    nodes.push({
+      rows: Array(16)
+        .fill(0)
+        .map(() => Array(32).fill(0)),
+      row_exist: Array(16).fill(false),
+      node_type: 0,
+    });
+  }
+  return nodes;
+}
+
+function nodeToLibFormat(node: { rows: number[][]; row_exist: boolean[]; node_type: number }) {
+  return {
+    rows: node.rows.map(bytesToU64s),
+    row_exist: node.row_exist,
+    node_type: String(node.node_type),
+  };
+}
+
+async function main() {
+  if (!RPC_URL) {
+    throw new Error('RPC_URL is not set');
+  }
+  console.log(`Fetching account proof for ${ADDRESS}`);
+
+  const client = createPublicClient({
+    chain: mainnet,
+    transport: http(RPC_URL),
+  });
+
+  const [blockNumber, proof, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getProof({
+      address: ADDRESS,
+      storageKeys: [],
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+    client.getBlock({
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+  ]);
+
+  console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}`);
+
+  // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+  const accountPathLen = proof.accountProof.length - 1;
+  if (accountPathLen > MAX_ACCOUNT_PATH) {
+    throw new Error(
+      `Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`,
+    );
+  }
+
+  const nonce = toBytesAndLen(proof.nonce);
+  const balance = toBytesAndLen(proof.balance);
+
+  const data = {
+    block_number: String(blockNumber),
+    node_length: String(accountPathLen),
+    root: bytesToU64s(toBytes(block.stateRoot)),
+    nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+    account: {
+      address: toBytes(ADDRESS).map(String),
+      balance: padTo(balance.bytes, 32).map(String),
+      balance_length: String(balance.length),
+      code_hash: bytesToU64s(toBytes(proof.codeHash)),
+      nonce: padTo(nonce.bytes, 8).map(String),
+      nonce_length: String(nonce.length),
+      storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+    },
+  };
+
+  fs.writeFileSync(join(__dirname, 'account_proof.json'), JSON.stringify(data, null, 2));
+  console.log('account_proof.json generated');
+}
+
+main().catch(console.error);

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -13,6 +13,7 @@ import { SimpleContractDataSource } from '../../fixtures/simple_contract_data_so
 import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
 import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
 import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
 import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
 import { initContext, initExecutionEnvironment } from './initializers.js';
 import {
@@ -89,7 +90,7 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       collectCallMetadata: true,
     });
     const environment = initExecutionEnvironment({
-      calldata,
+      calldata: new CallDataArray(calldata),
       globals,
       address,
       sender,
@@ -105,7 +106,12 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
     if (result.reverted) {
       this.logger.error(`Error in ${fnName}:`);
       this.logger.error(
-        resolveContractAssertionMessage(fnName, result.revertReason!, result.output, contractArtifact)!,
+        resolveContractAssertionMessage(
+          fnName,
+          result.revertReason!,
+          result.output.bestEffortReadAll(),
+          contractArtifact,
+        )!,
       );
     } else {
       this.logger.info(`Simulation of function ${fnName} succeeded!`);

package/src/public/avm/fixtures/initializers.ts

@@ -19,6 +19,7 @@ import { AvmContext } from '../avm_context.js';
 import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
 import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
 import { DEFAULT_TIMESTAMP } from './utils.js';
 
 /**
@@ -70,7 +71,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.transactionFee ?? Fr.zero(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
-    overrides?.calldata ?? [],
+    overrides?.calldata ?? new CallDataArray([]),
     overrides?.config ?? PublicSimulatorConfig.empty(),
   );
 }

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

@@ -1,3 +1,5 @@
+import { MAX_ETH_ADDRESS_VALUE } from '@aztec/constants';
+
 import { NullifierCollisionError } from '../../side_effect_errors.js';
 import type { AvmContext } from '../avm_context.js';
 import { TypeTag, Uint1 } from '../avm_memory_types.js';
@@ -86,18 +88,11 @@ export class NullifierExists extends Instruction {
   static type: string = 'NULLIFIEREXISTS';
   static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-  ];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
   constructor(
     private addressingMode: number,
-    private nullifierOffset: number,
-    private addressOffset: number,
+    private siloedNullifierOffset: number,
     private existsOffset: number,
   ) {
     super();
@@ -111,13 +106,12 @@ export class NullifierExists extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
-    const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
+    const operands = [this.siloedNullifierOffset, this.existsOffset];
+    const [siloedNullifierOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, siloedNullifierOffset);
 
-    const nullifier = memory.get(nullifierOffset).toFr();
-    const address = memory.get(addressOffset).toAztecAddress();
-    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
+    const siloedNullifier = memory.get(siloedNullifierOffset).toFr();
+    const exists = await context.persistableState.checkSiloedNullifierExists(siloedNullifier);
 
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
   }
@@ -210,10 +204,9 @@ export class L1ToL2MessageExists extends Instruction {
   }
 }
 
-export class EmitUnencryptedLog extends Instruction {
-  // TODO(#11124): rename unencrypted -> public
-  static type: string = 'EMITUNENCRYPTEDLOG';
-  static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
+export class EmitPublicLog extends Instruction {
+  static type: string = 'EMITPUBLICLOG';
+  static readonly opcode: Opcode = Opcode.EMITPUBLICLOG;
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
@@ -282,6 +275,10 @@ export class SendL2ToL1Message extends Instruction {
     memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
 
     const recipient = memory.get(recipientOffset).toFr();
+
+    if (recipient.toBigInt() > MAX_ETH_ADDRESS_VALUE) {
+      throw new InstructionExecutionError(`SENDL2TOL1MSG: Recipient address is too large`);
+    }
     const content = memory.get(contentOffset).toFr();
     context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
   }

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

@@ -1,6 +1,7 @@
 import type { AvmContext } from '../avm_context.js';
 import type { AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { CallDataMemory, ReturnDataMemory } from '../calldata.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -45,8 +46,8 @@ abstract class ExternalCall extends Instruction {
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
-    // This is a DOS vector. CalldataSize is chosen by the bytecode, and can be arbitrarily large leading to a OOM here.
-    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
+
+    const calldata = new CallDataMemory(memory, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
     // If we are already in a static call, we propagate the environment.
@@ -73,8 +74,8 @@ abstract class ExternalCall extends Instruction {
     const success = !nestedCallResults.reverted;
 
     // Save return/revert data for later.
-    const fullReturnData = nestedCallResults.output;
-    context.machineState.nestedReturndata = fullReturnData;
+    const returnData = nestedCallResults.output;
+    context.machineState.nestedReturndata = returnData;
 
     // Track the success status directly
     context.machineState.nestedCallSuccess = success;
@@ -89,7 +90,7 @@ abstract class ExternalCall extends Instruction {
     // (in Noir code).
     if (!success) {
       context.machineState.collectedRevertInfo = {
-        revertDataRepresentative: fullReturnData,
+        revertDataRepresentative: returnData.bestEffortReadAll(),
         recursiveRevertReason: nestedCallResults.revertReason!,
       };
     }
@@ -195,7 +196,7 @@ export class Return extends Instruction {
     memory.checkTag(TypeTag.UINT32, returnSizeOffset);
     const returnSize = memory.get(returnSizeOffset).toNumber();
 
-    const output = memory.getSlice(returnOffset, returnSize).map(word => word.toFr());
+    const output = new ReturnDataMemory(memory, returnOffset, returnSize);
 
     context.machineState.return(output);
   }
@@ -243,7 +244,7 @@ export class Revert extends Instruction {
 
     memory.checkTag(TypeTag.UINT32, retSizeOffset);
     const retSize = memory.get(retSizeOffset).toNumber();
-    const output = memory.getSlice(returnOffset, retSize).map(word => word.toFr());
+    const output = new ReturnDataMemory(memory, returnOffset, retSize);
 
     context.machineState.revert(output);
   }

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

@@ -242,7 +242,7 @@ export class ReturndataSize extends Instruction {
     const operands = [this.dstOffset];
     const [dstOffset] = addressing.resolve(operands, memory);
 
-    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
+    memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length()));
   }
 }
 

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

@@ -19,7 +19,7 @@ import {
   EcAdd,
   EmitNoteHash,
   EmitNullifier,
-  EmitUnencryptedLog,
+  EmitPublicLog,
   Eq,
   FieldDiv,
   GetContractInstance,
@@ -129,7 +129,7 @@ export const INSTRUCTION_SET = new Map<Opcode, InstructionDeserializer>([
   [L1ToL2MessageExists.opcode, Instruction.fromBuffer.bind(L1ToL2MessageExists)], // Messages
 
   // Accrued Substate
-  [EmitUnencryptedLog.opcode, Instruction.fromBuffer.bind(EmitUnencryptedLog)],
+  [EmitPublicLog.opcode, Instruction.fromBuffer.bind(EmitPublicLog)],
   [SendL2ToL1Message.opcode, Instruction.fromBuffer.bind(SendL2ToL1Message)],
   [GetContractInstance.opcode, Instruction.fromBuffer.bind(GetContractInstance)],
 

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

@@ -70,7 +70,7 @@ export enum Opcode {
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
   GETCONTRACTINSTANCE,
-  EMITUNENCRYPTEDLOG,
+  EMITPUBLICLOG,
   SENDL2TOL1MSG,
   // External calls
   CALL,

package/src/public/debug_fn_name.ts

@@ -1,20 +1,21 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
+import type { CallData } from './avm/calldata.js';
 import type { PublicContractsDBInterface } from './db_interfaces.js';
 
 export async function getPublicFunctionDebugName(
   db: PublicContractsDBInterface,
   contractAddress: AztecAddress,
-  calldata: Fr[],
+  calldata: CallData,
 ): Promise<string> {
   // Public function is dispatched and therefore the target function is passed in the first argument.
-  if (!calldata[0]) {
+  const selectorField = calldata.read(0);
+  if (!selectorField) {
     return `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
   }
-  const fallbackName = `<calldata[0]:${calldata[0].toString()}> (Contract Address: ${contractAddress})`;
-  const selector = FunctionSelector.fromFieldOrUndefined(calldata[0]);
+  const fallbackName = `<calldata[0]:${selectorField.toString()}> (Contract Address: ${contractAddress})`;
+  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
   if (!selector) {
     return fallbackName;
   }
@@ -32,13 +33,14 @@ export async function getPublicFunctionDebugName(
 export async function getPublicFunctionSelectorAndName(
   db: PublicContractsDBInterface,
   contractAddress: AztecAddress,
-  calldata: Fr[],
+  calldata: CallData,
 ): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
   // Public function is dispatched and therefore the target function is passed in the first argument.
-  if (!calldata[0]) {
+  const selectorField = calldata.read(0);
+  if (!selectorField) {
     return {};
   }
-  const selector = FunctionSelector.fromFieldOrUndefined(calldata[0]);
+  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
   if (!selector) {
     return {};
   }

package/src/public/executor_metrics.ts

@@ -7,6 +7,7 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
@@ -25,7 +26,9 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     this.tracer = client.getTracer(name);
     const meter = client.getMeter(name);
 
-    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT);
+    this.fnCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
+      [Attributes.OK]: [true, false],
+    });
 
     this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION);
 

package/src/public/fixtures/amm_test.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
@@ -326,6 +326,6 @@ async function removeLiquidity(
 async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
   return await poseidon2HashWithSeparator(
     [partialNote.commitment, completer],
-    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
+    DomainSeparator.PARTIAL_NOTE_VALIDITY_COMMITMENT,
   );
 }

package/src/public/fixtures/opcode_spammer.ts

@@ -143,7 +143,7 @@
  * - `EMITNOTEHASH`: max 64 per TX
  * - `EMITNULLIFIER`: max 63 per TX (one reserved for TX nullifier)
  * - `SENDL2TOL1MSG`: max 8 per TX
- * - `EMITUNENCRYPTEDLOG`: limited by total log payload size
+ * - `EMITPUBLICLOG`: limited by total log payload size
  *
  * By having the inner contract REVERT after emitting side effects, those effects are discarded, allowing the outer contract to call it again. This enables thousands of opcode executions per TX instead of just the limit.
  *
@@ -164,7 +164,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Bufferable } from '@aztec/foundation/serialize';
 import { type CallStackMetadata, PublicDataWrite, type PublicTxResult } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 
@@ -182,7 +182,7 @@ import {
   EcAdd,
   EmitNoteHash,
   EmitNullifier,
-  EmitUnencryptedLog,
+  EmitPublicLog,
   Eq,
   FieldDiv,
   GetContractInstance,
@@ -295,9 +295,8 @@ export interface SpamConfigsForOpcode {
 export const WARM_NOTE_HASH = new Fr(0xdeadbeefn);
 export const WARM_L1_TO_L2_MSG = new Fr(0xcafebabedeadbeefn);
 
-/** Warm nullifier constants - uses a fixed address since NULLIFIEREXISTS takes address as parameter */
-export const WARM_NULLIFIER = new Fr(0xdeadbeef0001n);
-export const WARM_NULLIFIER_ADDRESS = AztecAddress.fromNumber(0xbeef);
+/** Warm nullifier constant - a pre-siloed nullifier value inserted directly into the tree */
+export const WARM_SILOED_NULLIFIER = new Fr(0xdeadbeef0001n);
 
 /** Warm storage constants - storage is inserted for the deployed contract's address */
 export const WARM_STORAGE_SLOT = new Fr(0xdeadbeef0002n);
@@ -331,9 +330,8 @@ export async function insertWarmTreeEntries(
   // Insert into L1 to L2 message tree
   await merkleTrees.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [WARM_L1_TO_L2_MSG]);
 
-  // Insert siloed nullifier into nullifier tree
-  const siloedNullifier = await siloNullifier(WARM_NULLIFIER_ADDRESS, WARM_NULLIFIER);
-  await merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
+  // Insert siloed nullifier into nullifier tree (already siloed - used directly by NULLIFIEREXISTS)
+  await merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [WARM_SILOED_NULLIFIER.toBuffer()]);
 
   // Insert storage value into public data tree
   const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, WARM_STORAGE_SLOT);
@@ -1060,56 +1058,25 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
   [Opcode.NULLIFIEREXISTS]: [
     {
       label: 'Non-existent nullifier',
+      // NULLIFIEREXISTS now takes a siloed nullifier directly (no address parameter)
       setup: [
-        { offset: 0, value: new Field(Fr.random()) }, // random nullifier
-        { offset: 1, value: new Field(Fr.random()) }, // random address
+        { offset: 0, value: new Field(Fr.random()) }, // random siloed nullifier (won't exist)
       ],
       targetInstructions: () => [
-        new NullifierExists(/*addressing_mode=*/ 0, /*nullifierOffset=*/ 0, /*addressOffset=*/ 1, /*existsOffset=*/ 2),
+        new NullifierExists(/*addressing_mode=*/ 0, /*siloedNullifierOffset=*/ 0, /*existsOffset=*/ 1),
       ],
     },
     {
       label: 'Existing nullifier (warm - from tree)',
-      // Uses pre-inserted nullifier from insertWarmTreeEntries()
+      // Uses pre-inserted siloed nullifier from insertWarmTreeEntries()
+      // NULLIFIEREXISTS now takes a siloed nullifier directly
       setup: [
-        { offset: 0, value: new Field(WARM_NULLIFIER) }, // pre-inserted nullifier
-        { offset: 1, value: new Field(WARM_NULLIFIER_ADDRESS.toField()) }, // address it was siloed with
+        { offset: 0, value: new Field(WARM_SILOED_NULLIFIER) }, // pre-inserted siloed nullifier
       ],
       targetInstructions: () => [
-        new NullifierExists(/*addressing_mode=*/ 0, /*nullifierOffset=*/ 0, /*addressOffset=*/ 1, /*existsOffset=*/ 2),
+        new NullifierExists(/*addressing_mode=*/ 0, /*siloedNullifierOffset=*/ 0, /*existsOffset=*/ 1),
       ],
     },
-    {
-      label: 'Existing nullifier (warm - EMITNULLIFIER first)',
-      // Memory layout: nullifier (incremented), constant 1, current address (from GETENVVAR), revertSize, exists result
-      setup: [
-        { offset: 0, value: new Field(Fr.random()) }, // nullifier (will be incremented)
-        { offset: 1, value: new Field(1n) }, // constant 1 for ADD
-        () => [
-          // Get current contract address into offset 2
-          new GetEnvVar(/*addressing_mode=*/ 0, /*dstOffset=*/ 2, /*varEnum=*/ 0).as(
-            Opcode.GETENVVAR_16,
-            GetEnvVar.wireFormat16,
-          ),
-        ],
-        { offset: 3, value: new Uint32(0n) }, // revertSize
-      ],
-      targetInstructions: () => [
-        new EmitNullifier(/*addressing_mode=*/ 0, /*nullifierOffset=*/ 0),
-        new NullifierExists(/*addressing_mode=*/ 0, /*nullifierOffset=*/ 0, /*addressOffset=*/ 2, /*existsOffset=*/ 4),
-        new Add(/*addressing_mode=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 0).as(
-          Opcode.ADD_8,
-          Add.wireFormat8,
-        ), // nullifier++
-      ],
-      cleanupInstructions: () => [
-        new Revert(/*addressing_mode=*/ 0, /*retSizeOffset=*/ 3, /*returnOffset=*/ 0).as(
-          Opcode.REVERT_8,
-          Revert.wireFormat8,
-        ),
-      ],
-      limit: MAX_NULLIFIERS_PER_TX - 1,
-    },
   ],
 
   [Opcode.L1TOL2MSGEXISTS]: [
@@ -1275,17 +1242,15 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
     },
   ],
 
-  // EMITUNENCRYPTEDLOG - two configs: minimal (many small logs) and max-size (one large log)
-  [Opcode.EMITUNENCRYPTEDLOG]: [
+  // EMITPUBLICLOG - two configs: minimal (many small logs) and max-size (one large log)
+  [Opcode.EMITPUBLICLOG]: [
     {
       label: 'Many empty logs, revert, repeat',
       setup: [
         { offset: 0, value: new Uint32(0n) }, // logSize = 0 fields (minimal)
         { offset: 1, value: new Uint32(0n) }, // revertSize
       ],
-      targetInstructions: () => [
-        new EmitUnencryptedLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 1),
-      ], // logOffset doesn't matter when size is 0
+      targetInstructions: () => [new EmitPublicLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 1)], // logOffset doesn't matter when size is 0
       cleanupInstructions: () => [
         new Revert(/*addressing_mode=*/ 0, /*retSizeOffset=*/ 1, /*returnOffset=*/ 0).as(
           Opcode.REVERT_8,
@@ -1309,9 +1274,7 @@ export const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>> = {
         //  value: new Field(0n),
         //})),
       ],
-      targetInstructions: () => [
-        new EmitUnencryptedLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 2),
-      ], // uses logOffset 2 (uninitialized Field(0))
+      targetInstructions: () => [new EmitPublicLog(/*addressing_mode=*/ 0, /*logSizeOffset=*/ 0, /*logOffset=*/ 2)], // uses logOffset 2 (uninitialized Field(0))
       cleanupInstructions: () => [
         new Revert(/*addressing_mode=*/ 0, /*retSizeOffset=*/ 1, /*returnOffset=*/ 0).as(
           Opcode.REVERT_8,

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,4 +1,9 @@
-import { DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT } from '@aztec/constants';
+import {
+  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
+  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  PUBLIC_TX_L2_GAS_OVERHEAD,
+  TX_DA_GAS_OVERHEAD,
+} from '@aztec/constants';
 import { asyncMap } from '@aztec/foundation/async-map';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -131,8 +136,11 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCallRequest,
       feePayer,
       /*gasUsedByPrivate*/ teardownCall
-        ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
-        : Gas.empty(),
+        ? new Gas(
+            DEFAULT_TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD,
+            DEFAULT_TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD,
+          )
+        : new Gas(TX_DA_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD),
       defaultGlobals(),
     );
   }
@@ -161,6 +169,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
+    await this.#recordBytecodeSizes(fullTxLabel, [...setupCalls, ...appCalls, ...(teardownCall ? [teardownCall] : [])]);
+
     // Something like this is often useful for debugging:
     //if (avmResult.revertReason) {
     //  // resolve / enrich revert reason
@@ -277,6 +287,27 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     return new PublicCallRequestWithCalldata(request, calldata);
   }
+
+  // WARNING: Deduplicates by artifact name, so two different artifacts with the same name
+  // in a single tx would only record the first one's bytecode size.
+  async #recordBytecodeSizes(txLabel: string, calls: TestEnqueuedCall[]) {
+    const seenArtifactNames = new Set<string>();
+    for (const call of calls) {
+      const artifact = await this.contractDataSource.getContractArtifact(call.address);
+      if (!artifact || seenArtifactNames.has(artifact.name)) {
+        continue;
+      }
+      seenArtifactNames.add(artifact.name);
+      const instance = await this.contractDataSource.getContract(call.address);
+      if (!instance) {
+        continue;
+      }
+      const contractClass = await this.contractDataSource.getContractClass(instance.currentContractClassId);
+      if (contractClass) {
+        this.metrics.recordBytecodeSize(txLabel, artifact.name, contractClass.packedBytecode.length);
+      }
+    }
+  }
 }
 
 export function defaultGlobals() {