@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/tx/tx.ts

@@ -1,94 +1,118 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
+import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
-import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
+import {
+  BufferReader,
+  BufferSink,
+  serializeArrayOfBufferableToVector,
+  serializeArrayToSink,
+  serializeToSink,
+} from '@aztec/foundation/serialize';
+import { type FieldsOf, unfreeze } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
 import type { GasSettings } from '../gas/gas_settings.js';
-import type { GetPublicLogsResponse } from '../interfaces/get_logs_response.js';
-import type { L2LogsSource } from '../interfaces/l2_logs_source.js';
-import type { ScopedLogHash } from '../kernel/log_hash.js';
+import type { PublicCallRequest } from '../kernel/index.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Gossipable } from '../p2p/gossipable.js';
-import { TopicType, createTopicString } from '../p2p/topic_type.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { TopicType } from '../p2p/topic_type.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { TxStats } from '../stats/stats.js';
-import { PublicExecutionRequest } from './public_execution_request.js';
+import { HashedValues } from './hashed_values.js';
+import { PublicCallRequestWithCalldata } from './public_call_request_with_calldata.js';
 import { TxHash } from './tx_hash.js';
 
+// Static presize hint for the BufferSink the no-sink Tx.toBuffer() path allocates. Empirically a
+// public-with-enqueued-calls Tx serialized by the bootstrapped bench (yarn-project/stdlib/src/tx/
+// tx_bench.test.ts) is ~129128 bytes; a private-only Tx is ~81763 bytes. 128 KiB covers both shapes
+// without a single doubling-growth `ensure()` resize on the cold path. Real-world Txs that happen to
+// exceed this still serialize correctly — the sink falls back to its standard doubling growth — just
+// with the existing cost.
+const TX_SINK_PRESIZE_BYTES = 131072;
+
 /**
  * The interface of an L2 transaction.
  */
+// docs:start:tx_class
 export class Tx extends Gossipable {
-  static override p2pTopic: string;
-  // For memoization
-  private txHash: TxHash | undefined;
+  static override p2pTopic = TopicType.tx;
+
+  private calldataMap: Map<string, Fr[]> | undefined;
 
   constructor(
+    /**
+     * Identifier of the tx.
+     * It's a hash of the public inputs of the tx's proof.
+     * This claimed hash is reconciled against the tx's public inputs (`this.data`) in data_validator.ts.
+     */
+    public readonly txHash: TxHash,
     /**
      * Output of the private kernel circuit for this tx.
      */
     public readonly data: PrivateKernelTailCircuitPublicInputs,
     /**
      * Proof from the private kernel circuit.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
-     *
      */
-    public readonly clientIvcProof: ClientIvcProof,
+    public readonly chonkProof: ChonkProof,
     /**
-     * Contract class logs generated by the tx.
+     * Contract class log fields emitted from the tx.
+     * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
+     * This claimed data is reconciled against a hash of this data (that is contained within
+     * the tx's public inputs (`this.data`)), in data_validator.ts.
      */
-    public contractClassLogs: ContractClassLog[],
+    public readonly contractClassLogFields: ContractClassLogFields[],
     /**
-     * Enqueued public functions from the private circuit to be run by the sequencer.
+     * An array of calldata for the enqueued public function calls and the teardown function call.
+     * This claimed data is reconciled against hashes of this data (that are contained within
+     * the tx's public inputs (`this.data`)), in data_validator.ts.
      */
-    public readonly enqueuedPublicFunctionCalls: PublicExecutionRequest[],
-    /**
-     * Public function call to be run by the sequencer as part of teardown.
-     */
-    public readonly publicTeardownFunctionCall: PublicExecutionRequest,
+    public readonly publicFunctionCalldata: HashedValues[],
   ) {
     super();
   }
+  // docs:end:tx_class
 
   // Gossipable method
-  static {
-    this.p2pTopic = createTopicString(TopicType.tx);
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
   }
 
-  // Gossipable method
-  override async p2pMessageIdentifier(): Promise<Buffer32> {
-    return new Buffer32((await this.getTxHash()).toBuffer());
+  hasPublicCalls() {
+    return this.numberOfPublicCalls() > 0;
   }
 
-  hasPublicCalls() {
-    return this.data.numberOfPublicCallRequests() > 0;
+  numberOfPublicCalls() {
+    return this.data.numberOfPublicCallRequests();
   }
 
-  getNonRevertiblePublicExecutionRequests(): PublicExecutionRequest[] {
-    const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-    return this.enqueuedPublicFunctionCalls.slice(numRevertible);
+  getNonRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getNonRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
   }
 
-  getRevertiblePublicExecutionRequests(): PublicExecutionRequest[] {
-    const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-    return this.enqueuedPublicFunctionCalls.slice(0, numRevertible);
+  getRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
   }
 
-  getPublicTeardownExecutionRequest(): PublicExecutionRequest | undefined {
-    return this.publicTeardownFunctionCall.isEmpty() ? undefined : this.publicTeardownFunctionCall;
+  getTeardownPublicCallRequestWithCalldata(): PublicCallRequestWithCalldata | undefined {
+    const request = this.data.getTeardownPublicCallRequest();
+    return request ? this.#combinePublicCallRequestWithCallData(request) : undefined;
   }
 
-  getTotalPublicArgsCount(): number {
-    let count = this.enqueuedPublicFunctionCalls.reduce((acc, execRequest) => acc + execRequest.args.length, 0);
-    if (!this.publicTeardownFunctionCall.isEmpty()) {
-      count += this.publicTeardownFunctionCall.args.length;
-    }
-    return count;
+  getPublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    const teardown = this.data.getTeardownPublicCallRequest();
+    const callRequests = [
+      ...this.data.getNonRevertiblePublicCallRequests(),
+      ...this.data.getRevertiblePublicCallRequests(),
+      ...(teardown ? [teardown] : []),
+    ];
+    return callRequests.map(r => this.#combinePublicCallRequestWithCallData(r));
+  }
+
+  getTotalPublicCalldataCount(): number {
+    return this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.values.length, 0);
   }
 
   getGasSettings(): GasSettings {
@@ -103,24 +127,11 @@ export class Tx extends Gossipable {
   static fromBuffer(buffer: Buffer | BufferReader): Tx {
     const reader = BufferReader.asReader(buffer);
     return new Tx(
+      reader.readObject(TxHash),
       reader.readObject(PrivateKernelTailCircuitPublicInputs),
-      reader.readObject(ClientIvcProof),
-      reader.readVectorUint8Prefix(ContractClassLog),
-      reader.readVectorUint8Prefix(PublicExecutionRequest),
-      reader.readObject(PublicExecutionRequest),
-    );
-  }
-
-  static newWithTxData(
-    data: PrivateKernelTailCircuitPublicInputs,
-    publicTeardownExecutionRequest?: PublicExecutionRequest,
-  ) {
-    return new Tx(
-      data,
-      ClientIvcProof.empty(),
-      [],
-      [],
-      publicTeardownExecutionRequest ? publicTeardownExecutionRequest : PublicExecutionRequest.empty(),
+      reader.readObject(ChonkProof),
+      reader.readVectorUint8Prefix(ContractClassLogFields),
+      reader.readVectorUint8Prefix(HashedValues),
     );
   }
 
@@ -128,237 +139,232 @@ export class Tx extends Gossipable {
    * Serializes the Tx object into a Buffer.
    * @returns Buffer representation of the Tx object.
    */
-  toBuffer() {
-    return serializeToBuffer([
-      this.data,
-      this.clientIvcProof,
-      serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
-      serializeArrayOfBufferableToVector(this.enqueuedPublicFunctionCalls, 1),
-      this.publicTeardownFunctionCall,
-    ]);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this, TX_SINK_PRESIZE_BYTES);
+    }
+    serializeToSink(sink, this.txHash, this.data, this.chonkProof);
+    serializeArrayToSink(sink, this.contractClassLogFields, 1);
+    serializeArrayToSink(sink, this.publicFunctionCalldata, 1);
   }
 
   static get schema(): ZodFor<Tx> {
     return z
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
-        contractClassLogs: z.array(ContractClassLog.schema),
-        enqueuedPublicFunctionCalls: z.array(PublicExecutionRequest.schema),
-        publicTeardownFunctionCall: PublicExecutionRequest.schema,
+        chonkProof: ChonkProof.schema,
+        contractClassLogFields: z.array(ContractClassLogFields.schema),
+        publicFunctionCalldata: z.array(HashedValues.schema),
       })
-      .transform(Tx.from);
+      .transform(Tx.create);
+  }
+
+  static async computeTxHash(fields: Pick<FieldsOf<Tx>, 'data'>) {
+    const hash = fields.data.forPublic
+      ? await fields.data.toPrivateToPublicKernelCircuitPublicInputs().hash()
+      : await fields.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
+    return new TxHash(hash);
+  }
+
+  static async create(fields: Omit<FieldsOf<Tx>, 'txHash'>): Promise<Tx> {
+    const txHash = await Tx.computeTxHash(fields);
+    return Tx.from({ ...fields, txHash });
   }
 
   static from(fields: FieldsOf<Tx>) {
     return new Tx(
+      fields.txHash,
       fields.data,
-      fields.clientIvcProof,
-      fields.contractClassLogs,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
+      fields.chonkProof,
+      fields.contractClassLogFields,
+      fields.publicFunctionCalldata,
     );
   }
 
   /**
-   * Gets public logs emitted by this tx.
-   * @param logsSource - An instance of `L2LogsSource` which can be used to obtain the logs.
-   * @returns The requested logs.
+   * Validates that the tx hash matches the computed hash from the tx data.
+   * This should be called when deserializing a tx from an untrusted source.
+   * @returns true if the hash is valid, false otherwise
    */
-  public async getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
-    return logsSource.getPublicLogs({ txHash: await this.getTxHash() });
+  async validateTxHash(): Promise<boolean> {
+    const expectedHash = await Tx.computeTxHash(this);
+    return this.txHash.equals(expectedHash);
+  }
+
+  getContractClassLogs(): ContractClassLog[] {
+    const logHashes = this.data.getNonEmptyContractClassLogsHashes();
+    return logHashes.map((logHash, i) =>
+      ContractClassLog.from({
+        contractAddress: logHash.contractAddress,
+        fields: this.contractClassLogFields[i],
+        emittedLength: logHash.logHash.length,
+      }),
+    );
   }
 
   /**
    * Gets either revertible or non revertible contract class logs emitted by this tx.
-   * @param revertible - true for revertible only logs, false for non reverible only logs.
+   * @param revertible - true for revertible only logs, false for non revertible only logs.
    * @returns The requested logs.
    */
-  async getSplitContractClassLogs(revertible: boolean, silo: boolean = false): Promise<ContractClassLog[]> {
-    // Should only be called on txs with public calls
+  getSplitContractClassLogs(revertible: boolean): ContractClassLog[] {
     if (!this.data.forPublic) {
-      return [];
+      throw new Error('`getSplitContractClassLogs` should only be called on txs with public calls');
     }
-    const contractClassLogsHashes = revertible
-      ? this.data.forPublic.revertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty())
-      : this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty());
-    return await this.filterContractClassLogs(contractClassLogsHashes, silo);
-  }
 
-  /**
-   * Filters contract class logs emitted by this tx.
-   * @param logHashes - logs to keep represented by their hashes.
-   * @param silo - whether to silo the logs before returning them.
-   * @returns The requested logs.
-   */
-  async filterContractClassLogs(logHashes: ScopedLogHash[], silo: boolean = false): Promise<ContractClassLog[]> {
-    const contractClassLogs = [];
-    for (const log of this.contractClassLogs) {
-      const hashedLog = await log.hash();
-      const logHash = logHashes.find(
-        hash => hash.value.equals(hashedLog) && hash.contractAddress.equals(log.contractAddress),
-      );
-      if (logHash) {
-        contractClassLogs.push(silo ? await log.silo() : log);
-      }
-    }
-    return contractClassLogs;
+    const contractClassLogs = this.getContractClassLogs();
+    const numNonRevertible = this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(
+      h => !h.isEmpty(),
+    ).length;
+    return revertible ? contractClassLogs.slice(numNonRevertible) : contractClassLogs.slice(0, numNonRevertible);
   }
 
   /**
-   * Computes (if necessary) & return transaction hash.
+   * Return transaction hash.
    * @returns The hash of the public inputs of the private kernel tail circuit.
    */
-  async getTxHash(forceRecompute = false): Promise<TxHash> {
-    if (!this.txHash || forceRecompute) {
-      const hash = this.data.forPublic
-        ? await this.data.toPrivateToPublicKernelCircuitPublicInputs().hash()
-        : await this.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
-      this.txHash = new TxHash(hash);
-    }
-    return this.txHash!;
+  getTxHash(): TxHash {
+    return this.txHash;
   }
 
-  /**
-   * Allows setting the hash of the Tx.
-   * Use this when you want to skip computing it from the original data.
-   * Don't set a Tx hash received from an untrusted source.
-   * @param hash - The hash to set.
-   */
-  setTxHash(hash: TxHash) {
-    this.txHash = hash;
+  getCalldataMap(): Map<string, Fr[]> {
+    if (!this.calldataMap) {
+      const calldataMap = new Map();
+      this.publicFunctionCalldata.forEach(cd => calldataMap.set(cd.hash.toString(), cd.values));
+      this.calldataMap = calldataMap;
+    }
+
+    return this.calldataMap;
   }
 
   /** Returns stats about this tx. */
-  async getStats(): Promise<TxStats> {
+  getStats(): TxStats {
     return {
-      txHash: (await this.getTxHash()).toString(),
+      txHash: this.txHash.toString(),
 
       noteHashCount: this.data.getNonEmptyNoteHashes().length,
       nullifierCount: this.data.getNonEmptyNullifiers().length,
       privateLogCount: this.data.getNonEmptyPrivateLogs().length,
-      classRegisteredCount: this.data.getNonEmptyContractClassLogsHashes().length,
+      classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
-      proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
-      size: this.toBuffer().length,
+      proofSize: this.chonkProof.fields.length,
+      size: this.getSize(),
 
       feePaymentMethod:
         // needsSetup? then we pay through a fee payment contract
-        this.data.forPublic?.needsSetup
-          ? // if the first call is to `approve_public_authwit`, then it's a public payment
-            this.data.getNonRevertiblePublicCallRequests().at(-1)!.functionSelector.toField().toBigInt() === 0x43417bb1n
-            ? 'fpc_public'
-            : 'fpc_private'
-          : 'fee_juice',
+        this.data.forPublic?.needsSetup ? 'fpc' : 'fee_juice',
     };
   }
 
-  getSize() {
-    return (
-      this.data.getSize() +
-      this.clientIvcProof.clientIvcProofBuffer.length +
-      arraySerializedSizeOfNonEmpty(this.contractClassLogs) +
-      arraySerializedSizeOfNonEmpty(this.enqueuedPublicFunctionCalls) +
-      arraySerializedSizeOfNonEmpty([this.publicTeardownFunctionCall])
-    );
-  }
+  private sizeCache: number | undefined;
 
-  /**
-   * Estimates the tx size based on its private effects. Note that the actual size of the tx
-   * after processing will probably be larger, as public execution would generate more data.
-   */
-  getEstimatedPrivateTxEffectsSize() {
-    return (
-      this.data.getNonEmptyNoteHashes().length * Fr.SIZE_IN_BYTES +
-      this.data.getNonEmptyNullifiers().length * Fr.SIZE_IN_BYTES +
-      this.data.getEmittedPrivateLogsLength() * Fr.SIZE_IN_BYTES +
-      this.data.getEmittedContractClassLogsLength() * Fr.SIZE_IN_BYTES
-    );
-  }
-
-  /**
-   * Convenience function to get a hash out of a tx or a tx-like.
-   * @param tx - Tx-like object.
-   * @returns - The hash.
-   */
-  static async getHash(tx: Tx | HasHash): Promise<TxHash> {
-    return hasHash(tx) ? tx.hash : await tx.getTxHash();
+  getSize(): number {
+    if (this.sizeCache == undefined) {
+      this.sizeCache = this.toBuffer().length;
+    }
+    return this.sizeCache;
   }
 
   /**
-   * Convenience function to get array of hashes for an array of txs.
-   * @param txs - The txs to get the hashes from.
-   * @returns The corresponding array of hashes.
+   * Returns the number of fields this tx's effects will occupy in the blob,
+   * based on its private side effects only. Accurate for txs without public calls.
+   * For txs with public calls, the actual size will be larger due to public execution outputs.
    */
-  static async getHashes(txs: (Tx | HasHash)[]): Promise<TxHash[]> {
-    return await Promise.all(txs.map(Tx.getHash));
+  getPrivateTxEffectsSizeInFields(): number {
+    // 3 fields overhead: tx_start_marker, tx_hash, tx_fee.
+    // TX_DA_GAS_OVERHEAD is defined as N * DA_GAS_PER_FIELD, so this division is always exact.
+    const overheadFields = TX_DA_GAS_OVERHEAD / DA_GAS_PER_FIELD;
+    const noteHashes = this.data.getNonEmptyNoteHashes().length;
+    const nullifiers = this.data.getNonEmptyNullifiers().length;
+    const l2ToL1Msgs = this.data.getNonEmptyL2ToL1Msgs().length;
+    // Each private log occupies (emittedLength + 1) fields: content + length field
+    const privateLogFields = this.data.getNonEmptyPrivateLogs().reduce((acc, log) => acc + log.emittedLength + 1, 0);
+    // Each contract class log occupies (length + 1) fields: content + contract address
+    const contractClassLogFields = this.data
+      .getNonEmptyContractClassLogsHashes()
+      .reduce((acc, log) => acc + log.logHash.length + 1, 0);
+    return overheadFields + noteHashes + nullifiers + l2ToL1Msgs + privateLogFields + contractClassLogFields;
   }
 
   /**
    * Clones a tx, making a deep copy of all fields.
    * @param tx - The transaction to be cloned.
+   * @param cloneProof - Whether to clone the proof as well. If false, will shallow copy.
    * @returns The cloned transaction.
    */
-  static clone(tx: Tx): Tx {
+  static clone(tx: Tx, cloneProof = true): Tx {
     const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.toBuffer());
-    const clientIvcProof = ClientIvcProof.fromBuffer(tx.clientIvcProof.toBuffer());
-    const contractClassLogs = tx.contractClassLogs.map(x => ContractClassLog.fromBuffer(x.toBuffer()));
-    const enqueuedPublicFunctionCalls = tx.enqueuedPublicFunctionCalls.map(x =>
-      PublicExecutionRequest.fromBuffer(x.toBuffer()),
-    );
-    const publicTeardownFunctionCall = PublicExecutionRequest.fromBuffer(tx.publicTeardownFunctionCall.toBuffer());
-    const clonedTx = new Tx(
-      publicInputs,
-      clientIvcProof,
-      contractClassLogs,
-      enqueuedPublicFunctionCalls,
-      publicTeardownFunctionCall,
-    );
-    if (tx.txHash) {
-      clonedTx.setTxHash(TxHash.fromBuffer(tx.txHash.toBuffer()));
-    }
+    const chonkProof = cloneProof ? ChonkProof.fromBuffer(tx.chonkProof.toBuffer()) : tx.chonkProof;
+    const contractClassLogFields = tx.contractClassLogFields.map(p => p.clone());
+    const publicFunctionCalldata = tx.publicFunctionCalldata.map(cd => HashedValues.fromBuffer(cd.toBuffer()));
+    const clonedTx = new Tx(tx.txHash, publicInputs, chonkProof, contractClassLogFields, publicFunctionCalldata);
 
     return clonedTx;
   }
 
+  /**
+   * Returns a copy of this tx with its proof stripped (replaced by an empty {@link ChonkProof}). Used when archiving
+   * txs or shipping a pending tx over RPC where the proof is not needed. Note that {@link Tx.clone} with
+   * `cloneProof = false` does not strip the proof; it shares the original.
+   * @returns A new tx with an empty proof.
+   */
+  withoutProof(): Tx {
+    return new Tx(this.txHash, this.data, ChonkProof.empty(), this.contractClassLogFields, this.publicFunctionCalldata);
+  }
+
   /**
    * Creates a random tx.
    * @param randomProof - Whether to create a random proof - this will be random bytes of the full size.
    * @returns A random tx.
    */
-  static async random(randomProof = false) {
-    return new Tx(
-      PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
-      randomProof ? ClientIvcProof.random() : ClientIvcProof.empty(),
-      [await ContractClassLog.random()],
-      [await PublicExecutionRequest.random()],
-      await PublicExecutionRequest.random(),
-    );
+  static random(args: { randomProof?: boolean; txHash?: string | TxHash } = {}): Tx {
+    return Tx.from({
+      txHash: (typeof args.txHash === 'string' ? TxHash.fromString(args.txHash) : args.txHash) ?? TxHash.random(),
+      data: PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
+      chonkProof: args.randomProof ? ChonkProof.random() : ChonkProof.empty(),
+      contractClassLogFields: [ContractClassLogFields.random()],
+      publicFunctionCalldata: [HashedValues.random()],
+    });
   }
 
-  /**
-   * Filters out logs from functions that are not present in the provided kernel output.
-   *
-   * The purpose of this is to remove logs that got dropped due to a revert,
-   * in which case, we only have the kernel's hashes to go on, as opposed to
-   * this grouping by function maintained in this class.
-   *
-   * The logic therefore is to drop all FunctionLogs if any constituent hash
-   * does not appear in the provided hashes: it is impossible for part of a
-   * function to revert.
-   *
-   * @param logHashes the individual log hashes we want to keep
-   * @param out the output to put passing logs in, to keep this function abstract
-   */
-  public async filterRevertedLogs() {
-    this.contractClassLogs = await this.getSplitContractClassLogs(false);
+  /** Recomputes the tx hash. Used for testing purposes only when a property of the tx was mutated. */
+  public async recomputeHash(): Promise<TxHash> {
+    unfreeze(this).txHash = await Tx.computeTxHash(this);
+    return this.txHash;
+  }
+
+  #combinePublicCallRequestWithCallData(request: PublicCallRequest) {
+    const calldataMap = this.getCalldataMap();
+    // Assume empty calldata if nothing is given for the hash.
+    // The verification of calldata vs hash should be handled outside of this class.
+    const calldata = calldataMap.get(request.calldataHash.toString()) ?? [];
+    return new PublicCallRequestWithCalldata(request, calldata);
   }
 }
 
-/** Utility type for an entity that has a hash property for a txhash */
-type HasHash = { /** The tx hash */ hash: TxHash };
+/**
+ * Helper class to handle Serialization and Deserialization of Txs array.
+ */
+export class TxArray extends Array<Tx> {
+  static fromBuffer(buffer: Buffer | BufferReader): TxArray {
+    const reader = BufferReader.asReader(buffer);
+    try {
+      const txs = reader.readVector(Tx);
+      return new TxArray(...txs);
+    } catch {
+      throw new Error('Failed to deserialize TxArray from buffer');
+    }
+  }
 
-function hasHash(tx: Tx | HasHash): tx is HasHash {
-  return (tx as HasHash).hash !== undefined;
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return serializeArrayOfBufferableToVector(this);
+    }
+    serializeArrayToSink(sink, [...this]);
+  }
 }