@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/tx/index.ts

@@ -0,0 +1,27 @@
+export * from './block_header.js';
+export * from './call_context.js';
+export * from './global_variables.js';
+export * from './max_block_number.js';
+export * from './content_commitment.js';
+export * from './state_reference.js';
+export * from './partial_state_reference.js';
+export * from './function_data.js';
+export * from './tree_snapshots.js';
+export * from './tx_constant_data.js';
+export * from './tx_context.js';
+export * from './tx_request.js';
+export * from './private_execution_result.js';
+export * from './public_execution_request.js';
+export * from './tx_hash.js';
+export * from './tx_receipt.js';
+export * from './tx.js';
+export * from './processed_tx.js';
+export * from './simulated_tx.js';
+export * from './tx_effect.js';
+export * from './public_simulation_output.js';
+export * from './tx_execution_request.js';
+export * from './validator/tx_validator.js';
+export * from './validator/empty_validator.js';
+export * from './capsule.js';
+export * from './global_variable_builder.js';
+export * from './hashed_values.js';

package/src/tx/max_block_number.ts

@@ -0,0 +1,79 @@
+import { MAX_BLOCK_NUMBER_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+/**
+ * Maximum block number.
+ */
+export class MaxBlockNumber {
+  constructor(
+    /**
+     * Whether a max block number was requested.
+     */
+    public isSome: boolean,
+    /**
+     * The requested max block number, if isSome is true.
+     */
+    public value: Fr,
+  ) {}
+
+  /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...MaxBlockNumber.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...MaxBlockNumber.getFields(this));
+    if (fields.length !== MAX_BLOCK_NUMBER_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for MaxBlockNumber. Expected ${MAX_BLOCK_NUMBER_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  /**
+   * Deserializes MaxBlockNumber from a buffer or reader.
+   * @param buffer - Buffer to read from.
+   * @returns The MaxBlockNumber.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): MaxBlockNumber {
+    const reader = BufferReader.asReader(buffer);
+    return new MaxBlockNumber(reader.readBoolean(), Fr.fromBuffer(reader));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): MaxBlockNumber {
+    const reader = FieldReader.asReader(fields);
+    return new MaxBlockNumber(reader.readBoolean(), reader.readField());
+  }
+
+  static empty() {
+    return new MaxBlockNumber(false, Fr.ZERO);
+  }
+
+  isEmpty(): boolean {
+    return !this.isSome && this.value.isZero();
+  }
+
+  /**
+   * Create a new instance from a fields dictionary.
+   * @param fields - The dictionary.
+   * @returns A new instance.
+   */
+  static from(fields: FieldsOf<MaxBlockNumber>): MaxBlockNumber {
+    return new MaxBlockNumber(...MaxBlockNumber.getFields(fields));
+  }
+
+  /**
+   * Serialize into a field array. Low-level utility.
+   * @param fields - Object with fields.
+   * @returns The array.
+   */
+  static getFields(fields: FieldsOf<MaxBlockNumber>) {
+    return [fields.isSome, fields.value] as const;
+  }
+}

package/src/tx/partial_state_reference.ts

@@ -0,0 +1,95 @@
+import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+
+/**
+ * Stores snapshots of trees which are commonly needed by base or merge rollup circuits.
+ */
+export class PartialStateReference {
+  constructor(
+    /** Snapshot of the note hash tree. */
+    public readonly noteHashTree: AppendOnlyTreeSnapshot,
+    /** Snapshot of the nullifier tree. */
+    public readonly nullifierTree: AppendOnlyTreeSnapshot,
+    /** Snapshot of the public data tree. */
+    public readonly publicDataTree: AppendOnlyTreeSnapshot,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        noteHashTree: AppendOnlyTreeSnapshot.schema,
+        nullifierTree: AppendOnlyTreeSnapshot.schema,
+        publicDataTree: AppendOnlyTreeSnapshot.schema,
+      })
+      .transform(
+        ({ noteHashTree, nullifierTree, publicDataTree }) =>
+          new PartialStateReference(noteHashTree, nullifierTree, publicDataTree),
+      );
+  }
+
+  getSize() {
+    return this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PartialStateReference {
+    const reader = BufferReader.asReader(buffer);
+    return new PartialStateReference(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PartialStateReference {
+    const reader = FieldReader.asReader(fields);
+
+    const noteHashTree = AppendOnlyTreeSnapshot.fromFields(reader);
+    const nullifierTree = AppendOnlyTreeSnapshot.fromFields(reader);
+    const publicDataTree = AppendOnlyTreeSnapshot.fromFields(reader);
+
+    return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
+  }
+
+  static empty(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.zero(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.noteHashTree, this.nullifierTree, this.publicDataTree);
+  }
+
+  toFields() {
+    const fields = [
+      ...this.noteHashTree.toFields(),
+      ...this.nullifierTree.toFields(),
+      ...this.publicDataTree.toFields(),
+    ];
+    if (fields.length !== PARTIAL_STATE_REFERENCE_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PartialStateReference. Expected ${PARTIAL_STATE_REFERENCE_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  isEmpty(): boolean {
+    return this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+  }
+
+  public equals(other: this): boolean {
+    return (
+      this.noteHashTree.equals(other.noteHashTree) &&
+      this.nullifierTree.equals(other.nullifierTree) &&
+      this.publicDataTree.equals(other.publicDataTree)
+    );
+  }
+}

package/src/tx/private_execution_result.ts

@@ -0,0 +1,315 @@
+import { timesParallel } from '@aztec/foundation/collection';
+import { randomBytes, randomInt } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { NoteSelector } from '../abi/note_selector.js';
+import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
+import type { IsEmpty } from '../kernel/utils/interfaces.js';
+import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { Note } from '../note/note.js';
+import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
+import { PublicExecutionRequest } from './public_execution_request.js';
+
+/**
+ * The contents of a new note.
+ */
+export class NoteAndSlot {
+  constructor(
+    /** The note. */
+    public note: Note,
+    /** The storage slot of the note. */
+    public storageSlot: Fr,
+    /** The note type identifier. */
+    public noteTypeId: NoteSelector,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        note: Note.schema,
+        storageSlot: schemas.Fr,
+        noteTypeId: schemas.NoteSelector,
+      })
+      .transform(NoteAndSlot.from);
+  }
+
+  static from(fields: FieldsOf<NoteAndSlot>) {
+    return new NoteAndSlot(fields.note, fields.storageSlot, fields.noteTypeId);
+  }
+
+  static random() {
+    return new NoteAndSlot(Note.random(), Fr.random(), NoteSelector.random());
+  }
+}
+
+export class CountedContractClassLog implements IsEmpty {
+  constructor(public log: ContractClassLog, public counter: number) {}
+
+  static get schema(): ZodFor<CountedContractClassLog> {
+    return z
+      .object({
+        log: ContractClassLog.schema,
+        counter: schemas.Integer,
+      })
+      .transform(CountedContractClassLog.from);
+  }
+
+  static from(fields: { log: ContractClassLog; counter: number }) {
+    return new CountedContractClassLog(fields.log, fields.counter);
+  }
+
+  isEmpty(): boolean {
+    return this.log.isEmpty() && !this.counter;
+  }
+}
+
+export class CountedPublicExecutionRequest {
+  constructor(public request: PublicExecutionRequest, public counter: number) {}
+
+  static get schema(): ZodFor<CountedPublicExecutionRequest> {
+    return z
+      .object({
+        request: PublicExecutionRequest.schema,
+        counter: schemas.Integer,
+      })
+      .transform(CountedPublicExecutionRequest.from);
+  }
+
+  static from(fields: FieldsOf<CountedPublicExecutionRequest>) {
+    return new CountedPublicExecutionRequest(fields.request, fields.counter);
+  }
+
+  isEmpty(): boolean {
+    return this.request.isEmpty() && !this.counter;
+  }
+
+  static async random() {
+    return new CountedPublicExecutionRequest(await PublicExecutionRequest.random(), 0);
+  }
+}
+
+export class PrivateExecutionResult {
+  constructor(
+    public entrypoint: PrivateCallExecutionResult,
+    /** The first non revertible nullifier, or zero if there was none. */
+    public firstNullifier: Fr,
+  ) {}
+
+  static get schema(): ZodFor<PrivateExecutionResult> {
+    return z
+      .object({
+        entrypoint: PrivateCallExecutionResult.schema,
+        firstNullifier: Fr.schema,
+      })
+      .transform(PrivateExecutionResult.from);
+  }
+
+  static from(fields: FieldsOf<PrivateExecutionResult>) {
+    return new PrivateExecutionResult(fields.entrypoint, fields.firstNullifier);
+  }
+
+  static async random(nested = 1): Promise<PrivateExecutionResult> {
+    return new PrivateExecutionResult(await PrivateCallExecutionResult.random(nested), Fr.random());
+  }
+}
+
+/**
+ * The result of executing a call to a private function.
+ */
+export class PrivateCallExecutionResult {
+  constructor(
+    // Needed for prover
+    /** The ACIR bytecode. */
+    public acir: Buffer,
+    /** The verification key. */
+    public vk: Buffer,
+    /** The partial witness. */
+    public partialWitness: Map<number, string>,
+    // Needed for the verifier (kernel)
+    /** The call stack item. */
+    public publicInputs: PrivateCircuitPublicInputs,
+    /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
+    public noteHashLeafIndexMap: Map<bigint, bigint>,
+    /** The notes created in the executed function. */
+    public newNotes: NoteAndSlot[],
+    /** Mapping of note hash counter to the counter of its nullifier. */
+    public noteHashNullifierCounterMap: Map<number, number>,
+    /** The raw return values of the executed function. */
+    public returnValues: Fr[],
+    /** The nested executions. */
+    public nestedExecutions: PrivateCallExecutionResult[],
+    /** Enqueued public function execution requests to be picked up by the sequencer. */
+    public enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[],
+    /** Public function execution requested for teardown */
+    public publicTeardownFunctionCall: PublicExecutionRequest,
+    /**
+     * Contract class logs emitted during execution of this function call.
+     * Note: These are preimages to `contractClassLogsHashes`.
+     */
+    public contractClassLogs: CountedContractClassLog[],
+  ) {}
+
+  static get schema(): ZodFor<PrivateCallExecutionResult> {
+    return z
+      .object({
+        acir: schemas.Buffer,
+        vk: schemas.Buffer,
+        partialWitness: mapSchema(z.coerce.number(), z.string()),
+        publicInputs: PrivateCircuitPublicInputs.schema,
+        noteHashLeafIndexMap: mapSchema(schemas.BigInt, schemas.BigInt),
+        newNotes: z.array(NoteAndSlot.schema),
+        noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
+        returnValues: z.array(schemas.Fr),
+        nestedExecutions: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
+        enqueuedPublicFunctionCalls: z.array(CountedPublicExecutionRequest.schema),
+        publicTeardownFunctionCall: PublicExecutionRequest.schema,
+        contractClassLogs: z.array(CountedContractClassLog.schema),
+      })
+      .transform(PrivateCallExecutionResult.from);
+  }
+
+  static from(fields: FieldsOf<PrivateCallExecutionResult>) {
+    return new PrivateCallExecutionResult(
+      fields.acir,
+      fields.vk,
+      fields.partialWitness,
+      fields.publicInputs,
+      fields.noteHashLeafIndexMap,
+      fields.newNotes,
+      fields.noteHashNullifierCounterMap,
+      fields.returnValues,
+      fields.nestedExecutions,
+      fields.enqueuedPublicFunctionCalls,
+      fields.publicTeardownFunctionCall,
+      fields.contractClassLogs,
+    );
+  }
+
+  static async random(nested = 1): Promise<PrivateCallExecutionResult> {
+    return new PrivateCallExecutionResult(
+      randomBytes(4),
+      randomBytes(4),
+      new Map([[1, 'one']]),
+      PrivateCircuitPublicInputs.empty(),
+      new Map([[1n, 1n]]),
+      [NoteAndSlot.random()],
+      new Map([[0, 0]]),
+      [Fr.random()],
+      await timesParallel(nested, () => PrivateCallExecutionResult.random(0)),
+      [await CountedPublicExecutionRequest.random()],
+      await PublicExecutionRequest.random(),
+      [new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))],
+    );
+  }
+}
+
+export function collectNoteHashLeafIndexMap(execResult: PrivateExecutionResult) {
+  const accum: Map<bigint, bigint> = new Map();
+  const collectNoteHashLeafIndexMapRecursive = (callResult: PrivateCallExecutionResult, accum: Map<bigint, bigint>) => {
+    callResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
+    callResult.nestedExecutions.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
+  };
+  collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
+  return accum;
+}
+
+export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionResult) {
+  const accum: Map<number, number> = new Map();
+  const collectNoteHashNullifierCounterMapRecursive = (
+    callResult: PrivateCallExecutionResult,
+    accum: Map<number, number>,
+  ) => {
+    callResult.noteHashNullifierCounterMap.forEach((value, key) => accum.set(key, value));
+    callResult.nestedExecutions.forEach(nested => collectNoteHashNullifierCounterMapRecursive(nested, accum));
+  };
+  collectNoteHashNullifierCounterMapRecursive(execResult.entrypoint, accum);
+  return accum;
+}
+
+/**
+ * Collect all contract class logs across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All contract class logs.
+ */
+function collectContractClassLogs(execResult: PrivateCallExecutionResult): CountedContractClassLog[] {
+  return [execResult.contractClassLogs, ...execResult.nestedExecutions.flatMap(collectContractClassLogs)].flat();
+}
+
+/**
+ * Collect all contract class logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All contract class logs.
+ */
+export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLog[] {
+  const allLogs = collectContractClassLogs(execResult.entrypoint);
+  const sortedLogs = sortByCounter(allLogs);
+  return sortedLogs.map(l => l.log);
+}
+
+function collectEnqueuedCountedPublicExecutionRequests(
+  execResult: PrivateCallExecutionResult,
+): CountedPublicExecutionRequest[] {
+  return [
+    ...execResult.enqueuedPublicFunctionCalls,
+    ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests),
+  ];
+}
+
+/**
+ * Collect all enqueued public function calls across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All enqueued public function calls.
+ */
+export function collectEnqueuedPublicFunctionCalls(execResult: PrivateExecutionResult): PublicExecutionRequest[] {
+  const countedRequests = collectEnqueuedCountedPublicExecutionRequests(execResult.entrypoint);
+  // without the reverse sort, the logs will be in a queue like fashion which is wrong
+  // as the kernel processes it like a stack, popping items off and pushing them to output
+  return sortByCounter(countedRequests, false).map(r => r.request);
+}
+
+export function collectPublicTeardownFunctionCall(execResult: PrivateExecutionResult): PublicExecutionRequest {
+  const collectPublicTeardownFunctionCallRecursive = (
+    callResult: PrivateCallExecutionResult,
+  ): PublicExecutionRequest[] => {
+    return [
+      callResult.publicTeardownFunctionCall,
+      ...callResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCallRecursive),
+    ].filter(call => !call.isEmpty());
+  };
+  const teardownCalls = collectPublicTeardownFunctionCallRecursive(execResult.entrypoint);
+
+  if (teardownCalls.length === 1) {
+    return teardownCalls[0];
+  }
+
+  if (teardownCalls.length > 1) {
+    throw new Error('Multiple public teardown calls detected');
+  }
+
+  return PublicExecutionRequest.empty();
+}
+
+export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {
+  const collectFinalMinRevertibleSideEffectCounterRecursive = (callResult: PrivateCallExecutionResult): number => {
+    return callResult.nestedExecutions.reduce((counter, exec) => {
+      const nestedCounter = collectFinalMinRevertibleSideEffectCounterRecursive(exec);
+      return nestedCounter ? nestedCounter : counter;
+    }, callResult.publicInputs.minRevertibleSideEffectCounter.toNumber());
+  };
+  return collectFinalMinRevertibleSideEffectCounterRecursive(execResult.entrypoint);
+}
+
+export function collectNested<T>(
+  executionStack: PrivateCallExecutionResult[],
+  extractExecutionItems: (execution: PrivateCallExecutionResult) => T[],
+): T[] {
+  const thisExecutionReads = executionStack.flatMap(extractExecutionItems);
+
+  return thisExecutionReads.concat(
+    executionStack.flatMap(({ nestedExecutions }) => collectNested(nestedExecutions, extractExecutionItems)),
+  );
+}

package/src/tx/processed_tx.ts

@@ -0,0 +1,175 @@
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AvmProvingRequest } from '../avm/avm_proving_request.js';
+import type { PublicDataWrite } from '../avm/public_data_write.js';
+import { RevertCode } from '../avm/revert_code.js';
+import type { SimulationError } from '../errors/simulation_error.js';
+import { Gas } from '../gas/gas.js';
+import type { GasUsed } from '../gas/gas_used.js';
+import { siloL2ToL1Message } from '../hash/hash.js';
+import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import type { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { GlobalVariables } from './global_variables.js';
+import type { Tx } from './tx.js';
+import { TxEffect } from './tx_effect.js';
+import type { TxHash } from './tx_hash.js';
+
+export enum TxExecutionPhase {
+  SETUP,
+  APP_LOGIC,
+  TEARDOWN,
+}
+
+/**
+ * Represents a tx that has been processed by the sequencer public processor,
+ * so its kernel circuit public inputs are filled in.
+ */
+export type ProcessedTx = {
+  /**
+   * Hash of the transaction.
+   */
+  hash: TxHash;
+  /**
+   * Tx.data. The output of the private kernel tail or tail_to_public.
+   */
+  data: PrivateKernelTailCircuitPublicInputs;
+  /**
+   * Proof for the private execution.
+   */
+  clientIvcProof: ClientIvcProof;
+  /**
+   * The request for AVM proving.
+   */
+  avmProvingRequest: AvmProvingRequest | undefined;
+  /**
+   * Combining `TxConstantData` specified by the user, and `GlobalVariables` injected by the sequencer.
+   */
+  constants: CombinedConstantData;
+  /**
+   * Output data of the tx.
+   */
+  txEffect: TxEffect;
+  /*
+   * Gas used by the entire transaction.
+   */
+  gasUsed: GasUsed;
+  /**
+   * Reason the tx was reverted.
+   */
+  revertReason: SimulationError | undefined;
+};
+
+/**
+ * Represents a tx that failed to be processed by the sequencer public processor.
+ */
+export type FailedTx = {
+  /**
+   * The failing transaction.
+   */
+  tx: Tx;
+  /**
+   * The error that caused the tx to fail.
+   */
+  error: Error;
+};
+
+export async function makeProcessedTxFromPrivateOnlyTx(
+  tx: Tx,
+  transactionFee: Fr,
+  feePaymentPublicDataWrite: PublicDataWrite,
+  globalVariables: GlobalVariables,
+): Promise<ProcessedTx> {
+  const constants = CombinedConstantData.combine(tx.data.constants, globalVariables);
+
+  const data = tx.data.forRollup!;
+  const txEffect = new TxEffect(
+    RevertCode.OK,
+    await tx.getTxHash(),
+    transactionFee,
+    data.end.noteHashes.filter(h => !h.isZero()),
+    data.end.nullifiers.filter(h => !h.isZero()),
+    data.end.l2ToL1Msgs
+      .map(message => siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId))
+      .filter(h => !h.isZero()),
+    [feePaymentPublicDataWrite],
+    data.end.privateLogs.filter(l => !l.isEmpty()),
+    [],
+    await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true),
+  );
+
+  const gasUsed = {
+    // Billed gas is the same as total gas since there is no teardown execution
+    totalGas: tx.data.gasUsed,
+    billedGas: tx.data.gasUsed,
+    teardownGas: Gas.empty(),
+    publicGas: Gas.empty(),
+  } satisfies GasUsed;
+
+  return {
+    hash: txEffect.txHash,
+    data: tx.data,
+    clientIvcProof: tx.clientIvcProof,
+    avmProvingRequest: undefined,
+    constants,
+    txEffect,
+    gasUsed,
+    revertReason: undefined,
+  };
+}
+
+export function toNumBlobFields(txs: ProcessedTx[]): number {
+  return txs.reduce((acc, tx) => {
+    return acc + tx.txEffect.toBlobFields().length;
+  }, 0);
+}
+
+export async function makeProcessedTxFromTxWithPublicCalls(
+  tx: Tx,
+  avmProvingRequest: AvmProvingRequest,
+  gasUsed: GasUsed,
+  revertCode: RevertCode,
+  revertReason: SimulationError | undefined,
+): Promise<ProcessedTx> {
+  const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
+
+  const constants = CombinedConstantData.combine(tx.data.constants, avmPublicInputs.globalVariables);
+
+  const publicDataWrites = avmPublicInputs.accumulatedData.publicDataWrites.filter(w => !w.isEmpty());
+
+  const privateLogs = [
+    ...tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs,
+    ...(revertCode.isOK() ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs : []),
+  ].filter(l => !l.isEmpty());
+
+  const contractClassLogs = [
+    ...(await tx.getSplitContractClassLogs(false, true)),
+    ...(revertCode.isOK() ? await tx.getSplitContractClassLogs(true, true) : []),
+  ].filter(l => !l.isEmpty());
+
+  const txEffect = new TxEffect(
+    revertCode,
+    await tx.getTxHash(),
+    avmPublicInputs.transactionFee,
+    avmPublicInputs.accumulatedData.noteHashes.filter(h => !h.isZero()),
+    avmPublicInputs.accumulatedData.nullifiers.filter(h => !h.isZero()),
+    avmPublicInputs.accumulatedData.l2ToL1Msgs
+      .map(message => siloL2ToL1Message(message, constants.txContext.version, constants.txContext.chainId))
+      .filter(h => !h.isZero()),
+    publicDataWrites,
+    privateLogs,
+    avmPublicInputs.accumulatedData.publicLogs.filter(l => !l.isEmpty()),
+    contractClassLogs,
+  );
+
+  return {
+    hash: txEffect.txHash,
+    data: tx.data,
+    clientIvcProof: tx.clientIvcProof,
+    avmProvingRequest,
+    constants,
+    txEffect,
+    gasUsed,
+    revertReason,
+  };
+}