@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/tx/tx.ts

@@ -0,0 +1,402 @@
+import {
+  DA_GAS_PER_FIELD,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  MAX_ENQUEUED_CALLS_PER_TX,
+  MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS,
+  TX_DA_GAS_OVERHEAD,
+} from '@aztec-labs/constants';
+import { type BaseBuffer32, Buffer32 } from '@aztec-labs/foundation/buffer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { ZodFor } from '@aztec-labs/foundation/schemas';
+import {
+  BufferReader,
+  BufferSink,
+  serializeArrayOfBufferableToVector,
+  serializeArrayToSink,
+  serializeToSink,
+} from '@aztec-labs/foundation/serialize';
+import { type FieldsOf, unfreeze } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+
+import type { GasSettings } from '../gas/gas_settings.js';
+import type { PublicCallRequest } from '../kernel/index.js';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
+import { Gossipable } from '../p2p/gossipable.js';
+import { TopicType } from '../p2p/topic_type.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import type { TxStats } from '../stats/stats.js';
+import { HashedValues } from './hashed_values.js';
+import { PublicCallRequestWithCalldata } from './public_call_request_with_calldata.js';
+import { TxHash } from './tx_hash.js';
+
+// Static presize hint for the BufferSink the no-sink Tx.toBuffer() path allocates. Empirically a
+// public-with-enqueued-calls Tx serialized by the bootstrapped bench (yarn-project/stdlib/src/tx/
+// tx_bench.test.ts) is ~129128 bytes; a private-only Tx is ~81763 bytes. 128 KiB covers both shapes
+// without a single doubling-growth `ensure()` resize on the cold path. Real-world Txs that happen to
+// exceed this still serialize correctly — the sink falls back to its standard doubling growth — just
+// with the existing cost.
+const TX_SINK_PRESIZE_BYTES = 131072;
+
+/**
+ * Upper bound on the calldata entries a tx can carry: one per enqueued call, plus one for the teardown call.
+ * The revertible and non-revertible call request arrays are each sized `MAX_ENQUEUED_CALLS_PER_TX`, but the
+ * private tail circuit fills them by partitioning a single array of that size, so their lengths sum to it. The
+ * teardown request is propagated separately and can only be set once.
+ */
+export const MAX_PUBLIC_FUNCTION_CALLDATA_PER_TX = MAX_ENQUEUED_CALLS_PER_TX + 1;
+
+/**
+ * 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.
+     * 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.
+     */
+    public readonly data: PrivateKernelTailCircuitPublicInputs,
+    /**
+     * Proof from the private kernel circuit.
+     */
+    public readonly chonkProof: ChonkProof,
+    /**
+     * Contract class log fields emitted from the tx.
+     * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
+     * 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<BaseBuffer32> {
+    return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
+  }
+
+  hasPublicCalls() {
+    return this.numberOfPublicCalls() > 0;
+  }
+
+  numberOfPublicCalls() {
+    return this.data.numberOfPublicCallRequests();
+  }
+
+  getNonRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getNonRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
+  }
+
+  getRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
+  }
+
+  getTeardownPublicCallRequestWithCalldata(): PublicCallRequestWithCalldata | undefined {
+    const request = this.data.getTeardownPublicCallRequest();
+    return request ? this.#combinePublicCallRequestWithCallData(request) : undefined;
+  }
+
+  getPublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    const teardown = this.data.getTeardownPublicCallRequest();
+    const callRequests = [
+      ...this.data.getNonRevertiblePublicCallRequests(),
+      ...this.data.getRevertiblePublicCallRequests(),
+      ...(teardown ? [teardown] : []),
+    ];
+    return callRequests.map(r => this.#combinePublicCallRequestWithCallData(r));
+  }
+
+  getTotalPublicCalldataCount(): number {
+    return this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.values.length, 0);
+  }
+
+  getGasSettings(): GasSettings {
+    return this.data.constants.txContext.gasSettings;
+  }
+
+  /**
+   * Deserializes the Tx object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of Tx.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): Tx {
+    const reader = BufferReader.asReader(buffer);
+    return new Tx(
+      reader.readObject(TxHash),
+      reader.readObject(PrivateKernelTailCircuitPublicInputs),
+      reader.readObject(ChonkProof),
+      reader.readVectorUint8Prefix(ContractClassLogFields),
+      reader.readVectorUint8Prefix(HashedValues),
+    );
+  }
+
+  /**
+   * Deserializes a Tx from separately-stored tx and proof buffers. The tx buffer is expected to carry an empty
+   * proof placeholder (as produced by `withoutProof().toBuffer()`), which is skipped in favor of the given proof.
+   * @param txBuffer - Serialized tx with an empty proof placeholder.
+   * @param proofBuffer - Serialized proof to attach.
+   * @returns An instance of Tx carrying the given proof.
+   */
+  static fromBuffers(txBuffer: Buffer | BufferReader, proofBuffer: Buffer | BufferReader): Tx {
+    const reader = BufferReader.asReader(txBuffer);
+    const txHash = reader.readObject(TxHash);
+    const data = reader.readObject(PrivateKernelTailCircuitPublicInputs);
+    reader.readObject(ChonkProof);
+    const contractClassLogFields = reader.readVectorUint8Prefix(ContractClassLogFields);
+    const publicFunctionCalldata = reader.readVectorUint8Prefix(HashedValues);
+    return new Tx(txHash, data, ChonkProof.fromBuffer(proofBuffer), contractClassLogFields, publicFunctionCalldata);
+  }
+
+  /**
+   * Serializes the Tx object into a Buffer.
+   * @returns Buffer representation of the Tx object.
+   */
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this, TX_SINK_PRESIZE_BYTES);
+    }
+    serializeToSink(sink, this.txHash, this.data, this.chonkProof);
+    serializeArrayToSink(sink, this.contractClassLogFields, 1);
+    serializeArrayToSink(sink, this.publicFunctionCalldata, 1);
+  }
+
+  static get schema(): ZodFor<Tx> {
+    return z
+      .object({
+        data: PrivateKernelTailCircuitPublicInputs.schema,
+        chonkProof: ChonkProof.schema,
+        contractClassLogFields: z.array(ContractClassLogFields.schema).max(MAX_CONTRACT_CLASS_LOGS_PER_TX),
+        publicFunctionCalldata: z
+          .array(HashedValues.schemaFor(MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS))
+          .max(MAX_PUBLIC_FUNCTION_CALLDATA_PER_TX),
+      })
+      .transform(Tx.create);
+  }
+
+  static async computeTxHash(fields: Pick<FieldsOf<Tx>, 'data'>) {
+    const hash = fields.data.forPublic
+      ? await fields.data.toPrivateToPublicKernelCircuitPublicInputs().hash()
+      : await fields.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
+    return new TxHash(hash);
+  }
+
+  static async create(fields: Omit<FieldsOf<Tx>, 'txHash'>): Promise<Tx> {
+    const txHash = await Tx.computeTxHash(fields);
+    return Tx.from({ ...fields, txHash });
+  }
+
+  static from(fields: FieldsOf<Tx>) {
+    return new Tx(
+      fields.txHash,
+      fields.data,
+      fields.chonkProof,
+      fields.contractClassLogFields,
+      fields.publicFunctionCalldata,
+    );
+  }
+
+  /**
+   * Validates that the tx hash matches the computed hash from the tx data.
+   * This should be called when deserializing a tx from an untrusted source.
+   * @returns true if the hash is valid, false otherwise
+   */
+  async validateTxHash(): Promise<boolean> {
+    const expectedHash = await Tx.computeTxHash(this);
+    return this.txHash.equals(expectedHash);
+  }
+
+  getContractClassLogs(): ContractClassLog[] {
+    const logHashes = this.data.getNonEmptyContractClassLogsHashes();
+    return logHashes.map((logHash, i) =>
+      ContractClassLog.from({
+        contractAddress: logHash.contractAddress,
+        fields: this.contractClassLogFields[i],
+        emittedLength: logHash.logHash.length,
+      }),
+    );
+  }
+
+  /**
+   * Gets either revertible or non revertible contract class logs emitted by this tx.
+   * @param revertible - true for revertible only logs, false for non revertible only logs.
+   * @returns The requested logs.
+   */
+  getSplitContractClassLogs(revertible: boolean): ContractClassLog[] {
+    if (!this.data.forPublic) {
+      throw new Error('`getSplitContractClassLogs` should only be called on txs with public calls');
+    }
+
+    const contractClassLogs = this.getContractClassLogs();
+    const numNonRevertible = this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(
+      h => !h.isEmpty(),
+    ).length;
+    return revertible ? contractClassLogs.slice(numNonRevertible) : contractClassLogs.slice(0, numNonRevertible);
+  }
+
+  /**
+   * Return transaction hash.
+   * @returns The hash of the public inputs of the private kernel tail circuit.
+   */
+  getTxHash(): TxHash {
+    return this.txHash;
+  }
+
+  getCalldataMap(): Map<string, Fr[]> {
+    if (!this.calldataMap) {
+      const calldataMap = new Map();
+      this.publicFunctionCalldata.forEach(cd => calldataMap.set(cd.hash.toString(), cd.values));
+      this.calldataMap = calldataMap;
+    }
+
+    return this.calldataMap;
+  }
+
+  /** Returns stats about this tx. */
+  getStats(): TxStats {
+    return {
+      txHash: this.txHash.toString(),
+
+      noteHashCount: this.data.getNonEmptyNoteHashes().length,
+      nullifierCount: this.data.getNonEmptyNullifiers().length,
+      privateLogCount: this.data.getNonEmptyPrivateLogs().length,
+      classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
+      contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
+
+      proofSize: this.chonkProof.fields.length,
+      size: this.getSize(),
+
+      feePaymentMethod:
+        // needsSetup? then we pay through a fee payment contract
+        this.data.forPublic?.needsSetup ? 'fpc' : 'fee_juice',
+    };
+  }
+
+  private sizeCache: number | undefined;
+
+  getSize(): number {
+    if (this.sizeCache == undefined) {
+      this.sizeCache = this.toBuffer().length;
+    }
+    return this.sizeCache;
+  }
+
+  /**
+   * Returns the number of fields this tx's effects will occupy in the blob,
+   * based on its private side effects only. Accurate for txs without public calls.
+   * For txs with public calls, the actual size will be larger due to public execution outputs.
+   */
+  getPrivateTxEffectsSizeInFields(): number {
+    // 3 fields overhead: tx_start_marker, tx_hash, tx_fee.
+    // TX_DA_GAS_OVERHEAD is defined as N * DA_GAS_PER_FIELD, so this division is always exact.
+    const overheadFields = TX_DA_GAS_OVERHEAD / DA_GAS_PER_FIELD;
+    const noteHashes = this.data.getNonEmptyNoteHashes().length;
+    const nullifiers = this.data.getNonEmptyNullifiers().length;
+    const l2ToL1Msgs = this.data.getNonEmptyL2ToL1Msgs().length;
+    // Each private log occupies (emittedLength + 1) fields: content + length field
+    const privateLogFields = this.data.getNonEmptyPrivateLogs().reduce((acc, log) => acc + log.emittedLength + 1, 0);
+    // Each contract class log occupies (length + 1) fields: content + contract address
+    const contractClassLogFields = this.data
+      .getNonEmptyContractClassLogsHashes()
+      .reduce((acc, log) => acc + log.logHash.length + 1, 0);
+    return overheadFields + noteHashes + nullifiers + l2ToL1Msgs + privateLogFields + contractClassLogFields;
+  }
+
+  /**
+   * 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, cloneProof = true): Tx {
+    const publicInputs = PrivateKernelTailCircuitPublicInputs.fromBuffer(tx.data.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);
+
+    return clonedTx;
+  }
+
+  /**
+   * Returns a copy of this tx with its proof stripped (replaced by an empty {@link ChonkProof}). Used when archiving
+   * txs or shipping a pending tx over RPC where the proof is not needed. Note that {@link Tx.clone} with
+   * `cloneProof = false` does not strip the proof; it shares the original.
+   * @returns A new tx with an empty proof.
+   */
+  withoutProof(): Tx {
+    return new Tx(this.txHash, this.data, ChonkProof.empty(), this.contractClassLogFields, this.publicFunctionCalldata);
+  }
+
+  /**
+   * Creates a random tx.
+   * @param randomProof - Whether to create a random proof - this will be random bytes of the full size.
+   * @returns A random tx.
+   */
+  static random(args: { randomProof?: boolean; txHash?: string | TxHash } = {}): Tx {
+    return Tx.from({
+      txHash: (typeof args.txHash === 'string' ? TxHash.fromString(args.txHash) : args.txHash) ?? TxHash.random(),
+      data: PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
+      chonkProof: args.randomProof ? ChonkProof.random() : ChonkProof.empty(),
+      contractClassLogFields: [ContractClassLogFields.random()],
+      publicFunctionCalldata: [HashedValues.random()],
+    });
+  }
+
+  /** Recomputes the tx hash. Used for testing purposes only when a property of the tx was mutated. */
+  public async recomputeHash(): Promise<TxHash> {
+    unfreeze(this).txHash = await Tx.computeTxHash(this);
+    return this.txHash;
+  }
+
+  #combinePublicCallRequestWithCallData(request: PublicCallRequest) {
+    const calldataMap = this.getCalldataMap();
+    // Assume empty calldata if nothing is given for the hash.
+    // The verification of calldata vs hash should be handled outside of this class.
+    const calldata = calldataMap.get(request.calldataHash.toString()) ?? [];
+    return new PublicCallRequestWithCalldata(request, calldata);
+  }
+}
+
+/**
+ * Helper class to handle Serialization and Deserialization of Txs array.
+ */
+export class TxArray extends Array<Tx> {
+  static fromBuffer(buffer: Buffer | BufferReader): TxArray {
+    const reader = BufferReader.asReader(buffer);
+    try {
+      const txs = reader.readVector(Tx);
+      return new TxArray(...txs);
+    } catch {
+      throw new Error('Failed to deserialize TxArray from buffer');
+    }
+  }
+
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return serializeArrayOfBufferableToVector(this);
+    }
+    serializeArrayToSink(sink, [...this]);
+  }
+}

package/src/tx/tx_constant_data.ts

@@ -0,0 +1,91 @@
+import { TX_CONSTANT_DATA_LENGTH } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import {
+  BufferReader,
+  BufferSink,
+  FieldReader,
+  serializeToFields,
+  serializeToSink,
+} from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+
+import { BlockHeader } from './block_header.js';
+import { TxContext } from './tx_context.js';
+
+/**
+ * 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(
+    public anchorBlockHeader: BlockHeader,
+    public txContext: TxContext,
+    public vkTreeRoot: Fr,
+    public protocolContractsHash: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<TxConstantData>) {
+    return new TxConstantData(...TxConstantData.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<TxConstantData>) {
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContractsHash] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): TxConstantData {
+    const reader = FieldReader.asReader(fields);
+    return new TxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readField(),
+    );
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...TxConstantData.getFields(this));
+    if (fields.length !== TX_CONSTANT_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for TxConstantData. Expected ${TX_CONSTANT_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): TxConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new TxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, ...TxConstantData.getFields(this));
+  }
+
+  static empty() {
+    return new TxConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, Fr.ZERO);
+  }
+
+  getSize() {
+    return (
+      this.anchorBlockHeader.getSize() +
+      this.txContext.getSize() +
+      this.vkTreeRoot.size +
+      this.protocolContractsHash.size
+    );
+  }
+
+  clone(): TxConstantData {
+    return TxConstantData.fromBuffer(this.toBuffer());
+  }
+}

package/src/tx/tx_context.ts

@@ -0,0 +1,114 @@
+import { TX_CONTEXT_LENGTH } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import {
+  BufferReader,
+  BufferSink,
+  FieldReader,
+  serializeToFields,
+  serializeToSink,
+} from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { z } from 'zod';
+
+import { GasSettings } from '../gas/gas_settings.js';
+
+/**
+ * Transaction context.
+ */
+export class TxContext {
+  public chainId: Fr;
+  public version: Fr;
+
+  constructor(
+    /** Chain ID of the transaction. Here for replay protection. */
+    chainId: Fr | number | bigint,
+    /** Version of the transaction. Here for replay protection. */
+    version: Fr | number | bigint,
+    /** Gas limits for this transaction. */
+    public gasSettings: GasSettings,
+  ) {
+    this.chainId = new Fr(chainId);
+    this.version = new Fr(version);
+  }
+
+  static get schema() {
+    return z
+      .object({
+        chainId: schemas.Fr,
+        version: schemas.Fr,
+        gasSettings: GasSettings.schema,
+      })
+      .transform(TxContext.from);
+  }
+
+  getSize() {
+    return this.chainId.size + this.version.size + this.gasSettings.getSize();
+  }
+
+  clone() {
+    return new TxContext(this.chainId, this.version, this.gasSettings.clone());
+  }
+
+  /**
+   * Serialize as a buffer.
+   * @returns The buffer.
+   */
+  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 {
+    const reader = FieldReader.asReader(fields);
+    return new TxContext(reader.readField(), reader.readField(), reader.readObject(GasSettings));
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...TxContext.getFields(this));
+    if (fields.length !== TX_CONTEXT_LENGTH) {
+      throw new Error(`Invalid number of fields for TxContext. Expected ${TX_CONTEXT_LENGTH}, got ${fields.length}`);
+    }
+    return fields;
+  }
+
+  /**
+   * Deserializes TxContext from a buffer or reader.
+   * @param buffer - Buffer to read from.
+   * @returns The TxContext.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): TxContext {
+    const reader = BufferReader.asReader(buffer);
+    return new TxContext(Fr.fromBuffer(reader), Fr.fromBuffer(reader), reader.readObject(GasSettings));
+  }
+
+  static empty(chainId: Fr | number = 0, version: Fr | number = 0) {
+    return new TxContext(new Fr(chainId), new Fr(version), GasSettings.empty());
+  }
+
+  isEmpty(): boolean {
+    return this.chainId.isZero() && this.version.isZero() && this.gasSettings.isEmpty();
+  }
+
+  /**
+   * Create a new instance from a fields dictionary.
+   * @param fields - The dictionary.
+   * @returns A new instance.
+   */
+  static from(fields: FieldsOf<TxContext>): TxContext {
+    return new TxContext(...TxContext.getFields(fields));
+  }
+
+  /**
+   * Serialize into a field array. Low-level utility.
+   * @param fields - Object with fields.
+   * @returns The array.
+   */
+  static getFields(fields: FieldsOf<TxContext>) {
+    return [fields.chainId, fields.version, fields.gasSettings] as const;
+  }
+}