@aztec/stdlib 0.0.1-commit.b33fc05d0 → 0.0.1-commit.b3d3157a

package/src/timetable/index.ts

@@ -25,6 +25,179 @@ export const DEFAULT_L1_PUBLISHING_TIME = 12;
 /** Minimum execution time for building a block in seconds */
 export const MIN_EXECUTION_TIME = 2;
 
+export type CheckpointTimingConfig = {
+  aztecSlotDuration: number;
+  ethereumSlotDuration?: number;
+  blockDuration?: number;
+  checkpointAssembleTime?: number;
+  checkpointInitializationTime?: number;
+  l1PublishingTime?: number;
+  minExecutionTime?: number;
+  p2pPropagationTime?: number;
+};
+
+export interface CheckpointTiming {
+  readonly aztecSlotDuration: number;
+  readonly blockDuration: number | undefined;
+  readonly checkpointAssembleTime: number;
+  readonly checkpointInitializationTime: number;
+  readonly l1PublishingTime: number;
+  readonly minExecutionTime: number;
+  readonly p2pPropagationTime: number;
+  readonly checkpointFinalizationTime: number;
+  readonly pipeliningAttestationGracePeriod: number;
+  readonly timeReservedAtEnd: number;
+  readonly minimumBuildSlotWork: number;
+  readonly initializeDeadline: number;
+  readonly checkpointAssemblyDeadline: number;
+  readonly checkpointAttestationStartDeadline: number;
+  readonly checkpointAttestationDeadline: number;
+  readonly checkpointPublishingDeadline: number;
+
+  calculateMaxBlocksPerSlot(): number;
+}
+
+export interface PipelinedCheckpointTiming extends CheckpointTiming {
+  readonly proposalWindowIntoTargetSlot: number;
+  readonly attestationWindowIntoTargetSlot: number;
+}
+
+/**
+ * Checkpoint timing model for proposer pipelining.
+ *
+ * The build work starts at the wall-clock slot boundary and the checkpoint
+ * proposal is broadcast early enough that attestations complete by the end of
+ * the build slot. L1 submission can then be sent at the boundary of the target
+ * slot. The target-slot window getters are intended for consumers such as P2P
+ * validators that need to validate pipelined messages against wallclock time.
+ */
+class CheckpointTimingModel implements PipelinedCheckpointTiming {
+  public readonly aztecSlotDuration: number;
+  public readonly blockDuration: number | undefined;
+  public readonly checkpointAssembleTime: number;
+  public readonly checkpointInitializationTime: number;
+  public readonly l1PublishingTime: number;
+  public readonly minExecutionTime: number;
+  public readonly p2pPropagationTime: number;
+  private readonly ethereumSlotDuration: number;
+
+  constructor(opts: CheckpointTimingConfig) {
+    this.aztecSlotDuration = opts.aztecSlotDuration;
+    this.blockDuration = opts.blockDuration;
+
+    this.checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+    this.checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+    this.l1PublishingTime = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+    this.minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+    this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
+    this.ethereumSlotDuration = opts.ethereumSlotDuration ?? this.l1PublishingTime;
+  }
+
+  public get checkpointFinalizationTime(): number {
+    // Allow enough time to
+    // - build the checkpoint
+    // - Round-trip over p2p
+    // - Publish to L1
+    return this.checkpointAssembleTime + this.p2pPropagationTime * 2 + this.l1PublishingTime;
+  }
+
+  public get proposalWindowIntoTargetSlot(): number {
+    // Proposals no longer spill into the target slot: they are broadcast early
+    // enough in the build slot that attestations complete before the boundary.
+    // Any residual tolerance into the target slot is covered by clock disparity.
+    return 0;
+  }
+
+  public get attestationWindowIntoTargetSlot(): number {
+    // Span from the target-slot start to the L1 publish deadline (12s before the last L1 block of
+    // the target slot). The p2p layer accepts slot-N attestations until right before the publish
+    // deadline so the proposer can keep collecting useful attestations up to the latest moment the
+    // checkpoint can still land on L1 in the target slot.
+    return Math.max(0, this.aztecSlotDuration - 2 * this.ethereumSlotDuration);
+  }
+
+  public get pipeliningAttestationGracePeriod(): number {
+    // Under the early-pipelining regime attestations complete inside the build slot itself. Local
+    // networks can publish much faster than the Ethereum slot geometry, so they may use the target
+    // slot attestation window without moving the L1 publish cutoff.
+    return this.l1PublishingTime < this.ethereumSlotDuration ? this.attestationWindowIntoTargetSlot : 0;
+  }
+
+  public get timeReservedAtEnd(): number {
+    // Reserve enough time at the end of the build slot for:
+    // - assembling and broadcasting the checkpoint proposal
+    // - round-trip p2p propagation (proposal out, attestations back)
+    // - validators re-executing the last block
+    return this.checkpointAssembleTime + 2 * this.p2pPropagationTime + (this.blockDuration ?? 0);
+  }
+
+  public get minimumBuildSlotWork(): number {
+    return this.checkpointInitializationTime + this.minExecutionTime * 2;
+  }
+
+  public get initializeDeadline(): number {
+    return this.aztecSlotDuration - this.minimumBuildSlotWork;
+  }
+
+  public get checkpointAssemblyDeadline(): number {
+    // Allow enough time to build all blocks and receive attestations. With
+    // `pipeliningAttestationGracePeriod = 0` this equals `aztecSlotDuration`.
+    return this.aztecSlotDuration + this.pipeliningAttestationGracePeriod;
+  }
+
+  public get checkpointAttestationStartDeadline(): number {
+    return this.checkpointAssemblyDeadline;
+  }
+
+  public get checkpointAttestationDeadline(): number {
+    // L1 publish deadline — 12s (one Ethereum slot) before the last L1 block of the target L2 slot;
+    // the latest the checkpoint can be submitted and still land on L1 in the target slot. This is an
+    // L1-geometry bound (ethereumSlotDuration), matching the publisher's send lead in sendRequestsAt
+    // (which also targets one Ethereum slot before the target slot start).
+    return this.aztecSlotDuration * 2 - this.ethereumSlotDuration;
+  }
+
+  public get checkpointPublishingDeadline(): number {
+    // L1 publish deadline — 12s (one Ethereum slot) before the last L1 block of the target L2 slot;
+    // the latest the checkpoint can be submitted and still land on L1 in the target slot.
+    return this.aztecSlotDuration * 2 - this.ethereumSlotDuration;
+  }
+
+  public calculateMaxBlocksPerSlot(): number {
+    if (!this.blockDuration) {
+      return 1;
+    }
+
+    const timeAvailableForBlocks = this.aztecSlotDuration - this.checkpointInitializationTime - this.timeReservedAtEnd;
+    return Math.floor(timeAvailableForBlocks / this.blockDuration);
+  }
+}
+
+/**
+ * Creates a checkpoint timing model.
+ *
+ * Most callers should use this factory and depend only on the shared
+ * `CheckpointTiming` interface.
+ */
+export function createCheckpointTimingModel(opts: CheckpointTimingConfig): CheckpointTiming {
+  return createPipelinedCheckpointTimingModel(opts);
+}
+
+/**
+ * Creates a checkpoint timing model exposing the target-slot window accessors.
+ *
+ * Use this when the caller specifically needs the pipelined timing surface, such
+ * as proposal or attestation acceptance windows into the target slot.
+ */
+export function createPipelinedCheckpointTimingModel(opts: CheckpointTimingConfig): PipelinedCheckpointTiming {
+  validateCheckpointTimingConfig(opts);
+  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
+
+  const timing = new CheckpointTimingModel(normalizedOpts);
+  validateCheckpointTimingModel(timing);
+  return timing;
+}
+
 /**
  * Calculates the maximum number of blocks that can be built in a slot.
  * Used by both the sequencer timetable and p2p gossipsub scoring.
@@ -44,23 +217,88 @@ export function calculateMaxBlocksPerSlot(
     l1PublishingTime?: number;
   } = {},
 ): number {
-  if (!blockDurationSec) {
-    return 1; // Single block per slot
+  return createCheckpointTimingModel({
+    aztecSlotDuration: aztecSlotDurationSec,
+    blockDuration: blockDurationSec,
+    checkpointAssembleTime: opts.checkpointAssembleTime,
+    checkpointInitializationTime: opts.checkpointInitializationTime,
+    l1PublishingTime: opts.l1PublishingTime,
+    p2pPropagationTime: opts.p2pPropagationTime,
+  }).calculateMaxBlocksPerSlot();
+}
+
+function assertNonNegative(name: string, value: number): void {
+  if (value < 0) {
+    throw new Error(`${name} must be non-negative (got ${value})`);
+  }
+}
+
+function validateCheckpointTimingConfig(opts: CheckpointTimingConfig): void {
+  if (opts.aztecSlotDuration <= 0) {
+    throw new Error(`aztecSlotDuration must be positive (got ${opts.aztecSlotDuration})`);
   }
 
-  const initOffset = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
-  const assembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
-  const p2pTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-  const l1Time = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration <= 0) {
+    throw new Error(`ethereumSlotDuration must be positive when provided (got ${opts.ethereumSlotDuration})`);
+  }
+
+  if (opts.blockDuration !== undefined && opts.blockDuration <= 0) {
+    throw new Error(`blockDuration must be positive when provided (got ${opts.blockDuration})`);
+  }
+
+  if (opts.minExecutionTime !== undefined && opts.minExecutionTime <= 0) {
+    throw new Error(`minExecutionTime must be positive when provided (got ${opts.minExecutionTime})`);
+  }
+
+  if (opts.checkpointAssembleTime !== undefined) {
+    assertNonNegative('checkpointAssembleTime', opts.checkpointAssembleTime);
+  }
+  if (opts.checkpointInitializationTime !== undefined) {
+    assertNonNegative('checkpointInitializationTime', opts.checkpointInitializationTime);
+  }
+  if (opts.l1PublishingTime !== undefined) {
+    assertNonNegative('l1PublishingTime', opts.l1PublishingTime);
+  }
+  if (opts.p2pPropagationTime !== undefined) {
+    assertNonNegative('p2pPropagationTime', opts.p2pPropagationTime);
+  }
+}
 
-  // Calculate checkpoint finalization time (assembly + round-trip propagation + L1 publishing)
-  const checkpointFinalizationTime = assembleTime + p2pTime * 2 + l1Time;
+function normalizeCheckpointTimingConfig(opts: CheckpointTimingConfig): CheckpointTimingConfig {
+  let checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+  let checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+  let minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+  let p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
 
-  // Time reserved at end for last sub-slot (validator re-execution) + finalization
-  const timeReservedAtEnd = blockDurationSec + checkpointFinalizationTime;
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration < 8) {
+    p2pPropagationTime = 0;
+    checkpointAssembleTime = 0.5;
+    checkpointInitializationTime = 0.5;
+    minExecutionTime = 1;
+  }
 
-  // Time available for building blocks
-  const timeAvailableForBlocks = aztecSlotDurationSec - initOffset - timeReservedAtEnd;
+  if (opts.blockDuration !== undefined && minExecutionTime > opts.blockDuration) {
+    minExecutionTime = opts.blockDuration;
+  }
 
-  return Math.max(1, Math.floor(timeAvailableForBlocks / blockDurationSec));
+  return {
+    ...opts,
+    checkpointAssembleTime,
+    checkpointInitializationTime,
+    minExecutionTime,
+    p2pPropagationTime,
+  };
+}
+
+function validateCheckpointTimingModel(model: CheckpointTiming): void {
+  if (model.blockDuration === undefined) {
+    return;
+  }
+
+  const timeAvailableForBlocks = model.aztecSlotDuration - model.checkpointInitializationTime - model.timeReservedAtEnd;
+  if (timeAvailableForBlocks < model.blockDuration) {
+    throw new Error(
+      `Invalid timing configuration: only ${timeAvailableForBlocks}s available for block building, which is less than one blockDuration (${model.blockDuration}s).`,
+    );
+  }
 }

package/src/trees/append_only_tree_snapshot.ts

@@ -1,6 +1,6 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
@@ -44,8 +44,13 @@ export class AppendOnlyTreeSnapshot {
     return this.root.size + 4;
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.root, this.nextAvailableLeafIndex);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.root, this.nextAvailableLeafIndex);
   }
 
   toFields(): Fr[] {

package/src/trees/nullifier_leaf.ts

@@ -86,6 +86,10 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     ];
   }
 
+  isEmpty(): boolean {
+    return this.leaf.isEmpty() && this.nextKey.isZero() && this.nextIndex === 0n;
+  }
+
   toFields(): Fr[] {
     return this.toHashInputs().map(buf => Fr.fromBuffer(buf));
   }

package/src/trees/nullifier_membership_witness.ts

@@ -53,22 +53,12 @@ export class NullifierMembershipWitness {
     return new MembershipWitness(NULLIFIER_TREE_HEIGHT, this.index, this.siblingPath.toTuple());
   }
 
-  /**
-   * Returns a field array representation of a nullifier witness.
-   * @returns A field array representation of a nullifier witness.
-   */
-  public toFields(): Fr[] {
-    return [new Fr(this.index), ...this.leafPreimage.toFields(), ...this.siblingPath.toFields()];
-  }
-
-  /**
-   * Returns a representation of the nullifier membership witness as expected by intrinsic Noir deserialization.
-   */
+  /** Serializes as `(NullifierLeafPreimage, MembershipWitness)` to match the Noir oracle return type. */
   public toNoirRepresentation(): (string | string[])[] {
     // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
     return [
-      new Fr(this.index).toString() as string,
       ...(this.leafPreimage.toFields().map(fr => fr.toString()) as string[]),
+      new Fr(this.index).toString() as string,
       this.siblingPath.toFields().map(fr => fr.toString()) as string[],
     ];
   }

package/src/tx/block_header.ts

@@ -4,7 +4,7 @@ import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -85,8 +85,13 @@ export class BlockHeader {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(...BlockHeader.getFields(this));
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, ...BlockHeader.getFields(this));
   }
 
   toFields(): Fr[] {
@@ -172,8 +177,8 @@ export class BlockHeader {
   }
 
   /** Manually set the hash for this block header if already computed */
-  setHash(hashed: Fr) {
-    this._cachedHash = Promise.resolve(new BlockHash(hashed));
+  setHash(hashed: BlockHash) {
+    this._cachedHash = Promise.resolve(hashed);
   }
 
   /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */

package/src/tx/capsule.ts

@@ -19,6 +19,8 @@ export class Capsule {
     public readonly storageSlot: Fr,
     /** Data passed to the contract  */
     public readonly data: Fr[],
+    /** Optional namespace for the capsule contents */
+    public readonly scope?: AztecAddress,
   ) {}
 
   static get schema() {
@@ -30,12 +32,18 @@ export class Capsule {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data));
+    return this.scope
+      ? serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), true, this.scope)
+      : serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), false);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): Capsule {
     const reader = BufferReader.asReader(buffer);
-    return new Capsule(AztecAddress.fromBuffer(reader), Fr.fromBuffer(reader), reader.readVector(Fr));
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const data = reader.readVector(Fr);
+    const hasScope = reader.readBoolean();
+    return new Capsule(contractAddress, storageSlot, data, hasScope ? AztecAddress.fromBuffer(reader) : undefined);
   }
 
   toString() {

package/src/tx/fee_provider.ts

@@ -0,0 +1,10 @@
+import type { ManaUsageEstimate } from '../gas/fee_math.js';
+import type { GasFees } from '../gas/gas_fees.js';
+
+/** Provides current and predicted fee information for transaction pricing. */
+export interface FeeProvider {
+  /** Returns the current minimum fees for inclusion in the next block. */
+  getCurrentMinFees(): Promise<GasFees>;
+  /** Returns predicted min fees for each slot in the prediction window. */
+  getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}

package/src/tx/global_variable_builder.ts

@@ -1,8 +1,8 @@
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { SlotNumber } from '@aztec/foundation/schemas';
 
 import type { AztecAddress } from '../aztec-address/index.js';
-import type { GasFees } from '../gas/gas_fees.js';
 import type { UInt32 } from '../types/index.js';
 import type { CheckpointGlobalVariables, GlobalVariables } from './global_variables.js';
 
@@ -10,8 +10,6 @@ import type { CheckpointGlobalVariables, GlobalVariables } from './global_variab
  * Interface for building global variables for Aztec blocks.
  */
 export interface GlobalVariableBuilder {
-  getCurrentMinFees(): Promise<GasFees>;
-
   /**
    * Builds global variables for a given block.
    * @param blockNumber - The block number to build global variables for.
@@ -32,5 +30,6 @@ export interface GlobalVariableBuilder {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables>;
 }

package/src/tx/global_variables.ts

@@ -4,13 +4,7 @@ import { randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import {
-  BufferReader,
-  FieldReader,
-  bigintToUInt64BE,
-  serializeToBuffer,
-  serializeToFields,
-} from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -149,17 +143,15 @@ export class GlobalVariables {
     ] as const;
   }
 
-  toBuffer() {
-    return serializeToBuffer([
-      this.chainId,
-      this.version,
-      this.blockNumber,
-      this.slotNumber,
-      bigintToUInt64BE(this.timestamp),
-      this.coinbase,
-      this.feeRecipient,
-      this.gasFees,
-    ]);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.chainId, this.version, this.blockNumber, this.slotNumber);
+    sink.writeUInt64(this.timestamp);
+    serializeToSink(sink, this.coinbase, this.feeRecipient, this.gasFees);
   }
 
   toFields() {

package/src/tx/hashed_values.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -48,8 +48,13 @@ export class HashedValues {
     return new HashedValues([Fr.random(), Fr.random()], Fr.random());
   }
 
-  toBuffer() {
-    return serializeToBuffer(new Vector(this.values), this.hash);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, new Vector(this.values), this.hash);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): HashedValues {

package/src/tx/index.ts

@@ -24,6 +24,7 @@ export * from './validator/tx_validator.js';
 export * from './validator/empty_validator.js';
 export * from './validator/error_texts.js';
 export * from './capsule.js';
+export * from './fee_provider.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';

package/src/tx/indexed_tx_effect.ts

@@ -1,5 +1,4 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -7,35 +6,48 @@ import { BlockHash } from '../block/block_hash.js';
 import { type DataInBlock, dataInBlockSchemaFor, randomDataInBlock } from '../block/in_block.js';
 import { TxEffect } from './tx_effect.js';
 
-export type IndexedTxEffect = DataInBlock<TxEffect> & { txIndexInBlock: number };
+/** A tx effect together with its position in the block (`txIndexInBlock`) and the slot the block was built in. */
+export type IndexedTxEffect = DataInBlock<TxEffect> & { txIndexInBlock: number; slotNumber: SlotNumber };
 
 export function indexedTxSchema() {
-  return dataInBlockSchemaFor(TxEffect.schema).extend({ txIndexInBlock: schemas.Integer });
+  return dataInBlockSchemaFor(TxEffect.schema).extend({
+    txIndexInBlock: schemas.Integer,
+    slotNumber: schemas.SlotNumber,
+  });
 }
 
 export async function randomIndexedTxEffect(): Promise<IndexedTxEffect> {
   return {
     ...randomDataInBlock(await TxEffect.random({ numNullifiers: 1 + Math.floor(Math.random() * 64) })),
     txIndexInBlock: Math.floor(Math.random() * 1000),
+    slotNumber: SlotNumber(Math.floor(Math.random() * 1000)),
   };
 }
 
 export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
-  return serializeToBuffer(effect.l2BlockHash, effect.l2BlockNumber, effect.txIndexInBlock, effect.data);
+  return serializeToBuffer(
+    effect.l2BlockHash,
+    effect.l2BlockNumber,
+    effect.txIndexInBlock,
+    effect.slotNumber,
+    effect.data,
+  );
 }
 
 export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
   const reader = BufferReader.asReader(buffer);
 
-  const l2BlockHash = new BlockHash(reader.readObject(Fr));
+  const l2BlockHash = BlockHash.fromBuffer(reader);
   const l2BlockNumber = BlockNumber(reader.readNumber());
   const txIndexInBlock = reader.readNumber();
+  const slotNumber = SlotNumber(reader.readNumber());
   const data = reader.readObject(TxEffect);
 
   return {
     l2BlockHash,
     l2BlockNumber,
     txIndexInBlock,
+    slotNumber,
     data,
   };
 }

package/src/tx/partial_state_reference.ts

@@ -1,6 +1,6 @@
 import { PARTIAL_STATE_REFERENCE_LENGTH } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
@@ -88,8 +88,13 @@ export class PartialStateReference {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.noteHashTree, this.nullifierTree, this.publicDataTree);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.noteHashTree, this.nullifierTree, this.publicDataTree);
   }
 
   toFields() {

package/src/tx/profiling.ts

@@ -3,6 +3,7 @@ import { type ZodFor, optional, schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import { AztecAddress } from '../aztec-address/index.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
 
@@ -132,12 +133,12 @@ export class TxProfileResult {
       ],
       {
         nodeRPCCalls: {
-          perMethod: { getBlockHeader: { times: [1] } },
+          perMethod: { getBlock: { times: [1] } },
           roundTrips: {
             roundTrips: 1,
             totalBlockingTime: 1,
             roundTripDurations: [1],
-            roundTripMethods: [['getBlockHeader']],
+            roundTripMethods: [['getBlock']],
           },
         },
         timings: {
@@ -160,6 +161,9 @@ export class TxProfileResult {
 export class UtilityExecutionResult {
   constructor(
     public result: Fr[],
+    public offchainEffects: { data: Fr[]; contractAddress: AztecAddress }[],
+    /** Timestamp of the anchor block used during utility execution. */
+    public anchorBlockTimestamp: bigint,
     public stats?: SimulationStats,
   ) {}
 
@@ -167,20 +171,25 @@ export class UtilityExecutionResult {
     return z
       .object({
         result: z.array(schemas.Fr),
+        offchainEffects: z.array(z.object({ data: z.array(schemas.Fr), contractAddress: AztecAddress.schema })),
+        anchorBlockTimestamp: schemas.BigInt,
         stats: optional(SimulationStatsSchema),
       })
-      .transform(({ result, stats }) => new UtilityExecutionResult(result, stats));
+      .transform(
+        ({ result, offchainEffects, anchorBlockTimestamp, stats }) =>
+          new UtilityExecutionResult(result, offchainEffects, anchorBlockTimestamp, stats),
+      );
   }
 
   static random(): UtilityExecutionResult {
-    return new UtilityExecutionResult([Fr.random()], {
+    return new UtilityExecutionResult([Fr.random()], [], 0n, {
       nodeRPCCalls: {
-        perMethod: { getBlockHeader: { times: [1] } },
+        perMethod: { getBlock: { times: [1] } },
         roundTrips: {
           roundTrips: 1,
           totalBlockingTime: 1,
           roundTripDurations: [1],
-          roundTripMethods: [['getBlockHeader']],
+          roundTripMethods: [['getBlock']],
         },
       },
       timings: {