@aztec/txe 0.71.0 → 0.73.0

package/src/oracle/txe_oracle.ts

@@ -1,6 +1,10 @@
 import {
   AuthWitness,
+  Body,
+  L2Block,
   MerkleTreeId,
+  type MerkleTreeReadOperations,
+  type MerkleTreeWriteOperations,
   Note,
   type NoteStatus,
   NullifierMembershipWitness,
@@ -13,6 +17,7 @@ import {
 } from '@aztec/circuit-types';
 import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
+  AppendOnlyTreeSnapshot,
   BlockHeader,
   CallContext,
   type ContractInstance,
@@ -24,8 +29,11 @@ import {
   IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
   NULLIFIER_SUBTREE_HEIGHT,
   type NULLIFIER_TREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   type NullifierLeafPreimage,
   PRIVATE_CONTEXT_INPUTS_LENGTH,
   type PUBLIC_DATA_TREE_HEIGHT,
@@ -34,7 +42,8 @@ import {
   type PrivateLog,
   PublicDataTreeLeaf,
   type PublicDataTreeLeafPreimage,
-  type PublicDataWrite,
+  PublicDataWrite,
+  type PublicLog,
   computeContractClassId,
   computeTaggingSecretPoint,
   deriveKeys,
@@ -48,6 +57,12 @@ import {
   siloNoteHash,
   siloNullifier,
 } from '@aztec/circuits.js/hash';
+import {
+  makeAppendOnlyTreeSnapshot,
+  makeContentCommitment,
+  makeGlobalVariables,
+  makeHeader,
+} from '@aztec/circuits.js/testing';
 import {
   type ContractArtifact,
   type FunctionAbi,
@@ -56,6 +71,7 @@ import {
   countArgumentsSize,
 } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type LogFn, type Logger, applyStringFormatting, createDebugOnlyLogger } from '@aztec/foundation/log';
@@ -84,7 +100,7 @@ import {
   createSimulationError,
   resolveAssertionMessageFromError,
 } from '@aztec/simulator/server';
-import { MerkleTreeSnapshotOperationsFacade, type MerkleTrees } from '@aztec/world-state';
+import { type NativeWorldStateService } from '@aztec/world-state';
 
 import { TXENode } from '../node/txe_node.js';
 import { type TXEDatabase } from '../util/txe_database.js';
@@ -92,9 +108,8 @@ import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_so
 import { TXEWorldStateDB } from '../util/txe_world_state_db.js';
 
 export class TXE implements TypedOracle {
-  private blockNumber = 0;
+  private blockNumber = 1;
   private sideEffectCounter = 0;
-  private contractAddress: AztecAddress;
   private msgSender: AztecAddress;
   private functionSelector = FunctionSelector.fromField(new Fr(0));
   private isStaticCall = false;
@@ -104,10 +119,11 @@ export class TXE implements TypedOracle {
   private contractDataOracle: ContractDataOracle;
   private simulatorOracle: SimulatorOracle;
 
+  private publicDataWrites: PublicDataWrite[] = [];
   private uniqueNoteHashesFromPublic: Fr[] = [];
   private siloedNullifiersFromPublic: Fr[] = [];
   private privateLogs: PrivateLog[] = [];
-  private publicLogs: UnencryptedL2Log[] = [];
+  private publicLogs: PublicLog[] = [];
 
   private committedBlocks = new Set<number>();
 
@@ -122,18 +138,19 @@ export class TXE implements TypedOracle {
 
   debug: LogFn;
 
-  constructor(
+  private constructor(
     private logger: Logger,
-    private trees: MerkleTrees,
     private executionCache: HashedValuesCache,
     private keyStore: KeyStore,
     private txeDatabase: TXEDatabase,
+    private contractAddress: AztecAddress,
+    private nativeWorldStateService: NativeWorldStateService,
+    private baseFork: MerkleTreeWriteOperations,
   ) {
     this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
     this.contractDataOracle = new ContractDataOracle(txeDatabase);
-    this.contractAddress = AztecAddress.random();
 
-    this.node = new TXENode(this.blockNumber, this.VERSION, this.CHAIN_ID, this.trees);
+    this.node = new TXENode(this.blockNumber, this.VERSION, this.CHAIN_ID, nativeWorldStateService, baseFork);
 
     // Default msg_sender (for entrypoints) is now Fr.max_value rather than 0 addr (see #7190 & #7404)
     this.msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE);
@@ -148,14 +165,33 @@ export class TXE implements TypedOracle {
     this.debug = createDebugOnlyLogger('aztec:kv-pxe-database');
   }
 
+  static async create(
+    logger: Logger,
+    executionCache: HashedValuesCache,
+    keyStore: KeyStore,
+    txeDatabase: TXEDatabase,
+    nativeWorldStateService: NativeWorldStateService,
+    baseFork: MerkleTreeWriteOperations,
+  ) {
+    return new TXE(
+      logger,
+      executionCache,
+      keyStore,
+      txeDatabase,
+      await AztecAddress.random(),
+      nativeWorldStateService,
+      baseFork,
+    );
+  }
+
   // Utils
 
-  async #getTreesAt(blockNumber: number) {
-    const db =
-      blockNumber === (await this.getBlockNumber())
-        ? await this.trees.getLatest()
-        : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-    return db;
+  getNativeWorldStateService() {
+    return this.nativeWorldStateService;
+  }
+
+  getBaseFork() {
+    return this.baseFork;
   }
 
   getChainId(): Promise<Fr> {
@@ -199,10 +235,6 @@ export class TXE implements TypedOracle {
     this.node.setBlockNumber(blockNumber);
   }
 
-  getTrees() {
-    return this.trees;
-  }
-
   getContractDataOracle() {
     return this.contractDataOracle;
   }
@@ -220,8 +252,8 @@ export class TXE implements TypedOracle {
   }
 
   async addContractArtifact(artifact: ContractArtifact) {
-    const contractClass = getContractClassFromArtifact(artifact);
-    await this.txeDatabase.addContractArtifact(computeContractClassId(contractClass), artifact);
+    const contractClass = await getContractClassFromArtifact(artifact);
+    await this.txeDatabase.addContractArtifact(await computeContractClassId(contractClass), artifact);
   }
 
   async getPrivateContextInputs(
@@ -229,10 +261,21 @@ export class TXE implements TypedOracle {
     sideEffectsCounter = this.sideEffectCounter,
     isStaticCall = false,
   ) {
-    const db = await this.#getTreesAt(blockNumber);
-    const previousBlockState = await this.#getTreesAt(blockNumber - 1);
+    if (blockNumber > this.blockNumber) {
+      throw new Error(
+        `Tried to request private context inputs for ${blockNumber}, which is greater than our current block number of ${this.blockNumber}`,
+      );
+    } else if (blockNumber === this.blockNumber) {
+      this.logger.debug(
+        `Tried to request private context inputs for ${blockNumber}, equal to current block of ${this.blockNumber}. Clamping to current block - 1.`,
+      );
+      blockNumber = this.blockNumber - 1;
+    }
+
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+    const previousBlockState = this.nativeWorldStateService.getSnapshot(blockNumber - 1);
 
-    const stateReference = await db.getStateReference();
+    const stateReference = await snap.getStateReference();
     const inputs = PrivateContextInputs.empty();
     inputs.txContext.chainId = new Fr(await this.node.getChainId());
     inputs.txContext.version = new Fr(await this.node.getVersion());
@@ -254,32 +297,23 @@ export class TXE implements TypedOracle {
     const account = await this.txeDatabase.getAccount(address);
     const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
     const schnorr = new Schnorr();
-    const signature = schnorr.constructSignature(messageHash.toBuffer(), privateKey).toBuffer();
-    const authWitness = new AuthWitness(messageHash, [...signature]);
+    const signature = await schnorr.constructSignature(messageHash.toBuffer(), privateKey);
+    const authWitness = new AuthWitness(messageHash, [...signature.toBuffer()]);
     return this.txeDatabase.addAuthWitness(authWitness.requestHash, authWitness.witness);
   }
 
   async addPublicDataWrites(writes: PublicDataWrite[]) {
-    const db = await this.trees.getLatest();
-    await db.batchInsert(
+    this.publicDataWrites.push(...writes);
+
+    await this.baseFork.sequentialInsert(
       MerkleTreeId.PUBLIC_DATA_TREE,
       writes.map(w => new PublicDataTreeLeaf(w.leafSlot, w.value).toBuffer()),
-      0,
-    );
-  }
-
-  async addSiloedNullifiers(siloedNullifiers: Fr[]) {
-    const db = await this.trees.getLatest();
-    await db.batchInsert(
-      MerkleTreeId.NULLIFIER_TREE,
-      siloedNullifiers.map(n => n.toBuffer()),
-      NULLIFIER_SUBTREE_HEIGHT,
     );
   }
 
   async checkNullifiersNotInTree(contractAddress: AztecAddress, nullifiers: Fr[]) {
-    const siloedNullifiers = nullifiers.map(nullifier => siloNullifier(contractAddress, nullifier));
-    const db = await this.trees.getLatest();
+    const siloedNullifiers = await Promise.all(nullifiers.map(nullifier => siloNullifier(contractAddress, nullifier)));
+    const db = this.baseFork;
     const nullifierIndexesInTree = await db.findLeafIndices(
       MerkleTreeId.NULLIFIER_TREE,
       siloedNullifiers.map(n => n.toBuffer()),
@@ -289,61 +323,29 @@ export class TXE implements TypedOracle {
     }
   }
 
-  async addSiloedNullifiersFromPublic(siloedNullifiers: Fr[]) {
+  addSiloedNullifiersFromPublic(siloedNullifiers: Fr[]) {
     this.siloedNullifiersFromPublic.push(...siloedNullifiers);
-
-    await this.addSiloedNullifiers(siloedNullifiers);
-  }
-
-  async addNullifiers(contractAddress: AztecAddress, nullifiers: Fr[]) {
-    const siloedNullifiers = nullifiers.map(nullifier => siloNullifier(contractAddress, nullifier));
-    await this.addSiloedNullifiers(siloedNullifiers);
-  }
-
-  async addUniqueNoteHashes(siloedNoteHashes: Fr[]) {
-    const db = await this.trees.getLatest();
-    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, siloedNoteHashes);
   }
 
-  async addUniqueNoteHashesFromPublic(siloedNoteHashes: Fr[]) {
+  addUniqueNoteHashesFromPublic(siloedNoteHashes: Fr[]) {
     this.uniqueNoteHashesFromPublic.push(...siloedNoteHashes);
-    await this.addUniqueNoteHashes(siloedNoteHashes);
   }
 
-  async addNoteHashes(contractAddress: AztecAddress, noteHashes: Fr[]) {
-    const siloedNoteHashes = noteHashes.map(noteHash => siloNoteHash(contractAddress, noteHash));
-
-    await this.addUniqueNoteHashes(siloedNoteHashes);
-  }
-
-  addPrivateLogs(contractAddress: AztecAddress, privateLogs: PrivateLog[]) {
-    privateLogs.forEach(privateLog => {
-      privateLog.fields[0] = poseidon2Hash([contractAddress, privateLog.fields[0]]);
-    });
+  async addPrivateLogs(contractAddress: AztecAddress, privateLogs: PrivateLog[]) {
+    for (const privateLog of privateLogs) {
+      privateLog.fields[0] = await poseidon2Hash([contractAddress, privateLog.fields[0]]);
+    }
 
     this.privateLogs.push(...privateLogs);
   }
 
-  addPublicLogs(logs: UnencryptedL2Log[]) {
+  addPublicLogs(logs: PublicLog[]) {
     logs.forEach(log => {
-      if (log.data.length < 32 * 33) {
-        // TODO remove when #9835 and #9836 are fixed
-        this.logger.warn(`Skipping unencrypted log with insufficient data length: ${log.data.length}`);
-        return;
-      }
       try {
-        // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
-        // This means that for every 32 bytes of payload, we only have 1 byte of data.
-        // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
-        const correctedBuffer = Buffer.alloc(32);
-        const initialOffset = 32;
-        for (let i = 0; i < 32; i++) {
-          const byte = Fr.fromBuffer(log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset)).toNumber();
-          correctedBuffer.writeUInt8(byte, i);
-        }
-        const tag = new Fr(correctedBuffer);
-
-        this.logger.verbose(`Found tagged unencrypted log with tag ${tag.toString()} in block ${this.blockNumber}`);
+        // The first elt stores lengths => tag is in fields[1]
+        const tag = log.log[1];
+
+        this.logger.verbose(`Found tagged public log with tag ${tag.toString()} in block ${this.blockNumber}`);
         this.publicLogs.push(log);
       } catch (err) {
         this.logger.warn(`Failed to add tagged log to store: ${err}`);
@@ -373,12 +375,8 @@ export class TXE implements TypedOracle {
     return Fr.random();
   }
 
-  storeArrayInExecutionCache(values: Fr[]) {
-    return Promise.resolve(this.executionCache.store(values));
-  }
-
   storeInExecutionCache(values: Fr[]) {
-    return Promise.resolve(this.executionCache.store(values));
+    return this.executionCache.store(values);
   }
 
   loadFromExecutionCache(returnsHash: Fr) {
@@ -398,34 +396,36 @@ export class TXE implements TypedOracle {
   }
 
   async getMembershipWitness(blockNumber: number, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined> {
-    const db = await this.#getTreesAt(blockNumber);
-    const index = (await db.findLeafIndices(treeId, [leafValue.toBuffer()]))[0];
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+    const index = (await snap.findLeafIndices(treeId, [leafValue.toBuffer()]))[0];
     if (index === undefined) {
       throw new Error(`Leaf value: ${leafValue} not found in ${MerkleTreeId[treeId]} at block ${blockNumber}`);
     }
-    const siblingPath = await db.getSiblingPath(treeId, index);
+    const siblingPath = await snap.getSiblingPath(treeId, index);
 
     return [new Fr(index), ...siblingPath.toFields()];
   }
 
-  // async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
-  //   const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
-  //   const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
-  //   return result.toFields();
-  // }
+  async getSiblingPath(blockNumber: number, treeId: MerkleTreeId, leafIndex: Fr) {
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+
+    const result = await snap.getSiblingPath(treeId, leafIndex.toBigInt());
+    return result.toFields();
+  }
 
   async getNullifierMembershipWitness(
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    const db = await this.#getTreesAt(blockNumber);
-    const index = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+
+    const [index] = await snap.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]);
     if (!index) {
       return undefined;
     }
 
-    const leafPreimagePromise = db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-    const siblingPathPromise = db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
+    const leafPreimagePromise = snap.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    const siblingPathPromise = snap.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
       MerkleTreeId.NULLIFIER_TREE,
       BigInt(index),
     );
@@ -440,16 +440,17 @@ export class TXE implements TypedOracle {
   }
 
   async getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    const db = await this.#getTreesAt(blockNumber);
-    const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+
+    const lowLeafResult = await snap.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
     if (!lowLeafResult) {
       return undefined;
     } else {
-      const preimage = (await db.getLeafPreimage(
+      const preimage = (await snap.getLeafPreimage(
         MerkleTreeId.PUBLIC_DATA_TREE,
         lowLeafResult.index,
       )) as PublicDataTreeLeafPreimage;
-      const path = await db.getSiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>(
+      const path = await snap.getSiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>(
         MerkleTreeId.PUBLIC_DATA_TREE,
         lowLeafResult.index,
       );
@@ -461,8 +462,9 @@ export class TXE implements TypedOracle {
     blockNumber: number,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    const committedDb = await this.#getTreesAt(blockNumber);
-    const findResult = await committedDb.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+
+    const findResult = await snap.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
     if (!findResult) {
       return undefined;
     }
@@ -470,9 +472,9 @@ export class TXE implements TypedOracle {
     if (alreadyPresent) {
       this.logger.warn(`Nullifier ${nullifier.toBigInt()} already exists in the tree`);
     }
-    const preimageData = (await committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))!;
+    const preimageData = (await snap.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))!;
 
-    const siblingPath = await committedDb.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
+    const siblingPath = await snap.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
       MerkleTreeId.NULLIFIER_TREE,
       BigInt(index),
     );
@@ -480,10 +482,26 @@ export class TXE implements TypedOracle {
   }
 
   async getBlockHeader(blockNumber: number): Promise<BlockHeader | undefined> {
-    const header = BlockHeader.empty();
-    const db = await this.#getTreesAt(blockNumber);
-    header.state = await db.getStateReference();
-    header.globalVariables.blockNumber = new Fr(blockNumber);
+    if (blockNumber === 1) {
+      // TODO: Figure out why native merkle trees cannot get snapshot of 0, as it defaults to latest
+      throw new Error('Cannot get the block header of block number 1');
+    }
+
+    const snap = this.nativeWorldStateService.getSnapshot(blockNumber);
+    const stateReference = await snap.getStateReference();
+
+    const previousState = this.nativeWorldStateService.getSnapshot(blockNumber - 1);
+    const archiveInfo = await previousState.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    const header = new BlockHeader(
+      new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+      makeContentCommitment(),
+      stateReference,
+      makeGlobalVariables(),
+      Fr.ZERO,
+      Fr.ZERO,
+    );
+
     return header;
   }
 
@@ -564,21 +582,20 @@ export class TXE implements TypedOracle {
 
   async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
-    this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
+    await this.noteCache.nullifyNote(this.contractAddress, innerNullifier, noteHash);
     this.sideEffectCounter = counter + 1;
-    return Promise.resolve();
   }
 
   async notifyCreatedNullifier(innerNullifier: Fr): Promise<void> {
     await this.checkNullifiersNotInTree(this.contractAddress, [innerNullifier]);
-    this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
-    return Promise.resolve();
+    await this.noteCache.nullifierCreated(this.contractAddress, innerNullifier);
   }
 
   async checkNullifierExists(innerNullifier: Fr): Promise<boolean> {
-    const nullifier = siloNullifier(this.contractAddress, innerNullifier!);
-    const db = await this.trees.getLatest();
-    const index = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    const snap = this.nativeWorldStateService.getSnapshot(this.blockNumber - 1);
+
+    const nullifier = await siloNullifier(this.contractAddress, innerNullifier!);
+    const [index] = await snap.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]);
     return index !== undefined;
   }
 
@@ -596,11 +613,17 @@ export class TXE implements TypedOracle {
     blockNumber: number,
     numberOfElements: number,
   ): Promise<Fr[]> {
-    const db = await this.#getTreesAt(blockNumber);
+    let db: MerkleTreeReadOperations;
+    if (blockNumber === this.blockNumber) {
+      db = this.baseFork;
+    } else {
+      db = this.nativeWorldStateService.getSnapshot(blockNumber);
+    }
+
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = startStorageSlot.add(new Fr(i));
-      const leafSlot = computePublicDataTreeLeafSlot(contractAddress, storageSlot).toBigInt();
+      const leafSlot = (await computePublicDataTreeLeafSlot(contractAddress, storageSlot)).toBigInt();
 
       const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
 
@@ -619,18 +642,15 @@ export class TXE implements TypedOracle {
   }
 
   async storageWrite(startStorageSlot: Fr, values: Fr[]): Promise<Fr[]> {
-    const db = await this.trees.getLatest();
-
-    const publicDataWrites = values.map((value, i) => {
-      const storageSlot = startStorageSlot.add(new Fr(i));
-      this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
-      return new PublicDataTreeLeaf(computePublicDataTreeLeafSlot(this.contractAddress, storageSlot), value);
-    });
-    await db.batchInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      publicDataWrites.map(write => write.toBuffer()),
-      0,
+    const publicDataWrites = await Promise.all(
+      values.map(async (value, i) => {
+        const storageSlot = startStorageSlot.add(new Fr(i));
+        this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
+        return new PublicDataWrite(await computePublicDataTreeLeafSlot(this.contractAddress, storageSlot), value);
+      }),
     );
+
+    await this.addPublicDataWrites(publicDataWrites);
     return publicDataWrites.map(write => write.value);
   }
 
@@ -643,35 +663,91 @@ export class TXE implements TypedOracle {
       this.committedBlocks.add(blockNumber);
     }
 
+    const fork = this.baseFork;
+
     const txEffect = TxEffect.empty();
 
     const nonceGenerator = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
 
     let i = 0;
-    txEffect.noteHashes = [
-      ...this.noteCache
+    const uniqueNoteHashesFromPrivate = await Promise.all(
+      this.noteCache
         .getAllNotes()
-        .map(pendingNote =>
+        .map(async pendingNote =>
           computeUniqueNoteHash(
-            computeNoteHashNonce(nonceGenerator, i++),
-            siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption),
+            await computeNoteHashNonce(nonceGenerator, i++),
+            await siloNoteHash(pendingNote.note.contractAddress, pendingNote.noteHashForConsumption),
           ),
         ),
-      ...this.uniqueNoteHashesFromPublic,
-    ];
+    );
+    txEffect.noteHashes = [...uniqueNoteHashesFromPrivate, ...this.uniqueNoteHashesFromPublic];
 
-    txEffect.nullifiers = this.noteCache.getAllNullifiers();
+    txEffect.nullifiers = [...this.siloedNullifiersFromPublic, ...this.noteCache.getAllNullifiers()];
     if (usedTxRequestHashForNonces) {
       txEffect.nullifiers.unshift(this.getTxRequestHash());
     }
-    this.node.setTxEffect(blockNumber, new TxHash(new Fr(blockNumber)), txEffect);
+
+    txEffect.publicDataWrites = this.publicDataWrites;
+
+    const body = new Body([txEffect]);
+
+    const l2Block = new L2Block(
+      makeAppendOnlyTreeSnapshot(blockNumber + 1),
+      makeHeader(0, blockNumber, blockNumber),
+      body,
+    );
+
+    const paddedTxEffects = l2Block.body.txEffects;
+
+    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
+
+    {
+      const noteHashesPadded = paddedTxEffects.flatMap(txEffect =>
+        padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+      );
+      await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+
+      await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+    }
+
+    {
+      for (const txEffect of paddedTxEffects) {
+        // We do not need to add public data writes because we apply them as we go. We use the sequentialInsert because
+        // the batchInsert was not working when updating a previously updated slot.
+
+        const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
+
+        await fork.batchInsert(
+          MerkleTreeId.NULLIFIER_TREE,
+          nullifiersPadded.map(nullifier => nullifier.toBuffer()),
+          NULLIFIER_SUBTREE_HEIGHT,
+        );
+      }
+    }
+
+    await this.node.setTxEffect(blockNumber, new TxHash(new Fr(blockNumber)), txEffect);
     this.node.setNullifiersIndexesWithBlock(blockNumber, txEffect.nullifiers);
     this.node.addNoteLogsByTags(this.blockNumber, this.privateLogs);
     this.node.addPublicLogsByTags(this.blockNumber, this.publicLogs);
 
-    await this.addUniqueNoteHashes(txEffect.noteHashes);
-    await this.addSiloedNullifiers(txEffect.nullifiers);
+    const stateReference = await fork.getStateReference();
+    const archiveInfo = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+    const header = new BlockHeader(
+      new AppendOnlyTreeSnapshot(new Fr(archiveInfo.root), Number(archiveInfo.size)),
+      makeContentCommitment(),
+      stateReference,
+      makeGlobalVariables(),
+      Fr.ZERO,
+      Fr.ZERO,
+    );
+
+    l2Block.header = header;
 
+    await fork.updateArchive(l2Block.header);
+
+    await this.nativeWorldStateService.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
+
+    this.publicDataWrites = [];
     this.privateLogs = [];
     this.publicLogs = [];
     this.uniqueNoteHashesFromPublic = [];
@@ -750,7 +826,7 @@ export class TXE implements TypedOracle {
     const endSideEffectCounter = publicInputs.endSideEffectCounter;
     this.sideEffectCounter = endSideEffectCounter.toNumber() + 1;
 
-    this.addPrivateLogs(
+    await this.addPrivateLogs(
       targetContractAddress,
       publicInputs.privateLogs.filter(privateLog => !privateLog.isEmpty()).map(privateLog => privateLog.log),
     );
@@ -794,22 +870,25 @@ export class TXE implements TypedOracle {
     if (!artifact) {
       return undefined;
     }
-
-    const f = artifact.functions.find(f =>
-      FunctionSelector.fromNameAndParameters(f.name, f.parameters).equals(selector),
+    const functionSelectorsAndNames = await Promise.all(
+      artifact.functions.map(async f => ({
+        name: f.name,
+        selector: await FunctionSelector.fromNameAndParameters(f.name, f.parameters),
+      })),
     );
-    if (!f) {
+    const functionSelectorAndName = functionSelectorsAndNames.find(f => f.selector.equals(selector));
+    if (!functionSelectorAndName) {
       return undefined;
     }
 
-    return `${artifact.name}:${f.name}`;
+    return `${artifact.name}:${functionSelectorAndName.name}`;
   }
 
   private async executePublicFunction(args: Fr[], callContext: CallContext, isTeardown: boolean = false) {
     const executionRequest = new PublicExecutionRequest(callContext, args);
 
-    const db = await this.trees.getLatest();
-    const worldStateDb = new TXEWorldStateDB(db, new TXEPublicContractDataSource(this));
+    const db = this.baseFork;
+    const worldStateDb = new TXEWorldStateDB(db, new TXEPublicContractDataSource(this), this);
 
     const globalVariables = GlobalVariables.empty();
     globalVariables.chainId = new Fr(await this.node.getChainId());
@@ -817,38 +896,65 @@ export class TXE implements TypedOracle {
     globalVariables.blockNumber = new Fr(this.blockNumber);
     globalVariables.gasFees = new GasFees(1, 1);
 
+    const tempFork = await this.nativeWorldStateService.fork();
+    // Apply current public data writes
+    await tempFork.sequentialInsert(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      this.publicDataWrites.map(p => p.toBuffer()),
+    );
+
     // If the contract instance exists in the TXE's world state, make sure its nullifier is present in the tree
     // so its nullifier check passes.
     if ((await worldStateDb.getContractInstance(callContext.contractAddress)) !== undefined) {
-      const contractAddressNullifier = siloNullifier(
+      const contractAddressNullifier = await siloNullifier(
         AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
         callContext.contractAddress.toField(),
       );
       if ((await worldStateDb.getNullifierIndex(contractAddressNullifier)) === undefined) {
-        await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+        await tempFork.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
       }
     }
 
     const simulator = new PublicTxSimulator(
-      db,
-      new TXEWorldStateDB(db, new TXEPublicContractDataSource(this)),
+      tempFork,
+      new TXEWorldStateDB(tempFork, new TXEPublicContractDataSource(this), this),
       globalVariables,
     );
 
+    const { usedTxRequestHashForNonces } = this.noteCache.finish();
+    const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
+
     // When setting up a teardown call, we tell it that
     // private execution used Gas(1, 1) so it can compute a tx fee.
     const gasUsedByPrivate = isTeardown ? new Gas(1, 1) : Gas.empty();
-    const tx = createTxForPublicCalls(
+    const tx = await createTxForPublicCalls(
+      firstNullifier,
       /*setupExecutionRequests=*/ [],
       /*appExecutionRequests=*/ isTeardown ? [] : [executionRequest],
       /*teardownExecutionRequests=*/ isTeardown ? executionRequest : undefined,
+      /*feePayer=*/ AztecAddress.zero(),
       gasUsedByPrivate,
     );
 
     const result = await simulator.simulate(tx);
+    const noteHashes = result.avmProvingRequest.inputs.publicInputs.accumulatedData.noteHashes.filter(
+      s => !s.isEmpty(),
+    );
+
+    const publicDataWrites = result.avmProvingRequest.inputs.publicInputs.accumulatedData.publicDataWrites.filter(
+      s => !s.isEmpty(),
+    );
+    await this.addPublicDataWrites(publicDataWrites);
+
+    this.addUniqueNoteHashesFromPublic(noteHashes);
 
-    this.addPublicLogs(tx.unencryptedLogs.unrollLogs());
+    this.addPublicLogs(
+      result.avmProvingRequest.inputs.publicInputs.accumulatedData.publicLogs.filter(
+        log => !log.contractAddress.equals(AztecAddress.ZERO),
+      ),
+    );
 
+    await tempFork.close();
     return Promise.resolve(result);
   }
 
@@ -876,7 +982,7 @@ export class TXE implements TypedOracle {
     );
 
     const args = [this.functionSelector.toField(), ...this.executionCache.getPreimage(argsHash)];
-    const newArgsHash = this.executionCache.store(args);
+    const newArgsHash = await this.executionCache.store(args);
 
     const executionResult = await this.executePublicFunction(args, callContext, isTeardown);
 
@@ -896,13 +1002,14 @@ export class TXE implements TypedOracle {
     }
 
     // Apply side effects
-    const sideEffects = executionResult.avmProvingRequest.inputs.output.accumulatedData;
-    const publicDataWrites = sideEffects.publicDataWrites.filter(s => !s.isEmpty());
-    const noteHashes = sideEffects.noteHashes.filter(s => !s.isEmpty());
-    const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty());
-    await this.addPublicDataWrites(publicDataWrites);
-    await this.addUniqueNoteHashesFromPublic(noteHashes);
-    await this.addSiloedNullifiers(nullifiers);
+    const sideEffects = executionResult.avmProvingRequest.inputs.publicInputs.accumulatedData;
+
+    const { usedTxRequestHashForNonces } = this.noteCache.finish();
+    const firstNullifier = usedTxRequestHashForNonces ? this.getTxRequestHash() : this.noteCache.getAllNullifiers()[0];
+    const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty()).filter(s => !s.equals(firstNullifier));
+
+    // For some reason we cannot move this up to 'executePublicFunction'. It gives us an error of trying to modify the same nullifier twice.
+    this.addSiloedNullifiersFromPublic(nullifiers);
 
     this.setContractAddress(currentContractAddress);
     this.setMsgSender(currentMessageSender);
@@ -930,8 +1037,8 @@ export class TXE implements TypedOracle {
     );
   }
 
-  notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
-    this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+  async notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
+    await this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
   }
 
   debugLog(message: string, fields: Fr[]): void {
@@ -953,7 +1060,7 @@ export class TXE implements TypedOracle {
   async #calculateAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
     const senderCompleteAddress = await this.getCompleteAddress(sender);
     const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-    const secretPoint = computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
+    const secretPoint = await computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
     // Silo the secret to the app so it can't be used to track other app's notes
     const appSecret = poseidon2Hash([secretPoint.x, secretPoint.y, contractAddress]);
     return appSecret;
@@ -1010,13 +1117,17 @@ export class TXE implements TypedOracle {
 
     // Apply side effects
     if (executionResult.revertCode.isOK()) {
-      const sideEffects = executionResult.avmProvingRequest.inputs.output.accumulatedData;
+      const sideEffects = executionResult.avmProvingRequest.inputs.publicInputs.accumulatedData;
       const publicDataWrites = sideEffects.publicDataWrites.filter(s => !s.isEmpty());
       const noteHashes = sideEffects.noteHashes.filter(s => !s.isEmpty());
-      const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty());
+      const { usedTxRequestHashForNonces } = this.noteCache.finish();
+      const firstNullifier = usedTxRequestHashForNonces
+        ? this.getTxRequestHash()
+        : this.noteCache.getAllNullifiers()[0];
+      const nullifiers = sideEffects.nullifiers.filter(s => !s.isEmpty()).filter(s => !s.equals(firstNullifier));
       await this.addPublicDataWrites(publicDataWrites);
-      await this.addUniqueNoteHashes(noteHashes);
-      await this.addSiloedNullifiers(nullifiers);
+      this.addUniqueNoteHashesFromPublic(noteHashes);
+      this.addSiloedNullifiersFromPublic(nullifiers);
     }
 
     this.setContractAddress(currentContractAddress);
@@ -1034,37 +1145,35 @@ export class TXE implements TypedOracle {
   }
 
   async avmOpcodeNullifierExists(innerNullifier: Fr, targetAddress: AztecAddress): Promise<boolean> {
-    const nullifier = siloNullifier(targetAddress, innerNullifier!);
-    const db = await this.trees.getLatest();
+    const nullifier = await siloNullifier(targetAddress, innerNullifier!);
+    const db = this.baseFork;
     const index = (await db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
     return index !== undefined;
   }
 
   async avmOpcodeEmitNullifier(nullifier: Fr) {
-    const db = await this.trees.getLatest();
-    const siloedNullifier = siloNullifier(this.contractAddress, nullifier);
-    await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()], NULLIFIER_SUBTREE_HEIGHT);
+    const siloedNullifier = await siloNullifier(this.contractAddress, nullifier);
+    this.addSiloedNullifiersFromPublic([siloedNullifier]);
+
     return Promise.resolve();
   }
 
+  // Doesn't this need to get hashed w/ the nonce ?
   async avmOpcodeEmitNoteHash(noteHash: Fr) {
-    const db = await this.trees.getLatest();
-    const siloedNoteHash = siloNoteHash(this.contractAddress, noteHash);
-    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
+    const siloedNoteHash = await siloNoteHash(this.contractAddress, noteHash);
+    this.addUniqueNoteHashesFromPublic([siloedNoteHash]);
     return Promise.resolve();
   }
 
   async avmOpcodeStorageRead(slot: Fr) {
-    const db = await this.trees.getLatest();
-
-    const leafSlot = computePublicDataTreeLeafSlot(this.contractAddress, slot);
+    const leafSlot = await computePublicDataTreeLeafSlot(this.contractAddress, slot);
 
-    const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+    const lowLeafResult = await this.baseFork.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
     if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
       return Fr.ZERO;
     }
 
-    const preimage = (await db.getLeafPreimage(
+    const preimage = (await this.baseFork.getLeafPreimage(
       MerkleTreeId.PUBLIC_DATA_TREE,
       lowLeafResult.index,
     )) as PublicDataTreeLeafPreimage;