@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/interfaces/configs.ts

@@ -1,18 +1,10 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 
 import { z } from 'zod';
 
-import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
-
-type AllowedInstance = { address: AztecAddress };
-type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
-type AllowedClass = { classId: Fr };
-type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
-
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
+import { type AllowedElement, AllowedElementSchema } from './allowed_element.js';
 
 /**
  * The sequencer configuration.
@@ -24,6 +16,8 @@ export interface SequencerConfig {
   maxTxsPerBlock?: number;
   /** The minimum number of txs to include in a block. */
   minTxsPerBlock?: number;
+  /** Whether to publish txs with the block proposals */
+  publishTxsWithProposals?: boolean;
   /** The maximum L2 block gas. */
   maxL2BlockGas?: number;
   /** The maximum DA block gas. */
@@ -37,7 +31,7 @@ export interface SequencerConfig {
   /** The path to the ACVM binary */
   acvmBinaryPath?: string;
   /** The list of functions calls allowed to run in setup */
-  allowedInSetup?: AllowedElement[];
+  txPublicSetupAllowList?: AllowedElement[];
   /** Max block size */
   maxBlockSizeInBytes?: number;
   /** Payload address to vote for */
@@ -46,28 +40,45 @@ export interface SequencerConfig {
   enforceTimeTable?: boolean;
   /** How many seconds into an L1 slot we can still send a tx and get it mined. */
   maxL1TxInclusionTimeIntoSlot?: number;
+  /** Used for testing to introduce a fake delay after processing each tx */
+  fakeProcessingDelayPerTxMs?: number;
+  /** How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way) */
+  attestationPropagationTime?: number;
+  /** How many seconds before invalidating a block as a committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsCommitteeMember?: number;
+  /** How many seconds before invalidating a block as a non-committee member (zero to never invalidate) */
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember?: number;
+  /** Skip collecting attestations (for testing only) */
+  skipCollectingAttestations?: boolean;
+  /** Do not invalidate the previous block if invalid when we are the proposer (for testing only) */
+  skipInvalidateBlockAsProposer?: boolean;
+  /** Broadcast invalid block proposals with corrupted state (for testing only) */
+  broadcastInvalidBlockProposal?: boolean;
+  /** Inject a fake attestation (for testing only) */
+  injectFakeAttestation?: boolean;
 }
 
-const AllowedElementSchema = z.union([
-  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-  z.object({ address: schemas.AztecAddress }),
-  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-  z.object({ classId: schemas.Fr }),
-]) satisfies ZodFor<AllowedElement>;
-
 export const SequencerConfigSchema = 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(),
-  allowedInSetup: z.array(AllowedElementSchema).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(),
 }) satisfies ZodFor<SequencerConfig>;

package/src/interfaces/epoch-prover.ts

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

package/src/interfaces/l2_logs_source.ts

@@ -20,10 +20,11 @@ export interface L2LogsSource {
   /**
    * 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.
    */
-  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
+  getLogsByTags(tags: Fr[], logsPerTag?: number): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets public logs based on the provided filter.

package/src/interfaces/merkle_tree_operations.ts

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

package/src/interfaces/p2p.ts

@@ -4,6 +4,8 @@ import { BlockAttestation } from '../p2p/block_attestation.js';
 import type { P2PClientType } from '../p2p/client_type.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { MAX_RPC_TXS_LEN } from './api_limit.js';
 
 export type PeerInfo =
   | { status: 'connected'; score: number; id: string }
@@ -26,9 +28,14 @@ const PeerInfoSchema = z.discriminatedUnion('status', [
 export interface P2PApiWithoutAttestations {
   /**
    * Returns all pending transactions in the transaction pool.
+   * @param limit - The number of items to returns
+   * @param after - The last known pending tx. Used for pagination
    * @returns An array of Txs.
    */
-  getPendingTxs(): Promise<Tx[]>;
+  getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]>;
+
+  /** Returns the number of pending txs in the p2p tx pool. */
+  getPendingTxCount(): Promise<number>;
 
   /**
    * Returns the ENR for this node, if any.
@@ -41,7 +48,7 @@ export interface P2PApiWithoutAttestations {
   getPeers(includePending?: boolean): Promise<PeerInfo[]>;
 }
 
-export interface P2PClient extends P2PApiWithoutAttestations {
+export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
   /**
    * Queries the Attestation pool for attestations for the given slot
    *
@@ -50,10 +57,22 @@ export interface P2PClient extends P2PApiWithoutAttestations {
    * @returns BlockAttestations
    */
   getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+
+  /** Deletes a given attestation manually from the p2p client attestation pool. */
+  deleteAttestation(attestation: BlockAttestation): Promise<void>;
+}
+
+export interface P2PClient extends P2PApiWithAttestations {
+  /** Manually adds an attestation to the p2p client attestation pool. */
+  addAttestations(attestations: BlockAttestation[]): Promise<void>;
 }
 
 export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
-  ? P2PClient & P2PApiWithoutAttestations
+  ? P2PApiWithAttestations
+  : P2PApiWithoutAttestations;
+
+export type P2PApiFull<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
+  ? P2PApiWithAttestations & P2PClient
   : P2PApiWithoutAttestations;
 
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
@@ -61,7 +80,13 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
     .function()
     .args(schemas.BigInt, optional(z.string()))
     .returns(z.array(BlockAttestation.schema)),
-  getPendingTxs: z.function().returns(z.array(Tx.schema)),
+  getPendingTxs: z
+    .function()
+    .args(optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)), optional(TxHash.schema))
+    .returns(z.array(Tx.schema)),
+
+  getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
+  deleteAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };

package/src/interfaces/private_kernel_prover.ts

@@ -1,6 +1,7 @@
-import type { WitnessMap } from '@noir-lang/acvm_js';
-
 import type {
+  HidingKernelToPublicPrivateInputs,
+  HidingKernelToRollupPrivateInputs,
+  PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
@@ -9,7 +10,7 @@ import type {
   PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
 
 /**
  * PrivateKernelProver provides functionality to simulate and validate circuits, and retrieve
@@ -96,12 +97,20 @@ export interface PrivateKernelProver {
     privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
+  generateHidingToRollupOutput(
+    inputs: HidingKernelToRollupPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+
+  generateHidingToPublicOutput(
+    inputs: HidingKernelToPublicPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+
   /**
    * Based of a program stack, create a folding proof.
    * @param acirs The program bytecode.
    * @param witnessStack The witnessses for each program bytecode.
    */
-  createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
+  createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
 
   /**
    * Compute the gate count for a given circuit.

package/src/interfaces/prover-agent.ts

@@ -2,19 +2,18 @@ import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/index.js';
 
-export interface ProverAgentApi {
-  setMaxConcurrency(maxConcurrency: number): Promise<void>;
+export const ProverAgentStatusSchema = z.discriminatedUnion('status', [
+  z.object({ status: z.literal('stopped') }),
+  z.object({ status: z.literal('running') }),
+  z.object({ status: z.literal('proving'), jobId: z.string(), proofType: z.number(), startedAtISO: z.string() }),
+]);
 
-  isRunning(): Promise<boolean>;
+export type ProverAgentStatus = z.infer<typeof ProverAgentStatusSchema>;
 
-  getCurrentJobs(): Promise<{ id: string; type: string }[]>;
+export interface ProverAgentApi {
+  getStatus(): Promise<unknown>;
 }
 
 export const ProverAgentApiSchema: ApiSchemaFor<ProverAgentApi> = {
-  setMaxConcurrency: z.function().args(z.number().min(1).int()).returns(z.void()),
-  isRunning: z.function().args().returns(z.boolean()),
-  getCurrentJobs: z
-    .function()
-    .args()
-    .returns(z.array(z.object({ id: z.string(), type: z.string() }))),
+  getStatus: z.function().args().returns(ProverAgentStatusSchema),
 };

package/src/interfaces/prover-client.ts

@@ -1,5 +1,5 @@
 import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { z } from 'zod';
 
@@ -26,7 +26,7 @@ export type ProverConfig = ActualProverConfig & {
   /** The URL to the Aztec node to take proving jobs from */
   nodeUrl?: string;
   /** Identifier of the prover */
-  proverId: Fr;
+  proverId?: EthAddress;
   /** Number of proving agents to start within the prover. */
   proverAgentCount: number;
   /** Store for failed proof inputs. */
@@ -36,7 +36,7 @@ export type ProverConfig = ActualProverConfig & {
 export const ProverConfigSchema = z.object({
   nodeUrl: z.string().optional(),
   realProofs: z.boolean(),
-  proverId: schemas.Fr,
+  proverId: schemas.EthAddress.optional(),
   proverTestDelayType: z.enum(['fixed', 'realistic']),
   proverTestDelayMs: z.number(),
   proverTestDelayFactor: z.number(),
@@ -51,13 +51,12 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   realProofs: {
     env: 'PROVER_REAL_PROOFS',
     description: 'Whether to construct real proofs',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(true),
   },
   proverId: {
     env: 'PROVER_ID',
-    parseEnv: (val: string) => parseProverId(val),
-    description: 'Identifier of the prover',
-    defaultValue: Fr.ZERO,
+    parseEnv: (val?: string) => parseProverId(val),
+    description: 'Hex value that identifies the prover. Defaults to the address used for submitting proofs if not set.',
   },
   proverTestDelayType: {
     env: 'PROVER_TEST_DELAY_TYPE',
@@ -85,8 +84,11 @@ export const proverConfigMappings: ConfigMappingsType<ProverConfig> = {
   },
 };
 
-function parseProverId(str: string) {
-  return Fr.fromHexString(str.startsWith('0x') ? str : Buffer.from(str, 'utf8').toString('hex'));
+function parseProverId(str?: string) {
+  if (!str) {
+    return undefined;
+  }
+  return EthAddress.fromString(str);
 }
 
 /**
@@ -102,7 +104,7 @@ export interface EpochProverManager {
 
   getProvingJobSource(): ProvingJobConsumer;
 
-  getProverId(): Fr;
+  getProverId(): EthAddress;
 
   updateProverConfig(config: Partial<ProverConfig>): Promise<void>;
 }
@@ -111,7 +113,10 @@ export class BlockProofError extends Error {
   static #name = 'BlockProofError';
   override name = BlockProofError.#name;
 
-  constructor(message: string, public readonly txHashes: TxHash[]) {
+  constructor(
+    message: string,
+    public readonly txHashes: TxHash[],
+  ) {
     super(message);
   }
 

package/src/interfaces/prover-coordination.ts

@@ -1,27 +1,17 @@
-import { z } from 'zod';
-
-import type { ApiSchemaFor } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
 import { TxHash } from '../tx/tx_hash.js';
+import type { P2PClient } from './p2p.js';
 
 /** Provides basic operations for ProverNodes to interact with other nodes in the network. */
 export interface ProverCoordination {
-  /**
-   * Returns a transaction given its hash if available.
-   * @param txHash - The hash of the transaction, used as an ID.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
   /**
    * Returns a set of transactions given their hashes if available.
    * @param txHashes - The hashes of the transactions, used as an ID.
-   * @returns The transactions, if found, 'undefined' otherwise.
+   * @returns The transactions found, no necessarily in the same order as the hashes.
    */
   getTxsByHash(txHashes: TxHash[]): Promise<Tx[]>;
-}
 
-export const ProverCoordinationApiSchema: ApiSchemaFor<ProverCoordination> = {
-  getTxByHash: z.function().args(TxHash.schema).returns(Tx.schema.optional()),
-  getTxsByHash: z.function().args(z.array(TxHash.schema)).returns(z.array(Tx.schema)),
-};
+  gatherTxs(txHashes: TxHash[]): Promise<void>;
+
+  getP2PClient(): P2PClient | undefined;
+}

package/src/interfaces/prover-node.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 
+import { type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
 import { type ApiSchemaFor, schemas } from '../schemas/index.js';
+import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_state.js';
 
 const EpochProvingJobState = [
   'initialized',
@@ -11,6 +13,7 @@ const EpochProvingJobState = [
   'failed',
   'stopped',
   'timed-out',
+  'reorg',
 ] as const;
 
 export type EpochProvingJobState = (typeof EpochProvingJobState)[number];
@@ -20,6 +23,7 @@ export const EpochProvingJobTerminalState: EpochProvingJobState[] = [
   'failed',
   'stopped',
   'timed-out',
+  'reorg',
 ] as const;
 
 export type EpochProvingJobTerminalState = (typeof EpochProvingJobTerminalState)[number];
@@ -30,7 +34,9 @@ export interface ProverNodeApi {
 
   startProof(epochNumber: number): Promise<void>;
 
-  prove(epochNumber: number): Promise<void>;
+  getL2Tips(): Promise<L2Tips>;
+
+  getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
 }
 
 /** Schemas for prover node API functions. */
@@ -42,5 +48,7 @@ export const ProverNodeApiSchema: ApiSchemaFor<ProverNodeApi> = {
 
   startProof: z.function().args(schemas.Integer).returns(z.void()),
 
-  prove: z.function().args(schemas.Integer).returns(z.void()),
+  getL2Tips: z.function().args().returns(L2TipsSchema),
+
+  getWorldStateSyncStatus: z.function().args().returns(WorldStateSyncStatusSchema),
 };