@aztec/stdlib 0.86.0-starknet.1 → 0.87.0

package/src/p2p/block_attestation.ts

@@ -53,7 +53,7 @@ export class BlockAttestation extends Gossipable {
       .transform(obj => new BlockAttestation(obj.blockNumber, obj.payload, obj.signature));
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
   }
 

package/src/p2p/block_proposal.ts

@@ -5,6 +5,7 @@ import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { Tx } from '../tx/tx.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -20,6 +21,10 @@ export class BlockProposalHash extends Buffer32 {
   }
 }
 
+export type BlockProposalOptions = {
+  publishFullTxs: boolean;
+};
+
 /**
  * BlockProposal
  *
@@ -40,11 +45,15 @@ export class BlockProposal extends Gossipable {
 
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
+
+    // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
+    /** The transactions in the block */
+    public readonly txs?: Tx[],
   ) {
     super();
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockProposalHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -59,12 +68,14 @@ export class BlockProposal extends Gossipable {
   static async createProposalFromSigner(
     blockNumber: Fr,
     payload: ConsensusPayload,
+    // Note(md): Provided separately to tx hashes such that this function can be optional
+    txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
   ) {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig);
+    return new BlockProposal(blockNumber, payload, sig, txs);
   }
 
   /**Get Sender
@@ -85,15 +96,35 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockNumber, this.payload, this.signature]);
+    const buffer: any[] = [this.blockNumber, this.payload, this.signature];
+    if (this.txs) {
+      buffer.push(this.txs.length);
+      buffer.push(this.txs);
+    }
+    return serializeToBuffer(buffer);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
-    return new BlockProposal(reader.readObject(Fr), reader.readObject(ConsensusPayload), reader.readObject(Signature));
+
+    const blockNumber = reader.readObject(Fr);
+    const payload = reader.readObject(ConsensusPayload);
+    const sig = reader.readObject(Signature);
+
+    if (!reader.isEmpty()) {
+      const txs = reader.readArray(reader.readNumber(), Tx);
+      return new BlockProposal(blockNumber, payload, sig, txs);
+    }
+
+    return new BlockProposal(blockNumber, payload, sig);
   }
 
   getSize(): number {
-    return this.blockNumber.size + this.payload.getSize() + this.signature.getSize();
+    return (
+      this.blockNumber.size +
+      this.payload.getSize() +
+      this.signature.getSize() +
+      (this.txs ? this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+    );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -105,4 +105,8 @@ export class ConsensusPayload implements Signable {
     this.size = this.toBuffer().length;
     return this.size;
   }
+
+  toString() {
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(', ')}`;
+  }
 }

package/src/p2p/gossipable.ts

@@ -1,13 +1,43 @@
-import type { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
 
+export class P2PMessage {
+  constructor(
+    public readonly publishTime: Date,
+    public readonly id: Buffer32,
+    public readonly payload: Buffer,
+  ) {}
+
+  static async fromGossipable(message: Gossipable): Promise<P2PMessage> {
+    return new P2PMessage(new Date(), await message.p2pMessageIdentifier(), message.toBuffer());
+  }
+
+  static fromMessageData(messageData: Buffer): P2PMessage {
+    const reader = new BufferReader(messageData);
+    const publishTime = reader.readUInt64();
+    const id = Buffer32.fromBuffer(reader);
+    const payload = reader.readBuffer();
+    return new P2PMessage(new Date(Number(publishTime)), id, payload);
+  }
+
+  toMessageData(): Buffer {
+    return serializeToBuffer([
+      bigintToUInt64BE(BigInt(this.publishTime.getTime())),
+      this.id,
+      serializeToBuffer(this.payload.length, this.payload),
+    ]);
+  }
+}
+
 /**
  * Gossipable
  *
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
+  private cachedId: Buffer32 | undefined;
   /** p2p Topic
    *
    * - The p2p topic identifier, this determines how the message is handled
@@ -18,7 +48,15 @@ export abstract class Gossipable {
    *
    *  - A digest of the message information, this key is used for deduplication
    */
-  abstract p2pMessageIdentifier(): Promise<Buffer32>;
+  async p2pMessageIdentifier(): Promise<Buffer32> {
+    if (this.cachedId) {
+      return this.cachedId;
+    }
+    this.cachedId = await this.generateP2PMessageIdentifier();
+    return this.cachedId;
+  }
+
+  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
   /** To Buffer
    *
@@ -26,6 +64,10 @@ export abstract class Gossipable {
    */
   abstract toBuffer(): Buffer;
 
+  toMessage(): Buffer {
+    return this.toBuffer();
+  }
+
   /**
    * Get the size of the gossipable object.
    *

package/src/p2p/topic_type.ts

@@ -22,6 +22,8 @@ export enum TopicType {
 export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
     return Object.values(TopicType);
+  } else if (clientType === P2PClientType.Prover) {
+    return [TopicType.tx, TopicType.block_proposal];
   }
   return [TopicType.tx];
 }

package/src/rollup/base_rollup_hints.ts

@@ -7,7 +7,7 @@ import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PublicDataHint } from '../avm/public_data_hint.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLogFields } from '../logs/index.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { ConstantRollupData } from './constant_rollup_data.js';
 import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
@@ -39,7 +39,7 @@ export class PrivateBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -86,7 +86,7 @@ export class PrivateBaseRollupHints {
       reader.readObject(PrivateBaseStateDiffHints),
       reader.readObject(PublicDataHint),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(ConstantRollupData),
     );
   }
@@ -102,7 +102,7 @@ export class PrivateBaseRollupHints {
       PrivateBaseStateDiffHints.empty(),
       PublicDataHint.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       ConstantRollupData.empty(),
     );
   }
@@ -121,7 +121,7 @@ export class PublicBaseRollupHints {
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
-    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    public contractClassLogsPreimages: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
     /**
      * Data which is not modified by the base rollup circuit.
      */
@@ -162,7 +162,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
-      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(ConstantRollupData),
     );
   }
@@ -175,7 +175,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
-      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       ConstantRollupData.empty(),
     );
   }

package/src/rollup/block_root_or_block_merge_public_inputs.ts

@@ -133,7 +133,10 @@ export class BlockRootOrBlockMergePublicInputs {
 }
 
 export class FeeRecipient {
-  constructor(public recipient: EthAddress, public value: Fr) {}
+  constructor(
+    public recipient: EthAddress,
+    public value: Fr,
+  ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): FeeRecipient {
     const reader = BufferReader.asReader(buffer);

package/src/rollup/private_base_rollup_inputs.ts

@@ -7,7 +7,10 @@ import { PrivateBaseRollupHints } from './base_rollup_hints.js';
 import { PrivateTubeData } from './private_tube_data.js';
 
 export class PrivateBaseRollupInputs {
-  constructor(public tubeData: PrivateTubeData, public hints: PrivateBaseRollupHints) {}
+  constructor(
+    public tubeData: PrivateTubeData,
+    public hints: PrivateBaseRollupHints,
+  ) {}
 
   static from(fields: FieldsOf<PrivateBaseRollupInputs>): PrivateBaseRollupInputs {
     return new PrivateBaseRollupInputs(...PrivateBaseRollupInputs.getFields(fields));

package/src/rollup/tube_inputs.ts

@@ -10,7 +10,10 @@ import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
  * 'usePublicTailVk' signifies if we should prove this with the public or private kernel tail client IVC VKs.
  */
 export class TubeInputs {
-  constructor(public usePublicTailVk: boolean, public clientIVCData: ClientIvcProof) {}
+  constructor(
+    public usePublicTailVk: boolean,
+    public clientIVCData: ClientIvcProof,
+  ) {}
 
   static from(fields: FieldsOf<TubeInputs>): TubeInputs {
     return new TubeInputs(...TubeInputs.getFields(fields));

package/src/shared_mutable/scheduled_delay_change.ts

@@ -1,7 +1,11 @@
 import type { UInt32 } from '../types/shared.js';
 
 export class ScheduledDelayChange {
-  constructor(public pre: UInt32 | undefined, public post: UInt32 | undefined, public blockOfChange: UInt32) {}
+  constructor(
+    public pre: UInt32 | undefined,
+    public post: UInt32 | undefined,
+    public blockOfChange: UInt32,
+  ) {}
 
   static empty() {
     return new this(undefined, undefined, 0);

package/src/shared_mutable/scheduled_value_change.ts

@@ -1,7 +1,11 @@
 import { Fr } from '@aztec/foundation/fields';
 
 export class ScheduledValueChange {
-  constructor(public previous: Fr[], public post: Fr[], public blockOfChange: number) {
+  constructor(
+    public previous: Fr[],
+    public post: Fr[],
+    public blockOfChange: number,
+  ) {
     if (this.previous.length !== this.post.length) {
       throw new Error('Previous and post must have the same length');
     }

package/src/shared_mutable/shared_mutable_values.ts

@@ -9,7 +9,10 @@ import { ScheduledValueChange } from './scheduled_value_change.js';
 export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
 
 export class SharedMutableValues {
-  constructor(public svc: ScheduledValueChange, public sdc: ScheduledDelayChange) {}
+  constructor(
+    public svc: ScheduledValueChange,
+    public sdc: ScheduledDelayChange,
+  ) {}
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);

package/src/tests/factories.ts

@@ -4,7 +4,7 @@ import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AZTEC_MAX_EPOCH_DURATION,
   BLOBS_PER_BLOCK,
-  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
+  CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
   FIELDS_PER_BLOB,
   FIXED_DA_GAS,
   FIXED_L2_GAS,
@@ -36,7 +36,7 @@ import {
   NUM_MSGS_PER_BASE_PARITY,
   PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
   RECURSIVE_PROOF_LENGTH,
   TUBE_PROOF_LENGTH,
   VK_TREE_HEIGHT,
@@ -108,7 +108,7 @@ import {
   PrivateToRollupAccumulatedData,
   mergeAccumulatedData,
 } from '../kernel/index.js';
-import { LogHash, ScopedLogHash } from '../kernel/log_hash.js';
+import { CountedLogHash, LogHash, ScopedLogHash } from '../kernel/log_hash.js';
 import { NoteHash } from '../kernel/note_hash.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCallRequest } from '../kernel/private_call_request.js';
@@ -117,7 +117,7 @@ import { PrivateLogData } from '../kernel/private_log_data.js';
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
 import { CountedPublicCallRequest, PublicCallRequest } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { PublicLog } from '../logs/public_log.js';
 import { L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
@@ -178,7 +178,11 @@ import { mockTx } from './mocks.js';
  * @returns A side effect object.
  */
 function makeLogHash(seed: number) {
-  return new LogHash(fr(seed), seed + 1, seed + 2);
+  return new LogHash(fr(seed), seed + 1);
+}
+
+function makeCountedLogHash(seed: number) {
+  return new CountedLogHash(makeLogHash(seed), seed + 0x10);
 }
 
 function makeScopedLogHash(seed: number) {
@@ -193,16 +197,8 @@ function makeNullifier(seed: number) {
   return new Nullifier(fr(seed), seed + 1, fr(seed + 2));
 }
 
-function makeContractClassLog(seed: number) {
-  // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
-  return new ContractClassLog(
-    makeAztecAddress(seed),
-    makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS * 1, fr, seed + 1),
-  );
-}
-
 function makePrivateLog(seed: number) {
-  return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed));
+  return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed), PRIVATE_LOG_SIZE_IN_FIELDS);
 }
 
 function makePrivateLogData(seed: number) {
@@ -210,7 +206,11 @@ function makePrivateLogData(seed: number) {
 }
 
 function makePublicLog(seed: number) {
-  return new PublicLog(makeAztecAddress(seed), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, fr, seed + 1));
+  return new PublicLog(
+    makeAztecAddress(seed),
+    makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, fr, seed + 1),
+    PUBLIC_LOG_SIZE_IN_FIELDS,
+  );
 }
 
 /**
@@ -548,6 +548,7 @@ export function makeTxRequest(seed = 1): TxRequest {
     functionData: new FunctionData(makeSelector(seed + 0x100), /*isPrivate=*/ true),
     argsHash: fr(seed + 0x200),
     txContext: makeTxContext(seed + 0x400),
+    salt: fr(seed + 0x500),
   });
 }
 
@@ -577,7 +578,7 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
     publicTeardownCallRequest: makePublicCallRequest(seed + 0x800),
     l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeL2ToL1Message, seed + 0x800),
     privateLogs: makeTuple(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
-    contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeLogHash, seed + 0xa00),
+    contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
     startSideEffectCounter: fr(seed + 0x849),
     endSideEffectCounter: fr(seed + 0x850),
     historicalHeader: makeHeader(seed + 0xd00, undefined),
@@ -1081,6 +1082,10 @@ function makePrivateTubeData(seed = 1, kernelPublicInputs?: PrivateToRollupKerne
   );
 }
 
+function makeContractClassLogFields(seed = 1) {
+  return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
+}
+
 function makePrivateBaseRollupHints(seed = 1) {
   const start = makePartialStateReference(seed + 0x100);
 
@@ -1090,7 +1095,11 @@ function makePrivateBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
+  const contractClassLogsPreimages = makeTuple(
+    MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    makeContractClassLogFields,
+    seed + 0x800,
+  );
 
   const constants = makeConstantRollupData(0x100);
 
@@ -1112,7 +1121,11 @@ function makePublicBaseRollupHints(seed = 1) {
 
   const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
 
-  const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
+  const contractClassLogsPreimages = makeTuple(
+    MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    makeContractClassLogFields,
+    seed + 0x800,
+  );
 
   const constants = makeConstantRollupData(0x100);
 

package/src/tests/mocks.ts

@@ -242,6 +242,7 @@ export interface MakeConsensusPayloadOptions {
   archive?: Fr;
   stateReference?: StateReference;
   txHashes?: TxHash[];
+  txs?: Tx[];
 }
 
 const makeAndSignConsensusPayload = (
@@ -274,7 +275,7 @@ export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockP
     SignatureDomainSeparator.blockProposal,
     options,
   );
-  return new BlockProposal(blockNumber, payload, signature);
+  return new BlockProposal(blockNumber, payload, signature, options?.txs ?? []);
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)

package/src/tx/content_commitment.ts

@@ -9,7 +9,12 @@ import { z } from 'zod';
 export const NUM_BYTES_PER_SHA256 = 32;
 
 export class ContentCommitment {
-  constructor(public numTxs: Fr, public blobsHash: Buffer, public inHash: Buffer, public outHash: Buffer) {
+  constructor(
+    public numTxs: Fr,
+    public blobsHash: Buffer,
+    public inHash: Buffer,
+    public outHash: Buffer,
+  ) {
     // NB: we do not calculate blobHash in the circuit, but we still truncate it so it fits in a field
     if (blobsHash.length !== NUM_BYTES_PER_SHA256) {
       throw new Error(`blobsHash buffer must be ${NUM_BYTES_PER_SHA256} bytes`);

package/src/tx/private_execution_result.ts

@@ -9,7 +9,7 @@ import { NoteSelector } from '../abi/note_selector.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
 import { HashedValues } from './hashed_values.js';
@@ -47,7 +47,10 @@ export class NoteAndSlot {
 }
 
 export class CountedContractClassLog implements IsEmpty {
-  constructor(public log: ContractClassLog, public counter: number) {}
+  constructor(
+    public log: ContractClassLog,
+    public counter: number,
+  ) {}
 
   static get schema(): ZodFor<CountedContractClassLog> {
     return z
@@ -132,7 +135,8 @@ export class PrivateCallExecutionResult {
     public nestedExecutions: PrivateCallExecutionResult[],
     /**
      * Contract class logs emitted during execution of this function call.
-     * Note: These are preimages to `contractClassLogsHashes`.
+     * Note: We only need to collect the ContractClassLogFields as preimages for the tx.
+     * But keep them as ContractClassLog so that we can verify the log hashes before submitting the tx (TODO).
      */
     public contractClassLogs: CountedContractClassLog[],
     public profileResult?: PrivateExecutionProfileResult,
@@ -223,10 +227,10 @@ function collectContractClassLogs(execResult: PrivateCallExecutionResult): Count
  * @param execResult - The topmost execution result.
  * @returns All contract class logs.
  */
-export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLog[] {
+export function collectSortedContractClassLogs(execResult: PrivateExecutionResult): ContractClassLogFields[] {
   const allLogs = collectContractClassLogs(execResult.entrypoint);
   const sortedLogs = sortByCounter(allLogs);
-  return sortedLogs.map(l => l.log);
+  return sortedLogs.map(l => l.log.fields);
 }
 
 export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {

package/src/tx/profiling.ts

@@ -1,8 +1,11 @@
+import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, optional } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import type { AbiDecoded } from '../abi/decoder.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
+import { AbiDecodedSchema } from '../schemas/schemas.js';
 
 type FunctionTiming = {
   functionName: string;
@@ -46,7 +49,10 @@ export const SimulationTimingsSchema = z.object({
 });
 
 export class TxProfileResult {
-  constructor(public executionSteps: PrivateExecutionStep[], public timings: ProvingTimings) {}
+  constructor(
+    public executionSteps: PrivateExecutionStep[],
+    public timings: ProvingTimings,
+  ) {}
 
   static get schema(): ZodFor<TxProfileResult> {
     return z
@@ -86,3 +92,35 @@ export class TxProfileResult {
     );
   }
 }
+
+export class UtilitySimulationResult {
+  constructor(
+    public result: AbiDecoded,
+    public timings?: SimulationTimings,
+  ) {}
+
+  static get schema(): ZodFor<UtilitySimulationResult> {
+    return z
+      .object({
+        result: AbiDecodedSchema,
+        timings: optional(SimulationTimingsSchema),
+      })
+      .transform(({ result, timings }) => new UtilitySimulationResult(result, timings));
+  }
+
+  static random(): UtilitySimulationResult {
+    return new UtilitySimulationResult(Fr.random().toBigInt(), {
+      sync: 1,
+      publicSimulation: 1,
+      validation: 1,
+      perFunction: [
+        {
+          functionName: 'random',
+          time: 1,
+        },
+      ],
+      unaccounted: 1,
+      total: 5,
+    });
+  }
+}

package/src/tx/proposed_block_header.ts

@@ -154,6 +154,7 @@ export class ProposedBlockHeader {
   }
 
   [inspect.custom]() {
+    const gasfees = `da:${this.gasFees.feePerDaGas.toBigInt()}, l2:${this.gasFees.feePerL2Gas.toBigInt()}`;
     return `Header {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
   contentCommitment: ${inspect(this.contentCommitment)},
@@ -161,7 +162,7 @@ export class ProposedBlockHeader {
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},
   feeRecipient: ${this.feeRecipient.toString()},
-  gasFees: ${this.gasFees.toInspect()},
+  gasFees: ${gasfees},
   totalManaUsed: ${this.totalManaUsed.toBigInt()},
 }`;
   }