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

package/src/tx/partial_state_reference.ts

@@ -1,7 +1,7 @@
 import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
-import type { ViemPartialStateReference } 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 { z } from 'zod';
 
@@ -37,6 +37,14 @@ export class PartialStateReference {
     return this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
   }
 
+  static getFields(fields: FieldsOf<PartialStateReference>) {
+    return [fields.noteHashTree, fields.nullifierTree, fields.publicDataTree] as const;
+  }
+
+  static from(fields: FieldsOf<PartialStateReference>) {
+    return new PartialStateReference(...PartialStateReference.getFields(fields));
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader): PartialStateReference {
     const reader = BufferReader.asReader(buffer);
     return new PartialStateReference(
@@ -56,14 +64,6 @@ export class PartialStateReference {
     return new PartialStateReference(noteHashTree, nullifierTree, publicDataTree);
   }
 
-  static fromViem(stateReference: ViemPartialStateReference) {
-    return new PartialStateReference(
-      AppendOnlyTreeSnapshot.fromViem(stateReference.noteHashTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.nullifierTree),
-      AppendOnlyTreeSnapshot.fromViem(stateReference.publicDataTree),
-    );
-  }
-
   static random(): PartialStateReference {
     return new PartialStateReference(
       AppendOnlyTreeSnapshot.random(),
@@ -72,14 +72,6 @@ export class PartialStateReference {
     );
   }
 
-  toViem(): ViemPartialStateReference {
-    return {
-      noteHashTree: this.noteHashTree.toViem(),
-      nullifierTree: this.nullifierTree.toViem(),
-      publicDataTree: this.publicDataTree.toViem(),
-    };
-  }
-
   toAbi(): [
     ReturnType<AppendOnlyTreeSnapshot['toAbi']>,
     ReturnType<AppendOnlyTreeSnapshot['toAbi']>,

package/src/tx/private_execution_result.ts

@@ -1,6 +1,7 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { timesParallel } from '@aztec/foundation/collection';
-import { randomBytes, randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomBytes, randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -13,7 +14,6 @@ import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class
 import { type PreTag, PreTagSchema } from '../logs/pre_tag.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
-import type { UInt32 } from '../types/index.js';
 import { HashedValues } from './hashed_values.js';
 import type { OffchainEffect } from './offchain_effect.js';
 
@@ -26,6 +26,8 @@ export class NoteAndSlot {
     public note: Note,
     /** The storage slot of the note. */
     public storageSlot: Fr,
+    /** The randomness injected to the note. */
+    public randomness: Fr,
     /** The note type identifier. */
     public noteTypeId: NoteSelector,
   ) {}
@@ -35,17 +37,18 @@ export class NoteAndSlot {
       .object({
         note: Note.schema,
         storageSlot: schemas.Fr,
+        randomness: schemas.Fr,
         noteTypeId: schemas.NoteSelector,
       })
       .transform(NoteAndSlot.from);
   }
 
   static from(fields: FieldsOf<NoteAndSlot>) {
-    return new NoteAndSlot(fields.note, fields.storageSlot, fields.noteTypeId);
+    return new NoteAndSlot(fields.note, fields.storageSlot, fields.randomness, fields.noteTypeId);
   }
 
   static random() {
-    return new NoteAndSlot(Note.random(), Fr.random(), NoteSelector.random());
+    return new NoteAndSlot(Note.random(), Fr.random(), Fr.random(), NoteSelector.random());
   }
 }
 
@@ -76,7 +79,7 @@ export class CountedContractClassLog implements IsEmpty {
 export class PrivateExecutionResult {
   constructor(
     public entrypoint: PrivateCallExecutionResult,
-    /** The first non revertible nullifier, or zero if there was none. */
+    /** The first non-revertible nullifier emitted by any private call, or the protocol nullifier if there was none. */
     public firstNullifier: Fr,
     /** An array of calldata for the enqueued public function calls and the teardown function call. */
     public publicFunctionCalldata: HashedValues[],
@@ -106,7 +109,7 @@ export class PrivateExecutionResult {
   /**
    * The anchor block number that this execution was simulated with.
    */
-  getSimulationAnchorBlockNumber(): UInt32 {
+  getSimulationAnchorBlockNumber(): BlockNumber {
     return this.entrypoint.publicInputs.anchorBlockHeader.globalVariables.blockNumber;
   }
 }
@@ -126,8 +129,6 @@ export class PrivateCallExecutionResult {
     // Needed for the verifier (kernel)
     /** The call stack item. */
     public publicInputs: PrivateCircuitPublicInputs,
-    /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
-    public noteHashLeafIndexMap: Map<bigint, bigint>,
     /** The notes created in the executed function. */
     public newNotes: NoteAndSlot[],
     /** Mapping of note hash counter to the counter of its nullifier. */
@@ -136,7 +137,7 @@ export class PrivateCallExecutionResult {
     public returnValues: Fr[],
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
-    /** The pre tags used in this tx to compute tags for private logs */
+    /** The pre-tags used in this tx to compute tags for private logs */
     public preTags: PreTag[],
     /** The nested executions. */
     public nestedExecutionResults: PrivateCallExecutionResult[],
@@ -156,7 +157,6 @@ export class PrivateCallExecutionResult {
         vk: schemas.Buffer,
         partialWitness: mapSchema(z.coerce.number(), z.string()),
         publicInputs: PrivateCircuitPublicInputs.schema,
-        noteHashLeafIndexMap: mapSchema(schemas.BigInt, schemas.BigInt),
         newNotes: z.array(NoteAndSlot.schema),
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
@@ -174,7 +174,6 @@ export class PrivateCallExecutionResult {
       fields.vk,
       fields.partialWitness,
       fields.publicInputs,
-      fields.noteHashLeafIndexMap,
       fields.newNotes,
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
@@ -191,7 +190,6 @@ export class PrivateCallExecutionResult {
       randomBytes(4),
       new Map([[1, 'one']]),
       PrivateCircuitPublicInputs.empty(),
-      new Map([[1n, 1n]]),
       [NoteAndSlot.random()],
       new Map([[0, 0]]),
       [Fr.random()],
@@ -207,16 +205,6 @@ export class PrivateCallExecutionResult {
   }
 }
 
-export function collectNoteHashLeafIndexMap(execResult: PrivateExecutionResult) {
-  const accum: Map<bigint, bigint> = new Map();
-  const collectNoteHashLeafIndexMapRecursive = (callResult: PrivateCallExecutionResult, accum: Map<bigint, bigint>) => {
-    callResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
-    callResult.nestedExecutionResults.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
-  };
-  collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
-  return accum;
-}
-
 export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionResult) {
   const accum: Map<number, number> = new Map();
   const collectNoteHashNullifierCounterMapRecursive = (

package/src/tx/private_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/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,16 +1,40 @@
-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[] }>>;
+export type RoundTripStats = {
+  /** Number of round trips (times we blocked waiting for node responses) */
+  roundTrips: number;
+  /** Total wall-clock time spent waiting on node (excludes parallel overlap) */
+  totalBlockingTime: number;
+  /** Individual round trip durations */
+  roundTripDurations: number[];
+  /** Methods called in each round trip (parallel calls grouped together) */
+  roundTripMethods: string[][];
+};
+
+const RoundTripStatsSchema = z.object({
+  roundTrips: z.number(),
+  totalBlockingTime: z.number(),
+  roundTripDurations: z.array(z.number()),
+  roundTripMethods: z.array(z.array(z.string())),
+});
+
+export type NodeStats = {
+  /** Per-method call stats */
+  perMethod: Partial<Record<keyof AztecNode, { times: number[] }>>;
+  /** Round trip stats tracking actual blocking waits */
+  roundTrips: RoundTripStats;
+};
 
-const NodeStatsSchema = z.record(z.string(), z.object({ times: z.array(z.number()) }));
+const NodeStatsSchema = z.object({
+  perMethod: z.record(z.string(), z.object({ times: z.array(z.number()) })),
+  roundTrips: RoundTripStatsSchema,
+});
 
 type FunctionTiming = {
   functionName: string;
@@ -107,7 +131,15 @@ export class TxProfileResult {
         },
       ],
       {
-        nodeRPCCalls: { getBlockHeader: { times: [1] } },
+        nodeRPCCalls: {
+          perMethod: { getBlockHeader: { times: [1] } },
+          roundTrips: {
+            roundTrips: 1,
+            totalBlockingTime: 1,
+            roundTripDurations: [1],
+            roundTripMethods: [['getBlockHeader']],
+          },
+        },
         timings: {
           sync: 1,
           proving: 1,
@@ -127,22 +159,30 @@ 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(), {
-      nodeRPCCalls: { getBlockHeader: { times: [1] } },
+    return new UtilitySimulationResult([Fr.random()], {
+      nodeRPCCalls: {
+        perMethod: { getBlockHeader: { times: [1] } },
+        roundTrips: {
+          roundTrips: 1,
+          totalBlockingTime: 1,
+          roundTripDurations: [1],
+          roundTripMethods: [['getBlockHeader']],
+        },
+      },
       timings: {
         sync: 1,
         publicSimulation: 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,5 @@
 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';
@@ -24,13 +23,18 @@ import { TxHash } from './tx_hash.js';
 /**
  * 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,16 +47,20 @@ 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> {
@@ -238,7 +246,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,13 +254,13 @@ 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;
   }
 
   /**
@@ -271,11 +279,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 +308,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 +327,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');
     }
   }