@enclave-e3/sdk 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,9 +1,55 @@
 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 { Enclave, CiphernodeRegistryOwnable, MockCiphernodeRegistry, EnclaveToken, MockUSDC } from '@enclave-e3/contracts/types';
 import { CompiledCircuit } from '@noir-lang/noir_js';
 
+type Field = string;
+/**
+ * Describes a polynomial to be used in a Noir circuit (Greco)
+ */
+type Polynomial = {
+    coefficients: Field[];
+};
+/**
+ * Describes the inputs to Greco circuit
+ */
+interface CircuitInputs {
+    pk0is: string[][];
+    pk1is: string[][];
+    ct0is: string[][];
+    ct1is: string[][];
+    u: string[];
+    e0: string[];
+    e1: string[];
+    e0is: string[][];
+    k1: string[];
+    r1is: string[][];
+    r2is: string[][];
+    p1is: string[][];
+    p2is: string[][];
+}
+/**
+ * Convert a string array to a polynomial
+ * @param stringArray - The string array
+ * @returns The polynomial
+ */
+declare const convertToPolynomial: (stringArray: string[]) => Polynomial;
+/**
+ * Convert an array of string arrays to an array of polynomials
+ * @param stringArrays - The array of string arrays
+ * @returns The array of polynomials
+ */
+declare const convertToPolynomialArray: (stringArrays: string[][]) => Polynomial[];
+/**
+ * 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>;
+
 /**
  * SDK configuration
  */
@@ -28,6 +74,10 @@ interface SDKConfig {
          * The CiphernodeRegistry contract address
          */
         ciphernodeRegistry: `0x${string}`;
+        /**
+         * The FeeToken contract address
+         */
+        feeToken: `0x${string}`;
     };
     /**
      * The chain ID to which the contracts are deployed
@@ -51,11 +101,11 @@ interface EventListenerConfig {
 interface ContractInstances {
     enclave: Enclave;
     ciphernodeRegistry: CiphernodeRegistryOwnable | MockCiphernodeRegistry;
+    feeToken: EnclaveToken | MockUSDC;
 }
 declare enum EnclaveEventType {
     E3_REQUESTED = "E3Requested",
     E3_ACTIVATED = "E3Activated",
-    INPUT_PUBLISHED = "InputPublished",
     CIPHERTEXT_OUTPUT_PUBLISHED = "CiphertextOutputPublished",
     PLAINTEXT_OUTPUT_PUBLISHED = "PlaintextOutputPublished",
     E3_PROGRAM_ENABLED = "E3ProgramEnabled",
@@ -71,6 +121,7 @@ declare enum EnclaveEventType {
 declare enum RegistryEventType {
     COMMITTEE_REQUESTED = "CommitteeRequested",
     COMMITTEE_PUBLISHED = "CommitteePublished",
+    COMMITTEE_FINALIZED = "CommitteeFinalized",
     ENCLAVE_SET = "EnclaveSet",
     OWNERSHIP_TRANSFERRED = "OwnershipTransferred",
     INITIALIZED = "Initialized"
@@ -86,7 +137,6 @@ interface E3 {
     encryptionSchemeId: string;
     e3Program: string;
     e3ProgramParams: string;
-    inputValidator: string;
     decryptionVerifier: string;
     committeePublicKey: string;
     ciphertextOutput: string;
@@ -103,12 +153,6 @@ interface E3ActivatedData {
     expiration: bigint;
     committeePublicKey: string;
 }
-interface InputPublishedData {
-    e3Id: bigint;
-    data: string;
-    inputHash: bigint;
-    index: bigint;
-}
 interface CiphertextOutputPublishedData {
     e3Id: bigint;
     ciphertextOutput: string;
@@ -131,17 +175,22 @@ interface CiphernodeRemovedData {
 }
 interface CommitteeRequestedData {
     e3Id: bigint;
-    filter: string;
+    seed: bigint;
     threshold: [bigint, bigint];
+    requestBlock: bigint;
+    submissionDeadline: bigint;
 }
 interface CommitteePublishedData {
     e3Id: bigint;
     publicKey: string;
 }
+interface CommitteeFinalizedData {
+    e3Id: bigint;
+    nodes: 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]: {
@@ -176,6 +225,7 @@ interface EnclaveEventData {
 interface RegistryEventData {
     [RegistryEventType.COMMITTEE_REQUESTED]: CommitteeRequestedData;
     [RegistryEventType.COMMITTEE_PUBLISHED]: CommitteePublishedData;
+    [RegistryEventType.COMMITTEE_FINALIZED]: CommitteeFinalizedData;
     [RegistryEventType.ENCLAVE_SET]: {
         enclave: string;
     };
@@ -212,9 +262,9 @@ interface SDKEventEmitter {
  */
 interface VerifiableEncryptionResult {
     /**
-     * The encrypted vote
+     * The encrypted data
      */
-    encryptedVote: Uint8Array;
+    encryptedData: Uint8Array;
     /**
      * The proof generated by Greco
      */
@@ -227,7 +277,11 @@ declare enum FheProtocol {
     /**
      * The BFV protocol
      */
-    BFV = "BFV"
+    BFV = "BFV",
+    /**
+     * The TrBFV protocol
+     */
+    TRBFV = "TRBFV"
 }
 /**
  * Protocol parameters for an Enclave program request
@@ -248,24 +302,55 @@ interface ProtocolParams {
     /**
      * The moduli
      */
-    moduli: bigint;
+    moduli: bigint[];
+    /**
+     * error1
+     */
+    error1Variance: string | undefined;
 }
+type ProtocolParamsName = 'INSECURE_SET_2048_1032193_1' | 'INSECURE_SET_512_10_1' | 'INSECURE_SET_512_0XFFFFEE001_1' | 'SET_8192_1000_4' | 'SET_8192_144115188075855872_2';
 /**
  * Parameters for the BFV protocol
  */
 declare const BfvProtocolParams: {
     /**
-       * Recommended parameters for BFV protocol
-       * - Degree: 2048
-       * - Plaintext modulus: 1032193
-       * - Moduli:0x3FFFFFFF000001
-       */
+     * Recommended parameters for BFV protocol
+     * - Degree: 2048
+     * - Plaintext modulus: 1032193
+     * - Moduli:0x3FFFFFFF000001
+     */
     BFV_NORMAL: {
         readonly degree: 2048;
         readonly plaintextModulus: 1032193n;
-        readonly moduli: 18014398492704769n;
+        readonly moduli: [18014398492704769n];
+        readonly error1Variance: "10";
+    };
+    /**
+     * Recommended parameters for TrBFV protocol
+     * - Degree: 8192
+     * - Plaintext modulus: 1000
+     * - Moduli: [0x00800000022a0001, 0x00800000021a0001, 0x0080000002120001, 0x0080000001f60001]
+     */
+    BFV_THRESHOLD: {
+        readonly degree: 8192;
+        readonly plaintextModulus: 1000n;
+        readonly moduli: [36028797055270913n, 36028797054222337n, 36028797053698049n, 36028797051863041n];
+        readonly error1Variance: "10";
     };
 };
+/**
+ * The result of encrypting a value and generating a proof
+ */
+interface EncryptedValueAndPublicInputs {
+    /**
+     * The encrypted data
+     */
+    encryptedData: Uint8Array;
+    /**
+     * The public inputs for the proof
+     */
+    publicInputs: CircuitInputs;
+}
 
 declare class EnclaveSDK {
     private config;
@@ -278,13 +363,11 @@ declare class EnclaveSDK {
                     readonly apiUrl: "https://api.etherscan.io/api";
                 };
             };
+            blockTime: 12000;
             contracts: {
-                readonly ensRegistry: {
-                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-                };
                 readonly ensUniversalResolver: {
-                    readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
-                    readonly blockCreated: 19258213;
+                    readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                    readonly blockCreated: 23085558;
                 };
                 readonly multicall3: {
                     readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
@@ -299,6 +382,7 @@ declare class EnclaveSDK {
                 readonly symbol: "ETH";
                 readonly decimals: 18;
             };
+            experimental_preconfirmationTime?: number | undefined | undefined;
             rpcUrls: {
                 readonly default: {
                     readonly http: readonly ["https://eth.merkle.io"];
@@ -319,17 +403,15 @@ declare class EnclaveSDK {
                     readonly apiUrl: "https://api-sepolia.etherscan.io/api";
                 };
             };
+            blockTime?: number | undefined | undefined;
             contracts: {
                 readonly multicall3: {
                     readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
                     readonly blockCreated: 751532;
                 };
-                readonly ensRegistry: {
-                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
-                };
                 readonly ensUniversalResolver: {
-                    readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
-                    readonly blockCreated: 5317080;
+                    readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                    readonly blockCreated: 8928790;
                 };
             };
             ensTlds?: readonly string[] | undefined;
@@ -340,9 +422,10 @@ declare class EnclaveSDK {
                 readonly symbol: "ETH";
                 readonly decimals: 18;
             };
+            experimental_preconfirmationTime?: number | undefined | undefined;
             rpcUrls: {
                 readonly default: {
-                    readonly http: readonly ["https://sepolia.drpc.org"];
+                    readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
                 };
             };
             sourceId?: number | undefined | undefined;
@@ -359,6 +442,7 @@ declare class EnclaveSDK {
                     readonly url: "https://testnet.monadexplorer.com";
                 };
             };
+            blockTime: 400;
             contracts: {
                 readonly multicall3: {
                     readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
@@ -373,6 +457,7 @@ declare class EnclaveSDK {
                 readonly symbol: "MON";
                 readonly decimals: 18;
             };
+            experimental_preconfirmationTime?: number | undefined | undefined;
             rpcUrls: {
                 readonly default: {
                     readonly http: readonly ["https://testnet-rpc.monad.xyz"];
@@ -398,6 +483,7 @@ declare class EnclaveSDK {
                     apiUrl?: string | undefined;
                 };
             } | undefined | undefined;
+            blockTime?: number | undefined | undefined;
             contracts?: {
                 [x: string]: viem.ChainContract | {
                     [sourceId: number]: viem.ChainContract | undefined;
@@ -405,7 +491,7 @@ declare class EnclaveSDK {
                 ensRegistry?: viem.ChainContract | undefined;
                 ensUniversalResolver?: viem.ChainContract | undefined;
                 multicall3?: viem.ChainContract | undefined;
-                universalSignatureVerifier?: viem.ChainContract | undefined;
+                erc6492Verifier?: viem.ChainContract | undefined;
             } | undefined;
             ensTlds?: readonly string[] | undefined;
             id: 31337;
@@ -415,6 +501,7 @@ declare class EnclaveSDK {
                 readonly name: "Ether";
                 readonly symbol: "ETH";
             };
+            experimental_preconfirmationTime?: number | undefined | undefined;
             rpcUrls: {
                 readonly default: {
                     readonly http: readonly ["http://127.0.0.1:8545"];
@@ -432,12 +519,20 @@ declare class EnclaveSDK {
     private contractClient;
     private initialized;
     private protocol;
-    private protocolParams;
+    private protocolParams?;
+    private publicClient;
     constructor(config: SDKConfig);
     /**
      * Initialize the SDK
      */
     initialize(): Promise<void>;
+    /**
+     * Get the public client used by the SDK
+     * @returns The public client
+     */
+    getPublicClient: () => PublicClient;
+    getBfvParamsSet(name: ProtocolParamsName): Promise<ProtocolParams>;
+    getProtocolParams(): Promise<ProtocolParams>;
     /**
      * Encrypt a number using the configured protocol
      * @param data - The number to encrypt
@@ -445,6 +540,21 @@ declare class EnclaveSDK {
      * @returns The encrypted number
      */
     encryptNumber(data: bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt a vector using the configured protocol
+     * @param data - The vector to encrypt
+     * @param publicKey - The public key to use for encryption
+     * @returns The ciphertext
+     */
+    encryptVector(data: BigUint64Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    /**
+     * This function encrypts a number using the configured FHE protocol
+     * and generates the necessary public inputs for a zk-SNARK proof.
+     * @param data The number to encrypt
+     * @param publicKey The public key to use for encryption
+     * @returns The encrypted number and the inputs for the zk-SNARK proof
+     */
+    encryptNumberAndGenInputs(data: bigint, publicKey: Uint8Array): Promise<EncryptedValueAndPublicInputs>;
     /**
      * Encrypt a number using the configured protocol and generate a zk-SNARK proof using Greco
      * @param data - The number to encrypt
@@ -453,18 +563,38 @@ declare class EnclaveSDK {
      * @returns The encrypted number and the proof
      */
     encryptNumberAndGenProof(data: bigint, publicKey: Uint8Array, circuit: CompiledCircuit): Promise<VerifiableEncryptionResult>;
+    /**
+     * Encrypt a vector and generate inputs for an E3 computation
+     * @param data - The vector to encrypt
+     * @param publicKey - The public key to use for encryption
+     * @returns The encrypted vector and the inputs for the E3 computation
+     */
+    encryptVectorAndGenInputs(data: BigUint64Array, publicKey: Uint8Array): Promise<EncryptedValueAndPublicInputs>;
+    /**
+     * Encrypt a vector using the configured protocol and generate a zk-SNARK proof using Greco
+     * @param data - The vector to encrypt
+     * @param publicKey - The public key to use for encryption
+     * @param circuit - The circuit to use for proof generation
+     * @returns The encrypted vector and the proof
+     */
+    encryptVectorAndGenProof(data: BigUint64Array, publicKey: Uint8Array, circuit: CompiledCircuit): Promise<VerifiableEncryptionResult>;
+    /**
+     * Approve the fee token for the Enclave
+     * @param amount - The amount to approve
+     * @returns The approval transaction hash
+     */
+    approveFeeToken(amount: bigint): Promise<Hash>;
     /**
      * 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;
+        customParams?: `0x${string}`;
         gasLimit?: bigint;
     }): Promise<Hash>;
     /**
@@ -537,6 +667,7 @@ declare class EnclaveSDK {
         contracts: {
             enclave: `0x${string}`;
             ciphernodeRegistry: `0x${string}`;
+            feeToken: `0x${string}`;
         };
         privateKey?: `0x${string}`;
         chainId: keyof typeof EnclaveSDK.chains;
@@ -594,16 +725,22 @@ declare class ContractClient {
     constructor(publicClient: PublicClient, walletClient?: WalletClient | undefined, addresses?: {
         enclave: `0x${string}`;
         ciphernodeRegistry: `0x${string}`;
+        feeToken: `0x${string}`;
     });
     /**
      * Initialize contract instances
      */
     initialize(): Promise<void>;
+    /**
+     * Approve the fee token for the Enclave
+     * approve(address spender, uint256 amount)
+     */
+    approveFeeToken(amount: bigint): Promise<Hash>;
     /**
      * Request a new E3 computation
-     * request(address filter, uint32[2] threshold, uint256[2] startWindow, uint256 duration, IE3Program e3Program, bytes e3ProgramParams, bytes computeProviderParams)
+     * request(address filter, uint32[2] threshold, uint256[2] startWindow, uint256 duration, IE3Program e3Program, bytes e3ProgramParams, bytes computeProviderParams, bytes customParams)
      */
-    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>;
+    requestE3(threshold: [number, number], startWindow: [bigint, bigint], duration: bigint, e3Program: `0x${string}`, e3ProgramParams: `0x${string}`, computeProviderParams: `0x${string}`, customParams?: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
     /**
      * Activate an E3 computation
      * activate(uint256 e3Id, bytes memory publicKey)
@@ -664,6 +801,7 @@ declare const BFV_PARAMS_SET: {
     readonly degree: 2048;
     readonly plaintext_modulus: 1032193;
     readonly moduli: readonly [18014398492704769n];
+    readonly error1_variance: "10";
 };
 interface ComputeProviderParams {
     name: string;
@@ -673,7 +811,7 @@ interface ComputeProviderParams {
 declare const DEFAULT_COMPUTE_PROVIDER_PARAMS: ComputeProviderParams;
 declare const DEFAULT_E3_CONFIG: {
     readonly threshold_min: 2;
-    readonly threshold_max: 3;
+    readonly threshold_max: 5;
     readonly window_size: 120;
     readonly duration: 1800;
     readonly payment_amount: "0";
@@ -682,11 +820,16 @@ declare const DEFAULT_E3_CONFIG: {
  * 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}`;
+declare function encodeBfvParams(degree?: number, plaintext_modulus?: number, moduli?: readonly bigint[], error1_variance?: string): `0x${string}`;
+/**
+ * Encode compute provider parameters for the smart contract'
+ * If mock is true, the compute provider parameters will return 32 bytes of 0x00
+ */
+declare function encodeComputeProviderParams(params: ComputeProviderParams, mock?: boolean): `0x${string}`;
 /**
- * Encode compute provider parameters for the smart contract
+ * Encode custom parameters for the smart contract.
  */
-declare function encodeComputeProviderParams(params: ComputeProviderParams): `0x${string}`;
+declare function encodeCustomParams(params: Record<string, unknown>): `0x${string}`;
 /**
  * Calculate start window for E3 request
  */
@@ -696,30 +839,4 @@ declare function calculateStartWindow(windowSize?: number): [bigint, bigint];
  */
 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 };
+export { type AllEventTypes, BFV_PARAMS_SET, BfvProtocolParams, type CiphernodeAddedData, type CiphernodeRemovedData, type CiphertextOutputPublishedData, type CommitteeFinalizedData, 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 EncryptedValueAndPublicInputs, type EventCallback, type EventFilter, EventListener, type EventListenerConfig, FheProtocol, type PlaintextOutputPublishedData, type Polynomial, type ProtocolParams, type RegistryEventData, RegistryEventType, type SDKConfig, SDKError, type SDKEventEmitter, type VerifiableEncryptionResult, calculateStartWindow, convertToPolynomial, convertToPolynomialArray, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, generateProof, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };