@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/tx/block_header.ts

@@ -1,6 +1,8 @@
 import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+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, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -9,34 +11,39 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { BlockHash } from '../block/block_hash.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { ContentCommitment } from './content_commitment.js';
 import { GlobalVariables } from './global_variables.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
 export class BlockHeader {
+  private _cachedHash?: Promise<BlockHash>;
+
   constructor(
     /** Snapshot of archive before the block is applied. */
-    public lastArchive: AppendOnlyTreeSnapshot,
-    /** Hash of the body of an L2 block. */
-    public contentCommitment: ContentCommitment,
+    public readonly lastArchive: AppendOnlyTreeSnapshot,
     /** State reference. */
-    public state: StateReference,
+    public readonly state: StateReference,
+    /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */
+    public readonly spongeBlobHash: Fr,
     /** Global variables of an L2 block. */
-    public globalVariables: GlobalVariables,
+    public readonly globalVariables: GlobalVariables,
     /** Total fees in the block, computed by the root rollup circuit */
-    public totalFees: Fr,
+    public readonly totalFees: Fr,
     /** Total mana used in the block, computed by the root rollup circuit */
-    public totalManaUsed: Fr,
+    public readonly totalManaUsed: Fr,
   ) {}
 
   static get schema(): ZodFor<BlockHeader> {
     return z
       .object({
         lastArchive: AppendOnlyTreeSnapshot.schema,
-        contentCommitment: ContentCommitment.schema,
         state: StateReference.schema,
+        spongeBlobHash: schemas.Fr,
         globalVariables: GlobalVariables.schema,
         totalFees: schemas.Fr,
         totalManaUsed: schemas.Fr,
@@ -45,11 +52,10 @@ export class BlockHeader {
   }
 
   static getFields(fields: FieldsOf<BlockHeader>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
     return [
       fields.lastArchive,
-      fields.contentCommitment,
       fields.state,
+      fields.spongeBlobHash,
       fields.globalVariables,
       fields.totalFees,
       fields.totalManaUsed,
@@ -60,15 +66,19 @@ export class BlockHeader {
     return new BlockHeader(...BlockHeader.getFields(fields));
   }
 
-  getSlot() {
-    return this.globalVariables.slotNumber.toBigInt();
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
+  }
+
+  getBlockNumber(): BlockNumber {
+    return this.globalVariables.blockNumber;
   }
 
   getSize() {
     return (
       this.lastArchive.getSize() +
-      this.contentCommitment.getSize() +
       this.state.getSize() +
+      this.spongeBlobHash.size +
       this.globalVariables.getSize() +
       this.totalFees.size +
       this.totalManaUsed.size
@@ -96,8 +106,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(ContentCommitment),
       reader.readObject(StateReference),
+      reader.readObject(Fr),
       reader.readObject(GlobalVariables),
       reader.readObject(Fr),
       reader.readObject(Fr),
@@ -109,8 +119,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       AppendOnlyTreeSnapshot.fromFields(reader),
-      ContentCommitment.fromFields(reader),
       StateReference.fromFields(reader),
+      reader.readField(),
       GlobalVariables.fromFields(reader),
       reader.readField(),
       reader.readField(),
@@ -119,9 +129,9 @@ export class BlockHeader {
 
   static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
     return BlockHeader.from({
-      lastArchive: AppendOnlyTreeSnapshot.zero(),
-      contentCommitment: ContentCommitment.empty(),
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
       state: StateReference.empty(),
+      spongeBlobHash: Fr.ZERO,
       globalVariables: GlobalVariables.empty(),
       totalFees: Fr.ZERO,
       totalManaUsed: Fr.ZERO,
@@ -131,9 +141,9 @@ export class BlockHeader {
 
   isEmpty(): boolean {
     return (
-      this.lastArchive.isZero() &&
-      this.contentCommitment.isEmpty() &&
+      this.lastArchive.isEmpty() &&
       this.state.isEmpty() &&
+      this.spongeBlobHash.isZero() &&
       this.globalVariables.isEmpty() &&
       this.totalFees.isZero() &&
       this.totalManaUsed.isZero()
@@ -152,15 +162,37 @@ export class BlockHeader {
     return BlockHeader.fromBuffer(hexToBuffer(str));
   }
 
-  hash(): Promise<Fr> {
-    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+  hash(): Promise<BlockHash> {
+    if (!this._cachedHash) {
+      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HEADER_HASH).then(
+        fr => new BlockHash(fr),
+      );
+    }
+    return this._cachedHash;
+  }
+
+  /** Manually set the hash for this block header if already computed */
+  setHash(hashed: Fr) {
+    this._cachedHash = Promise.resolve(new BlockHash(hashed));
+  }
+
+  static random(overrides: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>> = {}): BlockHeader {
+    return BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.random(),
+      state: StateReference.random(),
+      spongeBlobHash: Fr.random(),
+      globalVariables: GlobalVariables.random(overrides),
+      totalFees: new Fr(randomInt(100_000)),
+      totalManaUsed: new Fr(randomInt(100_000_000)),
+      ...overrides,
+    });
   }
 
   toInspect() {
     return {
       lastArchive: this.lastArchive.root.toString(),
-      contentCommitment: this.contentCommitment.toInspect(),
       state: this.state.toInspect(),
+      spongeBlobHash: this.spongeBlobHash.toBigInt(),
       globalVariables: this.globalVariables.toInspect(),
       totalFees: this.totalFees.toBigInt(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
@@ -170,14 +202,11 @@ export class BlockHeader {
   [inspect.custom]() {
     return `Header {
   lastArchive: ${inspect(this.lastArchive)},
-  contentCommitment.numTxs: ${this.contentCommitment.numTxs.toNumber()},
-  contentCommitment.blobsHash: ${this.contentCommitment.blobsHash.toString('hex')},
-  contentCommitment.inHash: ${this.contentCommitment.inHash.toString('hex')},
-  contentCommitment.outHash: ${this.contentCommitment.outHash.toString('hex')},
   state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
   state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
   state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},
   state.publicDataTree: ${inspect(this.state.partial.publicDataTree)},
+  spongeBlobHash: ${this.spongeBlobHash},
   globalVariables: ${inspect(this.globalVariables)},
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
@@ -186,12 +215,12 @@ export class BlockHeader {
 
   public equals(other: this): boolean {
     return (
-      this.contentCommitment.equals(other.contentCommitment) &&
+      this.lastArchive.equals(other.lastArchive) &&
       this.state.equals(other.state) &&
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
       this.globalVariables.equals(other.globalVariables) &&
       this.totalFees.equals(other.totalFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed) &&
-      this.lastArchive.equals(other.lastArchive)
+      this.totalManaUsed.equals(other.totalManaUsed)
     );
   }
 }

package/src/tx/call_context.ts

@@ -1,5 +1,5 @@
 import { CALL_CONTEXT_LENGTH } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import type { 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/capsule.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -8,6 +8,8 @@ import { Vector } from '../types/shared.js';
 
 /**
  * Read-only data that is passed to the contract through an oracle during a transaction execution.
+ * TODO(#12425): Check whether this is always used to represent a transient capsule and if so, rename to
+ * TransientCapsule.
  */
 export class Capsule {
   constructor(

package/src/tx/execution_payload.ts

@@ -0,0 +1,60 @@
+import type { FunctionCall } from '../abi/function_call.js';
+import type { AuthWitness } from '../auth_witness/auth_witness.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { Capsule } from './capsule.js';
+import type { HashedValues } from './hashed_values.js';
+
+/**
+ * Represents data necessary to perform an action in the network successfully.
+ * This class can be considered Aztec's "minimal execution unit".
+ * */
+export class ExecutionPayload {
+  public constructor(
+    /** The function calls to be executed. */
+    public calls: FunctionCall[],
+    /** Any transient auth witnesses needed for this execution */
+    public authWitnesses: AuthWitness[],
+    /** Data passed through an oracle for this execution. */
+    public capsules: Capsule[],
+    /** Extra hashed values to be injected in the execution cache */
+    public extraHashedArgs: HashedValues[] = [],
+    /**
+     * The address that is paying for the fee in this execution payload (if any).
+     * If undefined, the wallet software executing the payload will have to add a fee payment method
+     */
+    public feePayer?: AztecAddress,
+  ) {}
+
+  static empty() {
+    return new ExecutionPayload([], [], [], [], undefined);
+  }
+}
+
+/**
+ * Merges an array ExecutionPayloads combining their calls, authWitnesses, capsules and extraArgHashes.
+ * @throws Error if multiple payloads have different fee payers set
+ */
+export function mergeExecutionPayloads(requests: ExecutionPayload[]): ExecutionPayload {
+  const calls = requests.map(r => r.calls).flat();
+  const combinedAuthWitnesses = requests.map(r => r.authWitnesses ?? []).flat();
+  const combinedCapsules = requests.map(r => r.capsules ?? []).flat();
+  const combinedExtraHashedArgs = requests.map(r => r.extraHashedArgs ?? []).flat();
+
+  // Collect unique fee payers
+  const uniqueFeePayers = new Set(
+    requests
+      .map(r => r.feePayer)
+      .filter((fp): fp is AztecAddress => fp !== undefined)
+      .map(fp => fp.toString()),
+  );
+
+  if (uniqueFeePayers.size > 1) {
+    throw new Error(
+      `Cannot merge execution payloads with different fee payers. Found: ${Array.from(uniqueFeePayers).join(', ')}`,
+    );
+  }
+
+  const feePayer = uniqueFeePayers.size === 1 ? AztecAddress.fromString(Array.from(uniqueFeePayers)[0]) : undefined;
+
+  return new ExecutionPayload(calls, combinedAuthWitnesses, combinedCapsules, combinedExtraHashedArgs, feePayer);
+}

package/src/tx/function_data.ts

@@ -1,5 +1,5 @@
 import { FUNCTION_DATA_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';

package/src/tx/global_variable_builder.ts

@@ -1,15 +1,16 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
+import type { SlotNumber } from '@aztec/foundation/schemas';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { GasFees } from '../gas/gas_fees.js';
-import type { GlobalVariables } from './global_variables.js';
+import type { UInt32 } from '../types/index.js';
+import type { CheckpointGlobalVariables, GlobalVariables } from './global_variables.js';
 
 /**
  * Interface for building global variables for Aztec blocks.
  */
 export interface GlobalVariableBuilder {
-  getCurrentBaseFees(): Promise<GasFees>;
+  getCurrentMinFees(): Promise<GasFees>;
 
   /**
    * Builds global variables for a given block.
@@ -20,9 +21,16 @@ export interface GlobalVariableBuilder {
    * @returns A promise that resolves to the GlobalVariables for the given block number.
    */
   buildGlobalVariables(
-    blockNumber: Fr,
+    blockNumber: UInt32,
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: bigint,
+    slotNumber?: SlotNumber,
   ): Promise<GlobalVariables>;
+
+  /** Builds global variables that are constant throughout a checkpoint. */
+  buildCheckpointGlobalVariables(
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber: SlotNumber,
+  ): Promise<CheckpointGlobalVariables>;
 }

package/src/tx/global_variables.ts

@@ -1,8 +1,16 @@
 import { GLOBAL_VARIABLES_LENGTH } from '@aztec/constants';
+import { BlockNumber, BlockNumberSchema, SlotNumber } from '@aztec/foundation/branded-types';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt64BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -11,6 +19,13 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { schemas } from '../schemas/index.js';
+import type { UInt64 } from '../types/index.js';
+
+/**
+ * Global variables that are constant across the entire slot.
+ * TODO(palla/mbps): Should timestamp be included here as well?
+ */
+export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber' | 'timestamp'>;
 
 /**
  * Global variables of the L2 block.
@@ -22,11 +37,11 @@ export class GlobalVariables {
     /** Version for the L2 block. */
     public version: Fr,
     /** Block number of the L2 block. */
-    public blockNumber: Fr,
+    public blockNumber: BlockNumber,
     /** Slot number of the L2 block */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
-    public timestamp: Fr,
+    public timestamp: UInt64,
     /** Recipient of block reward. */
     public coinbase: EthAddress,
     /** Address to receive fees. */
@@ -40,9 +55,9 @@ export class GlobalVariables {
       .object({
         chainId: schemas.Fr,
         version: schemas.Fr,
-        blockNumber: schemas.Fr,
-        slotNumber: schemas.Fr,
-        timestamp: schemas.Fr,
+        blockNumber: BlockNumberSchema,
+        slotNumber: schemas.SlotNumber,
+        timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
         gasFees: GasFees.schema,
@@ -58,11 +73,31 @@ export class GlobalVariables {
     return new GlobalVariables(...GlobalVariables.getFields(fields));
   }
 
+  /**
+   * Creates a GlobalVariables 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 GlobalVariables fields
+   * @returns A GlobalVariables instance
+   */
+  static fromPlainObject(obj: any): GlobalVariables {
+    return new GlobalVariables(
+      Fr.fromPlainObject(obj.chainId),
+      Fr.fromPlainObject(obj.version),
+      obj.blockNumber,
+      SlotNumber(Fr.fromPlainObject(obj.slotNumber).toNumber()),
+      typeof obj.timestamp === 'bigint' ? obj.timestamp : BigInt(obj.timestamp),
+      EthAddress.fromPlainObject(obj.coinbase),
+      AztecAddress.fromPlainObject(obj.feeRecipient),
+      GasFees.fromPlainObject(obj.gasFees),
+    );
+  }
+
   static empty(fields: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
     return GlobalVariables.from({
-      blockNumber: Fr.ZERO,
-      slotNumber: Fr.ZERO,
-      timestamp: Fr.ZERO,
+      blockNumber: BlockNumber.ZERO,
+      slotNumber: SlotNumber.ZERO,
+      timestamp: 0n,
       chainId: Fr.ZERO,
       version: Fr.ZERO,
       coinbase: EthAddress.ZERO,
@@ -77,9 +112,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      BlockNumber(reader.readNumber()),
+      SlotNumber(reader.readNumber()),
+      reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
       reader.readObject(GasFees),
@@ -92,9 +127,9 @@ export class GlobalVariables {
     return new GlobalVariables(
       reader.readField(),
       reader.readField(),
-      reader.readField(),
-      reader.readField(),
-      reader.readField(),
+      BlockNumber(reader.readU32()),
+      SlotNumber(reader.readU32()),
+      reader.readField().toBigInt(),
       EthAddress.fromField(reader.readField()),
       AztecAddress.fromField(reader.readField()),
       GasFees.fromFields(reader),
@@ -102,7 +137,6 @@ export class GlobalVariables {
   }
 
   static getFields(fields: FieldsOf<GlobalVariables>) {
-    // Note: The order here must match the order in the HeaderLib solidity library.
     return [
       fields.chainId,
       fields.version,
@@ -116,7 +150,16 @@ export class GlobalVariables {
   }
 
   toBuffer() {
-    return serializeToBuffer(...GlobalVariables.getFields(this));
+    return serializeToBuffer([
+      this.chainId,
+      this.version,
+      this.blockNumber,
+      this.slotNumber,
+      bigintToUInt64BE(this.timestamp),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+    ]);
   }
 
   toFields() {
@@ -135,14 +178,32 @@ export class GlobalVariables {
    */
   toFriendlyJSON() {
     return {
-      blockNumber: this.blockNumber.toNumber(),
-      slotNumber: this.slotNumber.toNumber(),
+      blockNumber: this.blockNumber,
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp.toString(),
       coinbase: this.coinbase.toString(),
       gasFees: jsonStringify(this.gasFees),
     };
   }
 
+  /**
+   * Converts GlobalVariables to a plain object suitable for MessagePack serialization.
+   * This method ensures that slotNumber is serialized as a Fr (Field element) to match
+   * the C++ struct definition which expects slot_number as FF.
+   */
+  toJSON() {
+    return {
+      chainId: this.chainId,
+      version: this.version,
+      blockNumber: this.blockNumber,
+      slotNumber: new Fr(this.slotNumber), // Convert to Fr for C++ compatibility
+      timestamp: this.timestamp,
+      coinbase: this.coinbase,
+      feeRecipient: this.feeRecipient,
+      gasFees: this.gasFees,
+    };
+  }
+
   clone(): GlobalVariables {
     return GlobalVariables.fromBuffer(this.toBuffer());
   }
@@ -151,26 +212,40 @@ export class GlobalVariables {
     return (
       this.chainId.isZero() &&
       this.version.isZero() &&
-      this.blockNumber.isZero() &&
-      this.slotNumber.isZero() &&
-      this.timestamp.isZero() &&
+      this.blockNumber === 0 &&
+      this.slotNumber === 0 &&
+      this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
       this.gasFees.isEmpty()
     );
   }
 
+  static random(overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
+    return GlobalVariables.from({
+      chainId: new Fr(randomInt(100_000)),
+      version: new Fr(randomInt(100_000)),
+      blockNumber: BlockNumber(randomInt(100_000)),
+      slotNumber: SlotNumber(randomInt(100_000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: AztecAddress.fromField(Fr.random()),
+      gasFees: GasFees.random(),
+      timestamp: BigInt(randomInt(100_000_000)),
+      ...overrides,
+    });
+  }
+
   toInspect() {
     return {
       chainId: this.chainId.toNumber(),
       version: this.version.toNumber(),
-      blockNumber: this.blockNumber.toNumber(),
-      slotNumber: this.slotNumber.toNumber(),
-      timestamp: this.timestamp.toNumber(),
+      blockNumber: this.blockNumber,
+      slotNumber: this.slotNumber,
+      timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
-      feePerDaGas: this.gasFees.feePerDaGas.toNumber(),
-      feePerL2Gas: this.gasFees.feePerL2Gas.toNumber(),
+      feePerDaGas: Number(this.gasFees.feePerDaGas),
+      feePerL2Gas: Number(this.gasFees.feePerL2Gas),
     };
   }
 
@@ -182,9 +257,9 @@ export class GlobalVariables {
     return (
       this.chainId.equals(other.chainId) &&
       this.version.equals(other.version) &&
-      this.blockNumber.equals(other.blockNumber) &&
-      this.slotNumber.equals(other.slotNumber) &&
-      this.timestamp.equals(other.timestamp) &&
+      this.blockNumber === other.blockNumber &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
       this.gasFees.equals(other.gasFees)

package/src/tx/hashed_values.ts

@@ -1,9 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { computeVarArgsHash } from '../hash/index.js';
+import { computeCalldataHash, computeVarArgsHash } from '../hash/index.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
 import { Vector } from '../types/index.js';
 
@@ -11,7 +12,7 @@ import { Vector } from '../types/index.js';
  * A container for storing a list of values and their hash.
  */
 export class HashedValues {
-  private constructor(
+  constructor(
     /**
      *  Raw values.
      */
@@ -22,20 +23,29 @@ export class HashedValues {
     public readonly hash: Fr,
   ) {}
 
+  getSize() {
+    return this.values.length + 1 /* hash */;
+  }
+
   static get schema(): ZodFor<HashedValues> {
-    return z.array(schemas.Fr).transform(HashedValues.fromValues);
+    return z
+      .object({
+        values: z.array(schemas.Fr),
+        hash: schemas.Fr,
+      })
+      .transform(HashedValues.from);
   }
 
-  toJSON() {
-    return this.values;
+  static from(fields: FieldsOf<HashedValues>): HashedValues {
+    return new HashedValues(...HashedValues.getFields(fields));
   }
 
-  static random() {
-    return HashedValues.fromValues([Fr.random(), Fr.random()]);
+  static getFields(fields: FieldsOf<HashedValues>) {
+    return [fields.values, fields.hash] as const;
   }
 
-  static async fromValues(values: Fr[]) {
-    return new HashedValues(values, await computeVarArgsHash(values));
+  static random() {
+    return new HashedValues([Fr.random(), Fr.random()], Fr.random());
   }
 
   toBuffer() {
@@ -46,4 +56,14 @@ export class HashedValues {
     const reader = BufferReader.asReader(buffer);
     return new HashedValues(reader.readVector(Fr), Fr.fromBuffer(reader));
   }
+
+  // Computes the hash of input arguments or return values for private functions, or for authwit creation.
+  static async fromArgs(args: Fr[]) {
+    return new HashedValues(args, await computeVarArgsHash(args));
+  }
+
+  // Computes the hash of calldata for public functions.
+  static async fromCalldata(calldata: Fr[]) {
+    return new HashedValues(calldata, await computeCalldataHash(calldata));
+  }
 }

package/src/tx/in_tx.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+import { type InBlock, inBlockSchema, randomInBlock } from '../block/in_block.js';
+import { TxHash } from './tx_hash.js';
+
+export type InTx = InBlock & {
+  txHash: TxHash;
+};
+
+export function randomInTx(): InTx {
+  return {
+    ...randomInBlock(),
+    txHash: TxHash.random(),
+  };
+}
+
+export function inTxSchema() {
+  return z.intersection(
+    inBlockSchema(),
+    z.object({
+      txHash: TxHash.schema,
+    }),
+  );
+}