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

package/src/tx/processed_tx.ts

@@ -1,9 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
+import type { PublicTxEffect } from '../avm/avm.js';
 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 { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
 import { computeL2ToL1MessageHash } from '../hash/hash.js';
@@ -130,17 +131,13 @@ export function makeProcessedTxFromPrivateOnlyTx(
 
 export function makeProcessedTxFromTxWithPublicCalls(
   tx: Tx,
-  avmProvingRequest: AvmProvingRequest,
+  globalVariables: GlobalVariables,
+  avmProvingRequest: AvmProvingRequest | undefined,
+  publicTxEffect: PublicTxEffect,
   gasUsed: GasUsed,
   revertCode: RevertCode,
   revertReason: SimulationError | undefined,
 ): ProcessedTx {
-  const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
-
-  const globalVariables = 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 : []),
@@ -153,10 +150,10 @@ export function makeProcessedTxFromTxWithPublicCalls(
   const txEffect = new TxEffect(
     revertCode,
     tx.getTxHash(),
-    avmPublicInputs.transactionFee,
-    avmPublicInputs.accumulatedData.noteHashes.filter(h => !h.isZero()),
-    avmPublicInputs.accumulatedData.nullifiers.filter(h => !h.isZero()),
-    avmPublicInputs.accumulatedData.l2ToL1Msgs
+    publicTxEffect.transactionFee,
+    publicTxEffect.noteHashes,
+    publicTxEffect.nullifiers,
+    publicTxEffect.l2ToL1Msgs // convert messages to hashes.
       .filter(msg => !msg.contractAddress.isZero())
       .map(msg =>
         computeL2ToL1MessageHash({
@@ -167,12 +164,18 @@ export function makeProcessedTxFromTxWithPublicCalls(
           chainId: globalVariables.chainId,
         }),
       ),
-    publicDataWrites,
+    publicTxEffect.publicDataWrites,
     privateLogs,
-    avmPublicInputs.accumulatedData.publicLogs.toLogs(),
+    publicTxEffect.publicLogs,
     contractClassLogs,
   );
 
+  // Some callers expect a revert reason if the tx reverted.
+  const finalRevertReason =
+    revertReason === undefined && !revertCode.isOK()
+      ? new SimulationError('TX reverted', /*functionErrorStack=*/ [], /*revertData=*/ [])
+      : revertReason;
+
   return {
     hash: txEffect.txHash,
     data: tx.data,
@@ -182,6 +185,6 @@ export function makeProcessedTxFromTxWithPublicCalls(
     txEffect,
     gasUsed,
     revertCode,
-    revertReason,
+    revertReason: finalRevertReason,
   };
 }

package/src/tx/profiling.ts

@@ -1,12 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, optional } from '@aztec/foundation/schemas';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type ZodFor, optional, schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import type { AbiDecoded } from '../abi/decoder.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
-import { AbiDecodedSchema } from '../schemas/schemas.js';
 
 export type NodeStats = Partial<Record<keyof AztecNode, { times: number[] }>>;
 
@@ -127,21 +125,21 @@ export class TxProfileResult {
 
 export class UtilitySimulationResult {
   constructor(
-    public result: AbiDecoded,
+    public result: Fr[],
     public stats?: SimulationStats,
   ) {}
 
   static get schema(): ZodFor<UtilitySimulationResult> {
     return z
       .object({
-        result: AbiDecodedSchema,
+        result: z.array(schemas.Fr),
         stats: optional(SimulationStatsSchema),
       })
       .transform(({ result, stats }) => new UtilitySimulationResult(result, stats));
   }
 
   static random(): UtilitySimulationResult {
-    return new UtilitySimulationResult(Fr.random().toBigInt(), {
+    return new UtilitySimulationResult([Fr.random()], {
       nodeRPCCalls: { getBlockHeader: { times: [1] } },
       timings: {
         sync: 1,

package/src/tx/protocol_contracts.ts

@@ -1,8 +1,8 @@
 import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   BufferReader,
   FieldReader,
@@ -50,6 +50,22 @@ export class ProtocolContracts {
     return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, () => AztecAddress.zero()));
   }
 
+  /**
+   * Creates a ProtocolContracts 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 ProtocolContracts fields
+   * @returns A ProtocolContracts instance
+   */
+  static fromPlainObject(obj: any): ProtocolContracts {
+    return new ProtocolContracts(
+      assertLength(
+        obj.derivedAddresses.map((addr: any) => AztecAddress.fromPlainObject(addr)),
+        MAX_PROTOCOL_CONTRACTS,
+      ),
+    );
+  }
+
   getSize() {
     return arraySerializedSizeOfNonEmpty(this.derivedAddresses);
   }

package/src/tx/public_call_request_with_calldata.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -46,6 +46,23 @@ export class PublicCallRequestWithCalldata {
     return new PublicCallRequestWithCalldata(fields.request, fields.calldata);
   }
 
+  /**
+   * Creates a PublicCallRequestWithCalldata 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 PublicCallRequestWithCalldata fields
+   * @returns A PublicCallRequestWithCalldata instance
+   */
+  static fromPlainObject(obj: any): PublicCallRequestWithCalldata {
+    if (obj instanceof PublicCallRequestWithCalldata) {
+      return obj;
+    }
+    return new PublicCallRequestWithCalldata(
+      PublicCallRequest.fromPlainObject(obj.request),
+      obj.calldata.map((f: any) => Fr.fromPlainObject(f)),
+    );
+  }
+
   toBuffer() {
     return serializeToBuffer(this.request, new Vector(this.calldata));
   }

package/src/tx/public_simulation_output.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 
 import times from 'lodash.times';
@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
+import { NullishToUndefined } from '../schemas/schemas.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { GlobalVariables } from './global_variables.js';
 
@@ -23,15 +24,31 @@ export class NestedProcessReturnValues {
     this.nested = nested ?? [];
   }
 
+  equals(other: NestedProcessReturnValues): boolean {
+    return (
+      this.values?.length === other.values?.length &&
+      this.nested.length === other.nested.length &&
+      (this.values === undefined || this.values.every((v, i) => v.equals(other.values![i]))) &&
+      this.nested.every((n, i) => n.equals(other.nested[i]))
+    );
+  }
+
   static get schema(): ZodFor<NestedProcessReturnValues> {
     return z
       .object({
-        values: z.array(schemas.Fr).optional(),
+        values: NullishToUndefined(z.array(schemas.Fr)),
         nested: z.array(z.lazy(() => NestedProcessReturnValues.schema)),
       })
       .transform(({ values, nested }) => new NestedProcessReturnValues(values, nested));
   }
 
+  static fromPlainObject(obj: any): NestedProcessReturnValues {
+    return new NestedProcessReturnValues(
+      obj.values?.map(Fr.fromPlainObject),
+      obj.nested?.map(NestedProcessReturnValues.fromPlainObject),
+    );
+  }
+
   static empty() {
     return new NestedProcessReturnValues([]);
   }

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 type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -38,6 +38,14 @@ export class StateReference {
     return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
   }
 
+  static getFields(fields: FieldsOf<StateReference>) {
+    return [fields.l1ToL2MessageTree, fields.partial] as const;
+  }
+
+  static from(fields: FieldsOf<StateReference>) {
+    return new StateReference(...StateReference.getFields(fields));
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
@@ -67,13 +75,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 +83,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,5 +1,5 @@
 import { TREE_SNAPSHOTS_LENGTH } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -91,6 +91,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,6 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+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';
@@ -30,7 +30,11 @@ export class Tx extends Gossipable {
   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,11 +47,14 @@ 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[],
   ) {
@@ -271,11 +278,12 @@ export class Tx extends Gossipable {
   /**
    * 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);
@@ -299,8 +307,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() {
+  public async recomputeHash(): Promise<TxHash> {
     (this as any).txHash = await Tx.computeTxHash(this);
+    return this.txHash;
   }
 
   #combinePublicCallRequestWithCallData(request: PublicCallRequest) {
@@ -317,13 +326,12 @@ 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');
     }
   }
 

package/src/tx/tx_constant_data.ts

@@ -1,5 +1,5 @@
 import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/tx/tx_context.ts

@@ -1,5 +1,5 @@
 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 type { FieldsOf } from '@aztec/foundation/types';

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';
@@ -27,6 +28,7 @@ import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { computeTxOutHash } from '../messaging/out_hash.js';
 import { TxHash } from './tx_hash.js';
 
 export class TxEffect {
@@ -160,11 +162,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.
@@ -191,45 +188,45 @@ 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()));
+  txOutHash(): Fr {
+    return computeTxOutHash(this.l2ToL1Msgs);
   }
 
-  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 +239,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({

package/src/tx/tx_execution_request.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';

package/src/tx/tx_hash.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeArrayOfBufferableToVector } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/index.js';