@aztec/stdlib 0.87.5 → 0.87.7

package/dest/tx/profiling.js

@@ -3,9 +3,15 @@ import { optional } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 import { PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
 import { AbiDecodedSchema } from '../schemas/schemas.js';
+const NodeStatsSchema = z.record(z.string(), z.object({
+    times: z.array(z.number())
+}));
 const FunctionTimingSchema = z.object({
     functionName: z.string(),
-    time: z.number()
+    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()),
@@ -14,6 +20,10 @@ export const ProvingTimingsSchema = z.object({
     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()),
@@ -22,18 +32,22 @@ export const SimulationTimingsSchema = z.object({
     unaccounted: z.number(),
     total: z.number()
 });
+export const SimulationStatsSchema = z.object({
+    timings: SimulationTimingsSchema,
+    nodeRPCCalls: NodeStatsSchema
+});
 export class TxProfileResult {
     executionSteps;
-    timings;
-    constructor(executionSteps, timings){
+    stats;
+    constructor(executionSteps, stats){
         this.executionSteps = executionSteps;
-        this.timings = timings;
+        this.stats = stats;
     }
     static get schema() {
         return z.object({
             executionSteps: z.array(PrivateExecutionStepSchema),
-            timings: ProvingTimingsSchema
-        }).transform(({ executionSteps, timings })=>new TxProfileResult(executionSteps, timings));
+            stats: ProvingStatsSchema
+        }).transform(({ executionSteps, stats })=>new TxProfileResult(executionSteps, stats));
     }
     static random() {
         return new TxProfileResult([
@@ -53,45 +67,63 @@ export class TxProfileResult {
                 }
             }
         ], {
-            sync: 1,
-            proving: 1,
-            perFunction: [
-                {
-                    functionName: 'random',
-                    time: 1
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
                 }
-            ],
-            unaccounted: 1,
-            total: 4
+            },
+            timings: {
+                sync: 1,
+                proving: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 4
+            }
         });
     }
 }
 export class UtilitySimulationResult {
     result;
-    timings;
-    constructor(result, timings){
+    stats;
+    constructor(result, stats){
         this.result = result;
-        this.timings = timings;
+        this.stats = stats;
     }
     static get schema() {
         return z.object({
             result: AbiDecodedSchema,
-            timings: optional(SimulationTimingsSchema)
-        }).transform(({ result, timings })=>new UtilitySimulationResult(result, timings));
+            stats: optional(SimulationStatsSchema)
+        }).transform(({ result, stats })=>new UtilitySimulationResult(result, stats));
     }
     static random() {
         return new UtilitySimulationResult(Fr.random().toBigInt(), {
-            sync: 1,
-            publicSimulation: 1,
-            validation: 1,
-            perFunction: [
-                {
-                    functionName: 'random',
-                    time: 1
+            nodeRPCCalls: {
+                getBlockHeader: {
+                    times: [
+                        1
+                    ]
                 }
-            ],
-            unaccounted: 1,
-            total: 5
+            },
+            timings: {
+                sync: 1,
+                publicSimulation: 1,
+                validation: 1,
+                perFunction: [
+                    {
+                        functionName: 'random',
+                        time: 1
+                    }
+                ],
+                unaccounted: 1,
+                total: 5
+            }
         });
     }
 }

package/dest/tx/proven_tx.d.ts

@@ -3,99 +3,121 @@ 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 } from './private_execution_result.js';
-import { type ProvingTimings } from './profiling.js';
+import { type ProvingStats } from './profiling.js';
 import { Tx } from './tx.js';
 export declare class TxProvingResult {
     privateExecutionResult: PrivateExecutionResult;
     publicInputs: PrivateKernelTailCircuitPublicInputs;
     clientIvcProof: ClientIvcProof;
-    timings?: ProvingTimings | undefined;
-    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, clientIvcProof: ClientIvcProof, timings?: ProvingTimings | undefined);
+    stats?: ProvingStats | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, clientIvcProof: ClientIvcProof, stats?: ProvingStats | undefined);
     toTx(): Tx;
     static get schema(): z.ZodEffects<z.ZodObject<{
         privateExecutionResult: import("@aztec/foundation/schemas").ZodFor<PrivateExecutionResult>;
         publicInputs: z.ZodType<PrivateKernelTailCircuitPublicInputs, any, string>;
         clientIvcProof: z.ZodType<ClientIvcProof, any, string>;
         timings: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodObject<{
-            sync: z.ZodNumber;
-            publicSimulation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
-            validation: import("@aztec/foundation/schemas").ZodNullableOptional<z.ZodNumber>;
+            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;
             perFunction: {
                 functionName: string;
                 time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
             }[];
             unaccounted: number;
             total: number;
-            validation?: number | undefined;
-            publicSimulation?: number | undefined;
+            sync?: number | undefined;
+            proving?: number | undefined;
         }, {
-            sync: number;
             perFunction: {
                 functionName: string;
                 time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
             }[];
             unaccounted: number;
             total: number;
-            validation?: number | undefined;
-            publicSimulation?: number | undefined;
+            sync?: number | undefined;
+            proving?: number | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         publicInputs: PrivateKernelTailCircuitPublicInputs;
         clientIvcProof: ClientIvcProof;
         privateExecutionResult: PrivateExecutionResult;
         timings?: {
-            sync: number;
             perFunction: {
                 functionName: string;
                 time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
             }[];
             unaccounted: number;
             total: number;
-            validation?: number | undefined;
-            publicSimulation?: number | undefined;
+            sync?: number | undefined;
+            proving?: number | undefined;
         } | undefined;
     }, {
         publicInputs: string;
         clientIvcProof: string;
         timings?: {
-            sync: number;
             perFunction: {
                 functionName: string;
                 time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
             }[];
             unaccounted: number;
             total: number;
-            validation?: number | undefined;
-            publicSimulation?: number | undefined;
+            sync?: number | undefined;
+            proving?: number | undefined;
         } | undefined;
         privateExecutionResult?: any;
     }>, TxProvingResult, {
         publicInputs: string;
         clientIvcProof: string;
         timings?: {
-            sync: number;
             perFunction: {
                 functionName: string;
                 time: number;
+                oracles?: Record<string, {
+                    times: number[];
+                }> | undefined;
             }[];
             unaccounted: number;
             total: number;
-            validation?: number | undefined;
-            publicSimulation?: number | undefined;
+            sync?: number | undefined;
+            proving?: number | undefined;
         } | undefined;
         privateExecutionResult?: any;
     }>;

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

@@ -1 +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,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAkC,MAAM,+BAA+B,CAAC;AACvG,OAAO,EAAE,KAAK,cAAc,EAA2B,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,cAAc,EAAE,cAAc;IAC9B,OAAO,CAAC,EAAE,cAAc;gBAHxB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE,cAAc,YAAA;IAGjC,IAAI,IAAI,EAAE;IAYV,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;WAIhC,MAAM;CAOpB"}
+{"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,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAkC,MAAM,+BAA+B,CAAC;AACvG,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,cAAc,EAAE,cAAc;IAC9B,KAAK,CAAC,EAAE,YAAY;gBAHpB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,cAAc,EAAE,cAAc,EAC9B,KAAK,CAAC,EAAE,YAAY,YAAA;IAG7B,IAAI,IAAI,EAAE;IAYV,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;WAIhC,MAAM;CAOpB"}

package/dest/tx/proven_tx.js

@@ -3,18 +3,18 @@ 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 { SimulationTimingsSchema } from './profiling.js';
+import { ProvingTimingsSchema } from './profiling.js';
 import { Tx } from './tx.js';
 export class TxProvingResult {
     privateExecutionResult;
     publicInputs;
     clientIvcProof;
-    timings;
-    constructor(privateExecutionResult, publicInputs, clientIvcProof, timings){
+    stats;
+    constructor(privateExecutionResult, publicInputs, clientIvcProof, stats){
         this.privateExecutionResult = privateExecutionResult;
         this.publicInputs = publicInputs;
         this.clientIvcProof = clientIvcProof;
-        this.timings = timings;
+        this.stats = stats;
     }
     toTx() {
         const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
@@ -26,7 +26,7 @@ export class TxProvingResult {
             privateExecutionResult: PrivateExecutionResult.schema,
             publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
             clientIvcProof: ClientIvcProof.schema,
-            timings: optional(SimulationTimingsSchema)
+            timings: optional(ProvingTimingsSchema)
         }).transform(TxProvingResult.from);
     }
     static from(fields) {

package/dest/tx/simulated_tx.d.ts

@@ -3,7 +3,7 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import type { GasUsed } from '../gas/gas_used.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { PrivateExecutionResult } from './private_execution_result.js';
-import { type SimulationTimings } from './profiling.js';
+import { type SimulationStats } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
 export declare class PrivateSimulationResult {
@@ -17,12 +17,12 @@ export declare class TxSimulationResult {
     privateExecutionResult: PrivateExecutionResult;
     publicInputs: PrivateKernelTailCircuitPublicInputs;
     publicOutput?: PublicSimulationOutput | undefined;
-    timings?: SimulationTimings | undefined;
-    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, publicOutput?: PublicSimulationOutput | undefined, timings?: SimulationTimings | undefined);
+    stats?: SimulationStats | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, publicOutput?: PublicSimulationOutput | undefined, stats?: SimulationStats | undefined);
     get gasUsed(): GasUsed;
     static get schema(): ZodFor<TxSimulationResult>;
     static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>): TxSimulationResult;
-    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult: PrivateSimulationResult, publicOutput?: PublicSimulationOutput, timings?: SimulationTimings): TxSimulationResult;
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult: PrivateSimulationResult, publicOutput?: PublicSimulationOutput, stats?: SimulationStats): TxSimulationResult;
     static random(): Promise<TxSimulationResult>;
     getPrivateReturnValues(): NestedProcessReturnValues;
     toSimulatedTx(): Tx;

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

@@ -1 +1 @@
-{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAKxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAE9G,OAAO,EAEL,sBAAsB,EAEvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,iBAAiB,EAA2B,MAAM,gBAAgB,CAAC;AACjF,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;CAWpB;AAED,qBAAa,kBAAkB;IAEpB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,YAAY,CAAC,EAAE,sBAAsB;IACrC,OAAO,CAAC,EAAE,iBAAiB;gBAH3B,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,YAAY,CAAC,EAAE,sBAAsB,YAAA,EACrC,OAAO,CAAC,EAAE,iBAAiB,YAAA;IAGpC,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,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,OAAO,CAAC,EAAE,iBAAiB;WAUhB,MAAM;IAQnB,sBAAsB;IAItB,aAAa,IAAI,EAAE;IAInB,qBAAqB;CAGtB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}
+{"version":3,"file":"simulated_tx.d.ts","sourceRoot":"","sources":["../../src/tx/simulated_tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAKxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,oCAAoC,EAAE,MAAM,wDAAwD,CAAC;AAE9G,OAAO,EAEL,sBAAsB,EAEvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,gBAAgB,CAAC;AAC7E,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;CAWpB;AAED,qBAAa,kBAAkB;IAEpB,sBAAsB,EAAE,sBAAsB;IAC9C,YAAY,EAAE,oCAAoC;IAClD,YAAY,CAAC,EAAE,sBAAsB;IACrC,KAAK,CAAC,EAAE,eAAe;gBAHvB,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,YAAY,CAAC,EAAE,sBAAsB,YAAA,EACrC,KAAK,CAAC,EAAE,eAAe,YAAA;IAGhC,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,MAAM,CAAC,0CAA0C,CAC/C,uBAAuB,EAAE,uBAAuB,EAChD,YAAY,CAAC,EAAE,sBAAsB,EACrC,KAAK,CAAC,EAAE,eAAe;WAUZ,MAAM;IAQnB,sBAAsB;IAItB,aAAa,IAAI,EAAE;IAInB,qBAAqB;CAGtB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,sBAAsB,GAAG,yBAAyB,CAWhH"}

package/dest/tx/simulated_tx.js

@@ -4,7 +4,7 @@ import { Gas } from '../gas/gas.js';
 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 { SimulationTimingsSchema } from './profiling.js';
+import { SimulationStatsSchema } from './profiling.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simulation_output.js';
 import { Tx } from './tx.js';
 export class PrivateSimulationResult {
@@ -27,12 +27,12 @@ export class TxSimulationResult {
     privateExecutionResult;
     publicInputs;
     publicOutput;
-    timings;
-    constructor(privateExecutionResult, publicInputs, publicOutput, timings){
+    stats;
+    constructor(privateExecutionResult, publicInputs, publicOutput, stats){
         this.privateExecutionResult = privateExecutionResult;
         this.publicInputs = publicInputs;
         this.publicOutput = publicOutput;
-        this.timings = timings;
+        this.stats = stats;
     }
     get gasUsed() {
         return this.publicOutput?.gasUsed ?? {
@@ -47,14 +47,14 @@ export class TxSimulationResult {
             privateExecutionResult: PrivateExecutionResult.schema,
             publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
             publicOutput: PublicSimulationOutput.schema.optional(),
-            timings: optional(SimulationTimingsSchema)
+            stats: optional(SimulationStatsSchema)
         }).transform(TxSimulationResult.from);
     }
     static from(fields) {
-        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.timings);
+        return new TxSimulationResult(fields.privateExecutionResult, fields.publicInputs, fields.publicOutput, fields.stats);
     }
-    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, timings) {
-        return new TxSimulationResult(privateSimulationResult.privateExecutionResult, privateSimulationResult.publicInputs, publicOutput, timings);
+    static fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput, stats) {
+        return new TxSimulationResult(privateSimulationResult.privateExecutionResult, privateSimulationResult.publicInputs, publicOutput, stats);
     }
     static async random() {
         return new TxSimulationResult(await PrivateExecutionResult.random(), PrivateKernelTailCircuitPublicInputs.empty(), await PublicSimulationOutput.random());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "0.87.5",
+  "version": "0.87.7",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -67,12 +67,12 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.87.5",
-    "@aztec/blob-lib": "0.87.5",
-    "@aztec/constants": "0.87.5",
-    "@aztec/ethereum": "0.87.5",
-    "@aztec/foundation": "0.87.5",
-    "@aztec/noir-noirc_abi": "0.87.5",
+    "@aztec/bb.js": "0.87.7",
+    "@aztec/blob-lib": "0.87.7",
+    "@aztec/constants": "0.87.7",
+    "@aztec/ethereum": "0.87.7",
+    "@aztec/foundation": "0.87.7",
+    "@aztec/noir-noirc_abi": "0.87.7",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.9.0",
     "json-stringify-deterministic": "1.0.12",

package/src/abi/decoder.ts

@@ -7,7 +7,7 @@ import { isAztecAddressStruct, parseSignedInt } from './utils.js';
 /**
  * The type of our decoded ABI.
  */
-export type AbiDecoded = bigint | boolean | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
+export type AbiDecoded = bigint | boolean | string | AztecAddress | AbiDecoded[] | { [key: string]: AbiDecoded };
 
 /**
  * Decodes values using a provided ABI.
@@ -58,11 +58,12 @@ class AbiDecoder {
         return struct;
       }
       case 'string': {
-        const array = [];
+        let str = '';
         for (let i = 0; i < abiType.length; i += 1) {
-          array.push(this.getNextField().toBigInt());
+          const charCode = Number(this.getNextField().toBigInt());
+          str += String.fromCharCode(charCode);
         }
-        return array;
+        return str;
       }
       case 'tuple': {
         const array = [];

package/src/interfaces/prover-agent.ts

@@ -2,19 +2,18 @@ import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/index.js';
 
-export interface ProverAgentApi {
-  setMaxConcurrency(maxConcurrency: number): Promise<void>;
+export const ProverAgentStatusSchema = z.discriminatedUnion('status', [
+  z.object({ status: z.literal('stopped') }),
+  z.object({ status: z.literal('running') }),
+  z.object({ status: z.literal('proving'), jobId: z.string(), proofType: z.number(), startedAtISO: z.string() }),
+]);
 
-  isRunning(): Promise<boolean>;
+export type ProverAgentStatus = z.infer<typeof ProverAgentStatusSchema>;
 
-  getCurrentJobs(): Promise<{ id: string; type: string }[]>;
+export interface ProverAgentApi {
+  getStatus(): Promise<unknown>;
 }
 
 export const ProverAgentApiSchema: ApiSchemaFor<ProverAgentApi> = {
-  setMaxConcurrency: z.function().args(z.number().min(1).int()).returns(z.void()),
-  isRunning: z.function().args().returns(z.boolean()),
-  getCurrentJobs: z
-    .function()
-    .args()
-    .returns(z.array(z.object({ id: z.string(), type: z.string() }))),
+  getStatus: z.function().args().returns(ProverAgentStatusSchema),
 };

package/src/kernel/private_kernel_prover_output.ts

@@ -34,6 +34,7 @@ export interface PrivateExecutionStep {
   timings: {
     witgen: number;
     gateCount?: number;
+    oracles?: Record<string, { times: number[] }>;
   };
 }
 

package/src/logs/pending_tagged_log.ts

@@ -5,7 +5,7 @@ import type { AztecAddress } from '../aztec-address/index.js';
 import type { TxHash } from '../tx/tx_hash.js';
 
 /**
- * Represents a pending tagged log as it is stored in the pending tagged log array to which the syncPrivateState oracle
+ * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
  * inserts found private logs. A TS version of `pending_tagged_log.nr`.
  */
 export class PendingTaggedLog {

package/src/tx/private_execution_result.ts

@@ -255,5 +255,5 @@ export function collectNested<T>(
 }
 
 export class PrivateExecutionProfileResult {
-  constructor(public timings: { witgen: number }) {}
+  constructor(public timings: { witgen: number; oracles?: Record<string, { times: number[] }> }) {}
 }