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

package/src/tx/state_reference.ts

@@ -1,4 +1,10 @@
-import { STATE_REFERENCE_LENGTH } from '@aztec/constants';
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  STATE_REFERENCE_LENGTH,
+} from '@aztec/constants';
+import type { ViemStateReference } from '@aztec/ethereum';
 import type { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -33,7 +39,7 @@ export class StateReference {
   }
 
   toBuffer() {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
   }
 
@@ -61,12 +67,34 @@ export class StateReference {
     return new StateReference(l1ToL2MessageTree, partial);
   }
 
+  static fromViem(stateReference: ViemStateReference) {
+    return new StateReference(
+      AppendOnlyTreeSnapshot.fromViem(stateReference.l1ToL2MessageTree),
+      PartialStateReference.fromViem(stateReference.partialStateReference),
+    );
+  }
+
   static empty(): StateReference {
-    return new StateReference(AppendOnlyTreeSnapshot.zero(), PartialStateReference.empty());
+    return new StateReference(AppendOnlyTreeSnapshot.empty(), PartialStateReference.empty());
+  }
+
+  static random(): StateReference {
+    return new StateReference(AppendOnlyTreeSnapshot.random(), PartialStateReference.random());
+  }
+
+  toViem(): ViemStateReference {
+    return {
+      l1ToL2MessageTree: this.l1ToL2MessageTree.toViem(),
+      partialStateReference: this.partial.toViem(),
+    };
+  }
+
+  toAbi(): [ReturnType<AppendOnlyTreeSnapshot['toAbi']>, ReturnType<PartialStateReference['toAbi']>] {
+    return [this.l1ToL2MessageTree.toAbi(), [...this.partial.toAbi()]];
   }
 
   isEmpty(): boolean {
-    return this.l1ToL2MessageTree.isZero() && this.partial.isEmpty();
+    return this.l1ToL2MessageTree.isEmpty() && this.partial.isEmpty();
   }
 
   toInspect() {
@@ -78,6 +106,27 @@ export class StateReference {
     };
   }
 
+  /**
+   * Validates the trees in world state have the expected number of leaves (multiple of number of insertions per tx)
+   */
+  public validate() {
+    if (this.l1ToL2MessageTree.nextAvailableLeafIndex % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP !== 0) {
+      throw new Error(
+        `Invalid L1 to L2 message tree next available leaf index ${this.l1ToL2MessageTree.nextAvailableLeafIndex} (must be a multiple of ${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP})`,
+      );
+    }
+    if (this.partial.noteHashTree.nextAvailableLeafIndex % MAX_NOTE_HASHES_PER_TX !== 0) {
+      throw new Error(
+        `Invalid note hash tree next available leaf index ${this.partial.noteHashTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NOTE_HASHES_PER_TX})`,
+      );
+    }
+    if (this.partial.nullifierTree.nextAvailableLeafIndex % MAX_NULLIFIERS_PER_TX !== 0) {
+      throw new Error(
+        `Invalid nullifier tree next available leaf index ${this.partial.nullifierTree.nextAvailableLeafIndex} (must be a multiple of ${MAX_NULLIFIERS_PER_TX})`,
+      );
+    }
+  }
+
   [inspect.custom]() {
     return `StateReference {
   l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
@@ -88,6 +137,6 @@ export class StateReference {
   }
 
   public equals(other: this): boolean {
-    return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    return this.l1ToL2MessageTree.equals(other.l1ToL2MessageTree) && this.partial.equals(other.partial);
   }
 }

package/src/tx/tree_snapshots.ts

@@ -12,10 +12,10 @@ import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
  */
 export class TreeSnapshots {
   constructor(
-    public readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot,
-    public readonly noteHashTree: AppendOnlyTreeSnapshot,
-    public readonly nullifierTree: AppendOnlyTreeSnapshot,
-    public readonly publicDataTree: AppendOnlyTreeSnapshot,
+    public l1ToL2MessageTree: AppendOnlyTreeSnapshot,
+    public noteHashTree: AppendOnlyTreeSnapshot,
+    public nullifierTree: AppendOnlyTreeSnapshot,
+    public publicDataTree: AppendOnlyTreeSnapshot,
   ) {}
 
   static get schema() {
@@ -52,7 +52,7 @@ export class TreeSnapshots {
   }
 
   toBuffer() {
-    // Note: The order here must match the order in the HeaderLib solidity library.
+    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
   }
 
@@ -84,19 +84,19 @@ export class TreeSnapshots {
 
   static empty(): TreeSnapshots {
     return new TreeSnapshots(
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
-      AppendOnlyTreeSnapshot.zero(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
+      AppendOnlyTreeSnapshot.empty(),
     );
   }
 
   isEmpty(): boolean {
     return (
-      this.l1ToL2MessageTree.isZero() &&
-      this.noteHashTree.isZero() &&
-      this.nullifierTree.isZero() &&
-      this.publicDataTree.isZero()
+      this.l1ToL2MessageTree.isEmpty() &&
+      this.noteHashTree.isEmpty() &&
+      this.nullifierTree.isEmpty() &&
+      this.publicDataTree.isEmpty()
     );
   }
 

package/src/tx/tx.ts

@@ -10,85 +10,88 @@ 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';
 
 /**
  * The interface of an L2 transaction.
  */
 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 */
+    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,
-    /**
-     * Contract class logs generated by the tx.
      */
-    public contractClassLogs: ContractClassLog[],
+    public readonly chonkProof: ChonkProof,
     /**
-     * Enqueued public functions from the private circuit to be run by the sequencer.
+     * Contract class log fields emitted from the tx.
+     * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
+     * It's checked in data_validator.ts
      */
-    public readonly enqueuedPublicFunctionCalls: PublicExecutionRequest[],
+    public readonly contractClassLogFields: ContractClassLogFields[],
     /**
-     * Public function call to be run by the sequencer as part of teardown.
+     * An array of calldata for the enqueued public function calls and the teardown function call.
      */
-    public readonly publicTeardownFunctionCall: PublicExecutionRequest,
+    public readonly publicFunctionCalldata: HashedValues[],
   ) {
     super();
   }
 
   // Gossipable method
-  static {
-    this.p2pTopic = createTopicString(TopicType.tx);
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+    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 +106,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),
     );
   }
 
@@ -130,11 +120,11 @@ export class Tx extends Gossipable {
    */
   toBuffer() {
     return serializeToBuffer([
+      this.txHash,
       this.data,
-      this.clientIvcProof,
-      serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
-      serializeArrayOfBufferableToVector(this.enqueuedPublicFunctionCalls, 1),
-      this.publicTeardownFunctionCall,
+      this.chonkProof,
+      serializeArrayOfBufferableToVector(this.contractClassLogFields, 1),
+      serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1),
     ]);
   }
 
@@ -142,125 +132,126 @@ export class Tx extends Gossipable {
     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,
     );
   }
 
+  /**
+   * 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
+   */
+  async validateTxHash(): Promise<boolean> {
+    const expectedHash = await Tx.computeTxHash(this);
+    return this.txHash.equals(expectedHash);
+  }
+
   /**
    * 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.
    */
-  public async getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
-    return logsSource.getPublicLogs({ txHash: await this.getTxHash() });
+  public getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
+    return logsSource.getPublicLogs({ txHash: this.getTxHash() });
+  }
+
+  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,
+      proofSize: this.chonkProof.fields.length,
       size: this.toBuffer().length,
 
       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])
+      this.chonkProof.fields.length * Fr.SIZE_IN_BYTES +
+      arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
+      this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );
   }
 
@@ -277,24 +268,6 @@ export class Tx extends Gossipable {
     );
   }
 
-  /**
-   * 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();
-  }
-
-  /**
-   * 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.
-   */
-  static async getHashes(txs: (Tx | HasHash)[]): Promise<TxHash[]> {
-    return await Promise.all(txs.map(Tx.getHash));
-  }
-
   /**
    * Clones a tx, making a deep copy of all fields.
    * @param tx - The transaction to be cloned.
@@ -302,22 +275,10 @@ export class Tx extends Gossipable {
    */
   static clone(tx: Tx): 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 = ChonkProof.fromBuffer(tx.chonkProof.toBuffer());
+    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;
   }
@@ -327,38 +288,46 @@ export class Tx extends Gossipable {
    * @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() {
+    (this as any).txHash = await Tx.computeTxHash(this);
+  }
+
+  #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 {
+    try {
+      const reader = BufferReader.asReader(buffer);
+      const txs = reader.readVector(Tx);
+
+      return new TxArray(...txs);
+    } catch {
+      return new TxArray();
+    }
+  }
 
-function hasHash(tx: Tx | HasHash): tx is HasHash {
-  return (tx as HasHash).hash !== undefined;
+  public toBuffer(): Buffer {
+    return serializeArrayOfBufferableToVector(this);
+  }
 }