@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/tx/public_execution_request.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { inspect } from 'util';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { type ZodFor } from '../schemas/index.js';
+import { CallContext } from './call_context.js';
+/**
+ * The execution request of a public function.
+ */
+export declare class PublicExecutionRequest {
+    /**
+     * Context of the public call.
+     */
+    callContext: CallContext;
+    /**
+     * Function arguments.
+     */
+    args: Fr[];
+    constructor(
+    /**
+     * Context of the public call.
+     */
+    callContext: CallContext, 
+    /**
+     * Function arguments.
+     */
+    args: Fr[]);
+    getSize(): number;
+    toBuffer(): Buffer;
+    static get schema(): ZodFor<PublicExecutionRequest>;
+    static fromBuffer(buffer: Buffer | BufferReader): PublicExecutionRequest;
+    static from(fields: FieldsOf<PublicExecutionRequest>): PublicExecutionRequest;
+    static getFields(fields: FieldsOf<PublicExecutionRequest>): readonly [CallContext, Fr[]];
+    static empty(): PublicExecutionRequest;
+    static random(): Promise<PublicExecutionRequest>;
+    isEmpty(): boolean;
+    isForCallRequest(callRequest: PublicCallRequest): Promise<boolean>;
+    toCallRequest(): Promise<PublicCallRequest>;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=public_execution_request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_execution_request.d.ts","sourceRoot":"","sources":["../../src/tx/public_execution_request.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAI/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;GAEG;AACH,qBAAa,sBAAsB;IAE/B;;OAEG;IACI,WAAW,EAAE,WAAW;IAC/B;;OAEG;IACI,IAAI,EAAE,EAAE,EAAE;;IAPjB;;OAEG;IACI,WAAW,EAAE,WAAW;IAC/B;;OAEG;IACI,IAAI,EAAE,EAAE,EAAE;IAGnB,OAAO;IAIP,QAAQ;IAIR,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAOlD;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC,GAAG,sBAAsB;IAI7E,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC;IAIzD,MAAM,CAAC,KAAK;WAIC,MAAM;IAInB,OAAO,IAAI,OAAO;IAIZ,gBAAgB,CAAC,WAAW,EAAE,iBAAiB;IAU/C,aAAa,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAUjD,CAAC,OAAO,CAAC,MAAM,CAAC;CAMjB"}

package/dest/tx/public_execution_request.js

@@ -0,0 +1,72 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { computeVarArgsHash } from '../hash/index.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/index.js';
+import { CallContext } from './call_context.js';
+/**
+ * The execution request of a public function.
+ */ export class PublicExecutionRequest {
+    callContext;
+    args;
+    constructor(/**
+     * Context of the public call.
+     */ callContext, /**
+     * Function arguments.
+     */ args){
+        this.callContext = callContext;
+        this.args = args;
+    }
+    getSize() {
+        return this.isEmpty() ? 0 : this.toBuffer().length;
+    }
+    toBuffer() {
+        return serializeToBuffer(this.callContext, new Vector(this.args));
+    }
+    static get schema() {
+        return z.object({
+            callContext: CallContext.schema,
+            args: z.array(schemas.Fr)
+        }).transform(PublicExecutionRequest.from);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicExecutionRequest(CallContext.fromBuffer(reader), reader.readVector(Fr));
+    }
+    static from(fields) {
+        return new PublicExecutionRequest(...PublicExecutionRequest.getFields(fields));
+    }
+    static getFields(fields) {
+        return [
+            fields.callContext,
+            fields.args
+        ];
+    }
+    static empty() {
+        return new PublicExecutionRequest(CallContext.empty(), []);
+    }
+    static async random() {
+        return new PublicExecutionRequest(await CallContext.random(), [
+            Fr.random(),
+            Fr.random()
+        ]);
+    }
+    isEmpty() {
+        return this.callContext.isEmpty() && this.args.length === 0;
+    }
+    async isForCallRequest(callRequest) {
+        return this.callContext.msgSender.equals(callRequest.msgSender) && this.callContext.contractAddress.equals(callRequest.contractAddress) && this.callContext.functionSelector.equals(callRequest.functionSelector) && this.callContext.isStaticCall == callRequest.isStaticCall && (await computeVarArgsHash(this.args)).equals(callRequest.argsHash);
+    }
+    async toCallRequest() {
+        return new PublicCallRequest(this.callContext.msgSender, this.callContext.contractAddress, this.callContext.functionSelector, this.callContext.isStaticCall, await computeVarArgsHash(this.args));
+    }
+    [inspect.custom]() {
+        return `PublicExecutionRequest {
+      callContext: ${inspect(this.callContext)}
+      args: ${this.args}
+    }`;
+    }
+}

package/dest/tx/public_simulation_output.d.ts

@@ -0,0 +1,31 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { SimulationError } from '../errors/simulation_error.js';
+import type { GasUsed } from '../gas/gas_used.js';
+import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import { TxEffect } from '../tx/tx_effect.js';
+/** Return values of simulating a circuit. */
+export type ProcessReturnValues = Fr[] | undefined;
+/** Return values of simulating complete callstack. */
+export declare class NestedProcessReturnValues {
+    values: ProcessReturnValues;
+    nested: NestedProcessReturnValues[];
+    constructor(values: ProcessReturnValues, nested?: NestedProcessReturnValues[]);
+    static get schema(): ZodFor<NestedProcessReturnValues>;
+    static empty(): NestedProcessReturnValues;
+    static random(depth?: number): NestedProcessReturnValues;
+}
+/**
+ * Outputs of processing the public component of a transaction.
+ */
+export declare class PublicSimulationOutput {
+    revertReason: SimulationError | undefined;
+    constants: CombinedConstantData;
+    txEffect: TxEffect;
+    publicReturnValues: NestedProcessReturnValues[];
+    gasUsed: GasUsed;
+    constructor(revertReason: SimulationError | undefined, constants: CombinedConstantData, txEffect: TxEffect, publicReturnValues: NestedProcessReturnValues[], gasUsed: GasUsed);
+    static get schema(): ZodFor<PublicSimulationOutput>;
+    static random(): Promise<PublicSimulationOutput>;
+}
+//# sourceMappingURL=public_simulation_output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_simulation_output.d.ts","sourceRoot":"","sources":["../../src/tx/public_simulation_output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,EAAE,EAAE,GAAG,SAAS,CAAC;AAEnD,sDAAsD;AACtD,qBAAa,yBAAyB;IACpC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,yBAAyB,EAAE,CAAC;gBAExB,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,yBAAyB,EAAE;IAK7E,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,yBAAyB,CAAC,CAOrD;IAED,MAAM,CAAC,KAAK;IAIZ,MAAM,CAAC,MAAM,CAAC,KAAK,SAAI,GAAG,yBAAyB;CAMpD;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAExB,YAAY,EAAE,eAAe,GAAG,SAAS;IACzC,SAAS,EAAE,oBAAoB;IAC/B,QAAQ,EAAE,QAAQ;IAClB,kBAAkB,EAAE,yBAAyB,EAAE;IAC/C,OAAO,EAAE,OAAO;gBAJhB,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,SAAS,EAAE,oBAAoB,EAC/B,QAAQ,EAAE,QAAQ,EAClB,kBAAkB,EAAE,yBAAyB,EAAE,EAC/C,OAAO,EAAE,OAAO;IAGzB,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAwBlD;WAEY,MAAM;CASpB"}

package/dest/tx/public_simulation_output.js

@@ -0,0 +1,68 @@
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import times from 'lodash.times';
+import { z } from 'zod';
+import { SimulationError } from '../errors/simulation_error.js';
+import { Gas } from '../gas/gas.js';
+import { CombinedConstantData } from '../kernel/combined_constant_data.js';
+import { TxEffect } from '../tx/tx_effect.js';
+/** Return values of simulating complete callstack. */ export class NestedProcessReturnValues {
+    values;
+    nested;
+    constructor(values, nested){
+        this.values = values;
+        this.nested = nested ?? [];
+    }
+    static get schema() {
+        return z.object({
+            values: z.array(schemas.Fr).optional(),
+            nested: z.array(z.lazy(()=>NestedProcessReturnValues.schema))
+        }).transform(({ values, nested })=>new NestedProcessReturnValues(values, nested));
+    }
+    static empty() {
+        return new NestedProcessReturnValues([]);
+    }
+    static random(depth = 1) {
+        return new NestedProcessReturnValues(times(3, Fr.random), depth > 0 ? [
+            NestedProcessReturnValues.random(depth - 1)
+        ] : []);
+    }
+}
+/**
+ * Outputs of processing the public component of a transaction.
+ */ export class PublicSimulationOutput {
+    revertReason;
+    constants;
+    txEffect;
+    publicReturnValues;
+    gasUsed;
+    constructor(revertReason, constants, txEffect, publicReturnValues, gasUsed){
+        this.revertReason = revertReason;
+        this.constants = constants;
+        this.txEffect = txEffect;
+        this.publicReturnValues = publicReturnValues;
+        this.gasUsed = gasUsed;
+    }
+    static get schema() {
+        return z.object({
+            revertReason: SimulationError.schema.optional(),
+            constants: CombinedConstantData.schema,
+            txEffect: TxEffect.schema,
+            publicReturnValues: z.array(NestedProcessReturnValues.schema),
+            gasUsed: z.object({
+                totalGas: Gas.schema,
+                teardownGas: Gas.schema,
+                publicGas: Gas.schema,
+                billedGas: Gas.schema
+            })
+        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.constants, fields.txEffect, fields.publicReturnValues, fields.gasUsed));
+    }
+    static async random() {
+        return new PublicSimulationOutput(await SimulationError.random(), CombinedConstantData.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
+            teardownGas: Gas.random(),
+            totalGas: Gas.random(),
+            publicGas: Gas.random(),
+            billedGas: Gas.random()
+        });
+    }
+}

package/dest/tx/simulated_tx.d.ts

@@ -0,0 +1,72 @@
+import type { ZodFor } from '@aztec/foundation/schemas';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import type { GasUsed } from '../gas/gas_used.js';
+import { type PrivateKernelProverProfileResult } from '../kernel/private_kernel_prover_profile_result.js';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { PrivateExecutionResult } from './private_execution_result.js';
+import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
+import { Tx } from './tx.js';
+export declare class PrivateSimulationResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs);
+    getPrivateReturnValues(): NestedProcessReturnValues;
+    toSimulatedTx(): Tx;
+}
+export declare class TxSimulationResult extends PrivateSimulationResult {
+    publicOutput?: PublicSimulationOutput | undefined;
+    profileResult?: {
+        gateCounts: {
+            circuitName: string;
+            gateCount: number;
+        }[];
+    } | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, publicOutput?: PublicSimulationOutput | undefined, profileResult?: {
+        gateCounts: {
+            circuitName: string;
+            gateCount: number;
+        }[];
+    } | undefined);
+    get gasUsed(): GasUsed;
+    static get schema(): ZodFor<TxSimulationResult>;
+    static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>): TxSimulationResult;
+    getPublicReturnValues(): NestedProcessReturnValues[];
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult: PrivateSimulationResult, publicOutput?: PublicSimulationOutput, profileResult?: PrivateKernelProverProfileResult): TxSimulationResult;
+    static random(): Promise<TxSimulationResult>;
+}
+export declare class TxProvingResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    clientIvcProof: ClientIvcProof;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, clientIvcProof: ClientIvcProof);
+    toTx(): Tx;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        privateExecutionResult: ZodFor<PrivateExecutionResult>;
+        publicInputs: z.ZodType<PrivateKernelTailCircuitPublicInputs, any, string>;
+        clientIvcProof: z.ZodType<ClientIvcProof, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        publicInputs: PrivateKernelTailCircuitPublicInputs;
+        clientIvcProof: ClientIvcProof;
+        privateExecutionResult: PrivateExecutionResult;
+    }, {
+        publicInputs: string;
+        clientIvcProof: string;
+        privateExecutionResult?: any;
+    }>, TxProvingResult, {
+        publicInputs: string;
+        clientIvcProof: string;
+        privateExecutionResult?: any;
+    }>;
+    static from(fields: FieldsOf<TxProvingResult>): TxProvingResult;
+    static random(): Promise<TxProvingResult>;
+}
+/**
+ * Recursively accummulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */
+export declare function accumulatePrivateReturnValues(executionResult: PrivateExecutionResult): NestedProcessReturnValues;
+//# sourceMappingURL=simulated_tx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EACL,KAAK,gCAAgC,EAEtC,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAC9G,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAEL,sBAAsB,EAIvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAClG,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,qBAAa,uBAAuB;IAEzB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;gBADlD,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC;IAG3D,sBAAsB;IAItB,aAAa,IAAI,EAAE;CAcpB;AAED,qBAAa,kBAAmB,SAAQ,uBAAuB;IAIpD,YAAY,CAAC;IACb,aAAa,CAAC;;;;;;gBAHrB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAC3C,YAAY,CAAC,oCAAwB,EACrC,aAAa,CAAC;;;;;iBAAkC;IAKzD,IAAI,OAAO,IAAI,OAAO,CASrB;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAS9C;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,CAAC;IASjE,qBAAqB;IAIrB,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,aAAa,CAAC,EAAE,gCAAgC;WAUrC,MAAM;CAOpB;AAED,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,cAAc,EAAE,cAAc;gBAF9B,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,cAAc,EAAE,cAAc;IAGvC,IAAI,IAAI,EAAE;IAeV,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAQhB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;WAIhC,MAAM;CAOpB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}

package/dest/tx/simulated_tx.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { Gas } from '../gas/gas.js';
+import { PrivateKernelProverProfileResultSchema } from '../kernel/private_kernel_prover_profile_result.js';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { PrivateExecutionResult, collectEnqueuedPublicFunctionCalls, collectPublicTeardownFunctionCall, collectSortedContractClassLogs } from './private_execution_result.js';
+import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
+import { Tx } from './tx.js';
+export class PrivateSimulationResult {
+    privateExecutionResult;
+    publicInputs;
+    constructor(privateExecutionResult, publicInputs){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+    }
+    getPrivateReturnValues() {
+        return accumulatePrivateReturnValues(this.privateExecutionResult);
+    }
+    toSimulatedTx() {
+        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+        const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
+        const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
+        const tx = new Tx(this.publicInputs, ClientIvcProof.empty(), contractClassLogs, enqueuedPublicFunctions, teardownPublicFunction);
+        return tx;
+    }
+}
+export class TxSimulationResult extends PrivateSimulationResult {
+    publicOutput;
+    profileResult;
+    constructor(privateExecutionResult, publicInputs, publicOutput, profileResult){
+        super(privateExecutionResult, publicInputs), this.publicOutput = publicOutput, this.profileResult = profileResult;
+    }
+    get gasUsed() {
+        return this.publicOutput?.gasUsed ?? {
+            totalGas: this.publicInputs.gasUsed,
+            billedGas: this.publicInputs.gasUsed,
+            teardownGas: Gas.empty(),
+            publicGas: Gas.empty()
+        };
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            publicOutput: PublicSimulationOutput.schema.optional(),
+            profileResult: PrivateKernelProverProfileResultSchema.optional()
+        }).transform(TxSimulationResult.from);
+    }
+    static from(fields) {
+        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.profileResult);
+    }
+    getPublicReturnValues() {
+        return this.publicOutput ? this.publicOutput.publicReturnValues : [];
+    }
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, profileResult) {
+        return new TxSimulationResult(privateSimulationResult.privateExecutionResult, privateSimulationResult.publicInputs, publicOutput, profileResult);
+    }
+    static async random() {
+        return new TxSimulationResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), await PublicSimulationOutput.random());
+    }
+}
+export class TxProvingResult {
+    privateExecutionResult;
+    publicInputs;
+    clientIvcProof;
+    constructor(privateExecutionResult, publicInputs, clientIvcProof){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+        this.clientIvcProof = clientIvcProof;
+    }
+    toTx() {
+        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+        const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(this.privateExecutionResult);
+        const teardownPublicFunction = collectPublicTeardownFunctionCall(this.privateExecutionResult);
+        const tx = new Tx(this.publicInputs, this.clientIvcProof, contractClassLogs, enqueuedPublicFunctions, teardownPublicFunction);
+        return tx;
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            clientIvcProof: ClientIvcProof.schema
+        }).transform(TxProvingResult.from);
+    }
+    static from(fields) {
+        return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.clientIvcProof);
+    }
+    static async random() {
+        return new TxProvingResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), ClientIvcProof.empty());
+    }
+}
+/**
+ * Recursively accummulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */ export function accumulatePrivateReturnValues(executionResult) {
+    const collectPrivateReturnValuesRecursive = (executionResult)=>{
+        const acc = new NestedProcessReturnValues(executionResult.returnValues);
+        acc.nested = executionResult.nestedExecutions.map((nestedExecution)=>collectPrivateReturnValuesRecursive(nestedExecution));
+        return acc;
+    };
+    return collectPrivateReturnValuesRecursive(executionResult.entrypoint);
+}

package/dest/tx/state_reference.d.ts

@@ -0,0 +1,166 @@
+/// <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';
+import { PartialStateReference } from './partial_state_reference.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */
+export declare class StateReference {
+    /** Snapshot of the l1 to l2 message tree. */
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    /** Reference to the rest of the state. */
+    partial: PartialStateReference;
+    constructor(
+    /** Snapshot of the l1 to l2 message tree. */
+    l1ToL2MessageTree: AppendOnlyTreeSnapshot, 
+    /** Reference to the rest of the state. */
+    partial: PartialStateReference);
+    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;
+        }>;
+        partial: z.ZodEffects<z.ZodObject<{
+            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, {
+            noteHashTree: AppendOnlyTreeSnapshot;
+            nullifierTree: AppendOnlyTreeSnapshot;
+            publicDataTree: AppendOnlyTreeSnapshot;
+        }, {
+            noteHashTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            nullifierTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            publicDataTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        }>, PartialStateReference, {
+            noteHashTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            nullifierTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            publicDataTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        partial: PartialStateReference;
+        l1ToL2MessageTree: AppendOnlyTreeSnapshot;
+    }, {
+        partial: {
+            noteHashTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            nullifierTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            publicDataTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        };
+        l1ToL2MessageTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+    }>, StateReference, {
+        partial: {
+            noteHashTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            nullifierTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+            publicDataTree: {
+                root: string;
+                nextAvailableLeafIndex: string | number | bigint;
+            };
+        };
+        l1ToL2MessageTree: {
+            root: string;
+            nextAvailableLeafIndex: string | number | bigint;
+        };
+    }>;
+    getSize(): number;
+    toBuffer(): Buffer;
+    toFields(): Fr[];
+    static fromBuffer(buffer: Buffer | BufferReader): StateReference;
+    static fromFields(fields: Fr[] | FieldReader): StateReference;
+    static empty(): StateReference;
+    isEmpty(): boolean;
+    toInspect(): {
+        l1ToL2MessageTree: `0x${string}`;
+        noteHashTree: `0x${string}`;
+        nullifierTree: `0x${string}`;
+        publicDataTree: `0x${string}`;
+    };
+    [inspect.custom](): string;
+    equals(other: this): boolean;
+}
+//# sourceMappingURL=state_reference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"state_reference.d.ts","sourceRoot":"","sources":["../../src/tx/state_reference.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;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,qBAAa,cAAc;IAEvB,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB;;IAHrC,6CAA6C;IACtC,iBAAiB,EAAE,sBAAsB;IAChD,0CAA0C;IACnC,OAAO,EAAE,qBAAqB;IAGvC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAOhB;IAED,OAAO;IAIP,QAAQ;IAKR,QAAQ,IAAI,EAAE,EAAE;IAUhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc;IAKhE,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,cAAc;IAS7D,MAAM,CAAC,KAAK,IAAI,cAAc;IAI9B,OAAO,IAAI,OAAO;IAIlB,SAAS;;;;;;IAST,CAAC,OAAO,CAAC,MAAM,CAAC;IAST,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;CAGpC"}

package/dest/tx/state_reference.js

@@ -0,0 +1,74 @@
+import { STATE_REFERENCE_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';
+import { PartialStateReference } from './partial_state_reference.js';
+/**
+ * Stores snapshots of all the trees but archive.
+ */ export class StateReference {
+    l1ToL2MessageTree;
+    partial;
+    constructor(/** Snapshot of the l1 to l2 message tree. */ l1ToL2MessageTree, /** Reference to the rest of the state. */ partial){
+        this.l1ToL2MessageTree = l1ToL2MessageTree;
+        this.partial = partial;
+    }
+    static get schema() {
+        return z.object({
+            l1ToL2MessageTree: AppendOnlyTreeSnapshot.schema,
+            partial: PartialStateReference.schema
+        }).transform(({ l1ToL2MessageTree, partial })=>new StateReference(l1ToL2MessageTree, partial));
+    }
+    getSize() {
+        return this.l1ToL2MessageTree.getSize() + this.partial.getSize();
+    }
+    toBuffer() {
+        // Note: The order here must match the order in the HeaderLib solidity library.
+        return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
+    }
+    toFields() {
+        const fields = [
+            ...this.l1ToL2MessageTree.toFields(),
+            ...this.partial.toFields()
+        ];
+        if (fields.length !== STATE_REFERENCE_LENGTH) {
+            throw new Error(`Invalid number of fields for StateReference. Expected ${STATE_REFERENCE_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new StateReference(reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(PartialStateReference));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        const l1ToL2MessageTree = AppendOnlyTreeSnapshot.fromFields(reader);
+        const partial = PartialStateReference.fromFields(reader);
+        return new StateReference(l1ToL2MessageTree, partial);
+    }
+    static empty() {
+        return new StateReference(AppendOnlyTreeSnapshot.zero(), PartialStateReference.empty());
+    }
+    isEmpty() {
+        return this.l1ToL2MessageTree.isZero() && this.partial.isEmpty();
+    }
+    toInspect() {
+        return {
+            l1ToL2MessageTree: this.l1ToL2MessageTree.root.toString(),
+            noteHashTree: this.partial.noteHashTree.root.toString(),
+            nullifierTree: this.partial.nullifierTree.root.toString(),
+            publicDataTree: this.partial.publicDataTree.root.toString()
+        };
+    }
+    [inspect.custom]() {
+        return `StateReference {
+  l1ToL2MessageTree: ${inspect(this.l1ToL2MessageTree)},
+  noteHashTree: ${inspect(this.partial.noteHashTree)},
+  nullifierTree: ${inspect(this.partial.nullifierTree)},
+  publicDataTree: ${inspect(this.partial.publicDataTree)},
+}`;
+    }
+    equals(other) {
+        return this.l1ToL2MessageTree.root.equals(other.l1ToL2MessageTree.root) && this.partial.equals(other.partial);
+    }
+}