@aztec/stdlib 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

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_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

@@ -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/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,51 +1,19 @@
-import type { FeeHeader } from '@aztec/ethereum/contracts';
-import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+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';
-
-/** Fee header fields needed for pipelining overrides. */
-export type ForceProposedFeeHeader = {
-  checkpointNumber: CheckpointNumber;
-  feeHeader: FeeHeader;
-};
-
-/** Options for building checkpoint global variables during pipelining. */
-export type BuildCheckpointGlobalVariablesOpts = {
-  forcePendingCheckpointNumber?: CheckpointNumber;
-  forceProposedFeeHeader?: ForceProposedFeeHeader;
-};
+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,
-    opts?: BuildCheckpointGlobalVariablesOpts,
+    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';
@@ -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_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

@@ -133,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: {
@@ -184,12 +184,12 @@ export class UtilityExecutionResult {
   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: {

package/src/tx/proven_tx.ts

@@ -13,6 +13,7 @@ import {
 } from './private_execution_result.js';
 import { type ProvingStats, ProvingTimingsSchema } from './profiling.js';
 import { Tx } from './tx.js';
+import type { TxHash } from './tx_hash.js';
 
 export class TxProvingResult {
   constructor(
@@ -22,6 +23,11 @@ export class TxProvingResult {
     public stats?: ProvingStats,
   ) {}
 
+  getTxHash(): Promise<TxHash> {
+    // Equivalent to `(await this.toTx()).txHash` but skips walking the execution result tree to collect logs.
+    return Tx.computeTxHash({ data: this.publicInputs });
+  }
+
   async toTx(): Promise<Tx> {
     const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
 

package/src/tx/public_call_request_with_calldata.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 { inspect } from 'util';
 import { z } from 'zod';
@@ -63,8 +63,13 @@ export class PublicCallRequestWithCalldata {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.request, new Vector(this.calldata));
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.request, new Vector(this.calldata));
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {

package/src/tx/simulated_tx.ts

@@ -3,13 +3,14 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
 import {
   type ContractInstanceWithAddress,
   ContractInstanceWithAddressSchema,
 } from '../contract/interfaces/contract_instance.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
+import { MAX_RPC_CONTRACT_OVERRIDES_LEN, MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN } from '../interfaces/api_limit.js';
+import { type PublicStorageOverride, PublicStorageOverrideSchema } from '../interfaces/public_storage_override.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
 import type { OffchainEffect } from './offchain_effect.js';
@@ -24,35 +25,46 @@ import { NestedProcessReturnValues, PublicSimulationOutput } from './public_simu
 import { Tx } from './tx.js';
 
 /*
- * If passed during the execution of a user circuit, the contract function simulator will replace the instance and class
- * of the contract with the one provided in the overrides for that address. An example use case
- * would be overriding your own account contract so that valid signatures don't have to be provided while simulating.
+ * If passed during the execution of a user circuit, the contract function simulator will replace
+ * the contract instance at that address with the one provided. An example use case would be
+ * overriding your own account contract so that valid signatures don't have to be provided while
+ * simulating. The override's `currentContractClassId` resolves through PXE's locally registered
+ * classes, so pre-register the target artifact via `pxe.registerContractClass(...)`.
  */
-export type ContractOverrides = Record<
-  string /* AztecAddress as string */,
-  { instance: ContractInstanceWithAddress; artifact: ContractArtifact }
->;
+export type ContractOverrides = Record<string /* AztecAddress as string */, { instance: ContractInstanceWithAddress }>;
 
 /*
- * Optional values that can be overridden during simulation. In order to simulate a transaction with these
- * set, it *must* be run without the kernel circuits, or validations will fail
+ * Optional values that can be overridden during simulation. `publicStorage` writes to the public-data
+ * tree fork. `contracts` overrides contract instances in the contract DB.
+ * In order to simulate a transaction with these set, it *must* be run without the kernel circuits,
+ * or validations will fail.
  */
 export class SimulationOverrides {
-  constructor(public contracts?: ContractOverrides) {}
+  public publicStorage?: PublicStorageOverride[];
+  public contracts?: ContractOverrides;
+
+  constructor(args: { publicStorage?: PublicStorageOverride[]; contracts?: ContractOverrides } = {}) {
+    this.publicStorage = args.publicStorage?.length ? args.publicStorage : undefined;
+    this.contracts = args.contracts && Object.keys(args.contracts).length > 0 ? args.contracts : undefined;
+  }
 
   static get schema() {
     return z
       .object({
+        publicStorage: optional(
+          z.array(PublicStorageOverrideSchema).max(MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN, {
+            message: `publicStorage must have at most ${MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN} entries`,
+          }),
+        ),
         contracts: optional(
-          z.record(
-            z.string(),
-            z.object({ instance: ContractInstanceWithAddressSchema, artifact: ContractArtifactSchema }),
-          ),
+          z
+            .record(z.string(), z.object({ instance: ContractInstanceWithAddressSchema }))
+            .refine(contracts => Object.keys(contracts).length <= MAX_RPC_CONTRACT_OVERRIDES_LEN, {
+              message: `contracts must have at most ${MAX_RPC_CONTRACT_OVERRIDES_LEN} entries`,
+            }),
         ),
       })
-      .transform(({ contracts }) => {
-        return new SimulationOverrides(contracts);
-      });
+      .transform(args => new SimulationOverrides(args));
   }
 }
 
@@ -157,7 +169,7 @@ export class TxSimulationResult {
 }
 
 /**
- * Recursively accummulate the return values of a call result and its nested executions,
+ * Recursively accumulate the return values of a call result and its nested executions,
  * so they can be retrieved in order.
  * @param executionResult
  * @returns

package/src/tx/state_reference.ts

@@ -5,7 +5,7 @@ import {
   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 { inspect } from 'util';
@@ -46,9 +46,14 @@ export class StateReference {
     return new StateReference(...StateReference.getFields(fields));
   }
 
-  toBuffer() {
-    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
-    return serializeToBuffer(this.l1ToL2MessageTree, this.partial);
+  // Note: The order here must match the order in the ProposedHeaderLib solidity library.
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.l1ToL2MessageTree, this.partial);
   }
 
   toFields(): Fr[] {