@aztec/stdlib 0.87.7 → 1.0.0-nightly.20250605

package/src/avm/avm_circuit_public_inputs.ts

@@ -9,15 +9,15 @@ import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import { Gas, GasSettings } from '../gas/index.js';
+import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
 } from '../kernel/private_to_avm_accumulated_data.js';
-import { PublicCallRequest } from '../kernel/public_call_request.js';
+import { PublicCallRequest, PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
-import { AvmAccumulatedData } from './avm_accumulated_data.js';
+import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths } from './avm_accumulated_data.js';
 import { serializeWithMessagePack } from './message_pack.js';
 
 // Note: the {from,to}{Buffer,Fields,String} methods are needed by AvmProofData and PublicBaseRollupInputs.
@@ -30,7 +30,9 @@ export class AvmCircuitPublicInputs {
     public startTreeSnapshots: TreeSnapshots,
     public startGasUsed: Gas,
     public gasSettings: GasSettings,
+    public effectiveGasFees: GasFees,
     public feePayer: AztecAddress,
+    public publicCallRequestArrayLengths: PublicCallRequestArrayLengths,
     public publicSetupCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicAppLogicCallRequests: Tuple<PublicCallRequest, typeof MAX_ENQUEUED_CALLS_PER_TX>,
     public publicTeardownCallRequest: PublicCallRequest,
@@ -42,6 +44,7 @@ export class AvmCircuitPublicInputs {
     // Outputs.
     public endTreeSnapshots: TreeSnapshots,
     public endGasUsed: Gas,
+    public accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths,
     public accumulatedData: AvmAccumulatedData,
     public transactionFee: Fr,
     public reverted: boolean,
@@ -54,7 +57,9 @@ export class AvmCircuitPublicInputs {
         startTreeSnapshots: TreeSnapshots.schema,
         startGasUsed: Gas.schema,
         gasSettings: GasSettings.schema,
+        effectiveGasFees: GasFees.schema,
         feePayer: AztecAddress.schema,
+        publicCallRequestArrayLengths: PublicCallRequestArrayLengths.schema,
         publicSetupCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicAppLogicCallRequests: PublicCallRequest.schema.array().max(MAX_ENQUEUED_CALLS_PER_TX),
         publicTeardownCallRequest: PublicCallRequest.schema,
@@ -64,6 +69,7 @@ export class AvmCircuitPublicInputs {
         previousRevertibleAccumulatedData: PrivateToAvmAccumulatedData.schema,
         endTreeSnapshots: TreeSnapshots.schema,
         endGasUsed: Gas.schema,
+        accumulatedDataArrayLengths: AvmAccumulatedDataArrayLengths.schema,
         accumulatedData: AvmAccumulatedData.schema,
         transactionFee: schemas.Fr,
         reverted: z.boolean(),
@@ -74,7 +80,9 @@ export class AvmCircuitPublicInputs {
           startTreeSnapshots,
           startGasUsed,
           gasSettings,
+          effectiveGasFees,
           feePayer,
+          publicCallRequestArrayLengths,
           publicSetupCallRequests,
           publicAppLogicCallRequests,
           publicTeardownCallRequest,
@@ -84,6 +92,7 @@ export class AvmCircuitPublicInputs {
           previousRevertibleAccumulatedData,
           endTreeSnapshots,
           endGasUsed,
+          accumulatedDataArrayLengths,
           accumulatedData,
           transactionFee,
           reverted,
@@ -93,7 +102,9 @@ export class AvmCircuitPublicInputs {
             startTreeSnapshots,
             startGasUsed,
             gasSettings,
+            effectiveGasFees,
             feePayer,
+            publicCallRequestArrayLengths,
             assertLength(publicSetupCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             assertLength(publicAppLogicCallRequests, MAX_ENQUEUED_CALLS_PER_TX),
             publicTeardownCallRequest,
@@ -103,6 +114,7 @@ export class AvmCircuitPublicInputs {
             previousRevertibleAccumulatedData,
             endTreeSnapshots,
             endGasUsed,
+            accumulatedDataArrayLengths,
             accumulatedData,
             transactionFee,
             reverted,
@@ -117,7 +129,9 @@ export class AvmCircuitPublicInputs {
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
       reader.readObject(GasSettings),
+      reader.readObject(GasFees),
       reader.readObject(AztecAddress),
+      reader.readObject(PublicCallRequestArrayLengths),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readObject(PublicCallRequest),
@@ -127,6 +141,7 @@ export class AvmCircuitPublicInputs {
       reader.readObject(PrivateToAvmAccumulatedData),
       reader.readObject(TreeSnapshots),
       reader.readObject(Gas),
+      reader.readObject(AvmAccumulatedDataArrayLengths),
       reader.readObject(AvmAccumulatedData),
       reader.readObject(Fr),
       reader.readBoolean(),
@@ -139,7 +154,9 @@ export class AvmCircuitPublicInputs {
       this.startTreeSnapshots,
       this.startGasUsed,
       this.gasSettings,
+      this.effectiveGasFees,
       this.feePayer,
+      this.publicCallRequestArrayLengths,
       this.publicSetupCallRequests,
       this.publicAppLogicCallRequests,
       this.publicTeardownCallRequest,
@@ -149,6 +166,7 @@ export class AvmCircuitPublicInputs {
       this.previousRevertibleAccumulatedData,
       this.endTreeSnapshots,
       this.endGasUsed,
+      this.accumulatedDataArrayLengths,
       this.accumulatedData,
       this.transactionFee,
       this.reverted,
@@ -170,7 +188,9 @@ export class AvmCircuitPublicInputs {
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
       GasSettings.fromFields(reader),
+      GasFees.fromFields(reader),
       AztecAddress.fromFields(reader),
+      PublicCallRequestArrayLengths.fromFields(reader),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       reader.readArray(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest),
       PublicCallRequest.fromFields(reader),
@@ -180,6 +200,7 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.fromFields(reader),
       TreeSnapshots.fromFields(reader),
       Gas.fromFields(reader),
+      AvmAccumulatedDataArrayLengths.fromFields(reader),
       AvmAccumulatedData.fromFields(reader),
       reader.readField(),
       reader.readBoolean(),
@@ -192,7 +213,9 @@ export class AvmCircuitPublicInputs {
       ...this.startTreeSnapshots.toFields(),
       ...this.startGasUsed.toFields(),
       ...this.gasSettings.toFields(),
+      ...this.effectiveGasFees.toFields(),
       this.feePayer,
+      ...this.publicCallRequestArrayLengths.toFields(),
       ...this.publicSetupCallRequests.map(request => request.toFields()),
       ...this.publicAppLogicCallRequests.map(request => request.toFields()),
       ...this.publicTeardownCallRequest.toFields(),
@@ -202,6 +225,7 @@ export class AvmCircuitPublicInputs {
       ...this.previousRevertibleAccumulatedData.toFields(),
       ...this.endTreeSnapshots.toFields(),
       ...this.endGasUsed.toFields(),
+      ...this.accumulatedDataArrayLengths.toFields(),
       ...this.accumulatedData.toFields(),
       this.transactionFee,
       this.reverted,
@@ -214,7 +238,9 @@ export class AvmCircuitPublicInputs {
       TreeSnapshots.empty(),
       Gas.empty(),
       GasSettings.empty(),
+      GasFees.empty(),
       AztecAddress.zero(),
+      PublicCallRequestArrayLengths.empty(),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       makeTuple(MAX_ENQUEUED_CALLS_PER_TX, PublicCallRequest.empty),
       PublicCallRequest.empty(),
@@ -224,6 +250,7 @@ export class AvmCircuitPublicInputs {
       PrivateToAvmAccumulatedData.empty(),
       TreeSnapshots.empty(),
       Gas.empty(),
+      AvmAccumulatedDataArrayLengths.empty(),
       AvmAccumulatedData.empty(),
       Fr.zero(),
       false,
@@ -240,7 +267,9 @@ export class AvmCircuitPublicInputs {
       startTreeSnapshots: ${inspect(this.startTreeSnapshots)},
       startGasUsed: ${inspect(this.startGasUsed)},
       gasSettings: ${inspect(this.gasSettings)},
+      effectiveGasFees: ${inspect(this.effectiveGasFees)},
       feePayer: ${inspect(this.feePayer)},
+      publicCallRequestArrayLengths: ${inspect(this.publicCallRequestArrayLengths)},
       publicSetupCallRequests: [${this.publicSetupCallRequests
         .filter(x => !x.isEmpty())
         .map(h => inspect(h))
@@ -258,6 +287,7 @@ export class AvmCircuitPublicInputs {
       previousRevertibleAccumulatedData: ${inspect(this.previousRevertibleAccumulatedData)},
       endTreeSnapshots: ${inspect(this.endTreeSnapshots)},
       endGasUsed: ${inspect(this.endGasUsed)},
+      accumulatedDataArrayLengths: ${inspect(this.accumulatedDataArrayLengths)},
       accumulatedData: ${inspect(this.accumulatedData)},
       transactionFee: ${inspect(this.transactionFee)},
       reverted: ${this.reverted},

package/src/avm/gas.ts

@@ -0,0 +1,26 @@
+import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
+
+import { Gas } from '../gas/gas.js';
+import { GasSettings } from '../gas/gas_settings.js';
+
+/**
+ * Apply L2 gas maximum to the gas settings.
+ */
+export function clampGasSettingsForAVM(gasSettings: GasSettings, gasUsedByPrivate: Gas): GasSettings {
+  return new GasSettings(
+    clampGasLimitsForAVM(gasSettings.gasLimits, gasUsedByPrivate),
+    clampGasLimitsForAVM(gasSettings.teardownGasLimits, new Gas(0, 0)),
+    gasSettings.maxFeesPerGas,
+    gasSettings.maxPriorityFeesPerGas,
+  );
+}
+
+/**
+ * Apply L2 gas maximum to the gas limits.
+ */
+function clampGasLimitsForAVM(gasLimits: Gas, gasUsedByPrivate: Gas): Gas {
+  return new Gas(
+    /*daGas=*/ gasLimits.daGas,
+    /*l2Gas=*/ Math.min(gasLimits.l2Gas, gasUsedByPrivate.l2Gas + MAX_L2_GAS_PER_TX_PUBLIC_PORTION),
+  );
+}

package/src/avm/index.ts

@@ -10,3 +10,4 @@ export * from './contract_storage_read.js';
 export * from './public_inner_call_request.js';
 export * from './public_call_stack_item_compressed.js';
 export * from './avm_proving_request.js';
+export * from './gas.js';

package/src/block/body.ts

@@ -87,9 +87,14 @@ export class Body {
 }`;
   }
 
-  static async random(txsPerBlock = 4, numPublicCallsPerTx = 3, numPublicLogsPerCall = 1) {
+  static async random(
+    txsPerBlock = 4,
+    numPublicCallsPerTx = 3,
+    numPublicLogsPerCall = 1,
+    maxEffects: number | undefined = undefined,
+  ) {
     const txEffects = await timesParallel(txsPerBlock, () =>
-      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall),
+      TxEffect.random(numPublicCallsPerTx, numPublicLogsPerCall, maxEffects),
     );
 
     return new Body(txEffects);

package/src/block/index.ts

@@ -6,3 +6,4 @@ export * from './l2_block_number.js';
 export * from './l2_block_source.js';
 export * from './block_hash.js';
 export * from './published_l2_block.js';
+export * from './proposal/index.js';

package/src/block/l2_block.ts

@@ -20,6 +20,7 @@ export class L2Block {
     public header: BlockHeader,
     /** L2 block body. */
     public body: Body,
+    private blockHash: Fr | undefined = undefined,
   ) {}
 
   static get schema() {
@@ -86,8 +87,9 @@ export class L2Block {
     numPublicLogsPerCall = 1,
     inHash: Buffer | undefined = undefined,
     slotNumber: number | undefined = undefined,
+    maxEffects: number | undefined = undefined,
   ): Promise<L2Block> {
-    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall);
+    const body = await Body.random(txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects);
 
     return new L2Block(
       makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
@@ -112,8 +114,11 @@ export class L2Block {
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public hash(): Promise<Fr> {
-    return this.header.hash();
+  public async hash(): Promise<Fr> {
+    if (this.blockHash === undefined) {
+      this.blockHash = await this.header.hash();
+    }
+    return this.blockHash;
   }
 
   /**

package/src/block/l2_block_source.ts

@@ -1,6 +1,6 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 
-import type { EventEmitter } from 'events';
 import { z } from 'zod';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
@@ -127,7 +127,12 @@ export interface L2BlockSource {
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
  */
-export interface L2BlockSourceEventEmitter extends L2BlockSource, EventEmitter {}
+
+export type ArchiverEmitter = TypedEventEmitter<{
+  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockSourceEvent) => void;
+  [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockSourceEvent) => void;
+}>;
+export interface L2BlockSourceEventEmitter extends L2BlockSource, ArchiverEmitter {}
 
 /**
  * Identifier for L2 block tags.
@@ -171,10 +176,11 @@ export const L2TipsSchema = z.object({
 
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
+  L2BlockProven = 'l2BlockProven',
 }
 
 export type L2BlockSourceEvent = {
-  type: 'l2PruneDetected';
+  type: 'l2PruneDetected' | 'l2BlockProven';
   blockNumber: bigint;
   slotNumber: bigint;
   epochNumber: bigint;

package/src/block/proposal/committee_attestation.ts

@@ -0,0 +1,70 @@
+import type { ViemCommitteeAttestation } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+export { Signature };
+export { EthAddress };
+
+export class CommitteeAttestation {
+  constructor(
+    public readonly address: EthAddress,
+    public readonly signature: Signature,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        address: EthAddress.schema,
+        signature: Signature.schema,
+      })
+      .transform(({ address, signature }) => new CommitteeAttestation(address, signature));
+  }
+
+  // Create an empty attestation for an address that has not signed
+  static fromAddress(address: EthAddress): CommitteeAttestation {
+    return new CommitteeAttestation(address, Signature.empty());
+  }
+
+  // Create an attestation from an address and a signature
+  static fromAddressAndSignature(address: EthAddress, signature: Signature): CommitteeAttestation {
+    return new CommitteeAttestation(address, signature);
+  }
+
+  static fromViem(viem: ViemCommitteeAttestation): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.fromString(viem.addr), Signature.fromViemSignature(viem.signature));
+  }
+
+  static fromBuffer(buffer: Buffer): CommitteeAttestation {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(EthAddress);
+    const signature = reader.readObject(Signature);
+    return new CommitteeAttestation(address, signature);
+  }
+
+  static random(): CommitteeAttestation {
+    // note: will be invalid
+    return new CommitteeAttestation(EthAddress.random(), Signature.random());
+  }
+
+  static empty(): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.ZERO, Signature.empty());
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.address, this.signature]);
+  }
+
+  equals(other: CommitteeAttestation): boolean {
+    return this.address.equals(other.address) && this.signature.equals(other.signature);
+  }
+
+  toViem(): ViemCommitteeAttestation {
+    return {
+      addr: this.address.toString(),
+      signature: this.signature.toViemSignature(),
+    };
+  }
+}

package/src/block/proposal/index.ts

@@ -0,0 +1 @@
+export * from './committee_attestation.js';

package/src/block/published_l2_block.ts

@@ -1,37 +1,51 @@
-import { Signature } from '@aztec/foundation/eth-signature';
+// Ignoring import issue to fix portable inferred type issue in zod schema
 import { schemas } from '@aztec/foundation/schemas';
-import { L2Block } from '@aztec/stdlib/block';
 
 import { z } from 'zod';
 
 import { BlockAttestation } from '../p2p/block_attestation.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { L2Block } from './l2_block.js';
+import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
-export type L1PublishedData = {
-  blockNumber: bigint;
-  timestamp: bigint;
-  blockHash: string;
-};
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
 
-export type PublishedL2Block = {
-  block: L2Block;
-  l1: L1PublishedData;
-  signatures: Signature[];
-};
+  static get schema() {
+    return z.object({
+      blockNumber: schemas.BigInt,
+      timestamp: schemas.BigInt,
+      blockHash: z.string(),
+    });
+  }
+}
+
+export class PublishedL2Block {
+  constructor(
+    public block: L2Block,
+    public l1: L1PublishedData,
+    public attestations: CommitteeAttestation[],
+  ) {}
 
-export const PublishedL2BlockSchema = z.object({
-  block: L2Block.schema,
-  l1: z.object({
-    blockNumber: schemas.BigInt,
-    timestamp: schemas.BigInt,
-    blockHash: z.string(),
-  }),
-  signatures: z.array(Signature.schema),
-});
+  static get schema() {
+    return z.object({
+      block: L2Block.schema,
+      l1: L1PublishedData.schema,
+      attestations: z.array(CommitteeAttestation.schema),
+    });
+  }
+}
 
 export function getAttestationsFromPublishedL2Block(block: PublishedL2Block) {
   const payload = ConsensusPayload.fromBlock(block.block);
-  return block.signatures
-    .filter(sig => !sig.isEmpty)
-    .map(signature => new BlockAttestation(block.block.header.globalVariables.blockNumber, payload, signature));
+  return block.attestations
+    .filter(attestation => !attestation.signature.isEmpty())
+    .map(
+      attestation =>
+        new BlockAttestation(block.block.header.globalVariables.blockNumber, payload, attestation.signature),
+    );
 }

package/src/block/test/l2_tips_store_test_suite.ts

@@ -17,7 +17,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
   const makeBlock = (number: number): PublishedL2Block => ({
     block: { number, header: { hash: () => Promise.resolve(new Fr(number)) } as BlockHeader } as L2Block,
     l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
-    signatures: [],
+    attestations: [],
   });
 
   const makeBlockId = (number: number): L2BlockId => ({

package/src/fees/transaction_fee.ts

@@ -4,7 +4,11 @@ import type { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import type { GasSettings } from '../gas/gas_settings.js';
 
-export function computeTransactionFee(gasFees: GasFees, gasSettings: GasSettings, gasUsed: Gas): Fr {
+/**
+ * Compute the effective gas fees that should be used to compute the transaction fee.
+ * This is the sum of the gas fees and the priority fees, but capped at the max fees per gas.
+ */
+export function computeEffectiveGasFees(gasFees: GasFees, gasSettings: GasSettings): GasFees {
   const { maxFeesPerGas, maxPriorityFeesPerGas } = gasSettings;
   const minField = (f1: Fr, f2: Fr) => (f1.lt(f2) ? f1 : f2);
   const priorityFees = new GasFees(
@@ -12,10 +16,15 @@ export function computeTransactionFee(gasFees: GasFees, gasSettings: GasSettings
     minField(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas.sub(gasFees.feePerL2Gas)),
   );
 
-  const totalFees = new GasFees(
+  const effectiveFees = new GasFees(
     gasFees.feePerDaGas.add(priorityFees.feePerDaGas),
     gasFees.feePerL2Gas.add(priorityFees.feePerL2Gas),
   );
 
-  return gasUsed.computeFee(totalFees);
+  return effectiveFees;
+}
+
+export function computeTransactionFee(gasFees: GasFees, gasSettings: GasSettings, gasUsed: Gas): Fr {
+  const effectiveFees = computeEffectiveGasFees(gasFees, gasSettings);
+  return gasUsed.computeFee(effectiveFees);
 }

package/src/interfaces/archiver.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
-import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
+import { PublishedL2Block } from '../block/published_l2_block.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
@@ -45,7 +45,7 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getPublishedBlocks: z
     .function()
     .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(PublishedL2BlockSchema)),
+    .returns(z.array(PublishedL2Block.schema)),
   getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.BigInt),

package/src/interfaces/aztec-node.ts

@@ -17,7 +17,7 @@ import { type InBlock, inBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockNumber, L2BlockNumberSchema } from '../block/l2_block_number.js';
 import { type L2BlockSource, type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
-import { PublishedL2BlockSchema } from '../block/published_l2_block.js';
+import { PublishedL2Block } from '../block/published_l2_block.js';
 import {
   type ContractClassPublic,
   ContractClassPublicSchema,
@@ -129,19 +129,11 @@ export interface AztecNode
   isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
 
   /**
-   * Returns a membership witness of an l2ToL1Message in an ephemeral l2 to l1 message tree.
-   * @dev Membership witness is a consists of the index and the sibling path of the l2ToL1Message.
-   * @remarks This tree is considered ephemeral because it is created on-demand by: taking all the l2ToL1 messages
-   * in a single block, and then using them to make a variable depth append-only tree with these messages as leaves.
-   * The tree is discarded immediately after calculating what we need from it.
+   * Returns all the L2 to L1 messages in a block.
    * @param blockNumber - The block number at which to get the data.
-   * @param l2ToL1Message - The l2ToL1Message to get the membership witness for.
-   * @returns A tuple of the index and the sibling path of the L2ToL1Message.
+   * @returns The L2 to L1 messages (undefined if the block number is not found).
    */
-  getL2ToL1MessageMembershipWitness(
-    blockNumber: L2BlockNumber,
-    l2ToL1Message: Fr,
-  ): Promise<[bigint, SiblingPath<number>]>;
+  getL2ToL1Messages(blockNumber: L2BlockNumber): Promise<Fr[][] | undefined>;
 
   /**
    * Returns a sibling path for a leaf in the committed historic blocks tree.
@@ -445,10 +437,10 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
 
-  getL2ToL1MessageMembershipWitness: z
+  getL2ToL1Messages: z
     .function()
-    .args(L2BlockNumberSchema, schemas.Fr)
-    .returns(z.tuple([schemas.BigInt, SiblingPath.schema])),
+    .args(L2BlockNumberSchema)
+    .returns(z.array(z.array(schemas.Fr)).optional()),
 
   getArchiveSiblingPath: z
     .function()
@@ -484,7 +476,7 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getBlocks: z.function().args(z.number(), z.number()).returns(z.array(L2Block.schema)),
 
-  getPublishedBlocks: z.function().args(z.number(), z.number()).returns(z.array(PublishedL2BlockSchema)),
+  getPublishedBlocks: z.function().args(z.number(), z.number()).returns(z.array(PublishedL2Block.schema)),
 
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 

package/src/interfaces/block-builder.ts

@@ -1,13 +1,18 @@
 import type { Fr } from '@aztec/foundation/fields';
+import type { Timer } from '@aztec/foundation/timer';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { AllowedElement } from '../config/index.js';
+import type { Gas } from '../gas/gas.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { GlobalVariables } from '../tx/global_variables.js';
-import type { ProcessedTx } from '../tx/processed_tx.js';
+import type { FailedTx, ProcessedTx } from '../tx/processed_tx.js';
+import { Tx } from '../tx/tx.js';
+import type { TxValidator } from '../tx/validator/tx_validator.js';
 import type { ProcessedTxHandler } from './processed-tx-handler.js';
 
 /** The interface to a block builder. Generates an L2 block out of a set of processed txs. */
-export interface BlockBuilder extends ProcessedTxHandler {
+export interface IBlockFactory extends ProcessedTxHandler {
   /**
    * Prepares to build a new block. Updates the L1 to L2 message tree.
    * @param globalVariables - The global variables for this block.
@@ -31,3 +36,45 @@ export interface BlockBuilder extends ProcessedTxHandler {
    */
   setBlockCompleted(expectedBlockHeader?: BlockHeader): Promise<L2Block>;
 }
+
+export interface PublicProcessorLimits {
+  maxTransactions?: number;
+  maxBlockSize?: number;
+  maxBlockGas?: Gas;
+  deadline?: Date;
+}
+
+export interface PublicProcessorValidator {
+  preprocessValidator?: TxValidator<Tx>;
+  nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
+}
+
+export interface BuildBlockOptions extends PublicProcessorLimits {
+  txPublicSetupAllowList?: AllowedElement[];
+}
+
+export interface BuildBlockResult {
+  block: L2Block;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numMsgs: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  blockBuildingTimer: Timer;
+  usedTxs: Tx[];
+}
+
+export interface IFullNodeBlockBuilder {
+  getConfig(): {
+    l1GenesisTime: bigint;
+    slotDuration: number;
+    l1ChainId: number;
+    rollupVersion: number;
+  };
+
+  buildBlock(
+    txs: Iterable<Tx> | AsyncIterable<Tx>,
+    globalVariables: GlobalVariables,
+    options: BuildBlockOptions,
+  ): Promise<BuildBlockResult>;
+}

package/src/interfaces/epoch-prover.ts

@@ -5,10 +5,10 @@ import type { Proof } from '../proofs/proof.js';
 import type { RootRollupPublicInputs } from '../rollup/root_rollup.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { Tx } from '../tx/tx.js';
-import type { BlockBuilder } from './block-builder.js';
+import type { IBlockFactory } from './block-builder.js';
 
 /** Coordinates the proving of an entire epoch. */
-export interface EpochProver extends Omit<BlockBuilder, 'setBlockCompleted'> {
+export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted'> {
   /**
    * Starts a new epoch. Must be the first method to be called.
    * @param epochNumber - The epoch number.