@enclave-e3/sdk 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -23,24 +23,14 @@ interface CircuitInputs {
     e0: string[];
     e1: string[];
     e0is: string[][];
+    e0_quotients: string[][];
     k1: string[];
     r1is: string[][];
     r2is: string[][];
     p1is: string[][];
     p2is: string[][];
+    pk_commitment: 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
@@ -84,13 +74,9 @@ interface SDKConfig {
      */
     chainId?: number;
     /**
-     * The protocol to use for the Enclave requests
-     */
-    protocol: FheProtocol;
-    /**
-     * The protocol parameters to use for the Enclave requests
+     * The threshold BFV parameters preset name to use for the Enclave requests
      */
-    protocolParams?: ProtocolParams;
+    thresholdBfvParamsPresetName: ThresholdBfvParamsPresetName;
 }
 interface EventListenerConfig {
     fromBlock?: bigint;
@@ -271,26 +257,14 @@ interface VerifiableEncryptionResult {
     proof: ProofData;
 }
 /**
- * The protocol to use for the Enclave requests
- */
-declare enum FheProtocol {
-    /**
-     * The BFV protocol
-     */
-    BFV = "BFV",
-    /**
-     * The TrBFV protocol
-     */
-    TRBFV = "TRBFV"
-}
-/**
- * Protocol parameters for an Enclave program request
+ * BFV parameters for an Enclave program request
  * Example for BFV
- *   2048,               // degree
- *   1032193,            // plaintext_modulus
- *   0x3FFFFFFF000001,   // moduli
+ *   512,           // degree
+ *   10,            // plaintext_modulus
+ *   0xffffee001,   // moduli
+ *   0xffffc4001,   // moduli
  */
-interface ProtocolParams {
+interface BfvParams {
     /**
      * The degree of the polynomial
      */
@@ -308,36 +282,8 @@ interface ProtocolParams {
      */
     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
-     */
-    BFV_NORMAL: {
-        readonly degree: 2048;
-        readonly plaintextModulus: 1032193n;
-        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";
-    };
-};
+type ThresholdBfvParamsPresetName = 'INSECURE_THRESHOLD_512' | 'SECURE_THRESHOLD_8192';
+declare const ThresholdBfvParamsPresetNames: readonly ["INSECURE_THRESHOLD_512", "SECURE_THRESHOLD_8192"];
 /**
  * The result of encrypting a value and generating a proof
  */
@@ -349,7 +295,7 @@ interface EncryptedValueAndPublicInputs {
     /**
      * The public inputs for the proof
      */
-    publicInputs: CircuitInputs;
+    circuitInputs: CircuitInputs;
 }
 
 declare class EnclaveSDK {
@@ -518,8 +464,7 @@ declare class EnclaveSDK {
     private eventListener;
     private contractClient;
     private initialized;
-    private protocol;
-    private protocolParams?;
+    private thresholdBfvParamsPresetName?;
     private publicClient;
     constructor(config: SDKConfig);
     /**
@@ -531,8 +476,9 @@ declare class EnclaveSDK {
      * @returns The public client
      */
     getPublicClient: () => PublicClient;
-    getBfvParamsSet(name: ProtocolParamsName): Promise<ProtocolParams>;
-    getProtocolParams(): Promise<ProtocolParams>;
+    getThresholdBfvParamsSet(): Promise<BfvParams>;
+    generatePublicKey(): Promise<Uint8Array>;
+    computePublicKeyCommitment(publicKey: Uint8Array): Promise<Uint8Array>;
     /**
      * Encrypt a number using the configured protocol
      * @param data - The number to encrypt
@@ -606,7 +552,7 @@ declare class EnclaveSDK {
     /**
      * Activate an E3 computation
      */
-    activateE3(e3Id: bigint, publicKey: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    activateE3(e3Id: bigint, gasLimit?: bigint): Promise<Hash>;
     /**
      * Publish input for an E3 computation
      */
@@ -671,8 +617,7 @@ declare class EnclaveSDK {
         };
         privateKey?: `0x${string}`;
         chainId: keyof typeof EnclaveSDK.chains;
-        protocol: FheProtocol;
-        protocolParams?: ProtocolParams;
+        thresholdBfvParamsPresetName: ThresholdBfvParamsPresetName;
     }): EnclaveSDK;
 }
 
@@ -743,9 +688,9 @@ declare class ContractClient {
     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)
+     * activate(uint256 e3Id)
      */
-    activateE3(e3Id: bigint, publicKey: `0x${string}`, gasLimit?: bigint): Promise<Hash>;
+    activateE3(e3Id: bigint, gasLimit?: bigint): Promise<Hash>;
     /**
      * Publish input for an E3 computation
      * publishInput(uint256 e3Id, bytes memory data)
@@ -797,12 +742,6 @@ 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];
-    readonly error1_variance: "10";
-};
 interface ComputeProviderParams {
     name: string;
     parallel: boolean;
@@ -820,7 +759,7 @@ 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[], error1_variance?: string): `0x${string}`;
+declare function encodeBfvParams(params: BfvParams): `0x${string}`;
 /**
  * Encode compute provider parameters for the smart contract'
  * If mock is true, the compute provider parameters will return 32 bytes of 0x00
@@ -839,4 +778,4 @@ declare function calculateStartWindow(windowSize?: number): [bigint, bigint];
  */
 declare function decodePlaintextOutput(plaintextOutput: string): number | null;
 
-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 };
+export { type AllEventTypes, type BfvParams, 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, type PlaintextOutputPublishedData, type Polynomial, type RegistryEventData, RegistryEventType, type SDKConfig, SDKError, type SDKEventEmitter, type ThresholdBfvParamsPresetName, ThresholdBfvParamsPresetNames, type VerifiableEncryptionResult, calculateStartWindow, decodePlaintextOutput, encodeBfvParams, encodeComputeProviderParams, encodeCustomParams, formatBigInt, formatEventName, generateEventId, generateProof, getCurrentTimestamp, isValidAddress, isValidHash, parseBigInt, parseEventData, sleep };

package/dist/index.js

@@ -44,14 +44,6 @@ function generateEventId(log) {
 function getCurrentTimestamp() {
   return Math.floor(Date.now() / 1e3);
 }
-var INSECURE_SET_2048_1032193_1 = {
-  degree: 2048,
-  plaintext_modulus: 1032193,
-  moduli: [0x3fffffff000001n],
-  // BigInt for the modulus
-  error1_variance: "10"
-};
-var BFV_PARAMS_SET = INSECURE_SET_2048_1032193_1;
 var DEFAULT_COMPUTE_PROVIDER_PARAMS = {
   name: "risc0",
   parallel: false,
@@ -67,7 +59,14 @@ var DEFAULT_E3_CONFIG = {
   payment_amount: "0"
   // 0 ETH in wei
 };
-function encodeBfvParams(degree = BFV_PARAMS_SET.degree, plaintext_modulus = BFV_PARAMS_SET.plaintext_modulus, moduli = BFV_PARAMS_SET.moduli, error1_variance = BFV_PARAMS_SET.error1_variance) {
+function encodeBfvParams(params) {
+  const { degree, plaintextModulus, moduli, error1Variance } = params;
+  if (error1Variance === void 0) {
+    throw new SDKError(
+      "error1Variance is required in ProtocolParams. All BFV parameter sets must specify error1_variance.",
+      "MISSING_ERROR1_VARIANCE"
+    );
+  }
   return encodeAbiParameters(
     [
       {
@@ -84,9 +83,9 @@ function encodeBfvParams(degree = BFV_PARAMS_SET.degree, plaintext_modulus = BFV
     [
       {
         degree: BigInt(degree),
-        plaintext_modulus: BigInt(plaintext_modulus),
+        plaintext_modulus: BigInt(plaintextModulus),
         moduli: [...moduli],
-        error1_variance
+        error1_variance: error1Variance
       }
     ]
   );
@@ -242,9 +241,9 @@ var ContractClient = class {
   }
   /**
    * Activate an E3 computation
-   * activate(uint256 e3Id, bytes memory publicKey)
+   * activate(uint256 e3Id)
    */
-  async activateE3(e3Id, publicKey, gasLimit) {
+  async activateE3(e3Id, gasLimit) {
     if (!this.walletClient) {
       throw new SDKError("Wallet client required for write operations", "NO_WALLET");
     }
@@ -260,7 +259,7 @@ var ContractClient = class {
         address: this.addresses.enclave,
         abi: Enclave__factory.abi,
         functionName: "activate",
-        args: [e3Id, publicKey],
+        args: [e3Id],
         account,
         gas: gasLimit
       });
@@ -631,110 +630,29 @@ var RegistryEventType = /* @__PURE__ */ ((RegistryEventType2) => {
   RegistryEventType2["INITIALIZED"] = "Initialized";
   return RegistryEventType2;
 })(RegistryEventType || {});
-var FheProtocol = /* @__PURE__ */ ((FheProtocol2) => {
-  FheProtocol2["BFV"] = "BFV";
-  FheProtocol2["TRBFV"] = "TRBFV";
-  return FheProtocol2;
-})(FheProtocol || {});
-var BfvProtocolParams = {
-  /**
-   * Recommended parameters for BFV protocol
-   * - Degree: 2048
-   * - Plaintext modulus: 1032193
-   * - Moduli:0x3FFFFFFF000001
-   */
-  BFV_NORMAL: {
-    degree: 2048,
-    plaintextModulus: 1032193n,
-    moduli: [0x3fffffff000001n],
-    error1Variance: "10"
-  },
-  /**
-   * Recommended parameters for TrBFV protocol
-   * - Degree: 8192
-   * - Plaintext modulus: 1000
-   * - Moduli: [0x00800000022a0001, 0x00800000021a0001, 0x0080000002120001, 0x0080000001f60001]
-   */
-  BFV_THRESHOLD: {
-    degree: 8192,
-    plaintextModulus: 1000n,
-    moduli: [0x00800000022a0001n, 0x00800000021a0001n, 0x0080000002120001n, 0x0080000001f60001n],
-    error1Variance: "10"
-  }
-};
+var ThresholdBfvParamsPresetNames = [
+  "INSECURE_THRESHOLD_512",
+  "SECURE_THRESHOLD_8192"
+];
 
 // src/enclave-sdk.ts
 import {
   bfv_encrypt_number,
   bfv_encrypt_vector,
+  generate_public_key,
   bfv_verifiable_encrypt_number,
   bfv_verifiable_encrypt_vector,
+  compute_pk_commitment,
   get_bfv_params
 } from "@enclave-e3/wasm";
 
 // src/greco.ts
 import { UltraHonkBackend } from "@aztec/bb.js";
 import { Noir } from "@noir-lang/noir_js";
-var defaultParams = {
-  bounds: {
-    pk_bounds: ["34359701504", "34359615488"],
-    e0_bound: "20",
-    e1_bound: "20",
-    u_bound: "1",
-    r1_low_bounds: ["261", "258"],
-    r1_up_bounds: ["260", "258"],
-    r2_bounds: ["34359701504", "34359615488"],
-    p1_bounds: ["256", "256"],
-    p2_bounds: ["34359701504", "34359615488"],
-    k1_low_bound: "5",
-    k1_up_bound: "4"
-  },
-  crypto: {
-    q_mod_t: "3",
-    qis: ["68719403009", "68719230977"],
-    k0is: ["61847462708", "20615769293"]
-  }
-};
-var convertToPolynomial = (stringArray) => {
-  return {
-    coefficients: stringArray
-  };
-};
-var convertToPolynomialArray = (stringArrays) => {
-  return stringArrays.map(convertToPolynomial);
-};
 var generateProof = async (circuitInputs, circuit) => {
   const noir = new Noir(circuit);
   const backend = new UltraHonkBackend(circuit.bytecode, { threads: 4 });
-  const pk0is_poly = convertToPolynomialArray(circuitInputs.pk0is);
-  const pk1is_poly = convertToPolynomialArray(circuitInputs.pk1is);
-  const ct0is_poly = convertToPolynomialArray(circuitInputs.ct0is);
-  const ct1is_poly = convertToPolynomialArray(circuitInputs.ct1is);
-  const u_poly = convertToPolynomial(circuitInputs.u);
-  const e0_poly = convertToPolynomial(circuitInputs.e0);
-  const e1_poly = convertToPolynomial(circuitInputs.e1);
-  const e0is_poly = convertToPolynomialArray(circuitInputs.e0is);
-  const k1_poly = convertToPolynomial(circuitInputs.k1);
-  const r1is_poly = convertToPolynomialArray(circuitInputs.r1is);
-  const r2is_poly = convertToPolynomialArray(circuitInputs.r2is);
-  const p1is_poly = convertToPolynomialArray(circuitInputs.p1is);
-  const p2is_poly = convertToPolynomialArray(circuitInputs.p2is);
-  const { witness } = await noir.execute({
-    params: defaultParams,
-    pk0is: pk0is_poly,
-    pk1is: pk1is_poly,
-    ct0is: ct0is_poly,
-    ct1is: ct1is_poly,
-    u: u_poly,
-    e0: e0_poly,
-    e1: e1_poly,
-    e0is: e0is_poly,
-    k1: k1_poly,
-    r1is: r1is_poly,
-    r2is: r2is_poly,
-    p1is: p1is_poly,
-    p2is: p2is_poly
-  });
+  const { witness } = await noir.execute(circuitInputs);
   return await backend.generateProof(witness, { keccakZK: true });
 };
 
@@ -755,15 +673,18 @@ var EnclaveSDK = class _EnclaveSDK {
     if (!isValidAddress(config.contracts.feeToken)) {
       throw new SDKError("Invalid FeeToken contract address", "INVALID_ADDRESS");
     }
-    this.eventListener = new EventListener(config.publicClient);
-    this.contractClient = new ContractClient(config.publicClient, config.walletClient, config.contracts);
-    if (!Object.values(FheProtocol).includes(config.protocol)) {
-      throw new SDKError(`Invalid protocol: ${config.protocol}`, "INVALID_PROTOCOL");
+    if (!config.thresholdBfvParamsPresetName) {
+      throw new SDKError("Threshold BFV parameters preset name is required", "MISSING_THRESHOLD_BFV_PARAMS_PRESET_NAME");
     }
-    this.protocol = config.protocol;
-    if (config.protocolParams) {
-      this.protocolParams = config.protocolParams;
+    if (!Object.values(ThresholdBfvParamsPresetNames).includes(config.thresholdBfvParamsPresetName)) {
+      throw new SDKError(
+        `Invalid threshold BFV parameters preset name: ${config.thresholdBfvParamsPresetName}`,
+        "INVALID_THRESHOLD_BFV_PARAMS_PRESET_NAME"
+      );
     }
+    this.thresholdBfvParamsPresetName = config.thresholdBfvParamsPresetName;
+    this.eventListener = new EventListener(config.publicClient);
+    this.contractClient = new ContractClient(config.publicClient, config.walletClient, config.contracts);
     this.publicClient = config.publicClient;
   }
   static chains = {
@@ -775,8 +696,7 @@ var EnclaveSDK = class _EnclaveSDK {
   eventListener;
   contractClient;
   initialized = false;
-  protocol;
-  protocolParams;
+  thresholdBfvParamsPresetName;
   publicClient;
   /**
    * Initialize the SDK
@@ -798,9 +718,9 @@ var EnclaveSDK = class _EnclaveSDK {
   getPublicClient = () => {
     return this.publicClient;
   };
-  async getBfvParamsSet(name) {
+  async getThresholdBfvParamsSet() {
     await initializeWasm();
-    let params = get_bfv_params(name);
+    let params = get_bfv_params(this.thresholdBfvParamsPresetName);
     return {
       degree: Number(params.degree),
       // degree is returned as a bigint from wasm
@@ -809,17 +729,20 @@ var EnclaveSDK = class _EnclaveSDK {
       error1Variance: params.error1_variance
     };
   }
-  async getProtocolParams() {
+  async generatePublicKey() {
     await initializeWasm();
-    if (this.protocolParams) {
-      return this.protocolParams;
-    }
-    switch (this.protocol) {
-      case "BFV" /* BFV */:
-        return await this.getBfvParamsSet("INSECURE_SET_2048_1032193_1");
-      case "TRBFV" /* TRBFV */:
-        return await this.getBfvParamsSet("INSECURE_SET_512_10_1");
-    }
+    const protocolParams = await this.getThresholdBfvParamsSet();
+    return generate_public_key(protocolParams.degree, protocolParams.plaintextModulus, BigUint64Array.from(protocolParams.moduli));
+  }
+  async computePublicKeyCommitment(publicKey) {
+    await initializeWasm();
+    const protocolParams = await this.getThresholdBfvParamsSet();
+    return compute_pk_commitment(
+      publicKey,
+      protocolParams.degree,
+      protocolParams.plaintextModulus,
+      BigUint64Array.from(protocolParams.moduli)
+    );
   }
   /**
    * Encrypt a number using the configured protocol
@@ -829,7 +752,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptNumber(data, publicKey) {
     await initializeWasm();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     return bfv_encrypt_number(
       data,
       publicKey,
@@ -846,7 +769,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptVector(data, publicKey) {
     await initializeWasm();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     return bfv_encrypt_vector(
       data,
       publicKey,
@@ -864,7 +787,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptNumberAndGenInputs(data, publicKey) {
     await initializeWasm();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     const [encryptedData, circuitInputs] = bfv_verifiable_encrypt_number(
       data,
       publicKey,
@@ -872,10 +795,9 @@ var EnclaveSDK = class _EnclaveSDK {
       protocolParams.plaintextModulus,
       BigUint64Array.from(protocolParams.moduli)
     );
-    const publicInputs = JSON.parse(circuitInputs);
     return {
       encryptedData,
-      publicInputs
+      circuitInputs: JSON.parse(circuitInputs)
     };
   }
   /**
@@ -886,7 +808,7 @@ var EnclaveSDK = class _EnclaveSDK {
    * @returns The encrypted number and the proof
    */
   async encryptNumberAndGenProof(data, publicKey, circuit) {
-    const { publicInputs, encryptedData } = await this.encryptNumberAndGenInputs(data, publicKey);
+    const { circuitInputs: publicInputs, encryptedData } = await this.encryptNumberAndGenInputs(data, publicKey);
     const proof = await generateProof(publicInputs, circuit);
     return {
       encryptedData,
@@ -901,7 +823,7 @@ var EnclaveSDK = class _EnclaveSDK {
    */
   async encryptVectorAndGenInputs(data, publicKey) {
     await initializeWasm();
-    const protocolParams = await this.getProtocolParams();
+    const protocolParams = await this.getThresholdBfvParamsSet();
     const [encryptedData, circuitInputs] = bfv_verifiable_encrypt_vector(
       data,
       publicKey,
@@ -909,10 +831,9 @@ var EnclaveSDK = class _EnclaveSDK {
       protocolParams.plaintextModulus,
       BigUint64Array.from(protocolParams.moduli)
     );
-    const publicInputs = JSON.parse(circuitInputs);
     return {
       encryptedData,
-      publicInputs
+      circuitInputs: JSON.parse(circuitInputs)
     };
   }
   /**
@@ -923,7 +844,7 @@ var EnclaveSDK = class _EnclaveSDK {
    * @returns The encrypted vector and the proof
    */
   async encryptVectorAndGenProof(data, publicKey, circuit) {
-    const { publicInputs, encryptedData } = await this.encryptVectorAndGenInputs(data, publicKey);
+    const { circuitInputs: publicInputs, encryptedData } = await this.encryptVectorAndGenInputs(data, publicKey);
     const proof = await generateProof(publicInputs, circuit);
     return {
       encryptedData,
@@ -975,11 +896,11 @@ var EnclaveSDK = class _EnclaveSDK {
   /**
    * Activate an E3 computation
    */
-  async activateE3(e3Id, publicKey, gasLimit) {
+  async activateE3(e3Id, gasLimit) {
     if (!this.initialized) {
       await this.initialize();
     }
-    return this.contractClient.activateE3(e3Id, publicKey, gasLimit);
+    return this.contractClient.activateE3(e3Id, gasLimit);
   }
   /**
    * Publish input for an E3 computation
@@ -1127,26 +1048,21 @@ var EnclaveSDK = class _EnclaveSDK {
       walletClient,
       contracts: options.contracts,
       chainId: options.chainId,
-      protocol: options.protocol,
-      protocolParams: options.protocolParams
+      thresholdBfvParamsPresetName: options.thresholdBfvParamsPresetName
     });
   }
 };
 export {
-  BFV_PARAMS_SET,
-  BfvProtocolParams,
   ContractClient,
   DEFAULT_COMPUTE_PROVIDER_PARAMS,
   DEFAULT_E3_CONFIG,
   EnclaveEventType,
   EnclaveSDK,
   EventListener,
-  FheProtocol,
   RegistryEventType,
   SDKError,
+  ThresholdBfvParamsPresetNames,
   calculateStartWindow,
-  convertToPolynomial,
-  convertToPolynomialArray,
   decodePlaintextOutput,
   encodeBfvParams,
   encodeComputeProviderParams,