@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/trees/public_data_witness.ts

@@ -0,0 +1,90 @@
+import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec-labs/constants';
+import { toBigIntBE } from '@aztec-labs/foundation/bigint-buffer';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { MembershipWitness, SiblingPath } from '@aztec-labs/foundation/trees';
+import { z } from 'zod';
+
+import { schemas } from '../schemas/schemas.js';
+import { PublicDataTreeLeafPreimage } from './public_data_leaf.js';
+
+/**
+ * Public data witness.
+ * @remarks This allows to prove either:
+ * - That a slot in the public data tree is empty (0 value) if it falls within the range of the leaf.
+ * - The current value of a slot in the public data tree if it matches exactly the slot of the leaf.
+ */
+export class PublicDataWitness {
+  constructor(
+    /**
+     * The index of the leaf in the public data tree.
+     */
+    public readonly index: bigint,
+    /**
+     * Preimage of a low leaf. All the slots in the range of the leaf are empty, and the current value of the
+     * leaf slot is stored in the leaf.
+     */
+    public readonly leafPreimage: PublicDataTreeLeafPreimage,
+    /**
+     * Sibling path to prove membership of the leaf.
+     */
+    public readonly siblingPath: SiblingPath<typeof PUBLIC_DATA_TREE_HEIGHT>,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        index: schemas.BigInt,
+        leafPreimage: PublicDataTreeLeafPreimage.schema,
+        siblingPath: SiblingPath.schemaFor(PUBLIC_DATA_TREE_HEIGHT),
+      })
+      .transform(({ index, leafPreimage, siblingPath }) => new PublicDataWitness(index, leafPreimage, siblingPath));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
+  }
+
+  /**
+   * Returns a string representation of the TxEffect object.
+   */
+  toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static random() {
+    return new PublicDataWitness(
+      BigInt(Math.floor(Math.random() * 1000)),
+      PublicDataTreeLeafPreimage.random(),
+      SiblingPath.random(PUBLIC_DATA_TREE_HEIGHT),
+    );
+  }
+
+  public withoutPreimage(): MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT> {
+    return new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
+  }
+
+  /**
+   * Deserializes an PublicDataWitness object from a buffer.
+   * @param buf - Buffer or BufferReader to deserialize.
+   * @returns An instance of PublicDataWitness.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): PublicDataWitness {
+    const reader = BufferReader.asReader(buffer);
+
+    return new PublicDataWitness(
+      toBigIntBE(reader.readBytes(32)),
+      reader.readObject(PublicDataTreeLeafPreimage),
+      SiblingPath.fromBuffer(reader.readBytes(4 + 32 * PUBLIC_DATA_TREE_HEIGHT)),
+    );
+  }
+
+  /**
+   * Deserializes an PublicDataWitness object from a string.
+   * @param str - String to deserialize.
+   * @returns An instance of PublicDataWitness.
+   */
+  static fromString(str: string) {
+    return PublicDataWitness.fromBuffer(hexToBuffer(str));
+  }
+}

package/src/tx/block_header.ts

@@ -0,0 +1,242 @@
+import { BLOCK_HEADER_LENGTH, DomainSeparator } from '@aztec-labs/constants';
+import { BlockNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { randomInt } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type ZodFor, schemas } from '@aztec-labs/foundation/schemas';
+import {
+  BufferReader,
+  BufferSink,
+  FieldReader,
+  serializeToFields,
+  serializeToSink,
+} from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import type { FieldsOf } from '@aztec-labs/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 { 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 readonly lastArchive: AppendOnlyTreeSnapshot,
+    /** State reference. */
+    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 readonly globalVariables: GlobalVariables,
+    /** Total fees in the block, computed by the root rollup circuit */
+    public readonly totalFees: Fr,
+    /** Total mana used in the block, computed by the root rollup circuit */
+    public readonly totalManaUsed: Fr,
+  ) {}
+
+  static get schema(): ZodFor<BlockHeader> {
+    return z
+      .object({
+        lastArchive: AppendOnlyTreeSnapshot.schema,
+        state: StateReference.schema,
+        spongeBlobHash: schemas.Fr,
+        globalVariables: GlobalVariables.schema,
+        totalFees: schemas.Fr,
+        totalManaUsed: schemas.Fr,
+      })
+      .transform(BlockHeader.from);
+  }
+
+  static getFields(fields: FieldsOf<BlockHeader>) {
+    return [
+      fields.lastArchive,
+      fields.state,
+      fields.spongeBlobHash,
+      fields.globalVariables,
+      fields.totalFees,
+      fields.totalManaUsed,
+    ] as const;
+  }
+
+  static from(fields: FieldsOf<BlockHeader>) {
+    return new BlockHeader(...BlockHeader.getFields(fields));
+  }
+
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
+  }
+
+  getBlockNumber(): BlockNumber {
+    return this.globalVariables.blockNumber;
+  }
+
+  getSize() {
+    return (
+      this.lastArchive.getSize() +
+      this.state.getSize() +
+      this.spongeBlobHash.size +
+      this.globalVariables.getSize() +
+      this.totalFees.size +
+      this.totalManaUsed.size
+    );
+  }
+
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, ...BlockHeader.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...BlockHeader.getFields(this));
+    if (fields.length !== BLOCK_HEADER_LENGTH) {
+      throw new Error(`Invalid number of fields for Header. Expected ${BLOCK_HEADER_LENGTH}, got ${fields.length}`);
+    }
+    return fields;
+  }
+
+  clone(): BlockHeader {
+    return BlockHeader.fromBuffer(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockHeader {
+    const reader = BufferReader.asReader(buffer);
+
+    return new BlockHeader(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(StateReference),
+      reader.readObject(Fr),
+      reader.readObject(GlobalVariables),
+      reader.readObject(Fr),
+      reader.readObject(Fr),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): BlockHeader {
+    const reader = FieldReader.asReader(fields);
+
+    return new BlockHeader(
+      AppendOnlyTreeSnapshot.fromFields(reader),
+      StateReference.fromFields(reader),
+      reader.readField(),
+      GlobalVariables.fromFields(reader),
+      reader.readField(),
+      reader.readField(),
+    );
+  }
+
+  static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
+    return BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.empty(),
+      state: StateReference.empty(),
+      spongeBlobHash: Fr.ZERO,
+      globalVariables: GlobalVariables.empty(),
+      totalFees: Fr.ZERO,
+      totalManaUsed: Fr.ZERO,
+      ...fields,
+    });
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.lastArchive.isEmpty() &&
+      this.state.isEmpty() &&
+      this.spongeBlobHash.isZero() &&
+      this.globalVariables.isEmpty() &&
+      this.totalFees.isZero() &&
+      this.totalManaUsed.isZero()
+    );
+  }
+
+  /**
+   * Serializes this instance into a string.
+   * @returns Encoded string.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string): BlockHeader {
+    return BlockHeader.fromBuffer(hexToBuffer(str));
+  }
+
+  hash(): Promise<BlockHash> {
+    if (!this._cachedHash) {
+      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), DomainSeparator.BLOCK_HEADER_HASH).then(
+        fr => new BlockHash(fr),
+      );
+    }
+    return this._cachedHash;
+  }
+
+  /** Manually set the hash for this block header if already computed */
+  setHash(hashed: BlockHash) {
+    this._cachedHash = Promise.resolve(hashed);
+  }
+
+  /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */
+  recomputeHash(): Promise<BlockHash> {
+    this._cachedHash = undefined;
+    return this.hash();
+  }
+
+  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(),
+      state: this.state.toInspect(),
+      spongeBlobHash: this.spongeBlobHash.toBigInt(),
+      globalVariables: this.globalVariables.toInspect(),
+      totalFees: this.totalFees.toBigInt(),
+      totalManaUsed: this.totalManaUsed.toBigInt(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `Header {
+  lastArchive: ${inspect(this.lastArchive)},
+  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},
+}`;
+  }
+
+  public equals(other: this): boolean {
+    return (
+      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)
+    );
+  }
+}

package/src/tx/call_context.ts

@@ -0,0 +1,137 @@
+import { CALL_CONTEXT_LENGTH } from '@aztec-labs/constants';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { FunctionSelector } from '../abi/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/index.js';
+
+/**
+ * Call context.
+ */
+export class CallContext {
+  constructor(
+    /**
+     * Address of the account which represents the entity who invoked the call.
+     */
+    public msgSender: AztecAddress,
+    /**
+     * The contract address being called.
+     */
+    public contractAddress: AztecAddress,
+    /**
+     * Function selector of the function being called.
+     */
+    public functionSelector: FunctionSelector,
+    /**
+     * Determines whether the call is modifying state.
+     */
+    public isStaticCall: boolean,
+  ) {}
+
+  /**
+   * Returns a new instance of CallContext with zero msg sender, storage contract address.
+   * @returns A new instance of CallContext with zero msg sender, storage contract address.
+   */
+  public static empty(): CallContext {
+    return new CallContext(AztecAddress.ZERO, AztecAddress.ZERO, FunctionSelector.empty(), false);
+  }
+
+  static async random() {
+    return new CallContext(
+      await AztecAddress.random(),
+      await AztecAddress.random(),
+      FunctionSelector.random(),
+      Math.random() > 0.5,
+    );
+  }
+
+  static get schema() {
+    return z
+      .object({
+        msgSender: schemas.AztecAddress,
+        contractAddress: schemas.AztecAddress,
+        functionSelector: schemas.FunctionSelector,
+        isStaticCall: z.boolean(),
+      })
+      .transform(CallContext.from);
+  }
+
+  isEmpty() {
+    return (
+      this.msgSender.isZero() && this.contractAddress.isZero() && this.functionSelector.isEmpty() && !this.isStaticCall
+    );
+  }
+
+  static from(fields: FieldsOf<CallContext>): CallContext {
+    return new CallContext(...CallContext.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<CallContext>) {
+    return [fields.msgSender, fields.contractAddress, fields.functionSelector, fields.isStaticCall] as const;
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...CallContext.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...CallContext.getFields(this));
+    if (fields.length !== CALL_CONTEXT_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for CallContext. Expected ${CALL_CONTEXT_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  /**
+   * Deserialize this from a buffer.
+   * @param buffer - The bufferable type from which to deserialize.
+   * @returns The deserialized instance of CallContext.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CallContext(
+      reader.readObject(AztecAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(FunctionSelector),
+      reader.readBoolean(),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): CallContext {
+    const reader = FieldReader.asReader(fields);
+    return new CallContext(
+      reader.readObject(AztecAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(FunctionSelector),
+      reader.readBoolean(),
+    );
+  }
+
+  equals(callContext: CallContext) {
+    return (
+      callContext.msgSender.equals(this.msgSender) &&
+      callContext.contractAddress.equals(this.contractAddress) &&
+      callContext.functionSelector.equals(this.functionSelector) &&
+      callContext.isStaticCall === this.isStaticCall
+    );
+  }
+
+  [inspect.custom]() {
+    return `CallContext {
+      msgSender: ${this.msgSender}
+      contractAddress: ${this.contractAddress}
+      functionSelector: ${this.functionSelector}
+      isStaticCall: ${this.isStaticCall}
+    }`;
+  }
+}

package/src/tx/capsule.ts

@@ -0,0 +1,56 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { hexSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+
+import { AztecAddress } from '../aztec-address/index.js';
+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(
+    /** The address of the contract the capsule is for */
+    public readonly contractAddress: AztecAddress,
+    /** The storage slot of the capsule */
+    public readonly storageSlot: Fr,
+    /** Data passed to the contract  */
+    public readonly data: Fr[],
+    /** Optional namespace for the capsule contents */
+    public readonly scope?: AztecAddress,
+  ) {}
+
+  static get schema() {
+    return hexSchemaFor(Capsule);
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  toBuffer() {
+    return this.scope
+      ? serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), true, this.scope)
+      : serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), false);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): Capsule {
+    const reader = BufferReader.asReader(buffer);
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const data = reader.readVector(Fr);
+    const hasScope = reader.readBoolean();
+    return new Capsule(contractAddress, storageSlot, data, hasScope ? AztecAddress.fromBuffer(reader) : undefined);
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return Capsule.fromBuffer(hexToBuffer(str));
+  }
+}

package/src/tx/execution_payload.ts

@@ -0,0 +1,61 @@
+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.fromStringUnsafe(Array.from(uniqueFeePayers)[0]) : undefined;
+
+  return new ExecutionPayload(calls, combinedAuthWitnesses, combinedCapsules, combinedExtraHashedArgs, feePayer);
+}

package/src/tx/fee_provider.ts

@@ -0,0 +1,10 @@
+import type { ManaUsageEstimate } from '../gas/fee_math.js';
+import type { GasFees } from '../gas/gas_fees.js';
+
+/** Provides current and predicted fee information for transaction pricing. */
+export interface FeeProvider {
+  /** Returns the current minimum fees for inclusion in the next block. */
+  getCurrentMinFees(): Promise<GasFees>;
+  /** Returns current min fees first, followed by predicted min fees for each slot in the prediction window. */
+  getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}

package/src/tx/function_data.ts

@@ -0,0 +1,101 @@
+import { FUNCTION_DATA_LENGTH } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { z } from 'zod';
+
+import { type FunctionAbi, FunctionSelector, FunctionType } from '../abi/index.js';
+import type { ContractFunctionDao } from '../contract/contract_function_dao.js';
+
+/** Function description for circuit. */
+export class FunctionData {
+  constructor(
+    /** Function selector of the function being called. */
+    public selector: FunctionSelector,
+    /** Indicates whether the function is private or public. */
+    public isPrivate: boolean,
+  ) {}
+
+  static async fromAbi(abi: FunctionAbi | ContractFunctionDao): Promise<FunctionData> {
+    return new FunctionData(
+      await FunctionSelector.fromNameAndParameters(abi.name, abi.parameters),
+      abi.functionType === FunctionType.PRIVATE,
+    );
+  }
+
+  static get schema() {
+    return z
+      .object({
+        selector: FunctionSelector.schema,
+        isPrivate: z.boolean(),
+      })
+      .transform(({ selector, isPrivate }) => new FunctionData(selector, isPrivate));
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.selector, this.isPrivate);
+  }
+
+  toFields(): Fr[] {
+    const fields = [this.selector.toField(), new Fr(this.isPrivate)];
+    if (fields.length !== FUNCTION_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for FunctionData. Expected ${FUNCTION_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  /**
+   * Returns whether this instance is empty.
+   * @returns True if the function selector is zero.
+   */
+  isEmpty() {
+    return this.selector.isEmpty();
+  }
+
+  /**
+   * Returns whether this instance is equal to another.
+   * @param other
+   * @returns
+   */
+  equals(other: FunctionData): boolean {
+    return this.selector.equals(other.selector) && this.isPrivate === other.isPrivate;
+  }
+
+  /**
+   * Returns a new instance of FunctionData with zero function selector.
+   * @param args - Arguments to pass to the constructor.
+   * @returns A new instance of FunctionData with zero function selector.
+   */
+  public static empty(args?: {
+    /** Indicates whether the function is private or public. */
+    isPrivate?: boolean;
+    /** Indicates whether the function can alter state or not. */
+    isStatic?: boolean;
+  }): FunctionData {
+    return new FunctionData(FunctionSelector.empty(), args?.isPrivate ?? false);
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns A new instance of FunctionData.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): FunctionData {
+    const reader = BufferReader.asReader(buffer);
+    return new FunctionData(reader.readObject(FunctionSelector), /*isPrivate=*/ reader.readBoolean());
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): FunctionData {
+    const reader = FieldReader.asReader(fields);
+
+    const selector = FunctionSelector.fromFields(reader);
+    const isPrivate = reader.readBoolean();
+
+    return new FunctionData(selector, isPrivate);
+  }
+}