@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/tx/tx.js

@@ -1,69 +1,88 @@
+import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, serializeArrayOfBufferableToVector, serializeArrayToSink, serializeToSink } from '@aztec/foundation/serialize';
+import { unfreeze } from '@aztec/foundation/types';
 import { z } from 'zod';
 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 { PublicExecutionRequest } from './public_execution_request.js';
+import { TopicType } from '../p2p/topic_type.js';
+import { ChonkProof } from '../proofs/chonk_proof.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;
 /**
  * The interface of an L2 transaction.
- */ export class Tx extends Gossipable {
-    data;
-    clientIvcProof;
-    contractClassLogs;
-    enqueuedPublicFunctionCalls;
-    publicTeardownFunctionCall;
-    static p2pTopic;
-    // For memoization
+ */ // docs:start:tx_class
+export class Tx extends Gossipable {
     txHash;
+    data;
+    chonkProof;
+    contractClassLogFields;
+    publicFunctionCalldata;
+    static p2pTopic = TopicType.tx;
+    calldataMap;
     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.
+     */ txHash, /**
      * Output of the private kernel circuit for this tx.
      */ data, /**
      * Proof from the private kernel circuit.
-     * TODO(#7368): This client IVC object currently contains various VKs that will eventually be more like static data.
-     *
-     */ clientIvcProof, /**
-     * Contract class logs generated by the tx.
-     */ contractClassLogs, /**
-     * Enqueued public functions from the private circuit to be run by the sequencer.
-     */ enqueuedPublicFunctionCalls, /**
-     * Public function call to be run by the sequencer as part of teardown.
-     */ publicTeardownFunctionCall){
-        super(), this.data = data, this.clientIvcProof = clientIvcProof, this.contractClassLogs = contractClassLogs, this.enqueuedPublicFunctionCalls = enqueuedPublicFunctionCalls, this.publicTeardownFunctionCall = publicTeardownFunctionCall;
-    }
-    // Gossipable method
-    static{
-        this.p2pTopic = createTopicString(TopicType.tx);
+     */ 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.
+     */ 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.
+     */ publicFunctionCalldata){
+        super(), this.txHash = txHash, this.data = data, this.chonkProof = chonkProof, this.contractClassLogFields = contractClassLogFields, this.publicFunctionCalldata = publicFunctionCalldata;
     }
+    // docs:end:tx_class
     // Gossipable method
-    async p2pMessageIdentifier() {
-        return new Buffer32((await this.getTxHash()).toBuffer());
+    generateP2PMessageIdentifier() {
+        return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
     }
     hasPublicCalls() {
-        return this.data.numberOfPublicCallRequests() > 0;
+        return this.numberOfPublicCalls() > 0;
     }
-    getNonRevertiblePublicExecutionRequests() {
-        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-        return this.enqueuedPublicFunctionCalls.slice(numRevertible);
+    numberOfPublicCalls() {
+        return this.data.numberOfPublicCallRequests();
     }
-    getRevertiblePublicExecutionRequests() {
-        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
-        return this.enqueuedPublicFunctionCalls.slice(0, numRevertible);
+    getNonRevertiblePublicCallRequestsWithCalldata() {
+        return this.data.getNonRevertiblePublicCallRequests().map((r)=>this.#combinePublicCallRequestWithCallData(r));
     }
-    getPublicTeardownExecutionRequest() {
-        return this.publicTeardownFunctionCall.isEmpty() ? undefined : this.publicTeardownFunctionCall;
+    getRevertiblePublicCallRequestsWithCalldata() {
+        return this.data.getRevertiblePublicCallRequests().map((r)=>this.#combinePublicCallRequestWithCallData(r));
     }
-    getTotalPublicArgsCount() {
-        let count = this.enqueuedPublicFunctionCalls.reduce((acc, execRequest)=>acc + execRequest.args.length, 0);
-        if (!this.publicTeardownFunctionCall.isEmpty()) {
-            count += this.publicTeardownFunctionCall.args.length;
-        }
-        return count;
+    getTeardownPublicCallRequestWithCalldata() {
+        const request = this.data.getTeardownPublicCallRequest();
+        return request ? this.#combinePublicCallRequestWithCallData(request) : undefined;
+    }
+    getPublicCallRequestsWithCalldata() {
+        const teardown = this.data.getTeardownPublicCallRequest();
+        const callRequests = [
+            ...this.data.getNonRevertiblePublicCallRequests(),
+            ...this.data.getRevertiblePublicCallRequests(),
+            ...teardown ? [
+                teardown
+            ] : []
+        ];
+        return callRequests.map((r)=>this.#combinePublicCallRequestWithCallData(r));
+    }
+    getTotalPublicCalldataCount() {
+        return this.publicFunctionCalldata.reduce((accum, cd)=>accum + cd.values.length, 0);
     }
     getGasSettings() {
         return this.data.constants.txContext.gasSettings;
@@ -74,173 +93,186 @@ import { TxHash } from './tx_hash.js';
    * @returns An instance of Tx.
    */ static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new Tx(reader.readObject(PrivateKernelTailCircuitPublicInputs), reader.readObject(ClientIvcProof), reader.readVectorUint8Prefix(ContractClassLog), reader.readVectorUint8Prefix(PublicExecutionRequest), reader.readObject(PublicExecutionRequest));
-    }
-    static newWithTxData(data, publicTeardownExecutionRequest) {
-        return new Tx(data, ClientIvcProof.empty(), [], [], publicTeardownExecutionRequest ? publicTeardownExecutionRequest : PublicExecutionRequest.empty());
+        return new Tx(reader.readObject(TxHash), reader.readObject(PrivateKernelTailCircuitPublicInputs), reader.readObject(ChonkProof), reader.readVectorUint8Prefix(ContractClassLogFields), reader.readVectorUint8Prefix(HashedValues));
     }
-    /**
-   * Serializes the Tx object into a Buffer.
-   * @returns Buffer representation of the Tx object.
-   */ toBuffer() {
-        return serializeToBuffer([
-            this.data,
-            this.clientIvcProof,
-            serializeArrayOfBufferableToVector(this.contractClassLogs, 1),
-            serializeArrayOfBufferableToVector(this.enqueuedPublicFunctionCalls, 1),
-            this.publicTeardownFunctionCall
-        ]);
+    toBuffer(sink) {
+        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() {
         return z.object({
             data: PrivateKernelTailCircuitPublicInputs.schema,
-            clientIvcProof: ClientIvcProof.schema,
-            contractClassLogs: z.array(ContractClassLog.schema),
-            enqueuedPublicFunctionCalls: z.array(PublicExecutionRequest.schema),
-            publicTeardownFunctionCall: PublicExecutionRequest.schema
-        }).transform(Tx.from);
+            chonkProof: ChonkProof.schema,
+            contractClassLogFields: z.array(ContractClassLogFields.schema),
+            publicFunctionCalldata: z.array(HashedValues.schema)
+        }).transform(Tx.create);
+    }
+    static async computeTxHash(fields) {
+        const hash = fields.data.forPublic ? await fields.data.toPrivateToPublicKernelCircuitPublicInputs().hash() : await fields.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
+        return new TxHash(hash);
+    }
+    static async create(fields) {
+        const txHash = await Tx.computeTxHash(fields);
+        return Tx.from({
+            ...fields,
+            txHash
+        });
     }
     static from(fields) {
-        return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogs, fields.enqueuedPublicFunctionCalls, fields.publicTeardownFunctionCall);
+        return new Tx(fields.txHash, fields.data, fields.chonkProof, fields.contractClassLogFields, fields.publicFunctionCalldata);
     }
     /**
-   * 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.
-   */ async getPublicLogs(logsSource) {
-        return logsSource.getPublicLogs({
-            txHash: await this.getTxHash()
-        });
+   * 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() {
+        const expectedHash = await Tx.computeTxHash(this);
+        return this.txHash.equals(expectedHash);
+    }
+    getContractClassLogs() {
+        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, silo = false) {
-        // Should only be called on txs with public calls
+   */ getSplitContractClassLogs(revertible) {
         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);
+        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);
     }
     /**
-   * 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, silo = false) {
-        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;
-    }
-    /**
-   * 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) {
-        if (!this.txHash || forceRecompute) {
-            const hash = this.data.forPublic ? await this.data.toPrivateToPublicKernelCircuitPublicInputs().hash() : await this.data.toPrivateToRollupKernelCircuitPublicInputs().hash();
-            this.txHash = new TxHash(hash);
-        }
+   */ getTxHash() {
         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) {
-        this.txHash = hash;
-    }
-    /** Returns stats about this tx. */ async getStats() {
+    getCalldataMap() {
+        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() {
         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,
-            size: this.toBuffer().length,
+            proofSize: this.chonkProof.fields.length,
+            size: this.getSize(),
             feePaymentMethod: // needsSetup? then we pay through a fee payment contract
-            this.data.forPublic?.needsSetup ? this.data.getNonRevertiblePublicCallRequests().at(-1).functionSelector.toField().toBigInt() === 0x43417bb1n ? 'fpc_public' : 'fpc_private' : 'fee_juice'
+            this.data.forPublic?.needsSetup ? 'fpc' : 'fee_juice'
         };
     }
+    sizeCache;
     getSize() {
-        return this.data.getSize() + this.clientIvcProof.clientIvcProofBuffer.length + arraySerializedSizeOfNonEmpty(this.contractClassLogs) + arraySerializedSizeOfNonEmpty(this.enqueuedPublicFunctionCalls) + arraySerializedSizeOfNonEmpty([
-            this.publicTeardownFunctionCall
-        ]);
-    }
-    /**
-   * Estimates the tx size based on its private effects. Note that the actual size of the tx
-   * after processing will probably be larger, as public execution would generate more data.
-   */ getEstimatedPrivateTxEffectsSize() {
-        return this.data.getNonEmptyNoteHashes().length * Fr.SIZE_IN_BYTES + this.data.getNonEmptyNullifiers().length * Fr.SIZE_IN_BYTES + this.data.getEmittedPrivateLogsLength() * Fr.SIZE_IN_BYTES + this.data.getEmittedContractClassLogsLength() * Fr.SIZE_IN_BYTES;
-    }
-    /**
-   * 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) {
-        return hasHash(tx) ? tx.hash : await tx.getTxHash();
+        if (this.sizeCache == undefined) {
+            this.sizeCache = this.toBuffer().length;
+        }
+        return this.sizeCache;
     }
     /**
-   * 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) {
-        return await Promise.all(txs.map(Tx.getHash));
+   * 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() {
+        // 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) {
+   */ static clone(tx, cloneProof = true) {
         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;
     }
     /**
+   * 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() {
+        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 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 = {}) {
+        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
-   */ 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. */ async recomputeHash() {
+        unfreeze(this).txHash = await Tx.computeTxHash(this);
+        return this.txHash;
+    }
+    #combinePublicCallRequestWithCallData(request) {
+        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);
     }
 }
-function hasHash(tx) {
-    return tx.hash !== undefined;
+/**
+ * Helper class to handle Serialization and Deserialization of Txs array.
+ */ export class TxArray extends Array {
+    static fromBuffer(buffer) {
+        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');
+        }
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return serializeArrayOfBufferableToVector(this);
+        }
+        serializeArrayToSink(sink, [
+            ...this
+        ]);
+    }
 }

package/dest/tx/tx_constant_data.d.ts

@@ -1,61 +1,28 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 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 declare class TxConstantData {
-    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
-    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.
-     */
+    anchorBlockHeader: BlockHeader;
     txContext: TxContext;
-    /**
-     * Root of the vk tree for the protocol circuits.
-     */
     vkTreeRoot: Fr;
-    /**
-     * Root of the tree for the protocol contracts.
-     */
-    protocolContractTreeRoot: Fr;
-    constructor(
-    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
-    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.
-     */
-    txContext: TxContext, 
-    /**
-     * Root of the vk tree for the protocol circuits.
-     */
-    vkTreeRoot: Fr, 
-    /**
-     * Root of the tree for the protocol contracts.
-     */
-    protocolContractTreeRoot: Fr);
+    protocolContractsHash: Fr;
+    constructor(anchorBlockHeader: BlockHeader, txContext: TxContext, vkTreeRoot: Fr, protocolContractsHash: Fr);
     static from(fields: FieldsOf<TxConstantData>): TxConstantData;
     static getFields(fields: FieldsOf<TxConstantData>): readonly [BlockHeader, TxContext, Fr, Fr];
     static fromFields(fields: Fr[] | FieldReader): TxConstantData;
     toFields(): Fr[];
     static fromBuffer(buffer: Buffer | BufferReader): TxConstantData;
     toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
     static empty(): TxConstantData;
     getSize(): number;
     clone(): TxConstantData;
 }
-//# sourceMappingURL=tx_constant_data.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfY29uc3RhbnRfZGF0YS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R4L3R4X2NvbnN0YW50X2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBc0MsTUFBTSw2QkFBNkIsQ0FBQztBQUN4SCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTVDOzs7O0dBSUc7QUFDSCxxQkFBYSxjQUFjO0lBRWhCLGlCQUFpQixFQUFFLFdBQVc7SUFDOUIsU0FBUyxFQUFFLFNBQVM7SUFDcEIsVUFBVSxFQUFFLEVBQUU7SUFDZCxxQkFBcUIsRUFBRSxFQUFFO0lBSmxDLFlBQ1MsaUJBQWlCLEVBQUUsV0FBVyxFQUM5QixTQUFTLEVBQUUsU0FBUyxFQUNwQixVQUFVLEVBQUUsRUFBRSxFQUNkLHFCQUFxQixFQUFFLEVBQUUsRUFDOUI7SUFFSixNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsY0FBYyxDQUFDLGtCQUUzQztJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxjQUFjLENBQUMsNkNBRWhEO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxHQUFHLGNBQWMsQ0FRNUQ7SUFFRCxRQUFRLElBQUksRUFBRSxFQUFFLENBUWY7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLGNBQWMsQ0FRL0Q7SUFFRCxRQUFRLElBQUksTUFBTSxDQUFDO0lBQ25CLFFBQVEsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FBQztJQVFqQyxNQUFNLENBQUMsS0FBSyxtQkFFWDtJQUVELE9BQU8sV0FPTjtJQUVELEtBQUssSUFBSSxjQUFjLENBRXRCO0NBQ0YifQ==

package/dest/tx/tx_constant_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tx_constant_data.d.ts","sourceRoot":"","sources":["../../src/tx/tx_constant_data.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAwC,MAAM,6BAA6B,CAAC;AAC9G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,qBAAa,cAAc;IAEvB,6GAA6G;IACtG,gBAAgB,EAAE,WAAW;IACpC;;;;;;;OAOG;IACI,SAAS,EAAE,SAAS;IAC3B;;OAEG;IACI,UAAU,EAAE,EAAE;IACrB;;OAEG;IACI,wBAAwB,EAAE,EAAE;;IAlBnC,6GAA6G;IACtG,gBAAgB,EAAE,WAAW;IACpC;;;;;;;OAOG;IACI,SAAS,EAAE,SAAS;IAC3B;;OAEG;IACI,UAAU,EAAE,EAAE;IACrB;;OAEG;IACI,wBAAwB,EAAE,EAAE;IAGrC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC;IAI5C,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC;IAIjD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,cAAc;IAU7D,QAAQ,IAAI,EAAE,EAAE;IAUhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc;IAUhE,QAAQ;IAIR,MAAM,CAAC,KAAK;IAIZ,OAAO;IASP,KAAK,IAAI,cAAc;CAGxB"}
+{"version":3,"file":"tx_constant_data.d.ts","sourceRoot":"","sources":["../../src/tx/tx_constant_data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAsC,MAAM,6BAA6B,CAAC;AACxH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,cAAc;IAEhB,iBAAiB,EAAE,WAAW;IAC9B,SAAS,EAAE,SAAS;IACpB,UAAU,EAAE,EAAE;IACd,qBAAqB,EAAE,EAAE;IAJlC,YACS,iBAAiB,EAAE,WAAW,EAC9B,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,EAAE,EACd,qBAAqB,EAAE,EAAE,EAC9B;IAEJ,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,kBAE3C;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,6CAEhD;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,cAAc,CAQ5D;IAED,QAAQ,IAAI,EAAE,EAAE,CAQf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,CAQ/D;IAED,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAQjC,MAAM,CAAC,KAAK,mBAEX;IAED,OAAO,WAON;IAED,KAAK,IAAI,cAAc,CAEtB;CACF"}

package/dest/tx/tx_constant_data.js

@@ -1,41 +1,32 @@
 import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 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 {
-    historicalHeader;
+    anchorBlockHeader;
     txContext;
     vkTreeRoot;
-    protocolContractTreeRoot;
-    constructor(/** Header of a block whose state is used during execution (not the block the transaction is included in). */ historicalHeader, /**
-     * 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.
-     */ txContext, /**
-     * Root of the vk tree for the protocol circuits.
-     */ vkTreeRoot, /**
-     * Root of the tree for the protocol contracts.
-     */ protocolContractTreeRoot){
-        this.historicalHeader = historicalHeader;
+    protocolContractsHash;
+    constructor(anchorBlockHeader, txContext, vkTreeRoot, protocolContractsHash){
+        this.anchorBlockHeader = anchorBlockHeader;
         this.txContext = txContext;
         this.vkTreeRoot = vkTreeRoot;
-        this.protocolContractTreeRoot = protocolContractTreeRoot;
+        this.protocolContractsHash = protocolContractsHash;
     }
     static from(fields) {
         return new TxConstantData(...TxConstantData.getFields(fields));
     }
     static getFields(fields) {
         return [
-            fields.historicalHeader,
+            fields.anchorBlockHeader,
             fields.txContext,
             fields.vkTreeRoot,
-            fields.protocolContractTreeRoot
+            fields.protocolContractsHash
         ];
     }
     static fromFields(fields) {
@@ -53,14 +44,17 @@ import { TxContext } from './tx_context.js';
         const reader = BufferReader.asReader(buffer);
         return new TxConstantData(reader.readObject(BlockHeader), reader.readObject(TxContext), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
     }
-    toBuffer() {
-        return serializeToBuffer(...TxConstantData.getFields(this));
+    toBuffer(sink) {
+        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.historicalHeader.getSize() + this.txContext.getSize() + this.vkTreeRoot.size + this.protocolContractTreeRoot.size;
+        return this.anchorBlockHeader.getSize() + this.txContext.getSize() + this.vkTreeRoot.size + this.protocolContractsHash.size;
     }
     clone() {
         return TxConstantData.fromBuffer(this.toBuffer());