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

package/dest/tx/profiling.js

@@ -0,0 +1,130 @@
+import { Fr } from '@aztec/foundation/fields';
+import { optional, schemas } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+const NodeStatsSchema = z.record(z.string(), z.object({
+    times: z.array(z.number())
+}));
+const FunctionTimingSchema = z.object({
+    functionName: z.string(),
+    time: z.number(),
+    oracles: optional(z.record(z.string(), z.object({
+        times: z.array(z.number())
+    })))
+});
+export const ProvingTimingsSchema = z.object({
+    sync: optional(z.number()),
+    proving: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const ProvingStatsSchema = z.object({
+    timings: ProvingTimingsSchema,
+    nodeRPCCalls: optional(NodeStatsSchema)
+});
+export const SimulationTimingsSchema = z.object({
+    sync: z.number(),
+    publicSimulation: optional(z.number()),
+    validation: optional(z.number()),
+    perFunction: z.array(FunctionTimingSchema),
+    unaccounted: z.number(),
+    total: z.number()
+});
+export const SimulationStatsSchema = z.object({
+    timings: SimulationTimingsSchema,
+    nodeRPCCalls: NodeStatsSchema
+});
+export class TxProfileResult {
+    executionSteps;
+    stats;
+    constructor(executionSteps, stats){
+        this.executionSteps = executionSteps;
+        this.stats = stats;
+    }
+    static get schema() {
+        return z.object({
+            executionSteps: z.array(PrivateExecutionStepSchema),
+            stats: ProvingStatsSchema
+        }).transform(({ executionSteps, stats })=>new TxProfileResult(executionSteps, stats));
+    }
+    static random() {
+        return new TxProfileResult([
+            {
+                functionName: 'random',
+                bytecode: Buffer.from('random'),
+                witness: new Map([
+                    [
+                        1,
+                        'random'
+                    ]
+                ]),
+                vk: Buffer.from('random'),
+                timings: {
+                    witgen: 1,
+                    gateCount: 1
+                }
+            }
+        ], {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                proving: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 4
+            }
+        });
+    }
+}
+export class UtilitySimulationResult {
+    result;
+    stats;
+    constructor(result, stats){
+        this.result = result;
+        this.stats = stats;
+    }
+    static get schema() {
+        return z.object({
+            result: z.array(schemas.Fr),
+            stats: optional(SimulationStatsSchema)
+        }).transform(({ result, stats })=>new UtilitySimulationResult(result, stats));
+    }
+    static random() {
+        return new UtilitySimulationResult([
+            Fr.random()
+        ], {
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
+                }
+            },
+            timings: {
+                sync: 1,
+                publicSimulation: 1,
+                validation: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 5
+            }
+        });
+    }
+}

package/dest/tx/protocol_contracts.d.ts

@@ -0,0 +1,37 @@
+import { MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, type Tuple } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export declare class ProtocolContracts {
+    derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>;
+    constructor(derivedAddresses: Tuple<AztecAddress, typeof MAX_PROTOCOL_CONTRACTS>);
+    static from(fields: FieldsOf<ProtocolContracts>): ProtocolContracts;
+    static getFields(fields: FieldsOf<ProtocolContracts>): readonly [[AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress, AztecAddress]];
+    static fromFields(fields: Fr[] | FieldReader): ProtocolContracts;
+    toFields(): Fr[];
+    static fromBuffer(buffer: Buffer | BufferReader): ProtocolContracts;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static empty(): ProtocolContracts;
+    /**
+     * Creates a ProtocolContracts instance from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing ProtocolContracts fields
+     * @returns A ProtocolContracts instance
+     */
+    static fromPlainObject(obj: any): ProtocolContracts;
+    getSize(): number;
+    hash(): Promise<Fr>;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        derivedAddresses: z.ZodArray<import("../schemas/schemas.js").ZodFor<AztecAddress>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        derivedAddresses: AztecAddress[];
+    }, {
+        derivedAddresses: any[];
+    }>, ProtocolContracts, {
+        derivedAddresses: any[];
+    }>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2xfY29udHJhY3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHJvdG9jb2xfY29udHJhY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBa0Isc0JBQXNCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUkxRSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDOUMsT0FBTyxFQUNMLFlBQVksRUFDWixXQUFXLEVBQ1gsS0FBSyxLQUFLLEVBSVgsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV6RCxxQkFBYSxpQkFBaUI7SUFDVCxnQkFBZ0IsRUFBRSxLQUFLLENBQUMsWUFBWSxFQUFFLE9BQU8sc0JBQXNCLENBQUM7SUFBdkYsWUFBbUIsZ0JBQWdCLEVBQUUsS0FBSyxDQUFDLFlBQVksRUFBRSxPQUFPLHNCQUFzQixDQUFDLEVBQUk7SUFFM0YsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLHFCQUU5QztJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyx5S0FFbkQ7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLEdBQUcsaUJBQWlCLENBRy9EO0lBRUQsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQUVmO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxpQkFBaUIsQ0FHbEU7SUFFRCxRQUFRLDRCQUVQO0lBRUQsTUFBTSxDQUFDLEtBQUssc0JBRVg7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsaUJBQWlCLENBT2xEO0lBRUQsT0FBTyxXQUVOO0lBRUQsSUFBSSxnQkFFSDtJQUVELE1BQU0sS0FBSyxNQUFNOzs7Ozs7OztPQVFoQjtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol_contracts.d.ts","sourceRoot":"","sources":["../../src/tx/protocol_contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAI1E,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,KAAK,EAIX,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,qBAAa,iBAAiB;IACT,gBAAgB,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,sBAAsB,CAAC;IAAvF,YAAmB,gBAAgB,EAAE,KAAK,CAAC,YAAY,EAAE,OAAO,sBAAsB,CAAC,EAAI;IAE3F,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,qBAE9C;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,yKAEnD;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,iBAAiB,CAG/D;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB,CAGlE;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,KAAK,sBAEX;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,iBAAiB,CAOlD;IAED,OAAO,WAEN;IAED,IAAI,gBAEH;IAED,MAAM,KAAK,MAAM;;;;;;;;OAQhB;CACF"}

package/dest/tx/protocol_contracts.js

@@ -0,0 +1,58 @@
+import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { BufferReader, FieldReader, assertLength, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export class ProtocolContracts {
+    derivedAddresses;
+    constructor(derivedAddresses){
+        this.derivedAddresses = derivedAddresses;
+    }
+    static from(fields) {
+        return new ProtocolContracts(...ProtocolContracts.getFields(fields));
+    }
+    static getFields(fields) {
+        return [
+            fields.derivedAddresses
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+    }
+    toFields() {
+        return serializeToFields(...ProtocolContracts.getFields(this));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new ProtocolContracts(reader.readArray(MAX_PROTOCOL_CONTRACTS, AztecAddress));
+    }
+    toBuffer() {
+        return serializeToBuffer(...ProtocolContracts.getFields(this));
+    }
+    static empty() {
+        return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, ()=>AztecAddress.zero()));
+    }
+    /**
+   * Creates a ProtocolContracts instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing ProtocolContracts fields
+   * @returns A ProtocolContracts instance
+   */ static fromPlainObject(obj) {
+        return new ProtocolContracts(assertLength(obj.derivedAddresses.map((addr)=>AztecAddress.fromPlainObject(addr)), MAX_PROTOCOL_CONTRACTS));
+    }
+    getSize() {
+        return arraySerializedSizeOfNonEmpty(this.derivedAddresses);
+    }
+    hash() {
+        return poseidon2HashWithSeparator(this.derivedAddresses, GeneratorIndex.PROTOCOL_CONTRACTS);
+    }
+    static get schema() {
+        return z.object({
+            derivedAddresses: AztecAddress.schema.array().min(MAX_PROTOCOL_CONTRACTS).max(MAX_PROTOCOL_CONTRACTS)
+        }).transform(({ derivedAddresses })=>new ProtocolContracts(assertLength(derivedAddresses, MAX_PROTOCOL_CONTRACTS)));
+    }
+}

package/dest/tx/proven_tx.d.ts

@@ -0,0 +1,129 @@
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import type { OffchainEffect } from './offchain_effect.js';
+import { PrivateExecutionResult } from './private_execution_result.js';
+import { type ProvingStats } from './profiling.js';
+import { Tx } from './tx.js';
+export declare class TxProvingResult {
+    privateExecutionResult: PrivateExecutionResult;
+    publicInputs: PrivateKernelTailCircuitPublicInputs;
+    chonkProof: ChonkProof;
+    stats?: ProvingStats | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, chonkProof: ChonkProof, stats?: ProvingStats | undefined);
+    toTx(): Promise<Tx>;
+    getOffchainEffects(): OffchainEffect[];
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        privateExecutionResult: import("@aztec/foundation/schemas").ZodFor<PrivateExecutionResult>;
+        publicInputs: z.ZodType<PrivateKernelTailCircuitPublicInputs, any, string>;
+        chonkProof: z.ZodType<ChonkProof, any, string>;
+        timings: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodObject<{
+            sync: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+            proving: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+            perFunction: z.ZodArray<z.ZodObject<{
+                functionName: z.ZodString;
+                time: z.ZodNumber;
+                oracles: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    times: z.ZodArray<z.ZodNumber, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    times: number[];
+                }, {
+                    times: number[];
+                }>>>;
+            }, "strip", z.ZodTypeAny, {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }, {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }>, "many">;
+            unaccounted: z.ZodNumber;
+            total: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            sync?: number | undefined;
+            proving?: number | undefined;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            total: number;
+        }, {
+            sync?: number | undefined;
+            proving?: number | undefined;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            total: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        privateExecutionResult: PrivateExecutionResult;
+        publicInputs: PrivateKernelTailCircuitPublicInputs;
+        chonkProof: ChonkProof;
+        timings?: {
+            sync?: number | undefined;
+            proving?: number | undefined;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            total: number;
+        } | undefined;
+    }, {
+        privateExecutionResult?: any;
+        publicInputs: string;
+        chonkProof: string;
+        timings?: {
+            sync?: number | undefined;
+            proving?: number | undefined;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            total: number;
+        } | undefined;
+    }>, TxProvingResult, {
+        privateExecutionResult?: any;
+        publicInputs: string;
+        chonkProof: string;
+        timings?: {
+            sync?: number | undefined;
+            proving?: number | undefined;
+            perFunction: {
+                functionName: string;
+                time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
+            }[];
+            unaccounted: number;
+            total: number;
+        } | undefined;
+    }>;
+    static from(fields: FieldsOf<TxProvingResult>): TxProvingResult;
+    static random(): Promise<TxProvingResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVuX3R4LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHJvdmVuX3R4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXhELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLG9DQUFvQyxFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFDOUcsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RELE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzNELE9BQU8sRUFDTCxzQkFBc0IsRUFHdkIsTUFBTSwrQkFBK0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQXdCLE1BQU0sZ0JBQWdCLENBQUM7QUFDekUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUU3QixxQkFBYSxlQUFlO0lBRWpCLHNCQUFzQixFQUFFLHNCQUFzQjtJQUM5QyxZQUFZLEVBQUUsb0NBQW9DO0lBQ2xELFVBQVUsRUFBRSxVQUFVO0lBQ3RCLEtBQUssQ0FBQztJQUpmLFlBQ1Msc0JBQXNCLEVBQUUsc0JBQXNCLEVBQzlDLFlBQVksRUFBRSxvQ0FBb0MsRUFDbEQsVUFBVSxFQUFFLFVBQVUsRUFDdEIsS0FBSyxDQUFDLDBCQUFjLEVBQ3pCO0lBRUUsSUFBSSxJQUFJLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FTeEI7SUFFRCxrQkFBa0IsSUFBSSxjQUFjLEVBQUUsQ0FFckM7SUFFRCxNQUFNLEtBQUssTUFBTTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O09BU2hCO0lBRUQsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGVBQWUsQ0FBQyxtQkFFNUM7SUFFRCxPQUFhLE1BQU0sNkJBTWxCO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"proven_tx.d.ts","sourceRoot":"","sources":["../../src/tx/proven_tx.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAC9G,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,sBAAsB,EAGvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,UAAU,EAAE,UAAU;IACtB,KAAK,CAAC;IAJf,YACS,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,0BAAc,EACzB;IAEE,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,CASxB;IAED,kBAAkB,IAAI,cAAc,EAAE,CAErC;IAED,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,mBAE5C;IAED,OAAa,MAAM,6BAMlB;CACF"}

package/dest/tx/proven_tx.js

@@ -0,0 +1,45 @@
+import { optional } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import { PrivateExecutionResult, collectOffchainEffects, collectSortedContractClassLogs } from './private_execution_result.js';
+import { ProvingTimingsSchema } from './profiling.js';
+import { Tx } from './tx.js';
+export class TxProvingResult {
+    privateExecutionResult;
+    publicInputs;
+    chonkProof;
+    stats;
+    constructor(privateExecutionResult, publicInputs, chonkProof, stats){
+        this.privateExecutionResult = privateExecutionResult;
+        this.publicInputs = publicInputs;
+        this.chonkProof = chonkProof;
+        this.stats = stats;
+    }
+    async toTx() {
+        const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
+        return await Tx.create({
+            data: this.publicInputs,
+            chonkProof: this.chonkProof,
+            contractClassLogFields: contractClassLogs,
+            publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata
+        });
+    }
+    getOffchainEffects() {
+        return collectOffchainEffects(this.privateExecutionResult);
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            chonkProof: ChonkProof.schema,
+            timings: optional(ProvingTimingsSchema)
+        }).transform(TxProvingResult.from);
+    }
+    static from(fields) {
+        return new TxProvingResult(fields.privateExecutionResult, fields.publicInputs, fields.chonkProof);
+    }
+    static async random() {
+        return new TxProvingResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), ChonkProof.empty());
+    }
+}

package/dest/tx/public_call_request_with_calldata.d.ts

@@ -0,0 +1,40 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { type ZodFor } from '../schemas/index.js';
+/**
+ * The call request of a public function, including the calldata.
+ */
+export declare class PublicCallRequestWithCalldata {
+    request: PublicCallRequest;
+    calldata: Fr[];
+    constructor(
+    /**
+     * Request of the public call.
+     */
+    request: PublicCallRequest, 
+    /**
+     * Function selector and arguments of the public call.
+     */
+    calldata: Fr[]);
+    get functionSelector(): FunctionSelector;
+    get args(): Fr[];
+    static get schema(): ZodFor<PublicCallRequestWithCalldata>;
+    static from(fields: Pick<PublicCallRequestWithCalldata, 'request' | 'calldata'>): PublicCallRequestWithCalldata;
+    /**
+     * Creates a PublicCallRequestWithCalldata from a plain object without Zod validation.
+     * This method is optimized for performance and skips validation, making it suitable
+     * for deserializing trusted data (e.g., from C++ via MessagePack).
+     * @param obj - Plain object containing PublicCallRequestWithCalldata fields
+     * @returns A PublicCallRequestWithCalldata instance
+     */
+    static fromPlainObject(obj: any): PublicCallRequestWithCalldata;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static fromBuffer(buffer: Buffer | BufferReader): PublicCallRequestWithCalldata;
+    static empty(): PublicCallRequestWithCalldata;
+    isEmpty(): boolean;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2NhbGxfcmVxdWVzdF93aXRoX2NhbGxkYXRhLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHVibGljX2NhbGxfcmVxdWVzdF93aXRoX2NhbGxkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFHL0IsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDL0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDckUsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFXLE1BQU0scUJBQXFCLENBQUM7QUFHM0Q7O0dBRUc7QUFDSCxxQkFBYSw2QkFBNkI7SUFLL0IsT0FBTyxFQUFFLGlCQUFpQjtJQUkxQixRQUFRLEVBQUUsRUFBRSxFQUFFO0lBUnZCO0lBQ0U7O09BRUc7SUFDSSxPQUFPLEVBQUUsaUJBQWlCO0lBQ2pDOztPQUVHO0lBQ0ksUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUNuQjtJQUdKLElBQUksZ0JBQWdCLElBQUksZ0JBQWdCLENBRXZDO0lBRUQsSUFBSSxJQUFJLElBQUksRUFBRSxFQUFFLENBRWY7SUFFRCxNQUFNLEtBQUssTUFBTSxJQUFJLE1BQU0sQ0FBQyw2QkFBNkIsQ0FBQyxDQU96RDtJQUVELE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyw2QkFBNkIsRUFBRSxTQUFTLEdBQUcsVUFBVSxDQUFDLEdBQUcsNkJBQTZCLENBRTlHO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLGVBQWUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxHQUFHLDZCQUE2QixDQVE5RDtJQUVELFFBQVEsNEJBRVA7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxpQ0FHOUM7SUFFRCxNQUFNLENBQUMsS0FBSyxrQ0FFWDtJQUVELE9BQU8sSUFBSSxPQUFPLENBRWpCO0lBRUQsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLFdBS2Y7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_call_request_with_calldata.d.ts","sourceRoot":"","sources":["../../src/tx/public_call_request_with_calldata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAG3D;;GAEG;AACH,qBAAa,6BAA6B;IAK/B,OAAO,EAAE,iBAAiB;IAI1B,QAAQ,EAAE,EAAE,EAAE;IARvB;IACE;;OAEG;IACI,OAAO,EAAE,iBAAiB;IACjC;;OAEG;IACI,QAAQ,EAAE,EAAE,EAAE,EACnB;IAGJ,IAAI,gBAAgB,IAAI,gBAAgB,CAEvC;IAED,IAAI,IAAI,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,6BAA6B,CAAC,CAOzD;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,6BAA6B,EAAE,SAAS,GAAG,UAAU,CAAC,GAAG,6BAA6B,CAE9G;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,6BAA6B,CAQ9D;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,iCAG9C;IAED,MAAM,CAAC,KAAK,kCAEX;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAKf;CACF"}

package/dest/tx/public_call_request_with_calldata.js

@@ -0,0 +1,69 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/index.js';
+/**
+ * The call request of a public function, including the calldata.
+ */ export class PublicCallRequestWithCalldata {
+    request;
+    calldata;
+    constructor(/**
+     * Request of the public call.
+     */ request, /**
+     * Function selector and arguments of the public call.
+     */ calldata){
+        this.request = request;
+        this.calldata = calldata;
+    }
+    // Public functions get routed through the dispatch function, whose first argument is the target function selector.
+    get functionSelector() {
+        return FunctionSelector.fromField(this.calldata[0]);
+    }
+    get args() {
+        return this.calldata.slice(1);
+    }
+    static get schema() {
+        return z.object({
+            request: PublicCallRequest.schema,
+            calldata: z.array(schemas.Fr)
+        }).transform(PublicCallRequestWithCalldata.from);
+    }
+    static from(fields) {
+        return new PublicCallRequestWithCalldata(fields.request, fields.calldata);
+    }
+    /**
+   * Creates a PublicCallRequestWithCalldata from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicCallRequestWithCalldata fields
+   * @returns A PublicCallRequestWithCalldata instance
+   */ static fromPlainObject(obj) {
+        if (obj instanceof PublicCallRequestWithCalldata) {
+            return obj;
+        }
+        return new PublicCallRequestWithCalldata(PublicCallRequest.fromPlainObject(obj.request), obj.calldata.map((f)=>Fr.fromPlainObject(f)));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.request, new Vector(this.calldata));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicCallRequestWithCalldata(PublicCallRequest.fromBuffer(reader), reader.readVector(Fr));
+    }
+    static empty() {
+        return new PublicCallRequestWithCalldata(PublicCallRequest.empty(), []);
+    }
+    isEmpty() {
+        return this.request.isEmpty() && this.calldata.length === 0;
+    }
+    [inspect.custom]() {
+        return `PublicCallRequestWithCalldata {
+      request: ${inspect(this.request)}
+      calldata: ${this.calldata}
+    }`;
+    }
+}

package/dest/tx/public_simulation_output.d.ts

@@ -2,8 +2,8 @@ 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';
+import { GlobalVariables } from './global_variables.js';
 /** Return values of simulating a circuit. */
 export type ProcessReturnValues = Fr[] | undefined;
 /** Return values of simulating complete callstack. */
@@ -11,7 +11,9 @@ export declare class NestedProcessReturnValues {
     values: ProcessReturnValues;
     nested: NestedProcessReturnValues[];
     constructor(values: ProcessReturnValues, nested?: NestedProcessReturnValues[]);
+    equals(other: NestedProcessReturnValues): boolean;
     static get schema(): ZodFor<NestedProcessReturnValues>;
+    static fromPlainObject(obj: any): NestedProcessReturnValues;
     static empty(): NestedProcessReturnValues;
     static random(depth?: number): NestedProcessReturnValues;
 }
@@ -20,12 +22,12 @@ export declare class NestedProcessReturnValues {
  */
 export declare class PublicSimulationOutput {
     revertReason: SimulationError | undefined;
-    constants: CombinedConstantData;
+    globalVariables: GlobalVariables;
     txEffect: TxEffect;
     publicReturnValues: NestedProcessReturnValues[];
     gasUsed: GasUsed;
-    constructor(revertReason: SimulationError | undefined, constants: CombinedConstantData, txEffect: TxEffect, publicReturnValues: NestedProcessReturnValues[], gasUsed: GasUsed);
+    constructor(revertReason: SimulationError | undefined, globalVariables: GlobalVariables, txEffect: TxEffect, publicReturnValues: NestedProcessReturnValues[], gasUsed: GasUsed);
     static get schema(): ZodFor<PublicSimulationOutput>;
     static random(): Promise<PublicSimulationOutput>;
 }
-//# sourceMappingURL=public_simulation_output.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3NpbXVsYXRpb25fb3V0cHV0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHVibGljX3NpbXVsYXRpb25fb3V0cHV0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQVcsTUFBTSwyQkFBMkIsQ0FBQztBQUtqRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFaEUsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RCw2Q0FBNkM7QUFDN0MsTUFBTSxNQUFNLG1CQUFtQixHQUFHLEVBQUUsRUFBRSxHQUFHLFNBQVMsQ0FBQztBQUVuRCxzREFBc0Q7QUFDdEQscUJBQWEseUJBQXlCO0lBQ3BDLE1BQU0sRUFBRSxtQkFBbUIsQ0FBQztJQUM1QixNQUFNLEVBQUUseUJBQXlCLEVBQUUsQ0FBQztJQUVwQyxZQUFZLE1BQU0sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLENBQUMsRUFBRSx5QkFBeUIsRUFBRSxFQUc1RTtJQUVELE1BQU0sQ0FBQyxLQUFLLEVBQUUseUJBQXlCLEdBQUcsT0FBTyxDQU9oRDtJQUVELE1BQU0sS0FBSyxNQUFNLElBQUksTUFBTSxDQUFDLHlCQUF5QixDQUFDLENBT3JEO0lBRUQsTUFBTSxDQUFDLGVBQWUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxHQUFHLHlCQUF5QixDQUsxRDtJQUVELE1BQU0sQ0FBQyxLQUFLLDhCQUVYO0lBRUQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxLQUFLLFNBQUksR0FBRyx5QkFBeUIsQ0FLbEQ7Q0FDRjtBQUVEOztHQUVHO0FBQ0gscUJBQWEsc0JBQXNCO0lBRXhCLFlBQVksRUFBRSxlQUFlLEdBQUcsU0FBUztJQUN6QyxlQUFlLEVBQUUsZUFBZTtJQUNoQyxRQUFRLEVBQUUsUUFBUTtJQUNsQixrQkFBa0IsRUFBRSx5QkFBeUIsRUFBRTtJQUMvQyxPQUFPLEVBQUUsT0FBTztJQUx6QixZQUNTLFlBQVksRUFBRSxlQUFlLEdBQUcsU0FBUyxFQUN6QyxlQUFlLEVBQUUsZUFBZSxFQUNoQyxRQUFRLEVBQUUsUUFBUSxFQUNsQixrQkFBa0IsRUFBRSx5QkFBeUIsRUFBRSxFQUMvQyxPQUFPLEVBQUUsT0FBTyxFQUNyQjtJQUVKLE1BQU0sS0FBSyxNQUFNLElBQUksTUFBTSxDQUFDLHNCQUFzQixDQUFDLENBd0JsRDtJQUVELE9BQWEsTUFBTSxvQ0FRbEI7Q0FDRiJ9

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

@@ -1 +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"}
+{"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;AAElD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,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;IAEpC,YAAY,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,yBAAyB,EAAE,EAG5E;IAED,MAAM,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAOhD;IAED,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,yBAAyB,CAAC,CAOrD;IAED,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,yBAAyB,CAK1D;IAED,MAAM,CAAC,KAAK,8BAEX;IAED,MAAM,CAAC,MAAM,CAAC,KAAK,SAAI,GAAG,yBAAyB,CAKlD;CACF;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAExB,YAAY,EAAE,eAAe,GAAG,SAAS;IACzC,eAAe,EAAE,eAAe;IAChC,QAAQ,EAAE,QAAQ;IAClB,kBAAkB,EAAE,yBAAyB,EAAE;IAC/C,OAAO,EAAE,OAAO;IALzB,YACS,YAAY,EAAE,eAAe,GAAG,SAAS,EACzC,eAAe,EAAE,eAAe,EAChC,QAAQ,EAAE,QAAQ,EAClB,kBAAkB,EAAE,yBAAyB,EAAE,EAC/C,OAAO,EAAE,OAAO,EACrB;IAEJ,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,sBAAsB,CAAC,CAwBlD;IAED,OAAa,MAAM,oCAQlB;CACF"}

package/dest/tx/public_simulation_output.js

@@ -4,8 +4,9 @@ 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 { NullishToUndefined } from '../schemas/schemas.js';
 import { TxEffect } from '../tx/tx_effect.js';
+import { GlobalVariables } from './global_variables.js';
 /** Return values of simulating complete callstack. */ export class NestedProcessReturnValues {
     values;
     nested;
@@ -13,12 +14,18 @@ import { TxEffect } from '../tx/tx_effect.js';
         this.values = values;
         this.nested = nested ?? [];
     }
+    equals(other) {
+        return this.values?.length === other.values?.length && this.nested.length === other.nested.length && (this.values === undefined || this.values.every((v, i)=>v.equals(other.values[i]))) && this.nested.every((n, i)=>n.equals(other.nested[i]));
+    }
     static get schema() {
         return z.object({
-            values: z.array(schemas.Fr).optional(),
+            values: NullishToUndefined(z.array(schemas.Fr)),
             nested: z.array(z.lazy(()=>NestedProcessReturnValues.schema))
         }).transform(({ values, nested })=>new NestedProcessReturnValues(values, nested));
     }
+    static fromPlainObject(obj) {
+        return new NestedProcessReturnValues(obj.values?.map(Fr.fromPlainObject), obj.nested?.map(NestedProcessReturnValues.fromPlainObject));
+    }
     static empty() {
         return new NestedProcessReturnValues([]);
     }
@@ -32,13 +39,13 @@ import { TxEffect } from '../tx/tx_effect.js';
  * Outputs of processing the public component of a transaction.
  */ export class PublicSimulationOutput {
     revertReason;
-    constants;
+    globalVariables;
     txEffect;
     publicReturnValues;
     gasUsed;
-    constructor(revertReason, constants, txEffect, publicReturnValues, gasUsed){
+    constructor(revertReason, globalVariables, txEffect, publicReturnValues, gasUsed){
         this.revertReason = revertReason;
-        this.constants = constants;
+        this.globalVariables = globalVariables;
         this.txEffect = txEffect;
         this.publicReturnValues = publicReturnValues;
         this.gasUsed = gasUsed;
@@ -46,7 +53,7 @@ import { TxEffect } from '../tx/tx_effect.js';
     static get schema() {
         return z.object({
             revertReason: SimulationError.schema.optional(),
-            constants: CombinedConstantData.schema,
+            globalVariables: GlobalVariables.schema,
             txEffect: TxEffect.schema,
             publicReturnValues: z.array(NestedProcessReturnValues.schema),
             gasUsed: z.object({
@@ -55,10 +62,10 @@ import { TxEffect } from '../tx/tx_effect.js';
                 publicGas: Gas.schema,
                 billedGas: Gas.schema
             })
-        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.constants, fields.txEffect, fields.publicReturnValues, fields.gasUsed));
+        }).transform((fields)=>new PublicSimulationOutput(fields.revertReason, fields.globalVariables, fields.txEffect, fields.publicReturnValues, fields.gasUsed));
     }
     static async random() {
-        return new PublicSimulationOutput(await SimulationError.random(), CombinedConstantData.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
+        return new PublicSimulationOutput(await SimulationError.random(), GlobalVariables.empty(), TxEffect.empty(), times(2, NestedProcessReturnValues.random), {
             teardownGas: Gas.random(),
             totalGas: Gas.random(),
             publicGas: Gas.random(),