@izi-noir/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1196 @@
+import { I as IChainFormatter } from './wasmInit-KV6DTj4J.js';
+export { C as ChainProofDataFor, a as IziNoir, S as SolanaDeployData, i as initNoirWasm, b as isWasmInitialized, m as markWasmInitialized } from './wasmInit-KV6DTj4J.js';
+import { P as ProofData, S as SolanaProofData, C as CircuitFunction, I as InputValue, a as ProofResult } from './types-CaaigonG.js';
+export { b as ProofTimings, c as ProverOptions, d as VerifierOptions, V as VerifyingKeyData } from './types-CaaigonG.js';
+import { a as CircuitMetadata, S as SolanaChainMetadata, d as IProvingSystem } from './IProvingSystem-D9TnEig0.js';
+export { c as Chain, C as ChainId, f as ChainMetadata, b as ChainMetadataFor, e as CircuitPaths, E as EthereumChainMetadata, g as ICompiler, h as IProver, i as IVerifier, I as IziNoirConfig, P as Provider } from './IProvingSystem-D9TnEig0.js';
+import { ArkworksWasm, ArkworksWasmConfig } from './providers/arkworks.js';
+export { ArkworksCompiledCircuit, ArkworksProofResult, ArkworksSetupResult, ArkworksWasmModule, isArkworksCircuit } from './providers/arkworks.js';
+import { CompiledCircuit } from '@noir-lang/types';
+export { CompiledCircuit, InputMap } from '@noir-lang/types';
+export { Barretenberg } from './providers/barretenberg.js';
+export { IZI_NOIR_PROGRAM_ID, buildInitVkFromBytesData, buildVerifyProofData, calculateVkAccountRent, calculateVkAccountSize, parseProof, parsePublicInputs, parseVerifyingKey } from './providers/solana.js';
+
+/**
+ * Formatter for Solana-compatible proof data.
+ *
+ * Converts generic ProofData into SolanaProofData format with:
+ * - Verifying key in gnark format (compatible with gnark-verifier-solana)
+ * - Proof bytes (256 bytes Groth16)
+ * - Public inputs as 32-byte arrays
+ * - VK account size and rent estimates
+ *
+ * @example
+ * ```typescript
+ * const formatter = new SolanaFormatter(arkworksProvider);
+ * const solanaProof = await formatter.formatProof(proofData, circuit, metadata);
+ * ```
+ */
+declare class SolanaFormatter implements IChainFormatter<'solana'> {
+    private arkworksProvider;
+    readonly chainId: "solana";
+    constructor(arkworksProvider: ArkworksWasm);
+    /**
+     * Format a generic proof for Solana on-chain verification.
+     *
+     * @param proofData - Generic proof data from Arkworks
+     * @param circuit - The compiled circuit (must be Arkworks circuit)
+     * @param metadata - Circuit metadata with public input count
+     * @returns SolanaProofData ready for on-chain verification
+     */
+    formatProof(proofData: ProofData, circuit: CompiledCircuit, metadata: CircuitMetadata): Promise<SolanaProofData>;
+    /**
+     * Get Solana-specific metadata for a circuit.
+     *
+     * @param publicInputCount - Number of public inputs in the circuit
+     * @returns Solana metadata with account size and rent estimates
+     */
+    getChainMetadata(publicInputCount: number): SolanaChainMetadata;
+    /**
+     * Calculate the size of a VK account for a given number of public inputs.
+     * Matches the Rust `vk_account_size` function in the Solana program.
+     */
+    private calculateVkAccountSize;
+    /**
+     * Calculate the minimum rent for a VK account.
+     */
+    private calculateVkAccountRent;
+    /**
+     * Convert Uint8Array to base64 string.
+     */
+    private uint8ArrayToBase64;
+    /**
+     * Convert hex string to Uint8Array.
+     */
+    private hexToBytes;
+}
+
+interface CircuitParam {
+    name: string;
+    index: number;
+}
+interface BinaryExpr {
+    kind: 'binary';
+    left: Expr;
+    operator: BinaryOperator;
+    right: Expr;
+}
+interface IdentifierExpr {
+    kind: 'identifier';
+    name: string;
+}
+interface LiteralExpr {
+    kind: 'literal';
+    value: number | string | bigint;
+}
+interface MemberExpr {
+    kind: 'member';
+    object: Expr;
+    index: Expr;
+}
+interface ArrayLiteralExpr {
+    kind: 'array_literal';
+    elements: Expr[];
+}
+interface CallExpr {
+    kind: 'call';
+    callee: Expr;
+    method?: string;
+    args: Expr[];
+}
+type BinaryOperator = '==' | '!=' | '+' | '-' | '*' | '/' | '%' | '<' | '>' | '<=' | '>=' | '&' | '|';
+type UnaryOperator = '!' | '-';
+interface UnaryExpr {
+    kind: 'unary';
+    operator: UnaryOperator;
+    operand: Expr;
+}
+interface IfExpr {
+    kind: 'if_expr';
+    condition: Expr;
+    consequent: Expr;
+    alternate: Expr;
+}
+type Expr = BinaryExpr | UnaryExpr | IdentifierExpr | LiteralExpr | MemberExpr | ArrayLiteralExpr | CallExpr | IfExpr;
+interface AssertStatement {
+    kind: 'assert';
+    condition: Expr;
+    message?: string;
+}
+interface VariableDeclaration {
+    kind: 'variable_declaration';
+    name: string;
+    mutable: boolean;
+    initializer: Expr;
+}
+interface AssignmentStatement {
+    kind: 'assignment';
+    target: string;
+    value: Expr;
+}
+interface IfStatement {
+    kind: 'if_statement';
+    condition: Expr;
+    consequent: Statement[];
+    alternate?: Statement[];
+}
+interface ForStatement {
+    kind: 'for_statement';
+    variable: string;
+    start: Expr;
+    end: Expr;
+    inclusive: boolean;
+    body: Statement[];
+}
+type Statement = AssertStatement | VariableDeclaration | AssignmentStatement | IfStatement | ForStatement;
+interface ParsedCircuit {
+    publicParams: CircuitParam[];
+    privateParams: CircuitParam[];
+    statements: Statement[];
+}
+
+interface IParser {
+    parse(fn: CircuitFunction, publicInputs: InputValue[], privateInputs: InputValue[]): ParsedCircuit;
+}
+
+interface CreateProofDependencies {
+    parser: IParser;
+    provingSystem: IProvingSystem;
+}
+declare class CreateProofUseCase {
+    private readonly deps;
+    constructor(deps: CreateProofDependencies);
+    execute(publicInputs: InputValue[], privateInputs: InputValue[], circuitFn: CircuitFunction): Promise<ProofResult>;
+}
+
+/**
+ * Create default container with Barretenberg backend
+ *
+ * @deprecated Use IziNoir.init({ provider: Provider.Barretenberg }) instead
+ */
+declare function createDefaultContainer(): CreateProofDependencies;
+/**
+ * Create container with ArkworksWasm backend (Groth16 for Solana, 100% browser)
+ *
+ * @deprecated Use IziNoir.init({ provider: Provider.Arkworks }) instead
+ *
+ * @example
+ * ```ts
+ * // Preferred:
+ * const izi = await IziNoir.init({ provider: Provider.Arkworks });
+ * await izi.compile(noirCode);
+ * const proof = await izi.proveForChain('solana', inputs);
+ * ```
+ */
+declare function createArkworksWasmContainer(config?: ArkworksWasmConfig): CreateProofDependencies;
+
+/**
+ * Parses JavaScript circuit functions into a structured representation.
+ *
+ * The AcornParser is the main orchestrator that:
+ * 1. Parses JS source using Acorn
+ * 2. Extracts parameters from ([public], [private]) => {} pattern
+ * 3. Delegates statement/expression parsing to specialized parsers
+ *
+ * Architecture:
+ * - ExpressionParser: Handles all expression types
+ * - StatementParser: Handles statements (vars, if, assert, assignments)
+ * - ForLoopParser: Handles for loop validation and parsing
+ */
+declare class AcornParser implements IParser {
+    private exprParser;
+    private forLoopParser;
+    private stmtParser;
+    /**
+     * Parses a circuit function into public/private parameters and statements.
+     *
+     * @param fn The circuit function with signature ([public], [private]) => { ... }
+     * @param _publicInputs Public input values (used for validation, not parsing)
+     * @param _privateInputs Private input values (used for validation, not parsing)
+     */
+    parse(fn: CircuitFunction, _publicInputs: InputValue[], _privateInputs: InputValue[]): ParsedCircuit;
+    /**
+     * Finds the arrow function or function expression in the AST.
+     */
+    private findFunctionNode;
+    /**
+     * Extracts public and private parameters from the function signature.
+     * Expects pattern: ([pub1, pub2], [priv1, priv2]) => { ... }
+     */
+    private extractParameters;
+    /**
+     * Parses the function body into statements.
+     */
+    private parseBody;
+}
+
+declare function generateNoir(circuit: ParsedCircuit): string;
+
+/**
+ * Transaction builder for IZI-NOIR Solana program.
+ *
+ * Provides a high-level API for building Solana transactions without
+ * requiring Anchor or deep knowledge of instruction formats.
+ *
+ * @example
+ * ```typescript
+ * import { SolanaTransactionBuilder } from '@izi-noir/sdk';
+ *
+ * const builder = new SolanaTransactionBuilder({
+ *   computeUnits: 400_000,
+ *   programId: 'EYhRED7EuMyyVjx57aDXUD9h6ArnEKng64qtz8999KrS',
+ * });
+ *
+ * // Build init VK transaction
+ * const initData = builder.buildInitVkInstructionData(solanaProofData);
+ *
+ * // Build verify proof transaction
+ * const verifyData = builder.buildVerifyProofInstructionData(
+ *   solanaProofData.proof.bytes,
+ *   solanaProofData.publicInputs.bytes
+ * );
+ * ```
+ *
+ * @module @izi-noir/sdk/solana
+ */
+
+/**
+ * Configuration for the transaction builder.
+ */
+interface TransactionBuilderConfig {
+    /**
+     * Program ID of the IZI-NOIR verifier program.
+     * Defaults to the deployed devnet program.
+     */
+    programId?: string;
+    /**
+     * Compute units to request for transactions.
+     * Default: 400,000 (sufficient for most proof verifications)
+     */
+    computeUnits?: number;
+    /**
+     * Priority fee in microLamports per compute unit.
+     * Default: 0 (no priority fee)
+     */
+    priorityFee?: number;
+}
+/**
+ * Account configuration for init_vk instruction.
+ */
+interface InitVkAccounts {
+    /** Public key of the VK account (as base58 string) */
+    vkAccount: string;
+    /** Public key of the authority (as base58 string) */
+    authority: string;
+    /** Public key of the payer (as base58 string) */
+    payer: string;
+}
+/**
+ * Account configuration for verify_proof instruction.
+ */
+interface VerifyProofAccounts {
+    /** Public key of the VK account (as base58 string) */
+    vkAccount: string;
+}
+/**
+ * Account configuration for close_vk instruction.
+ */
+interface CloseVkAccounts {
+    /** Public key of the VK account (as base58 string) */
+    vkAccount: string;
+    /** Public key of the authority (as base58 string) */
+    authority: string;
+}
+/**
+ * Instruction data and accounts for a Solana instruction.
+ */
+interface InstructionData {
+    /** Raw instruction data bytes */
+    data: Uint8Array;
+    /** Program ID (base58) */
+    programId: string;
+    /** Account keys with metadata */
+    keys: Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+}
+/**
+ * Result of building init and verify transactions together.
+ */
+interface InitAndVerifyInstructions {
+    /** Init VK instruction */
+    initVk: InstructionData;
+    /** Verify proof instruction */
+    verifyProof: InstructionData;
+    /** Compute budget instruction (set compute units) */
+    computeBudget?: InstructionData;
+    /** Priority fee instruction (if configured) */
+    priorityFee?: InstructionData;
+    /** Required rent for VK account in lamports */
+    rentLamports: number;
+    /** Size of VK account in bytes */
+    accountSize: number;
+}
+/**
+ * Transaction builder for IZI-NOIR Solana program.
+ *
+ * This class provides methods to build instruction data for the IZI-NOIR
+ * Solana program without requiring Anchor or @solana/web3.js dependencies.
+ *
+ * The returned instruction data can be used with any Solana library:
+ * - @solana/web3.js
+ * - @solana/kit (new)
+ * - Anchor
+ * - Mobile wallet adapters
+ */
+declare class SolanaTransactionBuilder {
+    private programId;
+    private computeUnits;
+    private priorityFee;
+    constructor(config?: TransactionBuilderConfig);
+    /**
+     * Builds the instruction data for initializing a VK account.
+     *
+     * @param solanaProofData - Proof data from `izi.proveForSolana()`
+     * @param accounts - Account public keys
+     * @returns Instruction data ready for transaction building
+     *
+     * @example
+     * ```typescript
+     * const initInstruction = builder.buildInitVkInstruction(solanaProofData, {
+     *   vkAccount: vkKeypair.publicKey.toBase58(),
+     *   authority: wallet.publicKey.toBase58(),
+     *   payer: wallet.publicKey.toBase58(),
+     * });
+     * ```
+     */
+    buildInitVkInstruction(solanaProofData: SolanaProofData, accounts: InitVkAccounts): InstructionData;
+    /**
+     * Builds the instruction data for verifying a proof.
+     *
+     * @param proofBytes - 256-byte Groth16 proof
+     * @param publicInputs - Array of 32-byte public inputs
+     * @param accounts - Account public keys
+     * @returns Instruction data ready for transaction building
+     *
+     * @example
+     * ```typescript
+     * const verifyInstruction = builder.buildVerifyProofInstruction(
+     *   solanaProofData.proof.bytes,
+     *   solanaProofData.publicInputs.bytes,
+     *   { vkAccount: vkAccountPubkey.toBase58() }
+     * );
+     * ```
+     */
+    buildVerifyProofInstruction(proofBytes: Uint8Array, publicInputs: Uint8Array[], accounts: VerifyProofAccounts): InstructionData;
+    /**
+     * Builds the instruction data for closing a VK account.
+     *
+     * @param accounts - Account public keys
+     * @returns Instruction data ready for transaction building
+     */
+    buildCloseVkInstruction(accounts: CloseVkAccounts): InstructionData;
+    /**
+     * Builds a compute budget instruction to set compute unit limit.
+     *
+     * @param units - Number of compute units (default: configured value)
+     * @returns Instruction data
+     */
+    buildSetComputeUnitLimitInstruction(units?: number): InstructionData;
+    /**
+     * Builds a compute budget instruction to set priority fee.
+     *
+     * @param microLamports - Priority fee in microLamports per CU
+     * @returns Instruction data
+     */
+    buildSetComputeUnitPriceInstruction(microLamports?: number): InstructionData;
+    /**
+     * Builds all instructions needed to initialize a VK and verify a proof.
+     *
+     * This is a convenience method that combines:
+     * - Compute budget instructions (if configured)
+     * - Init VK instruction
+     * - Verify proof instruction
+     *
+     * @param solanaProofData - Proof data from `izi.proveForSolana()`
+     * @param vkAccountPubkey - Public key for the new VK account
+     * @param authorityPubkey - Authority for the VK account
+     * @param payerPubkey - Payer for the transaction
+     * @returns All instruction data and metadata
+     *
+     * @example
+     * ```typescript
+     * const result = builder.buildInitAndVerifyInstructions(
+     *   solanaProofData,
+     *   vkKeypair.publicKey.toBase58(),
+     *   wallet.publicKey.toBase58(),
+     *   wallet.publicKey.toBase58()
+     * );
+     *
+     * // Use with @solana/web3.js:
+     * const transaction = new Transaction();
+     * if (result.computeBudget) {
+     *   transaction.add(toTransactionInstruction(result.computeBudget));
+     * }
+     * transaction.add(toTransactionInstruction(result.initVk));
+     * // ... sign and send
+     * ```
+     */
+    buildInitAndVerifyInstructions(solanaProofData: SolanaProofData, vkAccountPubkey: string, authorityPubkey: string, payerPubkey: string): InitAndVerifyInstructions;
+    /**
+     * Validates that SolanaProofData has the correct format.
+     *
+     * @param data - Proof data to validate
+     * @throws Error if validation fails
+     */
+    validateSolanaProofData(data: SolanaProofData): void;
+    /**
+     * Gets the program ID being used.
+     */
+    getProgramId(): string;
+    /**
+     * Gets the configured compute units.
+     */
+    getComputeUnits(): number;
+    /**
+     * Gets the configured priority fee.
+     */
+    getPriorityFee(): number;
+}
+
+/**
+ * VK Deployment Manager for IZI-NOIR.
+ *
+ * Provides idempotent deployment of verifying keys to Solana with
+ * local persistence for tracking deployed circuits.
+ *
+ * @example
+ * ```typescript
+ * import { VkDeploymentManager } from '@izi-noir/sdk';
+ *
+ * const manager = new VkDeploymentManager({
+ *   network: 'devnet',
+ *   configDir: './.izi-noir', // optional, defaults to .izi-noir
+ * });
+ *
+ * // Deploy (idempotent - won't redeploy if already deployed)
+ * const deployment = await manager.ensureDeployed({
+ *   circuitName: 'balance-check',
+ *   solanaProofData,
+ *   sendTransaction: async (tx) => {
+ *     // Sign and send using your wallet adapter
+ *     return await wallet.sendTransaction(tx, connection);
+ *   },
+ * });
+ *
+ * console.log(`VK at: ${deployment.vkAccount}`);
+ *
+ * // Save deployment state
+ * await manager.save();
+ * ```
+ *
+ * @module @izi-noir/sdk/deployment
+ */
+
+/**
+ * Supported Solana networks.
+ */
+type SolanaNetwork = 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+/**
+ * Network RPC endpoints.
+ */
+declare const NETWORK_ENDPOINTS: Record<SolanaNetwork, string>;
+/**
+ * Configuration for VK Deployment Manager.
+ */
+interface VkDeploymentManagerConfig {
+    /**
+     * Solana network to deploy to.
+     */
+    network: SolanaNetwork;
+    /**
+     * Custom RPC endpoint. Overrides network default.
+     */
+    rpcEndpoint?: string;
+    /**
+     * Directory to store deployment config. Default: '.izi-noir'
+     */
+    configDir?: string;
+    /**
+     * Program ID override.
+     */
+    programId?: string;
+    /**
+     * Compute units for transactions. Default: 400,000
+     */
+    computeUnits?: number;
+}
+/**
+ * Record of a deployed VK.
+ */
+interface VkDeployment {
+    /** Circuit identifier (name or hash) */
+    circuitId: string;
+    /** VK account public key (base58) */
+    vkAccount: string;
+    /** Authority public key (base58) */
+    authority: string;
+    /** Deployment timestamp */
+    deployedAt: string;
+    /** Transaction signature */
+    txSignature: string;
+    /** Network deployed to */
+    network: SolanaNetwork;
+    /** Hash of the VK bytes for deduplication */
+    vkHash: string;
+    /** Number of public inputs */
+    nrPublicInputs: number;
+}
+/**
+ * Options for ensureDeployed method.
+ */
+interface EnsureDeployedOptions {
+    /**
+     * Identifier for the circuit (used for lookup).
+     */
+    circuitName: string;
+    /**
+     * Proof data containing VK bytes.
+     */
+    solanaProofData: SolanaProofData;
+    /**
+     * Function to send a transaction.
+     * Should return the transaction signature.
+     */
+    sendTransaction: (instructions: InstructionData[], signers: SignerInfo[]) => Promise<string>;
+    /**
+     * Authority public key (base58).
+     */
+    authority: string;
+    /**
+     * Payer public key (base58).
+     */
+    payer: string;
+    /**
+     * Force redeploy even if already exists.
+     */
+    forceRedeploy?: boolean;
+}
+/**
+ * Information about required signers.
+ */
+interface SignerInfo {
+    /** Public key of the signer (base58) */
+    pubkey: string;
+    /** Whether this is a new keypair that needs to be generated */
+    isNewKeypair: boolean;
+    /** Description of the signer role */
+    role: 'vkAccount' | 'authority' | 'payer';
+}
+/**
+ * Result of deployment operation.
+ */
+interface DeploymentResult {
+    /** Whether deployment was performed (false if already deployed) */
+    deployed: boolean;
+    /** VK account address */
+    vkAccount: string;
+    /** Transaction signature (if deployed) */
+    txSignature?: string;
+    /** Full deployment record */
+    deployment: VkDeployment;
+}
+/**
+ * Deployments state file structure.
+ */
+interface DeploymentsState {
+    version: '1.0';
+    deployments: VkDeployment[];
+}
+/**
+ * VK Deployment Manager.
+ *
+ * Manages deployment of verifying keys to Solana with:
+ * - Idempotent deployments (skip if already deployed)
+ * - Local persistence of deployment records
+ * - Network-aware configuration
+ */
+declare class VkDeploymentManager {
+    private config;
+    private deployments;
+    private builder;
+    private dirty;
+    constructor(config: VkDeploymentManagerConfig);
+    /**
+     * Loads deployment state from disk.
+     *
+     * In browser environments, this is a no-op.
+     * In Node.js, reads from {configDir}/deployments.json
+     */
+    load(): Promise<void>;
+    /**
+     * Loads deployment state from a JSON object.
+     */
+    loadFromJson(state: DeploymentsState): void;
+    /**
+     * Saves deployment state.
+     *
+     * Returns the state object for custom persistence.
+     */
+    save(): Promise<DeploymentsState>;
+    /**
+     * Exports deployment state to JSON.
+     */
+    toJson(): DeploymentsState;
+    /**
+     * Ensures a VK is deployed, skipping if already exists.
+     *
+     * @returns Deployment result with VK account address
+     */
+    ensureDeployed(options: EnsureDeployedOptions): Promise<DeploymentResult>;
+    /**
+     * Gets deployment by circuit name.
+     */
+    getDeployment(circuitName: string): VkDeployment | undefined;
+    /**
+     * Gets deployment by VK hash.
+     */
+    getDeploymentByVkHash(vkHash: string): VkDeployment | undefined;
+    /**
+     * Gets all deployments.
+     */
+    getAllDeployments(): VkDeployment[];
+    /**
+     * Checks if there are unsaved changes.
+     */
+    isDirty(): boolean;
+    /**
+     * Gets the RPC endpoint.
+     */
+    getRpcEndpoint(): string;
+    /**
+     * Gets the network.
+     */
+    getNetwork(): SolanaNetwork;
+    /**
+     * Prepares instructions for deployment without sending.
+     *
+     * Useful when you need to combine with other instructions
+     * or use a specific signing flow.
+     */
+    prepareDeployment(solanaProofData: SolanaProofData, accounts: {
+        vkAccount: string;
+        authority: string;
+        payer: string;
+    }): {
+        instructions: InstructionData[];
+        signers: SignerInfo[];
+        rentLamports: number;
+    };
+    /**
+     * Records an external deployment (made outside this manager).
+     */
+    recordDeployment(deployment: VkDeployment): void;
+    /**
+     * Removes a deployment record.
+     */
+    removeDeployment(circuitName: string): boolean;
+    private makeDeploymentKey;
+    private hashVkBytes;
+    private generateVkAccountPlaceholder;
+}
+/**
+ * Creates a VK Deployment Manager with Node.js file persistence.
+ *
+ * @example
+ * ```typescript
+ * const manager = await createNodeVkDeploymentManager({
+ *   network: 'devnet',
+ *   configDir: './.izi-noir',
+ * });
+ *
+ * // Automatically loads existing deployments
+ * // and saves on manager.save()
+ * ```
+ */
+declare function createNodeVkDeploymentManager(config: VkDeploymentManagerConfig): Promise<VkDeploymentManager>;
+
+/**
+ * Circuit Registry for IZI-NOIR.
+ *
+ * Provides naming, versioning, and metadata management for JS circuits.
+ * Enables circuit reuse and documentation generation.
+ *
+ * @example
+ * ```typescript
+ * import { CircuitRegistry } from '@izi-noir/sdk';
+ *
+ * const registry = new CircuitRegistry();
+ *
+ * // Register a circuit
+ * registry.register({
+ *   name: 'balance-check',
+ *   version: '1.0.0',
+ *   description: 'Proves balance >= minimum without revealing actual balance',
+ *   jsCircuit: ([minimum], [balance]) => {
+ *     assert(balance >= minimum);
+ *   },
+ *   publicInputs: [{ name: 'minimum', type: 'Field', description: 'Minimum required balance' }],
+ *   privateInputs: [{ name: 'balance', type: 'Field', description: 'Actual balance (kept private)' }],
+ *   tags: ['finance', 'privacy'],
+ * });
+ *
+ * // Use the circuit
+ * const circuit = registry.get('balance-check');
+ * const result = await izi.createProof(circuit.jsCircuit, [100], [250]);
+ * ```
+ *
+ * @module @izi-noir/sdk/registry
+ */
+
+/**
+ * Input field definition with metadata.
+ */
+interface CircuitInputDef {
+    /** Name of the input */
+    name: string;
+    /** Type in Noir (Field, u8, u32, etc.) */
+    type: 'Field' | 'u8' | 'u16' | 'u32' | 'u64' | 'bool' | string;
+    /** Human-readable description */
+    description?: string;
+    /** Optional constraint or validation info */
+    constraints?: string;
+}
+/**
+ * Circuit definition with metadata.
+ */
+interface CircuitDefinition {
+    /** Unique identifier for the circuit */
+    name: string;
+    /** Semantic version (e.g., '1.0.0') */
+    version: string;
+    /** Human-readable description */
+    description?: string;
+    /** The JavaScript circuit function */
+    jsCircuit: CircuitFunction;
+    /** Public inputs metadata */
+    publicInputs: CircuitInputDef[];
+    /** Private inputs metadata */
+    privateInputs: CircuitInputDef[];
+    /** Optional tags for categorization */
+    tags?: string[];
+    /** Optional author information */
+    author?: string;
+    /** Optional license */
+    license?: string;
+}
+/**
+ * Registered circuit with computed metadata.
+ */
+interface RegisteredCircuit extends CircuitDefinition {
+    /** When the circuit was registered */
+    registeredAt: Date;
+    /** Unique identifier combining name and version */
+    id: string;
+    /** Hash of the circuit function for change detection */
+    functionHash: string;
+}
+/**
+ * Options for circuit lookup.
+ */
+interface GetCircuitOptions {
+    /** Specific version to get (default: latest) */
+    version?: string;
+}
+/**
+ * Circuit Registry.
+ *
+ * A registry for managing named, versioned circuits with rich metadata.
+ * Provides features for:
+ * - Semantic versioning
+ * - Input/output documentation
+ * - Tag-based categorization
+ * - Change detection
+ */
+declare class CircuitRegistry {
+    private circuits;
+    /**
+     * Registers a new circuit.
+     *
+     * @param definition - Circuit definition with metadata
+     * @returns The registered circuit with computed fields
+     * @throws Error if circuit with same name and version exists
+     */
+    register(definition: CircuitDefinition): RegisteredCircuit;
+    /**
+     * Gets a circuit by name.
+     *
+     * @param name - Circuit name
+     * @param options - Lookup options (version, etc.)
+     * @returns The circuit or undefined if not found
+     */
+    get(name: string, options?: GetCircuitOptions): RegisteredCircuit | undefined;
+    /**
+     * Gets all versions of a circuit.
+     *
+     * @param name - Circuit name
+     * @returns Array of all registered versions
+     */
+    getVersions(name: string): RegisteredCircuit[];
+    /**
+     * Checks if a circuit exists.
+     *
+     * @param name - Circuit name
+     * @param version - Optional specific version
+     */
+    has(name: string, version?: string): boolean;
+    /**
+     * Gets all registered circuit names.
+     */
+    names(): string[];
+    /**
+     * Gets all registered circuits.
+     */
+    all(): RegisteredCircuit[];
+    /**
+     * Searches circuits by tag.
+     *
+     * @param tag - Tag to search for
+     * @returns Circuits with matching tag
+     */
+    findByTag(tag: string): RegisteredCircuit[];
+    /**
+     * Removes a circuit from the registry.
+     *
+     * @param name - Circuit name
+     * @param version - Optional specific version (removes all if not specified)
+     * @returns true if circuit was removed
+     */
+    remove(name: string, version?: string): boolean;
+    /**
+     * Exports the registry to a serializable format.
+     */
+    export(): CircuitRegistryExport;
+    /**
+     * Generates documentation for a circuit.
+     *
+     * @param name - Circuit name
+     * @returns Markdown documentation
+     */
+    generateDocs(name: string): string;
+    /**
+     * Validates circuit inputs against the definition.
+     *
+     * @param name - Circuit name
+     * @param publicInputs - Public inputs to validate
+     * @param privateInputs - Private inputs to validate
+     * @throws Error if validation fails
+     */
+    validateInputs(name: string, publicInputs: unknown[], privateInputs: unknown[]): void;
+    private hashFunction;
+    private compareVersions;
+    private validateInput;
+}
+/**
+ * Serializable circuit entry (without the function).
+ */
+interface CircuitExportEntry {
+    name: string;
+    version: string;
+    description?: string;
+    publicInputs: CircuitInputDef[];
+    privateInputs: CircuitInputDef[];
+    tags?: string[];
+    author?: string;
+    license?: string;
+    registeredAt: string;
+    functionHash: string;
+}
+/**
+ * Serializable registry export.
+ */
+interface CircuitRegistryExport {
+    version: '1.0';
+    exportedAt: string;
+    circuits: CircuitExportEntry[];
+}
+declare function getGlobalRegistry(): CircuitRegistry;
+/**
+ * Decorator-style function to register a circuit with minimal boilerplate.
+ *
+ * @example
+ * ```typescript
+ * const balanceCheck = defineCircuit({
+ *   name: 'balance-check',
+ *   version: '1.0.0',
+ *   publicInputs: [{ name: 'minimum', type: 'Field' }],
+ *   privateInputs: [{ name: 'balance', type: 'Field' }],
+ * }, ([minimum], [balance]) => {
+ *   assert(balance >= minimum);
+ * });
+ *
+ * // balanceCheck is now registered and contains the full definition
+ * ```
+ */
+declare function defineCircuit(metadata: Omit<CircuitDefinition, 'jsCircuit'>, jsCircuit: CircuitFunction): RegisteredCircuit;
+
+/**
+ * Off-Chain Verifier for IZI-NOIR.
+ *
+ * Provides ZK proof verification without on-chain transactions.
+ * Useful for API authentication, backend validation, and testing.
+ *
+ * @example
+ * ```typescript
+ * import { OffchainVerifier, createVerifierMiddleware } from '@izi-noir/sdk';
+ * import express from 'express';
+ *
+ * // Create verifier with compiled circuits
+ * const verifier = new OffchainVerifier();
+ *
+ * // Register circuits for verification
+ * await verifier.registerCircuit('age-check', {
+ *   jsCircuit: ([minAge], [birthYear]) => {
+ *     assert(2024 - birthYear >= minAge);
+ *   }
+ * });
+ *
+ * // Use as Express middleware
+ * const app = express();
+ * app.post('/api/verify', createVerifierMiddleware(verifier));
+ *
+ * // Or verify directly
+ * const result = await verifier.verify({
+ *   circuitName: 'age-check',
+ *   proof: proofBytes,
+ *   publicInputs: [18],
+ * });
+ *
+ * if (result.verified) {
+ *   console.log('Proof valid!');
+ * }
+ * ```
+ *
+ * @module @izi-noir/sdk/server
+ */
+
+/**
+ * Circuit configuration for offchain verification.
+ */
+interface OffchainCircuitConfig {
+    /** JavaScript circuit function */
+    jsCircuit: CircuitFunction;
+    /** Pre-compiled circuit (optional, will compile if not provided) */
+    compiledCircuit?: CompiledCircuit;
+    /** Expected number of public inputs */
+    publicInputCount?: number;
+}
+/**
+ * Verification request.
+ */
+interface VerifyRequest {
+    /** Circuit name to verify against */
+    circuitName: string;
+    /** Proof bytes (hex string or Uint8Array) */
+    proof: string | Uint8Array;
+    /** Public inputs (numbers or hex strings) */
+    publicInputs: Array<number | bigint | string>;
+}
+/**
+ * Verification result.
+ */
+interface VerifyResult {
+    /** Whether the proof is valid */
+    verified: boolean;
+    /** Circuit name */
+    circuitName: string;
+    /** Verification time in milliseconds */
+    verificationTimeMs: number;
+    /** Error message if verification failed */
+    error?: string;
+    /** Public inputs that were verified */
+    publicInputs: Array<number | bigint | string>;
+}
+/**
+ * Configuration for OffchainVerifier.
+ */
+interface OffchainVerifierConfig {
+    /**
+     * Callback to compile a circuit.
+     * Required if registering circuits by jsCircuit without pre-compiled circuit.
+     */
+    compiler?: (jsCircuit: CircuitFunction) => Promise<CompiledCircuit>;
+    /**
+     * Callback to verify a proof against a compiled circuit.
+     */
+    verifier?: (circuit: CompiledCircuit, proof: Uint8Array, publicInputs: Uint8Array[]) => Promise<boolean>;
+}
+/**
+ * Express-like request interface.
+ */
+interface ExpressRequest {
+    body: {
+        circuitName?: string;
+        proof?: string | Uint8Array;
+        publicInputs?: Array<number | bigint | string>;
+    };
+}
+/**
+ * Express-like response interface.
+ */
+interface ExpressResponse {
+    status(code: number): ExpressResponse;
+    json(body: unknown): ExpressResponse;
+}
+/**
+ * Express-like next function.
+ */
+type ExpressNext = (err?: Error) => void;
+/**
+ * Off-chain ZK proof verifier.
+ *
+ * Manages registered circuits and provides proof verification
+ * without requiring blockchain transactions.
+ */
+declare class OffchainVerifier {
+    private circuits;
+    private compiledCircuits;
+    private config;
+    constructor(config?: OffchainVerifierConfig);
+    /**
+     * Registers a circuit for verification.
+     *
+     * @param name - Unique name for the circuit
+     * @param config - Circuit configuration
+     */
+    registerCircuit(name: string, config: OffchainCircuitConfig): Promise<void>;
+    /**
+     * Registers a pre-compiled circuit.
+     *
+     * @param name - Unique name for the circuit
+     * @param compiled - Pre-compiled circuit
+     */
+    registerCompiledCircuit(name: string, compiled: CompiledCircuit): void;
+    /**
+     * Verifies a ZK proof.
+     *
+     * @param request - Verification request with circuit name, proof, and public inputs
+     * @returns Verification result
+     */
+    verify(request: VerifyRequest): Promise<VerifyResult>;
+    /**
+     * Checks if a circuit is registered.
+     *
+     * @param name - Circuit name
+     */
+    hasCircuit(name: string): boolean;
+    /**
+     * Gets all registered circuit names.
+     */
+    getCircuitNames(): string[];
+    /**
+     * Removes a circuit from the verifier.
+     *
+     * @param name - Circuit name to remove
+     */
+    removeCircuit(name: string): boolean;
+    private toUint8Array;
+    private publicInputToBytes;
+}
+/**
+ * Creates an Express middleware for proof verification.
+ *
+ * @param verifier - The OffchainVerifier instance
+ * @returns Express middleware function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { OffchainVerifier, createVerifierMiddleware } from '@izi-noir/sdk';
+ *
+ * const app = express();
+ * const verifier = new OffchainVerifier({ ... });
+ *
+ * // Register your circuits
+ * await verifier.registerCircuit('my-circuit', { ... });
+ *
+ * // Add middleware
+ * app.use(express.json());
+ * app.post('/verify', createVerifierMiddleware(verifier));
+ *
+ * // Client sends:
+ * // POST /verify
+ * // { "circuitName": "my-circuit", "proof": "0x...", "publicInputs": [123, 456] }
+ *
+ * // Server responds:
+ * // { "verified": true, "circuitName": "my-circuit", "verificationTimeMs": 42 }
+ * ```
+ */
+declare function createVerifierMiddleware(verifier: OffchainVerifier): (req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => Promise<void>;
+/**
+ * Options for verification endpoint.
+ */
+interface VerificationEndpointOptions {
+    /** Custom path for the endpoint (default: '/verify') */
+    path?: string;
+    /** Rate limiting (requests per minute, 0 = unlimited) */
+    rateLimit?: number;
+    /** Required API key header */
+    apiKeyHeader?: string;
+    /** Allowed circuit names (empty = all) */
+    allowedCircuits?: string[];
+}
+/**
+ * Creates a verification endpoint configuration.
+ *
+ * This is a helper for setting up verification endpoints with
+ * common options like rate limiting and API key authentication.
+ *
+ * @example
+ * ```typescript
+ * const config = createVerificationEndpoint(verifier, {
+ *   path: '/api/v1/verify',
+ *   rateLimit: 100,
+ *   apiKeyHeader: 'X-API-Key',
+ *   allowedCircuits: ['balance-check', 'age-verify'],
+ * });
+ *
+ * // Use with Express
+ * app.post(config.path, config.middleware);
+ * ```
+ */
+declare function createVerificationEndpoint(verifier: OffchainVerifier, options?: VerificationEndpointOptions): {
+    path: string;
+    middleware: (req: ExpressRequest, res: ExpressResponse, next: ExpressNext) => Promise<void>;
+};
+/**
+ * Verification result for batch operations.
+ */
+interface BatchVerifyResult {
+    /** Results for each verification */
+    results: VerifyResult[];
+    /** Total time for all verifications */
+    totalTimeMs: number;
+    /** Number of verified proofs */
+    verifiedCount: number;
+    /** Number of failed verifications */
+    failedCount: number;
+}
+/**
+ * Batch verification extension for OffchainVerifier.
+ *
+ * @example
+ * ```typescript
+ * const results = await batchVerify(verifier, [
+ *   { circuitName: 'age-check', proof: proof1, publicInputs: [18] },
+ *   { circuitName: 'balance-check', proof: proof2, publicInputs: [100] },
+ * ]);
+ *
+ * console.log(`Verified: ${results.verifiedCount}/${results.results.length}`);
+ * ```
+ */
+declare function batchVerify(verifier: OffchainVerifier, requests: VerifyRequest[]): Promise<BatchVerifyResult>;
+
+export { AcornParser, ArkworksWasm, ArkworksWasmConfig, type AssertStatement, type BatchVerifyResult, type BinaryExpr, type BinaryOperator, type CircuitDefinition, type CircuitExportEntry, CircuitFunction, type CircuitInputDef, CircuitMetadata, type CircuitParam, CircuitRegistry, type CircuitRegistryExport, type CloseVkAccounts, type CreateProofDependencies, CreateProofUseCase, type DeploymentResult, type DeploymentsState, type EnsureDeployedOptions, type Expr, type GetCircuitOptions, IChainFormatter, type IParser, IProvingSystem, type IdentifierExpr, type InitAndVerifyInstructions, type InitVkAccounts, InputValue, type InstructionData, type LiteralExpr, type MemberExpr, NETWORK_ENDPOINTS, type OffchainCircuitConfig, OffchainVerifier, type OffchainVerifierConfig, type ParsedCircuit, ProofData, ProofResult, type RegisteredCircuit, type SignerInfo, SolanaChainMetadata, SolanaFormatter, type SolanaNetwork, SolanaProofData, SolanaTransactionBuilder, type Statement, type TransactionBuilderConfig, type VerificationEndpointOptions, type VerifyProofAccounts, type VerifyRequest, type VerifyResult, type VkDeployment, VkDeploymentManager, type VkDeploymentManagerConfig, batchVerify, createArkworksWasmContainer, createDefaultContainer, createNodeVkDeploymentManager, createVerificationEndpoint, createVerifierMiddleware, defineCircuit, generateNoir, getGlobalRegistry };