@enclave-e3/sdk 0.0.7-test

package/dist/index.d.ts

@@ -0,0 +1,712 @@
+import * as viem from 'viem';
+import { PublicClient, WalletClient, Log, Hash, Abi, TransactionReceipt, Address } from 'viem';
+import { ProofData } from '@aztec/bb.js';
+import { Enclave, CiphernodeRegistryOwnable, MockCiphernodeRegistry } from '@enclave-e3/contracts/types';
+import { CompiledCircuit } from '@noir-lang/noir_js';
+
+/**
+ * SDK configuration
+ */
+interface SDKConfig {
+    /**
+     * The public client to use to interact with the blockchain
+     */
+    publicClient: PublicClient;
+    /**
+     * The wallet client to use to send/sign transactions
+     */
+    walletClient?: WalletClient;
+    /**
+     * The Enclave contracts
+     */
+    contracts: {
+        /**
+         * The Enclave contract address
+         */
+        enclave: `0x${string}`;
+        /**
+         * The CiphernodeRegistry contract address
+         */
+        ciphernodeRegistry: `0x${string}`;
+    };
+    /**
+     * The chain ID to which the contracts are deployed
+     */
+    chainId?: number;
+    /**
+     * The protocol to use for the Enclave requests
+     */
+    protocol: FheProtocol;
+    /**
+     * The protocol parameters to use for the Enclave requests
+     */
+    protocolParams?: ProtocolParams;
+}
+interface EventListenerConfig {
+    fromBlock?: bigint;
+    toBlock?: bigint;
+    polling?: boolean;
+    pollingInterval?: number;
+}
+interface ContractInstances {
+    enclave: Enclave;
+    ciphernodeRegistry: CiphernodeRegistryOwnable | MockCiphernodeRegistry;
+}
+declare enum EnclaveEventType {
+    E3_REQUESTED = "E3Requested",
+    E3_ACTIVATED = "E3Activated",
+    INPUT_PUBLISHED = "InputPublished",
+    CIPHERTEXT_OUTPUT_PUBLISHED = "CiphertextOutputPublished",
+    PLAINTEXT_OUTPUT_PUBLISHED = "PlaintextOutputPublished",
+    E3_PROGRAM_ENABLED = "E3ProgramEnabled",
+    E3_PROGRAM_DISABLED = "E3ProgramDisabled",
+    ENCRYPTION_SCHEME_ENABLED = "EncryptionSchemeEnabled",
+    ENCRYPTION_SCHEME_DISABLED = "EncryptionSchemeDisabled",
+    CIPHERNODE_REGISTRY_SET = "CiphernodeRegistrySet",
+    MAX_DURATION_SET = "MaxDurationSet",
+    ALLOWED_E3_PROGRAMS_PARAMS_SET = "AllowedE3ProgramsParamsSet",
+    OWNERSHIP_TRANSFERRED = "OwnershipTransferred",
+    INITIALIZED = "Initialized"
+}
+declare enum RegistryEventType {
+    COMMITTEE_REQUESTED = "CommitteeRequested",
+    COMMITTEE_PUBLISHED = "CommitteePublished",
+    ENCLAVE_SET = "EnclaveSet",
+    OWNERSHIP_TRANSFERRED = "OwnershipTransferred",
+    INITIALIZED = "Initialized"
+}
+type AllEventTypes = EnclaveEventType | RegistryEventType;
+interface E3 {
+    seed: bigint;
+    threshold: readonly [number, number];
+    requestBlock: bigint;
+    startWindow: readonly [bigint, bigint];
+    duration: bigint;
+    expiration: bigint;
+    encryptionSchemeId: string;
+    e3Program: string;
+    e3ProgramParams: string;
+    inputValidator: string;
+    decryptionVerifier: string;
+    committeePublicKey: string;
+    ciphertextOutput: string;
+    plaintextOutput: string;
+}
+interface E3RequestedData {
+    e3Id: bigint;
+    e3: E3;
+    filter: string;
+    e3Program: string;
+}
+interface E3ActivatedData {
+    e3Id: bigint;
+    expiration: bigint;
+    committeePublicKey: string;
+}
+interface InputPublishedData {
+    e3Id: bigint;
+    data: string;
+    inputHash: bigint;
+    index: bigint;
+}
+interface CiphertextOutputPublishedData {
+    e3Id: bigint;
+    ciphertextOutput: string;
+}
+interface PlaintextOutputPublishedData {
+    e3Id: bigint;
+    plaintextOutput: string;
+}
+interface CiphernodeAddedData {
+    node: string;
+    index: bigint;
+    numNodes: bigint;
+    size: bigint;
+}
+interface CiphernodeRemovedData {
+    node: string;
+    index: bigint;
+    numNodes: bigint;
+    size: bigint;
+}
+interface CommitteeRequestedData {
+    e3Id: bigint;
+    filter: string;
+    threshold: [bigint, bigint];
+}
+interface CommitteePublishedData {
+    e3Id: bigint;
+    publicKey: string;
+}
+interface EnclaveEventData {
+    [EnclaveEventType.E3_REQUESTED]: E3RequestedData;
+    [EnclaveEventType.E3_ACTIVATED]: E3ActivatedData;
+    [EnclaveEventType.INPUT_PUBLISHED]: InputPublishedData;
+    [EnclaveEventType.CIPHERTEXT_OUTPUT_PUBLISHED]: CiphertextOutputPublishedData;
+    [EnclaveEventType.PLAINTEXT_OUTPUT_PUBLISHED]: PlaintextOutputPublishedData;
+    [EnclaveEventType.E3_PROGRAM_ENABLED]: {
+        e3Program: string;
+    };
+    [EnclaveEventType.E3_PROGRAM_DISABLED]: {
+        e3Program: string;
+    };
+    [EnclaveEventType.ENCRYPTION_SCHEME_ENABLED]: {
+        encryptionSchemeId: string;
+    };
+    [EnclaveEventType.ENCRYPTION_SCHEME_DISABLED]: {
+        encryptionSchemeId: string;
+    };
+    [EnclaveEventType.CIPHERNODE_REGISTRY_SET]: {
+        ciphernodeRegistry: string;
+    };
+    [EnclaveEventType.MAX_DURATION_SET]: {
+        maxDuration: bigint;
+    };
+    [EnclaveEventType.ALLOWED_E3_PROGRAMS_PARAMS_SET]: {
+        e3ProgramParams: string[];
+    };
+    [EnclaveEventType.OWNERSHIP_TRANSFERRED]: {
+        previousOwner: string;
+        newOwner: string;
+    };
+    [EnclaveEventType.INITIALIZED]: {
+        version: bigint;
+    };
+}
+interface RegistryEventData {
+    [RegistryEventType.COMMITTEE_REQUESTED]: CommitteeRequestedData;
+    [RegistryEventType.COMMITTEE_PUBLISHED]: CommitteePublishedData;
+    [RegistryEventType.ENCLAVE_SET]: {
+        enclave: string;
+    };
+    [RegistryEventType.OWNERSHIP_TRANSFERRED]: {
+        previousOwner: string;
+        newOwner: string;
+    };
+    [RegistryEventType.INITIALIZED]: {
+        version: bigint;
+    };
+}
+interface EnclaveEvent<T extends AllEventTypes> {
+    type: T;
+    data: T extends EnclaveEventType ? EnclaveEventData[T] : T extends RegistryEventType ? RegistryEventData[T] : unknown;
+    log: Log;
+    timestamp: Date;
+    blockNumber: bigint;
+    transactionHash: string;
+}
+type EventCallback<T extends AllEventTypes = AllEventTypes> = (event: EnclaveEvent<T>) => void | Promise<void>;
+interface EventFilter<T = unknown> {
+    address?: `0x${string}`;
+    fromBlock?: bigint;
+    toBlock?: bigint;
+    args?: Partial<T>;
+}
+interface SDKEventEmitter {
+    on<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    off<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    emit<T extends AllEventTypes>(event: EnclaveEvent<T>): void;
+}
+/**
+ * Result of verifiable encryption using BFV
+ */
+interface VerifiableEncryptionResult {
+    /**
+     * The encrypted vote
+     */
+    encryptedVote: Uint8Array;
+    /**
+     * The proof generated by Greco
+     */
+    proof: ProofData;
+}
+/**
+ * The protocol to use for the Enclave requests
+ */
+declare enum FheProtocol {
+    /**
+     * The BFV protocol
+     */
+    BFV = "BFV"
+}
+/**
+ * Protocol parameters for an Enclave program request
+ * Example for BFV
+ *   2048,               // degree
+ *   1032193,            // plaintext_modulus
+ *   0x3FFFFFFF000001,   // moduli
+ */
+interface ProtocolParams {
+    /**
+     * The degree of the polynomial
+     */
+    degree: number;
+    /**
+     * The plaintext modulus
+     */
+    plaintextModulus: bigint;
+    /**
+     * The moduli
+     */
+    moduli: bigint;
+}
+/**
+ * Parameters for the BFV protocol
+ */
+declare const BfvProtocolParams: {
+    /**
+       * Recommended parameters for BFV protocol
+       * - Degree: 2048
+       * - Plaintext modulus: 1032193
+       * - Moduli:0x3FFFFFFF000001
+       */
+    BFV_NORMAL: {
+        readonly degree: 2048;
+        readonly plaintextModulus: 1032193n;
+        readonly moduli: 18014398492704769n;
+    };
+};
+
+declare class EnclaveSDK {
+    private config;
+    static readonly chains: {
+        readonly 1: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            contracts: {
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+                    readonly blockCreated: 19258213;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://eth.merkle.io"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+        };
+        readonly 11155111: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://sepolia.etherscan.io";
+                    readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 751532;
+                };
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+                    readonly blockCreated: 5317080;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 11155111;
+            name: "Sepolia";
+            nativeCurrency: {
+                readonly name: "Sepolia Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://sepolia.drpc.org"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: true;
+            custom?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+        };
+        readonly 41454: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Monad Testnet explorer";
+                    readonly url: "https://testnet.monadexplorer.com";
+                };
+            };
+            contracts: {
+                readonly multicall3: {
+                    readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                    readonly blockCreated: 251449;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 10143;
+            name: "Monad Testnet";
+            nativeCurrency: {
+                readonly name: "Testnet MON Token";
+                readonly symbol: "MON";
+                readonly decimals: 18;
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://testnet-rpc.monad.xyz"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet: true;
+            custom?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+        };
+        readonly 31337: {
+            blockExplorers?: {
+                [key: string]: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+                default: {
+                    name: string;
+                    url: string;
+                    apiUrl?: string | undefined;
+                };
+            } | undefined | undefined;
+            contracts?: {
+                [x: string]: viem.ChainContract | {
+                    [sourceId: number]: viem.ChainContract | undefined;
+                } | undefined;
+                ensRegistry?: viem.ChainContract | undefined;
+                ensUniversalResolver?: viem.ChainContract | undefined;
+                multicall3?: viem.ChainContract | undefined;
+                universalSignatureVerifier?: viem.ChainContract | undefined;
+            } | undefined;
+            ensTlds?: readonly string[] | undefined;
+            id: 31337;
+            name: "Hardhat";
+            nativeCurrency: {
+                readonly decimals: 18;
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+            };
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["http://127.0.0.1:8545"];
+                };
+            };
+            sourceId?: number | undefined | undefined;
+            testnet?: boolean | undefined | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: viem.ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+        };
+    };
+    private eventListener;
+    private contractClient;
+    private initialized;
+    private protocol;
+    private protocolParams;
+    constructor(config: SDKConfig);
+    /**
+     * Initialize the SDK
+     */
+    initialize(): Promise<void>;
+    /**
+     * Encrypt a number using the configured protocol
+     * @param data - The number to encrypt
+     * @param publicKey - The public key to use for encryption
+     * @returns The encrypted number
+     */
+    encryptNumber(data: bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt a number using the configured protocol and generate a zk-SNARK proof using Greco
+     * @param data - The number to encrypt
+     * @param publicKey - The public key to use for encryption
+     * @param circuit - The circuit to use for proof generation
+     * @returns The encrypted number and the proof
+     */
+    encryptNumberAndGenProof(data: bigint, publicKey: Uint8Array, circuit: CompiledCircuit): Promise<VerifiableEncryptionResult>;
+    /**
+     * Request a new E3 computation
+     */
+    requestE3(params: {
+        filter: `0x${string}`;
+        threshold: [number, number];
+        startWindow: [bigint, bigint];
+        duration: bigint;
+        e3Program: `0x${string}`;
+        e3ProgramParams: `0x${string}`;
+        computeProviderParams: `0x${string}`;
+        value?: bigint;
+        gasLimit?: bigint;
+    }): Promise<Hash>;
+    /**
+     * Activate an E3 computation
+     */
+    activateE3(e3Id: bigint, publicKey: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Publish input for an E3 computation
+     */
+    publishInput(e3Id: bigint, data: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Publish ciphertext output for an E3 computation
+     */
+    publishCiphertextOutput(e3Id: bigint, ciphertextOutput: `0x${string}`, proof: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Get E3 information
+     */
+    getE3(e3Id: bigint): Promise<E3>;
+    /**
+     * Unified Event Listening - Listen to any Enclave or Registry event
+     */
+    onEnclaveEvent<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    /**
+     * Remove event listener
+     */
+    off<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    /**
+     * Handle an event only once
+     */
+    once<T extends AllEventTypes>(type: T, callback: EventCallback<T>): void;
+    /**
+     * Get historical events
+     */
+    getHistoricalEvents(eventType: AllEventTypes, fromBlock?: bigint, toBlock?: bigint): Promise<Log[]>;
+    /**
+     * Start polling for events
+     */
+    startEventPolling(): Promise<void>;
+    /**
+     * Stop polling for events
+     */
+    stopEventPolling(): void;
+    /**
+     * Utility methods
+     */
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas(functionName: string, args: readonly unknown[], contractAddress: `0x${string}`, abi: Abi, value?: bigint): Promise<bigint>;
+    /**
+     * Wait for transaction confirmation
+     */
+    waitForTransaction(hash: Hash): Promise<unknown>;
+    /**
+     * Clean up resources
+     */
+    cleanup(): void;
+    /**
+     * Update SDK configuration
+     */
+    updateConfig(newConfig: Partial<SDKConfig>): void;
+    static create(options: {
+        rpcUrl: string;
+        contracts: {
+            enclave: `0x${string}`;
+            ciphernodeRegistry: `0x${string}`;
+        };
+        privateKey?: `0x${string}`;
+        chainId: keyof typeof EnclaveSDK.chains;
+        protocol: FheProtocol;
+        protocolParams?: ProtocolParams;
+    }): EnclaveSDK;
+}
+
+declare class EventListener implements SDKEventEmitter {
+    private publicClient;
+    private config;
+    private listeners;
+    private activeWatchers;
+    private isPolling;
+    private lastBlockNumber;
+    constructor(publicClient: PublicClient, config?: EventListenerConfig);
+    /**
+     * Listen to specific contract events
+     */
+    watchContractEvent<T extends AllEventTypes>(address: `0x${string}`, eventType: T, abi: Abi, callback: EventCallback<T>): Promise<void>;
+    /**
+     * Listen to all logs from a specific address
+     */
+    watchLogs(address: `0x${string}`, callback: (log: Log) => void): Promise<void>;
+    /**
+     * Start polling for historical events
+     */
+    startPolling(): Promise<void>;
+    /**
+     * Stop polling for events
+     */
+    stopPolling(): void;
+    /**
+     * Get historical events
+     */
+    getHistoricalEvents(address: `0x${string}`, eventType: AllEventTypes, abi: Abi, fromBlock?: bigint, toBlock?: bigint): Promise<Log[]>;
+    /**
+     * SDKEventEmitter implementation
+     */
+    on<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    off<T extends AllEventTypes>(eventType: T, callback: EventCallback<T>): void;
+    emit<T extends AllEventTypes>(event: EnclaveEvent<T>): void;
+    /**
+     * Clean up all listeners and watchers
+     */
+    cleanup(): void;
+    private pollForEvents;
+}
+
+declare class ContractClient {
+    private publicClient;
+    private walletClient?;
+    private addresses;
+    private contractInfo;
+    constructor(publicClient: PublicClient, walletClient?: WalletClient | undefined, addresses?: {
+        enclave: `0x${string}`;
+        ciphernodeRegistry: `0x${string}`;
+    });
+    /**
+     * Initialize contract instances
+     */
+    initialize(): Promise<void>;
+    /**
+     * Request a new E3 computation
+     * request(address filter, uint32[2] threshold, uint256[2] startWindow, uint256 duration, IE3Program e3Program, bytes e3ProgramParams, bytes computeProviderParams)
+     */
+    requestE3(filter: `0x${string}`, threshold: [number, number], startWindow: [bigint, bigint], duration: bigint, e3Program: `0x${string}`, e3ProgramParams: `0x${string}`, computeProviderParams: `0x${string}`, value?: bigint, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Activate an E3 computation
+     * activate(uint256 e3Id, bytes memory publicKey)
+     */
+    activateE3(e3Id: bigint, publicKey: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Publish input for an E3 computation
+     * publishInput(uint256 e3Id, bytes memory data)
+     */
+    publishInput(e3Id: bigint, data: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Publish ciphertext output for an E3 computation
+     * publishCiphertextOutput(uint256 e3Id, bytes memory ciphertextOutput, bytes memory proof)
+     */
+    publishCiphertextOutput(e3Id: bigint, ciphertextOutput: `0x${string}`, proof: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    /**
+     * Get E3 information
+     * Based on the contract: getE3(uint256 e3Id) returns (E3 memory e3)
+     */
+    getE3(e3Id: bigint): Promise<E3>;
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas(functionName: string, args: readonly unknown[], contractAddress: `0x${string}`, abi: Abi, value?: bigint): Promise<bigint>;
+    /**
+     * Wait for transaction confirmation
+     */
+    waitForTransaction(hash: Hash): Promise<TransactionReceipt>;
+}
+
+declare class SDKError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare function isValidAddress(address: string): address is Address;
+declare function isValidHash(hash: string): hash is Hash;
+declare function formatEventName(contractName: string, eventName: string): string;
+declare function parseEventData<T>(log: Log): T;
+/**
+ * Sleep for a specified number of milliseconds
+ */
+declare const sleep: (ms: number) => Promise<void>;
+declare function formatBigInt(value: bigint): string;
+declare function parseBigInt(value: string): bigint;
+declare function generateEventId(log: Log): string;
+/**
+ * Get the current timestamp in seconds
+ */
+declare function getCurrentTimestamp(): number;
+declare const BFV_PARAMS_SET: {
+    readonly degree: 2048;
+    readonly plaintext_modulus: 1032193;
+    readonly moduli: readonly [18014398492704769n];
+};
+interface ComputeProviderParams {
+    name: string;
+    parallel: boolean;
+    batch_size: number;
+}
+declare const DEFAULT_COMPUTE_PROVIDER_PARAMS: ComputeProviderParams;
+declare const DEFAULT_E3_CONFIG: {
+    readonly threshold_min: 2;
+    readonly threshold_max: 3;
+    readonly window_size: 120;
+    readonly duration: 1800;
+    readonly payment_amount: "0";
+};
+/**
+ * Encode BFV parameters for the smart contract
+ * BFV (Brakerski-Fan-Vercauteren) is a type of fully homomorphic encryption
+ */
+declare function encodeBfvParams(degree?: number, plaintext_modulus?: number, moduli?: readonly bigint[]): `0x${string}`;
+/**
+ * Encode compute provider parameters for the smart contract
+ */
+declare function encodeComputeProviderParams(params: ComputeProviderParams): `0x${string}`;
+/**
+ * Calculate start window for E3 request
+ */
+declare function calculateStartWindow(windowSize?: number): [bigint, bigint];
+/**
+ * Decode plaintextOutput bytes to get the actual result number
+ */
+declare function decodePlaintextOutput(plaintextOutput: string): number | null;
+
+/**
+ * Describes the inputs to Greco circuit
+ */
+interface CircuitInputs {
+    pk0is: string[][];
+    pk1is: string[][];
+    ct0is: string[][];
+    ct1is: string[][];
+    u: string[];
+    e0: string[];
+    e1: string[];
+    k1: string[];
+    r1is: string[][];
+    r2is: string[][];
+    p1is: string[][];
+    p2is: string[][];
+}
+/**
+ * Generate a proof for a given circuit and circuit inputs
+ * @dev Defaults to the UltraHonkBackend
+ * @param circuitInputs - The circuit inputs
+ * @param circuit - The circuit
+ * @returns The proof
+ */
+declare const generateProof: (circuitInputs: CircuitInputs, circuit: CompiledCircuit) => Promise<ProofData>;
+
+export { type AllEventTypes, BFV_PARAMS_SET, BfvProtocolParams, type CiphernodeAddedData, type CiphernodeRemovedData, type CiphertextOutputPublishedData, type CommitteePublishedData, type CommitteeRequestedData, type ComputeProviderParams, ContractClient, type ContractInstances, DEFAULT_COMPUTE_PROVIDER_PARAMS, DEFAULT_E3_CONFIG, type E3, type E3ActivatedData, type E3RequestedData, type EnclaveEvent, type EnclaveEventData, EnclaveEventType, EnclaveSDK, type EventCallback, type EventFilter, EventListener, type EventListenerConfig, FheProtocol, type InputPublishedData, type PlaintextOutputPublishedData, type ProtocolParams, type RegistryEventData, RegistryEventType, type SDKConfig, SDKError, type SDKEventEmitter, type VerifiableEncryptionResult, calculateStartWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, formatBigInt, formatEventName, generateEventId, generateProof, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };