@aztec/simulator 0.67.0 → 0.67.1-devnet

package/src/public/enqueued_call_side_effect_trace.ts

@@ -42,7 +42,6 @@ import {
   PublicDataWrite,
   ScopedL2ToL1Message,
   ScopedLogHash,
-  type ScopedNoteHash,
   SerializableContractInstance,
   type TreeSnapshots,
 } from '@aztec/circuits.js';
@@ -74,7 +73,7 @@ export type SideEffects = {
   enqueuedCalls: PublicCallRequest[];
 
   publicDataWrites: PublicDataUpdateRequest[];
-  noteHashes: ScopedNoteHash[];
+  noteHashes: NoteHash[];
   nullifiers: Nullifier[];
   l2ToL1Msgs: ScopedL2ToL1Message[];
 
@@ -111,7 +110,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   private publicDataWrites: PublicDataUpdateRequest[] = [];
   private protocolPublicDataWritesLength: number = 0;
   private userPublicDataWritesLength: number = 0;
-  private noteHashes: ScopedNoteHash[] = [];
+  private noteHashes: NoteHash[] = [];
   private nullifiers: Nullifier[] = [];
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
   private unencryptedLogs: UnencryptedL2Log[] = [];
@@ -194,6 +193,10 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.sideEffectCounter++;
   }
 
+  public getNoteHashCount() {
+    return this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length;
+  }
+
   public tracePublicStorageRead(
     contractAddress: AztecAddress,
     slot: Fr,
@@ -272,19 +275,12 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
-  public traceNewNoteHash(
-    contractAddress: AztecAddress,
-    noteHash: Fr,
-    leafIndex: Fr = Fr.zero(),
-    path: Fr[] = emptyNoteHashPath(),
-  ) {
+  public traceNewNoteHash(noteHash: Fr, leafIndex: Fr = Fr.zero(), path: Fr[] = emptyNoteHashPath()) {
     if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
       throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
     }
 
-    // TODO(dbanks12): make unique and silo instead of scoping
-    //const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
-    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(contractAddress));
+    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
     this.log.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.avmCircuitHints.noteHashWrites.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.incrementSideEffectCounter();

package/src/public/execution.ts

@@ -20,7 +20,6 @@ import {
   RevertCode,
   type ScopedL2ToL1Message,
   type ScopedLogHash,
-  type ScopedNoteHash,
   type TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
@@ -29,7 +28,7 @@ export interface PublicSideEffects {
   /** The contract storage update requests performed. */
   publicDataWrites: PublicDataUpdateRequest[];
   /** The new note hashes to be inserted into the note hashes tree. */
-  noteHashes: ScopedNoteHash[];
+  noteHashes: NoteHash[];
   /** The new nullifiers to be inserted into the nullifier tree. */
   nullifiers: Nullifier[];
   /** The new l2 to l1 messages generated to be inserted into the messages tree. */

package/src/public/fee_payment.ts

@@ -1,13 +1,14 @@
 import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { ProtocolContractAddress, ProtocolContractArtifact } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
 
 /**
  * Computes the storage slot within the Fee Juice contract for the balance of the fee payer.
  */
 export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress) {
-  return deriveStorageSlotInMap(ProtocolContractArtifact.FeeJuice.storageLayout.balances.slot, feePayer);
+  return deriveStorageSlotInMap(FeeJuiceArtifact.storageLayout.balances.slot, feePayer);
 }
 
 /**

package/src/public/fixtures/index.ts

@@ -29,7 +29,7 @@ import { type ContractArtifact, type FunctionArtifact } from '@aztec/foundation/
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
-import { AvmTestContractArtifact } from '@aztec/noir-contracts.js';
+import { AvmTestContractArtifact } from '@aztec/noir-contracts.js/AvmTest';
 import { PublicTxSimulator, WorldStateDB } from '@aztec/simulator';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
@@ -125,7 +125,7 @@ export function createTxForPublicCall(
   }
 
   const teardownGasLimits = isTeardown ? gasLimits : Gas.empty();
-  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty());
+  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
 

package/src/public/public_db_sources.ts

@@ -22,7 +22,8 @@ import {
 import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ContractClassRegisteredEvent, ContractInstanceDeployedEvent } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
 import {
   type CommitmentsDB,
   MessageLoadOracleInputs,
@@ -207,7 +208,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
     const timer = new Timer();
-    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    const index = (await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
     if (!index) {
       return undefined;
     }
@@ -240,7 +241,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
     const timer = new Timer();
 
-    const messageIndex = await this.db.findLeafIndex(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash);
+    const messageIndex = (await this.db.findLeafIndices(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [messageHash]))[0];
     if (messageIndex === undefined) {
       throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
     }
@@ -279,7 +280,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
 
   public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
-    const index = await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
+    const index = (await this.db.findLeafIndices(MerkleTreeId.NOTE_HASH_TREE, [commitment]))[0];
     this.logger.debug(`[DB] Fetched commitment index`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
@@ -301,7 +302,7 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
 
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
-    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    const index = (await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
     this.logger.debug(`[DB] Fetched nullifier index`, {
       eventName: 'public-db-access',
       duration: timer.ms(),

package/src/public/public_processor.ts

@@ -4,7 +4,6 @@ import {
   type MerkleTreeWriteOperations,
   NestedProcessReturnValues,
   type ProcessedTx,
-  type ProcessedTxHandler,
   Tx,
   TxExecutionPhase,
   type TxValidator,
@@ -25,8 +24,9 @@ import {
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ContractClassRegisteredEvent, ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
 import { WorldStateDB } from './public_db_sources.js';
@@ -76,7 +76,7 @@ export class PublicProcessorFactory {
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
  * any public function calls in them. Txs with private calls only are unaffected.
  */
-export class PublicProcessor {
+export class PublicProcessor implements Traceable {
   private metrics: PublicProcessorMetrics;
   constructor(
     protected db: MerkleTreeWriteOperations,
@@ -103,7 +103,6 @@ export class PublicProcessor {
   public async process(
     txs: Tx[],
     maxTransactions = txs.length,
-    processedTxHandler?: ProcessedTxHandler,
     txValidator?: TxValidator<ProcessedTx>,
   ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
@@ -118,80 +117,9 @@ export class PublicProcessor {
         break;
       }
       try {
-        const [processedTx, returnValues] = !tx.hasPublicCalls()
-          ? await this.processPrivateOnlyTx(tx)
-          : await this.processTxWithPublicCalls(tx);
-
-        this.log.verbose(
-          !tx.hasPublicCalls()
-            ? `Processed tx ${processedTx.hash} with no public calls`
-            : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls`,
-          {
-            txHash: processedTx.hash,
-            txFee: processedTx.txEffect.transactionFee.toBigInt(),
-            revertCode: processedTx.txEffect.revertCode.getCode(),
-            revertReason: processedTx.revertReason,
-            gasUsed: processedTx.gasUsed,
-            publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
-            nullifierCount: processedTx.txEffect.nullifiers.length,
-            noteHashCount: processedTx.txEffect.noteHashes.length,
-            contractClassLogCount: processedTx.txEffect.contractClassLogs.getTotalLogCount(),
-            unencryptedLogCount: processedTx.txEffect.unencryptedLogs.getTotalLogCount(),
-            privateLogCount: processedTx.txEffect.privateLogs.length,
-            l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
-          },
-        );
-
-        // Commit the state updates from this transaction
-        await this.worldStateDB.commit();
-
-        // Re-validate the transaction
-        if (txValidator) {
-          // Only accept processed transactions that are not double-spends,
-          // public functions emitting nullifiers would pass earlier check but fail here.
-          // Note that we're checking all nullifiers generated in the private execution twice,
-          // we could store the ones already checked and skip them here as an optimization.
-          const [_, invalid] = await txValidator.validateTxs([processedTx]);
-          if (invalid.length) {
-            throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
-          }
-        }
-        // if we were given a handler then send the transaction to it for block building or proving
-        if (processedTxHandler) {
-          await processedTxHandler.addNewTx(processedTx);
-        }
-        // Update the state so that the next tx in the loop has the correct .startState
-        // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
-        // a) had only 1 tx with public calls per block, so this loop had len 1
-        // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
-        // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
-        // The below is taken from buildBaseRollupHints:
-        await this.db.appendLeaves(
-          MerkleTreeId.NOTE_HASH_TREE,
-          padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-        );
-        try {
-          await this.db.batchInsert(
-            MerkleTreeId.NULLIFIER_TREE,
-            padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
-            NULLIFIER_SUBTREE_HEIGHT,
-          );
-        } catch (error) {
-          if (txValidator) {
-            // Ideally the validator has already caught this above, but just in case:
-            throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
-          } else {
-            // We have no validator and assume this call should blindly process txs with duplicates being caught later
-            this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
-          }
-        }
-
-        await this.db.sequentialInsert(
-          MerkleTreeId.PUBLIC_DATA_TREE,
-          processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
-        );
+        const [processedTx, returnValues] = await this.processTx(tx, txValidator);
         result.push(processedTx);
-        returns = returns.concat(returnValues ?? []);
+        returns = returns.concat(returnValues);
       } catch (err: any) {
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
         this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
@@ -207,6 +135,83 @@ export class PublicProcessor {
     return [result, failed, returns];
   }
 
+  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.tryGetTxHash()?.toString() }))
+  private async processTx(
+    tx: Tx,
+    txValidator?: TxValidator<ProcessedTx>,
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+    const [processedTx, returnValues] = !tx.hasPublicCalls()
+      ? await this.processPrivateOnlyTx(tx)
+      : await this.processTxWithPublicCalls(tx);
+
+    this.log.verbose(
+      !tx.hasPublicCalls()
+        ? `Processed tx ${processedTx.hash} with no public calls`
+        : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls`,
+      {
+        txHash: processedTx.hash,
+        txFee: processedTx.txEffect.transactionFee.toBigInt(),
+        revertCode: processedTx.txEffect.revertCode.getCode(),
+        revertReason: processedTx.revertReason,
+        gasUsed: processedTx.gasUsed,
+        publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
+        nullifierCount: processedTx.txEffect.nullifiers.length,
+        noteHashCount: processedTx.txEffect.noteHashes.length,
+        contractClassLogCount: processedTx.txEffect.contractClassLogs.getTotalLogCount(),
+        unencryptedLogCount: processedTx.txEffect.unencryptedLogs.getTotalLogCount(),
+        privateLogCount: processedTx.txEffect.privateLogs.length,
+        l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
+      },
+    );
+
+    // Commit the state updates from this transaction
+    await this.worldStateDB.commit();
+
+    // Re-validate the transaction
+    if (txValidator) {
+      // Only accept processed transactions that are not double-spends,
+      // public functions emitting nullifiers would pass earlier check but fail here.
+      // Note that we're checking all nullifiers generated in the private execution twice,
+      // we could store the ones already checked and skip them here as an optimization.
+      const [_, invalid] = await txValidator.validateTxs([processedTx]);
+      if (invalid.length) {
+        throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
+      }
+    }
+    // Update the state so that the next tx in the loop has the correct .startState
+    // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
+    // a) had only 1 tx with public calls per block, so this loop had len 1
+    // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
+    // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
+    // The below is taken from buildBaseRollupHints:
+    await this.db.appendLeaves(
+      MerkleTreeId.NOTE_HASH_TREE,
+      padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    );
+    try {
+      await this.db.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
+        NULLIFIER_SUBTREE_HEIGHT,
+      );
+    } catch (error) {
+      if (txValidator) {
+        // Ideally the validator has already caught this above, but just in case:
+        throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
+      } else {
+        // We have no validator and assume this call should blindly process txs with duplicates being caught later
+        this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
+      }
+    }
+
+    await this.db.sequentialInsert(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
+    );
+
+    return [processedTx, returnValues ?? []];
+  }
+
   /**
    * Creates the public data write for paying the tx fee.
    * This is used in private only txs, since for txs with public calls

package/src/public/public_processor_metrics.ts

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

package/src/public/public_tx_context.ts

@@ -10,7 +10,6 @@ import {
   TxHash,
 } from '@aztec/circuit-types';
 import {
-  AppendOnlyTreeSnapshot,
   AvmCircuitInputs,
   type AvmCircuitPublicInputs,
   type AztecAddress,
@@ -19,12 +18,15 @@ import {
   type GasSettings,
   type GlobalVariables,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
   type PrivateToPublicAccumulatedData,
   type PublicCallRequest,
   PublicCircuitPublicInputs,
   RevertCode,
   type StateReference,
   TreeSnapshots,
+  computeTransactionFee,
   countAccumulatedItems,
 } from '@aztec/circuits.js';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -91,7 +93,7 @@ export class PublicTxContext {
     const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
       /*publicDataWrites*/ 0,
       /*protocolPublicDataWrites*/ 0,
-      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.noteHashes),
+      /*noteHashes*/ 0,
       /*nullifiers=*/ 0,
       countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
       /*unencryptedLogsHashes*/ 0,
@@ -102,7 +104,12 @@ export class PublicTxContext {
     );
 
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = await AvmPersistableStateManager.create(worldStateDB, enqueuedCallTrace, doMerkleOperations);
+    const txStateManager = await AvmPersistableStateManager.create(
+      worldStateDB,
+      enqueuedCallTrace,
+      doMerkleOperations,
+      fetchTxHash(nonRevertibleAccumulatedDataFromPrivate),
+    );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
     const gasUsedByPrivate = tx.data.gasUsed;
@@ -186,12 +193,7 @@ export class PublicTxContext {
    * @returns The transaction's hash.
    */
   getTxHash(): TxHash {
-    // Private kernel functions are executed client side and for this reason tx hash is already set as first nullifier
-    const firstNullifier = this.nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
-    if (!firstNullifier || firstNullifier.isZero()) {
-      throw new Error(`Cannot get tx hash since first nullifier is missing`);
-    }
-    return new TxHash(firstNullifier.toBuffer());
+    return fetchTxHash(this.nonRevertibleAccumulatedDataFromPrivate);
   }
 
   /**
@@ -297,12 +299,15 @@ export class PublicTxContext {
    * Should only be called during or after teardown.
    */
   private getTransactionFeeUnsafe(): Fr {
-    const txFee = this.getTotalGasUsed().computeFee(this.globalVariables.gasFees);
+    const gasUsed = this.getTotalGasUsed();
+    const txFee = computeTransactionFee(this.globalVariables.gasFees, this.gasSettings, gasUsed);
+
     this.log.debug(`Computed tx fee`, {
       txFee,
-      gasUsed: inspect(this.getTotalGasUsed()),
+      gasUsed: inspect(gasUsed),
       gasFees: inspect(this.globalVariables.gasFees),
     });
+
     return txFee;
   }
 
@@ -311,16 +316,29 @@ export class PublicTxContext {
    */
   private generateAvmCircuitPublicInputs(endStateReference: StateReference): AvmCircuitPublicInputs {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
-    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 ephemeralTrees = this.state.getActiveStateManager().merkleTrees;
+
+    const noteHashTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE);
+    const nullifierTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE);
+    const publicDataTree = ephemeralTrees.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE);
+    // Pad the note hash and nullifier trees
+    const paddedNoteHashTreeSize =
+      this.startStateReference.partial.noteHashTree.nextAvailableLeafIndex + MAX_NOTE_HASHES_PER_TX;
+    if (noteHashTree.nextAvailableLeafIndex > paddedNoteHashTreeSize) {
+      throw new Error(
+        `Inserted too many leaves in note hash tree: ${noteHashTree.nextAvailableLeafIndex} > ${paddedNoteHashTreeSize}`,
+      );
+    }
+    noteHashTree.nextAvailableLeafIndex = paddedNoteHashTreeSize;
+
+    const paddedNullifierTreeSize =
+      this.startStateReference.partial.nullifierTree.nextAvailableLeafIndex + MAX_NULLIFIERS_PER_TX;
+    if (nullifierTree.nextAvailableLeafIndex > paddedNullifierTreeSize) {
+      throw new Error(
+        `Inserted too many leaves in nullifier tree: ${nullifierTree.nextAvailableLeafIndex} > ${paddedNullifierTreeSize}`,
+      );
+    }
+    nullifierTree.nextAvailableLeafIndex = paddedNullifierTreeSize;
 
     const endTreeSnapshots = new TreeSnapshots(
       endStateReference.l1ToL2MessageTree,
@@ -425,3 +443,12 @@ function applyMaxToAvailableGas(availableGas: Gas) {
     /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION),
   );
 }
+
+function fetchTxHash(nonRevertibleAccumulatedData: PrivateToPublicAccumulatedData): TxHash {
+  // Private kernel functions are executed client side and for this reason tx hash is already set as first nullifier
+  const firstNullifier = nonRevertibleAccumulatedData.nullifiers[0];
+  if (!firstNullifier || firstNullifier.isZero()) {
+    throw new Error(`Cannot get tx hash since first nullifier is missing`);
+  }
+  return new TxHash(firstNullifier.toBuffer());
+}

package/src/public/public_tx_simulator.ts

@@ -378,6 +378,11 @@ export class PublicTxSimulator {
         );
       }
     }
+    for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes) {
+      if (!noteHash.isEmpty()) {
+        stateManager.writeUniqueNoteHash(noteHash);
+      }
+    }
   }
 
   /**
@@ -397,6 +402,12 @@ export class PublicTxSimulator {
         );
       }
     }
+    for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
+      if (!noteHash.isEmpty()) {
+        // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+        stateManager.writeSiloedNoteHash(noteHash);
+      }
+    }
   }
 
   private async payFee(context: PublicTxContext) {

package/src/public/side_effect_trace_interface.ts

@@ -39,7 +39,8 @@ export interface PublicSideEffectTraceInterface {
     insertionPath?: Fr[],
   ): void;
   traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path?: Fr[]): void;
-  traceNewNoteHash(contractAddress: AztecAddress, noteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+  traceNewNoteHash(uniqueNoteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+  getNoteHashCount(): number;
   traceNullifierCheck(
     siloedNullifier: Fr,
     exists: boolean,

package/src/public/transitional_adapters.ts

@@ -6,7 +6,6 @@ import {
   type GasSettings,
   type GlobalVariables,
   MAX_L2_TO_L1_MSGS_PER_TX,
-  MAX_NOTE_HASHES_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
@@ -19,7 +18,6 @@ import {
   countAccumulatedItems,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { assertLength } from '@aztec/foundation/serialize';
 
@@ -86,55 +84,6 @@ export function generateAvmCircuitPublicInputs(
     revertibleAccumulatedDataFromPrivate,
   );
 
-  const txHash = avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.nullifiers[0];
-
-  // Add nonces to revertible note hashes from private. These don't have nonces since we don't know
-  // the final position in the tx until the AVM has executed.
-  // TODO: Use the final position in the tx
-  for (
-    let revertibleIndex = 0;
-    revertibleIndex < avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes.length;
-    revertibleIndex++
-  ) {
-    const noteHash = avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes[revertibleIndex];
-    if (noteHash.isZero()) {
-      continue;
-    }
-    const indexInTx =
-      revertibleIndex + avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths.noteHashes;
-
-    const nonce = computeNoteHashNonce(txHash, indexInTx);
-    const uniqueNoteHash = computeUniqueNoteHash(nonce, noteHash);
-    avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes[revertibleIndex] = uniqueNoteHash;
-  }
-
-  // merge all revertible & non-revertible side effects into output accumulated data
-  const noteHashesFromPrivate = revertCode.isOK()
-    ? mergeAccumulatedData(
-        avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.noteHashes,
-        avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes,
-      )
-    : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.noteHashes;
-  avmCircuitPublicInputs.accumulatedData.noteHashes = assertLength(
-    mergeAccumulatedData(noteHashesFromPrivate, avmCircuitPublicInputs.accumulatedData.noteHashes),
-    MAX_NOTE_HASHES_PER_TX,
-  );
-
-  // Silo and add nonces for note hashes emitted by the AVM
-  const scopedNoteHashesFromPublic = trace.getSideEffects().noteHashes;
-  for (let i = 0; i < scopedNoteHashesFromPublic.length; i++) {
-    const scopedNoteHash = scopedNoteHashesFromPublic[i];
-    const noteHash = scopedNoteHash.value;
-    if (!noteHash.isZero()) {
-      const noteHashIndexInTx = i + countAccumulatedItems(noteHashesFromPrivate);
-      const nonce = computeNoteHashNonce(txHash, noteHashIndexInTx);
-      const siloedNoteHash = siloNoteHash(scopedNoteHash.contractAddress, noteHash);
-      const uniqueNoteHash = computeUniqueNoteHash(nonce, siloedNoteHash);
-
-      avmCircuitPublicInputs.accumulatedData.noteHashes[noteHashIndexInTx] = uniqueNoteHash;
-    }
-  }
-
   const msgsFromPrivate = revertCode.isOK()
     ? mergeAccumulatedData(
         avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs,