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

package/dest/interfaces/proving-job.js

@@ -3,21 +3,24 @@ 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 { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
-import { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
-import { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
-import { PaddingBlockRootRollupInputs, 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 { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
+import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
+import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs } 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_private_inputs.js';
+import { PublicTubePrivateInputs } from '../rollup/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';
 function schemaForRecursiveProofAndVerificationKey(proofLength) {
     return z.object({
@@ -45,90 +48,75 @@ export function makePublicInputsAndRecursiveProof(inputs, proof, verificationKey
         verificationKey
     };
 }
-export function mapProvingRequestTypeToCircuitName(type) {
-    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.EMPTY_BLOCK_ROOT_ROLLUP:
-            return 'empty-block-root-rollup';
-        case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
-            return 'padding-block-root-rollup';
-        case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-            return 'block-root-rollup';
-        case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
-            return 'single-tx-block-root-rollup';
-        case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-            return 'block-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 = 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
+        type: z.literal(ProvingRequestType.PARITY_BASE),
+        inputs: ParityBasePrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.ROOT_PARITY),
-        inputs: RootParityInputs.schema
+        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
+        type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+        inputs: PrivateTxBaseRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
-        inputs: PublicBaseRollupInputs.schema
+        type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+        inputs: PublicTxBaseRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.MERGE_ROLLUP),
-        inputs: MergeRollupInputs.schema
+        type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP),
+        inputs: TxMergeRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
-        inputs: BlockRootRollupInputs.schema
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
+        inputs: BlockRootFirstRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
-        inputs: SingleTxBlockRootRollupInputs.schema
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
+        inputs: BlockRootSingleTxFirstRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP),
-        inputs: EmptyBlockRootRollupInputs.schema
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+        inputs: BlockRootEmptyTxFirstRollupPrivateInputs.schema
     }),
     z.object({
-        type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
-        inputs: PaddingBlockRootRollupInputs.schema
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
+        inputs: BlockRootRollupPrivateInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+        inputs: BlockRootSingleTxRollupPrivateInputs.schema
     }),
     z.object({
         type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
-        inputs: BlockMergeRollupInputs.schema
+        inputs: BlockMergeRollupPrivateInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+        inputs: CheckpointRootRollupPrivateInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+        inputs: CheckpointRootSingleBlockRollupPrivateInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+        inputs: CheckpointPaddingRollupPrivateInputs.schema
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+        inputs: CheckpointMergeRollupPrivateInputs.schema
     }),
     z.object({
         type: z.literal(ProvingRequestType.ROOT_ROLLUP),
-        inputs: RootRollupInputs.schema
+        inputs: RootRollupPrivateInputs.schema
     })
 ]);
 export function getProvingJobInputClassFor(type) {
@@ -137,28 +125,38 @@ export function getProvingJobInputClassFor(type) {
             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.EMPTY_BLOCK_ROOT_ROLLUP:
-            return EmptyBlockRootRollupInputs;
-        case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
-            return PaddingBlockRootRollupInputs;
+        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:
+            return BlockRootSingleTxFirstRollupPrivateInputs;
+        case ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP:
+            return BlockRootEmptyTxFirstRollupPrivateInputs;
         case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-            return BlockRootRollupInputs;
-        case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
-            return SingleTxBlockRootRollupInputs;
+            return BlockRootRollupPrivateInputs;
+        case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP:
+            return BlockRootSingleTxRollupPrivateInputs;
         case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-            return BlockMergeRollupInputs;
+            return BlockMergeRollupPrivateInputs;
+        case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP:
+            return CheckpointRootRollupPrivateInputs;
+        case ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP:
+            return CheckpointRootSingleBlockRollupPrivateInputs;
+        case ProvingRequestType.CHECKPOINT_PADDING_ROLLUP:
+            return CheckpointPaddingRollupPrivateInputs;
+        case ProvingRequestType.CHECKPOINT_MERGE_ROLLUP:
+            return CheckpointMergeRollupPrivateInputs;
         case ProvingRequestType.ROOT_ROLLUP:
-            return RootRollupInputs;
-        case ProvingRequestType.BASE_PARITY:
-            return BaseParityInputs;
-        case ProvingRequestType.ROOT_PARITY:
-            return RootParityInputs;
+            return RootRollupPrivateInputs;
+        case ProvingRequestType.PARITY_BASE:
+            return ParityBasePrivateInputs;
+        case ProvingRequestType.PARITY_ROOT:
+            return ParityRootPrivateInputs;
         default:
             {
                 const _exhaustive = type;
@@ -176,47 +174,67 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
         result: schemaForPublicInputsAndRecursiveProof(PrivateToPublicKernelCircuitPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(TxRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(TxRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(TxRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.MERGE_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BaseOrMergeRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
         type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
-        type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
         type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
-        result: schemaForPublicInputsAndRecursiveProof(BlockRootOrBlockMergePublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+        result: schemaForPublicInputsAndRecursiveProof(BlockRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(CheckpointRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(CheckpointRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(CheckpointRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
+    }),
+    z.object({
+        type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+        result: schemaForPublicInputsAndRecursiveProof(CheckpointRollupPublicInputs.schema, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH)
     }),
     z.object({
         type: z.literal(ProvingRequestType.ROOT_ROLLUP),
         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)
     })
 ]);

package/dest/interfaces/pxe.d.ts

@@ -1,21 +1,17 @@
-import { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
-import type { ApiSchemaFor } from '@aztec/foundation/schemas';
-import { SiblingPath } from '@aztec/foundation/trees';
+import type { ApiSchemaFor, ZodFor } from '@aztec/foundation/schemas';
+import { z } from 'zod';
 import { type AbiType, type ContractArtifact } from '../abi/abi.js';
 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, type ContractInstanceWithAddress, type NodeInfo, type PartialAddress, type ProtocolContractAddresses } from '../contract/index.js';
 import { GasFees } from '../gas/gas_fees.js';
-import { type LogFilter } from '../logs/log_filter.js';
 import { UniqueNote } from '../note/extended_note.js';
 import { type NotesFilter } from '../note/notes_filter.js';
-import { type IndexedTxEffect, PrivateExecutionResult, SimulationOverrides, Tx, TxExecutionRequest, TxHash, TxReceipt, TxSimulationResult } from '../tx/index.js';
+import { PrivateExecutionResult, SimulationOverrides, Tx, TxExecutionRequest, TxHash, TxReceipt, TxSimulationResult } from '../tx/index.js';
 import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
-import { type GetContractClassLogsResponse, type GetPublicLogsResponse } from './get_logs_response.js';
 /**
  * Private eXecution Environment (PXE) runs locally for each user, providing functionality for all the operations
  * needed to interact with the Aztec network, including account management, private data management,
@@ -23,19 +19,6 @@ import { type GetContractClassLogsResponse, type GetPublicLogsResponse } from '.
  * 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
@@ -163,52 +146,12 @@ export interface PXE {
      * @returns A receipt of the transaction.
      */
     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.
      * @returns The requested notes.
      */
     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.
@@ -227,28 +170,6 @@ export interface PXE {
      * @returns The result of the utility function call, structured based on the function ABI.
      */
     simulateUtility(functionName: string, args: any[], to: AztecAddress, authwits?: AuthWitness[], from?: AztecAddress, 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.
@@ -296,20 +217,25 @@ export interface PXE {
      * @returns - The deserialized events.
      */
     getPrivateEvents<T>(contractAddress: AztecAddress, eventMetadata: EventMetadataDefinition, from: number, 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[]>;
 }
 export type EventMetadataDefinition = {
     eventSelector: EventSelector;
     abiType: AbiType;
     fieldNames: string[];
 };
+export declare const EventMetadataDefinitionSchema: z.ZodObject<{
+    eventSelector: z.ZodType<EventSelector, any, string>;
+    abiType: z.ZodType<AbiType, z.ZodTypeDef, AbiType>;
+    fieldNames: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    eventSelector: EventSelector;
+    abiType: AbiType;
+    fieldNames: string[];
+}, {
+    eventSelector: string;
+    abiType: AbiType;
+    fieldNames: string[];
+}>;
 /** This is used in getting events via the filter */
 export declare enum EventType {
     Encrypted = "Encrypted",
@@ -332,5 +258,181 @@ export interface ContractClassMetadata {
     isContractClassPubliclyRegistered: boolean;
     artifact?: ContractArtifact | undefined;
 }
+export declare const ContractMetadataSchema: z.ZodObject<{
+    contractInstance: z.ZodUnion<[z.ZodIntersection<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        salt: ZodFor<Fr>;
+        deployer: ZodFor<AztecAddress>;
+        currentContractClassId: ZodFor<Fr>;
+        originalContractClassId: ZodFor<Fr>;
+        initializationHash: ZodFor<Fr>;
+        publicKeys: z.ZodEffects<z.ZodObject<{
+            masterNullifierPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+            masterIncomingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+            masterOutgoingViewingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+            masterTaggingPublicKey: z.ZodType<import("@aztec/foundation/fields").Point, any, string>;
+        }, "strip", z.ZodTypeAny, {
+            masterNullifierPublicKey: import("@aztec/foundation/fields").Point;
+            masterIncomingViewingPublicKey: import("@aztec/foundation/fields").Point;
+            masterOutgoingViewingPublicKey: import("@aztec/foundation/fields").Point;
+            masterTaggingPublicKey: import("@aztec/foundation/fields").Point;
+        }, {
+            masterNullifierPublicKey: string;
+            masterIncomingViewingPublicKey: string;
+            masterOutgoingViewingPublicKey: string;
+            masterTaggingPublicKey: string;
+        }>, import("../keys/public_keys.js").PublicKeys, {
+            masterNullifierPublicKey: string;
+            masterIncomingViewingPublicKey: string;
+            masterOutgoingViewingPublicKey: string;
+            masterTaggingPublicKey: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        version: 1;
+        salt: Fr;
+        publicKeys: import("../keys/public_keys.js").PublicKeys;
+        deployer: AztecAddress;
+        currentContractClassId: Fr;
+        originalContractClassId: Fr;
+        initializationHash: Fr;
+    }, {
+        version: 1;
+        publicKeys: {
+            masterNullifierPublicKey: string;
+            masterIncomingViewingPublicKey: string;
+            masterOutgoingViewingPublicKey: string;
+            masterTaggingPublicKey: string;
+        };
+        salt?: any;
+        deployer?: any;
+        currentContractClassId?: any;
+        originalContractClassId?: any;
+        initializationHash?: any;
+    }>, z.ZodObject<{
+        address: ZodFor<AztecAddress>;
+    }, "strip", z.ZodTypeAny, {
+        address: AztecAddress;
+    }, {
+        address?: any;
+    }>>, z.ZodUndefined]>;
+    isContractInitialized: z.ZodBoolean;
+    isContractPublished: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    isContractInitialized: boolean;
+    isContractPublished: boolean;
+    contractInstance?: ({
+        version: 1;
+        salt: Fr;
+        publicKeys: import("../keys/public_keys.js").PublicKeys;
+        deployer: AztecAddress;
+        currentContractClassId: Fr;
+        originalContractClassId: Fr;
+        initializationHash: Fr;
+    } & {
+        address: AztecAddress;
+    }) | undefined;
+}, {
+    isContractInitialized: boolean;
+    isContractPublished: boolean;
+    contractInstance?: ({
+        version: 1;
+        publicKeys: {
+            masterNullifierPublicKey: string;
+            masterIncomingViewingPublicKey: string;
+            masterOutgoingViewingPublicKey: string;
+            masterTaggingPublicKey: string;
+        };
+        salt?: any;
+        deployer?: any;
+        currentContractClassId?: any;
+        originalContractClassId?: any;
+        initializationHash?: any;
+    } & {
+        address?: any;
+    }) | undefined;
+}>;
+export declare const ContractClassMetadataSchema: z.ZodObject<{
+    contractClass: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+        version: z.ZodLiteral<1>;
+        artifactHash: z.ZodType<Fr, any, string>;
+        privateFunctions: z.ZodArray<z.ZodObject<{
+            selector: ZodFor<import("../abi/function_selector.js").FunctionSelector>;
+            vkHash: z.ZodType<Fr, any, string>;
+        }, "strip", z.ZodTypeAny, {
+            selector: import("../abi/function_selector.js").FunctionSelector;
+            vkHash: Fr;
+        }, {
+            vkHash: string;
+            selector?: any;
+        }>, "many">;
+        packedBytecode: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer<ArrayBuffer>, string>, z.ZodEffects<z.ZodObject<{
+            type: z.ZodLiteral<"Buffer">;
+            data: z.ZodArray<z.ZodNumber, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "Buffer";
+            data: number[];
+        }, {
+            type: "Buffer";
+            data: number[];
+        }>, Buffer<ArrayBuffer>, {
+            type: "Buffer";
+            data: number[];
+        }>]>;
+    }, {
+        id: z.ZodType<Fr, any, string>;
+    }>, "strip", z.ZodTypeAny, {
+        version: 1;
+        id: Fr;
+        artifactHash: Fr;
+        packedBytecode: Buffer<ArrayBuffer>;
+        privateFunctions: {
+            selector: import("../abi/function_selector.js").FunctionSelector;
+            vkHash: Fr;
+        }[];
+    }, {
+        version: 1;
+        id: string;
+        artifactHash: string;
+        packedBytecode: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        privateFunctions: {
+            vkHash: string;
+            selector?: any;
+        }[];
+    }>, z.ZodUndefined]>;
+    isContractClassPubliclyRegistered: z.ZodBoolean;
+    artifact: z.ZodUnion<[ZodFor<ContractArtifact>, z.ZodUndefined]>;
+}, "strip", z.ZodTypeAny, {
+    isContractClassPubliclyRegistered: boolean;
+    artifact?: ContractArtifact | undefined;
+    contractClass?: {
+        version: 1;
+        id: Fr;
+        artifactHash: Fr;
+        packedBytecode: Buffer<ArrayBuffer>;
+        privateFunctions: {
+            selector: import("../abi/function_selector.js").FunctionSelector;
+            vkHash: Fr;
+        }[];
+    } | undefined;
+}, {
+    isContractClassPubliclyRegistered: boolean;
+    artifact?: any;
+    contractClass?: {
+        version: 1;
+        id: string;
+        artifactHash: string;
+        packedBytecode: string | {
+            type: "Buffer";
+            data: number[];
+        };
+        privateFunctions: {
+            vkHash: string;
+            selector?: any;
+        }[];
+    } | undefined;
+}>;
 export declare const PXESchema: ApiSchemaFor<PXE>;
 //# sourceMappingURL=pxe.d.ts.map