@aztec/stdlib 0.87.5 → 0.87.7

package/src/tx/profiling.ts

@@ -4,15 +4,25 @@ import { type ZodFor, optional } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import type { AbiDecoded } from '../abi/decoder.js';
+import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
 import { AbiDecodedSchema } from '../schemas/schemas.js';
 
+export type NodeStats = Partial<Record<keyof AztecNode, { times: number[] }>>;
+
+const NodeStatsSchema = z.record(z.string(), z.object({ times: z.array(z.number()) }));
+
 type FunctionTiming = {
   functionName: string;
   time: number;
+  oracles?: Record<string, { times: number[] }>;
 };
 
-const FunctionTimingSchema = z.object({ functionName: z.string(), time: 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 type ProvingTimings = {
   sync?: number;
@@ -30,6 +40,16 @@ export const ProvingTimingsSchema = z.object({
   total: z.number(),
 });
 
+export interface ProvingStats {
+  timings: ProvingTimings;
+  nodeRPCCalls?: NodeStats;
+}
+
+export const ProvingStatsSchema = z.object({
+  timings: ProvingTimingsSchema,
+  nodeRPCCalls: optional(NodeStatsSchema),
+});
+
 export interface SimulationTimings {
   sync: number;
   publicSimulation?: number;
@@ -48,19 +68,29 @@ export const SimulationTimingsSchema = z.object({
   total: z.number(),
 });
 
+export interface SimulationStats {
+  timings: SimulationTimings;
+  nodeRPCCalls: NodeStats;
+}
+
+export const SimulationStatsSchema = z.object({
+  timings: SimulationTimingsSchema,
+  nodeRPCCalls: NodeStatsSchema,
+});
+
 export class TxProfileResult {
   constructor(
     public executionSteps: PrivateExecutionStep[],
-    public timings: ProvingTimings,
+    public stats: ProvingStats,
   ) {}
 
   static get schema(): ZodFor<TxProfileResult> {
     return z
       .object({
         executionSteps: z.array(PrivateExecutionStepSchema),
-        timings: ProvingTimingsSchema,
+        stats: ProvingStatsSchema,
       })
-      .transform(({ executionSteps, timings }) => new TxProfileResult(executionSteps, timings));
+      .transform(({ executionSteps, stats }) => new TxProfileResult(executionSteps, stats));
   }
 
   static random(): TxProfileResult {
@@ -78,16 +108,19 @@ export class TxProfileResult {
         },
       ],
       {
-        sync: 1,
-        proving: 1,
-        perFunction: [
-          {
-            functionName: 'random',
-            time: 1,
-          },
-        ],
-        unaccounted: 1,
-        total: 4,
+        nodeRPCCalls: { getBlockHeader: { times: [1] } },
+        timings: {
+          sync: 1,
+          proving: 1,
+          perFunction: [
+            {
+              functionName: 'random',
+              time: 1,
+            },
+          ],
+          unaccounted: 1,
+          total: 4,
+        },
       },
     );
   }
@@ -96,31 +129,34 @@ export class TxProfileResult {
 export class UtilitySimulationResult {
   constructor(
     public result: AbiDecoded,
-    public timings?: SimulationTimings,
+    public stats?: SimulationStats,
   ) {}
 
   static get schema(): ZodFor<UtilitySimulationResult> {
     return z
       .object({
         result: AbiDecodedSchema,
-        timings: optional(SimulationTimingsSchema),
+        stats: optional(SimulationStatsSchema),
       })
-      .transform(({ result, timings }) => new UtilitySimulationResult(result, timings));
+      .transform(({ result, stats }) => new UtilitySimulationResult(result, stats));
   }
 
   static random(): UtilitySimulationResult {
     return new UtilitySimulationResult(Fr.random().toBigInt(), {
-      sync: 1,
-      publicSimulation: 1,
-      validation: 1,
-      perFunction: [
-        {
-          functionName: 'random',
-          time: 1,
-        },
-      ],
-      unaccounted: 1,
-      total: 5,
+      nodeRPCCalls: { getBlockHeader: { times: [1] } },
+      timings: {
+        sync: 1,
+        publicSimulation: 1,
+        validation: 1,
+        perFunction: [
+          {
+            functionName: 'random',
+            time: 1,
+          },
+        ],
+        unaccounted: 1,
+        total: 5,
+      },
     });
   }
 }

package/src/tx/proven_tx.ts

@@ -6,7 +6,7 @@ import { z } from 'zod';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
 import { PrivateExecutionResult, collectSortedContractClassLogs } from './private_execution_result.js';
-import { type ProvingTimings, SimulationTimingsSchema } from './profiling.js';
+import { type ProvingStats, ProvingTimingsSchema } from './profiling.js';
 import { Tx } from './tx.js';
 
 export class TxProvingResult {
@@ -14,7 +14,7 @@ export class TxProvingResult {
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public clientIvcProof: ClientIvcProof,
-    public timings?: ProvingTimings,
+    public stats?: ProvingStats,
   ) {}
 
   toTx(): Tx {
@@ -35,7 +35,7 @@ export class TxProvingResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         clientIvcProof: ClientIvcProof.schema,
-        timings: optional(SimulationTimingsSchema),
+        timings: optional(ProvingTimingsSchema),
       })
       .transform(TxProvingResult.from);
   }

package/src/tx/simulated_tx.ts

@@ -12,7 +12,7 @@ import {
   PrivateExecutionResult,
   collectSortedContractClassLogs,
 } from './private_execution_result.js';
-import { type SimulationTimings, SimulationTimingsSchema } from './profiling.js';
+import { type SimulationStats, SimulationStatsSchema } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
 
@@ -44,7 +44,7 @@ export class TxSimulationResult {
     public privateExecutionResult: PrivateExecutionResult,
     public publicInputs: PrivateKernelTailCircuitPublicInputs,
     public publicOutput?: PublicSimulationOutput,
-    public timings?: SimulationTimings,
+    public stats?: SimulationStats,
   ) {}
 
   get gasUsed(): GasUsed {
@@ -64,7 +64,7 @@ export class TxSimulationResult {
         privateExecutionResult: PrivateExecutionResult.schema,
         publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
         publicOutput: PublicSimulationOutput.schema.optional(),
-        timings: optional(SimulationTimingsSchema),
+        stats: optional(SimulationStatsSchema),
       })
       .transform(TxSimulationResult.from);
   }
@@ -74,20 +74,20 @@ export class TxSimulationResult {
       fields.privateExecutionResult,
       fields.publicInputs,
       fields.publicOutput,
-      fields.timings,
+      fields.stats,
     );
   }
 
   static fromPrivateSimulationResultAndPublicOutput(
     privateSimulationResult: PrivateSimulationResult,
     publicOutput?: PublicSimulationOutput,
-    timings?: SimulationTimings,
+    stats?: SimulationStats,
   ) {
     return new TxSimulationResult(
       privateSimulationResult.privateExecutionResult,
       privateSimulationResult.publicInputs,
       publicOutput,
-      timings,
+      stats,
     );
   }