@aztec/stdlib 3.0.0-nightly.20250926 → 3.0.0-nightly.20250928

package/src/interfaces/proving-job.ts

@@ -10,7 +10,6 @@ import { z } from 'zod';
 
 import { AvmCircuitInputs } from '../avm/avm.js';
 import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
-import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
@@ -32,8 +31,9 @@ import {
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
-import { PublicTubePrivateInputs } from '../rollup/index.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -214,7 +214,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_TUBE),
     result: schemaForPublicInputsAndRecursiveProof(
-      PrivateToPublicKernelCircuitPublicInputs.schema,
+      PublicTubePublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
@@ -326,7 +326,7 @@ export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
   [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
   [ProvingRequestType.PUBLIC_TUBE]: PublicInputsAndRecursiveProof<
-    PrivateToPublicKernelCircuitPublicInputs,
+    PublicTubePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<

package/src/interfaces/server_circuit_prover.ts

@@ -6,7 +6,6 @@ import type {
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
-import type { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
@@ -28,6 +27,7 @@ import type {
 } from '../rollup/checkpoint_root_rollup_private_inputs.js';
 import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
 import type { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import type { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
 import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
 import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
@@ -64,12 +64,7 @@ export interface ServerCircuitProver {
     inputs: PublicTubePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<
-      PrivateToPublicKernelCircuitPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.

package/src/logs/contract_class_log.ts

@@ -133,12 +133,11 @@ export class ContractClassLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+    return [this.contractAddress.toField()].concat(this.getEmittedFields());
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
     const contractAddress = reader.readObject(AztecAddress);
     const emittedFields = reader.readFieldArray(emittedLength);
     return new ContractClassLog(

package/src/rollup/base_rollup_hints.ts

@@ -127,10 +127,6 @@ export class PublicBaseRollupHints {
      * Preimages to the kernel's contractClassLogsHashes.
      */
     public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
-    /**
-     * Identifier of the prover.
-     */
-    public proverId: Fr,
   ) {}
 
   static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
@@ -143,7 +139,6 @@ export class PublicBaseRollupHints {
       fields.lastArchive,
       fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
-      fields.proverId,
     ] as const;
   }
 
@@ -170,7 +165,6 @@ export class PublicBaseRollupHints {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
-      reader.readObject(Fr),
     );
   }
 
@@ -184,7 +178,6 @@ export class PublicBaseRollupHints {
       AppendOnlyTreeSnapshot.empty(),
       makeTuple(ARCHIVE_HEIGHT, Fr.zero),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
-      Fr.ZERO,
     );
   }
 }

package/src/rollup/index.ts

@@ -13,6 +13,7 @@ export * from './epoch_constant_data.js';
 export * from './private_tx_base_rollup_private_inputs.js';
 export * from './public_tx_base_rollup_private_inputs.js';
 export * from './public_tube_private_inputs.js';
+export * from './public_tube_public_inputs.js';
 export * from './root_rollup_private_inputs.js';
 export * from './root_rollup_public_inputs.js';
 export * from './tree_snapshot_diff_hints.js';

package/src/rollup/public_tube_private_inputs.ts

@@ -1,3 +1,4 @@
+import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -7,19 +8,25 @@ import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_p
 import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
 
 export class PublicTubePrivateInputs {
-  constructor(public hidingKernelProofData: CivcProofData<PrivateToPublicKernelCircuitPublicInputs>) {}
+  constructor(
+    public hidingKernelProofData: CivcProofData<PrivateToPublicKernelCircuitPublicInputs>,
+    public proverId: Fr,
+  ) {}
 
   static from(fields: FieldsOf<PublicTubePrivateInputs>) {
     return new PublicTubePrivateInputs(...PublicTubePrivateInputs.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<PublicTubePrivateInputs>) {
-    return [fields.hidingKernelProofData] as const;
+    return [fields.hidingKernelProofData, fields.proverId] as const;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicTubePrivateInputs(ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs));
+    return new PublicTubePrivateInputs(
+      ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
+      Fr.fromBuffer(reader),
+    );
   }
 
   toBuffer() {

package/src/rollup/public_tube_public_inputs.ts

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+
+export class PublicTubePublicInputs {
+  constructor(
+    public privateTail: PrivateToPublicKernelCircuitPublicInputs,
+    public proverId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<PublicTubePublicInputs>) {
+    return new PublicTubePublicInputs(...PublicTubePublicInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicTubePublicInputs>) {
+    return [fields.privateTail, fields.proverId] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicTubePublicInputs(
+      reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
+      reader.readObject(Fr),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicTubePublicInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicTubePublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicTubePublicInputs);
+  }
+}

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -4,14 +4,14 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
-import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import type { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
+import { PublicTubePublicInputs } from './public_tube_public_inputs.js';
 
 export class PublicTxBaseRollupPrivateInputs {
   constructor(
-    public publicTubeProofData: RollupHonkProofData<PrivateToPublicKernelCircuitPublicInputs>,
+    public publicTubeProofData: RollupHonkProofData<PublicTubePublicInputs>,
     public avmProofData: AvmProofData,
     public hints: PublicBaseRollupHints,
   ) {}
@@ -27,7 +27,7 @@ export class PublicTxBaseRollupPrivateInputs {
   static fromBuffer(buffer: Buffer | BufferReader): PublicTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new PublicTxBaseRollupPrivateInputs(
-      ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
+      ProofData.fromBuffer(reader, PublicTubePublicInputs),
       ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
       reader.readObject(PublicBaseRollupHints),
     );

package/src/tests/factories.ts

@@ -143,6 +143,7 @@ import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { CheckpointRollupPublicInputs, FeeRecipient } from '../rollup/checkpoint_rollup_public_inputs.js';
 import { EpochConstantData } from '../rollup/epoch_constant_data.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
 import { TreeSnapshotDiffHints } from '../rollup/tree_snapshot_diff_hints.js';
@@ -415,6 +416,10 @@ export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   );
 }
 
+export function makePublicTubePublicInputs(seed = 1) {
+  return new PublicTubePublicInputs(makePrivateToPublicKernelCircuitPublicInputs(seed), fr(seed + 0x1000));
+}
+
 /**
  * Creates arbitrary public kernel circuit public inputs.
  * @param seed - The seed to use for generating the kernel circuit public inputs.
@@ -1068,7 +1073,6 @@ function makePublicBaseRollupHints(seed = 1) {
     lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x1000),
     anchorBlockArchiveSiblingPath: makeSiblingPath(seed + 0x2000, ARCHIVE_HEIGHT),
     contractClassLogsFields: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x3000),
-    proverId: fr(seed + 0x4000),
   });
 }
 
@@ -1080,11 +1084,7 @@ export function makePrivateTxBaseRollupPrivateInputs(seed = 0) {
 }
 
 export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
-  const publicTubeProofData = makeProofData(
-    seed,
-    makePrivateToPublicKernelCircuitPublicInputs,
-    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  );
+  const publicTubeProofData = makeProofData(seed, makePublicTubePublicInputs, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH);
   const avmProofData = makeProofData(seed + 0x100, makeAvmCircuitPublicInputs, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
   const hints = makePublicBaseRollupHints(seed + 0x200);
 

package/src/tx/tx_effect.ts

@@ -1,24 +1,13 @@
-import { TX_EFFECT_PREFIX_BYTE_LENGTH, TX_START_PREFIX_BYTES_LENGTH } from '@aztec/blob-lib/encoding';
+import { decodeTxStartMarker, encodeTxStartMarker, isValidTxStartMarker } from '@aztec/blob-lib/encoding';
 import {
-  CONTRACT_CLASS_LOGS_PREFIX,
-  L2_L1_MSGS_PREFIX,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NOTES_PREFIX,
-  NULLIFIERS_PREFIX,
-  PRIVATE_LOGS_PREFIX,
-  PUBLIC_DATA_UPDATE_REQUESTS_PREFIX,
-  PUBLIC_LOGS_PREFIX,
-  REVERT_CODE_PREFIX,
-  TX_FEE_PREFIX,
-  TX_START_PREFIX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -248,224 +237,90 @@ export class TxEffect {
     return new TxEffect(RevertCode.OK, TxHash.zero(), Fr.ZERO, [], [], [], [], [], [], []);
   }
 
-  isEmpty(): boolean {
-    return this.nullifiers.length === 0;
-  }
-
   /** Returns a hex representation of the TxEffect object. */
   toString() {
     return bufferToHex(this.toBuffer());
   }
 
   /**
-   * Returns the prefix as used in a blob.
-   * Used to prefix a 'block' of tx effects with its type and length.
-   */
-  private toPrefix(type: number, length: number): Fr {
-    const buf = Buffer.alloc(4);
-    buf.writeUint8(type);
-    buf.writeUInt16BE(length, 2);
-    return new Fr(buf);
-  }
-
-  /**
-   * Decodes the prefix as used in a blob to tx effect type and length.
-   */
-  static fromPrefix(prefix: Fr) {
-    const buf = prefix.toBuffer().subarray(-4);
-    return { type: buf[0], length: new Fr(buf.subarray(-2)).toNumber() };
-  }
-
-  /**
-   * Encodes the first field of a tx effect as used in a blob:
-   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-   */
-  private encodeFirstField(length: number, revertCode: RevertCode) {
-    const lengthBuf = Buffer.alloc(2);
-    lengthBuf.writeUInt16BE(length, 0);
-    return new Fr(
-      Buffer.concat([
-        toBufferBE(TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH),
-        Buffer.alloc(1),
-        lengthBuf,
-        Buffer.alloc(1),
-        Buffer.from([REVERT_CODE_PREFIX]),
-        Buffer.alloc(1),
-        revertCode.toBuffer(),
-      ]),
-    );
-  }
-
-  /**
-   * Decodes the first field of a tx effect as used in a blob:
-   * TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-   * Assumes that isFirstField has been called already.
-   */
-  static decodeFirstField(field: Fr) {
-    const buf = field.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    return {
-      length: new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber(),
-      revertCode: buf[buf.length - 1],
-    };
-  }
-
-  /**
-   * Determines whether a field is the first field of a tx effect
-   */
-  static isFirstField(field: Fr) {
-    const buf = field.toBuffer();
-    if (
-      !buf
-        .subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH)
-        .equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))
-    ) {
-      return false;
-    }
-    const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    if (
-      // Checking we start with the correct prefix...
-      !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) ||
-      // ...and include the revert code prefix..
-      sliced[sliced.length - 3] !== REVERT_CODE_PREFIX ||
-      // ...and the following revert code is valid.
-      sliced[sliced.length - 1] > 4
-    ) {
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Returns a flat packed array of prefixed fields of all tx effects, used for blobs.
+   * 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[] {
-    if (this.isEmpty()) {
-      return [];
-    }
     const flattened: Fr[] = [];
-    // We reassign the first field when we know the length of all effects - see below
+
+    // 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);
 
     flattened.push(this.txHash.hash);
-    // TODO: how long should tx fee be? For now, not using toPrefix()
-    flattened.push(
-      new Fr(
-        Buffer.concat([Buffer.from([TX_FEE_PREFIX]), Buffer.alloc(1), this.transactionFee.toBuffer().subarray(3)]),
-      ),
-    );
-    if (this.noteHashes.length) {
-      flattened.push(this.toPrefix(NOTES_PREFIX, this.noteHashes.length));
-      flattened.push(...this.noteHashes);
-    }
-    if (this.nullifiers.length) {
-      flattened.push(this.toPrefix(NULLIFIERS_PREFIX, this.nullifiers.length));
-      flattened.push(...this.nullifiers);
-    }
-    if (this.l2ToL1Msgs.length) {
-      flattened.push(this.toPrefix(L2_L1_MSGS_PREFIX, this.l2ToL1Msgs.length));
-      flattened.push(...this.l2ToL1Msgs);
-    }
-    if (this.publicDataWrites.length) {
-      flattened.push(this.toPrefix(PUBLIC_DATA_UPDATE_REQUESTS_PREFIX, this.publicDataWrites.length));
-      flattened.push(...this.publicDataWrites.flatMap(w => w.toBlobFields()));
-    }
-    if (this.privateLogs.length) {
-      flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, this.privateLogs.length));
-      flattened.push(...this.privateLogs.flatMap(l => l.toBlobFields()));
-    }
-    if (this.publicLogs.length) {
-      const flattenedPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
-      flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, flattenedPublicLogs.length));
-      flattened.push(...flattenedPublicLogs.toBlobFields());
-    }
-    if (this.contractClassLogs.length) {
-      flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, this.contractClassLogs.length));
-      flattened.push(...this.contractClassLogs.flatMap(l => l.toBlobFields()));
-    }
+    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()));
+
+    flattened[0] = encodeTxStartMarker({
+      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,
+      contractClassLogLength: this.contractClassLogs[0]?.emittedLength ?? 0,
+    });
 
-    // The first value appended to each list of fields representing a tx effect is:
-    // TX_START_PREFIX | 0 | txlen[0] txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revert_code
-    // Tx start and len are to aid decomposing/ identifying when we reach a new tx effect
-    // The remaining bytes are used for revert code, since that only requires 3 bytes
-    flattened[0] = this.encodeFirstField(flattened.length, this.revertCode);
     return flattened;
   }
 
   /**
-   * Decodes a flat packed array of prefixed fields to TxEffect
+   * Decodes a flat packed array of fields to TxEffect.
    */
   static fromBlobFields(fields: Fr[] | FieldReader) {
-    const ensureEmpty = <T>(arr: Array<T>) => {
-      if (arr.length) {
-        throw new Error('Invalid fields given to TxEffect.fromBlobFields(): Attempted to assign property twice.');
-      }
-    };
-
-    const effect = this.empty();
     const reader = FieldReader.asReader(fields);
     const totalFields = reader.remainingFields();
     if (!totalFields) {
-      return effect;
+      throw new Error('Cannot process empty blob fields.');
     }
 
-    const firstField = reader.readField();
-    if (!this.isFirstField(firstField)) {
-      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): First field invalid.');
+    const txStartMarker = decodeTxStartMarker(reader.readField());
+    if (!isValidTxStartMarker(txStartMarker)) {
+      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): invalid TxStartMarker');
     }
 
-    const { length: fieldsToProcess, revertCode } = this.decodeFirstField(firstField);
-    effect.revertCode = RevertCode.fromField(new Fr(revertCode));
-
-    effect.txHash = new TxHash(reader.readField());
-    // TODO: how long should tx fee be? For now, not using fromPrefix()
-    const prefixedFee = reader.readField();
-    // NB: Fr.fromBuffer hangs here if you provide a buffer less than 32 in len
-    // todo: try new Fr(prefixedFee.toBuffer().subarray(3))
-    effect.transactionFee = Fr.fromBuffer(Buffer.concat([Buffer.alloc(3), prefixedFee.toBuffer().subarray(3)]));
-
-    let fieldsProcessed = totalFields - reader.remainingFields();
-    while (fieldsProcessed < fieldsToProcess) {
-      const { type, length } = this.fromPrefix(reader.readField());
-      switch (type) {
-        case NOTES_PREFIX:
-          ensureEmpty(effect.noteHashes);
-          effect.noteHashes = reader.readFieldArray(length);
-          break;
-        case NULLIFIERS_PREFIX:
-          ensureEmpty(effect.nullifiers);
-          effect.nullifiers = reader.readFieldArray(length);
-          break;
-        case L2_L1_MSGS_PREFIX:
-          ensureEmpty(effect.l2ToL1Msgs);
-          effect.l2ToL1Msgs = reader.readFieldArray(length);
-          break;
-        case PUBLIC_DATA_UPDATE_REQUESTS_PREFIX: {
-          ensureEmpty(effect.publicDataWrites);
-          effect.publicDataWrites = Array.from({ length }, () => PublicDataWrite.fromBlobFields(reader));
-          break;
-        }
-        case PRIVATE_LOGS_PREFIX: {
-          ensureEmpty(effect.privateLogs);
-          effect.privateLogs = Array.from({ length }, () => PrivateLog.fromBlobFields(reader));
-          break;
-        }
-        case PUBLIC_LOGS_PREFIX: {
-          ensureEmpty(effect.publicLogs);
-          effect.publicLogs = FlatPublicLogs.fromBlobFields(length, reader).toLogs();
-          break;
-        }
-        case CONTRACT_CLASS_LOGS_PREFIX: {
-          ensureEmpty(effect.contractClassLogs);
-          effect.contractClassLogs = Array.from({ length }, () => ContractClassLog.fromBlobFields(reader));
-          break;
-        }
-        case REVERT_CODE_PREFIX:
-        default:
-          throw new Error(`Too many fields to decode given to TxEffect.fromBlobFields()`);
-      }
-      fieldsProcessed = totalFields - reader.remainingFields();
-    }
-    return effect;
+    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();
+    const contractClassLogs =
+      txStartMarker.contractClassLogLength > 0
+        ? [ContractClassLog.fromBlobFields(txStartMarker.contractClassLogLength, reader)]
+        : [];
+
+    return TxEffect.from({
+      revertCode,
+      txHash,
+      transactionFee,
+      noteHashes,
+      nullifiers,
+      l2ToL1Msgs,
+      publicDataWrites,
+      privateLogs,
+      publicLogs,
+      contractClassLogs,
+    });
   }
 
   static from(fields: FieldsOf<TxEffect>) {