@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/interfaces/aztec-node.ts

@@ -1,14 +1,17 @@
 import {
   ARCHIVE_HEIGHT,
+  INITIAL_L2_BLOCK_NUM,
   L1_TO_L2_MSG_TREE_HEIGHT,
   NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
 import { type L1ContractAddresses, L1ContractAddressesSchema } from '@aztec/ethereum/l1-contract-addresses';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
-import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -17,6 +20,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 { PublishedL2Block } from '../block/published_l2_block.js';
 import {
   type ContractClassPublic,
   ContractClassPublicSchema,
@@ -37,24 +41,26 @@ import { NullifierMembershipWitness } from '../trees/nullifier_membership_witnes
 import { PublicDataWitness } from '../trees/public_data_witness.js';
 import {
   BlockHeader,
+  type IndexedTxEffect,
   PublicSimulationOutput,
   Tx,
   TxHash,
   TxReceipt,
   type TxValidationResult,
   TxValidationResultSchema,
+  indexedTxSchema,
 } from '../tx/index.js';
-import { TxEffect } from '../tx/tx_effect.js';
+import { SingleValidatorStatsSchema, ValidatorsStatsSchema } from '../validators/schemas.js';
+import type { SingleValidatorStats, ValidatorsStats } from '../validators/types.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
-import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
+import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
+import { MAX_RPC_BLOCKS_LEN, MAX_RPC_LEN, MAX_RPC_TXS_LEN } from './api_limit.js';
 import {
   type GetContractClassLogsResponse,
   GetContractClassLogsResponseSchema,
   type GetPublicLogsResponse,
   GetPublicLogsResponseSchema,
 } from './get_logs_response.js';
-import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
-import type { ProverCoordination } from './prover-coordination.js';
 import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_state.js';
 
 /**
@@ -62,8 +68,7 @@ import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_s
  * We will probably implement the additional interfaces by means other than Aztec Node as it's currently a privacy leak
  */
 export interface AztecNode
-  extends ProverCoordination,
-    Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'> {
+  extends Pick<L2BlockSource, 'getBlocks' | 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'> {
   /**
    * Returns the tips of the L2 chain.
    */
@@ -75,41 +80,17 @@ export interface AztecNode
   getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
 
   /**
-   * Find the indexes of the given leaves in the given tree.
-   * @param blockNumber - The block number at which to get the data or 'latest' for latest data
+   * Find the indexes of the given leaves in the given tree along with a block metadata pointing to the block in which
+   * the leaves were inserted.
+   * @param blockNumber - The block number at which to get the data or 'latest' for latest data.
    * @param treeId - The tree to search in.
-   * @param leafValues - The values to search for
-   * @returns The indexes of the given leaves in the given tree or undefined if not found.
+   * @param leafValues - The values to search for.
+   * @returns The indices of leaves and the block metadata of a block in which the leaves were inserted.
    */
   findLeavesIndexes(
     blockNumber: L2BlockNumber,
     treeId: MerkleTreeId,
     leafValues: Fr[],
-  ): Promise<(bigint | undefined)[]>;
-
-  /**
-   * Find the indexes of the given leaves in the given tree.
-   * @param blockNumber - The block number at which to get the data or 'latest' for latest data
-   * @param treeId - The tree to search in.
-   * @param leafIndices - The values to search for
-   * @returns The indexes of the given leaves in the given tree or undefined if not found.
-   */
-  findBlockNumbersForIndexes(
-    blockNumber: L2BlockNumber,
-    treeId: MerkleTreeId,
-    leafIndices: bigint[],
-  ): Promise<(bigint | undefined)[]>;
-
-  /**
-   * Returns the indexes of the given nullifiers in the nullifier tree,
-   * scoped to the block they were included in.
-   * @param blockNumber - The block number at which to get the data.
-   * @param nullifiers - The nullifiers to search for.
-   * @returns The block scoped indexes of the given nullifiers in the nullifier tree, or undefined if not found.
-   */
-  findNullifiersIndexesWithBlock(
-    blockNumber: L2BlockNumber,
-    nullifiers: Fr[],
   ): Promise<(InBlock<bigint> | undefined)[]>;
 
   /**
@@ -134,39 +115,6 @@ export interface AztecNode
     leafIndex: bigint,
   ): Promise<SiblingPath<typeof NOTE_HASH_TREE_HEIGHT>>;
 
-  /**
-   * Returns the index and a sibling path for a leaf in the committed l1 to l2 data tree.
-   * @param blockNumber - The block number at which to get the data.
-   * @param l1ToL2Message - The l1ToL2Message to get the index / sibling path for.
-   * @returns A tuple of the index and the sibling path of the L1ToL2Message (undefined if not found).
-   */
-  getL1ToL2MessageMembershipWitness(
-    blockNumber: L2BlockNumber,
-    l1ToL2Message: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>] | undefined>;
-
-  /**
-   * Returns whether an L1 to L2 message is synced by archiver and if it's ready to be included in a block.
-   * @param l1ToL2Message - The L1 to L2 message to check.
-   * @returns Whether the message is synced and ready to be included in a block.
-   */
-  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.
-   * @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.
-   */
-  getL2ToL1MessageMembershipWitness(
-    blockNumber: L2BlockNumber,
-    l2ToL1Message: Fr,
-  ): Promise<[bigint, SiblingPath<number>]>;
-
   /**
    * Returns a sibling path for a leaf in the committed historic blocks tree.
    * @param blockNumber - The block number at which to get the data.
@@ -220,17 +168,80 @@ export interface AztecNode
    * "in range" slot, means that the slot doesn't exist and the value is 0. If the low leaf preimage corresponds to the exact slot, the current value
    * is contained in the leaf preimage.
    */
-  getPublicDataTreeWitness(blockNumber: L2BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  getPublicDataWitness(blockNumber: L2BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+
+  /**
+   * Returns a membership witness for a given archive leaf at a given block.
+   * @param blockNumber - The block number at which to get the data.
+   * @param archive - The archive leaf we try to find the witness for.
+   */
+  getArchiveMembershipWitness(
+    blockNumber: L2BlockNumber,
+    archive: Fr,
+  ): Promise<MembershipWitness<typeof ARCHIVE_HEIGHT> | undefined>;
+
+  /**
+   * Returns a membership witness for a given note hash at a given block.
+   * @param blockNumber - The block number at which to get the data.
+   * @param noteHash - The note hash we try to find the witness for.
+   */
+  getNoteHashMembershipWitness(
+    blockNumber: L2BlockNumber,
+    noteHash: Fr,
+  ): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
+
+  /**
+   * Returns the index and a sibling path for a leaf in the committed l1 to l2 data tree.
+   * @param blockNumber - The block number at which to get the data.
+   * @param l1ToL2Message - The l1ToL2Message to get the index / sibling path for.
+   * @returns A tuple of the index and the sibling path of the L1ToL2Message (undefined if not found).
+   */
+  getL1ToL2MessageMembershipWitness(
+    blockNumber: L2BlockNumber,
+    l1ToL2Message: Fr,
+  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>] | undefined>;
+
+  /** Returns the L2 block number in which this L1 to L2 message becomes available, or undefined if not found. */
+  getL1ToL2MessageBlock(l1ToL2Message: Fr): Promise<number | undefined>;
+
+  /**
+   * Returns whether an L1 to L2 message is synced by archiver.
+   * @param l1ToL2Message - The L1 to L2 message to check.
+   * @returns Whether the message is synced.
+   * @deprecated Use `getL1ToL2MessageBlock` instead. This method may return true even if the message is not ready to use.
+   */
+  isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
+
+  /**
+   * Returns all the L2 to L1 messages in a block.
+   * @param blockNumber - The block number at which to get the data.
+   * @returns The L2 to L1 messages (undefined if the block number is not found).
+   */
+  getL2ToL1Messages(blockNumber: L2BlockNumber): Promise<Fr[][] | undefined>;
 
   /**
    * Get a block specified by its number.
    * @param number - The block number being requested.
    * @returns The requested block.
    */
-  getBlock(number: number): Promise<L2Block | undefined>;
+  getBlock(number: L2BlockNumber): Promise<L2Block | undefined>;
+
+  /**
+   * Get a block specified by its hash.
+   * @param blockHash - The block hash being requested.
+   * @returns The requested block.
+   */
+  getBlockByHash(blockHash: Fr): Promise<L2Block | undefined>;
 
   /**
-   * Fetches the current block number.
+   * Get a block specified by its archive root.
+   * @param archive - The archive root being requested.
+   * @returns The requested block.
+   */
+  getBlockByArchive(archive: Fr): Promise<L2Block | undefined>;
+
+  /**
+   * Method to fetch the latest block number synchronized by the node.
    * @returns The block number.
    */
   getBlockNumber(): Promise<number>;
@@ -268,6 +279,12 @@ export interface AztecNode
    */
   getCurrentBaseFees(): Promise<GasFees>;
 
+  /**
+   * Method to fetch the current max priority fee of txs in the mempool.
+   * @returns The current max priority fees.
+   */
+  getMaxPriorityFees(): Promise<GasFees>;
+
   /**
    * Method to fetch the version of the package.
    * @returns The node package version
@@ -298,11 +315,10 @@ export interface AztecNode
   getProtocolContractAddresses(): Promise<ProtocolContractAddresses>;
 
   /**
-   * Method to add a contract artifact to the database.
-   * @param aztecAddress
-   * @param artifact
+   * Registers contract function signatures for debugging purposes.
+   * @param functionSignatures - An array of function signatures to register by selector.
    */
-  registerContractFunctionSignatures(address: AztecAddress, functionSignatures: string[]): Promise<void>;
+  registerContractFunctionSignatures(functionSignatures: string[]): Promise<void>;
 
   /**
    * Retrieves all private logs from up to `limit` blocks, starting from the block number `from`.
@@ -329,11 +345,12 @@ export interface AztecNode
   /**
    * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
    * @param tags - The tags to filter the logs by.
+   * @param logsPerTag - How many logs to return per tag. Default 10 logs are returned for each tag
    * @returns For each received tag, an array of matching logs and metadata (e.g. tx hash) is returned. An empty
    * array implies no logs match that tag. There can be multiple logs for 1 tag because tag reuse can happen
    * --> e.g. when sending a note from multiple unsynched devices.
    */
-  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
+  getLogsByTags(tags: Fr[], logsPerTag?: number): Promise<TxScopedL2Log[][]>;
 
   /**
    * Method to submit a transaction to the p2p pool.
@@ -353,17 +370,17 @@ export interface AztecNode
   getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
 
   /**
-   * Get a tx effect.
-   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-   * @returns The requested tx effect.
+   * Gets a tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
-  getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined>;
+  getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined>;
 
   /**
    * Method to retrieve pending txs.
    * @returns The pending txs.
    */
-  getPendingTxs(): Promise<Tx[]>;
+  getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]>;
 
   /**
    * Retrieves the number of pending txs
@@ -404,6 +421,30 @@ export interface AztecNode
    */
   getBlockHeader(blockNumber?: L2BlockNumber): Promise<BlockHeader | undefined>;
 
+  /**
+   * Get a block header specified by its hash.
+   * @param blockHash - The block hash being requested.
+   * @returns The requested block header.
+   */
+  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+
+  /**
+   * Get a block header specified by its archive root.
+   * @param archive - The archive root being requested.
+   * @returns The requested block header.
+   */
+  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+
+  /** Returns stats for validators if enabled. */
+  getValidatorsStats(): Promise<ValidatorsStats>;
+
+  /** Returns stats for a single validator if enabled. */
+  getValidatorStats(
+    validatorAddress: EthAddress,
+    fromSlot?: SlotNumber,
+    toSlot?: SlotNumber,
+  ): Promise<SingleValidatorStats | undefined>;
+
   /**
    * Simulates the public part of a transaction with the current state.
    * This currently just checks that the transaction execution succeeds.
@@ -414,19 +455,13 @@ export interface AztecNode
   /**
    * Returns true if the transaction is valid for inclusion at the current state. Valid transactions can be
    * made invalid by *other* transactions if e.g. they emit the same nullifiers, or come become invalid
-   * due to e.g. the max_block_number property.
+   * due to e.g. the include_by_timestamp property.
    * @param tx - The transaction to validate for correctness.
    * @param isSimulation - True if the transaction is a simulated one without generated proofs. (Optional)
    * @param skipFeeEnforcement - True if the validation of the fee should be skipped. Useful when the simulation is for estimating fee (Optional)
    */
   isValidTx(tx: Tx, options?: { isSimulation?: boolean; skipFeeEnforcement?: boolean }): Promise<TxValidationResult>;
 
-  /**
-   * Updates the configuration of this node.
-   * @param config - Updated configuration to be merged with the current one.
-   */
-  setConfig(config: Partial<SequencerConfig & ProverConfig>): Promise<void>;
-
   /**
    * Returns a registered contract class given its id.
    * @param id - Id of the contract class.
@@ -439,22 +474,22 @@ export interface AztecNode
    */
   getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
 
-  /** Forces the next block to be built bypassing all time and pending checks. Useful for testing. */
-  flushTxs(): Promise<void>;
-
   /**
    * Returns the ENR of this node for peer discovery, if available.
    */
   getEncodedEnr(): Promise<string | undefined>;
 
   /**
-   * Adds a contract class bypassing the registerer.
-   * TODO(#10007): Remove this method.
-   * @param contractClass - The class to register.
+   * Returns the list of allowed public setup elements configured for this node.
+   * @returns The list of allowed elements.
    */
-  addContractClass(contractClass: ContractClassPublic): Promise<void>;
+  getAllowedPublicSetup(): Promise<AllowedElement[]>;
 }
 
+export const MAX_LOGS_PER_TAG = 10;
+const MAX_SIGNATURES_PER_REGISTER_CALL = 100;
+const MAX_SIGNATURE_LEN = 10000;
+
 export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
   getL2Tips: z.function().args().returns(L2TipsSchema),
 
@@ -462,17 +497,7 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   findLeavesIndexes: z
     .function()
-    .args(L2BlockNumberSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.Fr))
-    .returns(z.array(optional(schemas.BigInt))),
-
-  findBlockNumbersForIndexes: z
-    .function()
-    .args(L2BlockNumberSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.BigInt))
-    .returns(z.array(optional(schemas.BigInt))),
-
-  findNullifiersIndexesWithBlock: z
-    .function()
-    .args(L2BlockNumberSchema, z.array(schemas.Fr))
+    .args(L2BlockNumberSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.Fr).max(MAX_RPC_LEN))
     .returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
 
   getNullifierSiblingPath: z
@@ -485,18 +510,6 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(L2BlockNumberSchema, schemas.BigInt)
     .returns(SiblingPath.schemaFor(NOTE_HASH_TREE_HEIGHT)),
 
-  getL1ToL2MessageMembershipWitness: z
-    .function()
-    .args(L2BlockNumberSchema, schemas.Fr)
-    .returns(z.tuple([schemas.BigInt, SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)]).optional()),
-
-  isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
-
-  getL2ToL1MessageMembershipWitness: z
-    .function()
-    .args(L2BlockNumberSchema, schemas.Fr)
-    .returns(z.tuple([schemas.BigInt, SiblingPath.schema])),
-
   getArchiveSiblingPath: z
     .function()
     .args(L2BlockNumberSchema, schemas.BigInt)
@@ -517,12 +530,37 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     .args(L2BlockNumberSchema, schemas.Fr)
     .returns(NullifierMembershipWitness.schema.optional()),
 
-  getPublicDataTreeWitness: z
+  getPublicDataWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(PublicDataWitness.schema.optional()),
+
+  getArchiveMembershipWitness: z
+    .function()
+    .args(L2BlockNumberSchema, schemas.Fr)
+    .returns(MembershipWitness.schemaFor(ARCHIVE_HEIGHT).optional()),
+
+  getNoteHashMembershipWitness: z
+    .function()
+    .args(L2BlockNumberSchema, schemas.Fr)
+    .returns(MembershipWitness.schemaFor(NOTE_HASH_TREE_HEIGHT).optional()),
+
+  getL1ToL2MessageMembershipWitness: z
     .function()
     .args(L2BlockNumberSchema, schemas.Fr)
-    .returns(PublicDataWitness.schema.optional()),
+    .returns(z.tuple([schemas.BigInt, SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)]).optional()),
+
+  getL1ToL2MessageBlock: z.function().args(schemas.Fr).returns(z.number().optional()),
+
+  isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
+
+  getL2ToL1Messages: z
+    .function()
+    .args(L2BlockNumberSchema)
+    .returns(z.array(z.array(schemas.Fr)).optional()),
+
+  getBlock: z.function().args(L2BlockNumberSchema).returns(L2Block.schema.optional()),
+
+  getBlockByHash: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
 
-  getBlock: z.function().args(z.number()).returns(L2Block.schema.optional()),
+  getBlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
 
   getBlockNumber: z.function().returns(z.number()),
 
@@ -532,10 +570,20 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getNodeInfo: z.function().returns(NodeInfoSchema),
 
-  getBlocks: z.function().args(z.number(), z.number()).returns(z.array(L2Block.schema)),
+  getBlocks: z
+    .function()
+    .args(z.number().gte(INITIAL_L2_BLOCK_NUM), z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
+    .returns(z.array(L2Block.schema)),
+
+  getPublishedBlocks: z
+    .function()
+    .args(z.number().gte(INITIAL_L2_BLOCK_NUM), z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN))
+    .returns(z.array(PublishedL2Block.schema)),
 
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 
+  getMaxPriorityFees: z.function().returns(GasFees.schema),
+
   getNodeVersion: z.function().returns(z.string()),
 
   getVersion: z.function().returns(z.number()),
@@ -546,9 +594,15 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getProtocolContractAddresses: z.function().returns(ProtocolContractAddressesSchema),
 
-  registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
+  registerContractFunctionSignatures: z
+    .function()
+    .args(z.array(z.string().max(MAX_SIGNATURE_LEN)).max(MAX_SIGNATURES_PER_REGISTER_CALL))
+    .returns(z.void()),
 
-  getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
+  getPrivateLogs: z
+    .function()
+    .args(z.number().gte(INITIAL_L2_BLOCK_NUM), z.number().lte(MAX_RPC_LEN))
+    .returns(z.array(PrivateLog.schema)),
 
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
 
@@ -556,27 +610,44 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 
   getLogsByTags: z
     .function()
-    .args(z.array(schemas.Fr))
+    .args(
+      z.array(schemas.Fr).max(MAX_RPC_LEN),
+      optional(z.number().gte(1).lte(MAX_LOGS_PER_TAG).default(MAX_LOGS_PER_TAG)),
+    )
     .returns(z.array(z.array(TxScopedL2Log.schema))),
 
   sendTx: z.function().args(Tx.schema).returns(z.void()),
 
   getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
 
-  getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
+  getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
 
-  getPendingTxs: z.function().returns(z.array(Tx.schema)),
+  getPendingTxs: z
+    .function()
+    .args(optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)), optional(TxHash.schema))
+    .returns(z.array(Tx.schema)),
 
   getPendingTxCount: z.function().returns(z.number()),
 
   getTxByHash: z.function().args(TxHash.schema).returns(Tx.schema.optional()),
 
-  getTxsByHash: z.function().args(z.array(TxHash.schema)).returns(z.array(Tx.schema)),
+  getTxsByHash: z.function().args(z.array(TxHash.schema).max(MAX_RPC_TXS_LEN)).returns(z.array(Tx.schema)),
 
   getPublicStorageAt: z.function().args(L2BlockNumberSchema, schemas.AztecAddress, schemas.Fr).returns(schemas.Fr),
 
   getBlockHeader: z.function().args(optional(L2BlockNumberSchema)).returns(BlockHeader.schema.optional()),
 
+  getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+
+  getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+
+  getValidatorsStats: z.function().returns(ValidatorsStatsSchema),
+
+  getValidatorStats: z
+    .function()
+    .args(schemas.EthAddress, optional(schemas.SlotNumber), optional(schemas.SlotNumber))
+    .returns(SingleValidatorStatsSchema.optional()),
+
   simulatePublicCalls: z.function().args(Tx.schema, optional(z.boolean())).returns(PublicSimulationOutput.schema),
 
   isValidTx: z
@@ -587,28 +658,25 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
     )
     .returns(TxValidationResultSchema),
 
-  setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
-
   getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
 
   getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
 
-  flushTxs: z.function().returns(z.void()),
-
   getEncodedEnr: z.function().returns(z.string().optional()),
 
-  // TODO(#10007): Remove this method
-  addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void()),
+  getAllowedPublicSetup: z.function().args().returns(z.array(AllowedElementSchema)),
 };
 
 export function createAztecNodeClient(
   url: string,
   versions: Partial<ComponentsVersions> = {},
-  fetch = defaultFetch,
+  fetch = makeFetch([1, 2, 3], false),
+  batchWindowMS = 0,
 ): AztecNode {
   return createSafeJsonRpcClient<AztecNode>(url, AztecNodeApiSchema, {
     namespaceMethods: 'node',
     fetch,
+    batchWindowMS,
     onResponse: getVersioningResponseHandler(versions),
   });
 }

package/src/interfaces/block-builder.ts

@@ -1,24 +1,26 @@
 import type { Fr } from '@aztec/foundation/fields';
+import type { Timer } from '@aztec/foundation/timer';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { ChainConfig, SequencerConfig } from '../config/chain-config.js';
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import type { Gas } from '../gas/gas.js';
+import type { MerkleTreeWriteOperations } from '../trees/index.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.
    * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this block.
-   * @param previousBlockHeader - The header of the previous block.
    */
-  startNewBlock(
-    globalVariables: GlobalVariables,
-    l1ToL2Messages: Fr[],
-    previousBlockHeader: BlockHeader,
-  ): Promise<void>;
+  startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void>;
 
   /**
    * Adds all processed txs to the block. Updates world state with the effects from this tx.
@@ -31,3 +33,46 @@ export interface BlockBuilder extends ProcessedTxHandler {
    */
   setBlockCompleted(expectedBlockHeader?: BlockHeader): Promise<L2Block>;
 }
+
+export interface PublicProcessorLimits {
+  maxTransactions?: number;
+  maxBlockSize?: number;
+  maxBlockGas?: Gas;
+  maxBlobFields?: number;
+  deadline?: Date;
+}
+
+export interface PublicProcessorValidator {
+  preprocessValidator?: TxValidator<Tx>;
+  nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
+}
+export interface BuildBlockResult {
+  block: L2Block;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numMsgs: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  blockBuildingTimer: Timer;
+  usedTxs: Tx[];
+}
+
+export type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'> &
+  Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
+  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'fakeProcessingDelayPerTxMs'>;
+
+export interface IFullNodeBlockBuilder {
+  getConfig(): FullNodeBlockBuilderConfig;
+
+  updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
+
+  buildBlock(
+    txs: Iterable<Tx> | AsyncIterable<Tx>,
+    l1ToL2Messages: Fr[],
+    globalVariables: GlobalVariables,
+    options: PublicProcessorLimits,
+    fork?: MerkleTreeWriteOperations,
+  ): Promise<BuildBlockResult>;
+
+  getFork(blockNumber: number): Promise<MerkleTreeWriteOperations>;
+}

package/src/interfaces/client.ts

@@ -1,4 +1,5 @@
-export * from './pxe.js';
 export * from './aztec-node.js';
+export * from './aztec-node-admin.js';
 export * from './private_kernel_prover.js';
 export * from './get_logs_response.js';
+export * from './api_limit.js';