@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/trees/nullifier_leaf.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
@@ -36,6 +36,24 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
       .transform(({ leaf, nextKey, nextIndex }) => new NullifierLeafPreimage(leaf, nextKey, nextIndex));
   }
 
+  /**
+   * Creates a NullifierLeafPreimage from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing NullifierLeafPreimage fields
+   * @returns A NullifierLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): NullifierLeafPreimage {
+    if (obj instanceof NullifierLeafPreimage) {
+      return obj;
+    }
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
   static get leafSchema() {
     return NullifierLeaf.schema;
   }
@@ -68,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));
   }
@@ -157,4 +179,18 @@ export class NullifierLeaf implements IndexedTreeLeaf {
   static get schema() {
     return z.object({ nullifier: schemas.Fr }).transform(({ nullifier }) => new NullifierLeaf(nullifier));
   }
+
+  /**
+   * Creates a NullifierLeaf from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing NullifierLeaf fields
+   * @returns A NullifierLeaf instance
+   */
+  static fromPlainObject(obj: any): NullifierLeaf {
+    if (obj instanceof NullifierLeaf) {
+      return obj;
+    }
+    return new NullifierLeaf(Fr.fromPlainObject(obj.nullifier));
+  }
 }

package/src/trees/nullifier_membership_witness.ts

@@ -1,5 +1,4 @@
 import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
 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,5 +1,6 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+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';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
@@ -36,6 +37,24 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
       .transform(({ leaf, nextKey, nextIndex }) => new PublicDataTreeLeafPreimage(leaf, nextKey, nextIndex));
   }
 
+  /**
+   * Creates a PublicDataTreeLeafPreimage from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeafPreimage fields
+   * @returns A PublicDataTreeLeafPreimage instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeafPreimage {
+    if (obj instanceof PublicDataTreeLeafPreimage) {
+      return obj;
+    }
+    return new PublicDataTreeLeafPreimage(
+      PublicDataTreeLeaf.fromPlainObject(obj.leaf),
+      Fr.fromPlainObject(obj.nextKey),
+      typeof obj.nextIndex === 'bigint' ? obj.nextIndex : BigInt(obj.nextIndex),
+    );
+  }
+
   static get leafSchema() {
     return PublicDataTreeLeaf.schema;
   }
@@ -63,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);
   }
@@ -86,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 {
@@ -172,4 +196,18 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
       })
       .transform(({ slot, value }) => new PublicDataTreeLeaf(slot, value));
   }
+
+  /**
+   * Creates a PublicDataTreeLeaf from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PublicDataTreeLeaf fields
+   * @returns A PublicDataTreeLeaf instance
+   */
+  static fromPlainObject(obj: any): PublicDataTreeLeaf {
+    if (obj instanceof PublicDataTreeLeaf) {
+      return obj;
+    }
+    return new PublicDataTreeLeaf(Fr.fromPlainObject(obj.slot), Fr.fromPlainObject(obj.value));
+  }
 }

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/fields';
 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,36 +1,41 @@
-import { BLOCK_HEADER_LENGTH, GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { BlockHash } from '../block/block_hash.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { GlobalVariables } from './global_variables.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
 export class BlockHeader {
+  private _cachedHash?: Promise<BlockHash>;
+
   constructor(
     /** Snapshot of archive before the block is applied. */
-    public lastArchive: AppendOnlyTreeSnapshot,
+    public readonly lastArchive: AppendOnlyTreeSnapshot,
     /** State reference. */
-    public state: StateReference,
+    public readonly state: StateReference,
     /**
      * Hash of the sponge blob after the tx effects of this block has been applied.
      * May contain tx effects from the previous blocks in the same checkpoint.
      */
-    public spongeBlobHash: Fr,
+    public readonly spongeBlobHash: Fr,
     /** Global variables of an L2 block. */
-    public globalVariables: GlobalVariables,
+    public readonly globalVariables: GlobalVariables,
     /** Total fees in the block, computed by the root rollup circuit */
-    public totalFees: Fr,
+    public readonly totalFees: Fr,
     /** Total mana used in the block, computed by the root rollup circuit */
-    public totalManaUsed: Fr,
+    public readonly totalManaUsed: Fr,
   ) {}
 
   static get schema(): ZodFor<BlockHeader> {
@@ -61,11 +66,11 @@ export class BlockHeader {
     return new BlockHeader(...BlockHeader.getFields(fields));
   }
 
-  getSlot() {
-    return this.globalVariables.slotNumber.toBigInt();
+  getSlot(): SlotNumber {
+    return this.globalVariables.slotNumber;
   }
 
-  getBlockNumber() {
+  getBlockNumber(): BlockNumber {
     return this.globalVariables.blockNumber;
   }
 
@@ -80,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[] {
@@ -157,8 +167,36 @@ export class BlockHeader {
     return BlockHeader.fromBuffer(hexToBuffer(str));
   }
 
-  hash(): Promise<Fr> {
-    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+  hash(): Promise<BlockHash> {
+    if (!this._cachedHash) {
+      this._cachedHash = poseidon2HashWithSeparator(this.toFields(), DomainSeparator.BLOCK_HEADER_HASH).then(
+        fr => new BlockHash(fr),
+      );
+    }
+    return this._cachedHash;
+  }
+
+  /** Manually set the hash for this block header if already computed */
+  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 {
+    return BlockHeader.from({
+      lastArchive: AppendOnlyTreeSnapshot.random(),
+      state: StateReference.random(),
+      spongeBlobHash: Fr.random(),
+      globalVariables: GlobalVariables.random(overrides),
+      totalFees: new Fr(randomInt(100_000)),
+      totalManaUsed: new Fr(randomInt(100_000_000)),
+      ...overrides,
+    });
   }
 
   toInspect() {

package/src/tx/call_context.ts

@@ -1,5 +1,5 @@
 import { CALL_CONTEXT_LENGTH } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/tx/capsule.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -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

@@ -0,0 +1,61 @@
+import type { FunctionCall } from '../abi/function_call.js';
+import type { AuthWitness } from '../auth_witness/auth_witness.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { Capsule } from './capsule.js';
+import type { HashedValues } from './hashed_values.js';
+
+/**
+ * Represents data necessary to perform an action in the network successfully.
+ * This class can be considered Aztec's "minimal execution unit".
+ * */
+export class ExecutionPayload {
+  public constructor(
+    /** The function calls to be executed. */
+    public calls: FunctionCall[],
+    /** Any transient auth witnesses needed for this execution */
+    public authWitnesses: AuthWitness[],
+    /** Data passed through an oracle for this execution. */
+    public capsules: Capsule[],
+    /** Extra hashed values to be injected in the execution cache */
+    public extraHashedArgs: HashedValues[] = [],
+    /**
+     * The address that is paying for the fee in this execution payload (if any).
+     * If undefined, the wallet software executing the payload will have to add a fee payment method
+     */
+    public feePayer?: AztecAddress,
+  ) {}
+
+  static empty() {
+    return new ExecutionPayload([], [], [], [], undefined);
+  }
+}
+
+/**
+ * Merges an array ExecutionPayloads combining their calls, authWitnesses, capsules and extraArgHashes.
+ * @throws Error if multiple payloads have different fee payers set
+ */
+export function mergeExecutionPayloads(requests: ExecutionPayload[]): ExecutionPayload {
+  const calls = requests.map(r => r.calls).flat();
+  const combinedAuthWitnesses = requests.map(r => r.authWitnesses ?? []).flat();
+  const combinedCapsules = requests.map(r => r.capsules ?? []).flat();
+  const combinedExtraHashedArgs = requests.map(r => r.extraHashedArgs ?? []).flat();
+
+  // Collect unique fee payers
+  const uniqueFeePayers = new Set(
+    requests
+      .map(r => r.feePayer)
+      .filter((fp): fp is AztecAddress => fp !== undefined)
+      .map(fp => fp.toString()),
+  );
+
+  if (uniqueFeePayers.size > 1) {
+    throw new Error(
+      `Cannot merge execution payloads with different fee payers. Found: ${Array.from(uniqueFeePayers).join(', ')}`,
+    );
+  }
+
+  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/function_data.ts

@@ -1,5 +1,5 @@
 import { FUNCTION_DATA_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';

package/src/tx/global_variable_builder.ts

@@ -1,28 +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 { GlobalVariables } from './global_variables.js';
+import type { CheckpointGlobalVariables } from './global_variables.js';
 
 /**
  * Interface for building global variables for Aztec blocks.
  */
 export interface GlobalVariableBuilder {
-  getCurrentBaseFees(): 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,
+  /** Builds global variables that are constant throughout a checkpoint. */
+  buildCheckpointGlobalVariables(
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
-    slotNumber?: bigint,
-  ): Promise<GlobalVariables>;
+    slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
+  ): Promise<CheckpointGlobalVariables>;
 }