@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.e61ad554

package/src/interfaces/block-builder.ts

@@ -1,17 +1,16 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
-import type { Timer } from '@aztec/foundation/timer';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 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 { 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. */
@@ -47,33 +46,51 @@ export interface PublicProcessorValidator {
   preprocessValidator?: TxValidator<Tx>;
   nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
 }
-export interface BuildBlockResult {
+
+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;
+
+/** Result of building a block within a checkpoint. */
+export interface BuildBlockInCheckpointResult {
   block: L2Block;
   publicGas: Gas;
   publicProcessorDuration: number;
-  numMsgs: number;
   numTxs: number;
   failedTxs: FailedTx[];
-  blockBuildingTimer: Timer;
   usedTxs: Tx[];
+  usedTxBlobFields: number;
 }
 
-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;
-
+/** Interface for building blocks within a checkpoint context. */
+export interface ICheckpointBlockBuilder {
   buildBlock(
-    txs: Iterable<Tx> | AsyncIterable<Tx>,
-    l1ToL2Messages: Fr[],
-    globalVariables: GlobalVariables,
-    options: PublicProcessorLimits,
-    fork?: MerkleTreeWriteOperations,
-  ): Promise<BuildBlockResult>;
+    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,
+  ): Promise<ICheckpointBlockBuilder>;
 }

package/src/interfaces/configs.ts

@@ -1,21 +1,22 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Prettify } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
 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';
 
-/**
- * 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. */
@@ -38,10 +39,12 @@ export interface SequencerConfig {
   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) */
@@ -60,31 +63,62 @@ export interface SequencerConfig {
   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;
 }
 
-export const SequencerConfigSchema = z.object({
-  transactionPollingIntervalMS: z.number().optional(),
-  maxTxsPerBlock: 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(),
-  maxL1TxInclusionTimeIntoSlot: z.number().optional(),
-  enforceTimeTable: z.boolean().optional(),
-  fakeProcessingDelayPerTxMs: z.number().optional(),
-  attestationPropagationTime: z.number().optional(),
-  skipCollectingAttestations: 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(),
-}) satisfies ZodFor<SequencerConfig>;
+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 type ResolvedSequencerConfig = Prettify<
+  Required<Omit<SequencerConfig, SequencerConfigOptionalKeys>> & Pick<SequencerConfig, SequencerConfigOptionalKeys>
+>;

package/src/interfaces/epoch-prover.ts

@@ -1,7 +1,7 @@
 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 { Fr } from '@aztec/foundation/fields';
 
 import type { Proof } from '../proofs/proof.js';
 import type { CheckpointConstantData } from '../rollup/checkpoint_constant_data.js';

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,8 +1,9 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
 
+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';
 
@@ -11,21 +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: BlockNumber, 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.
-   * @param logsPerTag - The maximum number of logs to return for each tag. Default returns everything
-   * @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[], logsPerTag?: number): Promise<TxScopedL2Log[][]>;
+  getPublicLogsByTagsFromContract(
+    contractAddress: AztecAddress,
+    tags: Tag[],
+    page?: number,
+  ): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs based on the provided filter.

package/src/interfaces/merkle_tree_operations.ts

@@ -1,5 +1,5 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 
@@ -251,7 +251,10 @@ export interface MerkleTreeCheckpointOperations {
   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

@@ -2,7 +2,7 @@ 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';
@@ -52,21 +52,18 @@ export interface 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: SlotNumber, proposalId?: string): Promise<BlockAttestation[]>;
-
-  /** Deletes a given attestation manually from the p2p client attestation pool. */
-  deleteAttestation(attestation: BlockAttestation): Promise<void>;
+  getCheckpointAttestationsForSlot(slot: SlotNumber, proposalId?: string): Promise<CheckpointAttestation[]>;
 }
 
 export interface P2PClient extends P2PApiWithAttestations {
-  /** Manually adds an attestation to the p2p client attestation pool. */
-  addAttestations(attestations: BlockAttestation[]): Promise<void>;
+  /** 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
@@ -78,10 +75,10 @@ export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends
   : P2PApiWithoutAttestations;
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
-  getAttestationsForSlot: z
+  getCheckpointAttestationsForSlot: z
     .function()
     .args(schemas.SlotNumber, optional(z.string()))
-    .returns(z.array(BlockAttestation.schema)),
+    .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))
@@ -90,5 +87,4 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
-  deleteAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };

package/src/interfaces/prover-client.ts

@@ -3,7 +3,7 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { EpochProver } from './epoch-prover.js';
 import type { ProvingJobConsumer } from './prover-broker.js';
@@ -17,6 +17,12 @@ export type ActualProverConfig = {
   proverTestDelayMs: number;
   /** If using realistic delays, what percentage of realistic times to apply. */
   proverTestDelayFactor: number;
+  /**
+   * Whether to abort pending proving jobs when the orchestrator is cancelled.
+   * When false (default), jobs remain in the broker queue and can be reused on restart/reorg.
+   * When true, jobs are explicitly cancelled with the broker, which prevents reuse.
+   */
+  cancelJobsOnStop: boolean;
 };
 
 /**
@@ -33,15 +39,19 @@ export type ProverConfig = ActualProverConfig & {
   failedProofStore?: string;
 };
 
-export const ProverConfigSchema = z.object({
-  nodeUrl: z.string().optional(),
-  realProofs: z.boolean(),
-  proverId: schemas.EthAddress.optional(),
-  proverTestDelayType: z.enum(['fixed', 'realistic']),
-  proverTestDelayMs: z.number(),
-  proverTestDelayFactor: z.number(),
-  proverAgentCount: z.number(),
-}) satisfies ZodFor<ProverConfig>;
+export const ProverConfigSchema = zodFor<ProverConfig>()(
+  z.object({
+    nodeUrl: z.string().optional(),
+    realProofs: z.boolean(),
+    proverId: schemas.EthAddress.optional(),
+    proverTestDelayType: z.enum(['fixed', 'realistic']),
+    proverTestDelayMs: z.number(),
+    proverTestDelayFactor: z.number(),
+    proverAgentCount: z.number(),
+    failedProofStore: z.string().optional(),
+    cancelJobsOnStop: z.boolean(),
+  }),
+);
 
 export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   nodeUrl: {
@@ -82,6 +92,14 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
     description:
       'Store for failed proof inputs. Google cloud storage is only supported at the moment. Set this value as gs://bucket-name/path/to/store.',
   },
+  cancelJobsOnStop: {
+    env: 'PROVER_CANCEL_JOBS_ON_STOP',
+    description:
+      'Whether to abort pending proving jobs when the orchestrator is cancelled. ' +
+      'When false (default), jobs remain in the broker queue and can be reused on restart/reorg. ' +
+      'When true, jobs are explicitly cancelled with the broker, which prevents reuse.',
+    ...booleanConfigHelper(false),
+  },
 };
 
 function parseProverId(str?: string) {

package/src/interfaces/proving-job.ts

@@ -47,15 +47,6 @@ export type ProofAndVerificationKey<N extends number> = {
   verificationKey: VerificationKeyData;
 };
 
-function schemaForRecursiveProofAndVerificationKey<N extends number>(
-  proofLength: N,
-): ZodFor<ProofAndVerificationKey<N>> {
-  return z.object({
-    proof: RecursiveProof.schemaFor(proofLength),
-    verificationKey: VerificationKeyData.schema,
-  });
-}
-
 export function makeProofAndVerificationKey<N extends number>(
   proof: RecursiveProof<N>,
   verificationKey: VerificationKeyData,
@@ -213,7 +204,7 @@ export type ProvingJobInputsMap = {
 export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_VM),
-    result: schemaForRecursiveProofAndVerificationKey(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
   }),
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
@@ -328,7 +319,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
-  [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
   [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
     PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH

package/src/interfaces/public_state_source.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 

package/src/interfaces/server_circuit_prover.ts

@@ -9,6 +9,7 @@ import type { AvmCircuitInputs } from '../avm/avm.js';
 import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
 import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
+import type { RecursiveProof } from '../proofs/recursive_proof.js';
 import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
 import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import type {
@@ -34,7 +35,7 @@ import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs
 import type { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
 import type { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import type { Tx } from '../tx/tx.js';
-import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from './proving-job.js';
+import type { PublicInputsAndRecursiveProof } from './proving-job.js';
 
 /**
  * Generates proofs for parity and rollup circuits.
@@ -186,10 +187,9 @@ export interface ServerCircuitProver {
    */
   getAvmProof(
     inputs: AvmCircuitInputs,
-    skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: Remove.
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
 }
 
 export type IVCProofVerificationResult = {

package/src/interfaces/slasher.ts

@@ -1,5 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -27,24 +27,26 @@ export interface SlasherConfig {
   slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
-export const SlasherConfigSchema = z.object({
-  slashOverridePayload: schemas.EthAddress.optional(),
-  slashMinPenaltyPercentage: z.number(),
-  slashMaxPenaltyPercentage: z.number(),
-  slashValidatorsAlways: z.array(schemas.EthAddress),
-  slashValidatorsNever: z.array(schemas.EthAddress),
-  slashPrunePenalty: schemas.BigInt,
-  slashDataWithholdingPenalty: schemas.BigInt,
-  slashInactivityTargetPercentage: z.number(),
-  slashInactivityConsecutiveEpochThreshold: z.number(),
-  slashInactivityPenalty: schemas.BigInt,
-  slashProposeInvalidAttestationsPenalty: schemas.BigInt,
-  slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
-  slashUnknownPenalty: schemas.BigInt,
-  slashOffenseExpirationRounds: z.number(),
-  slashMaxPayloadSize: z.number(),
-  slashGracePeriodL2Slots: z.number(),
-  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
-  slashExecuteRoundsLookBack: z.number(),
-  slashSelfAllowed: z.boolean().optional(),
-}) satisfies ZodFor<SlasherConfig>;
+export const SlasherConfigSchema = zodFor<SlasherConfig>()(
+  z.object({
+    slashOverridePayload: schemas.EthAddress.optional(),
+    slashMinPenaltyPercentage: z.number(),
+    slashMaxPenaltyPercentage: z.number(),
+    slashValidatorsAlways: z.array(schemas.EthAddress),
+    slashValidatorsNever: z.array(schemas.EthAddress),
+    slashPrunePenalty: schemas.BigInt,
+    slashDataWithholdingPenalty: schemas.BigInt,
+    slashInactivityTargetPercentage: z.number(),
+    slashInactivityConsecutiveEpochThreshold: z.number(),
+    slashInactivityPenalty: schemas.BigInt,
+    slashProposeInvalidAttestationsPenalty: schemas.BigInt,
+    slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
+    slashUnknownPenalty: schemas.BigInt,
+    slashOffenseExpirationRounds: z.number(),
+    slashMaxPayloadSize: z.number(),
+    slashGracePeriodL2Slots: z.number(),
+    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashExecuteRoundsLookBack: z.number(),
+    slashSelfAllowed: z.boolean().optional(),
+  }),
+);

package/src/interfaces/tx_provider.ts

@@ -1,4 +1,4 @@
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -13,5 +13,5 @@ export interface ITxProvider {
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 
-  getTxsForBlock(block: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 }