@aztec/stdlib 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

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

@@ -1,5 +1,4 @@
 import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
@@ -52,24 +51,4 @@ export class NullifierMembershipWitness {
   public withoutPreimage(): MembershipWitness<typeof NULLIFIER_TREE_HEIGHT> {
     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.
-   */
-  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[]),
-      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
-    ];
-  }
 }

package/src/trees/public_data_leaf.ts

@@ -1,4 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -81,11 +82,15 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   toHashInputs(): Buffer[] {
     return [
       ...this.leaf.toHashInputs(),
-      Buffer.from(toBufferBE(this.nextIndex, 32)),
       Buffer.from(this.nextKey.toBuffer()),
+      Buffer.from(toBufferBE(this.nextIndex, 32)),
     ];
   }
 
+  hash(): Promise<Fr> {
+    return poseidon2Hash(this.toHashInputs());
+  }
+
   clone(): PublicDataTreeLeafPreimage {
     return new PublicDataTreeLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
@@ -104,10 +109,11 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicDataTreeLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    const value = PublicDataTreeLeaf.fromBuffer(reader);
-    const nextIndex = toBigIntBE(reader.readBytes(32));
-    const nextSlot = Fr.fromBuffer(reader);
-    return new PublicDataTreeLeafPreimage(value, nextSlot, nextIndex);
+    return new PublicDataTreeLeafPreimage(
+      PublicDataTreeLeaf.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      toBigIntBE(reader.readBytes(32)),
+    );
   }
 
   static fromLeaf(leaf: PublicDataTreeLeaf, nextKey: bigint, nextIndex: bigint): PublicDataTreeLeafPreimage {

package/src/trees/public_data_witness.ts

@@ -1,6 +1,5 @@
 import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
@@ -43,36 +42,6 @@ export class PublicDataWitness {
       .transform(({ index, leafPreimage, siblingPath }) => new PublicDataWitness(index, leafPreimage, siblingPath));
   }
 
-  /**
-   * Returns a field array representation of a public data witness.
-   * @returns A field array representation of a public data witness.
-   */
-  public toFields(): Fr[] {
-    return [
-      new Fr(this.index),
-      new Fr(this.leafPreimage.leaf.slot),
-      new Fr(this.leafPreimage.leaf.value),
-      new Fr(this.leafPreimage.nextIndex),
-      new Fr(this.leafPreimage.nextKey),
-      ...this.siblingPath.toFields(),
-    ];
-  }
-
-  /**
-   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
-   */
-  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,
-      new Fr(this.leafPreimage.leaf.slot).toString() as string,
-      new Fr(this.leafPreimage.leaf.value).toString() as string,
-      new Fr(this.leafPreimage.nextKey).toString() as string,
-      new Fr(this.leafPreimage.nextIndex).toString() as string,
-      this.siblingPath.toFields().map(fr => fr.toString()) as string[],
-    ];
-  }
-
   toBuffer(): Buffer {
     return serializeToBuffer([this.index, this.leafPreimage, this.siblingPath]);
   }

package/src/tx/block_header.ts

@@ -1,10 +1,10 @@
-import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
+import { BLOCK_HEADER_LENGTH, DomainSeparator } from '@aztec/constants';
 import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 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[] {
@@ -164,7 +169,7 @@ export class BlockHeader {
 
   hash(): Promise<BlockHash> {
     if (!this._cachedHash) {
-      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HEADER_HASH).then(
+      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), DomainSeparator.BLOCK_HEADER_HASH).then(
         fr => new BlockHash(fr),
       );
     }
@@ -172,8 +177,14 @@ 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. */
+  recomputeHash(): Promise<BlockHash> {
+    this._cachedHash = undefined;
+    return this.hash();
   }
 
   static random(overrides: Partial<FieldsOf<BlockHeader>> & Partial<FieldsOf<GlobalVariables>> = {}): BlockHeader {

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/execution_payload.ts

@@ -54,7 +54,8 @@ export function mergeExecutionPayloads(requests: ExecutionPayload[]): ExecutionP
     );
   }
 
-  const feePayer = uniqueFeePayers.size === 1 ? AztecAddress.fromString(Array.from(uniqueFeePayers)[0]) : undefined;
+  const feePayer =
+    uniqueFeePayers.size === 1 ? AztecAddress.fromStringUnsafe(Array.from(uniqueFeePayers)[0]) : undefined;
 
   return new ExecutionPayload(calls, combinedAuthWitnesses, combinedCapsules, combinedExtraHashedArgs, feePayer);
 }

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 current min fees first, followed by predicted min fees for each slot in the prediction window. */
+  getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}

package/src/tx/global_variable_builder.ts

@@ -1,36 +1,19 @@
+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';
+import type { CheckpointGlobalVariables } from './global_variables.js';
 
 /**
  * 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.
-   * @param coinbase - The address to receive block reward.
-   * @param feeRecipient - The address to receive fees.
-   * @param slotNumber - Optional. The slot number to use for the global variables. If undefined, it will be calculated.
-   * @returns A promise that resolves to the GlobalVariables for the given block number.
-   */
-  buildGlobalVariables(
-    blockNumber: UInt32,
-    coinbase: EthAddress,
-    feeRecipient: AztecAddress,
-    slotNumber?: SlotNumber,
-  ): Promise<GlobalVariables>;
-
   /** Builds global variables that are constant throughout a checkpoint. */
   buildCheckpointGlobalVariables(
     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';
@@ -22,10 +16,10 @@ import { schemas } from '../schemas/index.js';
 import type { UInt64 } from '../types/index.js';
 
 /**
- * Global variables that are constant across the entire slot.
- * TODO(palla/mbps): Should timestamp be included here as well?
+ * Global variables that are constant across the entire checkpoint (slot).
+ * Excludes blockNumber since that varies per block within a checkpoint.
  */
-export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber' | 'timestamp'>;
+export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber'>;
 
 /**
  * Global variables of the L2 block.
@@ -131,7 +125,7 @@ export class GlobalVariables {
       SlotNumber(reader.readU32()),
       reader.readField().toBigInt(),
       EthAddress.fromField(reader.readField()),
-      AztecAddress.fromField(reader.readField()),
+      AztecAddress.fromFieldUnsafe(reader.readField()),
       GasFees.fromFields(reader),
     );
   }
@@ -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() {
@@ -228,7 +220,7 @@ export class GlobalVariables {
       blockNumber: BlockNumber(randomInt(100_000)),
       slotNumber: SlotNumber(randomInt(100_000)),
       coinbase: EthAddress.random(),
-      feeRecipient: AztecAddress.fromField(Fr.random()),
+      feeRecipient: AztecAddress.fromFieldUnsafe(Fr.random()),
       gasFees: GasFees.random(),
       timestamp: BigInt(randomInt(100_000_000)),
       ...overrides,

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';
@@ -28,12 +28,17 @@ export class HashedValues {
   }
 
   static get schema(): ZodFor<HashedValues> {
-    return z
-      .object({
-        values: z.array(schemas.Fr),
-        hash: schemas.Fr,
-      })
-      .transform(HashedValues.from);
+    return HashedValues.schemaFor();
+  }
+
+  /**
+   * Returns a schema that additionally rejects more than `maxValues` values. The bound belongs to the caller
+   * rather than to this class: the same container carries public calldata, private call arguments and authwit
+   * arguments, and those have different limits.
+   */
+  static schemaFor(maxValues?: number): ZodFor<HashedValues> {
+    const values = maxValues === undefined ? z.array(schemas.Fr) : z.array(schemas.Fr).max(maxValues);
+    return z.object({ values, hash: schemas.Fr }).transform(HashedValues.from);
   }
 
   static from(fields: FieldsOf<HashedValues>): HashedValues {
@@ -48,8 +53,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/private_execution_result.ts

@@ -11,7 +11,7 @@ import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inp
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
-import { type PreTag, PreTagSchema } from '../logs/pre_tag.js';
+import { type TaggingIndexRange, TaggingIndexRangeSchema } from '../logs/tagging_index_range.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
 import { HashedValues } from './hashed_values.js';
@@ -137,8 +137,8 @@ export class PrivateCallExecutionResult {
     public returnValues: Fr[],
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
-    /** The pre-tags used in this tx to compute tags for private logs */
-    public preTags: PreTag[],
+    /** The tagging index ranges used in this tx to compute tags for private logs */
+    public taggingIndexRanges: TaggingIndexRange[],
     /** The nested executions. */
     public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
@@ -161,7 +161,7 @@ export class PrivateCallExecutionResult {
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
         offchainEffects: z.array(z.object({ data: z.array(schemas.Fr) })),
-        preTags: z.array(PreTagSchema),
+        taggingIndexRanges: z.array(TaggingIndexRangeSchema),
         nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
@@ -178,7 +178,7 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.offchainEffects,
-      fields.preTags,
+      fields.taggingIndexRanges,
       fields.nestedExecutionResults,
       fields.contractClassLogs,
     );

package/src/tx/private_tx_constant_data.ts

@@ -23,6 +23,14 @@ export class PrivateTxConstantData {
      * protocol to execute and prove the transaction.
      */
     public txContext: TxContext,
+    /**
+     * Salt of the transaction request (`TxRequest.salt`).
+     *
+     * Bound to the user's `tx_request` by the Init circuit and kept constant by every subsequent kernel so that each
+     * app circuit's `txRequestSalt` public input can be checked against it. It is intentionally not carried into
+     * `TxConstantData`: it is dropped by the Tail circuits rather than being exposed by the final (hiding) kernel.
+     */
+    public txRequestSalt: Fr,
     /**
      * Root of the vk tree for the protocol circuits.
      */
@@ -38,7 +46,13 @@ export class PrivateTxConstantData {
   }
 
   static getFields(fields: FieldsOf<PrivateTxConstantData>) {
-    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContracts] as const;
+    return [
+      fields.anchorBlockHeader,
+      fields.txContext,
+      fields.txRequestSalt,
+      fields.vkTreeRoot,
+      fields.protocolContracts,
+    ] as const;
   }
 
   static fromFields(fields: Fr[] | FieldReader): PrivateTxConstantData {
@@ -47,6 +61,7 @@ export class PrivateTxConstantData {
       reader.readObject(BlockHeader),
       reader.readObject(TxContext),
       reader.readField(),
+      reader.readField(),
       reader.readObject(ProtocolContracts),
     );
   }
@@ -67,6 +82,7 @@ export class PrivateTxConstantData {
       reader.readObject(BlockHeader),
       reader.readObject(TxContext),
       Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
       reader.readObject(ProtocolContracts),
     );
   }
@@ -76,13 +92,20 @@ export class PrivateTxConstantData {
   }
 
   static empty() {
-    return new PrivateTxConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, ProtocolContracts.empty());
+    return new PrivateTxConstantData(
+      BlockHeader.empty(),
+      TxContext.empty(),
+      Fr.ZERO,
+      Fr.ZERO,
+      ProtocolContracts.empty(),
+    );
   }
 
   getSize() {
     return (
       this.anchorBlockHeader.getSize() +
       this.txContext.getSize() +
+      this.txRequestSalt.size +
       this.vkTreeRoot.size +
       this.protocolContracts.getSize()
     );

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: {
@@ -157,30 +158,38 @@ export class TxProfileResult {
   }
 }
 
-export class UtilitySimulationResult {
+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,
   ) {}
 
-  static get schema(): ZodFor<UtilitySimulationResult> {
+  static get schema(): ZodFor<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 UtilitySimulationResult(result, stats));
+      .transform(
+        ({ result, offchainEffects, anchorBlockTimestamp, stats }) =>
+          new UtilityExecutionResult(result, offchainEffects, anchorBlockTimestamp, stats),
+      );
   }
 
-  static random(): UtilitySimulationResult {
-    return new UtilitySimulationResult([Fr.random()], {
+  static random(): UtilityExecutionResult {
+    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: {