@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/src/tx/state_reference.ts

@@ -4,9 +4,9 @@ import {
   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';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -38,9 +38,22 @@ export class StateReference {
     return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
   }
 
-  toBuffer() {
-    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
-    return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
+  static getFields(fields: FieldsOf<StateReference>) {
+    return [fields.l1ToL2MessageTree, fields.partial] as const;
+  }
+
+  static from(fields: FieldsOf<StateReference>) {
+    return new StateReference(...StateReference.getFields(fields));
+  }
+
+  // Note: The order here must match the order in the ProposedHeaderLib solidity library.
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.l1ToL2MessageTree, this.partial);
   }
 
   toFields(): Fr[] {
@@ -67,13 +80,6 @@ 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.empty(), PartialStateReference.empty());
   }
@@ -82,13 +88,6 @@ export class 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()]];
   }

package/src/tx/tree_snapshots.ts

@@ -1,6 +1,6 @@
 import { TREE_SNAPSHOTS_LENGTH } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -51,9 +51,14 @@ export class TreeSnapshots {
     );
   }
 
-  toBuffer() {
-    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
-    return serializeToBuffer(this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
+  // Note: The order here must match the order in the ProposedHeaderLib solidity library.
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
@@ -91,6 +96,22 @@ export class TreeSnapshots {
     );
   }
 
+  /**
+   * Creates a TreeSnapshots instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing TreeSnapshots fields
+   * @returns A TreeSnapshots instance
+   */
+  static fromPlainObject(obj: any): TreeSnapshots {
+    return new TreeSnapshots(
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.l1ToL2MessageTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.noteHashTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.nullifierTree),
+      AppendOnlyTreeSnapshot.fromPlainObject(obj.publicDataTree),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.l1ToL2MessageTree.isEmpty() &&

package/src/tx/tx.ts

@@ -1,15 +1,19 @@
-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 { PublicCallRequest } from '../kernel/index.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
@@ -21,16 +25,29 @@ 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 = TopicType.tx;
 
   private calldataMap: Map<string, Fr[]> | undefined;
 
   constructor(
-    /** Identifier of the tx */
+    /**
+     * 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.
@@ -43,19 +60,23 @@ export class Tx extends Gossipable {
     /**
      * 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
+     * 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 readonly contractClassLogFields: ContractClassLogFields[],
     /**
      * 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 publicFunctionCalldata: HashedValues[],
   ) {
     super();
   }
+  // docs:end:tx_class
 
   // Gossipable method
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
     return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
   }
 
@@ -118,14 +139,15 @@ export class Tx extends Gossipable {
    * Serializes the Tx object into a Buffer.
    * @returns Buffer representation of the Tx object.
    */
-  toBuffer() {
-    return serializeToBuffer([
-      this.txHash,
-      this.data,
-      this.chonkProof,
-      serializeArrayOfBufferableToVector(this.contractClassLogFields, 1),
-      serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1),
-    ]);
+  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> {
@@ -171,15 +193,6 @@ export class Tx extends Gossipable {
     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 getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
-    return logsSource.getPublicLogs({ txHash: this.getTxHash() });
-  }
-
   getContractClassLogs(): ContractClassLog[] {
     const logHashes = this.data.getNonEmptyContractClassLogsHashes();
     return logHashes.map((logHash, i) =>
@@ -238,7 +251,7 @@ export class Tx extends Gossipable {
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
       proofSize: this.chonkProof.fields.length,
-      size: this.toBuffer().length,
+      size: this.getSize(),
 
       feePaymentMethod:
         // needsSetup? then we pay through a fee payment contract
@@ -246,36 +259,45 @@ export class Tx extends Gossipable {
     };
   }
 
-  getSize() {
-    return (
-      this.data.getSize() +
-      this.chonkProof.fields.length * Fr.SIZE_IN_BYTES +
-      arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
-      this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
-    );
+  private sizeCache: number | undefined;
+
+  getSize(): number {
+    if (this.sizeCache == undefined) {
+      this.sizeCache = this.toBuffer().length;
+    }
+    return this.sizeCache;
   }
 
   /**
-   * 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.
+   * 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.
    */
-  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
-    );
+  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 chonkProof = ChonkProof.fromBuffer(tx.chonkProof.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);
@@ -283,6 +305,16 @@ export class Tx extends Gossipable {
     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.
@@ -299,8 +331,9 @@ export class Tx extends Gossipable {
   }
 
   /** 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);
+  public async recomputeHash(): Promise<TxHash> {
+    unfreeze(this).txHash = await Tx.computeTxHash(this);
+    return this.txHash;
   }
 
   #combinePublicCallRequestWithCallData(request: PublicCallRequest) {
@@ -317,17 +350,21 @@ export class Tx extends Gossipable {
  */
 export class TxArray extends Array<Tx> {
   static fromBuffer(buffer: Buffer | BufferReader): TxArray {
+    const reader = BufferReader.asReader(buffer);
     try {
-      const reader = BufferReader.asReader(buffer);
       const txs = reader.readVector(Tx);
-
       return new TxArray(...txs);
     } catch {
-      return new TxArray();
+      throw new Error('Failed to deserialize TxArray from buffer');
     }
   }
 
-  public toBuffer(): Buffer {
-    return serializeArrayOfBufferableToVector(this);
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return serializeArrayOfBufferableToVector(this);
+    }
+    serializeArrayToSink(sink, [...this]);
   }
 }

package/src/tx/tx_constant_data.ts

@@ -1,6 +1,6 @@
 import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { BlockHeader } from './block_header.js';
@@ -57,8 +57,13 @@ export class TxConstantData {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(...TxConstantData.getFields(this));
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, ...TxConstantData.getFields(this));
   }
 
   static empty() {

package/src/tx/tx_context.ts

@@ -1,7 +1,7 @@
 import { TX_CONTEXT_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -49,8 +49,13 @@ export class TxContext {
    * Serialize as a buffer.
    * @returns The buffer.
    */
-  toBuffer() {
-    return serializeToBuffer(...TxContext.getFields(this));
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, ...TxContext.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader): TxContext {

package/src/tx/tx_effect.ts

@@ -1,4 +1,10 @@
-import { decodeTxStartMarker, encodeTxStartMarker, isValidTxStartMarker } from '@aztec/blob-lib/encoding';
+import {
+  type TxBlobData,
+  type TxStartMarker,
+  decodeTxBlobData,
+  encodeTxBlobData,
+  getNumTxBlobFields,
+} from '@aztec/blob-lib/encoding';
 import {
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
@@ -8,16 +14,11 @@ import {
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import {
-  BufferReader,
-  FieldReader,
-  serializeArrayOfBufferableToVector,
-  serializeToBuffer,
-} from '@aztec/foundation/serialize';
+import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -160,11 +161,6 @@ export class TxEffect {
     );
   }
 
-  /** Returns the size of this tx effect in bytes as serialized onto DA. */
-  getDASize() {
-    return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
-  }
-
   /**
    * Deserializes the TxEffect object from a Buffer.
    * @param buffer - Buffer or BufferReader object to deserialize.
@@ -187,49 +183,41 @@ export class TxEffect {
     );
   }
 
-  /**
-   * Computes txOutHash of this tx effect.
-   * @dev Follows new_sha in unbalanced_merkle_tree.nr
-   */
-  txOutHash(): Buffer {
-    const { l2ToL1Msgs } = this;
-    if (l2ToL1Msgs.length == 0) {
-      return Buffer.alloc(32);
-    }
-
-    return computeUnbalancedMerkleTreeRoot(l2ToL1Msgs.map(msg => msg.toBuffer()));
-  }
-
-  static async random(
+  static async random({
+    numNoteHashes,
+    numNullifiers,
+    numL2ToL1Msgs,
+    numPublicDataWrites,
+    numPrivateLogs,
     numPublicCallsPerTx = 3,
     numPublicLogsPerCall = 1,
-    maxEffects: number | undefined = undefined,
-  ): Promise<TxEffect> {
+    numContractClassLogs,
+    maxEffects,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Msgs?: number;
+    numPublicDataWrites?: number;
+    numPrivateLogs?: number;
+    numPublicCallsPerTx?: number;
+    numPublicLogsPerCall?: number;
+    numContractClassLogs?: number;
+    maxEffects?: number;
+  } = {}): Promise<TxEffect> {
+    const count = (max: number, num?: number) => num ?? Math.min(maxEffects ?? randomInt(max), max);
+    // Every tx effect must have at least 1 nullifier (the first nullifier is used for log indexing)
+    const countNullifiers = (max: number, num?: number) => Math.max(1, count(max, num));
     return new TxEffect(
       RevertCode.random(),
       TxHash.random(),
       new Fr(Math.floor(Math.random() * 100_000)),
-      makeTuple(
-        maxEffects === undefined ? MAX_NOTE_HASHES_PER_TX : Math.min(maxEffects, MAX_NOTE_HASHES_PER_TX),
-        Fr.random,
-      ),
-      makeTuple(
-        maxEffects === undefined ? MAX_NULLIFIERS_PER_TX : Math.min(maxEffects, MAX_NULLIFIERS_PER_TX),
-        Fr.random,
-      ),
-      makeTuple(
-        maxEffects === undefined ? MAX_L2_TO_L1_MSGS_PER_TX : Math.min(maxEffects, MAX_L2_TO_L1_MSGS_PER_TX),
-        Fr.random,
-      ),
-      makeTuple(
-        maxEffects === undefined
-          ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-          : Math.min(maxEffects, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
-        PublicDataWrite.random,
-      ),
-      makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => PrivateLog.random()),
+      makeTuple(count(MAX_NOTE_HASHES_PER_TX, numNoteHashes), Fr.random),
+      makeTuple(countNullifiers(MAX_NULLIFIERS_PER_TX, numNullifiers), Fr.random),
+      makeTuple(count(MAX_L2_TO_L1_MSGS_PER_TX, numL2ToL1Msgs), Fr.random),
+      makeTuple(count(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, numPublicDataWrites), PublicDataWrite.random),
+      makeTuple(count(MAX_PRIVATE_LOGS_PER_TX, numPrivateLogs), () => PrivateLog.random()),
       await Promise.all(new Array(numPublicCallsPerTx * numPublicLogsPerCall).fill(null).map(() => PublicLog.random())),
-      await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.random),
+      await makeTupleAsync(count(MAX_CONTRACT_CLASS_LOGS_PER_TX, numContractClassLogs), ContractClassLog.random),
     );
   }
 
@@ -242,71 +230,70 @@ export class TxEffect {
     return bufferToHex(this.toBuffer());
   }
 
-  /**
-   * Returns a flat packed array of fields of all tx effects, to be appended to blobs.
-   * Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr
-   */
-  toBlobFields(): Fr[] {
-    const flattened: Fr[] = [];
+  getNumBlobFields(): number {
+    return this.getTxStartMarker().numBlobFields;
+  }
 
-    // We reassign the first field at the end when we know the length of all effects to create the tx start marker.
-    flattened.push(Fr.ZERO);
+  toBlobFields(): Fr[] {
+    return encodeTxBlobData(this.toTxBlobData());
+  }
 
-    flattened.push(this.txHash.hash);
-    flattened.push(this.transactionFee);
-    flattened.push(...this.noteHashes);
-    flattened.push(...this.nullifiers);
-    flattened.push(...this.l2ToL1Msgs);
-    flattened.push(...this.publicDataWrites.flatMap(w => w.toBlobFields()));
-    flattened.push(...this.privateLogs.flatMap(l => l.toBlobFields()));
-    const flattenedPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
-    flattened.push(...flattenedPublicLogs.toBlobFields());
-    flattened.push(...this.contractClassLogs.flatMap(l => l.toBlobFields()));
+  static fromBlobFields(fields: Fr[]) {
+    return TxEffect.fromTxBlobData(decodeTxBlobData(fields));
+  }
 
-    flattened[0] = encodeTxStartMarker({
+  getTxStartMarker(): TxStartMarker {
+    const flatPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
+    const partialTxStartMarker = {
       revertCode: this.revertCode.getCode(),
-      numBlobFields: flattened.length,
       numNoteHashes: this.noteHashes.length,
       numNullifiers: this.nullifiers.length,
       numL2ToL1Msgs: this.l2ToL1Msgs.length,
       numPublicDataWrites: this.publicDataWrites.length,
       numPrivateLogs: this.privateLogs.length,
-      publicLogsLength: flattenedPublicLogs.length,
+      privateLogsLength: this.privateLogs.reduce((acc, log) => acc + log.emittedLength, 0),
+      publicLogsLength: flatPublicLogs.length,
       contractClassLogLength: this.contractClassLogs[0]?.emittedLength ?? 0,
-    });
+    };
+    const numBlobFields = getNumTxBlobFields(partialTxStartMarker);
+    return {
+      ...partialTxStartMarker,
+      numBlobFields,
+    };
+  }
 
-    return flattened;
+  toTxBlobData(): TxBlobData {
+    return {
+      txStartMarker: this.getTxStartMarker(),
+      txHash: this.txHash.hash,
+      transactionFee: this.transactionFee,
+      noteHashes: this.noteHashes,
+      nullifiers: this.nullifiers,
+      l2ToL1Msgs: this.l2ToL1Msgs,
+      publicDataWrites: this.publicDataWrites.map(w => w.toBlobFields()),
+      privateLogs: this.privateLogs.map(l => l.toBlobFields()),
+      publicLogs: FlatPublicLogs.fromLogs(this.publicLogs).toBlobFields(),
+      contractClassLog: this.contractClassLogs.map(l => l.toBlobFields()).flat(),
+    };
   }
 
   /**
    * Decodes a flat packed array of fields to TxEffect.
    */
-  static fromBlobFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    const totalFields = reader.remainingFields();
-    if (!totalFields) {
-      throw new Error('Cannot process empty blob fields.');
-    }
-
-    const txStartMarker = decodeTxStartMarker(reader.readField());
-    if (!isValidTxStartMarker(txStartMarker)) {
-      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): invalid TxStartMarker');
-    }
-
-    const revertCode = RevertCode.fromField(new Fr(txStartMarker.revertCode));
-    const txHash = new TxHash(reader.readField());
-    const transactionFee = reader.readField();
-    const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
-    const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
-    const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
-    const publicDataWrites = Array.from({ length: txStartMarker.numPublicDataWrites }, () =>
-      PublicDataWrite.fromBlobFields(reader),
-    );
-    const privateLogs = Array.from({ length: txStartMarker.numPrivateLogs }, () => PrivateLog.fromBlobFields(reader));
-    const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, reader).toLogs();
+  static fromTxBlobData(txBlobData: TxBlobData) {
+    const txStartMarker = txBlobData.txStartMarker;
+    const revertCode = RevertCode.fromNumber(txStartMarker.revertCode);
+    const txHash = new TxHash(txBlobData.txHash);
+    const transactionFee = txBlobData.transactionFee;
+    const noteHashes = txBlobData.noteHashes;
+    const nullifiers = txBlobData.nullifiers;
+    const l2ToL1Msgs = txBlobData.l2ToL1Msgs;
+    const publicDataWrites = txBlobData.publicDataWrites.map(w => PublicDataWrite.fromBlobFields(w));
+    const privateLogs = txBlobData.privateLogs.map(l => PrivateLog.fromBlobFields(l.length, l));
+    const publicLogs = FlatPublicLogs.fromBlobFields(txStartMarker.publicLogsLength, txBlobData.publicLogs).toLogs();
     const contractClassLogs =
       txStartMarker.contractClassLogLength > 0
-        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, reader)]
+        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, txBlobData.contractClassLog)]
         : [];
 
     return TxEffect.from({