@aztec/txe 0.86.0-starknet.1 → 0.87.0

package/dest/util/encoding.js

@@ -40,8 +40,20 @@ export function fromArray(obj) {
     const boundedStorage = storage.slice(0, fromSingle(length).toNumber());
     return Buffer.concat(boundedStorage.map((str)=>hexToBuffer(str).slice(-uintByteSize)));
 }
-export function toSingle(obj) {
-    return obj.toString().slice(2);
+// Just like toACVMField in yarn-project/simulator/src/private/acvm/serialize.ts but returns a ForeignCallSingle
+// instead of an ACVMField.
+export function toSingle(value) {
+    let valueAsField;
+    if (Buffer.isBuffer(value)) {
+        valueAsField = Fr.fromBuffer(value);
+    } else if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'bigint') {
+        valueAsField = new Fr(value);
+    } else if (typeof value === 'string') {
+        valueAsField = Fr.fromHexString(value);
+    } else {
+        valueAsField = value;
+    }
+    return valueAsField.toString().slice(2);
 }
 export function toArray(objs) {
     return objs.map((obj)=>obj.toString());
@@ -74,6 +86,30 @@ export function bufferToU8Array(buffer) {
         len
     ];
 }
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */ export function arrayOfArraysToBoundedVecOfArrays(bVecStorage, maxLen, nestedArrayLength) {
+    if (bVecStorage.length > maxLen) {
+        throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+    }
+    // Check that all nested arrays have length nestedArrayLength
+    if (!bVecStorage.every((nestedArray)=>nestedArray.length === nestedArrayLength)) {
+        throw new Error(`Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`);
+    }
+    const flattenedStorage = bVecStorage.flat();
+    const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+    const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(new Fr(0)));
+    // At last we get the actual length of the BoundedVec and return the values.
+    const len = toSingle(new Fr(bVecStorage.length));
+    return [
+        flattenedStorageWithPadding,
+        len
+    ];
+}
 export function toForeignCallResult(obj) {
     return {
         values: obj

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/txe",
-  "version": "0.86.0-starknet.1",
+  "version": "0.87.0",
   "type": "module",
   "exports": "./dest/index.js",
   "bin": "./dest/bin/index.js",
@@ -57,30 +57,30 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.86.0-starknet.1",
-    "@aztec/archiver": "0.86.0-starknet.1",
-    "@aztec/aztec-node": "0.86.0-starknet.1",
-    "@aztec/aztec.js": "0.86.0-starknet.1",
-    "@aztec/bb-prover": "0.86.0-starknet.1",
-    "@aztec/constants": "0.86.0-starknet.1",
-    "@aztec/foundation": "0.86.0-starknet.1",
-    "@aztec/key-store": "0.86.0-starknet.1",
-    "@aztec/kv-store": "0.86.0-starknet.1",
-    "@aztec/protocol-contracts": "0.86.0-starknet.1",
-    "@aztec/pxe": "0.86.0-starknet.1",
-    "@aztec/simulator": "0.86.0-starknet.1",
-    "@aztec/stdlib": "0.86.0-starknet.1",
-    "@aztec/world-state": "0.86.0-starknet.1",
+    "@aztec/accounts": "0.87.0",
+    "@aztec/archiver": "0.87.0",
+    "@aztec/aztec-node": "0.87.0",
+    "@aztec/aztec.js": "0.87.0",
+    "@aztec/bb-prover": "0.87.0",
+    "@aztec/constants": "0.87.0",
+    "@aztec/foundation": "0.87.0",
+    "@aztec/key-store": "0.87.0",
+    "@aztec/kv-store": "0.87.0",
+    "@aztec/protocol-contracts": "0.87.0",
+    "@aztec/pxe": "0.87.0",
+    "@aztec/simulator": "0.87.0",
+    "@aztec/stdlib": "0.87.0",
+    "@aztec/world-state": "0.87.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
-    "@types/node": "^18.7.23",
+    "@types/node": "^22.15.17",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.3",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -89,6 +89,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/oracle/txe_oracle.ts

@@ -1,8 +1,15 @@
 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,9 +123,15 @@ 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';
 
@@ -140,7 +166,7 @@ export class TXE implements TypedOracle {
 
   private simulationProvider = new WASMSimulator();
 
-  private noteCache: ExecutionNoteCache;
+  public noteCache: ExecutionNoteCache;
 
   private authwits: Map<string, AuthWitness> = new Map();
 
@@ -385,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) {
@@ -623,7 +647,6 @@ export class TXE implements TypedOracle {
       counter,
     );
     this.sideEffectCounter = counter + 1;
-    return Promise.resolve();
   }
 
   async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
@@ -729,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());
     }
@@ -812,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,
@@ -944,6 +1023,8 @@ export class TXE implements TypedOracle {
         contractsDB,
         globalVariables,
         /*doMerkleOperations=*/ false,
+        /*skipFeeEnforcement=*/ false,
+        /*clientInitiatedSimulation=*/ true,
       );
 
       const { usedTxRequestHashForNonces } = this.noteCache.finish();
@@ -1267,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,
+    };
+  }
 }

package/src/state_machine/archiver.ts

@@ -41,11 +41,11 @@ export class TXEArchiver extends ArchiverStoreHelper {
   }
 
   /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * Gets a published l2 block. If a negative number is passed, the block returned is the most recent.
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public async getBlock(number: number): Promise<L2Block | undefined> {
+  public override async getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getSynchedL2BlockNumber();
@@ -54,7 +54,16 @@ export class TXEArchiver extends ArchiverStoreHelper {
       return undefined;
     }
     const blocks = await this.store.getPublishedBlocks(number, 1);
-    return blocks.length === 0 ? undefined : blocks[0].block;
+    return blocks.length === 0 ? undefined : blocks[0];
+  }
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  public getBlock(number: number): Promise<L2Block | undefined> {
+    return this.getPublishedBlock(number).then(block => block?.block);
   }
 
   /**

package/src/state_machine/dummy_p2p_client.ts

@@ -5,6 +5,14 @@ import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
 export class DummyP2P implements P2P {
+  public validate(_txs: Tx[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public clear(): Promise<void> {
+    throw new Error('DummyP2P does not implement "clear".');
+  }
+
   public getPendingTxs(): Promise<Tx[]> {
     throw new Error('DummyP2P does not implement "getPendingTxs"');
   }
@@ -17,7 +25,7 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getPeers"');
   }
 
-  public broadcastProposal(_proposal: BlockProposal): void {
+  public broadcastProposal(_proposal: BlockProposal): Promise<void> {
     throw new Error('DummyP2P does not implement "broadcastProposal"');
   }
 
@@ -152,4 +160,8 @@ export class DummyP2P implements P2P {
   public getSyncedLatestSlot(): Promise<bigint> {
     throw new Error('DummyP2P does not implement "getSyncedLatestSlot"');
   }
+
+  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "markTxsAsNonEvictable".');
+  }
 }