@aztec/stdlib 0.0.0-test.0

package/dest/tx/tree_snapshots.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */
+export declare class TreeSnapshots {
+    readonly l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    readonly noteHashTree: AppendOnlyTreeSnapshot;
+    readonly nullifierTree: AppendOnlyTreeSnapshot;
+    readonly publicDataTree: AppendOnlyTreeSnapshot;
+    constructor(l1ToL2MessageTree: AppendOnlyTreeSnapshot, noteHashTree: AppendOnlyTreeSnapshot, nullifierTree: AppendOnlyTreeSnapshot, publicDataTree: AppendOnlyTreeSnapshot);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        l1ToL2MessageTree: z.ZodEffects<z.ZodObject<{
+            root: z.ZodType<Fr, any, string>;
+            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>, AppendOnlyTreeSnapshot, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>;
+        noteHashTree: z.ZodEffects<z.ZodObject<{
+            root: z.ZodType<Fr, any, string>;
+            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>, AppendOnlyTreeSnapshot, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>;
+        nullifierTree: z.ZodEffects<z.ZodObject<{
+            root: z.ZodType<Fr, any, string>;
+            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>, AppendOnlyTreeSnapshot, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>;
+        publicDataTree: z.ZodEffects<z.ZodObject<{
+            root: z.ZodType<Fr, any, string>;
+            nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            root: Fr;
+            nextAvailableLeafIndex: number;
+        }, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>, AppendOnlyTreeSnapshot, {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+        noteHashTree: AppendOnlyTreeSnapshot;
+        nullifierTree: AppendOnlyTreeSnapshot;
+        publicDataTree: AppendOnlyTreeSnapshot;
+    }, {
+        l1ToL2MessageTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        noteHashTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        nullifierTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        publicDataTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+    }>, TreeSnapshots, {
+        l1ToL2MessageTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        noteHashTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        nullifierTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+        publicDataTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+    }>;
+    getSize(): number;
+    static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshots;
+    toBuffer(): Buffer;
+    static fromFields(fields: Fr[] | FieldReader): TreeSnapshots;
+    toFields(): Fr[];
+    static empty(): TreeSnapshots;
+    isEmpty(): boolean;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=tree_snapshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_snapshots.d.ts","sourceRoot":"","sources":["../../src/tx/tree_snapshots.ts"],"names":[],"mappings":";;;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,qBAAa,aAAa;aAEN,iBAAiB,EAAE,sBAAsB;aACzC,YAAY,EAAE,sBAAsB;aACpC,aAAa,EAAE,sBAAsB;aACrC,cAAc,EAAE,sBAAsB;gBAHtC,iBAAiB,EAAE,sBAAsB,EACzC,YAAY,EAAE,sBAAsB,EACpC,aAAa,EAAE,sBAAsB,EACrC,cAAc,EAAE,sBAAsB;IAGxD,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAYhB;IAED,OAAO;IASP,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;IAU/D,QAAQ;IAKR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAW5C,QAAQ,IAAI,EAAE,EAAE;IAehB,MAAM,CAAC,KAAK,IAAI,aAAa;IAS7B,OAAO,IAAI,OAAO;IASlB,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}

package/dest/tx/tree_snapshots.js

@@ -0,0 +1,72 @@
+import { TREE_SNAPSHOTS_LENGTH } from '@aztec/constants';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */ export class TreeSnapshots {
+    l1ToL2MessageTree;
+    noteHashTree;
+    nullifierTree;
+    publicDataTree;
+    constructor(l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree){
+        this.l1ToL2MessageTree = l1ToL2MessageTree;
+        this.noteHashTree = noteHashTree;
+        this.nullifierTree = nullifierTree;
+        this.publicDataTree = publicDataTree;
+    }
+    static get schema() {
+        return z.object({
+            l1ToL2MessageTree: AppendOnlyTreeSnapshot.schema,
+            noteHashTree: AppendOnlyTreeSnapshot.schema,
+            nullifierTree: AppendOnlyTreeSnapshot.schema,
+            publicDataTree: AppendOnlyTreeSnapshot.schema
+        }).transform(({ l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree })=>new TreeSnapshots(l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree));
+    }
+    getSize() {
+        return this.l1ToL2MessageTree.getSize() + this.noteHashTree.getSize() + this.nullifierTree.getSize() + this.publicDataTree.getSize();
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new TreeSnapshots(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot));
+    }
+    toBuffer() {
+        // Note: The order here must match the order in the HeaderLib solidity library.
+        return serializeToBuffer(this.l1ToL2MessageTree, this.noteHashTree, this.nullifierTree, this.publicDataTree);
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const l1ToL2MessageTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const noteHashTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const nullifierTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const publicDataTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        return new TreeSnapshots(l1ToL2MessageTree, noteHashTree, nullifierTree, publicDataTree);
+    }
+    toFields() {
+        const fields = [
+            ...this.l1ToL2MessageTree.toFields(),
+            ...this.noteHashTree.toFields(),
+            ...this.nullifierTree.toFields(),
+            ...this.publicDataTree.toFields()
+        ];
+        if (fields.length !== TREE_SNAPSHOTS_LENGTH) {
+            throw new Error(`Invalid number of fields for TreeSnapshots. Expected ${TREE_SNAPSHOTS_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static empty() {
+        return new TreeSnapshots(AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero(), AppendOnlyTreeSnapshot.zero());
+    }
+    isEmpty() {
+        return this.l1ToL2MessageTree.isZero() && this.noteHashTree.isZero() && this.nullifierTree.isZero() && this.publicDataTree.isZero();
+    }
+    [inspect.custom]() {
+        return `TreeSnapshots {
+  l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
+  noteHashTree: ${inspect(this.noteHashTree)},
+  nullifierTree: ${inspect(this.nullifierTree)},
+  publicDataTree: ${inspect(this.publicDataTree)},
+}`;
+    }
+}

package/dest/tx/tx.d.ts

@@ -0,0 +1,174 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer32 } from '@aztec/foundation/buffer';
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+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 { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { Gossipable } from '../p2p/gossipable.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { TxStats } from '../stats/stats.js';
+import { PublicExecutionRequest } from './public_execution_request.js';
+import { TxHash } from './tx_hash.js';
+/**
+ * The interface of an L2 transaction.
+ */
+export declare class Tx extends Gossipable {
+    /**
+     * Output of the private kernel circuit for this tx.
+     */
+    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.
+     *
+     */
+    readonly clientIvcProof: ClientIvcProof;
+    /**
+     * Contract class logs generated by the tx.
+     */
+    contractClassLogs: ContractClassLog[];
+    /**
+     * Enqueued public functions from the private circuit to be run by the sequencer.
+     */
+    readonly enqueuedPublicFunctionCalls: PublicExecutionRequest[];
+    /**
+     * Public function call to be run by the sequencer as part of teardown.
+     */
+    readonly publicTeardownFunctionCall: PublicExecutionRequest;
+    static p2pTopic: string;
+    private txHash;
+    constructor(
+    /**
+     * Output of the private kernel circuit for this tx.
+     */
+    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.
+     *
+     */
+    clientIvcProof: ClientIvcProof, 
+    /**
+     * Contract class logs generated by the tx.
+     */
+    contractClassLogs: ContractClassLog[], 
+    /**
+     * Enqueued public functions from the private circuit to be run by the sequencer.
+     */
+    enqueuedPublicFunctionCalls: PublicExecutionRequest[], 
+    /**
+     * Public function call to be run by the sequencer as part of teardown.
+     */
+    publicTeardownFunctionCall: PublicExecutionRequest);
+    p2pMessageIdentifier(): Promise<Buffer32>;
+    hasPublicCalls(): boolean;
+    getNonRevertiblePublicExecutionRequests(): PublicExecutionRequest[];
+    getRevertiblePublicExecutionRequests(): PublicExecutionRequest[];
+    getPublicTeardownExecutionRequest(): PublicExecutionRequest | undefined;
+    getTotalPublicArgsCount(): number;
+    getGasSettings(): GasSettings;
+    /**
+     * Deserializes the Tx object from a Buffer.
+     * @param buffer - Buffer or BufferReader object to deserialize.
+     * @returns An instance of Tx.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Tx;
+    static newWithTxData(data: PrivateKernelTailCircuitPublicInputs, publicTeardownExecutionRequest?: PublicExecutionRequest): Tx;
+    /**
+     * Serializes the Tx object into a Buffer.
+     * @returns Buffer representation of the Tx object.
+     */
+    toBuffer(): Buffer;
+    static get schema(): ZodFor<Tx>;
+    static from(fields: FieldsOf<Tx>): Tx;
+    /**
+     * 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.
+     */
+    getPublicLogs(logsSource: L2LogsSource): Promise<GetPublicLogsResponse>;
+    /**
+     * 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.
+     * @returns The requested logs.
+     */
+    getSplitContractClassLogs(revertible: boolean, silo?: boolean): Promise<ContractClassLog[]>;
+    /**
+     * 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.
+     */
+    filterContractClassLogs(logHashes: ScopedLogHash[], silo?: boolean): Promise<ContractClassLog[]>;
+    /**
+     * Computes (if necessary) & return transaction hash.
+     * @returns The hash of the public inputs of the private kernel tail circuit.
+     */
+    getTxHash(forceRecompute?: boolean): Promise<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): void;
+    /** Returns stats about this tx. */
+    getStats(): Promise<TxStats>;
+    getSize(): number;
+    /**
+     * 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(): number;
+    /**
+     * Convenience function to get a hash out of a tx or a tx-like.
+     * @param tx - Tx-like object.
+     * @returns - The hash.
+     */
+    static getHash(tx: Tx | HasHash): Promise<TxHash>;
+    /**
+     * 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 getHashes(txs: (Tx | HasHash)[]): Promise<TxHash[]>;
+    /**
+     * Clones a tx, making a deep copy of all fields.
+     * @param tx - The transaction to be cloned.
+     * @returns The cloned transaction.
+     */
+    static clone(tx: Tx): Tx;
+    /**
+     * Creates a random tx.
+     * @param randomProof - Whether to create a random proof - this will be random bytes of the full size.
+     * @returns A random tx.
+     */
+    static random(randomProof?: boolean): Promise<Tx>;
+    /**
+     * 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
+     */
+    filterRevertedLogs(): Promise<void>;
+}
+/** Utility type for an entity that has a hash property for a txhash */
+type HasHash = {
+    hash: TxHash;
+};
+export {};
+//# sourceMappingURL=tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx.d.ts","sourceRoot":"","sources":["../../src/tx/tx.ts"],"names":[],"mappings":"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"}

package/dest/tx/tx.js

@@ -0,0 +1,246 @@
+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 { z } from 'zod';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ContractClassLog } 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 { 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(/**
+     * 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);
+    }
+    // Gossipable method
+    async p2pMessageIdentifier() {
+        return new Buffer32((await this.getTxHash()).toBuffer());
+    }
+    hasPublicCalls() {
+        return this.data.numberOfPublicCallRequests() > 0;
+    }
+    getNonRevertiblePublicExecutionRequests() {
+        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
+        return this.enqueuedPublicFunctionCalls.slice(numRevertible);
+    }
+    getRevertiblePublicExecutionRequests() {
+        const numRevertible = this.data.numberOfRevertiblePublicCallRequests();
+        return this.enqueuedPublicFunctionCalls.slice(0, numRevertible);
+    }
+    getPublicTeardownExecutionRequest() {
+        return this.publicTeardownFunctionCall.isEmpty() ? undefined : this.publicTeardownFunctionCall;
+    }
+    getTotalPublicArgsCount() {
+        let count = this.enqueuedPublicFunctionCalls.reduce((acc, execRequest)=>acc + execRequest.args.length, 0);
+        if (!this.publicTeardownFunctionCall.isEmpty()) {
+            count += this.publicTeardownFunctionCall.args.length;
+        }
+        return count;
+    }
+    getGasSettings() {
+        return this.data.constants.txContext.gasSettings;
+    }
+    /**
+   * Deserializes the Tx object from a Buffer.
+   * @param buffer - Buffer or BufferReader object to deserialize.
+   * @returns An instance of Tx.
+   */ static fromBuffer(buffer) {
+        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());
+    }
+    /**
+   * 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
+        ]);
+    }
+    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);
+    }
+    static from(fields) {
+        return new Tx(fields.data, fields.clientIvcProof, fields.contractClassLogs, fields.enqueuedPublicFunctionCalls, fields.publicTeardownFunctionCall);
+    }
+    /**
+   * 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()
+        });
+    }
+    /**
+   * 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.
+   * @returns The requested logs.
+   */ async getSplitContractClassLogs(revertible, silo = false) {
+        // Should only be called on txs with public calls
+        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);
+            }
+        }
+        return contractClassLogs;
+    }
+    /**
+   * Computes (if necessary) & 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);
+        }
+        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() {
+        return {
+            txHash: (await this.getTxHash()).toString(),
+            noteHashCount: this.data.getNonEmptyNoteHashes().length,
+            nullifierCount: this.data.getNonEmptyNullifiers().length,
+            privateLogCount: this.data.getNonEmptyPrivateLogs().length,
+            classRegisteredCount: this.data.getNonEmptyContractClassLogsHashes().length,
+            contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
+            proofSize: this.clientIvcProof.clientIvcProofBuffer.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'
+        };
+    }
+    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();
+    }
+    /**
+   * 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()));
+        }
+        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());
+    }
+    /**
+   * 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);
+    }
+}
+function hasHash(tx) {
+    return tx.hash !== undefined;
+}