@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/interfaces/block-builder.ts

@@ -1,24 +1,27 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
 
 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 { BlockHeader } from '../tx/block_header.js';
-import type { GlobalVariables } from '../tx/global_variables.js';
-import type { ProcessedTx } from '../tx/processed_tx.js';
+import type { CheckpointGlobalVariables, GlobalVariables } from '../tx/global_variables.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 { MerkleTreeWriteOperations } from './merkle_tree_operations.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 +34,73 @@ 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 type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'> &
+  Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> &
+  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'>;
+
+export const FullNodeBlockBuilderConfigKeys: (keyof FullNodeBlockBuilderConfig)[] = [
+  'l1GenesisTime',
+  'slotDuration',
+  'l1ChainId',
+  'rollupVersion',
+  'txPublicSetupAllowList',
+  'fakeProcessingDelayPerTxMs',
+  'fakeThrowAfterProcessingTxCount',
+] as const;
+
+/** Thrown when no valid transactions are available to include in a block after processing, and this is not the first block in a checkpoint. */
+export class NoValidTxsError extends Error {
+  constructor(public readonly failedTxs: FailedTx[]) {
+    super('No valid transactions to include in block');
+    this.name = 'NoValidTxsError';
+  }
+}
+
+/** Result of building a block within a checkpoint. */
+export type BuildBlockInCheckpointResult = {
+  block: L2Block;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  usedTxs: Tx[];
+  usedTxBlobFields: number;
+};
+
+/** Interface for building blocks within a checkpoint context. */
+export interface ICheckpointBlockBuilder {
+  buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits,
+  ): Promise<BuildBlockInCheckpointResult>;
+}
+
+/** Interface for creating checkpoint builders. */
+export interface ICheckpointsBuilder {
+  getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations>;
+
+  startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    fork: MerkleTreeWriteOperations,
+    bindings?: LoggerBindings,
+  ): Promise<ICheckpointBlockBuilder>;
+}

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';

package/src/interfaces/configs.ts

@@ -1,29 +1,24 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Prettify } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
+import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
 
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
-
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
-
-/**
- * The sequencer configuration.
- */
+/** Sequencer configuration */
 export interface SequencerConfig {
   /** The number of ms to wait between polling for pending txs. */
-  transactionPollingIntervalMS?: number;
+  sequencerPollingIntervalMS?: number;
   /** The maximum number of txs to include in a block. */
   maxTxsPerBlock?: number;
   /** The minimum number of txs to include in a block. */
   minTxsPerBlock?: number;
+  /** The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock. */
+  minValidTxsPerBlock?: number;
+  /** Whether to publish txs with the block proposals */
+  publishTxsWithProposals?: boolean;
   /** The maximum L2 block gas. */
   maxL2BlockGas?: number;
   /** The maximum DA block gas. */
@@ -37,37 +32,93 @@ export interface SequencerConfig {
   /** The path to the ACVM binary */
   acvmBinaryPath?: string;
   /** The list of functions calls allowed to run in setup */
-  allowedInSetup?: AllowedElement[];
+  txPublicSetupAllowList?: AllowedElement[];
   /** Max block size */
   maxBlockSizeInBytes?: number;
   /** Payload address to vote for */
   governanceProposerPayload?: EthAddress;
   /** Whether to enforce the time table when building blocks */
   enforceTimeTable?: boolean;
-  /** How many seconds into an L1 slot we can still send a tx and get it mined. */
-  maxL1TxInclusionTimeIntoSlot?: number;
+  /** How much time (in seconds) we allow in the slot for publishing the L1 tx. */
+  l1PublishingTime?: number;
+  /** Used for testing to introduce a fake delay after processing each tx */
+  fakeProcessingDelayPerTxMs?: number;
+  /** Used for testing to throw an error after processing N txs */
+  fakeThrowAfterProcessingTxCount?: number;
+  /** How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way) */
+  attestationPropagationTime?: number;
+  /** How many seconds before invalidating a block as a committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsCommitteeMember?: number;
+  /** How many seconds before invalidating a block as a non-committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember?: number;
+  /** Skip collecting attestations (for testing only) */
+  skipCollectingAttestations?: boolean;
+  /** Do not invalidate the previous block if invalid when we are the proposer (for testing only) */
+  skipInvalidateBlockAsProposer?: boolean;
+  /** Broadcast invalid block proposals with corrupted state (for testing only) */
+  broadcastInvalidBlockProposal?: boolean;
+  /** Inject a fake attestation (for testing only) */
+  injectFakeAttestation?: boolean;
+  /** Whether to run in fisherman mode: builds blocks on every slot for validation without publishing */
+  fishermanMode?: boolean;
+  /** Shuffle attestation ordering to create invalid ordering (for testing only) */
+  shuffleAttestationOrdering?: boolean;
+  /** Duration per block in milliseconds when building multiple blocks per slot (default: undefined = single block per slot) */
+  blockDurationMs?: number;
+  /** Have sequencer build and publish an empty checkpoint if there are no txs */
+  buildCheckpointIfEmpty?: boolean;
+  /** Skip pushing proposed blocks to archiver (default: false) */
+  skipPushProposedBlocksToArchiver?: boolean;
 }
 
-const AllowedElementSchema = z.union([
-  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-  z.object({ address: schemas.AztecAddress }),
-  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-  z.object({ classId: schemas.Fr }),
-]) satisfies ZodFor<AllowedElement>;
+export const SequencerConfigSchema = zodFor<SequencerConfig>()(
+  z.object({
+    sequencerPollingIntervalMS: z.number().optional(),
+    maxTxsPerBlock: z.number().optional(),
+    minValidTxsPerBlock: z.number().optional(),
+    minTxsPerBlock: z.number().optional(),
+    maxL2BlockGas: z.number().optional(),
+    publishTxsWithProposals: z.boolean().optional(),
+    maxDABlockGas: z.number().optional(),
+    coinbase: schemas.EthAddress.optional(),
+    feeRecipient: schemas.AztecAddress.optional(),
+    acvmWorkingDirectory: z.string().optional(),
+    acvmBinaryPath: z.string().optional(),
+    txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+    maxBlockSizeInBytes: z.number().optional(),
+    governanceProposerPayload: schemas.EthAddress.optional(),
+    l1PublishingTime: z.number().optional(),
+    enforceTimeTable: z.boolean().optional(),
+    fakeProcessingDelayPerTxMs: z.number().optional(),
+    fakeThrowAfterProcessingTxCount: z.number().optional(),
+    attestationPropagationTime: z.number().optional(),
+    skipCollectingAttestations: z.boolean().optional(),
+    skipInvalidateBlockAsProposer: z.boolean().optional(),
+    secondsBeforeInvalidatingBlockAsCommitteeMember: z.number(),
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.number(),
+    broadcastInvalidBlockProposal: z.boolean().optional(),
+    injectFakeAttestation: z.boolean().optional(),
+    fishermanMode: z.boolean().optional(),
+    shuffleAttestationOrdering: z.boolean().optional(),
+    blockDurationMs: z.number().positive().optional(),
+    buildCheckpointIfEmpty: z.boolean().optional(),
+    skipPushProposedBlocksToArchiver: z.boolean().optional(),
+  }),
+);
+
+type SequencerConfigOptionalKeys =
+  | 'governanceProposerPayload'
+  | 'blockDurationMs'
+  | 'coinbase'
+  | 'feeRecipient'
+  | 'acvmWorkingDirectory'
+  | 'acvmBinaryPath'
+  | 'fakeProcessingDelayPerTxMs'
+  | 'fakeThrowAfterProcessingTxCount'
+  | 'l1PublishingTime'
+  | 'txPublicSetupAllowList'
+  | 'minValidTxsPerBlock';
 
-export const SequencerConfigSchema = z.object({
-  transactionPollingIntervalMS: z.number().optional(),
-  maxTxsPerBlock: z.number().optional(),
-  minTxsPerBlock: z.number().optional(),
-  maxL2BlockGas: z.number().optional(),
-  maxDABlockGas: z.number().optional(),
-  coinbase: schemas.EthAddress.optional(),
-  feeRecipient: schemas.AztecAddress.optional(),
-  acvmWorkingDirectory: z.string().optional(),
-  acvmBinaryPath: z.string().optional(),
-  allowedInSetup: z.array(AllowedElementSchema).optional(),
-  maxBlockSizeInBytes: z.number().optional(),
-  governanceProposerPayload: schemas.EthAddress.optional(),
-  maxL1TxInclusionTimeIntoSlot: z.number().optional(),
-  enforceTimeTable: z.boolean().optional(),
-}) satisfies ZodFor<SequencerConfig>;
+export type ResolvedSequencerConfig = Prettify<
+  Required<Omit<SequencerConfig, SequencerConfigOptionalKeys>> & Pick<SequencerConfig, SequencerConfigOptionalKeys>
+>;

package/src/interfaces/epoch-prover.ts

@@ -1,42 +1,71 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
+import type { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L2Block } from '../block/l2_block.js';
 import type { Proof } from '../proofs/proof.js';
-import type { RootRollupPublicInputs } from '../rollup/root_rollup.js';
+import type { CheckpointConstantData } from '../rollup/checkpoint_constant_data.js';
+import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.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 { UInt64 } from '../types/index.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' | 'startNewBlock'> {
   /**
    * Starts a new epoch. Must be the first method to be called.
    * @param epochNumber - The epoch number.
-   * @param firstBlockNumber - The block number of the first block in the epoch.
-   * @param totalNumBlocks - The total number of blocks expected in the epoch (must be at least one).
+   * @param totalNumCheckpoints - The total number of checkpoints expected in the epoch (must be at least one).
+   * @param finalBlobBatchingChallenges - The final blob batching challenges for the epoch.
    **/
-  startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void;
+  startNewEpoch(
+    epochNumber: EpochNumber,
+    totalNumCheckpoints: number,
+    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+  ): void;
 
   /**
-   * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+   * Starts a new checkpoint.
+   * @param checkpointIndex - The index of the checkpoint in the epoch.
+   * @param constants - The constants for this checkpoint.
+   * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this checkpoint.
+   * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
+   * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
    */
-  startTubeCircuits(txs: Tx[]): Promise<void>;
+  startNewCheckpoint(
+    checkpointIndex: number,
+    constants: CheckpointConstantData,
+    l1ToL2Messages: Fr[],
+    totalNumBlocks: number,
+    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
+  ): Promise<void>;
+
+  /**
+   * Starts a new block.
+   * @param blockNumber - The block number.
+   * @param timestamp - The timestamp of the block.
+   * @param totalNumTxs - The total number of txs in the block.
+   */
+  startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number): Promise<void>;
+
+  /**
+   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
+   * Note that if the chonk verifier circuits are not started this way, they will be started nonetheless after processing.
+   */
+  startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
 
   /** Returns the block. */
-  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block>;
+  setBlockCompleted(blockNumber: BlockNumber, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;
 
   /** Pads the epoch with empty block roots if needed and blocks until proven. Throws if proving has failed. */
-  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof }>;
+  finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }>;
 
   /** Cancels all proving jobs. */
   cancel(): void;
 
   /** Returns an identifier for the prover or zero if not set. */
-  getProverId(): Fr;
-
-  /** Returns the block assembled at a given index (zero-based) within the epoch. */
-  getBlock(index: number): L2Block;
+  getProverId(): EthAddress;
 
   /** Called when no longer required, cleans up internal resources */
   stop(): Promise<void>;

package/src/interfaces/get_logs_response.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 
 import { ExtendedContractClassLog } from '../logs/extended_contract_class_log.js';
 import { ExtendedPublicLog } from '../logs/extended_public_log.js';
-import type { ZodFor } from '../schemas/index.js';
+import { zodFor } from '../schemas/index.js';
 
 /** Response for the getContractClassLogs archiver call. */
 export type GetContractClassLogsResponse = {
@@ -12,10 +12,12 @@ export type GetContractClassLogsResponse = {
   maxLogsHit: boolean;
 };
 
-export const GetContractClassLogsResponseSchema: ZodFor<GetContractClassLogsResponse> = z.object({
-  logs: z.array(ExtendedContractClassLog.schema),
-  maxLogsHit: z.boolean(),
-});
+export const GetContractClassLogsResponseSchema = zodFor<GetContractClassLogsResponse>()(
+  z.object({
+    logs: z.array(ExtendedContractClassLog.schema),
+    maxLogsHit: z.boolean(),
+  }),
+);
 
 /** Response for the getPublicLogs archiver call. */
 export type GetPublicLogsResponse = {
@@ -25,7 +27,9 @@ export type GetPublicLogsResponse = {
   maxLogsHit: boolean;
 };
 
-export const GetPublicLogsResponseSchema = z.object({
-  logs: z.array(ExtendedPublicLog.schema),
-  maxLogsHit: z.boolean(),
-}) satisfies ZodFor<GetPublicLogsResponse>;
+export const GetPublicLogsResponseSchema = zodFor<GetPublicLogsResponse>()(
+  z.object({
+    logs: z.array(ExtendedPublicLog.schema),
+    maxLogsHit: z.boolean(),
+  }),
+);

package/src/interfaces/l2_logs_source.ts

@@ -1,7 +1,9 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 
+import type { AztecAddress } from '../aztec-address/index.js';
 import type { LogFilter } from '../logs/log_filter.js';
-import type { PrivateLog } from '../logs/private_log.js';
+import type { SiloedTag } from '../logs/siloed_tag.js';
+import type { Tag } from '../logs/tag.js';
 import type { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from './get_logs_response.js';
 
@@ -10,20 +12,29 @@ import type { GetContractClassLogsResponse, GetPublicLogsResponse } from './get_
  */
 export interface L2LogsSource {
   /**
-   * Retrieves all private logs from up to `limit` blocks, starting from the block number `from`.
-   * @param from - The block number from which to begin retrieving logs.
-   * @param limit - The maximum number of blocks to retrieve logs from.
-   * @returns An array of private logs from the specified range of blocks.
+   * Gets private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * array implies no logs match that tag.
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination.
+   * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
+   * for a tag, the caller should fetch the next page to check for more logs.
    */
-  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]>;
+  getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
 
   /**
-   * 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.
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
+   * Gets public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * logs is returned. An empty array implies no logs match that tag.
+   * @param contractAddress - The contract address to search logs for.
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination.
+   * @returns An array of log arrays, one per tag. Returns at most 10 logs per tag per page. If 10 logs are returned
+   * for a tag, the caller should fetch the next page to check for more logs.
    */
-  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
+  getPublicLogsByTagsFromContract(
+    contractAddress: AztecAddress,
+    tags: Tag[],
+    page?: number,
+  ): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs based on the provided filter.
@@ -43,5 +54,5 @@ export interface L2LogsSource {
    * Gets the number of the latest L2 block processed by the implementation.
    * @returns The number of the latest L2 block processed by the implementation.
    */
-  getBlockNumber(): Promise<number>;
+  getBlockNumber(): Promise<BlockNumber>;
 }

package/src/interfaces/merkle_tree_operations.ts

@@ -1,12 +1,14 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 
-import type { MerkleTreeId } from '../trees/merkle_tree_id.js';
+import type { MerkleTreeId, TreeHeights } from '../trees/merkle_tree_id.js';
 import type { NullifierLeaf } from '../trees/nullifier_leaf.js';
 import type { PublicDataTreeLeaf } from '../trees/public_data_leaf.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { StateReference } from '../tx/state_reference.js';
+import type { WorldStateRevision, WorldStateRevisionWithHandle } from '../world-state/world_state_revision.js';
 
 /**
  * Type alias for the nullifier tree ID.
@@ -132,12 +134,17 @@ export interface MerkleTreeReadOperations {
    */
   getInitialHeader(): BlockHeader;
 
+  /**
+   * Gets the current revision.
+   */
+  getRevision(): WorldStateRevision | WorldStateRevisionWithHandle;
+
   /**
    * Gets sibling path for a leaf.
    * @param treeId - The tree to be queried for a sibling path.
    * @param index - The index of the leaf for which a sibling path should be returned.
    */
-  getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>>;
+  getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>>;
 
   /**
    * Returns the previous index for a given value in an indexed tree.
@@ -149,13 +156,9 @@ export interface MerkleTreeReadOperations {
     value: bigint,
   ): Promise<
     | {
-        /**
-         * The index of the found leaf.
-         */
+        /** The index of the found leaf.*/
         index: bigint;
-        /**
-         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
-         */
+        /** A flag indicating if the corresponding leaf's value is equal to `newValue`. */
         alreadyPresent: boolean;
       }
     | undefined
@@ -178,6 +181,16 @@ export interface MerkleTreeReadOperations {
     values: MerkleTreeLeafType<ID>[],
   ): Promise<(bigint | undefined)[]>;
 
+  /**
+   * Returns the sibling paths for the given leaf values
+   * @param treeId - The tree for which the index should be returned.
+   * @param values - The values to search for in the tree.
+   */
+  findSiblingPaths<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<({ path: SiblingPath<TreeHeights[ID]>; index: bigint } | undefined)[]>;
+
   /**
    * Returns the first index containing a leaf value after `startIndex`.
    * @param treeId - The tree for which the index should be returned.
@@ -208,7 +221,7 @@ export interface MerkleTreeReadOperations {
   getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
     treeId: ID,
     leafIndices: bigint[],
-  ): Promise<(bigint | undefined)[]>;
+  ): Promise<(BlockNumber | undefined)[]>;
 }
 
 export interface MerkleTreeCheckpointOperations {
@@ -226,9 +239,22 @@ export interface MerkleTreeCheckpointOperations {
    * Reverts the current checkpoint
    */
   revertCheckpoint(): Promise<void>;
+
+  /**
+   * Commits all checkpoints
+   */
+  commitAllCheckpoints(): Promise<void>;
+
+  /**
+   * Reverts all checkpoints
+   */
+  revertAllCheckpoints(): Promise<void>;
 }
 
-export interface MerkleTreeWriteOperations extends MerkleTreeReadOperations, MerkleTreeCheckpointOperations {
+export interface MerkleTreeWriteOperations
+  extends MerkleTreeReadOperations,
+    MerkleTreeCheckpointOperations,
+    Disposable {
   /**
    * Appends leaves to a given tree.
    * @param treeId - The tree to be updated.

package/src/interfaces/p2p.ts

@@ -1,9 +1,13 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+
 import { z } from 'zod';
 
-import { BlockAttestation } from '../p2p/block_attestation.js';
+import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
 import type { P2PClientType } from '../p2p/client_type.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { MAX_RPC_TXS_LEN } from './api_limit.js';
 
 export type PeerInfo =
   | { status: 'connected'; score: number; id: string }
@@ -26,9 +30,14 @@ const PeerInfoSchema = z.discriminatedUnion('status', [
 export interface P2PApiWithoutAttestations {
   /**
    * Returns all pending transactions in the transaction pool.
+   * @param limit - The number of items to returns
+   * @param after - The last known pending tx. Used for pagination
    * @returns An array of Txs.
    */
-  getPendingTxs(): Promise<Tx[]>;
+  getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]>;
+
+  /** Returns the number of pending txs in the p2p tx pool. */
+  getPendingTxCount(): Promise<number>;
 
   /**
    * Returns the ENR for this node, if any.
@@ -41,27 +50,41 @@ export interface P2PApiWithoutAttestations {
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
 }
 
-export interface P2PClient extends P2PApiWithoutAttestations {
+export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
-   * Queries the Attestation pool for attestations for the given slot
+   * Queries the Attestation pool for checkpoint attestations for the given slot
    *
    * @param slot - the slot to query
    * @param proposalId - the proposal id to query, or undefined to query all proposals for the slot
-   * @returns BlockAttestations
+   * @returns CheckpointAttestations
    */
-  getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+  getCheckpointAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<CheckpointAttestation[]>;
+}
+
+export interface P2PClient extends P2PApiWithAttestations {
+  /** Manually adds checkpoint attestations to the p2p client attestation pool. */
+  addCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
 }
 
 export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PClient & P2PApiWithoutAttestations
+  ? P2PApiWithAttestations
+  : P2PApiWithoutAttestations;
+
+export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
+  ? P2PApiWithAttestations & P2PClient
   : P2PApiWithoutAttestations;
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
-  getAttestationsForSlot: z
+  getCheckpointAttestationsForSlot: z
     .function()
-    .args(schemas.BigInt, optional(z.string()))
-    .returns(z.array(BlockAttestation.schema)),
-  getPendingTxs: z.function().returns(z.array(Tx.schema)),
+    .args(schemas.SlotNumber, optional(z.string()))
+    .returns(z.array(CheckpointAttestation.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(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
 };