@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/tx/tx.ts

@@ -1,6 +1,6 @@
 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';
@@ -10,85 +10,97 @@ import { z } from 'zod';
 import type { GasSettings } from '../gas/gas_settings.js';
 import type { GetPublicLogsResponse } from '../interfaces/get_logs_response.js';
 import type { L2LogsSource } from '../interfaces/l2_logs_source.js';
-import type { ScopedLogHash } from '../kernel/log_hash.js';
+import type { PublicCallRequest } from '../kernel/index.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Gossipable } from '../p2p/gossipable.js';
-import { TopicType, createTopicString } from '../p2p/topic_type.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { TopicType } from '../p2p/topic_type.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { TxStats } from '../stats/stats.js';
-import { PublicExecutionRequest } from './public_execution_request.js';
+import { HashedValues } from './hashed_values.js';
+import { PublicCallRequestWithCalldata } from './public_call_request_with_calldata.js';
 import { TxHash } from './tx_hash.js';
 
 /**
  * The interface of an L2 transaction.
  */
+// docs:start:tx_class
 export class Tx extends Gossipable {
-  static override p2pTopic: string;
-  // For memoization
-  private txHash: TxHash | undefined;
+  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.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
-     *
-     */
-    public readonly clientIvcProof: ClientIvcProof,
-    /**
-     * Contract class logs generated by the tx.
      */
-    public contractClassLogs: ContractClassLog[],
+    public readonly chonkProof: ChonkProof,
     /**
-     * Enqueued public functions from the private circuit to be run by the sequencer.
+     * 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 enqueuedPublicFunctionCalls: PublicExecutionRequest[],
+    public readonly contractClassLogFields: ContractClassLogFields[],
     /**
-     * Public function call to be run by the sequencer as part of teardown.
+     * 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 publicTeardownFunctionCall: PublicExecutionRequest,
+    public readonly publicFunctionCalldata: HashedValues[],
   ) {
     super();
   }
+  // docs:end:tx_class
 
   // Gossipable method
-  static {
-    this.p2pTopic = createTopicString(TopicType.tx);
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+    return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
   }
 
-  // Gossipable method
-  override async p2pMessageIdentifier(): Promise<Buffer32> {
-    return new Buffer32((await this.getTxHash()).toBuffer());
+  hasPublicCalls() {
+    return this.numberOfPublicCalls() > 0;
   }
 
-  hasPublicCalls() {
-    return this.data.numberOfPublicCallRequests() > 0;
+  numberOfPublicCalls() {
+    return this.data.numberOfPublicCallRequests();
   }
 
-  getNonRevertiblePublicExecutionRequests(): PublicExecutionRequest[] {
-    const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-    return this.enqueuedPublicFunctionCalls.slice(numRevertible);
+  getNonRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getNonRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
   }
 
-  getRevertiblePublicExecutionRequests(): PublicExecutionRequest[] {
-    const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-    return this.enqueuedPublicFunctionCalls.slice(0, numRevertible);
+  getRevertiblePublicCallRequestsWithCalldata(): PublicCallRequestWithCalldata[] {
+    return this.data.getRevertiblePublicCallRequests().map(r => this.#combinePublicCallRequestWithCallData(r));
   }
 
-  getPublicTeardownExecutionRequest(): PublicExecutionRequest | undefined {
-    return this.publicTeardownFunctionCall.isEmpty() ? undefined : this.publicTeardownFunctionCall;
+  getTeardownPublicCallRequestWithCalldata(): PublicCallRequestWithCalldata | undefined {
+    const request = this.data.getTeardownPublicCallRequest();
+    return request ? this.#combinePublicCallRequestWithCallData(request) : undefined;
   }
 
-  getTotalPublicArgsCount(): number {
-    let count = this.enqueuedPublicFunctionCalls.reduce((acc, execRequest) => acc + execRequest.args.length, 0);
-    if (!this.publicTeardownFunctionCall.isEmpty()) {
-      count += this.publicTeardownFunctionCall.args.length;
-    }
-    return count;
+  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 {
@@ -103,24 +115,11 @@ export class Tx extends Gossipable {
   static fromBuffer(buffer: Buffer | BufferReader): Tx {
     const reader = BufferReader.asReader(buffer);
     return new Tx(
+      reader.readObject(TxHash),
       reader.readObject(PrivateKernelTailCircuitPublicInputs),
-      reader.readObject(ClientIvcProof),
-      reader.readVectorUint8Prefix(ContractClassLog),
-      reader.readVectorUint8Prefix(PublicExecutionRequest),
-      reader.readObject(PublicExecutionRequest),
-    );
-  }
-
-  static newWithTxData(
-    data: PrivateKernelTailCircuitPublicInputs,
-    publicTeardownExecutionRequest?: PublicExecutionRequest,
-  ) {
-    return new Tx(
-      data,
-      ClientIvcProof.empty(),
-      [],
-      [],
-      publicTeardownExecutionRequest ? publicTeardownExecutionRequest : PublicExecutionRequest.empty(),
+      reader.readObject(ChonkProof),
+      reader.readVectorUint8Prefix(ContractClassLogFields),
+      reader.readVectorUint8Prefix(HashedValues),
     );
   }
 
@@ -130,11 +129,11 @@ export class Tx extends Gossipable {
    */
   toBuffer() {
     return serializeToBuffer([
+      this.txHash,
       this.data,
-      this.clientIvcProof,
-      serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
-      serializeArrayOfBufferableToVector(this.enqueuedPublicFunctionCalls, 1),
-      this.publicTeardownFunctionCall,
+      this.chonkProof,
+      serializeArrayOfBufferableToVector(this.contractClassLogFields, 1),
+      serializeArrayOfBufferableToVector(this.publicFunctionCalldata, 1),
     ]);
   }
 
@@ -142,125 +141,126 @@ export class Tx extends Gossipable {
     return z
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
-        clientIvcProof: ClientIvcProof.schema,
-        contractClassLogs: z.array(ContractClassLog.schema),
-        enqueuedPublicFunctionCalls: z.array(PublicExecutionRequest.schema),
-        publicTeardownFunctionCall: PublicExecutionRequest.schema,
+        chonkProof: ChonkProof.schema,
+        contractClassLogFields: z.array(ContractClassLogFields.schema),
+        publicFunctionCalldata: z.array(HashedValues.schema),
       })
-      .transform(Tx.from);
+      .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.clientIvcProof,
-      fields.contractClassLogs,
-      fields.enqueuedPublicFunctionCalls,
-      fields.publicTeardownFunctionCall,
+      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);
+  }
+
   /**
    * Gets public logs emitted by this tx.
    * @param logsSource - An instance of `L2LogsSource` which can be used to obtain the logs.
    * @returns The requested logs.
    */
-  public async getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
-    return logsSource.getPublicLogs({ txHash: await this.getTxHash() });
+  public getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse> {
+    return logsSource.getPublicLogs({ txHash: this.getTxHash() });
+  }
+
+  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 reverible only logs.
+   * @param revertible - true for revertible only logs, false for non revertible only logs.
    * @returns The requested logs.
    */
-  async getSplitContractClassLogs(revertible: boolean, silo: boolean = false): Promise<ContractClassLog[]> {
-    // Should only be called on txs with public calls
+  getSplitContractClassLogs(revertible: boolean): ContractClassLog[] {
     if (!this.data.forPublic) {
-      return [];
+      throw new Error('`getSplitContractClassLogs` should only be called on txs with public calls');
     }
-    const contractClassLogsHashes = revertible
-      ? this.data.forPublic.revertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty())
-      : this.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes.filter(h => !h.isEmpty());
-    return await this.filterContractClassLogs(contractClassLogsHashes, silo);
-  }
 
-  /**
-   * Filters contract class logs emitted by this tx.
-   * @param logHashes - logs to keep represented by their hashes.
-   * @param silo - whether to silo the logs before returning them.
-   * @returns The requested logs.
-   */
-  async filterContractClassLogs(logHashes: ScopedLogHash[], silo: boolean = false): Promise<ContractClassLog[]> {
-    const contractClassLogs = [];
-    for (const log of this.contractClassLogs) {
-      const hashedLog = await log.hash();
-      const logHash = logHashes.find(
-        hash => hash.value.equals(hashedLog) && hash.contractAddress.equals(log.contractAddress),
-      );
-      if (logHash) {
-        contractClassLogs.push(silo ? await log.silo() : log);
-      }
-    }
-    return contractClassLogs;
+    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);
   }
 
   /**
-   * Computes (if necessary) & return transaction hash.
+   * Return transaction hash.
    * @returns The hash of the public inputs of the private kernel tail circuit.
    */
-  async getTxHash(forceRecompute = false): Promise<TxHash> {
-    if (!this.txHash || forceRecompute) {
-      const hash = this.data.forPublic
-        ? await this.data.toPrivateToPublicKernelCircuitPublicInputs().hash()
-        : await this.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
-      this.txHash = new TxHash(hash);
-    }
-    return this.txHash!;
+  getTxHash(): TxHash {
+    return this.txHash;
   }
 
-  /**
-   * Allows setting the hash of the Tx.
-   * Use this when you want to skip computing it from the original data.
-   * Don't set a Tx hash received from an untrusted source.
-   * @param hash - The hash to set.
-   */
-  setTxHash(hash: TxHash) {
-    this.txHash = hash;
+  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. */
-  async getStats(): Promise<TxStats> {
+  getStats(): TxStats {
     return {
-      txHash: (await this.getTxHash()).toString(),
+      txHash: this.txHash.toString(),
 
       noteHashCount: this.data.getNonEmptyNoteHashes().length,
       nullifierCount: this.data.getNonEmptyNullifiers().length,
       privateLogCount: this.data.getNonEmptyPrivateLogs().length,
-      classRegisteredCount: this.data.getNonEmptyContractClassLogsHashes().length,
+      classPublishedCount: this.data.getNonEmptyContractClassLogsHashes().length,
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
-      proofSize: this.clientIvcProof.clientIvcProofBuffer.length,
+      proofSize: this.chonkProof.fields.length,
       size: this.toBuffer().length,
 
       feePaymentMethod:
         // needsSetup? then we pay through a fee payment contract
-        this.data.forPublic?.needsSetup
-          ? // if the first call is to `approve_public_authwit`, then it's a public payment
-            this.data.getNonRevertiblePublicCallRequests().at(-1)!.functionSelector.toField().toBigInt() === 0x43417bb1n
-            ? 'fpc_public'
-            : 'fpc_private'
-          : 'fee_juice',
+        this.data.forPublic?.needsSetup ? 'fpc' : 'fee_juice',
     };
   }
 
   getSize() {
     return (
       this.data.getSize() +
-      this.clientIvcProof.clientIvcProofBuffer.length +
-      arraySerializedSizeOfNonEmpty(this.contractClassLogs) +
-      arraySerializedSizeOfNonEmpty(this.enqueuedPublicFunctionCalls) +
-      arraySerializedSizeOfNonEmpty([this.publicTeardownFunctionCall])
+      this.chonkProof.fields.length * Fr.SIZE_IN_BYTES +
+      arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
+      this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
     );
   }
 
@@ -277,47 +277,18 @@ export class Tx extends Gossipable {
     );
   }
 
-  /**
-   * Convenience function to get a hash out of a tx or a tx-like.
-   * @param tx - Tx-like object.
-   * @returns - The hash.
-   */
-  static async getHash(tx: Tx | HasHash): Promise<TxHash> {
-    return hasHash(tx) ? tx.hash : await tx.getTxHash();
-  }
-
-  /**
-   * Convenience function to get array of hashes for an array of txs.
-   * @param txs - The txs to get the hashes from.
-   * @returns The corresponding array of hashes.
-   */
-  static async getHashes(txs: (Tx | HasHash)[]): Promise<TxHash[]> {
-    return await Promise.all(txs.map(Tx.getHash));
-  }
-
   /**
    * 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 clientIvcProof = ClientIvcProof.fromBuffer(tx.clientIvcProof.toBuffer());
-    const contractClassLogs = tx.contractClassLogs.map(x => ContractClassLog.fromBuffer(x.toBuffer()));
-    const enqueuedPublicFunctionCalls = tx.enqueuedPublicFunctionCalls.map(x =>
-      PublicExecutionRequest.fromBuffer(x.toBuffer()),
-    );
-    const publicTeardownFunctionCall = PublicExecutionRequest.fromBuffer(tx.publicTeardownFunctionCall.toBuffer());
-    const clonedTx = new Tx(
-      publicInputs,
-      clientIvcProof,
-      contractClassLogs,
-      enqueuedPublicFunctionCalls,
-      publicTeardownFunctionCall,
-    );
-    if (tx.txHash) {
-      clonedTx.setTxHash(TxHash.fromBuffer(tx.txHash.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;
   }
@@ -327,38 +298,46 @@ export class Tx extends Gossipable {
    * @param randomProof - Whether to create a random proof - this will be random bytes of the full size.
    * @returns A random tx.
    */
-  static async random(randomProof = false) {
-    return new Tx(
-      PrivateKernelTailCircuitPublicInputs.emptyWithNullifier(),
-      randomProof ? ClientIvcProof.random() : ClientIvcProof.empty(),
-      [await ContractClassLog.random()],
-      [await PublicExecutionRequest.random()],
-      await PublicExecutionRequest.random(),
-    );
+  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()],
+    });
   }
 
-  /**
-   * Filters out logs from functions that are not present in the provided kernel output.
-   *
-   * The purpose of this is to remove logs that got dropped due to a revert,
-   * in which case, we only have the kernel's hashes to go on, as opposed to
-   * this grouping by function maintained in this class.
-   *
-   * The logic therefore is to drop all FunctionLogs if any constituent hash
-   * does not appear in the provided hashes: it is impossible for part of a
-   * function to revert.
-   *
-   * @param logHashes the individual log hashes we want to keep
-   * @param out the output to put passing logs in, to keep this function abstract
-   */
-  public async filterRevertedLogs() {
-    this.contractClassLogs = await this.getSplitContractClassLogs(false);
+  /** Recomputes the tx hash. Used for testing purposes only when a property of the tx was mutated. */
+  public async recomputeHash(): Promise<TxHash> {
+    (this as any).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);
   }
 }
 
-/** Utility type for an entity that has a hash property for a txhash */
-type HasHash = { /** The tx hash */ hash: TxHash };
+/**
+ * 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');
+    }
+  }
 
-function hasHash(tx: Tx | HasHash): tx is HasHash {
-  return (tx as HasHash).hash !== undefined;
+  public toBuffer(): Buffer {
+    return serializeArrayOfBufferableToVector(this);
+  }
 }

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

package/src/tx/tx_context.ts

@@ -1,5 +1,5 @@
 import { TX_CONTEXT_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';