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

package/src/tx/tx_constant_data.ts

@@ -1,35 +1,22 @@
 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';
 import { TxContext } from './tx_context.js';
 
 /**
- * Data that is constant/not modified by neither of the kernels.
+ * Version of `PrivateTxConstantData` exposed by the tail circuits
+ * It compresses the protocol contracts list to a hash to minimize the number of public inputs.
+ * Refer to `PrivateTxConstantData` for more details.
  */
 export class TxConstantData {
   constructor(
-    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
-    public historicalHeader: BlockHeader,
-    /**
-     * Context of the transaction.
-     *
-     * Note: `chainId` and `version` in txContext are not redundant to the values in
-     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
-     * a situation we could be using header from a block before the upgrade took place but be using the updated
-     * protocol to execute and prove the transaction.
-     */
+    public anchorBlockHeader: BlockHeader,
     public txContext: TxContext,
-    /**
-     * Root of the vk tree for the protocol circuits.
-     */
     public vkTreeRoot: Fr,
-    /**
-     * Root of the tree for the protocol contracts.
-     */
-    public protocolContractTreeRoot: Fr,
+    public protocolContractsHash: Fr,
   ) {}
 
   static from(fields: FieldsOf<TxConstantData>) {
@@ -37,7 +24,7 @@ export class TxConstantData {
   }
 
   static getFields(fields: FieldsOf<TxConstantData>) {
-    return [fields.historicalHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractTreeRoot] as const;
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractsHash] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): TxConstantData {
@@ -70,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() {
@@ -80,10 +72,10 @@ export class TxConstantData {
 
   getSize() {
     return (
-      this.historicalHeader.getSize() +
+      this.anchorBlockHeader.getSize() +
       this.txContext.getSize() +
       this.vkTreeRoot.size +
-      this.protocolContractTreeRoot.size
+      this.protocolContractsHash.size
     );
   }
 

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,35 +1,23 @@
 import {
-  CONTRACT_CLASS_LOGS_PREFIX,
-  CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  L2_L1_MSGS_PREFIX,
+  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,
   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,
-  PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_DATA_UPDATE_REQUESTS_PREFIX,
-  PUBLIC_LOGS_PREFIX,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
-  REVERT_CODE_PREFIX,
-  TX_FEE_PREFIX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple, makeTupleAsync } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-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 { inspect } from 'util';
@@ -39,16 +27,9 @@ import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
-import { PublicLog } from '../logs/public_log.js';
+import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
 import { TxHash } from './tx_hash.js';
 
-// This will appear as 0x74785f7374617274 in logs
-export const TX_START_PREFIX = 8392562855083340404n;
-// These are helper constants to decode tx effects from blob encoded fields
-export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
-// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
-export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
-
 export class TxEffect {
   constructor(
     /**
@@ -153,14 +134,31 @@ export class TxEffect {
       serializeArrayOfBufferableToVector(this.l2ToL1Msgs, 1),
       serializeArrayOfBufferableToVector(this.publicDataWrites, 1),
       serializeArrayOfBufferableToVector(this.privateLogs, 1),
-      serializeArrayOfBufferableToVector(this.publicLogs, 1),
+      serializeArrayOfBufferableToVector(this.publicLogs, 4),
       serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
     ]);
   }
 
-  /** Returns the size of this tx effect in bytes as serialized onto DA. */
-  getDASize() {
-    return this.toBlobFields().length * Fr.SIZE_IN_BYTES;
+  equals(other: TxEffect): boolean {
+    return (
+      this.revertCode.equals(other.revertCode) &&
+      this.txHash.equals(other.txHash) &&
+      this.transactionFee.equals(other.transactionFee) &&
+      this.noteHashes.length === other.noteHashes.length &&
+      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
+      this.nullifiers.length === other.nullifiers.length &&
+      this.nullifiers.every((h, i) => h.equals(other.nullifiers[i])) &&
+      this.l2ToL1Msgs.length === other.l2ToL1Msgs.length &&
+      this.l2ToL1Msgs.every((h, i) => h.equals(other.l2ToL1Msgs[i])) &&
+      this.publicDataWrites.length === other.publicDataWrites.length &&
+      this.publicDataWrites.every((h, i) => h.equals(other.publicDataWrites[i])) &&
+      this.privateLogs.length === other.privateLogs.length &&
+      this.privateLogs.every((h, i) => h.equals(other.privateLogs[i])) &&
+      this.publicLogs.length === other.publicLogs.length &&
+      this.publicLogs.every((h, i) => h.equals(other.publicLogs[i])) &&
+      this.contractClassLogs.length === other.contractClassLogs.length &&
+      this.contractClassLogs.every((h, i) => h.equals(other.contractClassLogs[i]))
+    );
   }
 
   /**
@@ -180,51 +178,46 @@ export class TxEffect {
       reader.readVectorUint8Prefix(Fr),
       reader.readVectorUint8Prefix(PublicDataWrite),
       reader.readVectorUint8Prefix(PrivateLog),
-      reader.readVectorUint8Prefix(PublicLog),
+      reader.readVector(PublicLog),
       reader.readVectorUint8Prefix(ContractClassLog),
     );
   }
 
-  /**
-   * Computes txOutHash of this tx effect.
-   * TODO(#7218): Revert to fixed height tree for outbox
-   * @dev Follows new_sha in variable_merkle_tree.nr
-   */
-  txOutHash() {
-    const { l2ToL1Msgs } = this;
-    if (l2ToL1Msgs.length == 0) {
-      return Buffer.alloc(32);
-    }
-    const depth = l2ToL1Msgs.length == 1 ? 1 : Math.ceil(Math.log2(l2ToL1Msgs.length));
-    let thisLayer = padArrayEnd(
-      l2ToL1Msgs.map(msg => msg.toBuffer()),
-      Buffer.alloc(32),
-      2 ** depth,
-    );
-    let nextLayer = [];
-    for (let i = 0; i < depth; i++) {
-      for (let j = 0; j < thisLayer.length; j += 2) {
-        // Store the hash of each pair one layer up
-        nextLayer[j / 2] = sha256Trunc(Buffer.concat([thisLayer[j], thisLayer[j + 1]]));
-      }
-      thisLayer = nextLayer;
-      nextLayer = [];
-    }
-    return thisLayer[0];
-  }
-
-  static async random(numPublicCallsPerTx = 3, numPublicLogsPerCall = 1): Promise<TxEffect> {
+  static async random({
+    numNoteHashes,
+    numNullifiers,
+    numL2ToL1Msgs,
+    numPublicDataWrites,
+    numPrivateLogs,
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    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(MAX_NOTE_HASHES_PER_TX, Fr.random),
-      makeTuple(MAX_NULLIFIERS_PER_TX, Fr.random),
-      makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, Fr.random),
-      makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, () => new PublicDataWrite(Fr.random(), Fr.random())),
-      makeTuple(MAX_PRIVATE_LOGS_PER_TX, () => new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random))),
-      await makeTupleAsync(numPublicCallsPerTx * numPublicLogsPerCall, PublicLog.random),
-      await makeTupleAsync(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.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(count(MAX_CONTRACT_CLASS_LOGS_PER_TX, numContractClassLogs), ContractClassLog.random),
     );
   }
 
@@ -232,267 +225,89 @@ 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);
+  getNumBlobFields(): number {
+    return this.getTxStartMarker().numBlobFields;
   }
 
-  /**
-   * 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() };
+  toBlobFields(): Fr[] {
+    return encodeTxBlobData(this.toTxBlobData());
   }
 
-  /**
-   * 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(),
-      ]),
-    );
+  static fromBlobFields(fields: Fr[]) {
+    return TxEffect.fromTxBlobData(decodeTxBlobData(fields));
   }
 
-  /**
-   * 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);
+  getTxStartMarker(): TxStartMarker {
+    const flatPublicLogs = FlatPublicLogs.fromLogs(this.publicLogs);
+    const partialTxStartMarker = {
+      revertCode: this.revertCode.getCode(),
+      numNoteHashes: this.noteHashes.length,
+      numNullifiers: this.nullifiers.length,
+      numL2ToL1Msgs: this.l2ToL1Msgs.length,
+      numPublicDataWrites: this.publicDataWrites.length,
+      numPrivateLogs: this.privateLogs.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 {
-      length: new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber(),
-      revertCode: buf[buf.length - 1],
+      ...partialTxStartMarker,
+      numBlobFields,
     };
   }
 
-  /**
-   * 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.
-   */
-  toBlobFields(): Fr[] {
-    if (this.isEmpty()) {
-      return [];
-    }
-    const flattened: Fr[] = [];
-    // We reassign the first field when we know the length of all effects - see below
-    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 * 2));
-      flattened.push(...this.publicDataWrites.map(w => [w.leafSlot, w.value]).flat());
-    }
-    if (this.privateLogs.length) {
-      const totalLogLen = this.privateLogs.reduce(
-        // +1 for length prefix
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 1),
-        0,
-      );
-      flattened.push(this.toPrefix(PRIVATE_LOGS_PREFIX, totalLogLen));
-      flattened.push(...this.privateLogs.flatMap(l => [new Fr(l.getEmittedLength()), ...l.getEmittedFields()]));
-    }
-    if (this.publicLogs.length) {
-      const totalLogLen = this.publicLogs.reduce(
-        // +1 for length prefix
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 1),
-        0,
-      );
-      flattened.push(this.toPrefix(PUBLIC_LOGS_PREFIX, totalLogLen));
-      flattened.push(...this.publicLogs.flatMap(l => [new Fr(l.getEmittedLength()), ...l.getEmittedFields()]));
-    }
-    if (this.contractClassLogs.length) {
-      const totalLogLen = this.contractClassLogs.reduce(
-        // +2 for length prefix and contract address
-        (total, log) => total + (log.getEmittedLength() == 0 ? 0 : log.getEmittedLength() + 2),
-        0,
-      );
-      flattened.push(this.toPrefix(CONTRACT_CLASS_LOGS_PREFIX, totalLogLen));
-      flattened.push(
-        ...this.contractClassLogs.flatMap(l => [
-          new Fr(l.getEmittedLength()),
-          l.contractAddress.toField(),
-          ...l.getEmittedFields(),
-        ]),
-      );
-    }
-
-    // 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;
+  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 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();
-    if (!(fields instanceof FieldReader) && !fields.length) {
-      return effect;
-    }
-    const reader = FieldReader.asReader(fields);
-    const firstField = reader.readField();
-    if (!this.isFirstField(firstField)) {
-      throw new Error('Invalid fields given to TxEffect.fromBlobFields(): First field invalid.');
-    }
-    const { length: _, revertCode } = this.decodeFirstField(firstField);
-    effect.revertCode = RevertCode.fromField(new Fr(revertCode));
+  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, txBlobData.contractClassLog)]
+        : [];
 
-    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)]));
-    while (!reader.isFinished()) {
-      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);
-          const publicDataPairs = reader.readFieldArray(length);
-          for (let i = 0; i < length; i += 2) {
-            effect.publicDataWrites.push(new PublicDataWrite(publicDataPairs[i], publicDataPairs[i + 1]));
-          }
-          break;
-        }
-        case PRIVATE_LOGS_PREFIX: {
-          ensureEmpty(effect.privateLogs);
-          const flatPrivateLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatPrivateLogs[i++].toNumber();
-            const logFields = flatPrivateLogs.slice(i, (i += logLen));
-            effect.privateLogs.push(
-              PrivateLog.fromFields(logFields.concat(new Array(PRIVATE_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO))),
-            );
-          }
-          break;
-        }
-        case PUBLIC_LOGS_PREFIX: {
-          ensureEmpty(effect.publicLogs);
-          const flatPublicLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatPublicLogs[i++].toNumber();
-            const logFields = flatPublicLogs.slice(i, (i += logLen));
-            effect.publicLogs.push(
-              PublicLog.fromFields(logFields.concat(new Array(PUBLIC_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO))),
-            );
-          }
-          break;
-        }
-        case CONTRACT_CLASS_LOGS_PREFIX: {
-          ensureEmpty(effect.contractClassLogs);
-          const flatContractClassLogs = reader.readFieldArray(length);
-          let i = 0;
-          while (i < length) {
-            const logLen = flatContractClassLogs[i++].toNumber();
-            // +1 for address
-            const logFields = flatContractClassLogs.slice(i, (i += logLen + 1));
-            effect.contractClassLogs.push(
-              ContractClassLog.fromFields(
-                logFields.concat(new Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - logLen).fill(Fr.ZERO)),
-              ),
-            );
-          }
-          break;
-        }
-        case REVERT_CODE_PREFIX:
-        default:
-          throw new Error(`Too many fields to decode given to TxEffect.fromBlobFields()`);
-      }
-    }
-    return effect;
+    return TxEffect.from({
+      revertCode,
+      txHash,
+      transactionFee,
+      noteHashes,
+      nullifiers,
+      l2ToL1Msgs,
+      publicDataWrites,
+      privateLogs,
+      publicLogs,
+      contractClassLogs,
+    });
   }
 
   static from(fields: FieldsOf<TxEffect>) {
@@ -529,16 +344,23 @@ export class TxEffect {
 
   [inspect.custom]() {
     return `TxEffect {
-      revertCode: ${this.revertCode},
+      revertCode: ${this.revertCode.getCode()},
       txHash: ${this.txHash},
       transactionFee: ${this.transactionFee},
       note hashes: [${this.noteHashes.map(h => h.toString()).join(', ')}],
       nullifiers: [${this.nullifiers.map(h => h.toString()).join(', ')}],
       l2ToL1Msgs: [${this.l2ToL1Msgs.map(h => h.toString()).join(', ')}],
       publicDataWrites: [${this.publicDataWrites.map(h => h.toString()).join(', ')}],
-      privateLogs: [${this.privateLogs.map(l => l.toString()).join(', ')}],
-      publicLogs: [${this.publicLogs.map(l => l.toString()).join(', ')}],
-      contractClassLogs: [${this.contractClassLogs.map(l => l.toString()).join(', ')}],
+      privateLogs: [${this.privateLogs.map(l => l.fields.map(f => f.toString()).join(',')).join(', ')}],
+      publicLogs: ${inspect(this.publicLogs)},
+      contractClassLogs: [${this.contractClassLogs
+        .map(l =>
+          l
+            .toFields()
+            .map(f => f.toString())
+            .join(','),
+        )
+        .join(', ')}],
      }`;
   }