@aztec/simulator 0.87.1 → 0.87.2-nightly.20250524

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

@@ -35,6 +35,10 @@ export class DebugLog extends Instruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
+
     const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
     const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
@@ -60,9 +64,5 @@ export class DebugLog extends Instruction {
 
       DebugLog.logger.verbose(formattedStr);
     }
-
-    // Despite having dynamic "size" operands, the gas cost is fixed because
-    // this opcode is a no-op except during client-initiated simulation
-    context.machineState.consumeGas(this.gasCost());
   }
 }

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

@@ -39,14 +39,22 @@ export class SStore extends BaseStorageInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset];
     const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
+    // We read before tag checking since it's needed for gas cost calculation
+    const slot = memory.get(slotOffset).toFr();
+
+    context.machineState.consumeGas(
+      this.dynamicGasCost(Number(context.persistableState.isStorageCold(context.environment.address, slot))),
+    );
+
     memory.checkTag(TypeTag.FIELD, slotOffset);
     memory.checkTag(TypeTag.FIELD, srcOffset);
 
-    const slot = memory.get(slotOffset).toFr();
     const value = memory.get(srcOffset).toFr();
     await context.persistableState.writeStorage(context.environment.address, slot, value);
   }
@@ -64,7 +72,9 @@ export class SLoad extends BaseStorageInstruction {
     const memory = context.machineState.memory;
     const addressing = Addressing.fromWire(this.indirect);
 
-    context.machineState.consumeGas(this.gasCost());
+    context.machineState.consumeGas(
+      this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
+    );
 
     const operands = [this.aOffset, this.bOffset];
     const [slotOffset, dstOffset] = addressing.resolve(operands, memory);

package/src/public/fixtures/index.ts

@@ -1,3 +1,4 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
+export { readAvmMinimalPublicTxInputsFromFile, createAvmMinimalPublicTx } from './minimal_public_tx.js';

package/src/public/fixtures/minimal_public_tx.ts

@@ -0,0 +1,57 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import avmMinimalCircuitInputsJson from '../../../artifacts/avm_minimal_inputs.json' with { type: 'json' };
+import { TypeTag } from '../avm/avm_memory_types.js';
+import { Add, Return, Set } from '../avm/opcodes/index.js';
+import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import { Opcode } from '../avm/serialization/instruction_serialization.js';
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export async function createAvmMinimalPublicTx(): Promise<PublicTxResult> {
+  const deployer = AztecAddress.fromNumber(42);
+
+  const simTester = await PublicTxSimulationTester.create();
+
+  const minimalBytecode = encodeToBytecode([
+    new Set(/*indirect*/ 0, /*dstOffset*/ 0, TypeTag.UINT32, /*value*/ 1).as(Opcode.SET_8, Set.wireFormat8),
+    new Set(/*indirect*/ 0, /*dstOffset*/ 1, TypeTag.UINT32, /*value*/ 2).as(Opcode.SET_8, Set.wireFormat8),
+    new Add(/*indirect=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 2).as(Opcode.ADD_8, Add.wireFormat8),
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 2),
+  ]);
+
+  const minimalContractArtifact = emptyContractArtifact();
+  minimalContractArtifact.name = 'MinimalContract';
+  minimalContractArtifact.functions = [emptyFunctionArtifact()];
+  minimalContractArtifact.functions[0].name = 'public_dispatch';
+  minimalContractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+  minimalContractArtifact.functions[0].bytecode = minimalBytecode;
+
+  const minimalTestContract = await simTester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    /*contractArtifact=*/ minimalContractArtifact,
+  );
+
+  return await simTester.simulateTx(
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: minimalTestContract.address,
+        fnName: 'public_dispatch',
+        args: [],
+      },
+    ],
+  );
+}
+
+/**
+ * Reads the AVM circuit inputs for the minimal public tx from a pre-generated JSON file.
+ * @returns The AvmCircuitInputs for the minimal public tx.
+ */
+export function readAvmMinimalPublicTxInputsFromFile(): AvmCircuitInputs {
+  return AvmCircuitInputs.schema.parse(avmMinimalCircuitInputsJson);
+}

package/src/public/public_tx_simulator/apps_tests/amm_test.ts

@@ -1,3 +1,5 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import { AMMContractArtifact } from '@aztec/noir-contracts.js/AMM';
@@ -137,7 +139,18 @@ async function addLiquidity(
   const liquidityPartialNote = {
     commitment: new Fr(99),
   };
-
+  const refundToken0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    refundToken0PartialNote,
+    amm.address,
+  );
+  const refundToken1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    refundToken1PartialNote,
+    amm.address,
+  );
+  const liquidityPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    liquidityPartialNote,
+    amm.address,
+  );
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/add_liquidity',
     /*sender=*/ sender,
@@ -150,11 +163,11 @@ async function addLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ amount0Max],
         address: token0.address,
       },
-      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // token0.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [refundToken0PartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [refundToken0PartialNoteValidityCommitment],
         address: token0.address,
       },
       // token1.transfer_to_public enqueues a call to _increase_public_balance
@@ -164,18 +177,18 @@ async function addLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ amount1Max],
         address: token1.address,
       },
-      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // token1.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [refundToken1PartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [refundToken1PartialNoteValidityCommitment],
         address: token1.address,
       },
-      // liquidityToken.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // liquidityToken.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: liquidityToken.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [liquidityPartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [liquidityPartialNoteValidityCommitment],
         address: liquidityToken.address,
       },
       // amm.add_liquidity enqueues a call to _add_liquidity
@@ -216,6 +229,10 @@ async function swapExactTokensForTokens(
   const tokenOutPartialNote = {
     commitment: new Fr(66),
   };
+  const tokenOutPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    tokenOutPartialNote,
+    amm.address,
+  );
 
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/swap_exact_tokens_for_tokens',
@@ -229,11 +246,11 @@ async function swapExactTokensForTokens(
         args: [/*to=*/ amm.address, /*amount=*/ amountIn],
         address: tokenIn.address,
       },
-      // tokenOut.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // tokenOut.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: tokenOut.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [tokenOutPartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [tokenOutPartialNoteValidityCommitment],
         address: tokenOut.address,
       },
 
@@ -265,7 +282,14 @@ async function removeLiquidity(
   const token1PartialNote = {
     commitment: new Fr(222),
   };
-
+  const token0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    token0PartialNote,
+    amm.address,
+  );
+  const token1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    token1PartialNote,
+    amm.address,
+  );
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/remove_liquidity',
     /*sender=*/ sender,
@@ -278,18 +302,18 @@ async function removeLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ liquidity],
         address: liquidityToken.address,
       },
-      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // token0.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [token0PartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [token0PartialNoteValidityCommitment],
         address: token0.address,
       },
-      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      // token1.prepare_private_balance_increase enqueues a call to _set_uint_partial_note_validity
       {
         sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
-        fnName: '_store_balances_set_partial_note',
-        args: [token1PartialNote],
+        fnName: '_set_uint_partial_note_validity',
+        args: [token1PartialNoteValidityCommitment],
         address: token1.address,
       },
       // amm.remove_liquidity enqueues a call to _remove_liquidity
@@ -314,3 +338,10 @@ async function removeLiquidity(
     ],
   );
 }
+
+async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
+  return await poseidon2HashWithSeparator(
+    [partialNote.commitment, completer],
+    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
+  );
+}

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -10,7 +10,13 @@ import {
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { AvmAccumulatedData, AvmCircuitPublicInputs, PublicDataWrite, RevertCode } from '@aztec/stdlib/avm';
+import {
+  AvmAccumulatedData,
+  AvmAccumulatedDataArrayLengths,
+  AvmCircuitPublicInputs,
+  PublicDataWrite,
+  RevertCode,
+} from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { SimulationError } from '@aztec/stdlib/errors';
 import { computeTransactionFee } from '@aztec/stdlib/fees';
@@ -18,8 +24,9 @@ import { Gas, GasSettings } from '@aztec/stdlib/gas';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
-  type PrivateToPublicAccumulatedData,
+  PrivateToPublicAccumulatedData,
   PublicCallRequest,
+  PublicCallRequestArrayLengths,
   countAccumulatedItems,
 } from '@aztec/stdlib/kernel';
 import { PublicLog } from '@aztec/stdlib/logs';
@@ -356,12 +363,20 @@ export class PublicTxContext {
     // This converts the private accumulated data to the avm accumulated data format.
     const convertAccumulatedData = (from: PrivateToPublicAccumulatedData) =>
       new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
-    const getArrayLengths = (from: PrivateToPublicAccumulatedData) =>
+    const getPreviousAccumulatedDataArrayLengths = (from: PrivateToPublicAccumulatedData) =>
       new PrivateToAvmAccumulatedDataArrayLengths(
         countAccumulatedItems(from.noteHashes),
         countAccumulatedItems(from.nullifiers),
         countAccumulatedItems(from.l2ToL1Msgs),
       );
+    const getAvmAccumulatedDataArrayLengths = (from: AvmAccumulatedData) =>
+      new AvmAccumulatedDataArrayLengths(
+        from.noteHashes.length,
+        from.nullifiers.length,
+        from.l2ToL1Msgs.length,
+        from.publicLogs.length,
+        from.publicDataWrites.length,
+      );
 
     return new AvmCircuitPublicInputs(
       this.globalVariables,
@@ -369,6 +384,11 @@ export class PublicTxContext {
       /*startGasUsed=*/ this.gasUsedByPrivate,
       this.gasSettings,
       this.feePayer,
+      /*publicCallRequestArrayLengths=*/ new PublicCallRequestArrayLengths(
+        this.setupCallRequests.length,
+        this.appLogicCallRequests.length,
+        this.teardownCallRequests.length > 0,
+      ),
       /*publicSetupCallRequests=*/ padArrayEnd(
         this.setupCallRequests.map(r => r.request),
         PublicCallRequest.empty(),
@@ -382,12 +402,13 @@ export class PublicTxContext {
       /*publicTeardownCallRequests=*/ this.teardownCallRequests.length > 0
         ? this.teardownCallRequests[0].request
         : PublicCallRequest.empty(),
-      getArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate),
-      getArrayLengths(this.revertibleAccumulatedDataFromPrivate),
+      getPreviousAccumulatedDataArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate),
+      getPreviousAccumulatedDataArrayLengths(this.revertibleAccumulatedDataFromPrivate),
       convertAccumulatedData(this.nonRevertibleAccumulatedDataFromPrivate),
       convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate),
       endTreeSnapshots,
       this.getTotalGasUsed(),
+      getAvmAccumulatedDataArrayLengths(accumulatedData),
       accumulatedData,
       /*transactionFee=*/ this.getTransactionFeeUnsafe(),
       /*isReverted=*/ !this.revertCode.isOK(),

package/src/public/side_effect_trace.ts

@@ -82,6 +82,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     private readonly previousSideEffectArrayLengths: SideEffectArrayLengths = SideEffectArrayLengths.empty(),
     /** We need to track the set of class IDs used, to enforce limits. */
     private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
+    private writtenPublicDataSlots: Set<string> = new Set(),
   ) {
     this.sideEffectCounter = startSideEffectCounter;
   }
@@ -98,6 +99,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
         this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length,
       ),
       this.uniqueClassIds.fork(),
+      new Set(this.writtenPublicDataSlots),
     );
   }
 
@@ -111,6 +113,8 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
     this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
+    // Accept even if reverted, since the user already paid for the writes
+    this.writtenPublicDataSlots = new Set(forkedTrace.writtenPublicDataSlots);
 
     if (!reverted) {
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
@@ -170,6 +174,15 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       `Traced public data write (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter}, isProtocol:${protocolWrite})`,
     );
     this.incrementSideEffectCounter();
+    this.writtenPublicDataSlots.add(this.computePublicDataSlotKey(contractAddress, slot));
+  }
+
+  private computePublicDataSlotKey(contractAddress: AztecAddress, slot: Fr): string {
+    return `${contractAddress.toString()}:${slot.toString()}`;
+  }
+
+  public isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean {
+    return !this.writtenPublicDataSlots.has(this.computePublicDataSlotKey(contractAddress, slot));
   }
 
   public traceNewNoteHash(noteHash: Fr) {

package/src/public/side_effect_trace_interface.ts

@@ -12,6 +12,7 @@ export interface PublicSideEffectTraceInterface {
     value: Fr,
     protocolWrite: boolean,
   ): Promise<void>;
+  isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
   traceNewNoteHash(uniqueNoteHash: Fr): void;
   getNoteHashCount(): number;
   traceNewNullifier(siloedNullifier: Fr): void;

package/src/public/state_manager/state_manager.ts

@@ -148,6 +148,10 @@ export class PublicPersistableStateManager {
     await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
   }
 
+  public isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean {
+    return this.trace.isStorageCold(contractAddress, slot);
+  }
+
   /**
    * Read from public storage.
    *