@aztec/stdlib 0.86.0 → 0.87.0

package/src/interfaces/aztec-node-admin.ts

@@ -28,12 +28,28 @@ export interface AztecNodeAdmin {
    * @param location - The location to upload the snapshot to.
    */
   startSnapshotUpload(location: string): Promise<void>;
+
+  /**
+   * Pauses syncing and rolls back the database to the target L2 block number.
+   * @param targetBlockNumber - The block number to roll back to.
+   * @param force - If true, clears the world state db and p2p dbs if rolling back to behind the finalized block.
+   */
+  rollbackTo(targetBlockNumber: number, force?: boolean): Promise<void>;
+
+  /** Pauses archiver and world state syncing. */
+  pauseSync(): Promise<void>;
+
+  /** Resumes archiver and world state syncing. */
+  resumeSync(): Promise<void>;
 }
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
   setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
   flushTxs: z.function().returns(z.void()),
   startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
+  rollbackTo: z.function().args(z.number()).returns(z.void()),
+  pauseSync: z.function().returns(z.void()),
+  resumeSync: z.function().returns(z.void()),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/aztec-node.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/constants';
 import { type L1ContractAddresses, L1ContractAddressesSchema } from '@aztec/ethereum/l1-contract-addresses';
 import type { Fr } from '@aztec/foundation/fields';
-import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
 import { SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
@@ -551,11 +551,13 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 export function createAztecNodeClient(
   url: string,
   versions: Partial<ComponentsVersions> = {},
-  fetch = defaultFetch,
+  fetch = makeFetch([1, 2, 3], false),
+  batchWindowMS = 0,
 ): AztecNode {
   return createSafeJsonRpcClient<AztecNode>(url, AztecNodeApiSchema, {
     namespaceMethods: 'node',
     fetch,
+    batchWindowMS,
     onResponse: getVersioningResponseHandler(versions),
   });
 }

package/src/interfaces/configs.ts

@@ -16,6 +16,8 @@ export interface SequencerConfig {
   maxTxsPerBlock?: number;
   /** The minimum number of txs to include in a block. */
   minTxsPerBlock?: number;
+  /** Whether to publish txs with the block proposals */
+  publishTxsWithProposals?: boolean;
   /** The maximum L2 block gas. */
   maxL2BlockGas?: number;
   /** The maximum DA block gas. */
@@ -45,6 +47,7 @@ export const SequencerConfigSchema = z.object({
   maxTxsPerBlock: z.number().optional(),
   minTxsPerBlock: z.number().optional(),
   maxL2BlockGas: z.number().optional(),
+  publishTxsWithProposals: z.boolean().optional(),
   maxDABlockGas: z.number().optional(),
   coinbase: schemas.EthAddress.optional(),
   feeRecipient: schemas.AztecAddress.optional(),

package/src/interfaces/p2p.ts

@@ -30,6 +30,9 @@ export interface P2PApiWithoutAttestations {
    */
   getPendingTxs(): Promise<Tx[]>;
 
+  /** Returns the number of pending txs in the p2p tx pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Returns the ENR for this node, if any.
    */
@@ -65,6 +68,7 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
     .args(schemas.BigInt, optional(z.string()))
     .returns(z.array(BlockAttestation.schema)),
   getPendingTxs: z.function().returns(z.array(Tx.schema)),
+  getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
   addAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),

package/src/interfaces/prover-client.ts

@@ -113,7 +113,10 @@ export class BlockProofError extends Error {
   static #name = 'BlockProofError';
   override name = BlockProofError.#name;
 
-  constructor(message: string, public readonly txHashes: TxHash[]) {
+  constructor(
+    message: string,
+    public readonly txHashes: TxHash[],
+  ) {
     super(message);
   }
 

package/src/interfaces/pxe.ts

@@ -6,7 +6,6 @@ import { SiblingPath } from '@aztec/foundation/trees';
 import { z } from 'zod';
 
 import { type AbiType, AbiTypeSchema, type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
-import type { AbiDecoded } from '../abi/decoder.js';
 import type { EventSelector } from '../abi/event_selector.js';
 import { AuthWitness } from '../auth_witness/auth_witness.js';
 import type { AztecAddress } from '../aztec-address/index.js';
@@ -38,7 +37,7 @@ import {
   TxSimulationResult,
   indexedTxSchema,
 } from '../tx/index.js';
-import { TxProfileResult } from '../tx/profiled_tx.js';
+import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
 import {
   type GetContractClassLogsResponse,
@@ -139,12 +138,13 @@ export interface PXE {
    * (where validators prove the public portion).
    *
    * @param txRequest - An authenticated tx request ready for proving
-   * @param privateExecutionResult - The result of the private execution of the transaction
+   * @param privateExecutionResult - (optional) The result of the private execution of the transaction. The txRequest
+   * will be executed if not provided
    * @returns A result containing the proof and public inputs of the tail circuit.
    * @throws If contract code not found, or public simulation reverts.
    * Also throws if simulatePublic is true and public simulation reverts.
    */
-  proveTx(txRequest: TxExecutionRequest, privateExecutionResult: PrivateExecutionResult): Promise<TxProvingResult>;
+  proveTx(txRequest: TxExecutionRequest, privateExecutionResult?: PrivateExecutionResult): Promise<TxProvingResult>;
 
   /**
    * Simulates a transaction based on the provided preauthenticated execution request.
@@ -188,6 +188,7 @@ export interface PXE {
   profileTx(
     txRequest: TxExecutionRequest,
     profileMode: 'gates' | 'execution-steps' | 'full',
+    skipProofGeneration?: boolean,
     msgSender?: AztecAddress,
   ): Promise<TxProfileResult>;
 
@@ -289,7 +290,7 @@ export interface PXE {
     authwits?: AuthWitness[],
     from?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<AbiDecoded>;
+  ): Promise<UtilitySimulationResult>;
 
   /**
    * Gets public logs based on the provided filter.
@@ -455,12 +456,16 @@ export const PXESchema: ApiSchemaFor<PXE> = {
     .returns(z.void()),
   updateContract: z.function().args(schemas.AztecAddress, ContractArtifactSchema).returns(z.void()),
   getContracts: z.function().returns(z.array(schemas.AztecAddress)),
-  proveTx: z.function().args(TxExecutionRequest.schema, PrivateExecutionResult.schema).returns(TxProvingResult.schema),
+  proveTx: z
+    .function()
+    .args(TxExecutionRequest.schema, optional(PrivateExecutionResult.schema))
+    .returns(TxProvingResult.schema),
   profileTx: z
     .function()
     .args(
       TxExecutionRequest.schema,
       z.union([z.literal('gates'), z.literal('full'), z.literal('execution-steps')]),
+      optional(z.boolean()),
       optional(schemas.AztecAddress),
     )
     .returns(TxProfileResult.schema),
@@ -504,7 +509,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(schemas.AztecAddress),
       optional(z.array(schemas.AztecAddress)),
     )
-    .returns(AbiDecodedSchema),
+    .returns(UtilitySimulationResult.schema),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
   getBlockNumber: z.function().returns(z.number()),

package/src/interfaces/service.ts

@@ -1,5 +1,4 @@
 import type { Logger } from '@aztec/foundation/log';
-import type { Maybe } from '@aztec/foundation/types';
 
 /** Represents a local service that can be started and stopped. */
 export interface Service {
@@ -17,7 +16,7 @@ export interface Service {
 }
 
 /** Tries to call stop on a given object and awaits it. Logs any errors and does not rethrow. */
-export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise<void> {
+export async function tryStop(service?: Partial<Service>, logger?: Logger): Promise<void> {
   try {
     return typeof service === 'object' && service && 'stop' in service && typeof service.stop === 'function'
       ? await service.stop()
@@ -27,7 +26,7 @@ export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise
   }
 }
 
-export function tryRestart(service: Maybe<Service>, logger?: Logger) {
+export function tryRestart(service?: Partial<Service>, logger?: Logger) {
   try {
     return typeof service === 'object' && service && 'restart' in service && typeof service.restart === 'function'
       ? service.restart()

package/src/interfaces/world_state.ts

@@ -1,3 +1,5 @@
+import type { PromiseWithResolvers } from '@aztec/foundation/promise';
+
 import { z } from 'zod';
 
 import type { SnapshotDataKeys } from '../snapshots/types.js';
@@ -52,7 +54,7 @@ export interface ForkMerkleTreeOperations {
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
   /** Starts the synchronizer. */
-  start(): void;
+  start(): Promise<void | PromiseWithResolvers<void>>;
 
   /** Returns the current status of the synchronizer. */
   status(): Promise<WorldStateSynchronizerStatus>;
@@ -76,6 +78,9 @@ export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
 
   /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
   getCommitted(): MerkleTreeReadOperations;
+
+  /** Deletes the db */
+  clear(): Promise<void>;
 }
 
 export const WorldStateSyncStatusSchema = z.object({

package/src/kernel/hints/note_hash_read_request_hints.ts

@@ -42,7 +42,10 @@ export class NoteHashReadRequestHintsBuilder<PENDING extends number, SETTLED ext
   public numPendingReadHints = 0;
   public numSettledReadHints = 0;
 
-  constructor(public readonly maxPending: PENDING, public readonly maxSettled: SETTLED) {
+  constructor(
+    public readonly maxPending: PENDING,
+    public readonly maxSettled: SETTLED,
+  ) {
     this.hints = new ReadRequestResetHints(
       makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),

package/src/kernel/hints/nullifier_read_request_hints.ts

@@ -40,7 +40,10 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
   private numPendingReadHints = 0;
   private numSettledReadHints = 0;
 
-  constructor(public readonly maxPending: PENDING, public readonly maxSettled: SETTLED) {
+  constructor(
+    public readonly maxPending: PENDING,
+    public readonly maxSettled: SETTLED,
+  ) {
     this.hints = new ReadRequestResetHints(
       makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NULLIFIER_READ_REQUESTS_PER_TX)),

package/src/kernel/hints/read_request.ts

@@ -71,7 +71,10 @@ export class ReadRequest {
  * ReadRequest with context of the contract emitting the request.
  */
 export class ScopedReadRequest {
-  constructor(public readRequest: ReadRequest, public contractAddress: AztecAddress) {}
+  constructor(
+    public readRequest: ReadRequest,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get value() {
     return this.readRequest.value;

package/src/kernel/hints/read_request_hints.ts

@@ -9,7 +9,10 @@ export enum ReadRequestState {
 }
 
 export class ReadRequestStatus {
-  constructor(public state: ReadRequestState, public hintIndex: number) {}
+  constructor(
+    public state: ReadRequestState,
+    public hintIndex: number,
+  ) {}
 
   static nada() {
     return new ReadRequestStatus(ReadRequestState.NADA, 0);
@@ -34,7 +37,10 @@ export class ReadRequestStatus {
 }
 
 export class PendingReadHint {
-  constructor(public readRequestIndex: number, public pendingValueIndex: number) {}
+  constructor(
+    public readRequestIndex: number,
+    public pendingValueIndex: number,
+  ) {}
 
   static nada(readRequestLen: number) {
     return new PendingReadHint(readRequestLen, 0);
@@ -154,7 +160,10 @@ export class ReadRequestResetHints<
 }
 
 export class ReadRequestResetStates<NUM_READS extends number> {
-  constructor(public states: Tuple<ReadRequestState, NUM_READS>, public pendingReadHints: PendingReadHint[]) {}
+  constructor(
+    public states: Tuple<ReadRequestState, NUM_READS>,
+    public pendingReadHints: PendingReadHint[],
+  ) {}
 
   static empty<NUM_READS extends number>(numReads: NUM_READS) {
     return new ReadRequestResetStates(

package/src/kernel/hints/transient_data_index_hint.ts

@@ -4,7 +4,10 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 import { inspect } from 'util';
 
 export class TransientDataIndexHint {
-  constructor(public nullifierIndex: number, public noteHashIndex: number) {}
+  constructor(
+    public nullifierIndex: number,
+    public noteHashIndex: number,
+  ) {}
 
   toFields(): Fr[] {
     return [new Fr(this.nullifierIndex), new Fr(this.noteHashIndex)];

package/src/kernel/hints/tree_leaf_read_request.ts

@@ -2,7 +2,10 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class TreeLeafReadRequest {
-  constructor(public value: Fr, public leafIndex: Fr) {}
+  constructor(
+    public value: Fr,
+    public leafIndex: Fr,
+  ) {}
 
   toBuffer(): Buffer {
     return serializeToBuffer(this.value, this.leafIndex);

package/src/kernel/log_hash.ts

@@ -1,42 +1,49 @@
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { Ordered } from './utils/interfaces.js';
 
-export class LogHash implements Ordered {
-  constructor(public value: Fr, public counter: number, public length: number) {}
+export class LogHash {
+  constructor(
+    public value: Fr,
+    public length: number,
+  ) {}
+
+  static from(fields: FieldsOf<LogHash>) {
+    return new LogHash(fields.value, fields.length);
+  }
 
   toFields(): Fr[] {
-    return [this.value, new Fr(this.counter), new Fr(this.length)];
+    return [this.value, new Fr(this.length)];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new LogHash(reader.readField(), reader.readU32(), reader.readU32());
+    return new LogHash(reader.readField(), reader.readU32());
   }
 
   isEmpty() {
-    return this.value.isZero() && !this.length && !this.counter;
+    return this.value.isZero() && !this.length;
   }
 
   static empty() {
-    return new LogHash(Fr.zero(), 0, 0);
+    return new LogHash(Fr.zero(), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(this.value, this.counter, this.length);
+    return serializeToBuffer(this.value, this.length);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new LogHash(Fr.fromBuffer(reader), reader.readNumber(), reader.readNumber());
+    return new LogHash(Fr.fromBuffer(reader), reader.readNumber());
   }
 
   toString(): string {
-    return `value=${this.value} counter=${this.counter} length=${this.length}`;
+    return `value=${this.value} length=${this.length}`;
   }
 
   scope(contractAddress: AztecAddress) {
@@ -48,13 +55,45 @@ export class LogHash implements Ordered {
   }
 }
 
-export class ScopedLogHash implements Ordered {
-  constructor(public logHash: LogHash, public contractAddress: AztecAddress) {}
+export class CountedLogHash {
+  constructor(
+    public logHash: LogHash,
+    public counter: number,
+  ) {}
+
+  toFields(): Fr[] {
+    return [...this.logHash.toFields(), new Fr(this.counter)];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new CountedLogHash(reader.readObject(LogHash), reader.readU32());
+  }
+
+  isEmpty() {
+    return this.logHash.isEmpty() && !this.counter;
+  }
+
+  static empty() {
+    return new CountedLogHash(LogHash.empty(), 0);
+  }
 
-  get counter() {
-    return this.logHash.counter;
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.logHash, this.counter);
   }
 
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CountedLogHash(LogHash.fromBuffer(reader), reader.readNumber());
+  }
+}
+
+export class ScopedLogHash {
+  constructor(
+    public logHash: LogHash,
+    public contractAddress: AztecAddress,
+  ) {}
+
   get value() {
     return this.logHash.value;
   }
@@ -89,3 +128,36 @@ export class ScopedLogHash implements Ordered {
     return `logHash=${this.logHash} contractAddress=${this.contractAddress}`;
   }
 }
+
+export class ScopedCountedLogHash {
+  constructor(
+    public inner: CountedLogHash,
+    public contractAddress: AztecAddress,
+  ) {}
+
+  toFields(): Fr[] {
+    return [...this.inner.toFields(), this.contractAddress.toField()];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new ScopedCountedLogHash(reader.readObject(CountedLogHash), AztecAddress.fromField(reader.readField()));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.inner, this.contractAddress);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new ScopedCountedLogHash(CountedLogHash.fromBuffer(reader), AztecAddress.fromBuffer(reader));
+  }
+
+  isEmpty() {
+    return this.inner.isEmpty() && this.contractAddress.isZero();
+  }
+
+  static empty() {
+    return new ScopedCountedLogHash(CountedLogHash.empty(), AztecAddress.ZERO);
+  }
+}

package/src/kernel/note_hash.ts

@@ -5,7 +5,10 @@ import { AztecAddress } from '../aztec-address/index.js';
 import type { Ordered } from './utils/interfaces.js';
 
 export class NoteHash {
-  constructor(public value: Fr, public counter: number) {}
+  constructor(
+    public value: Fr,
+    public counter: number,
+  ) {}
 
   toFields(): Fr[] {
     return [this.value, new Fr(this.counter)];
@@ -43,7 +46,10 @@ export class NoteHash {
 }
 
 export class ScopedNoteHash implements Ordered {
-  constructor(public noteHash: NoteHash, public contractAddress: AztecAddress) {}
+  constructor(
+    public noteHash: NoteHash,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get counter() {
     return this.noteHash.counter;

package/src/kernel/nullifier.ts

@@ -5,7 +5,11 @@ import { AztecAddress } from '../aztec-address/index.js';
 import type { Ordered } from './utils/interfaces.js';
 
 export class Nullifier implements Ordered {
-  constructor(public value: Fr, public counter: number, public noteHash: Fr) {}
+  constructor(
+    public value: Fr,
+    public counter: number,
+    public noteHash: Fr,
+  ) {}
 
   toFields(): Fr[] {
     return [this.value, new Fr(this.counter), this.noteHash];
@@ -43,7 +47,10 @@ export class Nullifier implements Ordered {
 }
 
 export class ScopedNullifier implements Ordered {
-  constructor(public nullifier: Nullifier, public contractAddress: AztecAddress) {}
+  constructor(
+    public nullifier: Nullifier,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get counter() {
     return this.nullifier.counter;

package/src/kernel/private_accumulated_data.ts

@@ -12,7 +12,7 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
-import { ScopedLogHash } from './log_hash.js';
+import { ScopedCountedLogHash } from './log_hash.js';
 import { ScopedNoteHash } from './note_hash.js';
 import { ScopedNullifier } from './nullifier.js';
 import { PrivateCallRequest } from './private_call_request.js';
@@ -45,7 +45,7 @@ export class PrivateAccumulatedData {
      * Accumulated contract class logs from all the previous kernel iterations.
      * Note: Truncated to 31 bytes to fit in Fr.
      */
-    public contractClassLogsHashes: Tuple<ScopedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsHashes: Tuple<ScopedCountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Accumulated public call requests from all the previous kernel iterations.
      */
@@ -84,7 +84,7 @@ export class PrivateAccumulatedData {
       reader.readArray(MAX_NULLIFIERS_PER_TX, ScopedNullifier),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
       reader.readArray(MAX_PRIVATE_LOGS_PER_TX, ScopedPrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash),
+      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedCountedLogHash),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, CountedPublicCallRequest),
       reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, PrivateCallRequest),
     );
@@ -105,7 +105,7 @@ export class PrivateAccumulatedData {
       makeTuple(MAX_NULLIFIERS_PER_TX, ScopedNullifier.empty),
       makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message.empty),
       makeTuple(MAX_PRIVATE_LOGS_PER_TX, ScopedPrivateLogData.empty),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedLogHash.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ScopedCountedLogHash.empty),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, CountedPublicCallRequest.empty),
       makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, PrivateCallRequest.empty),
     );

package/src/kernel/private_call_request.ts

@@ -94,6 +94,6 @@ export class PrivateCallRequest {
   }
 
   toString() {
-    return `PrivateCallRequest(callContext: ${this.callContext}, argsHash: ${this.argsHash}, returnsHash: ${this.returnsHash}, startSideEffectCounter: ${this.startSideEffectCounter}, endSideEffectCounter: ${this.endSideEffectCounter})`;
+    return `PrivateCallRequest(contractAddress: ${this.callContext.contractAddress}, selector: ${this.callContext.functionSelector}, msgSender: ${this.callContext.msgSender}, isStatic: ${this.callContext.isEmpty},  argsHash: ${this.argsHash}, returnsHash: ${this.returnsHash}, startSideEffectCounter: ${this.startSideEffectCounter}, endSideEffectCounter: ${this.endSideEffectCounter})`;
   }
 }

package/src/kernel/private_circuit_public_inputs.ts

@@ -24,7 +24,7 @@ import {
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
-import { LogHash } from '../kernel/log_hash.js';
+import { CountedLogHash } from '../kernel/log_hash.js';
 import { PrivateCallRequest } from '../kernel/private_call_request.js';
 import { PrivateLogData } from '../kernel/private_log_data.js';
 import { L2ToL1Message } from '../messaging/l2_to_l1_message.js';
@@ -113,7 +113,7 @@ export class PrivateCircuitPublicInputs {
     /**
      * Hash of the contract class logs emitted in this function call.
      */
-    public contractClassLogsHashes: Tuple<LogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
+    public contractClassLogsHashes: Tuple<CountedLogHash, typeof MAX_CONTRACT_CLASS_LOGS_PER_CALL>,
     /**
      * The side effect counter at the start of this call.
      */
@@ -169,7 +169,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(PublicCallRequest),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_CALL, L2ToL1Message),
       reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash),
+      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash),
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(BlockHeader),
@@ -196,7 +196,7 @@ export class PrivateCircuitPublicInputs {
       reader.readObject(PublicCallRequest),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_CALL, L2ToL1Message),
       reader.readArray(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash),
+      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash),
       reader.readField(),
       reader.readField(),
       reader.readObject(BlockHeader),
@@ -226,7 +226,7 @@ export class PrivateCircuitPublicInputs {
       PublicCallRequest.empty(),
       makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, L2ToL1Message.empty),
       makeTuple(MAX_PRIVATE_LOGS_PER_CALL, PrivateLogData.empty),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_CALL, LogHash.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_CALL, CountedLogHash.empty),
       Fr.ZERO,
       Fr.ZERO,
       BlockHeader.empty(),

package/src/kernel/private_kernel_prover_output.ts

@@ -15,6 +15,10 @@ export const PrivateExecutionStepSchema = z.object({
   bytecode: bufferSchema,
   witness: mapSchema(z.number(), z.string()),
   vk: bufferSchema,
+  timings: z.object({
+    witgen: z.number(),
+    gateCount: z.number().optional(),
+  }),
 });
 
 /**
@@ -27,6 +31,10 @@ export interface PrivateExecutionStep {
   witness: WitnessMap;
   /* TODO(https://github.com/AztecProtocol/barretenberg/issues/1328) this should get its own proper class. */
   vk: Buffer;
+  timings: {
+    witgen: number;
+    gateCount?: number;
+  };
 }
 
 /** Represents the output of proven PrivateKernelSimulateOutput.*/
@@ -45,6 +53,8 @@ export interface PrivateKernelExecutionProofOutput<
    * If simulate is ran with profiling mode, also includes gate counts.
    */
   executionSteps: PrivateExecutionStep[];
+  /** Performance metrics */
+  timings?: { proving: number };
 }
 
 export function serializePrivateExecutionSteps(steps: PrivateExecutionStep[]) {