@aztec/stdlib 3.0.0-nightly.20250918 → 3.0.0-nightly.20250919

package/src/interfaces/proving-job.ts

@@ -11,13 +11,12 @@ import { z } from 'zod';
 import { AvmCircuitInputs } from '../avm/avm.js';
 import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
 import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
-import { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import { RootParityInputs } from '../parity/root_parity_inputs.js';
+import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
-import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup.js';
+import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
 import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import {
   BlockRootEmptyTxFirstRollupPrivateInputs,
@@ -25,20 +24,21 @@ import {
   BlockRootRollupPrivateInputs,
   BlockRootSingleTxFirstRollupPrivateInputs,
   BlockRootSingleTxRollupPrivateInputs,
-} from '../rollup/block_root_rollup.js';
-import { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup.js';
+} from '../rollup/block_root_rollup_private_inputs.js';
+import { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
 import { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
 import {
   CheckpointPaddingRollupPrivateInputs,
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
-} from '../rollup/checkpoint_root_rollup.js';
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
 import { PublicTubePrivateInputs } from '../rollup/index.js';
-import { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import { RootRollupPrivateInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import type { ServerCircuitName } from '../stats/index.js';
+import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import { VerificationKeyData } from '../vks/verification_key.js';
 
 export type ProofAndVerificationKey<N extends number> = {
@@ -87,59 +87,20 @@ export function makePublicInputsAndRecursiveProof<T, N extends number = typeof N
   return { inputs, proof, verificationKey };
 }
 
-export function mapProvingRequestTypeToCircuitName(type: ProvingRequestType): ServerCircuitName {
-  switch (type) {
-    case ProvingRequestType.PUBLIC_VM:
-      return 'avm-circuit';
-    case ProvingRequestType.PUBLIC_TUBE:
-      return 'public-tube';
-    case ProvingRequestType.PRIVATE_BASE_ROLLUP:
-      return 'private-base-rollup';
-    case ProvingRequestType.PUBLIC_BASE_ROLLUP:
-      return 'public-base-rollup';
-    case ProvingRequestType.MERGE_ROLLUP:
-      return 'merge-rollup';
-    case ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP:
-      return 'block-root-first-rollup';
-    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP:
-      return 'block-root-single-tx-first-rollup';
-    case ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP:
-      return 'block-root-empty-tx-first-rollup';
-    case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-      return 'block-root-rollup';
-    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP:
-      return 'block-root-single-tx-rollup';
-    case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-      return 'block-merge-rollup';
-    case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP:
-      return 'checkpoint-root-rollup';
-    case ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP:
-      return 'checkpoint-root-single-block-rollup';
-    case ProvingRequestType.CHECKPOINT_PADDING_ROLLUP:
-      return 'checkpoint-padding-rollup';
-    case ProvingRequestType.CHECKPOINT_MERGE_ROLLUP:
-      return 'checkpoint-merge-rollup';
-    case ProvingRequestType.ROOT_ROLLUP:
-      return 'root-rollup';
-    case ProvingRequestType.BASE_PARITY:
-      return 'base-parity';
-    case ProvingRequestType.ROOT_PARITY:
-      return 'root-parity';
-    default: {
-      const _exhaustive: never = type;
-      throw new Error(`Cannot find circuit name for proving request type: ${type}`);
-    }
-  }
-}
-
 export const ProvingJobInputs = z.discriminatedUnion('type', [
   AvmProvingRequestSchema,
-  z.object({ type: z.literal(ProvingRequestType.BASE_PARITY), inputs: BaseParityInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.ROOT_PARITY), inputs: RootParityInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.PARITY_BASE), inputs: ParityBasePrivateInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.PARITY_ROOT), inputs: ParityRootPrivateInputs.schema }),
   z.object({ type: z.literal(ProvingRequestType.PUBLIC_TUBE), inputs: PublicTubePrivateInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP), inputs: PrivateBaseRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP), inputs: PublicBaseRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.MERGE_ROLLUP), inputs: MergeRollupInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+    inputs: PrivateTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+    inputs: PublicTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP), inputs: TxMergeRollupPrivateInputs.schema }),
   z.object({
     type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
     inputs: BlockRootFirstRollupPrivateInputs.schema,
@@ -183,12 +144,12 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
       return AvmCircuitInputs;
     case ProvingRequestType.PUBLIC_TUBE:
       return PublicTubePrivateInputs;
-    case ProvingRequestType.PRIVATE_BASE_ROLLUP:
-      return PrivateBaseRollupInputs;
-    case ProvingRequestType.PUBLIC_BASE_ROLLUP:
-      return PublicBaseRollupInputs;
-    case ProvingRequestType.MERGE_ROLLUP:
-      return MergeRollupInputs;
+    case ProvingRequestType.PRIVATE_TX_BASE_ROLLUP:
+      return PrivateTxBaseRollupPrivateInputs;
+    case ProvingRequestType.PUBLIC_TX_BASE_ROLLUP:
+      return PublicTxBaseRollupPrivateInputs;
+    case ProvingRequestType.TX_MERGE_ROLLUP:
+      return TxMergeRollupPrivateInputs;
     case ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP:
       return BlockRootFirstRollupPrivateInputs;
     case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP:
@@ -211,10 +172,10 @@ export function getProvingJobInputClassFor(type: ProvingRequestType) {
       return CheckpointMergeRollupPrivateInputs;
     case ProvingRequestType.ROOT_ROLLUP:
       return RootRollupPrivateInputs;
-    case ProvingRequestType.BASE_PARITY:
-      return BaseParityInputs;
-    case ProvingRequestType.ROOT_PARITY:
-      return RootParityInputs;
+    case ProvingRequestType.PARITY_BASE:
+      return ParityBasePrivateInputs;
+    case ProvingRequestType.PARITY_ROOT:
+      return ParityRootPrivateInputs;
     default: {
       const _exhaustive: never = type;
       throw new Error(`Cannot find circuit inputs class for proving type ${type}`);
@@ -227,9 +188,9 @@ export type ProvingJobInputs = z.infer<typeof ProvingJobInputs>;
 export type ProvingJobInputsMap = {
   [ProvingRequestType.PUBLIC_VM]: AvmCircuitInputs;
   [ProvingRequestType.PUBLIC_TUBE]: PublicTubePrivateInputs;
-  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PrivateBaseRollupInputs;
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicBaseRollupInputs;
-  [ProvingRequestType.MERGE_ROLLUP]: MergeRollupInputs;
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PrivateTxBaseRollupPrivateInputs;
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicTxBaseRollupPrivateInputs;
+  [ProvingRequestType.TX_MERGE_ROLLUP]: TxMergeRollupPrivateInputs;
   [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: BlockRootFirstRollupPrivateInputs;
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: BlockRootSingleTxFirstRollupPrivateInputs;
   [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: BlockRootEmptyTxFirstRollupPrivateInputs;
@@ -241,8 +202,8 @@ export type ProvingJobInputsMap = {
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: CheckpointPaddingRollupPrivateInputs;
   [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: CheckpointMergeRollupPrivateInputs;
   [ProvingRequestType.ROOT_ROLLUP]: RootRollupPrivateInputs;
-  [ProvingRequestType.BASE_PARITY]: BaseParityInputs;
-  [ProvingRequestType.ROOT_PARITY]: RootParityInputs;
+  [ProvingRequestType.PARITY_BASE]: ParityBasePrivateInputs;
+  [ProvingRequestType.PARITY_ROOT]: ParityRootPrivateInputs;
 };
 
 export const ProvingJobResult = z.discriminatedUnion('type', [
@@ -258,23 +219,23 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.MERGE_ROLLUP),
+    type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
@@ -353,11 +314,11 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     result: schemaForPublicInputsAndRecursiveProof(RootRollupPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.BASE_PARITY),
+    type: z.literal(ProvingRequestType.PARITY_BASE),
     result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, RECURSIVE_PROOF_LENGTH),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.ROOT_PARITY),
+    type: z.literal(ProvingRequestType.PARITY_ROOT),
     result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
   }),
 ]);
@@ -368,16 +329,16 @@ export type ProvingJobResultsMap = {
     PrivateToPublicKernelCircuitPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
@@ -421,8 +382,8 @@ export type ProvingJobResultsMap = {
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof<RootRollupPublicInputs>;
-  [ProvingRequestType.BASE_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
-  [ProvingRequestType.ROOT_PARITY]: PublicInputsAndRecursiveProof<
+  [ProvingRequestType.PARITY_BASE]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
+  [ProvingRequestType.PARITY_ROOT]: PublicInputsAndRecursiveProof<
     ParityPublicInputs,
     typeof NESTED_RECURSIVE_PROOF_LENGTH
   >;

package/src/interfaces/pxe.ts

@@ -1,7 +1,5 @@
-import { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import type { ApiSchemaFor, ZodFor } from '@aztec/foundation/schemas';
-import { SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
 
@@ -9,7 +7,6 @@ import { type AbiType, AbiTypeSchema, type ContractArtifact, ContractArtifactSch
 import type { EventSelector } from '../abi/event_selector.js';
 import { AuthWitness } from '../auth_witness/auth_witness.js';
 import type { AztecAddress } from '../aztec-address/index.js';
-import { L2Block } from '../block/l2_block.js';
 import {
   CompleteAddress,
   type ContractClassWithId,
@@ -23,12 +20,10 @@ import {
   ProtocolContractAddressesSchema,
 } from '../contract/index.js';
 import { GasFees } from '../gas/gas_fees.js';
-import { type LogFilter, LogFilterSchema } from '../logs/log_filter.js';
 import { UniqueNote } from '../note/extended_note.js';
 import { type NotesFilter, NotesFilterSchema } from '../note/notes_filter.js';
 import { AbiDecodedSchema, optional, schemas } from '../schemas/schemas.js';
 import {
-  type IndexedTxEffect,
   PrivateExecutionResult,
   SimulationOverrides,
   Tx,
@@ -36,16 +31,9 @@ import {
   TxHash,
   TxReceipt,
   TxSimulationResult,
-  indexedTxSchema,
 } from '../tx/index.js';
 import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
-import {
-  type GetContractClassLogsResponse,
-  GetContractClassLogsResponseSchema,
-  type GetPublicLogsResponse,
-  GetPublicLogsResponseSchema,
-} from './get_logs_response.js';
 
 // docs:start:pxe-interface
 /**
@@ -55,21 +43,6 @@ import {
  * is exposed to dapps for interacting with the network on behalf of the user.
  */
 export interface PXE {
-  /**
-   * 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 and ready to be included in a block.
-   * @deprecated Use `waitForL1ToL2MessageReady` and `isL1ToL2MessageReady` instead.
-   */
-  isL1ToL2MessageSynced(l1ToL2Message: Fr): Promise<boolean>;
-
-  /**
-   * Returns the L2 block number in which this L1 to L2 message becomes available, or undefined if not found.
-   * @param l1ToL2Message - The L1 to L2 message to check.
-   * @returns The L2 block number or undefined if not synced yet.
-   */
-  getL1ToL2MessageBlock(l1ToL2Message: Fr): Promise<number | undefined>;
-
   /**
    * Registers a user account in PXE given its master encryption private key.
    * Once a new account is registered, the PXE Service will trial-decrypt all published notes on
@@ -220,26 +193,6 @@ export interface PXE {
    */
   getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
 
-  /**
-   * 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<IndexedTxEffect | undefined>;
-
-  /**
-   * Gets the storage value at the given contract storage slot.
-   *
-   * @remarks The storage slot here refers to the slot as it is defined in Noir not the index in the merkle tree.
-   * Aztec's version of `eth_getStorageAt`.
-   *
-   * @param contract - Address of the contract to query.
-   * @param slot - Slot to query.
-   * @returns Storage value at the given contract slot.
-   * @throws If the contract is not deployed.
-   */
-  getPublicStorageAt(contract: AztecAddress, slot: Fr): Promise<Fr>;
-
   /**
    * Gets notes registered in this PXE based on the provided filter.
    * @param filter - The filter to apply to the notes.
@@ -247,35 +200,6 @@ export interface PXE {
    */
   getNotes(filter: NotesFilter): Promise<UniqueNote[]>;
 
-  /**
-   * Fetches an L1 to L2 message from the node.
-   * @param contractAddress - Address of a contract by which the message was emitted.
-   * @param messageHash - Hash of the message.
-   * @param secret - Secret used to compute a nullifier.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */
-  getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]>;
-
-  /**
-   * Gets the membership witness for a message that was emitted at a particular block
-   * @param blockNumber - The block number in which to search for the message
-   * @param l2Tol1Message - The message to search for
-   * @returns The membership witness for the message
-   */
-  getL2ToL1MembershipWitness(blockNumber: number, l2Tol1Message: Fr): Promise<[bigint, SiblingPath<number>]>;
-
-  /**
-   * Get the given block.
-   * @param number - The block number being requested.
-   * @returns The blocks requested.
-   */
-  getBlock(number: number): Promise<L2Block | undefined>;
-
   /**
    * Method to fetch the current base fees.
    * @returns The current base fees.
@@ -303,32 +227,6 @@ export interface PXE {
     scopes?: AztecAddress[],
   ): Promise<UtilitySimulationResult>;
 
-  /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse>;
-
-  /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */
-  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse>;
-
-  /**
-   * Fetches the current block number.
-   * @returns The block number.
-   */
-  getBlockNumber(): Promise<number>;
-
-  /**
-   * Fetches the current proven block number.
-   * @returns The block number.
-   */
-  getProvenBlockNumber(): Promise<number>;
-
   /**
    * Returns the information about the server's node. Includes current Node version, compatible Noir version,
    * L1 chain identifier, rollup version, and L1 address of the rollup contract.
@@ -386,15 +284,6 @@ export interface PXE {
     numBlocks: number,
     recipients: AztecAddress[],
   ): Promise<T[]>;
-
-  /**
-   * Returns the public events given search parameters.
-   * @param eventMetadata - Metadata of the event. This should be the class generated from the contract. e.g. Contract.events.Event
-   * @param from - The block number to search from.
-   * @param limit - The amount of blocks to search.
-   * @returns - The deserialized events.
-   */
-  getPublicEvents<T>(eventMetadata: EventMetadataDefinition, from: number, limit: number): Promise<T[]>;
 }
 // docs:end:pxe-interface
 
@@ -404,7 +293,7 @@ export type EventMetadataDefinition = {
   fieldNames: string[];
 };
 
-const EventMetadataDefinitionSchema = z.object({
+export const EventMetadataDefinitionSchema = z.object({
   eventSelector: schemas.EventSelector,
   abiType: AbiTypeSchema,
   fieldNames: z.array(z.string()),
@@ -436,13 +325,13 @@ export interface ContractClassMetadata {
   artifact?: ContractArtifact | undefined;
 }
 
-const ContractMetadataSchema = z.object({
+export const ContractMetadataSchema = z.object({
   contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
   isContractInitialized: z.boolean(),
   isContractPublished: z.boolean(),
 }) satisfies ZodFor<ContractMetadata>;
 
-const ContractClassMetadataSchema = z.object({
+export const ContractClassMetadataSchema = z.object({
   contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
   isContractClassPubliclyRegistered: z.boolean(),
   artifact: z.union([ContractArtifactSchema, z.undefined()]),
@@ -454,8 +343,6 @@ const PXEInfoSchema = z.object({
 }) satisfies ZodFor<PXEInfo>;
 
 export const PXESchema: ApiSchemaFor<PXE> = {
-  isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
-  getL1ToL2MessageBlock: z.function().args(schemas.Fr).returns(z.number().optional()),
   registerAccount: z.function().args(schemas.Fr, schemas.Fr).returns(CompleteAddress.schema),
   getRegisteredAccounts: z.function().returns(z.array(CompleteAddress.schema)),
   registerSender: z.function().args(schemas.AztecAddress).returns(schemas.AztecAddress),
@@ -494,21 +381,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
     .returns(TxSimulationResult.schema),
   sendTx: z.function().args(Tx.schema).returns(TxHash.schema),
   getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
-  getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
-  getPublicStorageAt: z.function().args(schemas.AztecAddress, schemas.Fr).returns(schemas.Fr),
   getNotes: z.function().args(NotesFilterSchema).returns(z.array(UniqueNote.schema)),
-  getL1ToL2MembershipWitness: z
-    .function()
-    .args(schemas.AztecAddress, schemas.Fr, schemas.Fr)
-    .returns(z.tuple([schemas.BigInt, SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)])),
-  getL2ToL1MembershipWitness: z
-    .function()
-    .args(z.number(), schemas.Fr)
-    .returns(z.tuple([schemas.BigInt, SiblingPath.schema])),
-  getBlock: z
-    .function()
-    .args(z.number())
-    .returns(z.union([L2Block.schema, z.undefined()])),
   getCurrentBaseFees: z.function().returns(GasFees.schema),
 
   simulateUtility: z
@@ -522,10 +395,6 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(z.array(schemas.AztecAddress)),
     )
     .returns(UtilitySimulationResult.schema),
-  getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
-  getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-  getBlockNumber: z.function().returns(z.number()),
-  getProvenBlockNumber: z.function().returns(z.number()),
   getNodeInfo: z.function().returns(NodeInfoSchema),
   getPXEInfo: z.function().returns(PXEInfoSchema),
   getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
@@ -534,8 +403,4 @@ export const PXESchema: ApiSchemaFor<PXE> = {
     .function()
     .args(schemas.AztecAddress, EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.AztecAddress))
     .returns(z.array(AbiDecodedSchema)),
-  getPublicEvents: z
-    .function()
-    .args(EventMetadataDefinitionSchema, z.number(), z.number())
-    .returns(z.array(AbiDecodedSchema)),
 };

package/src/interfaces/server_circuit_prover.ts

@@ -7,11 +7,10 @@ import type {
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
 import type { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
-import type { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import type { RootParityInputs } from '../parity/root_parity_inputs.js';
-import type { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
-import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup.js';
+import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
+import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
 import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import type {
   BlockRootEmptyTxFirstRollupPrivateInputs,
@@ -19,19 +18,21 @@ import type {
   BlockRootRollupPrivateInputs,
   BlockRootSingleTxFirstRollupPrivateInputs,
   BlockRootSingleTxRollupPrivateInputs,
-} from '../rollup/block_root_rollup.js';
-import type { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup.js';
+} from '../rollup/block_root_rollup_private_inputs.js';
+import type { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
 import type { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
 import type {
   CheckpointPaddingRollupPrivateInputs,
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
-} from '../rollup/checkpoint_root_rollup.js';
-import type { PublicTubePrivateInputs } from '../rollup/index.js';
-import type { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import type { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import type { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import type { RootRollupPrivateInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
+import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import type { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+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';
 
@@ -44,7 +45,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
@@ -54,7 +55,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getRootParityProof(
-    inputs: RootParityInputs,
+    inputs: ParityRootPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
@@ -74,33 +75,27 @@ export interface ServerCircuitProver {
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getPrivateBaseRollupProof(
-    baseRollupInput: PrivateBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
-  getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
+  getPublicTxBaseRollupProof(
+    inputs: PublicTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getMergeRollupProof(
-    input: MergeRollupInputs,
+  getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.

package/src/parity/index.ts

@@ -1,4 +1,3 @@
-export * from './base_parity_inputs.js';
+export * from './parity_base_private_inputs.js';
 export * from './parity_public_inputs.js';
-export * from './root_parity_input.js';
-export * from './root_parity_inputs.js';
+export * from './parity_root_private_inputs.js';

package/src/parity/{base_parity_inputs.ts → parity_base_private_inputs.ts}

@@ -4,7 +4,7 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-export class BaseParityInputs {
+export class ParityBasePrivateInputs {
   constructor(
     /** Aggregated proof of all the parity circuit iterations. */
     public readonly msgs: Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>,
@@ -16,11 +16,11 @@ export class BaseParityInputs {
     array: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
     index: number,
     vkTreeRoot: Fr,
-  ): BaseParityInputs {
+  ): ParityBasePrivateInputs {
     const start = index * NUM_MSGS_PER_BASE_PARITY;
     const end = start + NUM_MSGS_PER_BASE_PARITY;
     const msgs = array.slice(start, end);
-    return new BaseParityInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
+    return new ParityBasePrivateInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
   }
 
   /** Serializes the inputs to a buffer. */
@@ -39,7 +39,7 @@ export class BaseParityInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BaseParityInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+    return new ParityBasePrivateInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
   }
 
   /**
@@ -48,7 +48,7 @@ export class BaseParityInputs {
    * @returns - The deserialized inputs.
    */
   static fromString(str: string) {
-    return BaseParityInputs.fromBuffer(hexToBuffer(str));
+    return ParityBasePrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -58,6 +58,6 @@ export class BaseParityInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseParityInputs);
+    return bufferSchemaFor(ParityBasePrivateInputs);
   }
 }