@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/tx/profiling.d.ts

@@ -0,0 +1,360 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+import type { AztecNode } from '../interfaces/aztec-node.js';
+import { type PrivateExecutionStep } from '../kernel/private_kernel_prover_output.js';
+export type NodeStats = Partial<Record<keyof AztecNode, {
+    times: number[];
+}>>;
+type FunctionTiming = {
+    functionName: string;
+    time: number;
+    oracles?: Record<string, {
+        times: number[];
+    }>;
+};
+export type ProvingTimings = {
+    sync?: number;
+    proving?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+};
+export declare const ProvingTimingsSchema: 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;
+}>;
+export interface ProvingStats {
+    timings: ProvingTimings;
+    nodeRPCCalls?: NodeStats;
+}
+export declare const ProvingStatsSchema: z.ZodObject<{
+    timings: 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;
+    }>;
+    nodeRPCCalls: 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, {
+    timings: {
+        sync?: number | undefined;
+        proving?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}, {
+    timings: {
+        sync?: number | undefined;
+        proving?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    };
+    nodeRPCCalls?: Record<string, {
+        times: number[];
+    }> | undefined;
+}>;
+export interface SimulationTimings {
+    sync: number;
+    publicSimulation?: number;
+    validation?: number;
+    perFunction: FunctionTiming[];
+    unaccounted: number;
+    total: number;
+}
+export declare const SimulationTimingsSchema: z.ZodObject<{
+    sync: z.ZodNumber;
+    publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+    validation: 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;
+    publicSimulation?: number | undefined;
+    validation?: number | undefined;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    total: number;
+}, {
+    sync: number;
+    publicSimulation?: number | undefined;
+    validation?: number | undefined;
+    perFunction: {
+        functionName: string;
+        time: number;
+        oracles?: Record<string, {
+            times: number[];
+        }> | undefined;
+    }[];
+    unaccounted: number;
+    total: number;
+}>;
+export interface SimulationStats {
+    timings: SimulationTimings;
+    nodeRPCCalls: NodeStats;
+}
+export declare const SimulationStatsSchema: z.ZodObject<{
+    timings: z.ZodObject<{
+        sync: z.ZodNumber;
+        publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+        validation: 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;
+        publicSimulation?: number | undefined;
+        validation?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    }, {
+        sync: number;
+        publicSimulation?: number | undefined;
+        validation?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    }>;
+    nodeRPCCalls: z.ZodRecord<z.ZodString, z.ZodObject<{
+        times: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        times: number[];
+    }, {
+        times: number[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timings: {
+        sync: number;
+        publicSimulation?: number | undefined;
+        validation?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}, {
+    timings: {
+        sync: number;
+        publicSimulation?: number | undefined;
+        validation?: number | undefined;
+        perFunction: {
+            functionName: string;
+            time: number;
+            oracles?: Record<string, {
+                times: number[];
+            }> | undefined;
+        }[];
+        unaccounted: number;
+        total: number;
+    };
+    nodeRPCCalls: Record<string, {
+        times: number[];
+    }>;
+}>;
+export declare class TxProfileResult {
+    executionSteps: PrivateExecutionStep[];
+    stats: ProvingStats;
+    constructor(executionSteps: PrivateExecutionStep[], stats: ProvingStats);
+    static get schema(): ZodFor<TxProfileResult>;
+    static random(): TxProfileResult;
+}
+export declare class UtilitySimulationResult {
+    result: Fr[];
+    stats?: SimulationStats | undefined;
+    constructor(result: Fr[], stats?: SimulationStats | undefined);
+    static get schema(): ZodFor<UtilitySimulationResult>;
+    static random(): UtilitySimulationResult;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlsaW5nLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHJvZmlsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQXFCLE1BQU0sMkJBQTJCLENBQUM7QUFFM0UsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsS0FBSyxvQkFBb0IsRUFBOEIsTUFBTSwyQ0FBMkMsQ0FBQztBQUVsSCxNQUFNLE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsTUFBTSxTQUFTLEVBQUU7SUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDLENBQUMsQ0FBQztBQUk5RSxLQUFLLGNBQWMsR0FBRztJQUNwQixZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLElBQUksRUFBRSxNQUFNLENBQUM7SUFDYixPQUFPLENBQUMsRUFBRSxNQUFNLENBQUMsTUFBTSxFQUFFO1FBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxDQUFBO0tBQUUsQ0FBQyxDQUFDO0NBQy9DLENBQUM7QUFRRixNQUFNLE1BQU0sY0FBYyxHQUFHO0lBQzNCLElBQUksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNkLE9BQU8sQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNqQixXQUFXLEVBQUUsY0FBYyxFQUFFLENBQUM7SUFDOUIsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUNwQixLQUFLLEVBQUUsTUFBTSxDQUFDO0NBQ2YsQ0FBQztBQUVGLGVBQU8sTUFBTSxvQkFBb0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFNL0IsQ0FBQztBQUVILE1BQU0sV0FBVyxZQUFZO0lBQzNCLE9BQU8sRUFBRSxjQUFjLENBQUM7SUFDeEIsWUFBWSxDQUFDLEVBQUUsU0FBUyxDQUFDO0NBQzFCO0FBRUQsZUFBTyxNQUFNLGtCQUFrQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFHN0IsQ0FBQztBQUVILE1BQU0sV0FBVyxpQkFBaUI7SUFDaEMsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzFCLFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNwQixXQUFXLEVBQUUsY0FBYyxFQUFFLENBQUM7SUFDOUIsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUNwQixLQUFLLEVBQUUsTUFBTSxDQUFDO0NBQ2Y7QUFFRCxlQUFPLE1BQU0sdUJBQXVCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0VBT2xDLENBQUM7QUFFSCxNQUFNLFdBQVcsZUFBZTtJQUM5QixPQUFPLEVBQUUsaUJBQWlCLENBQUM7SUFDM0IsWUFBWSxFQUFFLFNBQVMsQ0FBQztDQUN6QjtBQUVELGVBQU8sTUFBTSxxQkFBcUI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFHaEMsQ0FBQztBQUVILHFCQUFhLGVBQWU7SUFFakIsY0FBYyxFQUFFLG9CQUFvQixFQUFFO0lBQ3RDLEtBQUssRUFBRSxZQUFZO0lBRjVCLFlBQ1MsY0FBYyxFQUFFLG9CQUFvQixFQUFFLEVBQ3RDLEtBQUssRUFBRSxZQUFZLEVBQ3hCO0lBQ0osTUFBTSxLQUFLLE1BQU0sSUFBSSxNQUFNLENBQUMsZUFBZSxDQUFDLENBTzNDO0lBRUQsTUFBTSxDQUFDLE1BQU0sSUFBSSxlQUFlLENBOEIvQjtDQUNGO0FBRUQscUJBQWEsdUJBQXVCO0lBRXpCLE1BQU0sRUFBRSxFQUFFLEVBQUU7SUFDWixLQUFLLENBQUM7SUFGZixZQUNTLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFDWixLQUFLLENBQUMsNkJBQWlCLEVBQzVCO0lBRUosTUFBTSxLQUFLLE1BQU0sSUFBSSxNQUFNLENBQUMsdUJBQXVCLENBQUMsQ0FPbkQ7SUFFRCxNQUFNLENBQUMsTUFBTSxJQUFJLHVCQUF1QixDQWlCdkM7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"profiling.d.ts","sourceRoot":"","sources":["../../src/tx/profiling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,KAAK,MAAM,EAAqB,MAAM,2BAA2B,CAAC;AAE3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,KAAK,oBAAoB,EAA8B,MAAM,2CAA2C,CAAC;AAElH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC,CAAC;AAI9E,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC/C,CAAC;AAQF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAC;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AAEH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,YAAY,EAAE,SAAS,CAAC;CACzB;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH,qBAAa,eAAe;IAEjB,cAAc,EAAE,oBAAoB,EAAE;IACtC,KAAK,EAAE,YAAY;IAF5B,YACS,cAAc,EAAE,oBAAoB,EAAE,EACtC,KAAK,EAAE,YAAY,EACxB;IACJ,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,eAAe,CAAC,CAO3C;IAED,MAAM,CAAC,MAAM,IAAI,eAAe,CA8B/B;CACF;AAED,qBAAa,uBAAuB;IAEzB,MAAM,EAAE,EAAE,EAAE;IACZ,KAAK,CAAC;IAFf,YACS,MAAM,EAAE,EAAE,EAAE,EACZ,KAAK,CAAC,6BAAiB,EAC5B;IAEJ,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,uBAAuB,CAAC,CAOnD;IAED,MAAM,CAAC,MAAM,IAAI,uBAAuB,CAiBvC;CACF"}

package/dest/tx/profiling.js

@@ -0,0 +1,130 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+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/curves/bn254';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2xfY29udHJhY3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHgvcHJvdG9jb2xfY29udHJhY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBa0Isc0JBQXNCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUkxRSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLFlBQVksRUFDWixXQUFXLEVBQ1gsS0FBSyxLQUFLLEVBSVgsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV6RCxxQkFBYSxpQkFBaUI7SUFDVCxnQkFBZ0IsRUFBRSxLQUFLLENBQUMsWUFBWSxFQUFFLE9BQU8sc0JBQXNCLENBQUM7SUFBdkYsWUFBbUIsZ0JBQWdCLEVBQUUsS0FBSyxDQUFDLFlBQVksRUFBRSxPQUFPLHNCQUFzQixDQUFDLEVBQUk7SUFFM0YsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGlCQUFpQixDQUFDLHFCQUU5QztJQUVELE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyx5S0FFbkQ7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLEdBQUcsaUJBQWlCLENBRy9EO0lBRUQsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQUVmO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxpQkFBaUIsQ0FHbEU7SUFFRCxRQUFRLDRCQUVQO0lBRUQsTUFBTSxDQUFDLEtBQUssc0JBRVg7SUFFRDs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsaUJBQWlCLENBT2xEO0lBRUQsT0FBTyxXQUVOO0lBRUQsSUFBSSxnQkFFSDtJQUVELE1BQU0sS0FBSyxNQUFNOzs7Ozs7OztPQVFoQjtDQUNGIn0=

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,gCAAgC,CAAC;AACpD,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/poseidon';
+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)));
+    }
+}