@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/interfaces/configs.ts

@@ -0,0 +1,73 @@
+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;
+
+/**
+ * The sequencer configuration.
+ */
+export interface SequencerConfig {
+  /** The number of ms to wait between polling for pending txs. */
+  transactionPollingIntervalMS?: 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 maximum L2 block gas. */
+  maxL2BlockGas?: number;
+  /** The maximum DA block gas. */
+  maxDABlockGas?: number;
+  /** Recipient of block reward. */
+  coinbase?: EthAddress;
+  /** Address to receive fees. */
+  feeRecipient?: AztecAddress;
+  /** The working directory to use for simulation/proving */
+  acvmWorkingDirectory?: string;
+  /** The path to the ACVM binary */
+  acvmBinaryPath?: string;
+  /** The list of functions calls allowed to run in setup */
+  allowedInSetup?: AllowedElement[];
+  /** Max block size */
+  maxBlockSizeInBytes?: number;
+  /** Payload address to vote for */
+  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;
+}
+
+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(),
+  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(),
+  maxBlockSizeInBytes: z.number().optional(),
+  governanceProposerPayload: schemas.EthAddress.optional(),
+  maxL1TxInclusionTimeIntoSlot: z.number().optional(),
+  enforceTimeTable: z.boolean().optional(),
+}) satisfies ZodFor<SequencerConfig>;

package/src/interfaces/epoch-prover.ts

@@ -0,0 +1,43 @@
+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 { BlockHeader } from '../tx/block_header.js';
+import type { Tx } from '../tx/tx.js';
+import type { BlockBuilder } from './block-builder.js';
+
+/** Coordinates the proving of an entire epoch. */
+export interface EpochProver extends Omit<BlockBuilder, 'setBlockCompleted'> {
+  /**
+   * 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).
+   **/
+  startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): 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.
+   */
+  startTubeCircuits(txs: Tx[]): Promise<void>;
+
+  /** Returns the block. */
+  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block>;
+
+  /** Pads the epoch with empty block roots if needed and blocks until proven. Throws if proving has failed. */
+  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof }>;
+
+  /** 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;
+
+  /** Called when no longer required, cleans up internal resources */
+  stop(): Promise<void>;
+}

package/src/interfaces/get_logs_response.ts

@@ -0,0 +1,31 @@
+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';
+
+/** Response for the getContractClassLogs archiver call. */
+export type GetContractClassLogsResponse = {
+  /** An array of ExtendedContractClassLog elements. */
+  logs: ExtendedContractClassLog[];
+  /** Indicates if a limit has been reached. */
+  maxLogsHit: 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 = {
+  /** An array of ExtendedPublicLog elements. */
+  logs: ExtendedPublicLog[];
+  /** Indicates if a limit has been reached. */
+  maxLogsHit: boolean;
+};
+
+export const GetPublicLogsResponseSchema = z.object({
+  logs: z.array(ExtendedPublicLog.schema),
+  maxLogsHit: z.boolean(),
+}) satisfies ZodFor<GetPublicLogsResponse>;

package/src/interfaces/l2_logs_source.ts

@@ -0,0 +1,47 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { LogFilter } from '../logs/log_filter.js';
+import type { PrivateLog } from '../logs/private_log.js';
+import type { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
+import type { GetContractClassLogsResponse, GetPublicLogsResponse } from './get_logs_response.js';
+
+/**
+ * Interface of classes allowing for the retrieval of logs.
+ */
+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.
+   */
+  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]>;
+
+  /**
+   * 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.
+   * @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[][]>;
+
+  /**
+   * 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>;
+
+  /**
+   * Gets the number of the latest L2 block processed by the implementation.
+   * @returns The number of the latest L2 block processed by the implementation.
+   */
+  getBlockNumber(): Promise<number>;
+}

package/src/interfaces/merkle_tree_operations.ts

@@ -0,0 +1,293 @@
+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 { 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';
+
+/**
+ * Type alias for the nullifier tree ID.
+ */
+export type IndexedTreeId = MerkleTreeId.NULLIFIER_TREE | MerkleTreeId.PUBLIC_DATA_TREE;
+
+export type FrTreeId = Exclude<MerkleTreeId, IndexedTreeId>;
+
+/**
+ * Witness data for a leaf update.
+ */
+export interface LeafUpdateWitnessData<N extends number> {
+  /**
+   * Preimage of the leaf before updating.
+   */
+  leafPreimage: IndexedTreeLeafPreimage;
+  /**
+   * Sibling path to prove membership of the leaf.
+   */
+  siblingPath: SiblingPath<N>;
+  /**
+   * The index of the leaf.
+   */
+  index: bigint;
+}
+
+/**
+ * The result of a batch insertion in an indexed merkle tree.
+ */
+export interface BatchInsertionResult<TreeHeight extends number, SubtreeSiblingPathHeight extends number> {
+  /**
+   * Data for the leaves to be updated when inserting the new ones.
+   */
+  lowLeavesWitnessData?: LeafUpdateWitnessData<TreeHeight>[];
+  /**
+   * Sibling path "pointing to" where the new subtree should be inserted into the tree.
+   */
+  newSubtreeSiblingPath: SiblingPath<SubtreeSiblingPathHeight>;
+  /**
+   * The new leaves being inserted in high to low order. This order corresponds with the order of the low leaves witness.
+   */
+  sortedNewLeaves: Buffer[];
+  /**
+   * The indexes of the sorted new leaves to the original ones.
+   */
+  sortedNewLeavesIndexes: number[];
+}
+
+/**
+ * The result of a sequential insertion in an indexed merkle tree.
+ */
+export interface SequentialInsertionResult<TreeHeight extends number> {
+  /**
+   * Data for the leaves to be updated when inserting the new ones.
+   */
+  lowLeavesWitnessData: LeafUpdateWitnessData<TreeHeight>[];
+  /**
+   * Data for the inserted leaves
+   */
+  insertionWitnessData: LeafUpdateWitnessData<TreeHeight>[];
+}
+
+/**
+ *  Defines tree information.
+ */
+export interface TreeInfo {
+  /**
+   * The tree ID.
+   */
+  treeId: MerkleTreeId;
+  /**
+   * The tree root.
+   */
+  root: Buffer;
+  /**
+   * The number of leaves in the tree.
+   */
+  size: bigint;
+
+  /**
+   * The depth of the tree.
+   */
+  depth: number;
+}
+
+type LeafTypes = {
+  [MerkleTreeId.NULLIFIER_TREE]: Buffer;
+  [MerkleTreeId.NOTE_HASH_TREE]: Fr;
+  [MerkleTreeId.PUBLIC_DATA_TREE]: Buffer;
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: Fr;
+  [MerkleTreeId.ARCHIVE]: Fr;
+};
+
+type LeafValueTypes = {
+  [MerkleTreeId.NULLIFIER_TREE]: NullifierLeaf;
+  [MerkleTreeId.NOTE_HASH_TREE]: Fr;
+  [MerkleTreeId.PUBLIC_DATA_TREE]: PublicDataTreeLeaf;
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: Fr;
+  [MerkleTreeId.ARCHIVE]: Fr;
+};
+
+export type MerkleTreeLeafType<ID extends MerkleTreeId> = LeafTypes[ID];
+
+export type MerkleTreeLeafValue<ID extends MerkleTreeId> = LeafValueTypes[ID];
+
+/**
+ * Defines the interface for operations on a set of Merkle Trees.
+ */
+export interface MerkleTreeReadOperations {
+  /**
+   * Returns information about the given tree.
+   * @param treeId - The tree to be queried.
+   */
+  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo>;
+
+  /**
+   * Gets the current state reference.
+   */
+  getStateReference(): Promise<StateReference>;
+
+  /**
+   * Gets the initial header.
+   */
+  getInitialHeader(): BlockHeader;
+
+  /**
+   * 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>>;
+
+  /**
+   * Returns the previous index for a given value in an indexed tree.
+   * @param treeId - The tree for which the previous value index is required.
+   * @param value - The value to be queried.
+   */
+  getPreviousValueIndex<ID extends IndexedTreeId>(
+    treeId: ID,
+    value: bigint,
+  ): Promise<
+    | {
+        /**
+         * The index of the found leaf.
+         */
+        index: bigint;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+      }
+    | undefined
+  >;
+
+  /**
+   * Returns the data at a specific leaf.
+   * @param treeId - The tree for which leaf data should be returned.
+   * @param index - The index of the leaf required.
+   */
+  getLeafPreimage<ID extends IndexedTreeId>(treeId: ID, index: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
+
+  /**
+   * Returns the index containing a leaf value.
+   * @param treeId - The tree for which the index should be returned.
+   * @param value - The value to search for in the tree.
+   */
+  findLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<(bigint | undefined)[]>;
+
+  /**
+   * Returns the first index containing a leaf value after `startIndex`.
+   * @param treeId - The tree for which the index should be returned.
+   * @param value - The value to search for in the tree.
+   * @param startIndex - The index to start searching from (used when skipping nullified messages)
+   */
+  findLeafIndicesAfter<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+    startIndex: bigint,
+  ): Promise<(bigint | undefined)[]>;
+
+  /**
+   * Gets the value for a leaf in the tree.
+   * @param treeId - The tree for which the index should be returned.
+   * @param index - The index of the leaf.
+   */
+  getLeafValue<ID extends MerkleTreeId>(
+    treeId: ID,
+    index: bigint,
+  ): Promise<MerkleTreeLeafType<typeof treeId> | undefined>;
+
+  /**
+   * Get the block numbers for a set of leaf indices
+   * @param treeId - The tree for which the block numbers should be returned.
+   * @param leafIndices - The indices to be queried.
+   */
+  getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    leafIndices: bigint[],
+  ): Promise<(bigint | undefined)[]>;
+}
+
+export interface MerkleTreeCheckpointOperations {
+  /**
+   * Checkpoints the current fork state
+   */
+  createCheckpoint(): Promise<void>;
+
+  /**
+   * Commits the current checkpoint
+   */
+  commitCheckpoint(): Promise<void>;
+
+  /**
+   * Reverts the current checkpoint
+   */
+  revertCheckpoint(): Promise<void>;
+}
+
+export interface MerkleTreeWriteOperations extends MerkleTreeReadOperations, MerkleTreeCheckpointOperations {
+  /**
+   * Appends leaves to a given tree.
+   * @param treeId - The tree to be updated.
+   * @param leaves - The set of leaves to be appended.
+   */
+  appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void>;
+
+  /**
+   * Inserts the block hash into the archive.
+   * This includes all of the current roots of all of the data trees and the current blocks global vars.
+   * @param header - The header to insert into the archive.
+   */
+  updateArchive(header: BlockHeader): Promise<void>;
+
+  /**
+   * Batch insert multiple leaves into the tree.
+   * @param leaves - Leaves to insert into the tree.
+   * @param treeId - The tree on which to insert.
+   * @param subtreeHeight - Height of the subtree.
+   * @returns The witness data for the leaves to be updated when inserting the new ones.
+   */
+  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+    subtreeHeight: number,
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
+
+  /**
+   * Inserts multiple leaves into the tree, getting witnesses at every step.
+   * Note: This method doesn't support inserting empty leaves.
+   * @param treeId - The tree on which to insert.
+   * @param leaves - The leaves to insert.
+   * @returns The witnesses for the low leaf updates and the insertions.
+   */
+  sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+  ): Promise<SequentialInsertionResult<TreeHeight>>;
+
+  /**
+   * Closes the database, discarding any uncommitted changes.
+   */
+  close(): Promise<void>;
+}
+
+/**
+ * Outputs a tree leaves using for debugging purposes.
+ */
+export async function inspectTree(
+  db: MerkleTreeReadOperations,
+  treeId: MerkleTreeId,
+  log = createLogger('types:inspect-tree'),
+) {
+  const info = await db.getTreeInfo(treeId);
+  const output = [`Tree id=${treeId} size=${info.size} root=0x${info.root.toString('hex')}`];
+  for (let i = 0; i < info.size; i++) {
+    output.push(
+      ` Leaf ${i}: ${await db.getLeafValue(treeId, BigInt(i)).then(x => x?.toString('hex') ?? '[undefined]')}`,
+    );
+  }
+  log.info(output.join('\n'));
+}

package/src/interfaces/p2p-bootstrap.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import type { ApiSchemaFor } from '../schemas/index.js';
+
+/** Exposed API to the P2P bootstrap node. */
+export interface P2PBootstrapApi {
+  /**
+   * Returns the ENR for this node.
+   */
+  getEncodedEnr(): Promise<string>;
+
+  /**
+   * Returns ENRs for all nodes in the routing table.
+   */
+  getRoutingTable(): Promise<string[]>;
+}
+
+export const P2PBootstrapApiSchema: ApiSchemaFor<P2PBootstrapApi> = {
+  getEncodedEnr: z.function().returns(z.string()),
+  getRoutingTable: z.function().returns(z.array(z.string())),
+};

package/src/interfaces/p2p.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+
+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';
+
+export type PeerInfo =
+  | { status: 'connected'; score: number; id: string }
+  | { status: 'dialing'; dialStatus: string; id: string; addresses: string[] }
+  | { status: 'cached'; id: string; addresses: string[]; enr: string; dialAttempts: number };
+
+const PeerInfoSchema = z.discriminatedUnion('status', [
+  z.object({ status: z.literal('connected'), score: z.number(), id: z.string() }),
+  z.object({ status: z.literal('dialing'), dialStatus: z.string(), id: z.string(), addresses: z.array(z.string()) }),
+  z.object({
+    status: z.literal('cached'),
+    id: z.string(),
+    addresses: z.array(z.string()),
+    enr: z.string(),
+    dialAttempts: z.number(),
+  }),
+]);
+
+/** Exposed API to the P2P module. */
+export interface P2PApiWithoutAttestations {
+  /**
+   * Returns all pending transactions in the transaction pool.
+   * @returns An array of Txs.
+   */
+  getPendingTxs(): Promise<Tx[]>;
+
+  /**
+   * Returns the ENR for this node, if any.
+   */
+  getEncodedEnr(): Promise<string | undefined>;
+
+  /**
+   * Returns info for all connected, dialing, and cached peers.
+   */
+  getPeers(includePending?: boolean): Promise<PeerInfo[]>;
+}
+
+export interface P2PClient extends P2PApiWithoutAttestations {
+  /**
+   * Queries the Attestation pool for 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
+   */
+  getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+}
+
+export type P2PApi<T extends P2PClientType = P2PClientType.Full> = T extends P2PClientType.Full
+  ? P2PClient & P2PApiWithoutAttestations
+  : P2PApiWithoutAttestations;
+
+export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
+  getAttestationsForSlot: z
+    .function()
+    .args(schemas.BigInt, optional(z.string()))
+    .returns(z.array(BlockAttestation.schema)),
+  getPendingTxs: z.function().returns(z.array(Tx.schema)),
+  getEncodedEnr: z.function().returns(z.string().optional()),
+  getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
+};

package/src/interfaces/private_kernel_prover.ts

@@ -0,0 +1,113 @@
+import type { WitnessMap } from '@noir-lang/acvm_js';
+
+import type {
+  PrivateKernelCircuitPublicInputs,
+  PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInnerCircuitPrivateInputs,
+  PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelSimulateOutput,
+  PrivateKernelTailCircuitPrivateInputs,
+  PrivateKernelTailCircuitPublicInputs,
+} from '../kernel/index.js';
+import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+
+/**
+ * PrivateKernelProver provides functionality to simulate and validate circuits, and retrieve
+ * siloed commitments necessary for maintaining transaction privacy and security on the network.
+ */
+export interface PrivateKernelProver {
+  /**
+   * Creates a proof output for a given signed transaction request and private call data for the first iteration.
+   *
+   * @param privateKernelInputsInit - The private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInitOutput(
+    privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the first kernel iteration without generating a proof.
+   *
+   * @param privateKernelInputsInit - The private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInit(
+    privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
+   *
+   * @param privateKernelInputsInner - The private input data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInnerOutput(
+    privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes an inner kernel iteration without generating a proof.
+   *
+   * @param privateKernelInputsInit - The private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInner(
+    privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output by resetting the arrays using the reset circuit.
+   *
+   * @param privateKernelInputsTail - The private input data structure for the reset circuit.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateResetOutput(
+    privateKernelInputsReset: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the reset circuit without generating a proof
+   *
+   * @param privateKernelInputsTail - The private input data structure for the reset circuit.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs an empty kernel proof.
+   */
+  simulateReset(
+    privateKernelInputsReset: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   *
+   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateTailOutput(
+    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+
+  /**
+   * Executes the final ordering iteration circuit.
+   *
+   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs an empty kernel proof.
+   */
+  simulateTail(
+    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  ): 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>;
+
+  /**
+   * Compute the gate count for a given circuit.
+   * @param bytecode - The circuit bytecode in gzipped bincode format
+   * @param circuitName - The name of the circuit
+   * @returns A Promise resolving to the gate count
+   */
+  computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
+}