@aztec/txe 0.86.0 → 0.87.0

package/src/oracle/txe_oracle.ts

@@ -1,8 +1,15 @@
-import { Body, L2Block, Note } from '@aztec/aztec.js';
+import { type AztecNode, Body, L2Block, Note } from '@aztec/aztec.js';
 import {
+  DEFAULT_GAS_LIMIT,
+  DEFAULT_TEARDOWN_GAS_LIMIT,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  MAX_ENQUEUED_CALLS_PER_TX,
+  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_TX,
   NULLIFIER_SUBTREE_HEIGHT,
   type NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
@@ -13,7 +20,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { Aes128, Schnorr, poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { type Logger, applyStringFormatting } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
+import { TestDateProvider, Timer } from '@aztec/foundation/timer';
 import { KeyStore } from '@aztec/key-store';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { ProtocolContract } from '@aztec/protocol-contracts';
@@ -34,8 +41,11 @@ import {
   type MessageLoadOracleInputs,
   type NoteData,
   Oracle,
+  PrivateExecutionOracle,
   type TypedOracle,
+  UtilityExecutionOracle,
   WASMSimulator,
+  executePrivateFunction,
   extractCallStack,
   extractPrivateCircuitPublicInputs,
   pickNotes,
@@ -46,6 +56,7 @@ import { createTxForPublicCalls } from '@aztec/simulator/public/fixtures';
 import {
   ExecutionError,
   PublicContractsDB,
+  PublicProcessor,
   type PublicTxResult,
   PublicTxSimulator,
   createSimulationError,
@@ -56,6 +67,7 @@ import {
   EventSelector,
   type FunctionAbi,
   FunctionSelector,
+  FunctionType,
   type NoteSelector,
   countArgumentsSize,
 } from '@aztec/stdlib/abi';
@@ -64,25 +76,33 @@ import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstance, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SimulationError } from '@aztec/stdlib/errors';
-import { Gas, GasFees } from '@aztec/stdlib/gas';
+import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import {
   computeNoteHashNonce,
   computePublicDataTreeLeafSlot,
   computeUniqueNoteHash,
+  computeVarArgsHash,
   siloNoteHash,
   siloNullifier,
 } from '@aztec/stdlib/hash';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { type KeyValidationRequest, PrivateContextInputs, PublicCallRequest } from '@aztec/stdlib/kernel';
-import { deriveKeys } from '@aztec/stdlib/keys';
 import {
-  ContractClassLog,
-  IndexedTaggingSecret,
-  LogWithTxData,
-  type PrivateLog,
-  type PublicLog,
-} from '@aztec/stdlib/logs';
+  type KeyValidationRequest,
+  PartialPrivateTailPublicInputsForPublic,
+  PartialPrivateTailPublicInputsForRollup,
+  PrivateContextInputs,
+  PrivateKernelTailCircuitPublicInputs,
+  PrivateToPublicAccumulatedData,
+  PrivateToRollupAccumulatedData,
+  PublicCallRequest,
+  RollupValidationRequests,
+  ScopedLogHash,
+} from '@aztec/stdlib/kernel';
+import { deriveKeys } from '@aztec/stdlib/keys';
+import { ContractClassLog, IndexedTaggingSecret, LogWithTxData, PrivateLog, type PublicLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import type { NoteStatus } from '@aztec/stdlib/note';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import {
   makeAppendOnlyTreeSnapshot,
@@ -103,13 +123,19 @@ import {
   BlockHeader,
   CallContext,
   GlobalVariables,
+  HashedValues,
+  PrivateExecutionResult,
   PublicCallRequestWithCalldata,
+  Tx,
+  TxConstantData,
+  TxContext,
   TxEffect,
   TxHash,
+  collectNested,
 } from '@aztec/stdlib/tx';
 import { ForkCheckpoint, NativeWorldStateService } from '@aztec/world-state/native';
 
-import { TXENode } from '../node/txe_node.js';
+import { TXEStateMachine } from '../state_machine/index.js';
 import { TXEAccountDataProvider } from '../util/txe_account_data_provider.js';
 import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_source.js';
 
@@ -136,11 +162,11 @@ export class TXE implements TypedOracle {
   private ROLLUP_VERSION = 1;
   private CHAIN_ID = 1;
 
-  private node: TXENode;
+  private node: AztecNode;
 
   private simulationProvider = new WASMSimulator();
 
-  private noteCache: ExecutionNoteCache;
+  public noteCache: ExecutionNoteCache;
 
   private authwits: Map<string, AuthWitness> = new Map();
 
@@ -159,10 +185,12 @@ export class TXE implements TypedOracle {
     private contractAddress: AztecAddress,
     private nativeWorldStateService: NativeWorldStateService,
     private baseFork: MerkleTreeWriteOperations,
+    private stateMachine: TXEStateMachine,
   ) {
     this.noteCache = new ExecutionNoteCache(this.getTxRequestHash());
 
-    this.node = new TXENode(this.blockNumber, this.ROLLUP_VERSION, this.CHAIN_ID, nativeWorldStateService, baseFork);
+    this.node = stateMachine.node;
+
     // 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);
 
@@ -182,14 +210,16 @@ export class TXE implements TypedOracle {
 
   static async create(logger: Logger, store: AztecAsyncKVStore, protocolContracts: ProtocolContract[]) {
     const executionCache = new HashedValuesCache();
-    const nativeWorldStateService = await NativeWorldStateService.tmp();
+
+    const stateMachine = await TXEStateMachine.create(store);
+    const syncDataProvider = stateMachine.syncDataProvider;
+    const nativeWorldStateService = stateMachine.synchronizer.nativeWorldStateService;
     const baseFork = await nativeWorldStateService.fork();
 
     const addressDataProvider = new AddressDataProvider(store);
     const privateEventDataProvider = new PrivateEventDataProvider(store);
     const contractDataProvider = new ContractDataProvider(store);
     const noteDataProvider = await NoteDataProvider.create(store);
-    const syncDataProvider = new SyncDataProvider(store);
     const taggingDataProvider = new TaggingDataProvider(store);
     const capsuleDataProvider = new CapsuleDataProvider(store);
     const keyStore = new KeyStore(store);
@@ -217,6 +247,7 @@ export class TXE implements TypedOracle {
       await AztecAddress.random(),
       nativeWorldStateService,
       baseFork,
+      stateMachine,
     );
   }
 
@@ -231,11 +262,11 @@ export class TXE implements TypedOracle {
   }
 
   getChainId(): Promise<Fr> {
-    return Promise.resolve(this.node.getChainId().then(id => new Fr(id)));
+    return Promise.resolve(new Fr(this.CHAIN_ID));
   }
 
   getVersion(): Promise<Fr> {
-    return Promise.resolve(this.node.getVersion().then(v => new Fr(v)));
+    return Promise.resolve(new Fr(this.ROLLUP_VERSION));
   }
 
   getMsgSender() {
@@ -268,7 +299,6 @@ export class TXE implements TypedOracle {
 
   setBlockNumber(blockNumber: number) {
     this.blockNumber = blockNumber;
-    this.node.setBlockNumber(blockNumber);
   }
 
   getContractDataProvider() {
@@ -316,8 +346,8 @@ export class TXE implements TypedOracle {
 
     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());
+    inputs.txContext.chainId = new Fr(this.CHAIN_ID);
+    inputs.txContext.version = new Fr(this.ROLLUP_VERSION);
     inputs.historicalHeader.globalVariables.blockNumber = new Fr(blockNumber);
     inputs.historicalHeader.state = stateReference;
     inputs.historicalHeader.lastArchive.root = Fr.fromBuffer(
@@ -381,9 +411,7 @@ export class TXE implements TypedOracle {
   addPublicLogs(logs: PublicLog[]) {
     logs.forEach(log => {
       try {
-        // The first elt stores lengths => tag is in fields[1]
-        const tag = log.log[1];
-
+        const tag = log.fields[0];
         this.logger.verbose(`Found tagged public log with tag ${tag.toString()} in block ${this.blockNumber}`);
         this.publicLogs.push(log);
       } catch (err) {
@@ -619,7 +647,6 @@ export class TXE implements TypedOracle {
       counter,
     );
     this.sideEffectCounter = counter + 1;
-    return Promise.resolve();
   }
 
   async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
@@ -725,6 +752,7 @@ export class TXE implements TypedOracle {
     txEffect.noteHashes = [...uniqueNoteHashesFromPrivate, ...this.uniqueNoteHashesFromPublic];
 
     txEffect.nullifiers = [...this.siloedNullifiersFromPublic, ...this.noteCache.getAllNullifiers()];
+
     if (usedTxRequestHashForNonces) {
       txEffect.nullifiers.unshift(this.getTxRequestHash());
     }
@@ -732,6 +760,7 @@ export class TXE implements TypedOracle {
     txEffect.publicDataWrites = this.publicDataWrites;
     txEffect.privateLogs = this.privateLogs;
     txEffect.publicLogs = this.publicLogs;
+    txEffect.txHash = new TxHash(new Fr(blockNumber));
 
     const body = new Body([txEffect]);
 
@@ -771,10 +800,6 @@ export class TXE implements TypedOracle {
       }
     }
 
-    // At this point we always have a single tx in the block so we set the tx index to 0.
-    const txIndexInBlock = 0;
-    await this.node.processTxEffect(blockNumber, txIndexInBlock, new TxHash(new Fr(blockNumber)), txEffect);
-
     const stateReference = await fork.getStateReference();
     const archiveInfo = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
     const header = new BlockHeader(
@@ -792,14 +817,7 @@ export class TXE implements TypedOracle {
 
     await fork.updateArchive(l2Block.header);
 
-    // We've built a block with all of our state changes in a "fork".
-    // Now emulate a "sync" to this block, by letting cpp reapply the block's
-    // changes to the underlying unforked world state and comparing the results
-    // against the block's state reference (which is this state reference here in the fork).
-    // This essentially commits the state updates to the unforked state and sanity checks the roots.
-    await this.nativeWorldStateService.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
-
-    await this.syncDataProvider.setHeader(header);
+    await this.stateMachine.handleL2Block(l2Block);
 
     this.publicDataWrites = [];
     this.privateLogs = [];
@@ -818,6 +836,61 @@ export class TXE implements TypedOracle {
     throw new Error('Method not implemented.');
   }
 
+  async simulateUtilityFunction(targetContractAddress: AztecAddress, functionSelector: FunctionSelector, argsHash: Fr) {
+    const artifact = await this.contractDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
+    if (!artifact) {
+      throw new Error(`Cannot call ${functionSelector} as there is artifact found at ${targetContractAddress}.`);
+    }
+
+    const call = {
+      name: artifact.name,
+      selector: functionSelector,
+      to: targetContractAddress,
+    };
+
+    const entryPointArtifact = await this.pxeOracleInterface.getFunctionArtifact(call.to, call.selector);
+
+    if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as utility`);
+    }
+
+    const oracle = new UtilityExecutionOracle(call.to, [], [], this.pxeOracleInterface, undefined, undefined);
+
+    try {
+      this.logger.verbose(`Executing utility function ${entryPointArtifact.name}`, {
+        contract: call.to,
+        selector: call.selector,
+      });
+
+      const args = await this.loadFromExecutionCache(argsHash);
+      const initialWitness = toACVMWitness(0, args);
+      const acirExecutionResult = await this.simulationProvider
+        .executeUserCircuit(initialWitness, entryPointArtifact, new Oracle(oracle))
+        .catch((err: Error) => {
+          err.message = resolveAssertionMessageFromError(err, entryPointArtifact);
+          throw new ExecutionError(
+            err.message,
+            {
+              contractAddress: call.to,
+              functionSelector: call.selector,
+            },
+            extractCallStack(err, entryPointArtifact.debug),
+            { cause: err },
+          );
+        });
+
+      const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
+      this.logger.verbose(`Utility simulation for ${call.to}.${call.selector} completed`);
+
+      const returnHash = await computeVarArgsHash(returnWitness);
+
+      this.storeInExecutionCache(returnWitness, returnHash);
+      return returnHash;
+    } catch (err) {
+      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+    }
+  }
+
   async callPrivateFunction(
     targetContractAddress: AztecAddress,
     functionSelector: FunctionSelector,
@@ -934,8 +1007,8 @@ export class TXE implements TypedOracle {
     const db = this.baseFork;
 
     const globalVariables = GlobalVariables.empty();
-    globalVariables.chainId = new Fr(await this.node.getChainId());
-    globalVariables.version = new Fr(await this.node.getVersion());
+    globalVariables.chainId = new Fr(this.CHAIN_ID);
+    globalVariables.version = new Fr(this.ROLLUP_VERSION);
     globalVariables.blockNumber = new Fr(this.blockNumber);
     globalVariables.gasFees = new GasFees(1, 1);
 
@@ -950,6 +1023,8 @@ export class TXE implements TypedOracle {
         contractsDB,
         globalVariables,
         /*doMerkleOperations=*/ false,
+        /*skipFeeEnforcement=*/ false,
+        /*clientInitiatedSimulation=*/ true,
       );
 
       const { usedTxRequestHashForNonces } = this.noteCache.finish();
@@ -1273,4 +1348,276 @@ export class TXE implements TypedOracle {
       txIndexInBlock,
     );
   }
+
+  async privateCallNewFlow(
+    from: AztecAddress,
+    targetContractAddress: AztecAddress = AztecAddress.zero(),
+    functionSelector: FunctionSelector = FunctionSelector.empty(),
+    args: Fr[],
+    argsHash: Fr = Fr.zero(),
+    isStaticCall: boolean = false,
+  ) {
+    this.logger.verbose(
+      `Executing external function ${await this.getDebugFunctionName(
+        targetContractAddress,
+        functionSelector,
+      )}@${targetContractAddress} isStaticCall=${isStaticCall}`,
+    );
+
+    const artifact = await this.contractDataProvider.getFunctionArtifact(targetContractAddress, functionSelector);
+
+    if (artifact === undefined) {
+      throw new Error('Function Artifact does not exist');
+    }
+
+    const callContext = new CallContext(from, targetContractAddress, functionSelector, isStaticCall);
+
+    const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+
+    const teardownGasLimits = new Gas(DEFAULT_TEARDOWN_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+
+    const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty(), GasFees.empty());
+
+    const txContext = new TxContext(this.CHAIN_ID, this.ROLLUP_VERSION, gasSettings);
+
+    const blockHeader = await this.pxeOracleInterface.getBlockHeader();
+
+    const noteCache = new ExecutionNoteCache(this.getTxRequestHash());
+
+    const context = new PrivateExecutionOracle(
+      argsHash,
+      txContext,
+      callContext,
+      /** Header of a block whose state is used during private execution (not the block the transaction is included in). */
+      blockHeader,
+      /** List of transient auth witnesses to be used during this simulation */
+      [],
+      /** List of transient auth witnesses to be used during this simulation */
+      [],
+      HashedValuesCache.create(),
+      noteCache,
+      this.pxeOracleInterface,
+      this.simulationProvider,
+      0,
+      1,
+    );
+
+    context.storeInExecutionCache(args, argsHash);
+
+    // Note: This is a slight modification of simulator.run without any of the checks. Maybe we should modify simulator.run with a boolean value to skip checks.
+    let result;
+    try {
+      const executionResult = await executePrivateFunction(
+        this.simulationProvider,
+        context,
+        artifact,
+        targetContractAddress,
+        functionSelector,
+      );
+      const { usedTxRequestHashForNonces } = noteCache.finish();
+      const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
+
+      const publicCallRequests = collectNested([executionResult], r => [
+        ...r.publicInputs.publicCallRequests.map(r => r.inner),
+        r.publicInputs.publicTeardownCallRequest,
+      ]).filter(r => !r.isEmpty());
+      const publicFunctionsCalldata = await Promise.all(
+        publicCallRequests.map(async r => {
+          const calldata = await context.loadFromExecutionCache(r.calldataHash);
+          return new HashedValues(calldata, r.calldataHash);
+        }),
+      );
+
+      result = new PrivateExecutionResult(executionResult, firstNullifierHint, publicFunctionsCalldata);
+    } catch (err) {
+      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
+    }
+
+    const uniqueNoteHashes: Fr[] = [];
+    const taggedPrivateLogs: PrivateLog[] = [];
+    const nullifiers: Fr[] = result.firstNullifier.equals(Fr.ZERO)
+      ? [this.getTxRequestHash()]
+      : noteCache.getAllNullifiers();
+    const l2ToL1Messages: ScopedL2ToL1Message[] = [];
+    const contractClassLogsHashes: ScopedLogHash[] = [];
+    const publicCallRequests: PublicCallRequest[] = [];
+
+    const nonceGenerator = nullifiers[0];
+
+    let publicTeardownCallRequest;
+
+    let noteHashIndexInTx = 0;
+    const executions = [result.entrypoint];
+    while (executions.length !== 0) {
+      const execution = executions.shift()!;
+      executions.unshift(...execution!.nestedExecutions);
+
+      const { contractAddress } = execution.publicInputs.callContext;
+
+      const noteHashesFromExecution = await Promise.all(
+        execution.publicInputs.noteHashes
+          .filter(noteHash => !noteHash.isEmpty())
+          .map(async noteHash => {
+            const nonce = await computeNoteHashNonce(nonceGenerator, noteHashIndexInTx++);
+            const siloedNoteHash = await siloNoteHash(contractAddress, noteHash.value);
+
+            // We could defer this to the public processor, and pass this in as non-revertible.
+            return computeUniqueNoteHash(nonce, siloedNoteHash);
+          }),
+      );
+
+      const privateLogsFromExecution = await Promise.all(
+        execution.publicInputs.privateLogs
+          .filter(privateLog => !privateLog.isEmpty())
+          .map(async metadata => {
+            metadata.log.fields[0] = await poseidon2Hash([contractAddress, metadata.log.fields[0]]);
+
+            return metadata.log;
+          }),
+      );
+
+      uniqueNoteHashes.push(...noteHashesFromExecution);
+      taggedPrivateLogs.push(...privateLogsFromExecution);
+      l2ToL1Messages.push(
+        ...execution.publicInputs.l2ToL1Msgs
+          .filter(l2ToL1Message => !l2ToL1Message.isEmpty())
+          .map(message => message.scope(contractAddress)),
+      );
+      contractClassLogsHashes.push(
+        ...execution.publicInputs.contractClassLogsHashes
+          .filter(contractClassLogsHash => !contractClassLogsHash.isEmpty())
+          .map(message => message.logHash.scope(contractAddress)),
+      );
+      publicCallRequests.push(
+        ...execution.publicInputs.publicCallRequests
+          .filter(publicCallRequest => !publicCallRequest.isEmpty())
+          .map(callRequest => callRequest.inner),
+      );
+
+      if (publicTeardownCallRequest !== undefined && !execution.publicInputs.publicTeardownCallRequest.isEmpty()) {
+        throw new Error('Trying to set multiple teardown requests');
+      }
+
+      publicTeardownCallRequest = execution.publicInputs.publicTeardownCallRequest.isEmpty()
+        ? publicTeardownCallRequest
+        : execution.publicInputs.publicTeardownCallRequest;
+    }
+
+    const globals = makeGlobalVariables();
+    globals.blockNumber = new Fr(this.blockNumber);
+    globals.gasFees = GasFees.empty();
+
+    const contractsDB = new PublicContractsDB(new TXEPublicContractDataSource(this));
+    const simulator = new PublicTxSimulator(this.baseFork, contractsDB, globals, true, true);
+    const processor = new PublicProcessor(globals, this.baseFork, contractsDB, simulator, new TestDateProvider());
+
+    const constantData = new TxConstantData(blockHeader, txContext, Fr.zero(), Fr.zero());
+
+    const hasPublicCalls = result.publicFunctionCalldata.length !== 0;
+    let inputsForRollup;
+    let inputsForPublic;
+
+    // Private only
+    if (result.publicFunctionCalldata.length === 0) {
+      const accumulatedDataForRollup = new PrivateToRollupAccumulatedData(
+        padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+        padArrayEnd(nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+        padArrayEnd(l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+        padArrayEnd(taggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+        padArrayEnd(contractClassLogsHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+      );
+
+      inputsForRollup = new PartialPrivateTailPublicInputsForRollup(accumulatedDataForRollup);
+    } else {
+      const accumulatedDataForPublic = new PrivateToPublicAccumulatedData(
+        padArrayEnd(uniqueNoteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+        padArrayEnd(nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX),
+        padArrayEnd(l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+        padArrayEnd(taggedPrivateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX),
+        padArrayEnd(contractClassLogsHashes, ScopedLogHash.empty(), MAX_CONTRACT_CLASS_LOGS_PER_TX),
+        padArrayEnd(publicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
+      );
+
+      inputsForPublic = new PartialPrivateTailPublicInputsForPublic(
+        // We are using non-revertible because we set the first nullifier to be used as a nonce generator, otherwise the tx hash is manually calculated.
+        // nonrevertible
+        accumulatedDataForPublic,
+        // revertible
+        PrivateToPublicAccumulatedData.empty(),
+        publicTeardownCallRequest ?? PublicCallRequest.empty(),
+      );
+    }
+
+    const txData = new PrivateKernelTailCircuitPublicInputs(
+      constantData,
+      RollupValidationRequests.empty(),
+      /*gasUsed=*/ new Gas(0, 0),
+      /*feePayer=*/ AztecAddress.zero(),
+      hasPublicCalls ? inputsForPublic : undefined,
+      !hasPublicCalls ? inputsForRollup : undefined,
+    );
+
+    const tx = new Tx(txData, ClientIvcProof.empty(), [], result.publicFunctionCalldata);
+
+    const results = await processor.process([tx]);
+
+    const processedTxs = results[0];
+    const failedTxs = results[1];
+
+    if (failedTxs.length !== 0) {
+      throw new Error('Public execution has failed');
+    }
+
+    const fork = this.baseFork;
+
+    const txEffect = TxEffect.empty();
+
+    txEffect.noteHashes = processedTxs[0]!.txEffect.noteHashes;
+    txEffect.nullifiers = processedTxs[0]!.txEffect.nullifiers;
+    txEffect.privateLogs = taggedPrivateLogs;
+    txEffect.publicLogs = processedTxs[0]!.txEffect.publicLogs;
+    txEffect.publicDataWrites = processedTxs[0]!.txEffect.publicDataWrites;
+
+    txEffect.txHash = new TxHash(new Fr(this.blockNumber));
+
+    const body = new Body([txEffect]);
+
+    const l2Block = new L2Block(
+      makeAppendOnlyTreeSnapshot(this.blockNumber + 1),
+      makeHeader(0, this.blockNumber, this.blockNumber),
+      body,
+    );
+
+    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero);
+    await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+
+    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,
+      globals,
+      Fr.ZERO,
+      Fr.ZERO,
+    );
+
+    header.globalVariables.blockNumber = new Fr(this.blockNumber);
+
+    l2Block.header = header;
+
+    await fork.updateArchive(l2Block.header);
+
+    await this.stateMachine.handleL2Block(l2Block);
+
+    const txRequestHash = this.getTxRequestHash();
+
+    this.setBlockNumber(this.blockNumber + 1);
+    return {
+      endSideEffectCounter: result.entrypoint.publicInputs.endSideEffectCounter,
+      returnsHash: result.entrypoint.publicInputs.returnsHash,
+      txHash: txRequestHash,
+    };
+  }
 }