@aztec/stdlib 0.0.1-commit.7b97ef96e → 0.0.1-commit.7cbc774

package/src/ha-signing/local_config.ts

@@ -0,0 +1,46 @@
+import { type ConfigMappingsType, getConfigFromMappings, optionalNumberConfigHelper } from '@aztec/foundation/config';
+import { zodFor } from '@aztec/foundation/schemas';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
+
+import { z } from 'zod';
+
+import { type BaseSignerConfig, BaseSignerConfigSchema, baseSignerConfigMappings } from './config.js';
+
+/**
+ * Configuration for local (single-node) slashing protection.
+ *
+ * Combines the base signing protection fields (shared with HA mode) with
+ * DataStoreConfig for the local LMDB backing store, plus a per-store map-size
+ * override. Used when HA signing is disabled.
+ */
+export type LocalSignerConfig = BaseSignerConfig &
+  DataStoreConfig & {
+    /** Maximum size of the local signing-protection LMDB store in KB. Overwrites the general dataStoreMapSizeKb. */
+    signingProtectionMapSizeKb?: number;
+  };
+
+export const localSignerConfigMappings: ConfigMappingsType<LocalSignerConfig> = {
+  ...baseSignerConfigMappings,
+  ...dataConfigMappings,
+  signingProtectionMapSizeKb: {
+    env: 'SIGNING_PROTECTION_MAP_SIZE_KB',
+    description:
+      'Maximum size of the local signing-protection LMDB store in KB. Overwrites the general dataStoreMapSizeKb.',
+    ...optionalNumberConfigHelper(),
+  },
+};
+
+export const LocalSignerConfigSchema = zodFor<LocalSignerConfig>()(
+  BaseSignerConfigSchema.extend({
+    dataDirectory: z.string().optional(),
+    dataStoreMapSizeKb: z.number(),
+    signingProtectionMapSizeKb: z.number().optional(),
+  }),
+);
+
+/**
+ * Returns the local signer configuration from environment variables.
+ */
+export function getLocalSignerConfigEnvVars(): LocalSignerConfig {
+  return getConfigFromMappings<LocalSignerConfig>(localSignerConfigMappings);
+}

package/src/ha-signing/types.ts

@@ -0,0 +1,126 @@
+import {
+  BlockNumber,
+  CheckpointNumber,
+  type IndexWithinCheckpoint,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
+
+/**
+ * Type of validator duty being performed
+ */
+export enum DutyType {
+  BLOCK_PROPOSAL = 'BLOCK_PROPOSAL',
+  CHECKPOINT_PROPOSAL = 'CHECKPOINT_PROPOSAL',
+  ATTESTATION = 'ATTESTATION',
+  ATTESTATIONS_AND_SIGNERS = 'ATTESTATIONS_AND_SIGNERS',
+  GOVERNANCE_VOTE = 'GOVERNANCE_VOTE',
+  SLASHING_VOTE = 'SLASHING_VOTE',
+  AUTH_REQUEST = 'AUTH_REQUEST',
+  TXS = 'TXS',
+}
+
+/**
+ * Signing context for block proposals.
+ * Includes both the block number and the checkpoint number the block belongs to.
+ */
+export interface BlockProposalSigningContext {
+  slot: SlotNumber;
+  blockNumber: BlockNumber;
+  checkpointNumber: CheckpointNumber;
+  /** Block index within checkpoint (0, 1, 2...). Required for block proposals. */
+  blockIndexWithinCheckpoint: IndexWithinCheckpoint;
+  dutyType: DutyType.BLOCK_PROPOSAL;
+}
+
+/**
+ * Signing context for checkpoint proposals.
+ * Includes the checkpoint number being proposed, but not a block number.
+ */
+export interface CheckpointProposalSigningContext {
+  slot: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  dutyType: DutyType.CHECKPOINT_PROPOSAL;
+}
+
+/**
+ * Signing context for attestation duties (checkpoint attestations).
+ * Includes the checkpoint number when available (from proposal validation).
+ */
+export interface AttestationSigningContext {
+  slot: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  dutyType: DutyType.ATTESTATION | DutyType.ATTESTATIONS_AND_SIGNERS;
+}
+
+/**
+ * Signing context for governance/slashing votes which only need slot for HA protection.
+ */
+export interface VoteSigningContext {
+  slot: SlotNumber;
+  dutyType: DutyType.GOVERNANCE_VOTE | DutyType.SLASHING_VOTE;
+}
+
+/**
+ * Signing context for duties which don't require slot/blockNumber
+ * as they don't need HA protection (AUTH_REQUEST, TXS).
+ */
+export interface NoHAProtectionSigningContext {
+  dutyType: DutyType.AUTH_REQUEST | DutyType.TXS;
+}
+
+/**
+ * Signing contexts that require HA protection (excludes AUTH_REQUEST and TXS).
+ * Used by the HA signer's signWithProtection method.
+ */
+export type HAProtectedSigningContext =
+  | BlockProposalSigningContext
+  | CheckpointProposalSigningContext
+  | AttestationSigningContext
+  | VoteSigningContext;
+
+/**
+ * Context required for slashing protection during signing operations.
+ * Uses discriminated union to enforce type safety:
+ * - BLOCK_PROPOSAL duties have blockNumber, checkpointNumber, and blockIndexWithinCheckpoint
+ * - CHECKPOINT_PROPOSAL duties have checkpointNumber
+ * - ATTESTATION/ATTESTATIONS_AND_SIGNERS duties have only slot
+ * - Vote duties have only slot
+ * - AUTH_REQUEST and TXS duties don't need HA protection
+ */
+export type SigningContext = HAProtectedSigningContext | NoHAProtectionSigningContext;
+
+/**
+ * Type guard to check if a SigningContext requires HA protection.
+ * Returns true for contexts that need HA protection, false for AUTH_REQUEST and TXS.
+ */
+export function isHAProtectedContext(context: SigningContext): context is HAProtectedSigningContext {
+  return context.dutyType !== DutyType.AUTH_REQUEST && context.dutyType !== DutyType.TXS;
+}
+
+/**
+ * Gets the block number from a signing context.
+ * Only BLOCK_PROPOSAL duties carry a block number; all others return BlockNumber(0).
+ */
+export function getBlockNumberFromSigningContext(context: HAProtectedSigningContext): BlockNumber {
+  if (context.dutyType === DutyType.BLOCK_PROPOSAL) {
+    return context.blockNumber;
+  }
+  return BlockNumber(0);
+}
+
+/**
+ * Gets the checkpoint number from a signing context.
+ * BLOCK_PROPOSAL, CHECKPOINT_PROPOSAL, ATTESTATION, and ATTESTATIONS_AND_SIGNERS duties carry a checkpoint number;
+ * vote duties return CheckpointNumber(0).
+ */
+export function getCheckpointNumberFromSigningContext(context: HAProtectedSigningContext): CheckpointNumber {
+  if (
+    context.dutyType === DutyType.BLOCK_PROPOSAL ||
+    context.dutyType === DutyType.CHECKPOINT_PROPOSAL ||
+    context.dutyType === DutyType.ATTESTATION ||
+    context.dutyType === DutyType.ATTESTATIONS_AND_SIGNERS
+  ) {
+    return context.checkpointNumber;
+  }
+  return CheckpointNumber(0);
+}

package/src/hash/hash.ts

@@ -1,4 +1,4 @@
-import { DomainSeparator, NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { poseidon2Hash, poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -6,6 +6,21 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
+/** Computes a Poseidon2 merkle tree internal node hash for append-only trees (note-hash, L1->L2, archive). */
+export function computeMerkleHash(left: Fr, right: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([left, right], DomainSeparator.MERKLE_HASH);
+}
+
+/** Merkle-node hasher for the nullifier tree's sibling paths. */
+export function computeNullifierMerkleHash(left: Fr, right: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([left, right], DomainSeparator.NULLIFIER_MERKLE);
+}
+
+/** Merkle-node hasher for the public-data tree's sibling paths. */
+export function computePublicDataMerkleHash(left: Fr, right: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([left, right], DomainSeparator.PUBLIC_DATA_MERKLE);
+}
+
 /**
  * Computes a hash of a given verification key.
  * @param keyAsFields - The verification key as fields.
@@ -58,6 +73,35 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
   return poseidon2HashWithSeparator([contract, innerNullifier], DomainSeparator.SILOED_NULLIFIER);
 }
 
+/**
+ * Computes the siloed private initialization nullifier for a contract, given its address and initialization hash.
+ * @param contract - The contract address.
+ * @param initializationHash - The contract's initialization hash.
+ * @returns The siloed private initialization nullifier.
+ */
+export async function computeSiloedPrivateInitializationNullifier(
+  contract: AztecAddress,
+  initializationHash: Fr,
+): Promise<Fr> {
+  const innerNullifier = await poseidon2HashWithSeparator(
+    [contract, initializationHash],
+    DomainSeparator.PRIVATE_INITIALIZATION_NULLIFIER,
+  );
+  return siloNullifier(contract, innerNullifier);
+}
+
+/**
+ * Computes the siloed public initialization nullifier for a contract. Not all contracts emit this nullifier: it is only
+ * emitted when the contract has public functions that perform initialization checks (i.e. external public functions that
+ * are not `#[noinitcheck]` or `#[only_self]`).
+ * @param contract - The contract address.
+ * @returns The siloed public initialization nullifier.
+ */
+export async function computeSiloedPublicInitializationNullifier(contract: AztecAddress): Promise<Fr> {
+  const innerNullifier = await poseidon2HashWithSeparator([contract], DomainSeparator.PUBLIC_INITIALIZATION_NULLIFIER);
+  return siloNullifier(contract, innerNullifier);
+}
+
 /**
  * Computes the protocol nullifier, which is the hash of the initial tx request siloed with the null msg sender address.
  * @param txRequestHash - The hash of the initial tx request.
@@ -66,7 +110,24 @@ export function siloNullifier(contract: AztecAddress, innerNullifier: Fr): Promi
  * @dev Must match the implementation in noir-protocol-circuits/crates/types/src/hash.nr > compute_protocol_nullifier
  */
 export function computeProtocolNullifier(txRequestHash: Fr): Promise<Fr> {
-  return siloNullifier(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS), txRequestHash);
+  return siloNullifier(AztecAddress.NULL_MSG_SENDER, txRequestHash);
+}
+
+/** Domain-separates a raw log tag with the given domain separator. */
+export function computeLogTag(rawTag: number | bigint | boolean | Fr | Buffer, domSep: DomainSeparator): Promise<Fr> {
+  return poseidon2HashWithSeparator([new Fr(rawTag)], domSep);
+}
+
+/**
+ * Computes the commitment of a private event from its preimage.
+ * @param randomness - Random value emitted alongside the event to prevent preimage brute-forcing.
+ * @param eventSelector - Event selector as an Fr.
+ * @param content - Serialized event content.
+ *
+ * @dev Must match the implementation in aztec-nr/aztec/src/event/event_interface.nr > compute_private_serialized_event_commitment
+ */
+export function computePrivateEventCommitment(randomness: Fr, eventSelector: Fr, content: Fr[]): Promise<Fr> {
+  return poseidon2HashWithSeparator([randomness, eventSelector, ...content], DomainSeparator.EVENT_COMMITMENT);
 }
 
 export function computeSiloedPrivateLogFirstField(contract: AztecAddress, field: Fr): Promise<Fr> {

package/src/interfaces/allowed_element.ts

@@ -6,18 +6,38 @@ import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import { schemas, zodFor } from '../schemas/index.js';
 
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
+type AllowedInstanceFunction = {
+  address: AztecAddress;
+  selector: FunctionSelector;
+  onlySelf?: boolean;
+  rejectNullMsgSender?: boolean;
+  calldataLength?: number;
+};
+type AllowedClassFunction = {
+  classId: Fr;
+  selector: FunctionSelector;
+  onlySelf?: boolean;
+  rejectNullMsgSender?: boolean;
+  calldataLength?: number;
+};
 
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+export type AllowedElement = AllowedInstanceFunction | AllowedClassFunction;
 
 export const AllowedElementSchema = zodFor<AllowedElement>()(
   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 }),
+    z.object({
+      address: schemas.AztecAddress,
+      selector: schemas.FunctionSelector,
+      onlySelf: z.boolean().optional(),
+      rejectNullMsgSender: z.boolean().optional(),
+      calldataLength: z.number().optional(),
+    }),
+    z.object({
+      classId: schemas.Fr,
+      selector: schemas.FunctionSelector,
+      onlySelf: z.boolean().optional(),
+      rejectNullMsgSender: z.boolean().optional(),
+      calldataLength: z.number().optional(),
+    }),
   ]),
 );

package/src/interfaces/api_limit.ts

@@ -2,4 +2,4 @@ export const MAX_RPC_LEN = 100;
 export const MAX_RPC_TXS_LEN = 50;
 export const MAX_RPC_BLOCKS_LEN = 50;
 export const MAX_RPC_CHECKPOINTS_LEN = 50;
-export const MAX_LOGS_PER_TAG = 10;
+export const MAX_LOGS_PER_TAG = 20;

package/src/interfaces/archiver.ts

@@ -1,17 +1,21 @@
-import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { BlockNumberSchema, CheckpointNumberSchema, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 import { BlockDataSchema } from '../block/block_data.js';
-import { BlockHash } from '../block/block_hash.js';
-import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
-import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
+import {
+  BlockQuerySchema,
+  BlocksQuerySchema,
+  CheckpointQuerySchema,
+  CheckpointsQuerySchema,
+  type L2BlockSource,
+  L2TipsSchema,
+  ProposedCheckpointQuerySchema,
+} from '../block/l2_block_source.js';
 import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
-import { Checkpoint } from '../checkpoint/checkpoint.js';
-import { CheckpointDataSchema } from '../checkpoint/checkpoint_data.js';
+import { CheckpointDataSchema, ProposedCheckpointDataSchema } from '../checkpoint/checkpoint_data.js';
 import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   ContractClassPublicSchema,
@@ -19,17 +23,13 @@ import {
   ContractInstanceWithAddressSchema,
 } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
-import { LogFilterSchema } from '../logs/log_filter.js';
-import { SiloedTag } from '../logs/siloed_tag.js';
-import { Tag } from '../logs/tag.js';
-import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
+import { LogResultSchema } from '../logs/log_result.js';
+import { PrivateLogsQuerySchema, PublicLogsQuerySchema } from '../logs/logs_query.js';
 import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
 import { optional, schemas } from '../schemas/schemas.js';
-import { BlockHeader } from '../tx/block_header.js';
 import { indexedTxSchema } from '../tx/indexed_tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
 import { TxReceipt } from '../tx/tx_receipt.js';
-import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
 import type { L2LogsSource } from './l2_logs_source.js';
 
 /**
@@ -45,12 +45,6 @@ export type ArchiverSpecificConfig = {
   /** The polling interval viem uses in ms */
   viemPollingIntervalMS?: number;
 
-  /** The deployed L1 contract addresses */
-  l1Contracts: L1ContractAddresses;
-
-  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
-  maxLogs?: number;
-
   /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb. */
   archiverStoreMapSizeKb?: number;
 
@@ -60,96 +54,93 @@ export type ArchiverSpecificConfig = {
   /** Whether to allow starting the archiver without debug/trace method support on Ethereum hosts */
   ethereumAllowNoDebugHosts?: boolean;
 
+  /** Skip the startup check that probes the L1 RPC for historical logs on the Rollup contract. */
+  archiverSkipHistoricalLogsCheck?: boolean;
+
   /** Skip validating checkpoint attestations (for testing purposes only) */
   skipValidateCheckpointAttestations?: boolean;
+
+  /** Skip promoting proposed checkpoints during L1 sync (for testing purposes only) */
+  skipPromoteProposedCheckpointDuringL1Sync?: boolean;
+
+  /**
+   * Grace period in seconds, measured from the end of a proposed block's build slot, after which a
+   * proposed block whose enclosing checkpoint was never proposed is pruned as an orphan. Defaults
+   * from `blockDurationMs / 1000` at the node wiring layer, falling back to the timetable minimum
+   * execution time.
+   */
+  orphanProposedBlockPruneGraceSeconds?: number;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
   archiverPollingIntervalMS: schemas.Integer.optional(),
   archiverBatchSize: schemas.Integer.optional(),
   viemPollingIntervalMS: schemas.Integer.optional(),
-  maxLogs: schemas.Integer.optional(),
   archiverStoreMapSizeKb: schemas.Integer.optional(),
   maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
   ethereumAllowNoDebugHosts: z.boolean().optional(),
+  archiverSkipHistoricalLogsCheck: z.boolean().optional(),
   skipValidateCheckpointAttestations: z.boolean().optional(),
+  skipPromoteProposedCheckpointDuringL1Sync: z.boolean().optional(),
+  orphanProposedBlockPruneGraceSeconds: schemas.Integer.optional(),
 });
 
 export type ArchiverApi = Omit<
   L2BlockSource & L2LogsSource & ContractDataSource & L1ToL2MessageSource,
-  'start' | 'stop'
+  'start' | 'stop' | 'getGenesisBlockHash'
 >;
 
 export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
-  getRollupAddress: z.function().args().returns(schemas.EthAddress),
-  getRegistryAddress: z.function().args().returns(schemas.EthAddress),
-  getBlockNumber: z.function().args().returns(BlockNumberSchema),
-  getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
-  getCheckpointedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
-  getFinalizedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
-  getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
-  getBlockHeader: z
-    .function()
-    .args(z.union([BlockNumberSchema, z.literal('latest')]))
-    .returns(BlockHeader.schema.optional()),
-  getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
-  getCheckpointedBlocks: z
-    .function()
-    .args(BlockNumberSchema, schemas.Integer)
-    .returns(z.array(CheckpointedL2Block.schema)),
-  getBlocks: z.function().args(BlockNumberSchema, schemas.Integer).returns(z.array(L2Block.schema)),
-  getCheckpoints: z
-    .function()
-    .args(CheckpointNumberSchema, schemas.Integer)
-    .returns(z.array(PublishedCheckpoint.schema)),
-  getCheckpointedBlockByHash: z.function().args(BlockHash.schema).returns(CheckpointedL2Block.schema.optional()),
-  getCheckpointedBlockByArchive: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
-  getBlockHeaderByHash: z.function().args(BlockHash.schema).returns(BlockHeader.schema.optional()),
-  getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
-  getBlockData: z.function().args(BlockNumberSchema).returns(BlockDataSchema.optional()),
-  getBlockDataByArchive: z.function().args(schemas.Fr).returns(BlockDataSchema.optional()),
-  getL2Block: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
-  getL2BlockByHash: z.function().args(BlockHash.schema).returns(L2Block.schema.optional()),
-  getL2BlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
-  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.SlotNumber.optional()),
-  getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
-  getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
-  getCheckpointsDataForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointDataSchema)),
-  getCheckpointedBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointedL2Block.schema)),
-  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2Block.schema)),
-  getCheckpointedBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
-  isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
-  getL2Tips: z.function().args().returns(L2TipsSchema),
-  getPrivateLogsByTags: z
-    .function()
-    .args(z.array(SiloedTag.schema), optional(z.number().gte(0)))
-    .returns(z.array(z.array(TxScopedL2Log.schema))),
-  getPublicLogsByTagsFromContract: z
-    .function()
-    .args(schemas.AztecAddress, z.array(Tag.schema), optional(z.number().gte(0)))
-    .returns(z.array(z.array(TxScopedL2Log.schema))),
-  getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
-  getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-  getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
-  getBytecodeCommitment: z.function().args(schemas.Fr).returns(schemas.Fr),
-  getContract: z
-    .function()
-    .args(schemas.AztecAddress, optional(schemas.BigInt))
-    .returns(ContractInstanceWithAddressSchema.optional()),
-  getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
-  registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
-  getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
-  getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
-  getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
-  getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
-  getGenesisValues: z
-    .function()
-    .args()
-    .returns(z.object({ genesisArchiveRoot: schemas.Fr })),
-  getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
-  syncImmediate: z.function().args().returns(z.void()),
-  isPendingChainInvalid: z.function().args().returns(z.boolean()),
-  getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema),
+  getRollupAddress: z.function({ input: z.tuple([]), output: schemas.EthAddress }),
+  getRegistryAddress: z.function({ input: z.tuple([]), output: schemas.EthAddress }),
+  getBlockNumber: z.function({ input: z.tuple([optional(BlockQuerySchema)]), output: BlockNumberSchema.optional() }),
+  getCheckpointNumber: z.function({ input: z.tuple([]), output: CheckpointNumberSchema }),
+  getCheckpoint: z.function({ input: z.tuple([CheckpointQuerySchema]), output: PublishedCheckpoint.schema.optional() }),
+  getCheckpoints: z.function({ input: z.tuple([CheckpointsQuerySchema]), output: z.array(PublishedCheckpoint.schema) }),
+  getCheckpointData: z.function({ input: z.tuple([CheckpointQuerySchema]), output: CheckpointDataSchema.optional() }),
+  getCheckpointsData: z.function({ input: z.tuple([CheckpointsQuerySchema]), output: z.array(CheckpointDataSchema) }),
+  getTxEffect: z.function({ input: z.tuple([TxHash.schema]), output: indexedTxSchema().optional() }),
+  getSettledTxReceipt: z.function({ input: z.tuple([TxHash.schema]), output: TxReceipt.schema.optional() }),
+  getSyncedL2SlotNumber: z.function({ input: z.tuple([]), output: schemas.SlotNumber.optional() }),
+  getSyncedL2EpochNumber: z.function({ input: z.tuple([]), output: EpochNumberSchema.optional() }),
+  getBlocksForSlot: z.function({ input: z.tuple([schemas.SlotNumber]), output: z.array(L2Block.schema) }),
+  isEpochComplete: z.function({ input: z.tuple([EpochNumberSchema]), output: z.boolean() }),
+  getL2Tips: z.function({ input: z.tuple([]), output: L2TipsSchema }),
+  getPrivateLogsByTags: z.function({
+    input: z.tuple([PrivateLogsQuerySchema]),
+    output: z.array(z.array(LogResultSchema)),
+  }),
+  getPublicLogsByTags: z.function({
+    input: z.tuple([PublicLogsQuerySchema]),
+    output: z.array(z.array(LogResultSchema)),
+  }),
+  getContractClass: z.function({ input: z.tuple([schemas.Fr]), output: ContractClassPublicSchema.optional() }),
+  getBytecodeCommitment: z.function({ input: z.tuple([schemas.Fr]), output: schemas.Fr }),
+  getContract: z.function({
+    input: z.tuple([schemas.AztecAddress, optional(schemas.BigInt)]),
+    output: ContractInstanceWithAddressSchema.optional(),
+  }),
+  getContractClassIds: z.function({ input: z.tuple([]), output: z.array(schemas.Fr) }),
+  registerContractFunctionSignatures: z.function({ input: z.tuple([z.array(z.string())]), output: z.void() }),
+  getL1ToL2Messages: z.function({ input: z.tuple([CheckpointNumberSchema]), output: z.array(schemas.Fr) }),
+  getL1ToL2MessageIndex: z.function({ input: z.tuple([schemas.Fr]), output: schemas.BigInt.optional() }),
+  getDebugFunctionName: z.function({
+    input: z.tuple([schemas.AztecAddress, schemas.FunctionSelector]),
+    output: optional(z.string()),
+  }),
+  getL1Constants: z.function({ input: z.tuple([]), output: L1RollupConstantsSchema }),
+  isPruneDueAtSlot: z.function({ input: z.tuple([schemas.SlotNumber]), output: z.boolean() }),
+  getGenesisValues: z.function({ input: z.tuple([]), output: z.object({ genesisArchiveRoot: schemas.Fr }) }),
+  getL1Timestamp: z.function({ input: z.tuple([]), output: schemas.BigInt.optional() }),
+  getProposedCheckpointData: z.function({
+    input: z.tuple([optional(ProposedCheckpointQuerySchema)]),
+    output: ProposedCheckpointDataSchema.optional(),
+  }),
+  syncImmediate: z.function({ input: z.tuple([]), output: z.void() }),
+  isPendingChainInvalid: z.function({ input: z.tuple([]), output: z.boolean() }),
+  getPendingChainValidationStatus: z.function({ input: z.tuple([]), output: ValidateCheckpointResultSchema }),
+  getBlock: z.function({ input: z.tuple([BlockQuerySchema]), output: L2Block.schema.optional() }),
+  getBlocks: z.function({ input: z.tuple([BlocksQuerySchema]), output: z.array(L2Block.schema) }),
+  getBlockData: z.function({ input: z.tuple([BlockQuerySchema]), output: BlockDataSchema.optional() }),
+  getBlocksData: z.function({ input: z.tuple([BlocksQuerySchema]), output: z.array(BlockDataSchema) }),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -1,9 +1,11 @@
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
 
 import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/schemas.js';
-import { type Offense, OffenseSchema, type SlashPayloadRound, SlashPayloadRoundSchema } from '../slashing/index.js';
+import { optional } from '../schemas/schemas.js';
+import { type Offense, OffenseSchema } from '../slashing/index.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 import { type ArchiverSpecificConfig, ArchiverSpecificConfigSchema } from './archiver.js';
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
@@ -36,8 +38,9 @@ export interface AztecNodeAdmin {
    * Pauses syncing and rolls back the database to the target L2 block number.
    * @param targetBlockNumber - The block number to roll back to.
    * @param force - If true, clears the world state db and p2p dbs if rolling back to behind the finalized block.
+   * @param resumeSync - If true (default), resumes archiver and world state sync after rollback.
    */
-  rollbackTo(targetBlockNumber: number, force?: boolean): Promise<void>;
+  rollbackTo(targetBlockNumber: number, force?: boolean, resumeSync?: boolean): Promise<void>;
 
   /** Pauses archiver and world state syncing. */
   pauseSync(): Promise<void>;
@@ -45,8 +48,14 @@ export interface AztecNodeAdmin {
   /** Resumes archiver and world state syncing. */
   resumeSync(): Promise<void>;
 
-  /** Returns all monitored payloads by the slasher for the current round. */
-  getSlashPayloads(): Promise<SlashPayloadRound[]>;
+  /**
+   * Pauses block production. Pending txs remain in the mempool; no new blocks will be
+   * produced until {@link resumeSequencer} is called. Throws if no sequencer is running.
+   */
+  pauseSequencer(): Promise<void>;
+
+  /** Resumes block production previously paused via {@link pauseSequencer}. */
+  resumeSequencer(): Promise<void>;
 
   /** Returns all offenses applicable for the given round. */
   getSlashOffenses(round: bigint | 'all' | 'current'): Promise<Offense[]>;
@@ -72,8 +81,8 @@ export interface AztecNodeAdmin {
   reloadKeystore(): Promise<void>;
 }
 
-// L1 contracts are not mutable via admin updates.
-export type AztecNodeAdminConfig = Omit<ValidatorClientFullConfig, 'l1Contracts'> &
+// L1 contract addresses are pinned at startup and are not mutable via admin updates.
+export type AztecNodeAdminConfig = Omit<ValidatorClientFullConfig, keyof L1ContractAddresses> &
   SequencerConfig &
   ProverConfig &
   SlasherConfig &
@@ -82,11 +91,13 @@ export type AztecNodeAdminConfig = Omit<ValidatorClientFullConfig, 'l1Contracts'
     'archiverPollingIntervalMS' | 'archiverBatchSize' | 'skipValidateCheckpointAttestations'
   > & {
     maxPendingTxCount: number;
+    // Keep in sync with P2PConfig.skipIncomingProposals (circular dep prevents Pick<P2PConfig, ...> here)
+    skipIncomingProposals?: boolean;
   };
 
 export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
   .merge(SlasherConfigSchema)
-  .merge(ValidatorClientFullConfigSchema.omit({ l1Contracts: true }))
+  .merge(ValidatorClientFullConfigSchema.omit({ rollupAddress: true }))
   .merge(
     ArchiverSpecificConfigSchema.pick({
       archiverPollingIntervalMS: true,
@@ -94,21 +105,25 @@ export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConf
       skipValidateCheckpointAttestations: true,
     }),
   )
-  .merge(z.object({ maxPendingTxCount: z.number() }));
+  .merge(z.object({ maxPendingTxCount: z.number(), skipIncomingProposals: z.boolean().optional() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
-  getConfig: z.function().returns(AztecNodeAdminConfigSchema),
-  setConfig: z.function().args(AztecNodeAdminConfigSchema.partial()).returns(z.void()),
-  startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
-  rollbackTo: z.function().args(z.number()).returns(z.void()),
-  pauseSync: z.function().returns(z.void()),
-  resumeSync: z.function().returns(z.void()),
-  getSlashPayloads: z.function().returns(z.array(SlashPayloadRoundSchema)),
-  getSlashOffenses: z
-    .function()
-    .args(z.union([z.bigint(), z.literal('all'), z.literal('current')]))
-    .returns(z.array(OffenseSchema)),
-  reloadKeystore: z.function().returns(z.void()),
+  getConfig: z.function({ input: z.tuple([]), output: AztecNodeAdminConfigSchema }),
+  setConfig: z.function({ input: z.tuple([AztecNodeAdminConfigSchema.partial()]), output: z.void() }),
+  startSnapshotUpload: z.function({ input: z.tuple([z.string()]), output: z.void() }),
+  rollbackTo: z.function({
+    input: z.tuple([z.number(), optional(z.boolean()), optional(z.boolean())]),
+    output: z.void(),
+  }),
+  pauseSync: z.function({ input: z.tuple([]), output: z.void() }),
+  resumeSync: z.function({ input: z.tuple([]), output: z.void() }),
+  pauseSequencer: z.function({ input: z.tuple([]), output: z.void() }),
+  resumeSequencer: z.function({ input: z.tuple([]), output: z.void() }),
+  getSlashOffenses: z.function({
+    input: z.tuple([z.union([z.bigint(), z.literal('all'), z.literal('current')])]),
+    output: z.array(OffenseSchema),
+  }),
+  reloadKeystore: z.function({ input: z.tuple([]), output: z.void() }),
 };
 
 export function createAztecNodeAdminClient(