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

package/dest/tx/tx.js

@@ -4,66 +4,69 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
 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';
 /**
  * The interface of an L2 transaction.
  */ export class Tx extends Gossipable {
-    data;
-    clientIvcProof;
-    contractClassLogs;
-    enqueuedPublicFunctionCalls;
-    publicTeardownFunctionCall;
-    static p2pTopic;
-    // For memoization
     txHash;
-    constructor(/**
+    data;
+    chonkProof;
+    contractClassLogFields;
+    publicFunctionCalldata;
+    static p2pTopic = TopicType.tx;
+    calldataMap;
+    constructor(/** Identifier of the tx */ 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;
+     */ chonkProof, /**
+     * Contract class log fields emitted from the tx.
+     * Their order should match the order of the log hashes returned from `this.data.getNonEmptyContractClassLogsHashes`.
+     * It's checked in data_validator.ts
+     */ contractClassLogFields, /**
+     * An array of calldata for the enqueued public function calls and the teardown function call.
+     */ publicFunctionCalldata){
+        super(), this.txHash = txHash, this.data = data, this.chonkProof = chonkProof, this.contractClassLogFields = contractClassLogFields, this.publicFunctionCalldata = publicFunctionCalldata;
     }
     // Gossipable method
-    static{
-        this.p2pTopic = createTopicString(TopicType.tx);
-    }
-    // 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,108 +77,109 @@ 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.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)
         ]);
     }
     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);
+    }
+    /**
+   * 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);
     }
     /**
    * 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) {
+   */ getPublicLogs(logsSource) {
         return logsSource.getPublicLogs({
-            txHash: await this.getTxHash()
+            txHash: this.getTxHash()
         });
     }
+    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 [];
-        }
-        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, 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);
-            }
+            throw new Error('`getSplitContractClassLogs` should only be called on txs with public calls');
         }
-        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) {
-        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,
+            proofSize: this.chonkProof.fields.length,
             size: this.toBuffer().length,
             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'
         };
     }
     getSize() {
-        return this.data.getSize() + this.clientIvcProof.clientIvcProofBuffer.length + arraySerializedSizeOfNonEmpty(this.contractClassLogs) + arraySerializedSizeOfNonEmpty(this.enqueuedPublicFunctionCalls) + arraySerializedSizeOfNonEmpty([
-            this.publicTeardownFunctionCall
-        ]);
+        return this.data.getSize() + this.chonkProof.fields.length * Fr.SIZE_IN_BYTES + arraySerializedSizeOfNonEmpty(this.contractClassLogFields) + this.publicFunctionCalldata.reduce((accum, cd)=>accum + cd.getSize(), 0);
     }
     /**
    * Estimates the tx size based on its private effects. Note that the actual size of the tx
@@ -184,63 +188,58 @@ import { TxHash } from './tx_hash.js';
         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();
-    }
-    /**
-   * 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));
-    }
-    /**
    * Clones a tx, making a deep copy of all fields.
    * @param tx - The transaction to be cloned.
    * @returns The cloned transaction.
    */ static clone(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 = ChonkProof.fromBuffer(tx.chonkProof.toBuffer());
+        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;
     }
     /**
    * 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() {
+        this.txHash = await Tx.computeTxHash(this);
+    }
+    #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) {
+        try {
+            const reader = BufferReader.asReader(buffer);
+            const txs = reader.readVector(Tx);
+            return new TxArray(...txs);
+        } catch  {
+            return new TxArray();
+        }
+    }
+    toBuffer() {
+        return serializeArrayOfBufferableToVector(this);
+    }
 }

package/dest/tx/tx_constant_data.d.ts

@@ -1,59 +1,25 @@
-/// <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 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(): Buffer<ArrayBufferLike>;
     static empty(): TxConstantData;
     getSize(): number;
     clone(): TxConstantData;

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,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;;;;GAIG;AACH,qBAAa,cAAc;IAEhB,iBAAiB,EAAE,WAAW;IAC9B,SAAS,EAAE,SAAS;IACpB,UAAU,EAAE,EAAE;IACd,qBAAqB,EAAE,EAAE;gBAHzB,iBAAiB,EAAE,WAAW,EAC9B,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,EAAE,EACd,qBAAqB,EAAE,EAAE;IAGlC,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"}

package/dest/tx/tx_constant_data.js

@@ -4,38 +4,29 @@ import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from
 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) {
@@ -60,7 +51,7 @@ import { TxContext } from './tx_context.js';
         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());

package/dest/tx/tx_context.d.ts

@@ -1,5 +1,3 @@
-/// <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 type { FieldsOf } from '@aztec/foundation/types';
@@ -51,30 +49,30 @@ export declare class TxContext {
                 l2Gas: string | number | bigint;
             }>;
             maxFeesPerGas: z.ZodEffects<z.ZodObject<{
-                feePerDaGas: z.ZodType<Fr, any, string>;
-                feePerL2Gas: z.ZodType<Fr, any, string>;
+                feePerDaGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                feePerL2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
             }, "strip", z.ZodTypeAny, {
-                feePerDaGas: Fr;
-                feePerL2Gas: Fr;
+                feePerDaGas: bigint;
+                feePerL2Gas: bigint;
             }, {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             }>, import("../gas/gas_fees.js").GasFees, {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             }>;
             maxPriorityFeesPerGas: z.ZodEffects<z.ZodObject<{
-                feePerDaGas: z.ZodType<Fr, any, string>;
-                feePerL2Gas: z.ZodType<Fr, any, string>;
+                feePerDaGas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+                feePerL2Gas: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
             }, "strip", z.ZodTypeAny, {
-                feePerDaGas: Fr;
-                feePerL2Gas: Fr;
+                feePerDaGas: bigint;
+                feePerL2Gas: bigint;
             }, {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             }>, import("../gas/gas_fees.js").GasFees, {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             }>;
         }, "strip", z.ZodTypeAny, {
             gasLimits: import("../gas/gas.js").Gas;
@@ -91,12 +89,12 @@ export declare class TxContext {
                 l2Gas: string | number | bigint;
             };
             maxFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
             maxPriorityFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
         }>, GasSettings, {
             gasLimits: {
@@ -108,12 +106,12 @@ export declare class TxContext {
                 l2Gas: string | number | bigint;
             };
             maxFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
             maxPriorityFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
         }>;
     }, "strip", z.ZodTypeAny, {
@@ -133,12 +131,12 @@ export declare class TxContext {
                 l2Gas: string | number | bigint;
             };
             maxFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
             maxPriorityFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
         };
     }>, TxContext, {
@@ -154,12 +152,12 @@ export declare class TxContext {
                 l2Gas: string | number | bigint;
             };
             maxFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
             maxPriorityFeesPerGas: {
-                feePerDaGas: string;
-                feePerL2Gas: string;
+                feePerDaGas: string | number | bigint;
+                feePerL2Gas: string | number | bigint;
             };
         };
     }>;
@@ -169,7 +167,7 @@ export declare class TxContext {
      * Serialize as a buffer.
      * @returns The buffer.
      */
-    toBuffer(): Buffer;
+    toBuffer(): Buffer<ArrayBufferLike>;
     static fromFields(fields: Fr[] | FieldReader): TxContext;
     toFields(): Fr[];
     /**